Exponer un agente como herramienta MCP

En este tutorial se muestra cómo exponer un agente como una herramienta sobre el Protocolo de contexto de modelo (MCP), por lo que otros sistemas que admiten herramientas de MCP pueden usarlos.

Prerrequisitos

Para conocer los requisitos previos, consulte el paso Crear y ejecutar un agente sencillo en este tutorial.

Instalación de paquetes NuGet

Para usar Microsoft Agent Framework con Azure OpenAI, debe instalar los siguientes paquetes NuGet:

dotnet add package Azure.AI.OpenAI --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Agents.AI.OpenAI --prerelease

Para agregar también compatibilidad con el hospedaje de una herramienta a través del Protocolo de contexto de modelo (MCP), agregue los siguientes paquetes NuGet.

dotnet add package Microsoft.Extensions.Hosting --prerelease
dotnet add package ModelContextProtocol --prerelease

Exponer un agente como herramienta MCP

Puede hacer accesible un AIAgent como una herramienta MCP encapsulándolo en una función y utilizando McpServerTool. A continuación, debe registrarlo con un servidor MCP. Esto permite que cualquier cliente compatible con MCP invoque al agente como herramienta.

En primer lugar, cree un agente que será expuesto como una herramienta MCP.

using System;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using OpenAI;

AIAgent agent = new AzureOpenAIClient(
    new Uri("https://<myresource>.openai.azure.com"),
    new AzureCliCredential())
        .GetChatClient("gpt-4o-mini")
        .CreateAIAgent(instructions: "You are good at telling jokes.", name: "Joker");

Convierta el agente en una herramienta de función y, a continuación, una herramienta MCP. El nombre y la descripción del agente se usarán como nombre y descripción de la herramienta mcp.

using ModelContextProtocol.Server;

McpServerTool tool = McpServerTool.Create(agent.AsAIFunction());

Configure el servidor MCP para que escuche las solicitudes entrantes a través de la entrada y salida estándar y exponga la herramienta MCP:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ModelContextProtocol.Server;

HostApplicationBuilder builder = Host.CreateEmptyApplicationBuilder(settings: null);
builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithTools([tool]);

await builder.Build().RunAsync();

Esto iniciará un servidor MCP que exponga el agente como una herramienta sobre el protocolo MCP.

En este tutorial se muestra cómo exponer un agente como una herramienta sobre el Protocolo de contexto de modelo (MCP), por lo que otros sistemas que admiten herramientas de MCP pueden usarlos.

Prerrequisitos

Para conocer los requisitos previos e instalar paquetes de Python, consulte el paso Creación y ejecución de un agente sencillo en este tutorial.

Exponer un agente como servidor MCP

Puede exponer un agente como un servidor MCP mediante el método as_mcp_server(). Esto permite que cualquier cliente compatible con MCP invoque al agente como herramienta.

Primero, cree un agente que será expuesto como servidor MCP. También puede agregar herramientas al agente:

from typing import Annotated
from agent_framework.openai import OpenAIResponsesClient

def get_specials() -> Annotated[str, "Returns the specials from the menu."]:
    return """
        Special Soup: Clam Chowder
        Special Salad: Cobb Salad
        Special Drink: Chai Tea
        """

def get_item_price(
    menu_item: Annotated[str, "The name of the menu item."],
) -> Annotated[str, "Returns the price of the menu item."]:
    return "$9.99"

# Create an agent with tools
agent = OpenAIResponsesClient().create_agent(
    name="RestaurantAgent",
    description="Answer questions about the menu.",
    tools=[get_specials, get_item_price],
)

Convierta el agente en un servidor MCP. El nombre y la descripción del agente se usarán como metadatos del servidor MCP:

# Expose the agent as an MCP server
server = agent.as_mcp_server()

Configure el servidor MCP para que escuche las solicitudes entrantes a través de la entrada y salida estándar:

import anyio
from mcp.server.stdio import stdio_server

async def run():
    async def handle_stdin():
        async with stdio_server() as (read_stream, write_stream):
            await server.run(read_stream, write_stream, server.create_initialization_options())

    await handle_stdin()

if __name__ == "__main__":
    anyio.run(run)

Esto iniciará un servidor MCP que exponga el agente a través del protocolo MCP, lo que le permitirá ser utilizado por clientes compatibles con MCP, como agentes de GitHub Copilot de VS Code.

Pasos siguientes

Habilitación de la observabilidad para agentes