Connecter des agents à des services externes

Connectez vos agents IA à des applications externes telles que Slack, Google Calendar ou n’importe quel service avec une API. Azure Databricks fournit plusieurs approches selon que le service externe dispose d’un serveur MCP, que vous ayez besoin d’une authentification par utilisateur ou que vous préfériez appeler des API directement à partir du code de l’agent. Toutes les approches s’appuient sur une connexion HTTP du catalogue Unity pour gérer en toute sécurité les informations d’identification et régir l’accès aux services externes.

Requirements

• Une connexion HTTP de catalogue Unity pour votre application externe. Les connexions de catalogue Unity fournissent une gestion des informations d’identification sécurisée, régie et activent plusieurs méthodes d’authentification, notamment l’authentification utilisateur à machine OAuth 2.0 et l’authentification machine à machine.

Serveurs MCP externes

Si le service externe dispose d’un serveur MCP disponible, Azure Databricks recommande de se connecter via serveurs MCP externes. Les serveurs MCP fournissent la découverte automatique des outils, l’intégration simplifiée et l’authentification par utilisateur. Consultez Utiliser des serveurs MCP externes pour connaître les méthodes d’installation, l’utilisation programmatique et les détails de l’authentification.

Ajouter un serveur MCP externe à votre agent

Une fois que vous avez inscrit le serveur MCP externe en tant que connexion de catalogue Unity, connectez votre agent à celui-ci à l’aide de l’URL MCP gérée : https://<workspace-hostname>/api/2.0/mcp/external/{connection_name}. Remplacez <connection-name> par le nom de votre connexion de catalogue Unity.

SDK des Agents OpenAI (Applications)

from agents import Agent, Runner
from databricks.sdk import WorkspaceClient
from databricks_openai.agents import McpServer

workspace_client = WorkspaceClient()
host = workspace_client.config.host

async with McpServer(
    url=f"{host}/api/2.0/mcp/external/<connection-name>",
    name="external-service",
    workspace_client=workspace_client,
) as external_server:
    agent = Agent(
        name="Connected agent",
        instructions="You are a helpful assistant with access to external services.",
        model="databricks-claude-sonnet-4-5",
        mcp_servers=[external_server],
    )
    result = await Runner.run(agent, "Send a Slack message to the team about the deployment")
    print(result.final_output)

Accordez à l’application l’accès à la connexion du catalogue Unity dans databricks.yml:

resources:
  apps:
    my_agent_app:
      resources:
        - name: 'my_connection'
          uc_securable:
            securable_full_name: '<connection-name>'
            securable_type: 'CONNECTION'
            permission: 'USE_CONNECTION'

LangGraph (Applications)

from databricks.sdk import WorkspaceClient
from databricks_langchain import ChatDatabricks, DatabricksMCPServer, DatabricksMultiServerMCPClient
from langgraph.prebuilt import create_react_agent

workspace_client = WorkspaceClient()
host = workspace_client.config.host

mcp_client = DatabricksMultiServerMCPClient([
    DatabricksMCPServer(
        name="external-service",
        url=f"{host}/api/2.0/mcp/external/<connection-name>",
        workspace_client=workspace_client,
    ),
])

async with mcp_client:
    tools = await mcp_client.get_tools()
    agent = create_react_agent(
        ChatDatabricks(endpoint="databricks-claude-sonnet-4-5"),
        tools=tools,
    )
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": "Send a Slack message to the team about the deployment"}]}
    )
    print(result["messages"][-1].content)

Accordez à l’application l’accès à la connexion du catalogue Unity dans databricks.yml:

resources:
  apps:
    my_agent_app:
      resources:
        - name: 'my_connection'
          uc_securable:
            securable_full_name: '<connection-name>'
            securable_type: 'CONNECTION'
            permission: 'USE_CONNECTION'

Utilisation de modèles

from databricks.sdk import WorkspaceClient
from databricks_mcp import DatabricksMCPClient
import mlflow

workspace_client = WorkspaceClient()
host = workspace_client.config.host

mcp_client = DatabricksMCPClient(
    server_url=f"{host}/api/2.0/mcp/external/<connection-name>",
    workspace_client=workspace_client,
)

tools = mcp_client.list_tools()

mlflow.pyfunc.log_model(
    "agent",
    python_model=my_agent,
    resources=mcp_client.get_databricks_resources(),
)

Pour déployer l’agent, consultez Déployer un agent pour les applications IA génératives (Model Serving). Pour plus d’informations sur la journalisation des agents avec des ressources MCP, consultez Utiliser des serveurs MCP gérés par Databricks.

OAuth managé

Azure Databricks propose des flux OAuth managés pour sélectionner des fournisseurs d’outils d’API. Vous n’avez pas besoin d’inscrire votre propre application OAuth ou de gérer les informations d’identification. Azure Databricks recommande l’authentification OAuth managée pour le développement et le test. Si les cas d’usage de production nécessitent la génération d’informations d’identification OAuth personnalisées, consultez la documentation des fournisseurs pour plus d’informations.

Les intégrations suivantes utilisent des informations d’identification OAuth gérées par Azure Databricks stockées en toute sécurité dans le serveur principal.

Pour configurer OAuth managé, créez une connexion HTTP avec le type d’authentification de l’utilisateur OAuth à machine par utilisateur et sélectionnez votre fournisseur dans le menu déroulant Fournisseur OAuth . Pour obtenir des instructions détaillées, consultez Installer un serveur MCP externe.

Chaque utilisateur est invité à autoriser auprès du fournisseur lors de la première utilisation.

Si nécessaire, autorisez les URI de redirection suivants utilisés par OAuth géré :

Point de terminaison proxy des connexions UC

Utilisez le point de terminaison proxy des connexions du catalogue Unity avec le SDK client propre au service externe pour effectuer des appels aux API REST directement depuis le code de l'agent. Pointez l'URL de base du Kit de développement logiciel (SDK) vers le point de terminaison proxy et utilisez votre jeton Azure Databricks comme clé API. Azure Databricks authentifie la requête et injecte automatiquement les informations d'identification du service externe à partir de la connexion du catalogue Unity. Votre code ne gère jamais directement les jetons du service externe.

Autorisations requises :USE CONNECTION sur l’objet de connexion.

OpenAI

Utilisez DatabricksOpenAI pour router les appels vers OpenAI externe à travers le proxy de connexions du catalogue Unity. Tout d’abord, créez une connexion HTTP du catalogue Unity à l’aide de votre clé API OpenAI stockée en tant que secret Databricks :

CREATE CONNECTION openai_connection TYPE HTTP
OPTIONS (
  host 'https://api.openai.com',
  base_path '/v1',
  bearer_token secret ('<secret-scope>', '<secret-key>')
);

Installez ensuite le databricks-openai package et utilisez l’URL du proxy et le client d’espace de travail dans votre code d’agent :

pip install databricks-openai

from databricks_openai import DatabricksOpenAI
from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

client = DatabricksOpenAI(
    workspace_client=w,
    base_url=f"{w.config.host}/api/2.0/unity-catalog/connections/openai_connection/proxy/",
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(response.choices[0].message.content)

Slack

Configurez le SDK Slack pour router via le proxy de connexions du Unity Catalog. Créez une connexion HTTP du catalogue Unity avec l’hôte https://slack.com et le chemin d’accès /apide base, puis utilisez l’URL du proxy comme URL de base du KIT de développement logiciel (SDK) :

from slack_sdk import WebClient
from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

client = WebClient(
    token=w.config.authenticate()["Authorization"].split(" ")[1],
    base_url=f"{w.config.host}/api/2.0/unity-catalog/connections/slack_connection/proxy/",
)

result = client.chat_postMessage(channel="C123456", text="Hello from Databricks!")
print(result["message"]["text"])

HTTP générique

Pour les services sans Kit de Développement Logiciel (SDK) dédié, utilisez directement la bibliothèque avec l'URL du proxy requests :

import requests
from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

response = requests.post(
    f"{w.config.host}/api/2.0/unity-catalog/connections/my_connection/proxy/api/v1/resource",
    headers={
        **w.config.authenticate(),
        "Content-Type": "application/json",
    },
    json={"key": "value"},
)

Outils de fonction UC avec connexions HTTP

Vous pouvez créer une fonction Unity Catalog qui encapsule http_request() pour appeler des services externes. Cette approche est utile pour les définitions d’outils sql. Pour plus d’informations sur la création d’outils de fonction UC, consultez Créer des outils d’agent IA à l’aide des fonctions catalogue Unity .

L’exemple suivant crée un outil fonction de Unity Catalog qui publie un message sur Slack :

CREATE OR REPLACE FUNCTION main.default.slack_post_message(
  text STRING COMMENT 'message content'
)
RETURNS STRING
COMMENT 'Sends a Slack message by passing in the message and returns the response received from the external service.'
RETURN (http_request(
  conn => 'test_sql_slack',
  method => 'POST',
  path => '/api/chat.postMessage',
  json => to_json(named_struct(
    'channel', "C032G2DAH3",
    'text', text
  ))
)).text

Consultez CREATE FUNCTION (SQL et Python).

Exemples de notebooks

Connecter un agent à Slack

Consultez Connecter un agent IA à Slack.

Connecter un agent à Microsoft Teams

Consultez Connecter un agent IA à Microsoft Teams.

Outils de connexion externe

Les notebooks suivants démontrent comment créer des outils agents IA qui se connectent à Slack, OpenAI et Azure AI Search.

Outil d’agent de messagerie Slack

Obtenir un ordinateur portable

Outil d'agent de l’API Microsoft Graph

Obtenir un ordinateur portable

outil de l’agent Recherche Azure AI

Obtenir un ordinateur portable