Uso de herramientas de MCP con agentes

La versión de .Net de Agent Framework se puede usar junto con el SDK oficial de C# de MCP para permitir que el agente llame a las herramientas de MCP.

En el ejemplo siguiente se muestra cómo:

1. Configuración y servidor MCP
2. Recuperar la lista de herramientas disponibles del servidor MCP
3. Convertir las herramientas de MCP en AIFunctionpara que se puedan agregar a un agente
4. Invocación de las herramientas desde un agente mediante la llamada a funciones

Configuración de un cliente MCP

En primer lugar, cree un cliente MCP que se conecte al servidor MCP deseado:

// Create an MCPClient for the GitHub server
await using var mcpClient = await McpClientFactory.CreateAsync(new StdioClientTransport(new()
{
    Name = "MCPServer",
    Command = "npx",
    Arguments = ["-y", "--verbose", "@modelcontextprotocol/server-github"],
}));

En este ejemplo:

• Nombre: nombre descriptivo para la conexión del servidor MCP
• Comando: ejecutable para ejecutar el servidor MCP (aquí mediante npx para ejecutar un paquete de Node.js)
• Argumentos: argumentos de línea de comandos pasados al servidor MCP

Recuperación de herramientas disponibles

Una vez conectado, recupere la lista de herramientas disponibles en el servidor MCP:

// Retrieve the list of tools available on the GitHub server
var mcpTools = await mcpClient.ListToolsAsync().ConfigureAwait(false);

El ListToolsAsync() método devuelve una colección de herramientas que expone el servidor MCP. Estas herramientas se convierten automáticamente en objetos AITool que el agente puede usar.

Creación de un agente con herramientas de MCP

Cree el agente y proporcione las herramientas de MCP durante la inicialización:

AIAgent agent = new AzureOpenAIClient(
    new Uri(endpoint),
    new AzureCliCredential())
     .GetChatClient(deploymentName)
     .CreateAIAgent(
         instructions: "You answer questions related to GitHub repositories only.", 
         tools: [.. mcpTools.Cast<AITool>()]);

Puntos clave:

• Instrucciones: Proporcione instrucciones claras que se adapten a las funcionalidades de las herramientas de MCP.
• Herramientas: convertir las herramientas de MCP en AITool objetos y distribuirlas en la matriz de herramientas
• El agente tendrá acceso automáticamente a todas las herramientas proporcionadas por el servidor MCP.

Uso del agente

Una vez configurado, el agente puede usar automáticamente las herramientas de MCP para satisfacer las solicitudes de usuario:

// Invoke the agent and output the text result
Console.WriteLine(await agent.RunAsync("Summarize the last four commits to the microsoft/semantic-kernel repository?"));

El agente hará lo siguiente:

1. Análisis de la solicitud del usuario
2. Determinar qué herramientas de MCP son necesarias
3. Llamar a las herramientas adecuadas a través del servidor MCP
4. Síntesis de los resultados en una respuesta coherente

Configuración del entorno

Asegúrese de configurar las variables de entorno necesarias:

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? 
    throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";

Administración de recursos

Elimine siempre correctamente los recursos de cliente de MCP:

await using var mcpClient = await McpClientFactory.CreateAsync(...);

El uso await using garantiza que la conexión de cliente MCP se cierre correctamente cuando se quede fuera del ámbito.

Servidores MCP comunes

Entre los servidores MCP populares se incluyen:

• @modelcontextprotocol/server-github: acceso a repositorios y datos de GitHub
• @modelcontextprotocol/server-filesystem: Operaciones del sistema de archivos
• @modelcontextprotocol/server-sqlite: acceso a la base de datos de SQLite

Cada servidor proporciona diferentes herramientas y funcionalidades que amplían la funcionalidad del agente. Esta integración permite a los agentes acceder sin problemas a los datos y servicios externos, a la vez que mantiene las ventajas de seguridad y normalización del protocolo de contexto de modelo.

El código fuente completo e instrucciones para ejecutar este ejemplo está disponible aquí.

El marco del agente de Python proporciona compatibilidad completa para la integración con servidores de Protocolo de contexto de modelo (MCP) a través de varios tipos de conexión. Esto permite a los agentes acceder sin problemas a herramientas y servicios externos.

Tipos de herramientas de MCP

Agent Framework admite tres tipos de conexiones MCP:

MCPStdioTool: servidores MCP locales

Use MCPStdioTool para conectarse a servidores MCP que se ejecutan como procesos locales mediante la entrada y salida estándar:

import asyncio
from agent_framework import ChatAgent, MCPStdioTool
from agent_framework.openai import OpenAIChatClient

async def local_mcp_example():
    """Example using a local MCP server via stdio."""
    async with (
        MCPStdioTool(
            name="calculator", 
            command="uvx", 
            args=["mcp-server-calculator"]
        ) as mcp_server,
        ChatAgent(
            chat_client=OpenAIChatClient(),
            name="MathAgent",
            instructions="You are a helpful math assistant that can solve calculations.",
        ) as agent,
    ):
        result = await agent.run(
            "What is 15 * 23 + 45?", 
            tools=mcp_server
        )
        print(result)

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

MCPStreamableHTTPTool: servidores MCP HTTP/SSE

Use MCPStreamableHTTPTool para conectarse a servidores MCP a través de HTTP con eventos de Server-Sent:

import asyncio
from agent_framework import ChatAgent, MCPStreamableHTTPTool
from agent_framework.azure import AzureAIAgentClient
from azure.identity.aio import AzureCliCredential

async def http_mcp_example():
    """Example using an HTTP-based MCP server."""
    async with (
        AzureCliCredential() as credential,
        MCPStreamableHTTPTool(
            name="Microsoft Learn MCP",
            url="https://learn.microsoft.com/api/mcp",
            headers={"Authorization": "Bearer your-token"},
        ) as mcp_server,
        ChatAgent(
            chat_client=AzureAIAgentClient(async_credential=credential),
            name="DocsAgent",
            instructions="You help with Microsoft documentation questions.",
        ) as agent,
    ):
        result = await agent.run(
            "How to create an Azure storage account using az cli?",
            tools=mcp_server
        )
        print(result)

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

MCPWebsocketTool: servidores MCP de WebSocket

Use MCPWebsocketTool para conectarse a servidores MCP a través de conexiones de WebSocket:

import asyncio
from agent_framework import ChatAgent, MCPWebsocketTool
from agent_framework.openai import OpenAIChatClient

async def websocket_mcp_example():
    """Example using a WebSocket-based MCP server."""
    async with (
        MCPWebsocketTool(
            name="realtime-data",
            url="wss://api.example.com/mcp",
        ) as mcp_server,
        ChatAgent(
            chat_client=OpenAIChatClient(),
            name="DataAgent",
            instructions="You provide real-time data insights.",
        ) as agent,
    ):
        result = await agent.run(
            "What is the current market status?",
            tools=mcp_server
        )
        print(result)

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

Servidores MCP populares

Servidores MCP comunes que puede usar con python Agent Framework:

• Calculadora: uvx mcp-server-calculator - Cálculos matemáticos
• Sistema de archivos: uvx mcp-server-filesystem - Operaciones del sistema de archivos
• GitHub: npx @modelcontextprotocol/server-github - Acceso al repositorio de GitHub
• SQLite: uvx mcp-server-sqlite - Operaciones de base de datos

Cada servidor proporciona diferentes herramientas y funcionalidades que amplían la funcionalidad del agente al tiempo que mantienen las ventajas de seguridad y normalización del protocolo de contexto de modelo.