Introduzione all'uso del server MCP di Azure con Python

Il server MCP di Azure usa il protocollo MCP (Model Context Protocol) per standardizzare le integrazioni tra app di intelligenza artificiale e strumenti esterni e origini dati, consentendo ai sistemi di intelligenza artificiale di eseguire operazioni con riconoscimento del contesto delle risorse di Azure.

In questo articolo si apprenderà come completare le attività seguenti:

Installare ed eseguire l'autenticazione nel server MCP di Azure
Connettersi al server MCP di Azure usando un client Python personalizzato
Eseguire richieste di test delle operazioni del server MCP di Azure e gestire le risorse di Azure

Prerequisiti

Un account Azure con una sottoscrizione attiva
Python 3.9 o versione successiva installata
Node.js LTS installato

Annotazioni

Le risorse di Azure a cui si intende accedere con il server MCP di Azure devono già esistere all'interno della sottoscrizione di Azure. Inoltre, l'account utente deve avere i ruoli e le autorizzazioni di controllo degli accessi in base al ruolo necessari assegnati per tali risorse.

Il server MCP di Azure offre un'esperienza di autenticazione senza problemi usando l'autenticazione basata su token tramite Microsoft Entra ID. Internamente, il server MCP di Azure usa DefaultAzureCredential la libreria di identità di Azure per autenticare gli utenti.

È necessario accedere a uno degli strumenti supportati in DefaultAzureCredential locale con l'account Azure per usare il server MCP di Azure. Accedere usando una finestra del terminale, ad esempio il terminale di Visual Studio Code:

az login

Connect-AzAccount

azd auth login

Dopo aver eseguito l'accesso a uno degli strumenti precedenti, Il server MCP di Azure può individuare automaticamente le credenziali e usarle per autenticare ed eseguire operazioni sui servizi di Azure.

Annotazioni

È anche possibile accedere ad Azure tramite Visual Studio. Il server MCP di Azure è in grado di eseguire solo operazioni che l'utente connesso dispone delle autorizzazioni da eseguire.

Creare l'app Python

Completare i passaggi seguenti per creare un'app Python. L'app si connette a un modello di intelligenza artificiale e funge da host per un client MCP che si connette a un server MCP di Azure.

Creare il progetto

Aprire una cartella vuota all'interno dell'editor preferito.
Creare un nuovo file denominato requirements.txt e aggiungere le dipendenze della libreria seguenti:
```
mcp
azure-identity
openai
logging
```
Nella stessa cartella creare un nuovo file denominato .env e aggiungere le variabili di ambiente seguenti:
```
AZURE_OPENAI_ENDPOINT=<your-azure-openai-endpoint>
AZURE_OPENAI_MODEL=<your-model-deployment-name>
```
Creare un file vuoto denominato main.py per contenere il codice per l'app.

Creare l'ambiente e installare le dipendenze

Aprire un terminale nella nuova cartella e creare un ambiente virtuale Python per l'app:
```
python -m venv venv
```
Attivare l'ambiente virtuale:
```
venv\Scripts\activate
```
Installare le dipendenze da requirements.txt:
```
pip install -r requirements.txt
```

Aggiungere il codice dell'app

Aggiornare il contenuto di Main.py con il codice seguente:

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

Il codice precedente esegue le attività seguenti:

Configura la registrazione e carica le variabili di ambiente da un .env file.
Configura il client OpenAI di Azure usando azure-identity le librerie e openai .
Inizializza un client MCP per interagire con il server MCP di Azure usando un trasporto di I/O standard.
Recupera e visualizza un elenco degli strumenti disponibili dal server MCP.
Implementa un ciclo di conversazioni per elaborare le richieste degli utenti, utilizzare gli strumenti e gestire le chiamate agli strumenti.

Eseguire e testare l'app

Completare i passaggi seguenti per testare l'app host .NET:

In una finestra del terminale aperta alla radice del progetto eseguire il comando seguente per avviare l'app:
```
python main.py
```

Dopo l'esecuzione dell'app, immettere il prompt di test seguente:

List all of the resource groups in my subscription

L'output per il prompt precedente dovrebbe essere simile al testo seguente:

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!

Esplorare e testare le operazioni MCP di Azure usando altre richieste pertinenti, ad esempio:

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

Passaggi successivi

Altre informazioni sugli strumenti del server MCP di Azure

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-08-20