Použití nástrojů MCP s agenty

Model Context Protocol je otevřený standard, který definuje, jak aplikace poskytují nástroje a kontextová data velkým jazykovým modelům (LLM). Umožňuje konzistentní a škálovatelnou integraci externích nástrojů do pracovních postupů modelu.

Microsoft Agent Framework podporuje integraci se servery MCP (Model Context Protocol), což umožňuje vašim agentům přístup k externím nástrojům a službám. Tato příručka ukazuje, jak se připojit k serveru MCP a používat jeho nástroje v rámci vašeho agenta.

Důležité informace o používání serverů MCP třetích stran

Vaše použití serverů s kontextem modelu podléhá podmínkám mezi vámi a poskytovatelem služeb. Když se připojíte ke službě jiné společnosti než Microsoft, některá vaše data (například obsah výzvy) se předávají službě jiné společnosti než Microsoft nebo vaše aplikace může přijímat data ze služby jiné společnosti než Microsoft. Zodpovídáte za používání služeb a dat jiných společností než Microsoft a za případné poplatky spojené s tímto použitím.

Vzdálené servery MCP, které se rozhodnete použít s nástrojem MCP popsaným v tomto článku, byly vytvořeny třetími stranami, nikoli Microsoftem. Microsoft tyto servery neotestoval ani neověřil. Microsoft nemá žádnou odpovědnost za vás nebo jiné uživatele ve vztahu k vašemu používání vzdálených serverů MCP.

Doporučujeme pečlivě zkontrolovat a sledovat servery MCP, které přidáte do aplikací založených na agentech. Doporučujeme také spoléhat se na servery hostované samotnými důvěryhodnými poskytovateli služeb než proxy servery.

Nástroj MCP umožňuje předávat vlastní hlavičky, jako jsou ověřovací klíče nebo schémata, které může vzdálený server MCP potřebovat. Doporučujeme zkontrolovat všechna data sdílená se vzdálenými servery MCP a protokolovat data pro účely auditování. Buďte obeznámeni s postupy od jiných společností než Microsoft pro uchovávání a umístění dat.

Důležité

Záhlaví můžete zadat pouze tak, že je zahrnete do tool_resources při každém spuštění. Tímto způsobem můžete do požadavku vložit klíče rozhraní API, přístupové tokeny OAuth nebo jiné přihlašovací údaje. Hlavičky, které předáte, jsou k dispozici pouze pro aktuální spuštění a nejsou uloženy.

Další informace o zabezpečení MCP najdete tady:

Osvědčené postupy zabezpečení na webu Protokolu kontextu modelu
Pochopení a zmírnění rizik zabezpečení v implementacích MCP na blogu komunity zabezpečení Microsoftu

Verzi rozhraní Agent Framework pro .NET je možné použít společně s oficiální sadou MCP C# SDK , která umožňuje vašemu agentu volat nástroje MCP.

Následující ukázka ukazuje, jak:

Nastavení a server MCP
Načtení seznamu dostupných nástrojů ze serveru MCP
Převeďte nástroje MCP na AIFunction's, aby je bylo možné přidat do agenta.
Vyvolání nástrojů z agenta pomocí volání funkce

Nastavení klienta MCP

Nejprve vytvořte klienta MCP, který se připojí k požadovanému serveru 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"],
}));

V tomto příkladu:

Název: Popisný název připojení k serveru MCP
Příkaz: Spustitelný soubor pro spuštění serveru MCP (tady pomocí npx ke spuštění balíčku Node.js)
Argumenty: Argumenty příkazového řádku předané serveru MCP

Načítání dostupných nástrojů

Po připojení načtěte seznam nástrojů dostupných ze serveru MCP:

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

Tato ListToolsAsync() metoda vrátí kolekci nástrojů, které server MCP zveřejňuje. Tyto nástroje se automaticky převedou na objekty AITool, které může používat váš agent.

Vytvoření agenta pomocí nástrojů MCP

Vytvořte agenta a během inicializace zadejte nástroje MCP:

AIAgent agent = new AzureOpenAIClient(
    new Uri(endpoint),
    new DefaultAzureCredential())
     .GetChatClient(deploymentName)
     .AsAIAgent(
         instructions: "You answer questions related to GitHub repositories only.",
         tools: [.. mcpTools.Cast<AITool>()]);

Výstraha

DefaultAzureCredential je vhodný pro vývoj, ale vyžaduje pečlivé zvážení v produkčním prostředí. V produkčním prostředí zvažte použití konkrétních přihlašovacích údajů (např ManagedIdentityCredential. ) k zabránění problémům s latencí, neúmyslnému testování přihlašovacích údajů a potenciálním bezpečnostním rizikům z náhradních mechanismů.

Klíčové body:

Pokyny: Poskytněte jasné pokyny, které odpovídají možnostem nástrojů MCP.
Nástroje: Přetypování nástrojů MCP na AITool objekty a jejich rozložení do pole nástrojů
Agent bude mít automaticky přístup ke všem nástrojům poskytovaným serverem MCP.

Použití agenta

Po nakonfigurování může váš agent automaticky používat nástroje MCP ke splnění uživatelských požadavků:

// 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 bude:

Analýza žádosti uživatele
Určení potřebných nástrojů MCP
Volání příslušných nástrojů prostřednictvím serveru MCP
Syntetizování výsledků do koherentní odpovědi

Konfigurace prostředí

Nezapomeňte nastavit požadované proměnné prostředí:

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

Správa zdrojů

Vždy správně vyřaďte prostředky klienta MCP:

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

Použití await using zajišťuje, že je připojení klienta MCP správně uzavřeno, když přestane být vymezeno.

Běžné servery MCP

Mezi oblíbené servery MCP patří:

@modelcontextprotocol/server-github: Přístup k úložištím a datům GitHubu
@modelcontextprotocol/server-filesystem: Operace systému souborů
@modelcontextprotocol/server-sqlite: Přístup k databázi SQLite

Každý server poskytuje různé nástroje a možnosti, které rozšiřují funkce agenta. Tato integrace umožňuje vašim agentům bezproblémově přistupovat k externím datům a službám a současně udržovat výhody zabezpečení a standardizace protokolu Model Context Protocol.

Úplný zdrojový kód a pokyny ke spuštění této ukázky jsou k dispozici na adrese https://github.com/microsoft/agent-framework/tree/main/dotnet/samples/GettingStarted/ModelContextProtocol/Agent_MCP_Server.

Návod

Kompletní runnable příklady najdete v ukázkách .NET .

To umožňuje vašim agentům bezproblémový přístup k externím nástrojům a službám.

Typy nástrojů MCP

Rozhraní Agent Framework podporuje tři typy připojení MCP:

MCPStdioTool – místní servery MCP

Slouží MCPStdioTool k připojení k serverům MCP, které běží jako místní procesy pomocí standardního vstupu a výstupu:

import asyncio
from agent_framework import Agent, 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,
        Agent(
            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 – Servery HTTP/SSE MCP

Slouží MCPStreamableHTTPTool k připojení k serverům MCP přes protokol HTTP pomocí událostí Server-Sent:

import asyncio
from agent_framework import Agent, 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,
        Agent(
            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 – Servery WEBSocket MCP

Slouží MCPWebsocketTool k připojení k serverům MCP přes připojení WebSocket:

import asyncio
from agent_framework import Agent, 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,
        Agent(
            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())

Oblíbené servery MCP

Běžné servery MCP, které můžete použít s architekturou agenta Pythonu:

Kalkulačka: uvx mcp-server-calculator – matematické výpočty
Systém souborů: uvx mcp-server-filesystem – Operace systému souborů
GitHub: npx @modelcontextprotocol/server-github – Přístup k úložišti GitHub
SQLite: uvx mcp-server-sqlite – Databázové operace

Každý server poskytuje různé nástroje a možnosti, které rozšiřují funkce agenta a současně udržují výhody zabezpečení a standardizace protokolu Model Context Protocol.

Kompletní příklad

# Copyright (c) Microsoft. All rights reserved.

import os

from agent_framework import Agent, MCPStreamableHTTPTool
from agent_framework.openai import OpenAIResponsesClient
from httpx import AsyncClient

"""
MCP Authentication Example

This example demonstrates how to authenticate with MCP servers using API key headers.

For more authentication examples including OAuth 2.0 flows, see:
- https://github.com/modelcontextprotocol/python-sdk/tree/main/examples/clients/simple-auth-client
- https://github.com/modelcontextprotocol/python-sdk/tree/main/examples/servers/simple-auth
"""


async def api_key_auth_example() -> None:
    """Example of using API key authentication with MCP server."""
    # Configuration
    mcp_server_url = os.getenv("MCP_SERVER_URL", "your-mcp-server-url")
    api_key = os.getenv("MCP_API_KEY")

    # Create authentication headers
    # Common patterns:
    # - Bearer token: "Authorization": f"Bearer {api_key}"
    # - API key header: "X-API-Key": api_key
    # - Custom header: "Authorization": f"ApiKey {api_key}"
    auth_headers = {
        "Authorization": f"Bearer {api_key}",
    }

    # Create HTTP client with authentication headers
    http_client = AsyncClient(headers=auth_headers)

    # Create MCP tool with the configured HTTP client
    async with (
        MCPStreamableHTTPTool(
            name="MCP tool",
            description="MCP tool description",
            url=mcp_server_url,
            http_client=http_client,  # Pass HTTP client with authentication headers
        ) as mcp_tool,
        Agent(
            client=OpenAIResponsesClient(),
            name="Agent",
            instructions="You are a helpful assistant.",
            tools=mcp_tool,
        ) as agent,
    ):
        query = "What tools are available to you?"
        print(f"User: {query}")
        result = await agent.run(query)
        print(f"Agent: {result.text}")

Zveřejnění agenta jako serveru MCP

Agenta můžete zveřejnit jako server MCP, který umožňuje jeho použití jako nástroj libovolného klienta kompatibilního s MCP (například VS Code GitHub Copilot Agents nebo jiných agentů). Název a popis agenta se stanou metadaty serveru MCP.

Zabalte agenta do nástroje funkce pomocí .AsAIFunction(), vytvořte a McpServerToolzaregistrujte ho na serveru MCP:

using System;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ModelContextProtocol.Server;

// Create the agent
AIAgent agent = new AzureOpenAIClient(
    new Uri("https://<myresource>.openai.azure.com"),
    new AzureCliCredential())
        .GetChatClient("gpt-4o-mini")
        .AsAIAgent(instructions: "You are good at telling jokes.", name: "Joker");

// Convert the agent to an MCP tool
McpServerTool tool = McpServerTool.Create(agent.AsAIFunction());

// Set up the MCP server over stdio
HostApplicationBuilder builder = Host.CreateEmptyApplicationBuilder(settings: null);
builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithTools([tool]);

await builder.Build().RunAsync();

Nainstalujte požadované balíčky NuGet:

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

Zavolejte .as_mcp_server() agenta, aby ho zpřístupnil jako server MCP:

from agent_framework.openai import OpenAIResponsesClient
from typing import Annotated

def get_specials() -> Annotated[str, "Returns the specials from the menu."]:
    return "Special Soup: Clam Chowder, Special Salad: Cobb Salad"

# Create an agent with tools
agent = OpenAIResponsesClient().as_agent(
    name="RestaurantAgent",
    description="Answer questions about the menu.",
    tools=[get_specials],
)

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

Nastavte server MCP tak, aby naslouchal standardnímu vstupu a výstupu:

import anyio
from mcp.server.stdio import stdio_server

async def run():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

if __name__ == "__main__":
    anyio.run(run)

Další kroky

Použití pracovních postupů jako agentů

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-02-13