Intégrer un serveur MCP à un service d’inférence LLM sur Azure Kubernetes Service (AKS) avec le module complémentaire de chaîne d’outils IA

Dans cet article, vous connectez un serveur d’outils compatible MCP avec un espace de travail d’inférence KAITO (AI ToolChain Operator) sur Azure Kubernetes Service (AKS), ce qui permet d’appeler des outils sécurisés et modulaires pour les applications LLM. Vous allez également apprendre à valider l’appel d’outil de bout en bout en intégrant le modèle au serveur MCP et en surveillant l’exécution de la fonction en temps réel via des réponses structurées.

Protocole de contexte de modèle (MCP)

En tant qu’extension de l’inférence KAITO avec l’appel d’outils, le protocole MCP (Model Context Protocol) fournit un moyen standardisé de définir et d’exposer des outils pour les modèles de langage à appeler.

L’appel d’outils avec MCP facilite la connexion de modèles de langage à des services et actions réels sans couplage étroit de logique dans le modèle lui-même. Au lieu d’incorporer chaque fonction ou appel d’API dans votre code d’application, MCP vous permet d’exécuter un serveur d’outils autonome qui expose des outils ou API standardisés que n’importe quel LLM compatible peut utiliser. Cette séparation propre signifie que vous pouvez mettre à jour les outils indépendamment, les partager entre les modèles et les gérer comme n’importe quel autre microservice.

Vous avez la possibilité d'utiliser vos propres serveurs internes (BYO) ou de connecter des serveurs MCP externes de manière fluide avec l'espace de travail d'inférence KAITO sur AKS.

MCP avec l’opérateur de chaîne d’outils IA (KAITO) sur AKS

Vous pouvez inscrire un serveur MCP externe dans un format uniforme piloté par le schéma et le servir à n’importe quel point de terminaison d’inférence compatible, y compris ceux déployés avec un espace de travail KAITO. Cette approche permet de externaliser la logique métier, de découpler le comportement du modèle à partir de l’exécution de l’outil et de réutiliser les outils entre les agents, les modèles et les environnements.

Dans ce guide, vous inscrivez un serveur MCP prédéfini, testez les appels réels émis par un LLM s’exécutant dans un espace de travail d’inférence KAITO et confirmez l’intégralité du chemin d’exécution de l’outil (de l’invite de modèle à l’appel de fonction MCP) fonctionne comme prévu. Vous avez la possibilité de mettre à l’échelle ou d’échanger des outils indépendamment de votre modèle.

Prerequisites

Se connecter à un serveur MCP de référence

Dans cet exemple, nous allons utiliser un serveur MCP time de référence, qui fournit des fonctionnalités de conversion de fuseau horaire et permet à LLMs d’obtenir des informations d’heure actuelles et d’effectuer des conversions à l’aide de noms standardisés.

Transférer le service d’inférence KAITO

  1. Vérifiez que votre espace de travail KAITO est prêt et récupérez le point de terminaison du service d’inférence à l’aide de la kubectl get commande.

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

    Note

    La sortie peut être une ClusterIP ou une adresse interne. Vérifiez les ports sur lesquels le service écoute. L’API d’inférence KAITO par défaut est sur le port 80 pour HTTP. S’il s’agit uniquement d’un usage interne, vous pouvez effectuer un transfert de port localement.

  2. Transférer le service d’inférence à des fins de test à l’aide de la kubectl port-forward commande.

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

  3. Vérifiez le point de terminaison /v1/models pour confirmer que Phi-4-mini-instruct LLM est disponible à l'aide de curl.

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

    Votre Phi-4-mini-instruct API d’inférence compatible OpenAI sera disponible à l’adresse suivante :

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

Vérifiez que le serveur MCP de référence est valide

Cet exemple part du principe que le serveur MCP time est hébergé sur https://mcp.example.com.

  • Vérifiez que le serveur retourne des outils en utilisant curl.

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

    Sortie attendue :

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

Connecter le serveur MCP à l’espace de travail KAITO à l’aide de la demande d’API

KAITO récupère automatiquement les définitions d’outils des outils déclarés dans les requêtes d’API ou inscrits dynamiquement dans le runtime d’inférence (vLLM + chargeur d’outils MCP).

Dans ce guide, nous créons un environnement virtuel Python pour envoyer une requête d'appel d'outil au point de terminaison d'inférence en utilisant la définition MCP Phi-4-mini-instruct et en pointant vers le serveur.

  1. Définissez un nouveau répertoire de travail pour ce projet de test.

    mkdir kaito-mcp
cd kaito-mcp

  2. Créez un environnement virtuel Python et activez-le afin que tous les packages soient locaux pour votre projet de test.

    uv venv
source .venv/bin/activate

  3. Utilisez l’infrastructure Autogen open source pour tester la fonctionnalité appelant l’outil et installer ses dépendances :

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

  4. Créez un fichier de test nommé test.py :

    • Se connecte au serveur MCP Time et charge l’outil get_current_time.
    • Se connecte à votre service d'inférence KAITO à l'adresse localhost:8000.
    • Envoie un exemple de requête comme « Quelle heure est-il en Europe/Paris ? »
    • Active la sélection automatique et l’appel de l’outil get_current_time .
    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. Exécutez le script de test dans votre environnement virtuel.

    uv run test.py

    Dans la sortie de ce test, vous devez vous attendre à ce qui suit :

    • Le modèle génère correctement un appel d’outil à l’aide du nom MCP et des arguments attendus.
    • Autogen envoie l’appel de l’outil au serveur MCP, le serveur MCP exécute la logique et retourne un résultat.
    • Le Phi-4-mini-instruct LLM interprète la sortie de l’outil brut et fournit une réponse en langage naturel.
    ---------- 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).

Expérimenter avec d’autres outils MCP

Vous pouvez tester les différents outils disponibles pour ce serveur MCP, tels que convert_time.

  1. Dans votre test.py fichier de l’étape précédente, mettez à jour votre adapter définition en procédant comme suit :

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

  2. Mettez à jour votre task définition pour appeler le nouvel outil. Par exemple:

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

  3. Enregistrez et exécutez le script Python.

    uv run test.py

    Sortie attendue :

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

Résolution des problèmes

Le tableau suivant décrit les erreurs courantes lors du test de l’inférence KAITO avec un serveur MCP externe et comment les résoudre :

Erreur Guide pratique pour résoudre
Tool not found Vérifiez que le nom de votre outil correspond à celui déclaré dans /mcp/list_tools.
401 Unauthorized Si votre serveur MCP nécessite un jeton d’authentification, veillez à effectuer une mise à jour server_params pour inclure des en-têtes avec le jeton d’authentification.
connection refused Vérifiez que le service d’inférence KAITO est correctement transféré (par exemple, vers localhost:8000).
tool call ignored Passez en revue la documentation relative à l'appel d'outils de KAITO afin de repérer les modèles vLLM qui prennent en charge cet appel d'outils.

Étapes suivantes

Dans cet article, vous avez appris à connecter un espace de travail KAITO à un serveur MCP de référence externe à l’aide d’Autogen pour activer l’appel d’outils via l’API compatible OpenAI. Vous avez également validé que le LLM pouvait découvrir, appeler et intégrer des résultats à partir d’outils compatibles MCP sur AKS. Pour en savoir plus, consultez les ressources suivantes :

  • Last updated on