Partager via

Utilisation d’outils MCP avec des agents

Microsoft Agent Framework prend en charge l’intégration avec les serveurs MCP (Model Context Protocol), ce qui permet à vos agents d’accéder aux outils et services externes. Ce guide montre comment se connecter à un serveur MCP et utiliser ses outils au sein de votre agent.

La version .Net d’Agent Framework peut être utilisée avec le SDK C# MCP officiel pour permettre à votre agent d’appeler des outils MCP.

L’exemple suivant montre comment :

  1. Configurer et serveur MCP
  2. Récupérer la liste des outils disponibles à partir du serveur MCP
  3. Convertir les outils MCP en AIFunction' afin qu’ils puissent être ajoutés à un agent
  4. Appeler les outils d’un agent à l’aide de l’appel de fonction

Configuration d’un client MCP

Tout d’abord, créez un client MCP qui se connecte à votre serveur MCP souhaité :

// 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"],
}));

Dans cet exemple :

  • Nom : Nom convivial de votre connexion de serveur MCP
  • Commande : exécutable pour exécuter le serveur MCP (ici, à l’aide de npx pour exécuter un package Node.js)
  • Arguments : arguments de ligne de commande passés au serveur MCP

Récupération des outils disponibles

Une fois connecté, récupérez la liste des outils disponibles à partir du serveur MCP :

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

La ListToolsAsync() méthode retourne une collection d’outils exposés par le serveur MCP. Ces outils sont automatiquement convertis en objets AITool qui peuvent être utilisés par votre agent.

Création d’un agent avec les outils MCP

Créez votre agent et fournissez les outils MCP lors de l’initialisation :

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>()]);

Points clés :

  • Instructions : fournissez des instructions claires qui s’alignent sur les fonctionnalités de vos outils MCP
  • Outils : cassez les outils MCP en AITool objets et répartissez-les dans le tableau d’outils
  • L’agent aura automatiquement accès à tous les outils fournis par le serveur MCP

Utilisation de l’agent

Une fois configuré, votre agent peut utiliser automatiquement les outils MCP pour répondre aux demandes des utilisateurs :

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

L’agent :

  1. Analyser la demande de l’utilisateur
  2. Déterminer les outils MCP nécessaires
  3. Appeler les outils appropriés via le serveur MCP
  4. Synthétiser les résultats dans une réponse cohérente

Configuration de l’environnement

Veillez à configurer les variables d’environnement requises :

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";

Gestion des ressources

Supprimez toujours correctement les ressources clientes MCP :

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

L’utilisation await using garantit que la connexion du client MCP est correctement fermée lorsqu’elle sort de l’étendue.

Serveurs MCP courants

Les serveurs MCP populaires sont les suivants :

  • @modelcontextprotocol/server-github: Accéder aux référentiels et données GitHub
  • @modelcontextprotocol/server-filesystem: Opérations du système de fichiers
  • @modelcontextprotocol/server-sqlite: accès à la base de données SQLite

Chaque serveur fournit différents outils et fonctionnalités qui étendent les fonctionnalités de votre agent. Cette intégration permet à vos agents d’accéder en toute transparence aux données et services externes tout en conservant les avantages de sécurité et de normalisation du protocole de contexte de modèle.

Le code source complet et les instructions pour exécuter cet exemple sont disponibles ici.

Python Agent Framework fournit une prise en charge complète de l’intégration à des serveurs MCP (Model Context Protocol) via plusieurs types de connexion. Cela permet à vos agents d’accéder en toute transparence aux outils et services externes.

Types d’outils MCP

Agent Framework prend en charge trois types de connexions MCP :

MCPStdioTool - Serveurs MCP locaux

Permet MCPStdioTool de se connecter aux serveurs MCP qui s’exécutent en tant que processus locaux à l’aide de l’entrée/sortie standard :

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 - Serveurs HTTP/SSE MCP

Permet MCPStreamableHTTPTool de se connecter à des serveurs MCP via HTTP avec des événements 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 - Serveurs MCP WebSocket

Permet MCPWebsocketTool de se connecter à des serveurs MCP via des connexions 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())

Serveurs MCP courants que vous pouvez utiliser avec Python Agent Framework :

  • Calculatrice : uvx mcp-server-calculator - Calculs mathématiques
  • Système de fichiers : uvx mcp-server-filesystem - Opérations du système de fichiers
  • GitHub : npx @modelcontextprotocol/server-github - Accès au référentiel GitHub
  • SQLite : uvx mcp-server-sqlite - Opérations de base de données

Chaque serveur fournit différents outils et fonctionnalités qui étendent les fonctionnalités de votre agent tout en conservant les avantages de sécurité et de normalisation du protocole de contexte de modèle.

Étapes suivantes

Utilisation de flux de travail en tant qu’agents

  • Last updated on