Référence des API et des SDK MCP
Utilisez ces exemples pour automatiser la configuration de MCP. L’API représente chaque MCP comme une ressource McpService. Pour l’interface utilisateur du Workspace, consultez Serveurs MCP externes. Pour en savoir plus sur les contrôles d’accès et les politiques, consultez la section Gérer un MCP.
Prérequis
- Préparez l’URL de votre serveur MCP et vos détails d’authentification, ou utilisez une connexion HTTP existante.
- Vérifiez les autorisations d'enregistrement ou les autorisations de mise à jour et de suppression pour votre opération.
- Installez et authentifiez le Databricks CLI ou le SDK de votre choix. Les extraits de SDK supposent un client de Workspace authentifié.
Remplacez main.default.my_mcp, le nom de la connexion et data-team par vos propres valeurs. La création de MCP avec des commandes SQL telles que CREATE MCP SERVICE n'est pas prise en charge.
Opérations d’API
L'API REST MCP fournit ces opérations. Suivez chaque Link pour consulter ses champs, ses autorisations et ses réponses.
Opérations | Utilisez-le pour |
|---|---|
Enregistrer un serveur MCP via une connexion HTTP. | |
Trouvez les MCPs auxquels vous avez accès dans un schéma. | |
Lire la configuration d'un MCP et son | |
Modifiez le commentaire, la connexion, la sélection d'outils ou les limites de débit. | |
Supprimez un MCP enregistré. | |
Connectez-vous ou réauthentifiez l'appelant auprès du fournisseur. | |
Lire l'état de connexion du fournisseur de l'appelant. | |
Révoquer le certificat d’identification du fournisseur de l’appelant. |
Pour découvrir et appeler des outils, utilisez un client MCP avec l'URL MCP, https://<workspace-hostname>/ai-gateway/mcp-services/<catalog>.<schema>.<service>. Ces APIs de gestion utilisent le champ d'application OAuth unity-catalog. Les appels d'outils MCP utilisent ai-gateway.
Créer une connexion
Créez une connexion HTTP au niveau du schéma vers votre serveur MCP. Ces exemples se connectent à https://mcp.example.com/mcp à l’aide d’un jeton porteur. Pour OAuth et les autres paramètres d'authentification, consultez la section Paramètres de connexion HTTP.
Pour REST ou la CLI, enregistrez cette requête sous connection.json, en remplaçant l'URL et le jeton par les valeurs de votre serveur. Conservez ce fichier d'identifiants hors du contrôle de code source.
{
"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
Envoyez la requête à l'API Connections:
databricks api post /api/2.1/unity-catalog/connections --json @connection.json
databricks connections create --json @connection.json
Rendez le jeton porteur du serveur disponible dans la variable d’environnement 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"],
},
)
Le nom complet de la connexion est main.default.my_connection. Référencez-le en tant que connections/main.default.my_connection lors de la création du MCP ci-dessous. Si la connexion existe déjà, utilisez son nom et passez cette étape.
Créer un MCP
Le MCP fait référence à une connexion HTTP existante. Pour limiter les outils qu'il expose, configurez la sélection d'outils.
- REST API
- CLI
- Terraform
- Bundles (Beta)
- Python SDK
- Go SDK
- Go Modular SDK
- Java SDK
- JS Modular SDK
Envoyez un POST à /api/2.1/unity-catalog/mcp-services, en transmettant parent et mcp_service_id en tant que query parameters. config.source_connection.name identifie la connexion HTTP Unity Catalog au serveur MCP. Définissez include_tool_selectors pour restreindre les outils, ou omettez-le pour exposer tous les outils. Consultez Choisir les outils disponibles.
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"
}
}
}'
Transmettez le schéma parent et le nom du MCP, et fournissez la configuration avec --json. Définissez include_tool_selectors pour restreindre les outils, ou omettez-le pour exposer tous les outils.
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"
}
}
}'
Créez et gérez un MCP avec le Databricks Terraform provider et la ressource databricks_ai_gateway_mcp_service :
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"
}
}
}
Définissez le MCP dans un bundle et déployez-le avec databricks bundle deploy. Les ressources MCP nécessitent la version 1.17.0 ou supérieure de Databricks CLI et le moteur de déploiement direct.
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
Créez et gérez un MCP avec le SDK Databricks pour 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"
),
),
),
)
Créer et gérer un MCP avec le Databricks SDK for 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",
},
},
},
})
Créer et gérer un service MCP avec le SDK Databricks AI Gateway pour Go. Les champs optionnels sont des pointeurs, l'exemple utilise donc un assistant d'une ligne, 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"),
},
},
},
},
})
Créez et gérez un MCP avec le Databricks SDK for 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")))));
Créez et gérez un MCP avec le SDK JavaScript:
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' },
},
},
},
});
Rechercher un MCP
Répertoriez les MCP accessibles dans un schéma, puis obtenez la configuration d'un MCP par son nom de ressource. Pour les MCP intégrés, utilisez schemas/system.ai comme parent.
- 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"
Lorsque la réponse de la liste inclut next_page_token, transmettez-la en tant que page_token dans la requête suivante. Continuer jusqu’à ce que next_page_token soit absent ou vide.
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")
Par default, les réponses de la liste utilisent la vue BASIC, ce qui omet les détails de la connexion source et les noms des principaux de limite de débit. Utilisez FULL pour inclure ces champs. Le CLI et l’itérateur Python gèrent la pagination pour vous.
Accorder l’accès
Ces exemples accordent EXECUTE sur le MCP. Pour connaître l'ensemble des conditions d'accès, y compris les autorisations parentes, consultez Partager un 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"] }
]
}'
Accordez EXECUTE à l’aide de la CLI Databricks :
databricks grants update mcp_service main.default.my_mcp \
--json '{"changes": [{"principal": "data-team", "add": ["EXECUTE"]}]}'
Accorder EXECUTE avec le fournisseur Databricks Terraform et la ressource databricks_grant :
resource "databricks_grant" "example" {
mcp_service = "main.default.my_mcp"
principal = "data-team"
privileges = ["EXECUTE"]
}
Ajoutez un bloc grants à la ressource MCP de votre bundle et redéployez pour octroyer l’accès.
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]
Accorder EXECUTE avec le SDK Databricks pour 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])],
)
Accorder EXECUTE à l'aide du Databricks SDK pour 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},
}},
})
Accordez EXECUTE avec le Databricks SDK for 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)))));
Gérer la connexion du fournisseur
Pour les MCP qui utilisent OAuth par utilisateur, chaque appelant se connecte auprès du fournisseur externe. Pour une connexion interactive, suivez la configuration des services externes.
Les APIs d'identifiants sont en version bêta. Pour les intégrer à votre propre flux OAuth :
- Créez les identifiants de l'appelant avec les champs d'échange OAuth :
authorization_code,pkce_verifieretoauth_redirect_uri. - Vérifiez l’état des identifiants.
provisioning_info.statedoit êtreACTIVEpour que l’identifiant puisse être utilisé.NOT_FOUNDsignifie que l’appelant ne dispose d’aucun identifiant pour le moment. - Pour vous déconnecter, supprimez l’identifiant de l’appelant.
Ces opérations gèrent les informations d’identification de l’utilisateur à l’origine de l’appel. L’appelant a besoin d’un accès au MCP.
Update an MCP
Ces exemples mettent à jour le commentaire MCP. Le nom du MCP ne peut pas être modifié.
Définissez update_mask sur les champs que vous souhaitez modifier, tels que comment, config.source_connection.name, config.include_tool_selectors ou config.rate_limits. L'utilisation de config remplace l'ensemble de la configuration et efface les champs optionnels omis. Lors de la modification de la connexion, le propriétaire MCP a également besoin de USE CONNECTION sur la nouvelle connexion.
Pour une mise à jour conditionnelle, récupérez d'abord le MCP et transmettez son etag avec la mise à jour. La mise à jour ne réussit que si le MCP n’a pas changé depuis cette lecture. Encodez l'URL pour le etag lors de son ajout à une 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"}'
Modifiez comment (ou tout autre champ modifiable) sur la ressource databricks_ai_gateway_mcp_service et réappliquez. Les modifications s'appliquent sur place.
Modifiez comment (ou tout autre champ mutable) dans la ressource du bundle et exécutez databricks bundle deploy. Les modifications s’appliquent sur place.
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'),
});
Exemple : mettre à jour la sélection d'outils
Pour n'exposer que les outils dont les noms start par 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_*"]
}
}'
Une liste include_tool_selectors vide expose tous les outils. Consultez la section Choose available tools pour connaître les étapes de l'interface utilisateur.
Supprimer un MCP
Ne supprimez que le MCP que vous avez l’intention de retirer. Les clients configurés avec son URL ne peuvent plus l’appeler.
Vous pouvez également transmettre le etag actuel du protocole MCP pour que la suppression dépende de sa non-modification depuis la dernière lecture. Encoder au format URL le paramètre etag dans les query strings REST.
- 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
Supprimez la ressource MCP de votre configuration et exécutez terraform apply. Examinez le plan avant de l’appliquer.
Supprimez la ressource MCP du bundle et exécutez databricks bundle deploy. Examinez les modifications de déploiement avant de les appliquer.
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' });