Megosztás:

MCP-eszközök használata ügynökökkel

A Microsoft Agent Framework támogatja a Model Context Protocol (MCP) kiszolgálókkal való integrációt, így az ügynökök hozzáférhetnek külső eszközökhöz és szolgáltatásokhoz. Ez az útmutató bemutatja, hogyan csatlakozhat egy MCP-kiszolgálóhoz, és hogyan használhatja az eszközeit az ügynökön belül.

Az Agent Framework .NET-verziója a hivatalos MCP C# SDK-val együtt használható, hogy az ügynök meghívhassa az MCP-eszközöket.

Az alábbi minta bemutatja, hogyan:

  1. Beállítás és MCP-kiszolgáló
  2. Az elérhető eszközök listájának lekérése az MCP-kiszolgálóról
  3. Alakítsa át az MCP-eszközöket "s"-vé AIFunction, hogy hozzáadhatók legyenek egy ügynökhöz
  4. Az eszközök meghívása egy ügynökből függvényhívással

MCP-ügyfél beállítása

Először hozzon létre egy MCP-ügyfelet, amely a kívánt MCP-kiszolgálóhoz csatlakozik:

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

Ebben a példában:

  • Név: Az MCP-kiszolgáló kapcsolatának rövid neve
  • Parancs: Az MCP-kiszolgáló futtatásához futtatható végrehajtható fájl (itt npx használatával futtathat Node.js csomagot)
  • Argumentumok: Az MCP-kiszolgálónak átadott parancssori argumentumok

Elérhető eszközök lekérése

Csatlakozás után kérje le az MCP-kiszolgálóról elérhető eszközök listáját:

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

A ListToolsAsync() metódus az MCP-kiszolgáló által elérhetővé tesz eszközök gyűjteményét adja vissza. Ezek az eszközök automatikusan AITool-objektumokká alakulnak, amelyeket az ügynök használhat.

Ügynök létrehozása AZ MCP-eszközökkel

Hozza létre az ügynököt, és adja meg az MCP-eszközöket az inicializálás során:

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

Összefoglalás:

  • Utasítások: Adjon meg egyértelmű utasításokat, amelyek összhangban vannak az MCP-eszközök képességeivel
  • Eszközök: Az MCP-eszközöket az objektumokra AITool veti, és elosztja azokat az eszköztömbbe
  • Az ügynök automatikusan hozzáfér az MCP-kiszolgáló által biztosított összes eszközhöz

Az ügynök használata

A konfigurálás után az ügynök automatikusan használhatja az MCP-eszközöket a felhasználói kérések teljesítéséhez:

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

Az ügynök a következőt fogja:

  1. A felhasználó kérésének elemzése
  2. Annak meghatározása, hogy mely MCP-eszközökre van szükség
  3. A megfelelő eszközök meghívása az MCP-kiszolgálón keresztül
  4. Az eredmények egységes válaszként való szintetizálása

Környezeti konfiguráció

Győződjön meg arról, hogy beállítja a szükséges környezeti változókat:

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

Erőforrás-kezelés

Az MCP-ügyfélerőforrásokat mindig megfelelően szabadítsa fel:

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

A használat await using biztosítja, hogy az MCP-ügyfélkapcsolat megfelelően legyen lezárva, amikor kimegy a hatókörből.

Gyakori MCP-kiszolgálók

Népszerű MCP-kiszolgálók:

  • @modelcontextprotocol/server-github: GitHub-adattárak és adatok elérése
  • @modelcontextprotocol/server-filesystem: Fájlrendszerműveletek
  • @modelcontextprotocol/server-sqlite: SQLite-adatbázis-hozzáférés

Minden kiszolgáló különböző eszközöket és képességeket biztosít, amelyek kibővítik az ügynök funkcióit. Ez az integráció lehetővé teszi az ügynökök számára, hogy zökkenőmentesen hozzáférjenek a külső adatokhoz és szolgáltatásokhoz, miközben fenntartják a modellkörnyezeti protokoll biztonsági és szabványosítási előnyeit.

A minta futtatásához szükséges teljes forráskód és utasítások a következő címen https://github.com/microsoft/agent-framework/tree/main/dotnet/samples/GettingStarted/ModelContextProtocol/Agent_MCP_Serverérhetők el: .

A Python Agent Framework átfogó támogatást nyújt a Model Context Protocol (MCP) kiszolgálók több kapcsolattípuson keresztüli integrálásához. Ez lehetővé teszi az ügynökök számára, hogy zökkenőmentesen hozzáférjenek a külső eszközökhöz és szolgáltatásokhoz.

MCP eszköztípusok

Az Agent Framework háromféle MCP-kapcsolatot támogat:

MCPStdioTool – Helyi MCP-kiszolgálók

A helyi folyamatként futó MCP-kiszolgálókhoz való csatlakozáshoz használható MCPStdioTool standard bemenet/kimenet használatával:

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-kiszolgálók

Az MCPStreamableHTTPTool MCP-kiszolgálókhoz http-en keresztüli csatlakozásra használható Server-Sent események használatával:

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 – WebSocket MCP-kiszolgálók

Az MCP-kiszolgálókhoz WebSocket-kapcsolatokon keresztüli csatlakozáshoz használható MCPWebsocketTool :

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

A Python Agent Framework használatával használható gyakori MCP-kiszolgálók:

  • Számológép: uvx mcp-server-calculator - Matematikai számítások
  • Fájlrendszer: uvx mcp-server-filesystem – Fájlrendszer-műveletek
  • GitHub: npx @modelcontextprotocol/server-github – GitHub-adattár hozzáférése
  • SQLite: uvx mcp-server-sqlite – Adatbázis-műveletek

Minden kiszolgáló különböző eszközöket és képességeket biztosít, amelyek kibővítik az ügynök funkcióit, miközben fenntartják a modellkörnyezeti protokoll biztonsági és szabványosítási előnyeit.

Következő lépések

Munkafolyamatok használata ügynökökként

  • Last updated on