Exposer un agent en tant qu’outil MCP

Ce tutoriel vous montre comment exposer un agent en tant qu’outil sur le protocole MCP (Model Context Protocol), afin qu’il puisse être utilisé par d’autres systèmes qui prennent en charge les outils MCP.

Prerequisites

Pour connaître les prérequis, consultez la section Créer et exécuter une étape d’agent simple dans ce tutoriel.

Installer les packages NuGet

Pour utiliser Microsoft Agent Framework avec Azure OpenAI, vous devez installer les packages NuGet suivants :

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

Pour ajouter également la prise en charge de l’hébergement d’un outil via le protocole MCP (Model Context Protocol), ajoutez les packages NuGet suivants

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

Exposer un agent en tant qu’outil MCP

Vous pouvez exposer un AIAgent, outil MCP, en l'encapsulant dans une fonction et en utilisant McpServerTool. Vous devez ensuite l’inscrire auprès d’un serveur MCP. Cela permet à l’agent d’être appelé en tant qu’outil par n’importe quel client compatible MCP.

Tout d’abord, créez un agent que vous allez exposer en tant qu’outil 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");

Transformez l’agent en outil de fonction, puis un outil MCP. Le nom et la description de l’agent seront utilisés comme nom et description de l’outil mcp.

using ModelContextProtocol.Server;

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

Configurez le serveur MCP pour écouter les demandes entrantes sur les entrées/sorties standard et exposer l’outil 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();

Cela démarre un serveur MCP qui expose l’agent en tant qu’outil sur le protocole MCP.

Ce tutoriel vous montre comment exposer un agent en tant qu’outil sur le protocole MCP (Model Context Protocol), afin qu’il puisse être utilisé par d’autres systèmes qui prennent en charge les outils MCP.

Prerequisites

Pour connaître les prérequis et l’installation des packages Python, consultez l’étape Créer et exécuter un agent simple dans ce tutoriel.

Exposer un agent en tant que serveur MCP

Vous pouvez exposer un agent en tant que serveur MCP à l’aide de la as_mcp_server() méthode. Cela permet à l’agent d’être appelé en tant qu’outil par n’importe quel client compatible MCP.

Tout d’abord, créez un agent que vous allez exposer en tant que serveur MCP. Vous pouvez également ajouter des outils à l’agent :

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],
)

Transformez l’agent en serveur MCP. Le nom et la description de l’agent seront utilisés comme métadonnées du serveur MCP :

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

Configurez le serveur MCP pour écouter les requêtes entrantes sur les entrées/sorties standard :

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)

Cela démarre un serveur MCP qui expose l’agent sur le protocole MCP, ce qui lui permet d’être utilisé par des clients compatibles MCP tels que vs Code GitHub Copilot Agents.

Étapes suivantes

Activation de l’observabilité pour les agents