Integrera en MCP-server med en LLM-slutsatsdragningstjänst i Azure Kubernetes Service (AKS) med AI-verktygskedjans operatörstillägg

I den här artikeln ansluter du en MCP-kompatibel verktygsserver med en KAITO-slutsatsdragningsarbetsyta (AI toolchain operator) på Azure Kubernetes Service (AKS), vilket möjliggör säker och modulär verktygsanrop för LLM-program. Du får också lära dig hur du validerar anrop från slutpunkt till slutpunkt genom att integrera modellen med MCP-servern och övervaka funktionskörning i realtid via strukturerade svar.

McP (Model Context Protocol)

Som ett tillägg till KAITO-slutsatsdragning med verktygsanrop ger MCP (Model Context Protocol) ett standardiserat sätt att definiera och exponera verktyg för språkmodeller att anropa.

Verktygsanrop med MCP gör det enklare att ansluta språkmodeller till verkliga tjänster och åtgärder utan att nära koppla logik till själva modellen. I stället för att bädda in varje funktion eller API-anrop i programkoden kan du med MCP köra en fristående verktygsserver som exponerar standardiserade verktyg eller API:er som alla kompatibla LLM kan använda. Den här rena separationen innebär att du kan uppdatera verktygen oberoende av varandra, dela dem mellan modeller och hantera dem som andra mikrotjänster.

Du kan ta med dina egna (BYO) interna eller ansluta externa MCP-servrar sömlöst med din KAITO-slutsatsdragningsarbetsyta på AKS.

MCP med AI-verktygskedja (KAITO) på AKS

Du kan registrera en extern MCP-server i ett enhetligt schemabaserat format och hantera den till alla kompatibla slutpunkter för slutsatsdragning, inklusive de som distribueras med en KAITO-arbetsyta. Den här metoden möjliggör externalisering av affärslogik, avkoppling av modellbeteende från verktygskörning och återanvändning av verktyg mellan agenter, modeller och miljöer.

I den här guiden registrerar du en fördefinierad MCP-server, testar verkliga anrop som utfärdas av en LLM som körs i en KAITO-slutsatsdragningsarbetsyta och bekräftar att hela verktygskörningssökvägen (från modellprompt till MCP-funktionsanrop) fungerar som avsett. Du har flexibilitet att skala eller byta verktyg oberoende av din modell.

Förutsättningar

Ansluta till en referens-MCP-server

I det här exemplet använder vi en referens för Time MCP Server, som tillhandahåller funktioner för tidszonskonvertering och gör det möjligt för LLM:er att hämta aktuell tidsinformation och utföra konverteringar med hjälp av standardiserade namn.

Vidarebefordra KAITO-inferenstjänsten

  1. Bekräfta att KAITO-arbetsytan är klar och hämta slutpunkten för inferenstjänsten med kommandot kubectl get .

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

    Anmärkning

    Utdata kan vara en ClusterIP eller intern adress. Kontrollera vilka portar tjänsten lyssnar på. Standard-API:et för KAITO-slutsatsdragning finns på porten 80 för HTTP. Om det bara är internt kan du portforwarda lokalt.

  2. Vidarebefordra inferenstjänsten för testning med hjälp av kubectl port-forward kommandot .

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

  3. Kontrollera slutpunkten /v1/models för att bekräfta att LLM Phi-4-mini-instruct är tillgängligt genom att använda curl.

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

    Ditt Phi-4-mini-instruct OpenAI-kompatibla slutsatsdragnings-API kommer att vara tillgängligt på:

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

Bekräfta att referens-MCP-servern är giltig

Det här exemplet förutsätter att Time MCP-servern är värd vid https://mcp.example.com.

  • Bekräfta att servern returnerar verktygen med hjälp av curl.

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

    Förväntat resultat:

    {
  "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"
      }
    }
  ]
}

Ansluta MCP-servern till KAITO-arbetsytan med hjälp av API-begäran

KAITO hämtar automatiskt verktygsdefinitioner från verktyg som deklarerats i API-begäranden eller registrerats dynamiskt i inferenskörningen (vLLM + MCP-verktygsläsare).

I den här guiden skapar vi en virtuell Python-miljö för att skicka en begäran om verktygsanrop till Phi-4-mini-instruct inferrensslutpunkten genom att använda MCP-definitionen och ange servern.

  1. Definiera en ny arbetskatalog för det här testprojektet.

    mkdir kaito-mcp
cd kaito-mcp

  2. Skapa en virtuell Python-miljö och aktivera den så att alla paket är lokala för ditt testprojekt.

    uv venv
source .venv/bin/activate

  3. Använd Autogen-ramverket med öppen källkod för att testa funktionen för att anropa verktyget och installera dess beroenden:

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

  4. Skapa en testfil med namnet test.py :

    • Ansluter till TIME MCP-servern och läser in get_current_time verktyget.
    • Ansluter till din KAITO-slutsatsdragningstjänst som körs på localhost:8000.
    • Skickar en exempelfråga som "Vilken tid är det i Europa/Paris?"
    • Aktiverar automatisk markering och anrop av get_current_time verktyget.
    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. Kör testskriptet i din virtuella miljö.

    uv run test.py

    I utdata från det här testet bör du förvänta dig följande:

    • Modellen genererar korrekt ett verktygsanrop med mcp-namnet och förväntade argument.
    • Autogen skickar verktygsanropet till MCP-servern, MCP-servern kör logiken och returnerar ett resultat.
    • Phi-4-mini-instruct LLM tolkar råverktygets utdata och ger ett svar på naturligt språk.
    ---------- 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).

Experimentera med fler MCP-verktyg

Du kan testa de olika verktyg som är tillgängliga för den här MCP-servern, till exempel convert_time.

  1. Uppdatera definitionen i din test.py-fil från föregående steg till följande:adapter

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

  2. Uppdatera definitionen task för att anropa det nya verktyget. Till exempel:

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

  3. Spara och kör Python-skriptet.

    uv run test.py

    Förväntat resultat:

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

Felsökning

I följande tabell beskrivs vanliga fel vid testning av KAITO-slutsatsdragning med en extern MCP-server och hur du löser dem:

Error Så här löser du
Tool not found Kontrollera att verktygsnamnet matchar det som deklareras i /mcp/list_tools.
401 Unauthorized Om MCP-servern kräver en autentiseringstoken måste du uppdatera server_params så att den innehåller rubriker med autentiseringstoken.
connection refused Kontrollera att KAITO-slutsatsdragningstjänsten är portvidarebefordrad korrekt (t.ex. till localhost:8000).
tool call ignored Gå igenom dokumentationen för KAITO-verktygssamtal för att hitta vLLM-modeller som stöder verktygsanrop.

Nästa steg

I den här artikeln har du lärt dig hur du ansluter en KAITO-arbetsyta till en extern MCP-referensserver med hjälp av Autogen för att aktivera verktygsanrop via OpenAI-kompatibelt API. Du har också verifierat att LLM kan identifiera, anropa och integrera resultat från MCP-kompatibla verktyg i AKS. Mer information finns i följande resurser:

  • Last updated on