MCP-eszközök használata az Öntödei ügynökökkel

Az Azure AI Foundry-ügynök képességeit úgy bővítheti, hogy távoli Model Context Protocol (MCP) kiszolgálókon üzemeltetett eszközökhöz csatlakoztatja (saját MCP-kiszolgálóvégpontot hoz létre).

A Model Context Protocol eszköz használata

Ez a szakasz bemutatja, hogyan hozhat létre AI-ügynököt az Azure Foundry (Azure AI) használatával üzemeltetett Model Context Protocol (MCP) kiszolgálóintegrációval. Az ügynök olyan MCP-eszközöket használhat, amelyeket az Azure Foundry szolgáltatás felügyel és hajt végre, lehetővé téve a külső erőforrásokhoz való biztonságos és szabályozott hozzáférést.

A legfontosabb jellemzők

Üzemeltetett MCP-kiszolgáló: Az MCP-kiszolgálót az Azure AI Foundry üzemelteti és felügyeli, így nincs szükség kiszolgálóinfrastruktúra kezelésére
Állandó ügynökök: Az ügynökök kiszolgálóoldali létrehozása és tárolása lehetővé teszi az állapotalapú beszélgetéseket
Eszközjóváhagyási munkafolyamat: Konfigurálható jóváhagyási mechanizmusok MCP-eszközök meghívásához

Hogyan működik?

1. Környezet beállítása

A mintához két környezeti változó szükséges:

AZURE_FOUNDRY_PROJECT_ENDPOINT: Az Azure AI Foundry projektvégpont URL-címe
AZURE_FOUNDRY_PROJECT_MODEL_ID: A modell üzembehelyezési neve (alapértelmezés szerint "gpt-4.1-mini")

var endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") 
    ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
var model = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_MODEL_ID") ?? "gpt-4.1-mini";

2. Ügynök konfigurálása

Az ügynök speciális utasítások és metaadatok használatával van konfigurálva:

const string AgentName = "MicrosoftLearnAgent";
const string AgentInstructions = "You answer questions by searching the Microsoft Learn content only.";

Ez létrehoz egy ügynököt, amely a Microsoft Learn dokumentációjának használatával válaszol a kérdésekre.

3. MCP eszközdefiníció

A minta létrehoz egy MCP-eszközdefiníciót, amely egy üzemeltetett MCP-kiszolgálóra mutat:

var mcpTool = new MCPToolDefinition(
    serverLabel: "microsoft_learn",
    serverUrl: "https://learn.microsoft.com/api/mcp");
mcpTool.AllowedTools.Add("microsoft_docs_search");

Fő összetevők:

serverLabel: Az MCP-kiszolgálópéldány egyedi azonosítója
serverUrl: A üzemeltetett MCP-kiszolgáló URL-címe
AllowedTools: Megadja, hogy az ügynök mely eszközöket használhatja az MCP-kiszolgálóról

4. Állandó ügynök létrehozása

Az ügynök kiszolgálóoldali létrehozása az Azure AI Foundry Persistent Agents SDK használatával történik:

var persistentAgentsClient = new PersistentAgentsClient(endpoint, new DefaultAzureCredential());

var agentMetadata = await persistentAgentsClient.Administration.CreateAgentAsync(
    model: model,
    name: AgentName,
    instructions: AgentInstructions,
    tools: [mcpTool]);

Figyelmeztetés

DefaultAzureCredential a fejlesztéshez kényelmes, de az éles környezetben gondos megfontolást igényel. Éles környezetben fontolja meg egy adott hitelesítő adat (pl. ) használatát a ManagedIdentityCredentialkésési problémák, a nem szándékos hitelesítő adatok próbaüzeme és a tartalék mechanizmusok esetleges biztonsági kockázatainak elkerülése érdekében.

Ez létrehoz egy állandó ügynököt, amely:

Az Azure AI Foundry szolgáltatásban él
Hozzáféréssel rendelkezik a megadott MCP-eszközökhöz
Több interakcióban is fenntarthatja a beszélgetés állapotát

5. Ügynök lekérése és végrehajtása

A létrehozott ügynök példányként AIAgent lesz lekérve:

AIAgent agent = await persistentAgentsClient.GetAIAgentAsync(agentMetadata.Value.Id);

6. Eszközerőforrás konfigurálása

A minta jóváhagyási beállításokkal konfigurálja az eszközerőforrásokat:

var runOptions = new ChatClientAgentRunOptions()
{
    ChatOptions = new()
    {
        RawRepresentationFactory = (_) => new ThreadAndRunOptions()
        {
            ToolResources = new MCPToolResource(serverLabel: "microsoft_learn")
            {
                RequireApproval = new MCPApproval("never"),
            }.ToToolResources()
        }
    }
};

Kulcskonfiguráció:

MCPToolResource: Összekapcsolja az MCP-kiszolgálópéldányt az ügynök végrehajtásával
RequireApproval: Azt szabályozza, hogy mikor van szükség felhasználói jóváhagyásra az eszközhívásokhoz
- "never": Az eszközök automatikusan, jóváhagyás nélkül futnak
- "always": Minden eszközhíváshoz felhasználói jóváhagyás szükséges
- Egyéni jóváhagyási szabályok is konfigurálhatók

7. Ügynök végrehajtása

Az ügynök meghívása kérdésekkel történik, és a konfigurált MCP-eszközökkel hajtja végre:

AgentSession session = await agent.CreateSessionAsync();
var response = await agent.RunAsync(
    "Please summarize the Azure AI Agent documentation related to MCP Tool calling?", 
    session, 
    runOptions);
Console.WriteLine(response);

8. Törlés

A minta a megfelelő erőforrás-tisztítást mutatja be:

await persistentAgentsClient.Administration.DeleteAgentAsync(agent.Id);

Jótanács

A teljes futtatható példákért tekintse meg a .NET-mintákat .

Az Azure AI Foundry zökkenőmentes integrációt biztosít a Model Context Protocol (MCP) kiszolgálóival a Python Agent Frameworken keresztül. A szolgáltatás kezeli az MCP-kiszolgáló üzemeltetését és végrehajtását, kiküszöbölve az infrastruktúra kezelését, miközben biztonságos, ellenőrzött hozzáférést biztosít a külső eszközökhöz.

Környezet beállítása

Az Azure AI Foundry-projekt hitelesítő adatainak konfigurálása környezeti változókon keresztül:

import os
from azure.identity.aio import AzureCliCredential
from agent_framework.azure import AzureAIAgentClient

# Required environment variables
os.environ["AZURE_AI_PROJECT_ENDPOINT"] = "https://<your-project>.services.ai.azure.com/api/projects/<project-id>"
os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"] = "gpt-4o-mini"  # Optional, defaults to this

Alapszintű MCP-integráció

Azure AI Foundry-ügynök létrehozása üzemeltetett MCP-eszközökkel:

import asyncio
from agent_framework.azure import AzureAIAgentClient
from azure.identity.aio import AzureCliCredential

async def basic_foundry_mcp_example():
    """Basic example of Azure AI Foundry agent with hosted MCP tools."""
    async with (
        AzureCliCredential() as credential,
        AzureAIAgentClient(async_credential=credential) as client,
    ):
        # Create a hosted MCP tool using the client method
        learn_mcp = client.get_mcp_tool(
            name="Microsoft Learn MCP",
            url="https://learn.microsoft.com/api/mcp",
        )

        # Create agent with hosted MCP tool
        agent = client.as_agent(
            name="MicrosoftLearnAgent", 
            instructions="You answer questions by searching Microsoft Learn content only.",
            tools=learn_mcp,
        )

        # Simple query without approval workflow
        result = await agent.run(
            "Please summarize the Azure AI Agent documentation related to MCP tool calling?"
        )
        print(result)

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

Többeszközes MCP-konfiguráció

Több üzemeltetett MCP-eszköz használata egyetlen ügynökkel:

async def multi_tool_mcp_example():
    """Example using multiple hosted MCP tools."""
    async with (
        AzureCliCredential() as credential,
        AzureAIAgentClient(async_credential=credential) as client,
    ):
        # Create multiple MCP tools using the client method
        learn_mcp = client.get_mcp_tool(
            name="Microsoft Learn MCP",
            url="https://learn.microsoft.com/api/mcp",
            approval_mode="never_require",  # Auto-approve documentation searches
        )
        github_mcp = client.get_mcp_tool(
            name="GitHub MCP", 
            url="https://api.github.com/mcp",
            approval_mode="always_require",  # Require approval for GitHub operations
            headers={"Authorization": "Bearer github-token"},
        )

        # Create agent with multiple MCP tools
        agent = client.as_agent(
            name="MultiToolAgent",
            instructions="You can search documentation and access GitHub repositories.",
            tools=[learn_mcp, github_mcp],
        )

        result = await agent.run(
            "Find Azure documentation and also check the latest commits in microsoft/semantic-kernel"
        )
        print(result)

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

A Python Agent Framework zökkenőmentes integrációt biztosít az Azure AI Foundry üzemeltetett MCP-képességeivel, így biztonságos és méretezhető hozzáférést biztosít a külső eszközökhöz, miközben fenntartja az éles alkalmazásokhoz szükséges rugalmasságot és felügyeletet.

Teljes példa

# Copyright (c) Microsoft. All rights reserved.

import asyncio
import os

from agent_framework import Agent
from agent_framework.openai import OpenAIResponsesClient
from dotenv import load_dotenv

"""
MCP GitHub Integration with Personal Access Token (PAT)

This example demonstrates how to connect to GitHub's remote MCP server using a Personal Access
Token (PAT) for authentication. The agent can use GitHub operations like searching repositories,
reading files, creating issues, and more depending on how you scope your token.

Prerequisites:
1. A GitHub Personal Access Token with appropriate scopes
   - Create one at: https://github.com/settings/tokens
   - For read-only operations, you can use more restrictive scopes
2. Environment variables:
   - GITHUB_PAT: Your GitHub Personal Access Token (required)
   - OPENAI_API_KEY: Your OpenAI API key (required)
   - OPENAI_RESPONSES_MODEL_ID: Your OpenAI model ID (required)
"""


async def github_mcp_example() -> None:
    """Example of using GitHub MCP server with PAT authentication."""
    # 1. Load environment variables from .env file if present
    load_dotenv()

    # 2. Get configuration from environment
    github_pat = os.getenv("GITHUB_PAT")
    if not github_pat:
        raise ValueError(
            "GITHUB_PAT environment variable must be set. Create a token at https://github.com/settings/tokens"
        )

    # 3. Create authentication headers with GitHub PAT
    auth_headers = {
        "Authorization": f"Bearer {github_pat}",
    }

    # 4. Create agent with the GitHub MCP tool using instance method
    # The MCP tool manages the connection to the MCP server and makes its tools available
    # Set approval_mode="never_require" to allow the MCP tool to execute without approval
    client = OpenAIResponsesClient()
    github_mcp_tool = client.get_mcp_tool(
        name="GitHub",
        url="https://api.githubcopilot.com/mcp/",
        headers=auth_headers,
        approval_mode="never_require",
    )

    # 5. Create agent with the GitHub MCP tool
    async with Agent(
        client=client,
        name="GitHubAgent",
        instructions=(
            "You are a helpful assistant that can help users interact with GitHub. "
            "You can search for repositories, read file contents, check issues, and more. "
            "Always be clear about what operations you're performing."
        ),
        tools=github_mcp_tool,
    ) as agent:
        # Example 1: Get authenticated user information
        query1 = "What is my GitHub username and tell me about my account?"
        print(f"\nUser: {query1}")
        result1 = await agent.run(query1)
        print(f"Agent: {result1.text}")

        # Example 2: List my repositories
        query2 = "List all the repositories I own on GitHub"
        print(f"\nUser: {query2}")
        result2 = await agent.run(query2)
        print(f"Agent: {result2.text}")


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

Következő lépések

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

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2026-02-13