Ansluta agenter till externa tjänster

Anslut dina AI-agenter till externa program som Slack, Google Calendar eller någon tjänst med ett API. Azure Databricks tillhandahåller flera metoder beroende på om den externa tjänsten har en MCP-server, om du behöver autentisering per användare eller om du föredrar att anropa API:er direkt från agentkoden. Alla metoder förlitar sig på en HTTP-anslutning i Unity Catalog för att hantera autentiseringsuppgifter på ett säkert sätt och styra åtkomsten till externa tjänster.

Requirements

• En HTTP-anslutning för Unity Catalog för ditt externa program. Unity Catalog-anslutningar ger säker, styrd hantering av autentiseringsuppgifter och aktiverar flera autentiseringsmetoder, inklusive OAuth 2.0-autentisering från användare till dator och autentisering från dator till dator.

Externa MCP-servrar

Om den externa tjänsten har en MCP-server tillgänglig rekommenderar Azure Databricks att du ansluter via externa MCP-servrar. MCP-servrar tillhandahåller automatisk identifiering av verktyg, förenklad integrering och autentisering per användare. Se Använda externa MCP-servrar för installationsmetoder, programmatisk användning och autentiseringsinformation.

Lägga till en extern MCP-server i din agent

När du har registrerat den externa MCP-servern som en Anslutning till Unity Catalog ansluter du din agent till den med hjälp av den hanterade MCP-URL:en: https://<workspace-hostname>/api/2.0/mcp/external/{connection_name}. Ersätt <connection-name> med namnet på anslutningen till Unity Catalog.

OpenAI Agents SDK (Appar)

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)

Bevilja appen åtkomst till Unity Catalog-anslutningen i 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 (appar)

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)

Bevilja appen åtkomst till Unity Catalog-anslutningen i databricks.yml:

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

Modellhantering

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

Information om hur du distribuerar agenten finns i Distribuera en agent för generativa AI-program (modellservering). Mer information om loggningsagenter med MCP-resurser finns i Använda Databricks-hanterade MCP-servrar.

Hanterad OAuth

Azure Databricks erbjuder hanterade OAuth-flöden för utvalda API-verktygsproviders. Du behöver inte registrera din egen OAuth-app eller hantera autentiseringsuppgifter. Azure Databricks rekommenderar Managed OAuth för utveckling och testning. Om produktionsanvändningsfall kräver att anpassade OAuth-autentiseringsuppgifter genereras kan du läsa providerdokumentationen för mer information.

Följande integreringar använder Azure Databricks hanterade OAuth-autentiseringsuppgifter som lagras på ett säkert sätt i serverdelen.

Om du vill konfigurera hanterad OAuth skapar du en HTTP-anslutning med autentiseringstypen OAuth-användare till dator per användare och väljer din leverantör i listrutan OAuth-provider . Detaljerade steg finns i Installera en extern MCP-server.

Varje användare uppmanas att auktorisera med providern vid första användningen.

Tillåt vid behov följande omdirigeringsadresser som används av den hanterade OAuth-processen:

Proxyslutpunkt för UC-anslutningar

Använd proxyslutpunkten för Unity Catalog-anslutningar med den externa tjänstens egen klient-SDK för att anropa REST-API:er direkt från agentkoden. Peka SDK:ns bas-URL till proxyslutpunkten och använd din Azure Databricks-token som API-nyckel. Azure Databricks autentiserar begäran och matar automatiskt in den externa tjänstens autentiseringsuppgifter från Unity Catalog-anslutningen. Koden hanterar aldrig den externa tjänstens token direkt.

Behörigheter som krävs:USE CONNECTION på anslutningsobjektet.

OpenAI

Använd DatabricksOpenAI för att dirigera anrop till extern OpenAI via proxyn för Unity Catalog-anslutningar. Skapa först en HTTP-anslutning för Unity Catalog med hjälp av din OpenAI API-nyckel som lagras som en Databricks-hemlighet:

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

Installera sedan databricks-openai-paketet och använd proxy-URL:en och arbetsyte-klienten i agentkoden.

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

Konfigurera Slack SDK så att det dirigeras via unity catalog-anslutningsproxyn. Skapa en HTTP-anslutning för Unity-katalogen med värd https://slack.com - och bassökvägen /apioch använd sedan proxy-URL:en som SDK-bas-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"])

Generisk HTTP

För tjänster utan dedikerad SDK använder du requests biblioteket med proxy-URL:en direkt:

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-funktionsverktyg med HTTP-anslutningar

Du kan skapa en Unity Catalog-funktion som innesluter http_request() för att anropa externa tjänster. Den här metoden är användbar för SQL-baserade verktygsdefinitioner. Mer information om hur du skapar UC-funktionsverktyg finns i Skapa AI-agentverktyg med hjälp av Unity Catalog-funktioner .

I följande exempel skapas ett funktionsverktyg för Unity Catalog som publicerar ett meddelande till 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

Se CREATE FUNCTION (SQL och Python).

Exempelanteckningsböcker

Ansluta en agent till Slack

Se Ansluta en AI-agent till Slack.

Ansluta en agent till Microsoft Teams

Se Anslut en AI-agent till Microsoft Teams.

Verktyg för extern anslutning

Följande notebook-filer visar hur du skapar AI-agentverktyg som ansluter till Slack, OpenAI och Azure AI-sökning.

Verktyg för Slack-meddelandeagent

Hämta anteckningsbok

Microsoft Graph API agentverktyg

Hämta anteckningsbok

Azure AI Search agentverktyg

Hämta anteckningsbok