Integración de un servidor MCP con un servicio de inferencia de LLM en Azure Kubernetes Service (AKS) con el complemento del operador de cadena de herramientas de IA

En este artículo, conecta un servidor de herramientas compatible con MCP con un área de trabajo de inferencia de KAITO, el operador de cadenas de herramientas de IA, en Azure Kubernetes Service (AKS), lo que permite un llamado seguro y modular a herramientas para aplicaciones LLM. También aprenderá a validar la invocación de herramientas de un extremo a otro mediante la integración del modelo con el servidor MCP y la supervisión de la ejecución de funciones en tiempo real mediante respuestas estructuradas.

Protocolo de contexto de modelo (MCP)

Como extensión de la inferencia KAITO con llamadas a herramientas, el Protocolo de contexto de modelo (MCP) proporciona una manera estandarizada de definir y exponer herramientas para que llamen a modelos de lenguaje.

La llamada a herramientas con MCP facilita la conexión de modelos de lenguaje a servicios y acciones reales sin acoplar estrechamente la lógica al propio modelo. En lugar de insertar todas las funciones o llamadas API en el código de la aplicación, MCP le permite ejecutar un servidor de herramientas independiente que expone herramientas estandarizadas o API que cualquier LLM compatible puede usar. Esta separación limpia significa que puede actualizar herramientas de forma independiente, compartirlas entre modelos y administrarlas como cualquier otro microservicio.

Puede utilizar sus propios servidores MCP internos (BYO) o conectar servidores MCP externos de forma fluida con el área de trabajo de inferencia KAITO en AKS.

MCP con el operador de cadena de herramientas de IA (KAITO) en AKS

Puede registrar un servidor MCP externo en un formato uniforme controlado por esquemas y servirlo a cualquier punto de conexión de inferencia compatible, incluidos los implementados con un área de trabajo KAITO. Este enfoque permite externalizar la lógica de negocios, desacoplar el comportamiento del modelo de ejecución de herramientas y reutilizar herramientas entre agentes, modelos y entornos.

En esta guía, registrará un servidor MCP predefinido, probará las llamadas reales emitidas por un LLM que se ejecuta en un área de trabajo de inferencia KAITO y confirmará que todo el flujo de ejecución de la herramienta (desde el prompt del modelo hasta la invocación de la función MCP) funciona según lo previsto. Tiene flexibilidad para escalar o intercambiar herramientas independientemente del modelo.

Prerrequisitos

Conexión a un servidor MCP de referencia

En este ejemplo, usaremos un servidor MCP de tiempo de referencia, que proporciona funcionalidades de conversión de zona horaria y permite que los LLM obtengan información de hora actual y realicen conversiones mediante nombres estandarizados.

Reenvío por puerto del servicio de inferencia KAITO

  1. Confirme que el área de trabajo KAITO está lista y recupere el endpoint del servicio de inferencia mediante el comando kubectl get.

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

    Nota:

    La salida podría ser una dirección ClusterIP o una dirección interna. Compruebe en qué puertos escucha el servicio. La API de inferencia KAITO predeterminada está en el puerto 80 para HTTP. Si solo es interno, puede reenviar localmente.

  2. Reenvíe el servicio de inferencia para realizar pruebas mediante el kubectl port-forward comando .

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

  3. Compruebe el punto de conexión /v1/models para confirmar que Phi-4-mini-instruct LLM está disponible mediante curl.

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

    La Phi-4-mini-instruct API de inferencia compatible con OpenAI estará disponible en:

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

Confirmar que el servidor MCP de referencia es válido

En este ejemplo se supone que el servidor de tiempo MCP se aloja en https://mcp.example.com.

  • Confirme que el servidor devuelve herramientas mediante curl.

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

    Resultado esperado:

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

Conexión del servidor MCP al área de trabajo KAITO mediante la solicitud de API

KAITO captura automáticamente las definiciones de herramientas de las herramientas declaradas en solicitudes de API o registradas dinámicamente dentro del entorno de ejecución de inferencia (vLLM + cargador de herramientas MCP).

En esta guía, creamos un entorno virtual de Python para enviar una solicitud de llamada de herramientas al Phi-4-mini-instruct punto de conexión de inferencia mediante la definición de MCP y apuntando al servidor.

  1. Defina un nuevo directorio de trabajo para este proyecto de prueba.

    mkdir kaito-mcp
cd kaito-mcp

  2. Cree un entorno virtual de Python y actívelo para que todos los paquetes sean locales para el proyecto de prueba.

    uv venv
source .venv/bin/activate

  3. Use el marco autogen de código abierto para probar la funcionalidad de llamada de la herramienta e instalar sus dependencias:

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

  4. Cree un archivo de prueba denominado test.py que:

    • Se conecta al servidor Time MCP y carga la herramienta get_current_time.
    • Se conecta al servicio de inferencia KAITO que se ejecuta en localhost:8000.
    • Envía una consulta de ejemplo como "¿Qué hora es en Europa/París?"
    • Habilita la selección automática y la llamada de la get_current_time herramienta.
    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. Ejecute el script de prueba en el entorno virtual.

    uv run test.py

    En la salida de esta prueba, debe esperar lo siguiente:

    • El modelo genera correctamente una llamada de herramienta mediante el nombre mcP y los argumentos esperados.
    • Autogen envía la llamada de herramienta al servidor MCP, el servidor MCP ejecuta la lógica y devuelve un resultado.
    • El LLM Phi-4-mini-instruct interpreta la salida de la herramienta sin procesar y proporciona una respuesta en lenguaje natural.
    ---------- 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).

Experimentar con más herramientas de MCP

Puede probar las distintas herramientas disponibles para este servidor MCP, como convert_time.

  1. test.py En el archivo del paso anterior, actualice la adapter definición a lo siguiente:

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

  2. Actualice la task definición para invocar la nueva herramienta. Por ejemplo:

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

  3. Guarde y ejecute el script de Python.

    uv run test.py

    Resultado esperado:

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

Solución de problemas

En la tabla siguiente se describen los errores comunes al probar la inferencia KAITO con un servidor MCP externo y cómo resolverlos:

Error Cómo resolver
Tool not found Asegúrese de que el nombre de la herramienta coincida con el declarado en /mcp/list_tools.
401 Unauthorized Si el servidor MCP requiere un token de autenticación, asegúrese de actualizar server_params para incluir encabezados con el token de autenticación.
connection refused Asegúrese de que el servicio de inferencia KAITO se reenvía correctamente (por ejemplo, a localhost:8000).
tool call ignored Revise la documentación de llamada de la herramienta KAITO para buscar modelos de vLLM que admitan llamadas a herramientas.

Pasos siguientes

En este artículo, ha aprendido a conectar un área de trabajo KAITO a un servidor MCP de referencia externo mediante Autogen para habilitar la llamada a herramientas a través de la API compatible con OpenAI. También has validado que el LLM puede descubrir, invocar e integrar resultados de herramientas compatibles con MCP en AKS. Para obtener más información, consulte los siguientes recursos:

  • Last updated on