Rufen Sie MCP-Tools von einem Python-Agenten auf

Verwenden Sie MCP-Tools in einem benutzerdefinierten Python-Agenten, der mit LangGraph, dem OpenAI Agents SDK oder dem OpenAI-Client entwickelt wurde. Die Beispiele zeigen, wie man sich anmeldet, Tools entdeckt und einen Agenten lokal mit eigenen Azure Databricks-Zugangsdaten ausführen kann.

Für eine App, die Tools im Namen der angemeldeten Nutzer aufruft, siehe Verbinde deine App mit MCP-Tools.

Für weitere Verbindungsmöglichkeiten siehe Unterstützte Coding- und Work-Agents, Andere MCP-Clients oder MCP-Tools mit der Agent Bricks CLI hinzufügen.

Voraussetzungen

system.ai.dbsql, system.ai.sandbox, und system.ai.web_search befinden sich in der Beta. Um sie zu nutzen, muss ein Kontoadministrator die Vorschau des Enhanced Unity Gateway auf der Seite „Previews“ der Account-Konsole aktivieren. Unity Gateway selbst ist jetzt verfügbar. Siehe Kontovorschauen verwalten.

Für die Identitätswahl siehe Unterstützte ausgehende Authentifizierung. Weitere Informationen zu den Anforderungen an die Konnektivität finden Sie im Abschnitt MCP-Netzwerk.

Schritt 1: Installieren und anmelden

  1. Wenn du die Databricks-CLI noch nicht installiert hast, führe diesen Befehl auf macOS oder Linux aus:

    curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
    

    Für Windows oder andere Installationsmethoden siehe Databricks CLI installieren.

  2. Melden Sie sich in Ihrem Arbeitsbereich an:

    databricks auth login --host https://<workspace-hostname> --profile DEFAULT
    
  3. Installieren Sie die Python-Bibliotheken:

    pip install --upgrade databricks-mcp databricks-sdk "mcp>=1.24,<2"
    

Die Beispiele verwenden MCP Python 1.x, das mit den unten aufgeführten Agenten-Frameworks kompatibel ist.

Schritt 2: Verbinden Sie sich mit Ihrem Server

Speichern Sie den folgenden Code als mcp_agent.py. Ersetzen Sie <mcp-server-url> durch die URL Ihres Servers:

  • Von Databricks bereitgestelltes oder registriertes MCP:https://<workspace-hostname>/ai-gateway/mcp-services/<catalog>.<schema>.<service>.
  • Server auf Databricks-Apps: Kopieren Sie die App-URL von ihrer Übersichtsseite und fügen Sie /mcp.
from databricks_mcp import DatabricksMCPClient
from databricks.sdk import WorkspaceClient

workspace_client = WorkspaceClient()
server_url = "<mcp-server-url>"
mcp_client = DatabricksMCPClient(
    server_url=server_url,
    workspace_client=workspace_client,
)

tools = mcp_client.list_tools()
for tool in tools:
    print(tool.name, tool.description, tool.inputSchema, sep="\n")

Führen Sie das Skript aus:

python mcp_agent.py

Du solltest die Tools deines Servers sehen, mit Beschreibungen und Eingabeschemata. Wählen Sie für den nächsten Schritt eine schreibgeschützte Aufgabe, die von einem dieser Tools unterstützt wird. Wenn die Liste leer ist oder die Verbindung fehlschlägt, siehe MCP-Authentifizierung.

Nutze einen anderen Server

  • Für ein integriertes MCP verwenden Sie dessen vollständigen Namen in der MCP-URL, zum Beispiel system.ai.github.
  • Für eine bestehende Integration mit einem Workspace-MCP-Server ersetzen Sie server_url durch dessen Workspace-Endpunkt-URL.

Um MCPs zu finden, auf die Sie in einem Katalog und Schema zugreifen können, führen Sie aus:

databricks ai-gateway list-mcp-services --parent schemas/system.ai

Ersetzen Sie system.ai durch Ihre <catalog>.<schema>, um registrierte MCPs aufzulisten. Die CLI übernimmt die Paginierung.

Schritt 3: Führen Sie einen Agenten mit diesen Tools aus

Wählen Sie Ihr Framework, installieren Sie dessen Paket und fügen Sie dessen Python-Beispiel zu mcp_agent.py hinzu. Jedes Beispiel verwendet dieselbe server_url und dieselbe Workspace-Anmeldung wie in Schritt 2.

LangGraph

Das Beispiel konvertiert MCP-Inhaltsblöcke in das Chat-Nachrichtenformat des Modells mit convert_to_openai_messages.

pip install --upgrade databricks-langchain langgraph
import asyncio
from databricks_langchain import (
    ChatDatabricks,
    DatabricksMCPServer,
    DatabricksMultiServerMCPClient,
)
from langchain_core.messages import convert_to_openai_messages
from langgraph.prebuilt import create_react_agent

async def main():
    client = DatabricksMultiServerMCPClient([
        DatabricksMCPServer(
            name="my-mcp-server",
            url=server_url,
            workspace_client=workspace_client,
        ),
    ])
    agent = create_react_agent(
        ChatDatabricks(endpoint="databricks-claude-sonnet-4-5"),
        tools=await client.get_tools(),
        prompt=lambda state: convert_to_openai_messages(state["messages"]),
    )
    task = input("Ask the agent to use a tool: ")
    result = await agent.ainvoke({
        "messages": [{"role": "user", "content": task}],
    })
    for message in result["messages"]:
        print(message)

asyncio.run(main())
Bereitstellungsnotebook (optional)

Für die Bereitstellung von Model Serving passen Sie dieses Notizbuch so an, dass es Ihre Server-URL verwendet:

LangGraph MCP-Toolanruf-Agent

Notebook abrufen

OpenAI Agents SDK

pip install --upgrade databricks-openai openai-agents
import asyncio
from agents import Agent, Runner, set_default_openai_api, set_default_openai_client
from agents.mcp import MCPServerStreamableHttpParams
from agents.tracing import set_trace_processors
from databricks_openai import AsyncDatabricksOpenAI
from databricks_openai.agents.mcp_server import McpServer

set_default_openai_client(AsyncDatabricksOpenAI())
set_default_openai_api("chat_completions")
set_trace_processors([])

async def main():
    async with McpServer(
        name="my-mcp-server",
        params=MCPServerStreamableHttpParams(url=server_url),
        workspace_client=workspace_client,
    ) as server:
        agent = Agent(
            name="Tool-using agent",
            instructions="Use the available tools to answer the user's question.",
            model="databricks-claude-sonnet-4-5",
            mcp_servers=[server],
        )
        task = input("Ask the agent to use a tool: ")
        result = await Runner.run(agent, task)
        for item in result.new_items:
            print(item.to_input_item())

asyncio.run(main())
Bereitstellungsnotebook (optional)

Für die Bereitstellung von Model Serving passen Sie dieses Notizbuch so an, dass es Ihre Server-URL verwendet:

Agents SDK MCP-Toolaufruf-Agent

Notebook abrufen

OpenAI-Client

pip install --upgrade databricks-openai

Dieses Beispiel führt die Tool-Calling-Schleife explizit mit dem OpenAI-kompatiblen Client aus.

import json
from databricks_openai import DatabricksOpenAI, McpServerToolkit

toolkit = McpServerToolkit(url=server_url, workspace_client=workspace_client)
tools_by_name = {tool.name: tool for tool in toolkit.get_tools()}
model_client = DatabricksOpenAI()
messages = [{"role": "user", "content": input("Ask the agent to use a tool: ")}]

for _ in range(10):
    response = model_client.chat.completions.create(
        model="databricks-claude-sonnet-4-5",
        messages=messages,
        tools=[tool.spec for tool in tools_by_name.values()],
    )
    message = response.choices[0].message
    messages.append(message.model_dump(exclude_none=True))
    if not message.tool_calls:
        print(message.content)
        break
    for call in message.tool_calls:
        try:
            tool = tools_by_name.get(call.function.name)
            if tool is None:
                raise ValueError(f"Unknown tool: {call.function.name}")
            arguments = json.loads(call.function.arguments or "{}")
            if not isinstance(arguments, dict):
                raise ValueError("Tool arguments must be a JSON object.")
            output = tool.execute(**arguments)
        except Exception as error:
            output = json.dumps({"error": str(error)})
        print(call.function.name, output)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": str(output),
        })
else:
    raise RuntimeError("The agent reached the tool-calling limit.")
Bereitstellungsnotebook (optional)

Für die Bereitstellung von Model Serving passen Sie dieses Notizbuch so an, dass es Ihre Server-URL verwendet:

OpenAI MCP-Werkzeugaufruf-Agent

Notebook abrufen

Führen Sie python mcp_agent.py erneut aus. Wenn Sie aufgefordert werden, fragen Sie nach der von Ihnen gewählten schreibgeschützten Aufgabe, einschließlich aller erforderlichen Eingaben. Wenn Ihr Server zum Beispiel ein Ticket-Suchtool hat, bitten Sie es, offene Tickets in einem bestimmten Projekt zu finden.

Überprüfen Sie das gedruckte Gespräch auf einen Tool-Call, dessen Ergebnis und die Antwort des Agenten. Eine Antwort ohne Toolaufruf bestätigt nicht, dass der MCP-Server genutzt wurde.

Rufen Sie ein Tool direkt auf, um Fehler zu beheben

Verwenden Sie den Werkzeugnamen und das Eingabeschema, die in Schritt 2 ausgedruckt sind. Dieses Beispiel fordert den Namen und die Argumente an, damit es mit den Tools deines Servers funktioniert. Führe es nach dem Verbindungscode in Schritt 2 aus:

import json

tool_name = input("Read-only tool name: ")
arguments = json.loads(input("Tool arguments as a JSON object: "))
result = mcp_client.call_tool(tool_name, arguments)
print(result)

Überprüfen Sie, ob das Ergebnis keinen Werkzeugfehler enthält und die von Ihnen erwarteten Daten enthält.

Ermitteln Sie Tool-Namen und Eingabeschemata mit list_tools(), bevor Sie ein Tool aufrufen. Die Ergebnisformate variieren je nach Werkzeug:

  • Wenn structuredContent vorhanden ist, verwenden Sie dieses strukturierte Ergebnis direkt. Ein Tool kann seine Form durch outputSchema beschreiben.
  • Ansonsten inspizieren Sie die content Blöcke. Analysiere einen Textblock nur dann als JSON, wenn das Tool JSON zurückgibt. MCP unterstützt außerdem Klartext und andere Inhaltstypen.
  • Überprüfen isError und inspizieren Sie eine Probenantwort, bevor Sie sich auf bestimmte Ausgabefelder verlassen.

Stelle bereit und teile, wenn du bereit bist

Das lokale Beispiel wird unter Ihrer Benutzerkennung ausgeführt. Wenn Sie den Agenten auf Databricks Apps einsetzen, wählen Sie die verwendete Identität aus: den Service-Principal der App für den gemeinsamen Zugriff oder den anrufenden Benutzer für den Benutzerzugriff.

Für von Databricks bereitgestellte oder registrierte MCPs:

Für Workspace-MCP-Endpunkte oder Server, die auf Databricks Apps gehostet werden, gewähren Sie Zugriff auf die zugrundeliegenden Ressourcen oder die App. Siehe Agenten-Authentifizierung.

Weitere Ressourcen