Az Azure MCP Server használatának első lépései a Pythonnal

Az Azure MCP Server a Model Context Protocol (MCP) használatával szabványosítja az AI-alkalmazások és a külső eszközök és adatforrások közötti integrációt, lehetővé téve az AI-rendszerek számára az Azure-erőforrások környezettudatos műveleteit.

Ebből a cikkből megtudhatja, hogyan végezheti el a következő feladatokat:

Az Azure MCP Server telepítése és hitelesítése
Csatlakozás az Azure MCP Serverhez egyéni Python-ügyfél használatával
Az Azure MCP Server műveleteinek tesztelésére és az Azure-erőforrások kezelésére vonatkozó kérések futtatása

Előfeltételek

Aktív előfizetéssel rendelkező Azure-fiók
Python 3.9 vagy újabb telepítve
Node.js Telepített LTS

Megjegyzés:

Az Azure MCP Serverrel elérni kívánt Azure-erőforrásoknak már létezniük kell az Azure-előfizetésben. Emellett a felhasználói fióknak rendelkeznie kell az erőforrásokhoz szükséges RBAC-szerepkörök és engedélyek hozzárendelésével .

Az Azure MCP Server zökkenőmentes hitelesítési élményt nyújt jogkivonatalapú hitelesítéssel a Microsoft Entra ID-vel. Az Azure MCP Server belsőleg az DefaultAzureCredential használja a felhasználók hitelesítését.

Az Azure MCP Server használatához be kell jelentkeznie az Azure-fiókjával helyileg támogatott DefaultAzureCredential eszközök egyikére. Bejelentkezés terminálablakkal, például a Visual Studio Code terminállal:

az login

Connect-AzAccount

azd auth login

Miután sikeresen bejelentkezett az előző eszközök egyikére, az Azure MCP Server automatikusan felderítheti a hitelesítő adatait, és felhasználhatja őket az Azure-szolgáltatások hitelesítésére és műveleteinek végrehajtására.

Megjegyzés:

A Visual Studióval is bejelentkezhet az Azure-ba. Az Azure MCP Server csak olyan műveleteket képes futtatni, amelyekre a bejelentkezett felhasználónak engedélye van.

A Python-alkalmazás létrehozása

Python-alkalmazás létrehozásához hajtsa végre az alábbi lépéseket. Az alkalmazás egy AI-modellhez csatlakozik, és egy Azure MCP-kiszolgálóhoz csatlakozó MCP-ügyfél gazdagépeként működik.

A projekt létrehozása

Nyisson meg egy üres mappát a választott szerkesztőben.
Hozzon létre egy új, elnevezett requirements.txt fájlt, és adja hozzá a következő kódtár-függőségeket:
```
mcp
azure-identity
openai
logging
```
Ugyanabban a mappában hozzon létre egy új, elnevezett .env fájlt, és adja hozzá a következő környezeti változókat:
```
AZURE_OPENAI_ENDPOINT=<your-azure-openai-endpoint>
AZURE_OPENAI_MODEL=<your-model-deployment-name>
```
Hozzon létre egy üres fájlt, amely main.py az alkalmazás kódjának tárolására szolgál.

A környezet létrehozása és függőségek telepítése

Nyisson meg egy terminált az új mappában, és hozzon létre egy Python virtuális környezetet az alkalmazáshoz:
```
python -m venv venv
```
A virtuális környezet aktiválása:
```
venv\Scripts\activate
```
Telepítse a függőségeket a következő forrásból requirements.txt:
```
pip install -r requirements.txt
```

Az alkalmazáskód hozzáadása

Frissítse a következő kód tartalmát Main.py :

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI
from mcp import ClientSession, StdioServerParameters, types
from mcp.client.stdio import stdio_client
import json, os, logging, asyncio
from dotenv import load_dotenv

# Setup logging and load environment variables
logger = logging.getLogger(__name__)
load_dotenv()

# Azure OpenAI configuration
AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
AZURE_OPENAI_MODEL = os.getenv("AZURE_OPENAI_MODEL", "gpt-4o")

# Initialize Azure credentials
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
)

async def run():
    # Initialize Azure OpenAI client
    client = AzureOpenAI(
            azure_endpoint=AZURE_OPENAI_ENDPOINT, 
            api_version="2024-04-01-preview", 
            azure_ad_token_provider=token_provider
        )

    # MCP client configurations
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@azure/mcp@latest", "server", "start"],
        env=None
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # List available tools
            tools = await session.list_tools()
            for tool in tools.tools: print(tool.name)

            # Format tools for Azure OpenAI
            available_tools = [{
                "type": "function",
                "function": {
                    "name": tool.name,
                    "description": tool.description,
                    "parameters": tool.inputSchema
                }
            } for tool in tools.tools]

            # Start conversational loop
            messages = []
            while True:
                try:
                    user_input = input("\nPrompt: ")
                    messages.append({"role": "user", "content": user_input})

                    # First API call with tool configuration
                    response = client.chat.completions.create(
                        model = AZURE_OPENAI_MODEL,
                        messages = messages,
                        tools = available_tools)

                    # Process the model's response
                    response_message = response.choices[0].message
                    messages.append(response_message)

                    # Handle function calls
                    if response_message.tool_calls:
                        for tool_call in response_message.tool_calls:
                                function_args = json.loads(tool_call.function.arguments)
                                result = await session.call_tool(tool_call.function.name, function_args)

                                # Add the tool response to the messages
                                messages.append({
                                    "tool_call_id": tool_call.id,
                                    "role": "tool",
                                    "name": tool_call.function.name,
                                    "content": result.content,
                                })
                    else:
                        logger.info("No tool calls were made by the model")

                    # Get the final response from the model
                    final_response = client.chat.completions.create(
                        model = AZURE_OPENAI_MODEL,
                        messages = messages,
                        tools = available_tools)

                    for item in final_response.choices:
                        print(item.message.content)
                except Exception as e:
                    logger.error(f"Error in conversation loop: {e}")
                    print(f"An error occurred: {e}")

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

Az előző kód a következő feladatokat hajtja végre:

Beállítja a naplózási és betölti a környezeti változókat egy .env fájlból.
Konfigurálja az Azure OpenAI-ügyfelet a kódtárak és azure-identity -kódtárak használatávalopenai.
Inicializál egy MCP-ügyfelet az Azure MCP-kiszolgálóval való kommunikációhoz egy szabványos I/O-átvitel használatával.
Lekéri és megjeleníti az MCP-kiszolgálóról elérhető eszközök listáját.
Beszélgetési ciklust implementál a felhasználói kérések feldolgozásához, az eszközök használatához és az eszközhívások kezeléséhez.

Az alkalmazás futtatása és tesztelése

A .NET-gazdagépalkalmazás teszteléséhez hajtsa végre az alábbi lépéseket:

A projekt gyökeréhez megnyitott terminálablakban futtassa a következő parancsot az alkalmazás elindításához:
```
python main.py
```

Az alkalmazás futtatása után adja meg a következő tesztüzenetet:

List all of the resource groups in my subscription

Az előző parancssor kimenetének a következő szöveghez kell hasonlítania:

The following resource groups are available for your subscription:

1. **DefaultResourceGroup-EUS** (Location: `eastus`)
2. **rg-testing** (Location: `centralus`)
3. **rg-azd** (Location: `eastus2`)
4. **msdocs-sample** (Location: `southcentralus`)
14. **ai-testing** (Location: `eastus2`)

Let me know if you need further details or actions related to any of these resource groups!

Az Azure MCP-műveletek megismerése és tesztelése más vonatkozó kérésekkel, például:

List all of the storage accounts in my subscription
Get the available tables in my storage accounts

Következő lépések

További információ az Azure MCP Server-eszközökről

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-09-02