Een MCP-server integreren met een LLM-Inferenceservice op Azure Kubernetes Service (AKS) met de AI Toolchain-operator toevoeging.

In dit artikel verbindt u een MCP-compatibele hulpprogrammaserver met een KAITO-deductiewerkruimte (AI ToolChain Operator) in Azure Kubernetes Service (AKS), waardoor veilige en modulaire hulpprogramma's voor LLM-toepassingen worden aangeroepen. U leert ook hoe u end-to-end hulpprogramma-aanroep valideert door het model te integreren met de MCP-server en de uitvoering van realtime-functies te bewaken via gestructureerde antwoorden.

Model Context Protocol (MCP)

Als uitbreiding van KAITO-deductie met het aanroepen van hulpprogramma's biedt het MCP (Model Context Protocol) een gestandaardiseerde manier om hulpprogramma's te definiëren en beschikbaar te maken voor taalmodellen die moeten worden aangeroepen.

Het aanroepen van hulpprogramma's met MCP maakt het gemakkelijker om taalmodellen te verbinden met echte services en acties zonder nauw verband te leggen met logica in het model zelf. In plaats van elke functie of API-aanroep in te sluiten in uw toepassingscode, kunt u met MCP een zelfstandige hulpprogrammaserver uitvoeren die gestandaardiseerde hulpprogramma's of API's beschikbaar maakt die compatibel LLM kan gebruiken. Deze schone scheiding betekent dat u hulpprogramma's onafhankelijk kunt bijwerken, ze kunt delen tussen modellen en ze kunt beheren zoals elke andere microservice.

U kunt interne BYO-servers (Bring-Your-Own) gebruiken of externe MCP-servers naadloos verbinden met uw KAITO-deductiewerkruimte op AKS.

MCP met AI toolchain operator (KAITO) op AKS

U kunt een externe MCP-server registreren in een uniforme, schemagestuurde indeling en deze leveren aan elk compatibel deductie-eindpunt, inclusief de servers die zijn geïmplementeerd met een KAITO-werkruimte. Met deze aanpak kunt u bedrijfslogica externaliseren, het gedrag van het model loskoppelen van de uitvoering van hulpprogramma's en hulpprogramma's hergebruiken tussen agents, modellen en omgevingen.

In deze handleiding registreert u een vooraf gedefinieerde MCP-server, test u echte aanroepen die zijn uitgegeven door een LLM die wordt uitgevoerd in een KAITO-deductiewerkruimte en controleert u of het volledige uitvoeringspad van het hulpprogramma (van modelprompt naar mcp-functieaanroepen) werkt zoals bedoeld. U hebt flexibiliteit om hulpprogramma's onafhankelijk van uw model te schalen of te wisselen.

Vereiste voorwaarden

Verbinding maken met een referentie-MCP-server

In dit voorbeeld gebruiken we een referentietijd MCP-server, die mogelijkheden voor tijdzoneconversie biedt en LLM's in staat stelt om actuele tijdgegevens op te halen en conversies uit te voeren met behulp van gestandaardiseerde namen.

De KAITO-inferentieservice port-forwarden

  1. Controleer of uw KAITO-werkruimte gereed is en haal het eindpunt van de deductieservice op met behulp van de kubectl get opdracht.

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

    Opmerking

    De uitvoer kan een ClusterIP of intern adres zijn. Controleer op welke poort(en) de service luistert. De standaard-KAITO-deductie-API bevindt zich op poort 80 voor HTTP. Als dit alleen intern is, kunt u lokaal doorsturen.

  2. Stuur de interferentieservice door voor testen met behulp van de kubectl port-forward opdracht.

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

  3. Controleer /v1/models het eindpunt om te bevestigen dat Phi-4-mini-instruct LLM beschikbaar is met behulp van curl.

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

    Uw Phi-4-mini-instruct openAI-compatibele deductie-API is beschikbaar op:

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

Controleer of de MCP-verwijzingsserver geldig is

In dit voorbeeld wordt ervan uitgegaan dat de Time MCP-server wordt gehost op https://mcp.example.com.

  • Controleer of de server hulpprogramma's retourneert met behulp van curl.

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

    Verwachte uitvoer:

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

MCP-server verbinden met de KAITO-werkruimte met behulp van API-aanvraag

KAITO haalt automatisch hulpprogrammadefinities op uit hulpprogramma's die zijn gedeclareerd in API-aanvragen of dynamisch geregistreerd in de deductieruntime (vLLM + MCP tool loader).

In deze handleiding maken we een virtuele Python-omgeving om een aanvraag voor het aanroepen van hulpprogramma's naar het Phi-4-mini-instruct deductie-eindpunt te verzenden met behulp van de MCP-definitie en naar de server te verwijzen.

  1. Definieer een nieuwe werkmap voor dit testproject.

    mkdir kaito-mcp
cd kaito-mcp

  2. Maak een virtuele Python-omgeving en activeer deze zodat alle pakketten lokaal zijn voor uw testproject.

    uv venv
source .venv/bin/activate

  3. Gebruik het opensource Autogen-framework om de functionaliteit voor het aanroepen van hulpprogramma's te testen en de bijbehorende afhankelijkheden te installeren:

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

  4. Maak een testbestand met de naam test.py dat:

    • Maakt verbinding met de Time MCP-server en laadt get_current_time-tool.
    • Maakt verbinding met uw KAITO-inferenceservice die wordt uitgevoerd op localhost:8000.
    • Hiermee wordt een voorbeeldquery verzonden, zoals 'Hoe laat is het in Europa/Parijs?'
    • Hiermee schakelt u automatische selectie en aanroepen van het get_current_time hulpprogramma in.
    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. Voer het testscript uit in uw virtuele omgeving.

    uv run test.py

    In de uitvoer van deze test moet u het volgende verwachten:

    • Het model genereert correct een aanroep van een hulpprogramma met behulp van de MCP-naam en de verwachte argumenten.
    • Autogen verzendt de aanroep van het hulpprogramma naar de MCP-server, de MCP-server voert de logica uit en retourneert een resultaat.
    • De Phi-4-mini-instruct LLM interpreteert de ruwe uitvoer van de tool en geeft een reactie in natuurlijke taal.
    ---------- 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).

Experimenteren met meer MCP-hulpprogramma's

U kunt de verschillende hulpprogramma's testen die beschikbaar zijn voor deze MCP-server, zoals convert_time.

  1. Werk in uw test.py bestand uit de vorige stap uw adapter definitie bij naar het volgende:

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

  2. Werk uw task definitie bij om het nieuwe hulpprogramma aan te roepen. Voorbeeld:

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

  3. Sla het Python-script op en voer het uit.

    uv run test.py

    Verwachte uitvoer:

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

Probleemoplossingsproces

In de volgende tabel worden veelvoorkomende fouten beschreven bij het testen van KAITO-deductie met een externe MCP-server en hoe u deze kunt oplossen:

Fout Hoe op te lossen
Tool not found Zorg ervoor dat de naam van uw hulpprogramma overeenkomt met de naam die is gedeclareerd in /mcp/list_tools.
401 Unauthorized Als voor uw MCP-server een verificatietoken vereist is, moet u ervoor zorgen server_params bij te werken om de headers met het verificatietoken op te nemen.
connection refused Zorg ervoor dat de KAITO-deductieservice correct is doorgestuurd (bijvoorbeeld naar localhost:8000).
tool call ignored Raadpleeg de documentatie voor het aanroepen van kaito-hulpprogramma's om vLLM-modellen te vinden die ondersteuning bieden voor het aanroepen van hulpprogramma's.

Volgende stappen

In dit artikel heb je geleerd hoe je een KAITO-werkruimte verbindt met een externe referentie MCP-server om, met behulp van Autogen, het aanroepen van hulpprogramma's via de OpenAI-compatibele API in te schakelen. U hebt ook gevalideerd dat de LLM resultaten van MCP-compatibele hulpprogramma's in AKS kan detecteren, aanroepen en integreren. Zie de volgende bronnen voor meer informatie:

  • Last updated on