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 necessari ruoli e autorizzazioni RBAC assegnati per tali risorse.

Il server MCP di Azure esegue l'autenticazione con Microsoft Entra ID usando la libreria di identità di Azure per .NET. Il server supporta due modalità di autenticazione:

Modalità Broker: usa l'autenticazione nativa del sistema operativo (ad esempio Gestione Account Web di Windows) con InteractiveBrowserCredential.
Modalità catena di credenziali: prova più metodi di autenticazione in sequenza: variabili di ambiente, Visual Studio Code, Visual Studio, interfaccia della riga di comando di Azure, Azure PowerShell, interfaccia della riga di comando per sviluppatori di Azure e autenticazione interattiva del browser.

Accedere usando uno dei metodi seguenti:

Aprire il riquadro comandi (Ctrl+Shift+P o Cmd+Shift+P su Mac).
Eseguire Azure: accedere e seguire le istruzioni.

az login

Connect-AzAccount

azd auth login

Dopo l'accesso, il server MCP di Azure può autenticare ed eseguire operazioni sui servizi di Azure in base alle autorizzazioni.

Creare l'app Python

Completare i passaggi seguenti per creare un'app Python (applicazione ospite). 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 (processo locale che esegue il protocollo MCP).

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 le librerie azure-identity e openai.
Inizializza un client MCP per interagire con il server MCP di Azure (processo locale) usando un trasporto di I/O standard.
Recupera e visualizza un elenco di strumenti disponibili (operazioni di Azure registrate da MCP) dal server MCP di Azure.
Implementa un ciclo di conversazioni per elaborare le richieste degli utenti, utilizzare gli strumenti e gestire le chiamate agli strumenti.

Parametri di configurazione:

Parametro	Description	Example
`AZURE_OPENAI_ENDPOINT`	Endpoint del servizio OpenAI di Azure	`https://your-resource.openai.azure.com/`
`AZURE_OPENAI_MODEL`	Nome della distribuzione del modello	`gpt-4o`
Ambito del token	Ambito OAuth di Servizi cognitivi di Azure	`https://cognitiveservices.azure.com/.default`
Autenticazione	`DefaultAzureCredential` Usa (interfaccia della riga di comando di Azure, identità gestita o altra catena di credenziali)	Vedere la documentazione di Identità di Azure
Controllo degli accessi in base al ruolo richiesto	Ruolo utente di Servizi cognitivi o equivalente nella risorsa OpenAI di Azure	Assegnato tramite il portale di Azure o la CLI

Eseguire e testare l'app

Completare la procedura seguente per testare l'app Python:

In una finestra del terminale aperta alla radice del progetto eseguire il comando seguente per avviare l'app:
```
python main.py
```
Verifica del successo: l'app deve visualizzare un elenco degli strumenti server MCP di Azure disponibili e quindi visualizzare un Prompt: campo di input.

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 2026-02-12