Agents verbinden met externe services

Verbind uw AI-agents met externe toepassingen, zoals Slack, Google Calendar of een service met een API. Azure Databricks biedt verschillende benaderingen, afhankelijk van of de externe service een MCP-server heeft, of u verificatie per gebruiker nodig hebt of of u liever API's rechtstreeks vanuit agentcode aanroept. Alle benaderingen zijn afhankelijk van een UNITY Catalog HTTP-verbinding om referenties veilig te beheren en toegang tot externe services te beheren.

Requirements

• Een Unity Catalog HTTP-verbinding voor uw externe toepassing. Unity Catalog-verbindingen bieden veilig, beheerd referentiebeheer en maken meerdere verificatiemethoden mogelijk, waaronder OAuth 2.0-gebruikers-naar-machine- en machine-naar-machine-verificatie.

Externe MCP-servers

Als er een MCP-server beschikbaar is voor de externe service, raadt Azure Databricks u aan verbinding te maken via external MCP-servers. MCP-servers bieden automatische detectie van hulpprogramma's, vereenvoudigde integratie en verificatie per gebruiker. Zie Externe MCP-servers gebruiken voor installatiemethoden, programmatisch gebruik en verificatiedetails.

Een externe MCP-server toevoegen aan uw agent

Nadat u de externe MCP-server hebt geregistreerd als een Unity Catalog-verbinding, verbindt u uw agent met behulp van de beheerde MCP-URL: https://<workspace-hostname>/api/2.0/mcp/external/{connection_name}. Vervang <connection-name> door de naam van uw Unity Catalog-verbinding.

OpenAI Agents SDK (Apps)

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)

Ververleent de app toegang tot de Unity Catalog-verbinding in 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 (Apps)

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)

Ververleent de app toegang tot de Unity Catalog-verbinding in databricks.yml:

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

Model serveren

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(),
)

Zie Een agent implementeren voor generatieve AI-toepassingen (Model Serving) om de agent te implementeren. Zie Databricks managed MCP-servers gebruiken voor meer informatie over het registreren van agents met MCP-resources.

Beheerde OAuth

Azure Databricks biedt beheerde OAuth-stromen voor geselecteerde API-hulpprogrammaproviders. U hoeft uw eigen OAuth-app niet te registreren of referenties te beheren. Azure Databricks raadt Managed OAuth aan voor ontwikkeling en testen. Als voor productiegebruiksscenario's aangepaste OAuth-referenties moeten worden gegenereerd, raadpleegt u de documentatie van de providers voor meer informatie.

De volgende integraties gebruiken Azure Databricks beheerde OAuth-referenties die veilig zijn opgeslagen in de back-end.

Als u beheerde OAuth wilt instellen, maakt u een HTTP-verbinding met het verificatietype OAuth-gebruiker naar machine per gebruiker en selecteert u uw provider in de vervolgkeuzelijst OAuth-provider . Zie Een externe MCP-server installeren voor gedetailleerde stappen.

Elke gebruiker wordt gevraagd om bij de provider toestemming te geven voor het eerste gebruik.

Als het nodig is, staat u de volgende doorstuur-URI's toe die worden gebruikt door beheerde OAuth.

Proxy-eindpunt voor UC-verbindingen

Gebruik het proxy-eindpunt voor Unity Catalog-verbindingen met de eigen client-SDK van de externe service om REST API's rechtstreeks vanuit agentcode aan te roepen. Wijs de basis-URL van de SDK naar het proxy-eindpunt en gebruik uw Azure Databricks token als de API-sleutel. Azure Databricks verifieert de aanvraag en injecteert automatisch de referenties van de externe service vanuit de Unity Catalog-verbinding. Uw code verwerkt de tokens van de externe service nooit rechtstreeks.

Vereiste machtigingen:USE CONNECTION op het verbindingsobject.

OpenAI

Gebruik DatabricksOpenAI om oproepen naar externe OpenAI te routeren via de Unity Catalog-verbindingen proxy. Maak eerst een UNITY Catalog HTTP-verbinding met behulp van uw OpenAI API-sleutel die is opgeslagen als een Databricks-geheim:

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

Installeer vervolgens het databricks-openai pakket en gebruik de proxy-URL en werkruimteclient in uw agentcode:

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

Configureer de Slack SDK om te routeren via de Unity Catalog-verbindingenproxy. Maak een Unity Catalog HTTP-verbinding met host https://slack.com en basispad /apien gebruik vervolgens de proxy-URL als de SDK-basis-URL:

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"])

Algemene HTTP

Voor services zonder een toegewezen SDK gebruikt u de requests bibliotheek rechtstreeks met de proxy-URL:

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"},
)

UC-functiehulpprogramma's met HTTP-verbindingen

U kunt een Unity Catalog-functie maken die wordt verpakt http_request() om externe services aan te roepen. Deze methode is handig voor op SQL gebaseerde hulpprogrammadefinities. Zie Ai-agenthulpprogramma's maken met behulp van Unity Catalog-functies voor meer informatie over het maken van UC-functiehulpprogramma's.

In het volgende voorbeeld wordt een functiehulpprogramma voor Unity Catalog gemaakt waarmee een bericht naar Slack wordt geplaatst:

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

Zie CREATE FUNCTION (SQL en Python).

Voorbeeldnotitieblokken

Een agent verbinden met Slack

Zie Een AI-agent verbinden met Slack.

Een agent verbinden met Microsoft Teams

Zie Een AI-agent verbinden met Microsoft Teams.

Hulpprogramma's voor externe verbindingen

De volgende notebooks laten zien hoe u AI-agenttools maakt die verbinding maken met Slack, OpenAI en Azure AI Search.

Slack Messaging Agent-hulpprogramma

Notebook krijgen

Hulpprogramma voor Microsoft Graph API-agent

Notebook krijgen

hulpprogramma voor Azure AI Search agent

Notebook krijgen