Använda MCP-verktyg med agenter

.Net-versionen av Agent Framework kan användas tillsammans med den officiella MCP C# SDK :t så att din agent kan anropa MCP-verktyg.

Följande exempel visar hur du:

1. Konfigurera och MCP-server
2. Hämta listan över tillgängliga verktyg från MCP-servern
3. Konvertera MCP-verktygen till 's så att AIFunctionde kan läggas till i en agent
4. Anropa verktygen från en agent med hjälp av funktionsanrop

Konfigurera en MCP-klient

Skapa först en MCP-klient som ansluter till din önskade MCP-server:

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

I det här exemplet:

• Namn: Ett eget namn för MCP-serveranslutningen
• Kommando: Den körbara filen för att köra MCP-servern (här använder du npx för att köra ett Node.js-paket)
• Argument: Kommandoradsargument som skickas till MCP-servern

Hämtar tillgängliga verktyg

När du är ansluten hämtar du listan över verktyg som är tillgängliga från MCP-servern:

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

Metoden ListToolsAsync() returnerar en samling verktyg som MCP-servern exponerar. Dessa verktyg konverteras automatiskt till AITool-objekt som kan användas av din agent.

Skapa en agent med MCP-verktyg

Skapa din agent och ange MCP-verktygen under initieringen:

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

Viktiga punkter:

• Instruktioner: Ge tydliga instruktioner som överensstämmer med funktionerna i mcp-verktygen
• Verktyg: Omvandla MCP-verktygen till AITool objekt och sprida dem till verktygsmatrisen
• Agenten har automatiskt åtkomst till alla verktyg som tillhandahålls av MCP-servern

Använda agenten

När agenten har konfigurerats kan den automatiskt använda MCP-verktygen för att uppfylla användarbegäranden:

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

Agenten kommer att:

1. Analysera användarens begäran
2. Avgöra vilka MCP-verktyg som behövs
3. Anropa lämpliga verktyg via MCP-servern
4. Syntetisera resultatet till ett sammanhängande svar

Miljökonfiguration

Se till att konfigurera nödvändiga miljövariabler:

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

Resurshantering

Ta alltid bort MCP-klientresurser korrekt:

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

Genom att använda await using ser du till att MCP-klientanslutningen stängs korrekt när den hamnar utanför omfånget.

Vanliga MCP-servrar

Populära MCP-servrar är:

• @modelcontextprotocol/server-github: Få åtkomst till GitHub-lagringsplatser och data
• @modelcontextprotocol/server-filesystem: Filsystemåtgärder
• @modelcontextprotocol/server-sqlite: SQLite-databasåtkomst

Varje server har olika verktyg och funktioner som utökar agentens funktioner. Med den här integreringen kan dina agenter sömlöst komma åt externa data och tjänster samtidigt som säkerhets- och standardiseringsfördelarna med modelkontextprotokollet bibehålls.

Den fullständiga källkoden och instruktionerna för att köra det här exemplet finns här.

Python Agent Framework ger omfattande stöd för integrering med MCP-servrar (Model Context Protocol) via flera anslutningstyper. På så sätt kan dina agenter få sömlös åtkomst till externa verktyg och tjänster.

MCP-verktygstyper

Agent Framework stöder tre typer av MCP-anslutningar:

MCPStdioTool – lokala MCP-servrar

Använd MCPStdioTool för att ansluta till MCP-servrar som körs som lokala processer med standardindata/utdata:

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

Använd MCPStreamableHTTPTool för att ansluta till MCP-servrar via HTTP med Server-Sent-händelser:

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://free.blessedness.top/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 – WebSocket MCP-servrar

Använd MCPWebsocketTool för att ansluta till MCP-servrar via WebSocket-anslutningar:

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

Populära MCP-servrar

Vanliga MCP-servrar som du kan använda med Python Agent Framework:

• Kalkylator: uvx mcp-server-calculator – Matematiska beräkningar
• Filsystem: uvx mcp-server-filesystem – Filsystemåtgärder
• GitHub: npx @modelcontextprotocol/server-github – Åtkomst till GitHub-lagringsplats
• SQLite: uvx mcp-server-sqlite – Databasåtgärder

Varje server har olika verktyg och funktioner som utökar agentens funktioner samtidigt som säkerhets- och standardiseringsfördelarna med Model Context Protocol bibehålls.