Bien démarrer avec le serveur Azure MCP avec Python

Le serveur Azure MCP utilise le protocole MCP (Model Context Protocol) pour normaliser les intégrations entre les applications IA et les outils externes et les sources de données, ce qui permet aux systèmes IA d’effectuer des opérations qui prennent en compte le contexte de vos ressources Azure.

Dans cet article, vous allez apprendre à effectuer les tâches suivantes :

Installer et s’authentifier auprès du serveur Azure MCP
Se connecter au serveur Azure MCP à l’aide d’un client Python personnalisé
Exécuter des invites pour tester les opérations du serveur MCP Azure et gérer les ressources Azure

Prerequisites

Un compte Azure avec un abonnement actif
Python 3.9 ou version ultérieure installée
Node.js LTS installé

Note

Les ressources Azure auxquelles vous envisagez d’accéder avec le serveur Azure MCP doivent déjà exister dans votre abonnement Azure. En outre, votre compte d’utilisateur doit disposer des rôles et autorisations RBAC nécessaires pour ces ressources.

Azure MCP Server offre une expérience d’authentification transparente à l’aide de l’authentification basée sur des jetons via l’ID Microsoft Entra. En interne, azure MCP Server utilise DefaultAzureCredential à partir de la bibliothèque d’identités Azure pour authentifier les utilisateurs.

Vous devez vous connecter à l’un des outils pris en charge localement avec DefaultAzureCredential votre compte Azure pour utiliser Azure MCP Server. Connectez-vous à l’aide d’une fenêtre de terminal, telle que le terminal Visual Studio Code :

az login

Connect-AzAccount

azd auth login

Une fois que vous êtes connecté à l’un des outils précédents, Azure MCP Server peut détecter automatiquement vos informations d’identification et les utiliser pour authentifier et effectuer des opérations sur les services Azure.

Note

Vous pouvez également vous connecter à Azure via Visual Studio. Azure MCP Server est uniquement en mesure d’exécuter des opérations que l’utilisateur connecté dispose des autorisations nécessaires.

Créer l’application Python

Effectuez les étapes suivantes pour créer une application Python (application hôte). L’application se connecte à un modèle IA et agit en tant qu’hôte pour un client MCP qui se connecte à un serveur Azure MCP (processus local exécutant le protocole MCP).

Créer le projet

Ouvrez un dossier vide à l’intérieur de votre éditeur de choix.
Créez un fichier nommé requirements.txt et ajoutez les dépendances de bibliothèque suivantes :
```
mcp
azure-identity
openai
logging
```
Dans le même dossier, créez un fichier nommé .env et ajoutez les variables d’environnement suivantes :
```
AZURE_OPENAI_ENDPOINT=<your-azure-openai-endpoint>
AZURE_OPENAI_MODEL=<your-model-deployment-name>
```
Créez un fichier vide nommé main.py pour contenir le code de votre application.

Créer l’environnement et installer des dépendances

Ouvrez un terminal dans votre nouveau dossier et créez un environnement virtuel Python pour l’application :
```
python -m venv venv
```
Activez l’environnement virtuel :
```
venv\Scripts\activate
```
Installez les dépendances à partir de requirements.txt:
```
pip install -r requirements.txt
```

Ajouter le code de l’application

Mettez à jour le contenu du main.py code suivant :

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

Le code précédent effectue les tâches suivantes :

Configure la journalisation et charge les variables d’environnement à partir d’un .env fichier.
Configure le client Azure OpenAI à l’aide azure-identity et openai les bibliothèques.
Initialise un client MCP pour interagir avec le serveur Azure MCP (processus local) à l’aide d’un transport d’E/S standard.
Récupère et affiche une liste d’outils disponibles (opérations Azure inscrites sur MCP) à partir du serveur Azure MCP.
Implémente une boucle conversationnelle pour traiter les invites utilisateur, utiliser des outils et gérer les appels d’outils.

Paramètres de configuration :

Paramètre	Descriptif	Example
`AZURE_OPENAI_ENDPOINT`	Votre point de terminaison de service Azure OpenAI	`https://your-resource.openai.azure.com/`
`AZURE_OPENAI_MODEL`	Nom du déploiement de modèle	`gpt-4o`
Étendue du jeton	Étendue OAuth d’Azure Cognitive Services	`https://cognitiveservices.azure.com/.default`
Authentification	Utilise `DefaultAzureCredential` (Azure CLI, identité managée ou autre chaîne d'authentification)	Consultez la documentation d’Azure Identity
RBAC requis	Rôle d’utilisateur Cognitive Services ou équivalent sur la ressource Azure OpenAI	Affecté via le portail Azure ou l’interface CLI

Exécuter et tester l’application

Effectuez les étapes suivantes pour tester votre application Python :

Dans une fenêtre de terminal ouverte à la racine de votre projet, exécutez la commande suivante pour démarrer l’application :
```
python main.py
```
Vérification réussie : l’application doit afficher la liste des outils azure MCP Server disponibles, puis afficher une Prompt: entrée.

Une fois l’application en cours d’exécution, entrez l’invite de test suivante :

List all of the resource groups in my subscription

La sortie de l’invite précédente doit ressembler au texte suivant :

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!

Explorez et testez les opérations Azure MCP à l’aide d’autres invites pertinentes, telles que :

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

Étapes suivantes

En savoir plus sur les outils azure MCP Server

Commentaires

Cette page vous a-t-elle été utile ?

Last updated on 2025-12-13