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, které nejsou praktikami Microsoftu, pro uchovávání a umístění dat.

Důležité

Záhlaví jednotlivých spuštění můžete zadat tak, že je zahrnete do prostředků nástrojů při každém spuštění nebo nakonfigurujete header_provider Python místních nástrojů MCP. Zkontrolujte všechny klíče rozhraní API, přístupové tokeny OAuth nebo jiné přihlašovací údaje sdílené se vzdálenými servery MCP.

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

Osvědčené postupy zabezpečení na webu Protokolu kontextu modelu
Pochopení a zmírnění bezpečnostních rizik v implementacích MCP v blogu komunity zabezpečení od 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 AIProjectClient(
    new Uri(endpoint),
    new DefaultAzureCredential())
     .AsAIAgent(
         model: deploymentName,
         instructions: "You answer questions related to GitHub repositories only.",
         tools: [.. mcpTools.Cast<AITool>()]);

Warning

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.

Tip

Ú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/02-agents/ModelContextProtocol/Agent_MCP_Server.

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

Poznámka:

Při minimálních instalacích Pythonu může být potřeba nainstalovat podporu MCP ručně. Instalace mcp --pre pro použití MCPStdioTool, MCPStreamableHTTPToolnebo Agent.as_mcp_server(). Instalace mcp[ws] --pre , pokud potřebujete MCPWebsocketTooltaké .

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(
            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.foundry import FoundryChatClient
from azure.identity.aio import AzureCliCredential

async def http_mcp_example():
    """Example using an HTTP-based MCP server."""
    async with AzureCliCredential() as credential:
        client = FoundryChatClient(credential=credential)
        async with (
            MCPStreamableHTTPTool(
                name="Microsoft Learn MCP",
                url="https://learn.microsoft.com/api/mcp",
            ) as mcp_server,
            Agent(
                client=client,
                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())

Pro ověřené koncové body HTTP použijte header_provider přihlašovací údaje, takže se přidají jenom do požadavků stejného zdroje. Během volání nástroje zprostředkovatel obdrží hodnoty z function_invocation_kwargs. V případě okolních požadavků, jako je inicializace metody handshake, nástroje nebo výzvy ke zjišťování a příkazy ping na pozadí, obdrží prázdný slovník.

Pokud server vyžaduje ověření během připojení, zachyťte nebo aktualizujte požadované přihlašovací údaje ve zprostředkovateli, a ne v závislosti pouze na hodnotách spuštění. Zprostředkovatel, který vyvolá KeyError , protože hodnota pro spuštění není k dispozici, umožní okolí požadavku pokračovat bez této hlavičky. Tento vzor funguje pouze v případě, že server povoluje neověřená inicializace a zjišťování. Zobrazují se další chyby poskytovatele.

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(
            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 asyncio
import os

from agent_framework import Agent, MCPStreamableHTTPTool
from agent_framework.openai import OpenAIChatClient

"""
MCP Authentication Example

This example demonstrates a `header_provider` that authenticates both connection-time and tool-call requests.

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."""
    mcp_server_url = os.getenv("MCP_SERVER_URL", "your-mcp-server-url")
    api_key = os.getenv("MCP_API_KEY")
    if not api_key:
        raise ValueError("MCP_API_KEY environment variable must be set.")

    async with Agent(
        client=OpenAIChatClient(),
        name="Agent",
        instructions="You are a helpful assistant.",
        tools=MCPStreamableHTTPTool(
            name="MCP tool",
            description="MCP tool description",
            url=mcp_server_url,
            header_provider=lambda _kwargs: {"Authorization": f"Bearer {api_key}"},
        ),
    ) as agent:
        query = "What tools are available to you?"
        print(f"User: {query}")
        result = await agent.run(query)
        print(f"Agent: {result.text}")

if __name__ == "__main__":
    asyncio.run(api_key_auth_example())

Typy nástrojů MCP

Balíček mcptool umožňuje agentům používat nástroje ze serverů MCP (Model Context Protocol).

Připojení k serveru MCP

import (
    "github.com/microsoft/agent-framework-go/tool/mcptool"

    "github.com/modelcontextprotocol/go-sdk/mcp"
)

session, err := mcptool.Connect(ctx, &mcp.StreamableClientTransport{
    Endpoint: "https://learn.microsoft.com/api/mcp",
})
if err != nil {
    panic(err)
}
defer session.Close()

Zobrazení seznamu a použití nástrojů MCP

tools, err := mcptool.ListTools(ctx, session)
if err != nil {
    panic(err)
}

a := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are a helpful assistant.",
    Config: agent.Config{
        Tools: tools,
    },
})

resp, err := a.RunText(ctx, "How to create an Azure storage account using az cli?").Collect()

Podporované přenosy

HTTP/SSE - mcp.StreamableClientTransport{Endpoint: "https://..."}
Stdio – Spuštění místního procesu serveru MCP

Tip

Kompletní příklad spustitelných nástrojů najdete v ukázce nástrojů MCP .

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.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ModelContextProtocol.Server;

// Create the agent
AIAgent agent = new AIProjectClient(
    new Uri("<your-foundry-project-endpoint>"),
    new DefaultAzureCredential())
        .AsAIAgent(
            model: "gpt-4o-mini",
            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();

Warning

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:

Poznámka:

Python agent.as_mcp_server() také závisí na volitelném mcp balíčku. Pokud používáte instalaci založenou na tenkých jádrech, spusťte pip install mcp --pre nejprve.

from agent_framework.openai import OpenAIChatClient
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 = OpenAIChatClient().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)

Zabalte agenta agenttool.New, zaregistrujte ho pomocí serveru MCP a mcptool.AddToolspusťte server přes stdio:

import (
    "context"

    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
    "github.com/microsoft/agent-framework-go/tool/agenttool"
    "github.com/microsoft/agent-framework-go/tool/mcptool"
    "github.com/modelcontextprotocol/go-sdk/mcp"
)

jokeAgent := foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
    Instructions: "You are good at telling jokes.",
    Config: agent.Config{
        Name:        "Joker",
        Description: "An agent that tells jokes.",
    },
})

server := mcp.NewServer(&mcp.Implementation{
    Name:    "agent-mcp-server",
    Version: "1.0.0",
}, nil)

mcptool.AddTool(server, agenttool.New(jokeAgent, agenttool.Config{}))

if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
    panic(err)
}

Tip

Kompletní příklad spustitelného příkladu najdete v ukázce nástroje MCP jako agenta .

Další kroky

Konverzace a paměť

Váš názor

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

Last updated on 2026-08-25

Použití nástrojů MCP s agenty

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

Nastavení klienta MCP

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

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

Použití agenta

Konfigurace prostředí

Správa zdrojů

Běžné servery MCP

Typy nástrojů MCP

MCPStdioTool – místní servery MCP

MCPStreamableHTTPTool – Servery HTTP/SSE MCP

MCPWebsocketTool – Servery WEBSocket MCP

Oblíbené servery MCP

Kompletní příklad

Typy nástrojů MCP

Připojení k serveru MCP

Zobrazení seznamu a použití nástrojů MCP

Podporované přenosy

Zveřejnění agenta jako serveru MCP

Další kroky

Váš názor

Další materiály