Udostępnij przez

Integracja serwera MCP z usługą inferencyjną LLM w Azure Kubernetes Service (AKS) za pomocą dodatku operatora łańcucha narzędzi sztucznej inteligencji.

W tym artykule połączysz zgodny z MCP serwer narzędzi z obszarem roboczym wnioskowania operatora łańcucha narzędzi AI (KAITO) w usłudze Azure Kubernetes Service (AKS), umożliwiając bezpieczne i modułowe wywoływanie narzędzi dla aplikacji LLM. Dowiesz się również, jak zweryfikować wywołanie kompleksowego narzędzia, integrując model z serwerem MCP i monitorując wykonywanie funkcji w czasie rzeczywistym za pomocą odpowiedzi ustrukturyzowanych.

Protokół MCP (Model Context Protocol)

Jako rozszerzenie wnioskowania KAITO za pomocą wywoływania narzędzi, protokół MCP (Model Context Protocol) zapewnia ustandaryzowany sposób definiowania i uwidaczniania narzędzi do wywoływania modeli językowych.

Wywoływanie narzędzi za pomocą programu MCP ułatwia łączenie modeli językowych z rzeczywistymi usługami i akcjami bez ścisłego sprzęgania logiki z samym modelem. Zamiast osadzać każde wywołanie funkcji lub interfejsu API do kodu aplikacji, mcP umożliwia uruchomienie autonomicznego serwera narzędzi, który uwidacznia standardowe narzędzia lub interfejsy API, których może używać dowolny zgodny moduł LLM. Ta czysta separacja oznacza, że można niezależnie aktualizować narzędzia, udostępniać je między modelami i zarządzać nimi jak każda inna mikrousługa.

Możesz bezproblemowo podłączyć własne (BYO) wewnętrzne serwery MCP lub połączyć zewnętrzne serwery MCP z obszarem roboczym wnioskowania KAITO w usłudze AKS.

McP z operatorem łańcucha narzędzi AI (KAITO) w usłudze AKS

Zewnętrzny serwer MCP można zarejestrować w jednolitym, opartym na schemacie formacie i udostępnić w dowolnym zgodnym końcowym punkcie inferencyjnym, w tym w przypadku tych wdrożonych z obszarem roboczym KAITO. Takie podejście umożliwia zewnętrzną logikę biznesową, oddzielenie zachowania modelu od wykonywania narzędzi i ponowne używanie narzędzi między agentami, modelami i środowiskami.

W tym przewodniku zarejestrujesz wstępnie zdefiniowany serwer MCP, przetestujesz rzeczywiste wywołania wystawione przez usługę LLM uruchomioną w obszarze roboczym wnioskowania KAITO i potwierdzisz, że cała ścieżka wykonywania narzędzia (z monitu modelu do wywołania funkcji MCP) działa zgodnie z oczekiwaniami. Masz elastyczność skalowania lub zamiany narzędzi niezależnie od modelu.

Wymagania wstępne

Nawiązywanie połączenia z serwerem MCP odniesienia

W tym przykładzie użyjemy odwołania Time MCP Server, który zapewnia możliwości konwersji strefy czasowej i umożliwia LLMs uzyskiwanie bieżących informacji o czasie i wykonywanie konwersji przy użyciu standardowych nazw.

Przekazywanie dalej usługi wnioskowania KAITO

  1. Upewnij się, że obszar roboczy KAITO jest gotowy i przy użyciu polecenia kubectl get pobierz punkt końcowy usługi wnioskowania.

    kubectl get svc workspace‑phi‑4-mini-toolcall

    Uwaga / Notatka

    Dane wyjściowe mogą być adresem ClusterIP lub wewnętrznym. Sprawdź, na których portach nasłuchuje usługa. Domyślny interfejs API wnioskowania KAITO jest na porcie 80 protokołu HTTP. Jeśli dotyczy to tylko sieci wewnętrznej, możesz przekierować port lokalnie.

  2. Przekieruj port dla usługi wnioskowania do testowania przy użyciu polecenia kubectl port-forward.

    kubectl port-forward svc/workspace‑phi‑4‑mini-toolcall 8000:80

  3. Sprawdź /v1/models endpoint, aby upewnić się, że Phi-4-mini-instruct usługa LLM jest dostępna przy użyciu curl.

    curl http://localhost:8000/v1/models

    Twój Phi-4-mini-instruct interfejs API zgodny z OpenAI do wnioskowania będzie dostępny pod adresem:

    http://localhost:8000/v1/chat/completions

Upewnij się, że serwer wzorcowy MCP jest prawidłowy

W tym przykładzie przyjęto założenie, że serwer Time MCP jest hostowany w witrynie https://mcp.example.com.

  • Upewnij się, że serwer zwraca narzędzia przy użyciu polecenia curl.

    curl https://mcp.example.com/mcp/list_tools

    Oczekiwane dane wyjściowe:

    {
  "tools": [
    {
      "name": "get_current_time",
      "description": "Get the current time in a specific timezone",
      "arguments": {
        "timezone": "string"
      }
    },
    {
      "name": "convert_time",
      "description": "Convert time between two timezones",
      "arguments": {
        "source_timezone": "string",
        "time": "string",
        "target_timezone": "string"
      }
    }
  ]
}

Łączenie serwera MCP z obszarem roboczym KAITO przy użyciu żądania interfejsu API

Funkcja KAITO automatycznie pobiera definicje narzędzi z narzędzi zadeklarowanych w żądaniach interfejsu API lub zarejestrowanych dynamicznie w środowisku uruchomieniowym wnioskowania (vLLM + moduł ładujący narzędzi MCP).

W tym przewodniku utworzymy środowisko wirtualne języka Python, aby wysłać żądanie wywoływania narzędzi do Phi-4-mini-instruct punktu końcowego wnioskowania przy użyciu definicji MCP i wskazać serwer.

  1. Zdefiniuj nowy katalog roboczy dla tego projektu testowego.

    mkdir kaito-mcp
cd kaito-mcp

  2. Utwórz środowisko wirtualne języka Python i aktywuj je tak, aby wszystkie pakiety są lokalne dla projektu testowego.

    uv venv
source .venv/bin/activate

  3. Użyj open-source'owego frameworka Autogen, aby przetestować funkcjonalność wywoływania narzędzia i zainstalować jego zależności:

    uv pip install "autogen-ext[openai]" "autogen-agentchat" "autogen-ext[mcp]"

  4. Utwórz plik testowy o nazwie test.py , który:

    • Nawiązuje połączenie z serwerem Time MCP i ładuje narzędzie get_current_time.
    • Nawiązuje połączenie z usługą wnioskowania KAITO uruchomioną pod adresem localhost:8000.
    • Wysyła przykładowe zapytanie, takie jak "Jaki jest czas w Europie/Paryżu?"
    • Umożliwia automatyczne wybieranie i wywoływanie get_current_time narzędzia.
    import asyncio

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
from autogen_core import CancellationToken
from autogen_core.models import ModelFamily, ModelInfo
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import (StreamableHttpMcpToolAdapter,
                                StreamableHttpServerParams)
from openai import OpenAI


async def main() -> None:
    # Create server params for the Time MCP service
    server_params = StreamableHttpServerParams(
        url="https://mcp.example.com/mcp",
        timeout=30.0,
        terminate_on_close=True,
    )

    # Load the get_current_time tool from the server
    adapter = await StreamableHttpMcpToolAdapter.from_server_params(server_params, "get_current_time")

    # Fetch model name from KAITO's local OpenAI-compatible API
    model = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy").models.list().data[0].id

    model_info: ModelInfo = {
        "vision": False,
        "function_calling": True,
        "json_output": True,
        "family": ModelFamily.UNKNOWN,
        "structured_output": True,
        "multiple_system_messages": True,
    }

    # Connect to the KAITO inference workspace
    model_client = OpenAIChatCompletionClient(
        base_url="http://localhost:8000/v1",
        api_key="dummy",
        model=model,
        model_info=model_info
    )

    # Define the assistant agent
    agent = AssistantAgent(
        name="time-assistant",
        model_client=model_client,
        tools=[adapter],
        system_message="You are a helpful assistant that can provide time information."
    )

    # Run a test task that invokes the tool
    await Console(
        agent.run_stream(
            task="What time is it in Europe/Paris?",
            cancellation_token=CancellationToken()
        )
    )

if __name__ == "__main__":
    asyncio.run(main())

  5. Uruchom skrypt testowy w środowisku wirtualnym.

    uv run test.py

    W danych wyjściowych tego testu należy oczekiwać następujących elementów:

    • Model prawidłowo generuje wywołanie narzędzia przy użyciu nazwy MCP i oczekiwanych argumentów.
    • Autogen wysyła wywołanie narzędzia do serwera MCP, serwer MCP uruchamia logikę i zwraca wynik.
    • Funkcja Phi-4-mini-instruct LLM interpretuje nieprzetworzone dane wyjściowe narzędzia i zapewnia odpowiedź w języku naturalnym.
    ---------- TextMessage (user) ----------
What time is it in Europe/Paris?

---------- ToolCallRequestEvent (time-assistant) ----------
[FunctionCall(id='chatcmpl-tool-xxxx', arguments='{"timezone": "Europe/Paris"}', name='get_current_time')]

---------- ToolCallExecutionEvent (time-assistant) ----------
[FunctionExecutionResult(content='{"timezone":"Europe/Paris","datetime":"2025-09-17T17:43:05+02:00","is_dst":true}', name='get_current_time', call_id='chatcmpl-tool-xxxx', is_error=False)]

---------- ToolCallSummaryMessage (time-assistant) ----------
The current time in Europe/Paris is 5:43 PM (CEST).

Eksperymentowanie z większą ilością narzędzi MCP

Możesz przetestować różne narzędzia dostępne dla tego serwera MCP, takie jak convert_time.

  1. test.py W pliku z poprzedniego kroku zaktualizuj adapter definicję do następującej:

    adapter = await StreamableHttpMcpToolAdapter.from_server_params(server_params, "convert_time")

  2. Zaktualizuj definicję task , aby wywołać nowe narzędzie. Przykład:

    task="Convert 9:30 AM New York time to Tokyo time."

  3. Zapisz i uruchom skrypt języka Python.

    uv run test.py

    Oczekiwane dane wyjściowe:

    9:30 AM in New York is 10:30 PM in Tokyo.

Rozwiązywanie problemów

W poniższej tabeli przedstawiono typowe błędy podczas testowania wnioskowania KAITO za pomocą zewnętrznego serwera MCP i sposoby ich rozwiązywania:

Error Jak rozwiązać problem
Tool not found Upewnij się, że nazwa narzędzia jest zgodna z nazwą zadeklarowaną w pliku /mcp/list_tools.
401 Unauthorized Upewnij się, że zaktualizujesz server_params, aby uwzględnić nagłówki z tokenem uwierzytelniania, jeśli twój serwer MCP go wymaga.
connection refused Upewnij się, że usługa wnioskowania KAITO jest prawidłowo przekierowana przez port (np. do localhost:8000).
tool call ignored Zapoznaj się z dokumentacją wywoływania narzędzia KAITO , aby znaleźć modele VLLM, które obsługują wywoływanie narzędzi.

Dalsze kroki

W tym artykule nauczyłeś się, jak połączyć obszar roboczy KAITO z zewnętrznym serwerem referencyjnym MCP, korzystając z Autogen, aby umożliwić wywoływanie narzędzi za pośrednictwem interfejsu API zgodnego z OpenAI. Potwierdzono również, że LLM może odnajdywać, wywoływać i integrować wyniki z narzędzi zgodnych z MCP działających w środowisku AKS. Aby dowiedzieć się więcej, zobacz następujące zasoby:

  • Last updated on