Verwenden von MCP-Tools mit Agents

Das Modellkontextprotokoll ist ein offener Standard, der definiert, wie Anwendungen Tools und Kontextdaten für große Sprachmodelle (LLMs) bereitstellen. Sie ermöglicht eine konsistente, skalierbare Integration externer Tools in Modellworkflows.

Microsoft Agent Framework unterstützt die Integration mit MCP-Servern (Model Context Protocol), sodass Ihre Agents auf externe Tools und Dienste zugreifen können. In diesem Handbuch wird gezeigt, wie Sie eine Verbindung mit einem MCP-Server herstellen und dessen Tools innerhalb Ihres Agents verwenden.

Überlegungen zur Verwendung von MCP-Servern von Drittanbietern

Ihre Verwendung von Modellkontextprotokollservern unterliegt den Bedingungen zwischen Ihnen und dem Dienstanbieter. Wenn Sie eine Verbindung mit einem Nicht-Microsoft-Dienst herstellen, werden einige Ihrer Daten (z. B. Aufforderungsinhalte) an den Nicht-Microsoft-Dienst übergeben, oder Ihre Anwendung empfängt möglicherweise Daten vom Nicht-Microsoft-Dienst. Sie sind für Ihre Nutzung von Nicht-Microsoft-Diensten und -Daten sowie für alle Gebühren verantwortlich, die dieser Nutzung zugeordnet sind.

Die mcP-Remoteserver, die Sie mit dem in diesem Artikel beschriebenen MCP-Tool verwenden, wurden von Drittanbietern erstellt, nicht von Microsoft. Microsoft hat diese Server nicht getestet oder überprüft. Microsoft hat keine Verantwortung für Sie oder andere Personen in Bezug auf Ihre Nutzung von Remote-MCP-Servern.

Es wird empfohlen, die MCP-Server, die Sie Ihren Agent Framework-basierten Anwendungen hinzufügen, sorgfältig zu überprüfen und nachzuverfolgen. Außerdem wird empfohlen, dass Sie sich auf Server verlassen, die von vertrauenswürdigen Dienstanbietern selbst und nicht von Proxys gehostet werden.

Mit dem MCP-Tool können Sie benutzerdefinierte Header wie Authentifizierungsschlüssel oder Schemas übergeben, die ein MCP-Remoteserver möglicherweise benötigt. Es wird empfohlen, alle Daten, die für Remote-MCP-Server freigegeben werden, zu überprüfen und die Daten zu Auditzwecken zu protokollieren. Beachten Sie Nicht-Microsoft-Praktiken für die Aufbewahrung und den Standort von Daten.

Important

Sie können Kopfzeilen pro Ausführung angeben, indem Sie sie in Die Toolressourcen bei jeder Ausführung einschließen oder ein header_provider on Python lokalen MCP-Tools konfigurieren. Überprüfen Sie alle API-Schlüssel, OAuth-Zugriffstoken oder andere Anmeldeinformationen, die für Remote-MCP-Server freigegeben wurden.

Weitere Informationen zur MCP-Sicherheit finden Sie unter:

Die .NET-Version von Agent Framework kann zusammen mit dem offiziellen MCP C#-SDK verwendet werden, damit Ihr Agent MCP-Tools aufrufen kann.

Das folgende Beispiel zeigt, wie Sie:

  1. Einrichten und MCP-Server
  2. Abrufen der Liste der verfügbaren Tools vom MCP-Server
  3. Konvertieren der MCP-Tools in AIFunction's, damit sie einem Agent hinzugefügt werden können
  4. Aufrufen der Tools von einem Agent mithilfe von Funktionsaufrufen

Einrichten eines MCP-Clients

Erstellen Sie zunächst einen MCP-Client, der eine Verbindung mit Ihrem gewünschten MCP-Server herstellt:

using ModelContextProtocol.Client;

// Create an MCPClient for the GitHub server
await using var mcpClient = await McpClient.CreateAsync(new StdioClientTransport(new()
{
    Name = "MCPServer",
    Command = "npx",
    Arguments = ["-y", "--verbose", "@modelcontextprotocol/server-github"],
}));

In diesem Beispiel:

  • Name: Ein Anzeigename für Ihre MCP-Serververbindung
  • Befehl: Die ausführbare Datei zum Ausführen des MCP-Servers (hier mithilfe von npx zum Ausführen eines Node.js-Pakets)
  • Argumente: Befehlszeilenargumente, die an den MCP-Server übergeben werden

Abrufen verfügbarer Tools

Rufen Sie nach der Verbindung die Liste der tools ab, die vom MCP-Server verfügbar sind:

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

Die ListToolsAsync() Methode gibt eine Sammlung von Tools zurück, die der MCP-Server verfügbar macht. Diese Tools werden automatisch in AITool-Objekte konvertiert, die von Ihrem Agent verwendet werden können.

Erstellen eines Agents mit MCP-Tools

Erstellen Sie Ihren Agent, und stellen Sie während der Initialisierung die MCP-Tools bereit:

using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

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

Warnung

DefaultAzureCredential ist praktisch für die Entwicklung, erfordert aber sorgfältige Überlegungen in der Produktion. Berücksichtigen Sie in der Produktion die Verwendung bestimmter Anmeldeinformationen (z. B. ManagedIdentityCredential), um Latenzprobleme, unbeabsichtigte Abfragen von Anmeldeinformationen und potenzielle Sicherheitsrisiken durch Ausweichmechanismen zu vermeiden.

Wichtige Punkte:

  • Anweisungen: Stellen Sie klare Anweisungen bereit, die den Funktionen Ihrer MCP-Tools entsprechen
  • Tools: Umwandeln der MCP-Tools in AITool Objekte und Verteilen in das Toolsarray
  • Der Agent hat automatisch Zugriff auf alle Tools, die vom MCP-Server bereitgestellt werden.

Den Agent verwenden

Nach der Konfiguration kann Ihr Agent die MCP-Tools automatisch verwenden, um Benutzeranforderungen zu erfüllen:

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

Der Agent führt folgende Aktionen aus:

  1. Analysieren der Anforderung des Benutzers
  2. Ermitteln, welche MCP-Tools erforderlich sind
  3. Aufrufen der entsprechenden Tools über den MCP-Server
  4. Synthetisieren der Ergebnisse in eine kohärente Antwort

Umgebungskonfiguration

Stellen Sie sicher, dass Sie die erforderlichen Umgebungsvariablen einrichten:

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

Ressourcenverwaltung

Immer ordnungsgemäß verwerfen MCP-Clientressourcen:

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

Die Verwendung await using stellt sicher, dass die MCP-Clientverbindung ordnungsgemäß geschlossen wird, wenn sie nicht mehr gültig ist.

Allgemeine MCP-Server

Beliebte MCP-Server umfassen:

  • @modelcontextprotocol/server-github: Zugreifen auf GitHub-Repositorys und -Daten
  • @modelcontextprotocol/server-filesystem: Dateisystemvorgänge
  • @modelcontextprotocol/server-sqlite: SQLite-Datenbankzugriff

Jeder Server bietet verschiedene Tools und Funktionen, die die Funktionalität Ihres Agents erweitern. Diese Integration ermöglicht Es Ihren Agents, nahtlos auf externe Daten und Dienste zuzugreifen und gleichzeitig die Sicherheits- und Standardisierungsvorteile des Modellkontextprotokolls aufrechtzuerhalten.

Tip

Der vollständige Quellcode und anweisungen zum Ausführen dieses Beispiels finden Sie unter https://github.com/microsoft/agent-framework/tree/main/dotnet/samples/02-agents/ModelContextProtocol/Agent_MCP_Server.

Auf diese Weise können Ihre Agents nahtlos auf externe Tools und Dienste zugreifen.

Note

Bei minimalen Python-Installationen muss die MCP-Unterstützung möglicherweise manuell installiert werden. Installierenmcp>=2.2.0,<3, um zu verwendenMCPStdioTool, oder MCPStreamableHTTPToolAgent.as_mcp_server().

MCP-Tooltypen

Agent Framework unterstützt lokale Stdio- und Remotestreamable HTTP-Verbindungen.

MCPStdioTool - Lokale MCP-Server

Wird MCPStdioTool verwendet, um eine Verbindung mit MCP-Servern herzustellen, die als lokale Prozesse mit Standardeingabe/Ausgabe ausgeführt werden:

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

Wird MCPStreamableHTTPTool verwendet, um eine Verbindung mit MCP-Servern über HTTP mit Server-Sent-Ereignissen herzustellen:

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

Verbindungsbesitz auswählen

Übergeben command= oder url= Erstellen eines frameworkeigenen MCP-Clients auf hoher Ebene. Das Agent-Framework wechselt, stellt eine Erneute Verbindung her und schließt diesen Client. Der MCP SDK-Client bietet Protokollaushandlung, Multi-Roundtrip-Anforderungen, Antwortzwischenspeicherung und Abonnements.

Wenn die Anwendung den MCP-Client konfigurieren oder wiederverwenden muss, geben Sie einen mcp.Client ersten ein, und übergeben Sie ihn durch mcp_client=:

from agent_framework import MCPStreamableHTTPTool
from mcp import Client

async with (
    Client(server="https://learn.microsoft.com/api/mcp") as mcp_client,
    MCPStreamableHTTPTool(
        name="Microsoft Learn MCP",
        mcp_client=mcp_client,
    ) as mcp_tool,
):
    result = await agent.run(
        "Find the Agent Framework documentation.",
        tools=mcp_tool,
    )

Lassen Sie den anrufereigenen Client für den vollständigen Agent oder Workflow ausgeführt. Agent Framework gibt es nicht ein, schließt, ersetzt oder neu. Kombinieren Sie keine mcp_client= Optionen für url=Transportclients, command=Header oder Transportclients, die eine Verbindung konfigurieren, die der Aufrufer bereits besitzt.

Vom Aufrufer bereitgestellte Objekte auf niedriger Ebene ClientSession bleiben ein veralteter Kompatibilitätspfad. Sie erhalten keine allgemeine Reaktionszwischenspeicherung oder automatische Multi-Roundtrip-Behandlung. MCPTool.session ist nur für diesen veralteten Pfad aussagekräftig und gibt für Clientverbindungen auf hoher Ebene zurück None .

Der HTTP-Client, der erstellt wird, MCPStreamableHTTPTool speichert keine Antwortcookies. Wenn der Server Cookies für Authentifizierung, Sitzungen oder Lastenausgleichsaffinität benötigt, übergeben Sie eine konfigurierte httpx.AsyncClient Überführung http_client=. Der bereitgestellte Kunde behält sein Cookieverhalten bei und bleibt im Besitz des Anrufers. Beschränken Sie einen cookiebasierten Client und seine MCP-Toolsitzung auf einen authentifizierten Prinzipal.

Verwenden Sie static_headers für authentifizierte HTTP-Endpunkte feste Anmeldeinformationen oder header_provider für werte, die von jeder Ausführung abgeleitet wurden. Beide Pfade fügen Kopfzeilen nur zu Anforderungen für den konfigurierten Ursprung hinzu und entfernen sie aus ursprungsübergreifenden Umleitungen. Feste Header werden kopiert, wenn das Tool erstellt wird und nicht gleichzeitige Aufrufe serialisieren. Wenn beide Optionen denselben Header bereitstellen, hat der dynamische Wert vorrang header_provider .

Empfängt während generierter Toolaufrufe header_provider nur den Host function_invocation_kwargsder Ausführung. Sie empfängt keine vom Modell bereitgestellten Toolargumente, auch wenn ein Modellargument denselben Namen hat. Ein direkter call_tool(...) Aufruf übergibt die vom Aufrufer bereitgestellten Schlüsselwortargumente an den Anbieter. Modellwerte können weiterhin Vorrang in den getrennt zusammengeführten Ausgehenden Toolargumenten haben, sie steuern jedoch keine Authentifizierungsheader.

Die festen und dynamischen Header bilden zusammen die effektive Identität der HTTP-Sitzung. Kopfzeilennamen werden ohne Groß-/Kleinschreibung verglichen, während bei Werten die Groß-/Kleinschreibung beachtet wird. Laufzeitstichwortargumente sind auch für ausgehende Toolargumente geeignet, wenn das Serverschema denselben Namen zulässt. Um Anmeldeinformationen aus Toolargumenten herauszuhalten, erfassen Sie sie im Anbieter über eine Schließung oder , verwenden static_headersoder ContextVargeben Sie einen benutzerdefinierten HTTP-Client an.

Framework-eigene Clients binden diese effektive Identität, wenn sie eine Verbindung herstellen. Wenn eine spätere Ausführung eine andere Identität erzeugt, stellt das Tool vor dem Senden des Aufrufs wieder eine Verbindung her und aktualisiert das sitzungsbasierte Tool und fordert die Ermittlung auf. Initialisieren, Ermitteln, Hintergrundping und andere Anforderungen für die Verbindungslebensdauer verwenden weiterhin die an diese Sitzung gebundenen Header.

Vom Anrufer bereitgestellte Clients bleiben im Besitz des Anrufers. Da der Wrapper keine unbekannte Identität für diese Clients herstellen oder erneut verbinden kann, wird die dynamische Headerauflösung mit einer unbekannten Identität abgelehnt. Eine geänderte Identität wird ebenfalls abgelehnt; verwenden Sie eine separate vom Framework verwaltete Toolinstanz.

Wenn das Tool vor einer Ausführung eifrig eine Verbindung herstellt, empfängt der Anbieter eine leere Zuordnung für Verbindungslebensdauer-Anforderungen. Erfassen oder aktualisieren Sie für diesen Fall eine Konstruktionszeit-Anmeldeinformationen im Anbieter. Wenn zur Laufzeit nur anmeldeinformationen eingehen, übergeben Sie das nicht verbundene Tool run(tools=[...]) , function_invocation_kwargs sodass die Verbindung hergestellt wird.

A KeyError from the provider is tolerd only when no run seeded the connection, and the request continues without provider headers. Nach einer Ausführung ist die Verbindung ein fehlender Schlüssel ein Konfigurationsfehler und die Ausnahme wird angezeigt.

Auswählen von Tools nach eindeutigem Namen

Verwenden Sie beim Festlegen allowed_tools oder Auflisten von approval_modeTools den Namen des unformatierten Remotetools oder einen eindeutigen präfixierten Namen. Wenn ein konfigurierter Name nach der Normalisierung mehreren rohen Remotenamen entspricht, löst Agent Framework aus ToolExecutionException. Verwenden Sie einen exakten unformatierten Namen, oder ändern tool_name_prefix Sie ihn, um die lokalen Namen eindeutig zu machen.

MCP-Aufgaben und Sampling

Warnung

Agent Framework unterstützt derzeit die MCP-Aufgabenerweiterung nicht, da die MCP-Python SDK 2.x-Laufzeit sie nicht verfügbar macht. Remove MCPTaskOptions and task_options; non-null values are ignored with a warning.

Das vom Server initiierte MCP-Sampling ist ab VERSION 2026-07-28 veraltet und sampling_callback wird nicht später als 2027-07-28 entfernt. Erstellen Sie keine neuen Integrationen für dieses Feature. MCP-Server sollten Modellanbieter-APIs direkt aufrufen.

Steuern der Aufbewahrung von Hostnutzlasten

Wenn ein Hosttransport, z. B. AG-UI, ein MCP-Toolergebnis verbraucht, behält Agent Framework das vollständige JSON-sichere Ergebnis getrennt vom analysierten Modellwert bei. Auf diese Weise kann der Host Felder empfangen, z structuredContent . B. ohne Host-only-Daten zum Modellverlauf hinzuzufügen.

Wird tool_result_content für jeden MCP-Transport verwendet, um den modell sichtbaren Wert auszuwählen, wenn ein Ergebnis beides content enthält und structuredContent:

Wert Modell sichtbares Ergebnis
structured_first Wird structuredContent verwendet, wenn vorhanden, andernfalls content. Dies ist der Standardwert.
content_first Verwendet nicht erwendige content, andernfalls structuredContent.
content_only structuredContentIgnoriert .
structured_only contentIgnoriert .
both Fügt nach den content Blöcken serialisiert structuredContent an.

Diese Auswahl ändert die beibehaltene Hostnutzlast nicht. parse_tool_results setzt die Auswahlrichtlinie außer Kraft.

Jeder MCP-Transport beschränkt standardmäßig eine beibehaltene Hostnutzlast auf 1 MiB. Überdimensionierte Nutzlasten werden aus dem Hostkanal weggelassen, während das analysierte Ergebnis weiterhin das Modell erreicht. Legen Sie einen anderen positiven Bytegrenzwert für den Transport fest, oder verwenden None Sie nur, wenn der nachgeschaltete Host seine eigene Grenze anwendet:

mcp_server = MCPStreamableHTTPTool(
    name="Microsoft Learn MCP",
    url="https://learn.microsoft.com/api/mcp",
    max_host_payload_size_bytes=256 * 1024,
)

Important

DER MCP-WebSocket-Transport wird in Python 1.23 entfernt. Das MCPWebsocketTool Kompatibilitätssymbol wird ausgelöst, wenn es verwendet wird. Migrieren Sie Remoteserver zu streambarem HTTP und verwenden Sie MCPStreamableHTTPTool.

Allgemeine MCP-Server, die Sie mit Python Agent Framework verwenden können:

  • Rechner: uvx mcp-server-calculator - Mathematische Berechnungen
  • Dateisystem: uvx mcp-server-filesystem - Dateisystemvorgänge
  • GitHub: npx @modelcontextprotocol/server-github - GitHub-Repositoryzugriff
  • SQLite: uvx mcp-server-sqlite - Datenbankvorgänge

Jeder Server bietet verschiedene Tools und Funktionen, die die Funktionalität Ihres Agents erweitern und gleichzeitig die Sicherheits- und Standardisierungsvorteile des Modellkontextprotokolls beibehalten.

Vollständiges Beispiel

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

MCP-Tooltypen

Mit dem mcptool Paket können Agents Tools von MCP-Servern (Model Context Protocol) verwenden.

Herstellen einer Verbindung mit einem MCP-Server

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

Auflisten und Verwenden von MCP-Tools

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

Unterstützte Transporte

  • Streambares HTTP - mcp.StreamableClientTransport{Endpoint: "https://..."}
  • Stdio – Starten eines lokalen MCP-Serverprozesses

Geben Sie für authentifizierte HTTP-Endpunkte einen anwendungskonfigurierten Client über mcp.StreamableClientTransport.HTTPClient. Verwalten sie die Aktualisierung von Anmeldeinformationen und die Headerweiterleitung in diesem Client. Im Gegensatz zu den Toolbox-Helfern in den anderen SDKs mcptool.Connect werden keine Findry-Authentifizierungs- oder gehosteten Anruferheader hinzugefügt.

Lassen Sie die MCP-Sitzung für die Toolermittlung und den Aufruf geöffnet. Schließen Sie sie erst, nachdem der Agent die Remotetools verwendet hat.

Tip

Ein vollständiges Runnable-Beispiel finden Sie im MCP-Toolsbeispiel .

Verfügbarmachen eines Agents als MCP-Server

Sie können einen Agent als MCP-Server verfügbar machen, sodass er von jedem MCP-kompatiblen Client (z. B. VS Code GitHub Copilot Agents oder anderen Agents) als Tool verwendet werden kann. Der Name und die Beschreibung des Agents werden zu den MCP-Servermetadaten.

Schließen Sie den Agent in ein Funktionstool ein .AsAIFunction(), erstellen Sie einen McpServerTool, und registrieren Sie ihn mit einem MCP-Server:

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

Warnung

DefaultAzureCredential ist praktisch für die Entwicklung, erfordert aber sorgfältige Überlegungen in der Produktion. Berücksichtigen Sie in der Produktion die Verwendung bestimmter Anmeldeinformationen (z. B. ManagedIdentityCredential), um Latenzprobleme, unbeabsichtigte Abfragen von Anmeldeinformationen und potenzielle Sicherheitsrisiken durch Ausweichmechanismen zu vermeiden.

Installieren Sie die erforderlichen NuGet-Pakete:

dotnet add package Microsoft.Agents.AI.Foundry --prerelease
dotnet add package Microsoft.Extensions.Hosting
dotnet add package ModelContextProtocol

Rufen Sie .as_mcp_server() einen Agent auf, um ihn als MCP-Server verfügbar zu machen:

Note

Python agent.as_mcp_server() hängt auch vom optionalen mcp Paket ab. Wenn Sie eine schlanke/corebasierte Installation verwenden, führen Sie zuerst die Ausführung aus pip install "mcp>=2.2.0,<3" .

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

Richten Sie den MCP-Server ein, um die Standardeingabe/Ausgabe zu überwachen:

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)

Schließen Sie den Agent mit agenttool.New, registrieren Sie ihn mit einem MCP-Server mcptool.AddTool, und führen Sie den Server über Stdio aus:

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

Ein vollständiges Runnable-Beispiel finden Sie im Agent als MCP-Toolbeispiel .

Nächste Schritte

Unterhaltungen und Speicher

  • Zuletzt aktualisiert um