Korzystanie z narzędzi MCP z agentami

Wersja platformy .Net programu Agent Framework może być używana razem z oficjalnym zestawem SDK C# MCP , aby umożliwić agentowi wywoływanie narzędzi MCP.

W poniższym przykładzie pokazano, jak:

1. Konfigurowanie i serwer MCP
2. Pobieranie listy dostępnych narzędzi z serwera MCP
3. Przekonwertuj narzędzia MCP na AIFunction"s", aby można je było dodać do agenta
4. Wywoływanie narzędzi z agenta przy użyciu wywoływania funkcji

Konfigurowanie klienta MCP

Najpierw utwórz klienta MCP, który łączy się z żądanym serwerem MCP:

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

W tym przykładzie:

• Nazwa: przyjazna nazwa połączenia serwera MCP
• Polecenie: plik wykonywalny do uruchomienia serwera MCP (tutaj przy użyciu narzędzia npx do uruchomienia pakietu Node.js)
• Argumenty: argumenty wiersza polecenia przekazane do serwera MCP

Pobieranie dostępnych narzędzi

Po nawiązaniu połączenia pobierz listę narzędzi dostępnych z serwera MCP:

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

Metoda ListToolsAsync() zwraca kolekcję narzędzi udostępnianych przez serwer MCP. Te narzędzia są automatycznie konwertowane na obiekty AITool, które mogą być używane przez agenta.

Tworzenie agenta za pomocą narzędzi MCP

Utwórz agenta i podaj narzędzia MCP podczas inicjowania:

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

Najważniejsze kwestie:

• Instrukcje: Podaj jasne instrukcje, które są zgodne z możliwościami narzędzi MCP
• Narzędzia: rzutowanie narzędzi MCP na AITool obiekty i rozmieszczanie ich w tablicy narzędzi
• Agent będzie automatycznie miał dostęp do wszystkich narzędzi udostępnianych przez serwer MCP

Korzystanie z agenta

Po skonfigurowaniu agent może automatycznie używać narzędzi MCP do realizacji żądań użytkowników:

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

Agent będzie:

1. Analizowanie żądania użytkownika
2. Określanie, które narzędzia MCP są potrzebne
3. Wywoływanie odpowiednich narzędzi za pośrednictwem serwera MCP
4. Syntetyzowanie wyników w spójną odpowiedź

Konfiguracja środowiska

Upewnij się, że skonfigurowaliśmy wymagane zmienne środowiskowe:

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

Zarządzanie zasobami

Zawsze prawidłowo usuwaj zasoby klienta MCP:

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

Użycie await using zapewnia prawidłowe zamknięcie połączenia klienta MCP, gdy wykracza poza zakres.

Typowe serwery MCP

Popularne serwery MCP obejmują:

• @modelcontextprotocol/server-github: Uzyskiwanie dostępu do repozytoriów i danych usługi GitHub
• @modelcontextprotocol/server-filesystem: Operacje systemu plików
• @modelcontextprotocol/server-sqlite: dostęp do bazy danych SQLite

Każdy serwer udostępnia różne narzędzia i możliwości, które rozszerzają funkcjonalność agenta. Ta integracja umożliwia agentom bezproblemowy dostęp do danych i usług zewnętrznych przy zachowaniu zalet zabezpieczeń i standaryzacji protokołu kontekstu modelu.

Pełny kod źródłowy i instrukcje uruchamiania tego przykładu są dostępne tutaj.

Struktura agentów języka Python zapewnia kompleksową obsługę integracji z serwerami protokołu MCP (Model Context Protocol) za pośrednictwem wielu typów połączeń. Dzięki temu agenci mogą bezproblemowo uzyskiwać dostęp do zewnętrznych narzędzi i usług.

Typy narzędzi MCP

Struktura agenta obsługuje trzy typy połączeń MCP:

MCPStdioTool — lokalne serwery MCP

Użyj MCPStdioTool polecenia , aby nawiązać połączenie z serwerami MCP, które działają jako procesy lokalne przy użyciu standardowych danych wejściowych/wyjściowych:

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

Użyj MCPStreamableHTTPTool polecenia , aby nawiązać połączenie z serwerami MCP za pośrednictwem protokołu HTTP za pomocą zdarzeń 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 — serwery MCP WebSocket

Użyj MCPWebsocketTool polecenia , aby nawiązać połączenie z serwerami MCP za pośrednictwem połączeń protokołu 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())

Popularne serwery MCP

Typowe serwery MCP, których można używać z platformą Agent Framework języka Python:

• Kalkulator: uvx mcp-server-calculator — Obliczenia matematyczne
• System plików: uvx mcp-server-filesystem — Operacje systemu plików
• GitHub: npx @modelcontextprotocol/server-github — dostęp do repozytorium GitHub
• SQLite: uvx mcp-server-sqlite — Operacje bazy danych

Każdy serwer udostępnia różne narzędzia i możliwości, które rozszerzają funkcjonalność agenta przy zachowaniu zalet zabezpieczeń i standaryzacji protokołu kontekstu modelu.