Korzystanie z zewnętrznych serwerów MCP

Połącz usługę Databricks z zewnętrznymi serwerami protokołu MCP (Model Context Protocol), aby zapewnić agentom dostęp do szerszego zakresu narzędzi hostowanych poza usługą Databricks. Zewnętrzne serwery MCP to serwery MCP innych firm hostowane poza usługą Databricks, z którymi nawiązujesz połączenie za pośrednictwem zarządzanych przez usługę Databricks serwerów proxy.

Uwierzytelnianie i zabezpieczenia

Usługa Databricks używa zarządzanych serwerów proxy MCP i połączeń HTTP Katalogu Unity, aby bezpiecznie realizować uwierzytelnianie w twoim obszarze roboczym.

• Bezpieczne zarządzanie tokenami: usługa Databricks automatycznie obsługuje wszystkie przepływy protokołu OAuth i odświeżanie tokenów
• Brak uwidocznionych poświadczeń: tokeny nigdy nie są widoczne dla użytkowników końcowych
• Scentralizowane uwierzytelnianie: spójne wzorce uwierzytelniania przy użyciu połączeń Unity Catalog

Requirements

• Obszar roboczy z włączoną wersją zapoznawcza zarządzanych serwerów MCP . Zobacz Zarządzanie wersjami zapoznawczami usługi Azure Databricks.
• Musisz mieć CREATE CONNECTION uprawnienia w kontekście metastore'a Unity Catalog przechowującego informacje o połączeniu MCP.
• Serwer MCP musi używać mechanizmu transportu HTTP z możliwością przesyłania strumieniowego

Instalowanie zewnętrznego serwera MCP

Dostępne są trzy opcje instalowania zewnętrznych serwerów MCP do użycia z agentami. Wszystkie metody tworzą połączenie Unity Catalog, które umożliwia uwierzytelniony i bezpieczny dostęp do serwera MCP.

Wybierz metodę instalacji na podstawie serwera MCP:

Z witryny Databricks Marketplace

Zainstaluj wyselekcjonowane i wstępnie skonfigurowane serwery MCP bezpośrednio z witryny Azure Databricks Marketplace:

1. W obszarze roboczym usługi Azure Databricks przejdź do karty Marketplace>Agenci>Serwery MCP.

2. Znajdź serwer MCP, który chcesz zainstalować, a następnie kliknij przycisk Zainstaluj.

3. W oknie dialogowym instalacji skonfiguruj połączenie:

   • Nazwa połączenia: Wprowadź nazwę połączenia Unity Catalog (na przykład github_connection).
   • Host: domena hosta jest automatycznie wypełniana dla wyselekcjonowanych serwerów.
   • Ścieżka podstawowa: ścieżka podstawowa jest wstępnie wypełniana dla wyselekcjonowanych serwerów.

   Poświadczenia: wprowadź poświadczenia uwierzytelniania. Wymagane pola zależą od typu poświadczeń serwera:

   • W przypadku uwierzytelniania tokenu typu bearer: podaj swój token typu bearer.
   • W przypadku uwierzytelniania OAuth U2M : podaj identyfikator klienta i klucz tajny klienta.

   Zapoznaj się z dokumentacją dostawcy serwera MCP, aby uzyskać instrukcje dotyczące uzyskiwania tych poświadczeń.

4. Kliknij przycisk Zainstaluj , aby utworzyć połączenie.

Aby uzyskać szczegółowe informacje na temat instalacji witryny Marketplace, zobacz Uzyskiwanie dostępu do zewnętrznych serwerów MCP.

Niestandardowe połączenie HTTP

Utwórz połączenie HTTP katalogu Unity w celu ustanowienia połączenia z dowolnym serwerem MCP, w tym serwerami hostowanymi samodzielnie lub przez inne firmy, które nie są dostępne w Marketplace.

1. Utwórz połączenie HTTP. Zobacz Połączenie HTTP.

2. Podczas tworzenia połączenia HTTP zaznacz pole wyboru Is mcp connection, aby włączyć funkcjonalność MCP.

3. Sprawdź, czy adres URL połączenia wskazuje prawidłowy punkt końcowy serwera MCP.

Dynamiczna rejestracja klienta (eksperymentalna)

Użyj dynamicznej rejestracji klienta (DCR) do automatycznego rejestrowania i instalowania serwerów MCP obsługujących protokół OAuth 2.0 DCR (RFC7591).

DCR automatycznie obsługuje odnajdywanie OAuth, rejestrację klienta i tworzenie połączenia z Unity Catalog bez konieczności ręcznego podawania poświadczeń.

Aby można było korzystać z DCR, należy spełnić następujące wymagania:

• Serwer MCP musi obsługiwać autoryzację DCR i OAuth 2.0.
• Serwer MCP musi uwidaczniać punkty końcowe metadanych OAuth.

1. Zainstaluj lub uaktualnij pakiet, databricks-mcp aby uzyskać najnowszą wersję:

   %pip install -U databricks-mcp
   %restart_python
   

2. Użyj funkcji rejestracji DCR, aby utworzyć połączenie Unity Catalog.

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

Po zakończeniu dowolnej metody instalacji:

• Połączenie katalogu Unity jest tworzone na podstawie szczegółów serwera MCP

• Azure Databricks udostępnia zarządzany punkt końcowy proxy, który bezpiecznie obsługuje uwierzytelnianie i zarządzanie tokenami

• Serwer MCP jest dostępny na placu zabaw dla sztucznej inteligencji i może być używany programowo w agentach

• Możesz udzielić innym użytkownikom dostępu do połączenia poprzez uprawnienia w Unity Catalog.

• Adres URL punktu końcowego serwera proxy ma następujący format:

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

Aby wyświetlić serwer MCP, przejdź do przestrzeni roboczej >Agenci>Serwery MCP

Udostępnianie połączenia serwera MCP

Udziel USE CONNECTION uprawnień podmiotom zabezpieczeń tożsamości, które muszą używać połączenia serwera MCP:

1. W obszarze roboczym przejdź do Katalogu>Połączeń> Twoje >.
2. Udziel tożsamościom odpowiedniego dostępu do Unity Catalog.

Testowanie serwerów MCP za pomocą platformy AI Playground

Przetestuj serwery MCP bezpośrednio w środowisku AI Playground bez konieczności pisania kodu:

1. Przejdź do obszaru zabaw dla sztucznej inteligencji w obszarze roboczym usługi Databricks.

2. Wybierz model z etykietą „Narzędzia włączone”.

3. Kliknij pozycję Narzędzia > + Dodaj narzędzie i wybierz pozycję Serwery MCP z dostępnych opcji narzędzi.

4. W sekcji Serwery MCP wybierz pozycję Zewnętrzne serwery MCP , aby przeglądać dostępne połączenia.

5. Wybierz zainstalowane wcześniej połączenie katalogu Unity (na przykład github_connection).

6. Porozmawiaj z LLM, aby przetestować, jak współdziała z narzędziami serwerowymi MCP. AI Playground automatycznie odnajduje dostępne narzędzia z serwera MCP i udostępnia je LLM.

Dzięki temu można szybko tworzyć prototypy i testować integracje serwerów MCP przed utworzeniem pełnych agentów lub wdrożeniem w środowisku produkcyjnym.

Programowe używanie serwerów MCP

Po zainstalowaniu serwera MCP użyj go programowo w kodzie agenta, łącząc się z adresem URL serwera proxy. Serwer proxy usługi Databricks sprawia, że serwery zewnętrzne zachowują się jak zarządzane serwery MCP, obsługują uwierzytelnianie i zarządzanie tokenami.

Klient MCP Databricks

Zalecane podejście polega na traktowaniu zewnętrznych serwerów MCP jako serwerów zarządzanych przez Databricks przez dodanie punktu końcowego serwera proxy do listy MANAGED_MCP_SERVER_URLS.

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
]

Aby użyć serwera MCP w agencie, przekaż adres URL serwera proxy do parametru managed_server_urls :

# 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
    )
)

Narzędzie można również wywołać bezpośrednio przy użyciu klienta MCP usługi Databricks:

# 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)

Standardowy zestaw MCP SDK

Nawiąż połączenie z serwerami MCP przy użyciu standardowego zestawu MCP SDK z funkcją async/await:

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

Przykładowe notesy: tworzenie agenta za pomocą serwerów MCP usługi Databricks

W poniższych notesach pokazano, jak projektować agentów LangGraph i OpenAI, którzy wywołują narzędzia MCP, w tym zewnętrzne serwery MCP dostępne za pośrednictwem punktów końcowych serwera proxy Databricks.

Agent wywołujący narzędzia LangGraph MCP

Pobierz laptopa

Agent wywołujący narzędzia OpenAI MCP

Pobierz laptopa

Ograniczenia

• Prywatna łączność z zasobami w programie VPC przy użyciu usługi Private Link nie jest obsługiwana. Jeśli potrzebujesz tej funkcji, skontaktuj się z zespołem pomocy technicznej.

• Usługa Databricks obsługuje tylko zewnętrzne serwery MCP korzystające z mechanizmu transportu HTTP z możliwością przesyłania strumieniowego.

Dalsze kroki

• Używanie zarządzanych serwerów MCP wraz z serwerami zewnętrznymi
• Połączenie klientów z serwerami MCP w celu uzyskania dostępu do infrastruktury MCP Databricks
• Tworzenie niestandardowych serwerów MCP dla potrzeb organizacji
• Wdrażanie agentów korzystających z zewnętrznych serwerów MCP

• Użyj zewnętrznych serwerów MCP z Agent Bricks: Multi-Agent Supervisor.