Referência de API e SDK de MCP
Use estes exemplos para automatizar a configuração do MCP. A API representa cada MCP como um recurso McpService. Para a interface do Workspace, consulte Servidores MCP externos. Para controles de acesso e políticas, consulte Fazer a governança de um MCP.
Pré-requisitos
- Tenha a URL do seu servidor MCP e os detalhes de autenticação prontos ou use uma conexão HTTP existente.
- Verifique as permissões de registro ou as permissões de atualização e exclusão para sua operação.
- Instale e autentique a CLI do Databricks ou o SDK de sua escolha. Os trechos de código do SDK pressupõem um cliente de workspace autenticado.
Substitua main.default.my_mcp, o nome da conexão e data-team pelos seus próprios valores. Não há suporte para a criação de MCPs com comandos SQL como CREATE MCP SERVICE.
Operações da API
A API REST do MCP fornece estas operações. Siga cada link para ver seus campos, permissões e respostas.
Operação | Use-o para |
|---|---|
Registro um servidor MCP por meio de uma conexão HTTP. | |
Encontre MCPs que você pode acessar em um esquema. | |
Ler a configuração de um MCP e o | |
Altere o comentário, a conexão, a seleção de ferramentas ou os limites de taxa. | |
Remova um MCP registrado. | |
Faça login ou autentique novamente o chamador com o provedor. | |
Leia o estado de login do provedor do chamador. | |
Revogue a credencial de provedor do chamador. |
Para descobrir e chamar ferramentas, use um cliente MCP com a URL do MCP, https://<workspace-hostname>/ai-gateway/mcp-services/<catalog>.<schema>.<service>. Essas APIs de gerenciamento usam o escopo OAuth unity-catalog. As chamadas de ferramenta do MCP usam ai-gateway.
Criar uma conexão
Create a schema-level HTTP connection to your MCP server. These examples connect to https://mcp.example.com/mcp with a bearer token. For OAuth and other authentication settings, see HTTP connection settings.
Para REST ou CLI, salve esta solicitação como connection.json, substituindo a URL e o token pelos valores do seu servidor. Mantenha este arquivo de credenciais fora do controle de versão.
{
"name": "my_connection",
"parent": "schemas/main.default",
"connection_type": "HTTP",
"options": {
"host": "https://mcp.example.com",
"port": "443",
"base_path": "/mcp",
"bearer_token": "<mcp-server-token>"
}
}
- REST API
- CLI
- Python SDK
Envie a solicitação para a API de conexões:
databricks api post /api/2.1/unity-catalog/connections --json @connection.json
databricks connections create --json @connection.json
Torne o token do portador do servidor disponível na variável de ambiente MCP_SERVER_TOKEN.
import os
from databricks.sdk import WorkspaceClient
from databricks.sdk.service import catalog as c
w = WorkspaceClient()
connection = w.connections.create(
name="my_connection",
parent="schemas/main.default",
connection_type=c.ConnectionType.HTTP,
options={
"host": "https://mcp.example.com",
"port": "443",
"base_path": "/mcp",
"bearer_token": os.environ["MCP_SERVER_TOKEN"],
},
)
The connection's full name is main.default.my_connection. Reference it as connections/main.default.my_connection when creating the MCP abaixo. If the connection already exists, use its name and skip this o passo.
Criar um MCP
O MCP faz referência a uma conexão HTTP existente. Para limitar as ferramentas que ele expõe, configure a seleção de ferramentas.
- REST API
- CLI
- Terraform
- Bundles (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
Envie um POST para /api/2.1/unity-catalog/mcp-services, passando parent e mcp_service_id como parâmetros de query. config.source_connection.name identifica a conexão HTTP do Unity Catalog com o servidor MCP. Defina include_tool_selectors para restringir as ferramentas ou omita-o para expor todas as ferramentas. Consulte Escolher ferramentas disponíveis.
databricks api post \
"/api/2.1/unity-catalog/mcp-services?parent=schemas/main.default&mcp_service_id=my_mcp" \
--json '{
"comment": "External MCP server",
"config": {
"source_connection": {
"name": "connections/main.default.my_connection"
}
}
}'
Passe o esquema pai e o nome do MCP e forneça a configuração com --json. Defina include_tool_selectors para restringir as ferramentas ou omita-o para expor todas as ferramentas.
databricks ai-gateway create-mcp-service schemas/main.default my_mcp --json '{
"comment": "External MCP server",
"config": {
"source_connection": {
"name": "connections/main.default.my_connection"
}
}
}'
Criar e gerenciar um MCP com o provedor Databricks Terraform e o databricks_ai_gateway_mcp_service recurso:
resource "databricks_ai_gateway_mcp_service" "example" {
parent = "schemas/main.default"
mcp_service_id = "my_mcp"
comment = "External MCP server"
config = {
source_connection = {
name = "connections/main.default.my_connection"
}
}
}
Defina o MCP em um pacote e implante-o com databricks bundle deploy. Recursos do MCP exigem o Databricks CLI versão 1.17.0 e acima e o mecanismo de implantação direta.
resources:
mcp_services:
my_mcp:
parent: schemas/main.default
mcp_service_id: my_mcp
comment: External MCP server
config:
source_connection:
name: connections/main.default.my_connection
Crie e gerencie um MCP com o SDK do Databricks para Python:
from databricks.sdk import WorkspaceClient
from databricks.sdk.service import catalog as c
w = WorkspaceClient()
mcp_service = w.ai_gateway.create_mcp_service(
parent="schemas/main.default",
mcp_service_id="my_mcp",
mcp_service=c.McpService(
comment="External MCP server",
config=c.McpServiceConfig(
source_connection=c.McpServiceConfigSourceConnection(
name="connections/main.default.my_connection"
),
),
),
)
Criar e gerenciar um MCP com o SDK do Databricks para Go:
mcpService, err := w.AiGateway.CreateMcpService(ctx, catalog.CreateMcpServiceRequest{
Parent: "schemas/main.default",
McpServiceId: "my_mcp",
McpService: catalog.McpService{
Comment: "External MCP server",
Config: &catalog.McpServiceConfig{
SourceConnection: &catalog.McpServiceConfigSourceConnection{
Name: "connections/main.default.my_connection",
},
},
},
})
Crie e gerencie um serviço MCP com o SDK do Databricks AI Gateway para Go. Os campos opcionais são ponteiros; portanto, o exemplo usa um auxiliar de uma linha, func ptr[T any](v T) *T { return &v }.
mcpService, err := c.CreateMcpService(ctx, aigateway.CreateMcpServiceRequest{
Parent: ptr("schemas/main.default"),
McpServiceId: ptr("my_mcp"),
McpService: &aigateway.McpService{
Comment: ptr("External MCP server"),
Config: &aigateway.McpServiceConfig{
Source: &aigateway.McpServiceConfig_Source_SourceConnection{
SourceConnection: aigateway.McpServiceConfig_SourceConnection{
Name: ptr("connections/main.default.my_connection"),
},
},
},
},
})
Criar e gerenciar um MCP com o SDK do Databricks para Java:
McpService mcpService =
w.aiGateway()
.createMcpService(
new CreateMcpServiceRequest()
.setParent("schemas/main.default")
.setMcpServiceId("my_mcp")
.setMcpService(
new McpService()
.setComment("External MCP server")
.setConfig(
new McpServiceConfig()
.setSourceConnection(
new McpServiceConfigSourceConnection()
.setName("connections/main.default.my_connection")))));
Crie e gerencie um MCP com o JavaScript SDK:
const created = await client.createMcpService({
parent: 'schemas/main.default',
mcpServiceId: 'my_mcp',
mcpService: {
comment: 'External MCP server',
config: {
source: {
$case: 'sourceConnection',
sourceConnection: { name: 'connections/main.default.my_connection' },
},
},
},
});
Encontre um MCP
Liste os MCPs aos quais você pode acessar em um esquema e, em seguida, obtenha a configuração de um MCP pelo nome do seu recurso. Para MCPs integrados, use schemas/system.ai como pai.
- REST API
- CLI
- Python SDK
databricks api get \
"/api/2.1/unity-catalog/mcp-services?parent=schemas/main.default&view=FULL"
databricks api get "/api/2.1/unity-catalog/mcp-services/main.default.my_mcp"
Quando a resposta da lista incluir next_page_token, repasse-a como page_token na próxima solicitação. Continue até que next_page_token esteja ausente ou vazio.
databricks ai-gateway list-mcp-services --parent schemas/main.default --view FULL
databricks ai-gateway get-mcp-service mcp-services/main.default.my_mcp
from databricks.sdk import WorkspaceClient
from databricks.sdk.service import catalog as c
w = WorkspaceClient()
for service in w.ai_gateway.list_mcp_services(
parent="schemas/main.default",
view=c.ListMcpServicesRequestView.FULL,
):
print(service.name)
service = w.ai_gateway.get_mcp_service(name="mcp-services/main.default.my_mcp")
As respostas de listagem usam a view BASIC por default, o que omite detalhes de conexão de origem e nomes principais de limite de taxa. Use FULL para incluir esses campos. A CLI e o iterador Python lidam com a paginação para você.
Conceder acesso
Estes exemplos concedem EXECUTE no MCP. Para ver os requisitos completos de acesso, incluindo as permissões pai, consulte Compartilhar um MCP.
- REST API
- CLI
- Terraform
- Bundles (Beta)
- Python SDK
- Go SDK
- Java SDK
databricks api patch \
"/api/2.1/unity-catalog/permissions/mcp_service/main.default.my_mcp" \
--json '{
"changes": [
{ "principal": "data-team", "add": ["EXECUTE"] }
]
}'
Conceda EXECUTE com a CLI do Databricks:
databricks grants update mcp_service main.default.my_mcp \
--json '{"changes": [{"principal": "data-team", "add": ["EXECUTE"]}]}'
Grant EXECUTE with the Databricks Terraform provider and the databricks_grant recurso:
resource "databricks_grant" "example" {
mcp_service = "main.default.my_mcp"
principal = "data-team"
privileges = ["EXECUTE"]
}
Add a grants block to the MCP recurso in your bundle and redeploy to grant access.
resources:
mcp_services:
my_mcp:
parent: schemas/main.default
mcp_service_id: my_mcp
comment: External MCP server
config:
source_connection:
name: connections/main.default.my_connection
grants:
- principal: data-team
privileges: [EXECUTE]
Conceda EXECUTE com o SDK do Databricks para Python:
from databricks.sdk.service import catalog as c
w.grants.update(
securable_type="mcp_service",
full_name="main.default.my_mcp",
changes=[c.PermissionsChange(principal="data-team", add=[c.Privilege.EXECUTE])],
)
Grant EXECUTE with the Databricks SDK for Go:
_, err := w.Grants.Update(ctx, catalog.UpdatePermissions{
SecurableType: "mcp_service",
FullName: "main.default.my_mcp",
Changes: []catalog.PermissionsChange{{
Principal: "data-team",
Add: []catalog.Privilege{catalog.PrivilegeExecute},
}},
})
Conceda EXECUTE com o SDK do Databricks para Java:
w.grants().update(
new UpdatePermissions()
.setSecurableType("mcp_service")
.setFullName("main.default.my_mcp")
.setChanges(Arrays.asList(
new PermissionsChange().setPrincipal("data-team").setAdd(Arrays.asList(Privilege.EXECUTE)))));
Gerenciar início de sessão do provedor
Para MCPs que usam OAuth por usuário, cada chamador faz login no provedor externo e autoriza sua account de provedor. O chamador precisa de permissão para chamar o MCP.
Entrar no Unity Gateway
Esta opção requer o direito de acesso ao Workspace.
- Abra o Unity Gateway no seu workspace e selecione MCPs .
- Clique no MCP e, em seguida, clique em Login e autorize o acesso à sua account de provedor.
- Tente novamente a chamada da ferramenta após entrar.
Usar a página de login
A página de login funciona para usuários com acesso ao Workspace , acesso de consumidor ou acesso ao Databricks SQL . Usuários com apenas acesso de consumidor ou acesso ao Databricks SQL podem usá-lo sem abrir a UI do Unity Gateway. Chamadas de ferramenta que requerem login de provedor retornam um link para esta página. Você também pode abri-lo antes da sua primeira chamada ou para entrar novamente:
-
Abra a página de login do MCP:
Texthttps://<workspace-hostname>/mcp-service-login?name=<catalog>.<schema>.<service>Substitua
<workspace-hostname>pelo seu hostname do workspace e<catalog>.<schema>.<service>pelo nome completo do MCP, comosystem.ai.github. -
Clique em Sign in (Entrar) ou Login (Acessar) e autorize o acesso à sua account de provedor.
-
Quando a página mostrar Você está conectado , feche-a e tente novamente a chamada.
Para permitir que usuários apenas com acesso de consumidor façam login em um MCP registrado, conceda ao grupo account users permissão para chamar o MCP. Para remover as credenciais do seu provedor, abra a página de login e clique em Sair . Nenhum login é necessário significa que o MCP não usa OAuth por usuário.
A página usa a sessão de navegador do Databricks do usuário e solicita que ele faça login no workspace, se necessário. Se seu aplicativo chama MCPs em nome de um usuário, o usuário conectado nesta página deve corresponder ao usuário representado pelo token do aplicativo. Para obter o código de integração, use os exemplos de pop-up e status de login.
Gerenciar credenciais com a API
As APIs de credenciais estão em Beta. Para integrá-los ao seu próprio fluxo OAuth:
- Crie a credencial do chamador com os campos de troca de OAuth:
authorization_code,pkce_verifiereoauth_redirect_uri. - Verifique o status das credenciais.
provisioning_info.statedeve serACTIVEantes que a credencial possa ser usada.NOT_FOUNDsignifica que o chamador ainda não tem credencial. - Para sair, exclua a credencial do chamador.
Estas operações gerenciam a credencial do usuário chamador. O chamador precisa de acesso ao MCP.
Para usar a página de login do Databricks em vez do seu próprio fluxo OAuth, consulte Conectar seu aplicativo às ferramentas MCP.
Atualizar um MCP
Estes exemplos atualizam o comentário do MCP. O nome do MCP não pode ser alterado.
Defina update_mask para os campos que você deseja alterar, como comment, config.source_connection.name, config.include_tool_selectors ou config.rate_limits. O uso de config substitui toda a configuração e limpa os campos opcionais omitidos. Ao alterar a conexão, o proprietário do MCP também precisa de USE CONNECTION na nova conexão.
Para uma atualização condicional, primeiro obtenha o MCP e passe seu etag com a atualização. A atualização só será bem-sucedida se o MCP não tiver sido alterado desde essa leitura. Codifique em URL o etag ao adicioná-lo a uma query string REST.
- REST API
- CLI
- Terraform
- Bundles (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
databricks api patch \
"/api/2.1/unity-catalog/mcp-services/main.default.my_mcp?update_mask=comment" \
--json '{"comment": "Updated: governs an MCP server"}'
databricks ai-gateway update-mcp-service mcp-services/main.default.my_mcp comment \
--json '{"comment": "Updated: governs an MCP server"}'
Edite comment (ou qualquer outro campo mutável) no recurso databricks_ai_gateway_mcp_service e aplique novamente. As alterações se aplicam no local.
Edite comment (ou qualquer outro campo mutável) no recurso do bundle e execute a execução de databricks bundle deploy. As alterações são aplicadas diretamente.
from databricks.sdk.service import catalog as c
from databricks.sdk.common.types.fieldmask import FieldMask
updated = w.ai_gateway.update_mcp_service(
name="mcp-services/main.default.my_mcp",
update_mask=FieldMask(["comment"]),
mcp_service=c.McpService(comment="Updated: governs an MCP server"),
)
updated, err := w.AiGateway.UpdateMcpService(ctx, catalog.UpdateMcpServiceRequest{
Name: "mcp-services/main.default.my_mcp",
UpdateMask: *fieldmask.New([]string{"comment"}),
McpService: catalog.McpService{Comment: "Updated: governs an MCP server"},
})
mask, err := types.NewFieldMask[aigateway.McpService]("comment")
updated, err := c.UpdateMcpService(ctx, aigateway.UpdateMcpServiceRequest{
McpService: &aigateway.McpService{
Name: ptr("mcp-services/main.default.my_mcp"),
Comment: ptr("Updated: governs an MCP server"),
},
UpdateMask: mask,
})
McpService updated =
w.aiGateway()
.updateMcpService(
new UpdateMcpServiceRequest()
.setName("mcp-services/main.default.my_mcp")
.setUpdateMask(FieldMask.newBuilder().addPaths("comment").build())
.setMcpService(new McpService().setComment("Updated: governs an MCP server")));
import { mcpServiceFieldMask } from '@databricks/sdk-aigateway/v1';
const updated = await client.updateMcpService({
mcpService: {
name: 'mcp-services/main.default.my_mcp',
comment: 'Updated: governs an MCP server',
},
updateMask: mcpServiceFieldMask('comment'),
});
Exemplo: atualizar seleção de ferramenta
Para expor apenas ferramentas cujos nomes comecem com get_:
databricks api patch \
"/api/2.1/unity-catalog/mcp-services/main.default.my_mcp?update_mask=config.include_tool_selectors" \
--json '{
"config": {
"include_tool_selectors": ["get_*"]
}
}'
Uma lista include_tool_selectors vazia expõe todas as ferramentas. Consulte Escolher ferramentas disponíveis para ver os passos da interface do usuário.
Excluir um MCP
Exclua apenas o MCP que você pretende remover. Os clientes configurados com sua URL não podem mais chamá-lo.
Você também pode passar o etag atual do MCP para tornar a exclusão condicional para que ele não tenha sido alterado desde a última leitura. Codifique o URL para etag em REST query strings.
- REST API
- CLI
- Terraform
- Bundles (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
databricks api delete "/api/2.1/unity-catalog/mcp-services/main.default.my_mcp"
databricks ai-gateway delete-mcp-service mcp-services/main.default.my_mcp
Remova o recurso MCP da sua configuração e realize a execução terraform apply. Revise o plano antes de aplicá-lo.
Remova o recurso de MCP do pacote e execução databricks bundle deploy. Revise as alterações de implantação antes de aplicá-las.
w.ai_gateway.delete_mcp_service(name="mcp-services/main.default.my_mcp")
err := w.AiGateway.DeleteMcpService(ctx, catalog.DeleteMcpServiceRequest{
Name: "mcp-services/main.default.my_mcp",
})
err := c.DeleteMcpService(ctx, aigateway.DeleteMcpServiceRequest{
Name: ptr("mcp-services/main.default.my_mcp"),
})
w.aiGateway().deleteMcpService(new DeleteMcpServiceRequest().setName("mcp-services/main.default.my_mcp"));
await client.deleteMcpService({ name: 'mcp-services/main.default.my_mcp' });