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é
• Lancer des invites afin de tester les opérations du serveur Azure MCP 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é

Se connecter au serveur Azure MCP pour le développement local

Azure MCP Server s’authentifie auprès de Microsoft Entra ID à l’aide de la bibliothèque Azure Identity pour .NET. Le serveur prend en charge deux modes d’authentification :

• Mode Broker : utilise l’authentification native de votre système d’exploitation (comme le Gestionnaire de comptes web Windows) avec InteractiveBrowserCredential.
• Mode chaîne des informations d'identification : essaie plusieurs méthodes d’authentification successivement : variables d’environnement, Visual Studio Code, Visual Studio, Azure CLI, Azure PowerShell, Azure Developer CLI et authentification interactive par navigateur.

Connectez-vous à l’aide de l’une de ces méthodes :

az login

Connect-AzAccount

azd auth login

Une fois connecté, azure MCP Server peut authentifier et exécuter des opérations sur les services Azure en fonction de vos autorisations.

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

1. Ouvrez un dossier vide à l’intérieur de votre éditeur de choix.

2. Créez un fichier nommé requirements.txt et ajoutez les dépendances de bibliothèque suivantes :

   mcp
   azure-identity
   openai
   logging
   

3. 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>
   

4. Créez un fichier vide nommé main.py pour contenir le code de votre application.

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

1. Ouvrez un terminal dans votre nouveau dossier et créez un environnement virtuel Python pour l’application :

   python -m venv venv
   

2. Activez l’environnement virtuel :

   venv\Scripts\activate
   

3. Installez les dépendances à partir de requirements.txt:

   pip install -r requirements.txt
   

Ajouter le code de l’application

Mettez à jour le contenu de main.py avec le 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 de azure-identity et openai des 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 :

Exécuter et tester l’application

Effectuez les étapes suivantes pour tester votre application Python :

1. 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.

2. 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!
   

3. 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