Freigeben über

Verwenden externer MCP-Server

Von Bedeutung

Dieses Feature befindet sich in der Betaversion. Arbeitsbereichsadministratoren können den Zugriff auf dieses Feature über die Vorschauseite steuern. Siehe Verwalten von Azure Databricks-Vorschauen.

Verbinden Sie Databricks mit externen MCP-Servern (Model Context Protocol), um Ihren Agents Zugriff auf eine breitere Palette von Tools zu gewähren, die außerhalb von Databricks gehostet werden. Externe MCP-Server sind MCP-Server von Drittanbietern, die außerhalb von Databricks gehostet werden, mit denen Sie über databricks-verwaltete Proxys eine Verbindung herstellen.

Authentifizierung und Sicherheit

Databricks verwendet verwaltete MCP-Proxys und Unity Catalog HTTP-Verbindungen , um die Authentifizierung für Ihren Arbeitsbereich sicher zu verarbeiten:

  • Sichere Tokenverwaltung: Databricks verarbeitet alle OAuth-Flüsse und die Tokenaktualisierung automatisch
  • Keine verfügbar gemachten Anmeldeinformationen: Token werden niemals für Endbenutzer verfügbar gemacht.
  • Zentralisierte Authentifizierung: Konsistente Authentifizierungsmuster mit Unity-Katalogverbindungen

Anforderungen

Installieren eines externen MCP-Servers

Sie haben drei Optionen zum Installieren externer MCP-Server für die Verwendung mit Ihren Agents. Alle Methoden erstellen eine Unity-Katalogverbindung, die sicheren, authentifizierten Zugriff auf den MCP-Server ermöglicht.

Wählen Sie Ihre Installationsmethode basierend auf Ihrem MCP-Server aus:

Von Databricks Marketplace

Von Bedeutung

Dieses Feature befindet sich in der Public Preview.

Installieren Sie kuratierte und vorinstallierte MCP-Server direkt über Azure Databricks Marketplace:

  1. Wechseln Sie in Ihrem Azure Databricks-Arbeitsbereich zur Registerkarte "Marketplace>Agents>MCP-Server ".

  2. Suchen Sie den MCP-Server, den Sie installieren möchten, und klicken Sie auf "Installieren".

  3. Konfigurieren Sie im Installationsdialogfeld die Verbindung:

    • Verbindungsname: Geben Sie einen Namen für die Unity-Katalogverbindung ein (z. B github_connection. ).
    • Host: Die Hostdomäne ist für kuratierte Server vorab aufgefüllt.
    • Basispfad: Der Basispfad ist für kuratierte Server vorab aufgefüllt.

    Anmeldeinformationen: Geben Sie Ihre Authentifizierungsanmeldeinformationen ein. Die erforderlichen Felder hängen vom Anmeldedatentyp des Servers ab.

    • Für die Bearertokenauthentifizierung : Stellen Sie Ihr Bearertoken bereit.
    • Für OAuth U2M-Authentifizierung : Geben Sie Ihre Client-ID und ihren geheimen Clientschlüssel an.

    Anweisungen zum Abrufen dieser Anmeldeinformationen finden Sie in der Dokumentation des MCP-Serveranbieters.

  4. Klicken Sie auf "Installieren ", um die Verbindung zu erstellen.

Ausführliche Informationen zur Marketplace-Installation finden Sie unter Erhalten Sie Zugriff auf externe MCP-Server.

Benutzerdefinierte HTTP-Verbindung

Erstellen Sie eine Unity-Katalog-HTTP-Verbindung, um jeden MCP-Server zu installieren, einschließlich selbst gehosteter oder Drittanbieterserver, die in Marketplace nicht verfügbar sind.

  1. Erstellen Sie eine HTTP-Verbindung. Siehe HTTP-Verbindung.

  2. Wählen Sie beim Erstellen der HTTP-Verbindung das Kontrollkästchen „Ist MCP-Verbindung“, um die MCP-Funktionalität zu aktivieren.

  3. Stellen Sie sicher, dass die Verbindungs-URL auf einen gültigen MCP-Serverendpunkt verweist.

Dynamische Clientregistrierung (Experimental)

Von Bedeutung

Dieses Feature befindet sich in der Public Preview.

Verwenden Sie dynamische Clientregistrierung (Dynamic Client Registration, DCR), um MCP-Server, die OAuth 2.0 DCR (RFC7591) unterstützen, automatisch zu registrieren und zu installieren.

DCR verarbeitet automatisch OAuth-Ermittlung, Clientregistrierung und Unity Catalog-Verbindungserstellung, ohne dass eine manuelle Konfiguration der Anmeldeinformationen erforderlich ist.

Um DCR zu verwenden, müssen Sie die folgenden Anforderungen erfüllen:

  • Der MCP-Server muss DCR- und OAuth 2.0-Autorisierung unterstützen.
  • Der MCP-Server muss OAuth-Metadatenendpunkte verfügbar machen.

  1. Installieren oder aktualisieren Sie das databricks-mcp Paket, um die neueste Version zu erhalten:

    %pip install -U databricks-mcp
%restart_python

  2. Verwenden Sie die DCR-Registrierungsfunktion, um eine Unity-Katalogverbindung zu erstellen:

    from databricks.sdk import WorkspaceClient
from databricks_mcp import register_mcp_server_via_dcr

# Initialize workspace client
workspace_client = WorkspaceClient()

# Register MCP server via DCR
connection_url = register_mcp_server_via_dcr(
    connection_name="my_mcp_server",
    mcp_url="https://mcp.example.com/api",
    workspace_client=workspace_client
)

print(f"Connection created: {connection_url}")

Nach Abschluss einer Installationsmethode:

  • Es wird eine Unity-Katalogverbindung mit Ihren MCP-Serverdetails erstellt.

  • Azure Databricks stellt einen verwalteten Proxyendpunkt zur sicheren Verarbeitung von Authentifizierung und Tokenverwaltung vor.

  • Der MCP-Server ist in AI Playground verfügbar und kann programmgesteuert in Ihren Agents verwendet werden

  • Sie können anderen Benutzern Zugriff auf die Verbindung über Unity-Katalogberechtigungen gewähren.

  • Die Proxyendpunkt-URL folgt diesem Format:

    https://<workspace-hostname>/api/2.0/mcp/external/{connection_name}

Um Ihren MCP-Server anzuzeigen, wechseln Sie zu Ihrem Arbeitsbereich und dann zu >Agents> und MCP-Server

Registerkarte „Agents MCP Server“

Freigeben der MCP-Serververbindung

Gewähren sie USE CONNECTION Berechtigungen für Identitätsprinzipale, die die MCP-Serververbindung verwenden müssen:

  1. Wechseln Sie in Ihrem Arbeitsbereich zu Katalog>Verbindungen> Ihre >Verbindungsberechtigungen.
  2. Gewähren Sie identitätsgerechten Zugriff auf die Unity-Katalogverbindung.

Testen von MCP-Servern mit AI Playground

Testen Sie MCP-Server direkt in AI Playground , ohne Code zu schreiben:

  1. Wechseln Sie zum KI-Playground in Ihrem Databricks-Arbeitsbereich.

  2. Wählen Sie ein Modell mit der Kennzeichnung „Werkzeuge aktiviert“ aus.

  3. Klicken Sie auf "Extras > " + "Tool hinzufügen" , und wählen Sie "MCP-Server " aus den verfügbaren Tooloptionen aus.

  4. Wählen Sie im Abschnitt "MCP-Server " die Option "Externe MCP-Server " aus, um verfügbare Verbindungen zu durchsuchen.

  5. Wählen Sie die Unity-Katalogverbindung github_connection aus, die Sie zuvor installiert haben (z. B. github_connection).

  6. Chatten Sie mit der LLM, um zu testen, wie sie mit Ihren MCP-Servertools interagiert. AI Playground ermittelt automatisch verfügbare Tools von Ihrem MCP-Server und stellt sie dem LLM zur Verfügung.

Auf diese Weise können Sie schnell MCP-Serverintegrationen prototypieren und testen, bevor Sie vollständige Agents erstellen oder in der Produktion bereitstellen.

Programmgesteuertes Verwenden von MCP-Servern

Verwenden Sie ihn nach der Installation eines MCP-Servers programmgesteuert in Ihrem Agentcode, indem Sie eine Verbindung mit der Proxy-URL herstellen. Der Databricks-Proxy bewirkt, dass sich externe Server wie verwaltete MCP-Server verhalten, die Authentifizierung und die Tokenverwaltung behandeln.

Databricks MCP-Client

Der empfohlene Ansatz behandelt externe MCP-Server als von Databricks verwaltete Server, indem der Proxyendpunkt zu Ihrer MANAGED_MCP_SERVER_URLS Liste hinzugefügt wird.

from databricks.sdk import WorkspaceClient
from databricks_mcp import DatabricksMCPClient

# Initialize workspace client
workspace_client = WorkspaceClient()
host = workspace_client.config.host

# External MCP servers are proxied as managed servers, allowing you
# to use the same API for both managed and external servers
MANAGED_MCP_SERVER_URLS = [
    f"{host}/api/2.0/mcp/functions/system/ai",  # Default managed MCP
    f"{host}/api/2.0/mcp/external/github_connection"  # External MCP proxy
]

Um den MCP-Server in einem Agent zu verwenden, übergeben Sie die Proxy-URL an den managed_server_urls Parameter:

# Use with agents - external servers work just like managed ones
import asyncio
from your_agent_code import create_mcp_tools  # Your agent's tool creation function

# Create tools from both managed and external (proxied) servers
mcp_tools = asyncio.run(
    create_mcp_tools(
        ws=workspace_client,
        managed_server_urls=MANAGED_MCP_SERVER_URLS
    )
)

Sie können das Tool auch direkt über den Databricks MCP-Client aufrufen:

# Direct tool call using DatabricksMCPClient
mcp_client = DatabricksMCPClient(
    server_url=f"{host}/api/2.0/mcp/external/github_connection",
    workspace_client=workspace_client
)

# List available tools
tools = mcp_client.list_tools()
print(f"Available tools: {[tool.name for tool in tools]}")

# Call a tool
response = mcp_client.call_tool(
    "list_commits",
    {"owner": "mlflow", "repo": "mlflow", "sha": "master"}
)
print(response.content[0].text)

Standard MCP SDK

Stellen Sie eine Verbindung mit MCP-Servern mit dem standardmäßigen MCP SDK mit async/await her:

%pip install -U databricks-sdk databricks_mcp tabulate databricks_ai_bridge
%restart_python

import json
from databricks.sdk import WorkspaceClient
from databricks_mcp import DatabricksOAuthClientProvider
from databricks.sdk.credentials_provider import ModelServingUserCredentials
from mcp.client.streamable_http import streamablehttp_client as connect
from mcp import ClientSession
from tabulate import tabulate


async def main():
    app_url = "https://<workspace-hostname>/api/2.0/mcp/external/github_connection"
    client = WorkspaceClient()

    async with connect(app_url, auth=DatabricksOAuthClientProvider(client)) as (
        read_stream,
        write_stream,
        _,
    ):
        async with ClientSession(read_stream, write_stream) as session:
            init = await session.initialize()
            print(json.dumps(init.model_dump(), indent=2))
            tools = await session.list_tools()
            print(json.dumps(tools.model_dump(), indent=2))

            arguments = {
                "owner": "mlflow",
                "repo": "mlflow",
                "sha": "master"
            }
            response = await session.call_tool(name="list_commits", arguments=arguments)

            data = json.loads(response.content[0].text)
            rows = []
            for commit in data:
                author = commit.get("commit", {}).get("author", {}).get("name")
                message = commit.get("commit", {}).get("message", "").split("\n")[0]
                html_url = commit.get("html_url", "")
                rows.append([author, message, html_url])

            # Print as table
            print(tabulate(rows, headers=["Author", "Message", "Commit URL"], tablefmt="github"))

await main()

Beispielnotizbücher: Erstellen eines Agents mit Databricks MCP-Servern

Die folgenden Notizbücher zeigen, wie LangGraph- und OpenAI-Agents erstellt werden, die MCP-Tools aufrufen, einschließlich externer MCP-Server, auf die über Databricks-Proxyendpunkte zugegriffen wird.

LangGraph MCP-Toolanruf-Agent

Notebook abrufen

OpenAI MCP-Toolanruf-Agent

Notebook abrufen

Einschränkungen

  • Private Verbindung zu Ressourcen in Ihrer VPC über Private Link wird nicht unterstützt. Wenden Sie sich an Ihr Supportteam, wenn Sie diese Funktionalität benötigen.

Nächste Schritte

  • Last updated on