Prise en main du serveur Azure MCP

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 du mode d’agent Copilot GitHub dans Visual Studio Code
Exécuter des commandes pour tester les opérations d'Azure MCP Server et interagir avec les ressources Azure

Conditions préalables

Un compte Azure avec un abonnement actif
Visual Studio Code
GitHub Copilot Extension de Visual Studio Code

Remarque

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.

Installer le serveur Azure MCP

Sélectionnez l’une des options suivantes pour installer le serveur Azure MCP dans Visual Studio Code :

Installation globale
Installation du répertoire

Pour installer le serveur Azure MCP pour Visual Studio Code dans vos paramètres utilisateur, sélectionnez le lien suivant :

Une liste des options d’installation s’ouvre dans Visual Studio Code. Sélectionnez Installer le serveur pour ajouter la configuration du serveur à vos paramètres utilisateur.
Ouvrez GitHub Copilot et sélectionnez Mode agent. Pour en savoir plus sur le mode agent, consultez la documentation de Visual Studio Code.
Actualisez la liste des outils pour voir Azure MCP Server comme option disponible :

Vous pouvez également installer manuellement azure MCP Server pour un répertoire spécifique :

Ouvrez un répertoire vide ou un répertoire de projet existant dans Visual Studio Code.
À la racine du dossier, créez un .vscode dossier s’il n’en existe pas déjà un.

Dans le .vscode dossier, créez un fichier nommé mcp.json ajouter le code JSON suivant :

{
  "servers": {
    "Azure MCP Server": {
      "command": "npx",
      "args": [
        "-y",
        "@azure/mcp@latest",
        "server",
        "start"
      ]
    }
  }
}

Enregistrez vos modifications dans mcp.json.
Ouvrez GitHub Copilot et sélectionnez Mode agent.
Sélectionnez l’icône outils pour afficher les outils disponibles. Recherchez azure MCP Server pour filtrer les résultats.

Pour en savoir plus sur le mode agent, consultez la documentation de Visual Studio Code.

Utiliser des instructions pour tester le serveur Azure MCP

Ouvrez GitHub Copilot et sélectionnez Mode agent.
Entrez une invite qui amène l’agent à utiliser les outils azure MCP Server, tels que répertorier mes groupes de ressources Azure.
Pour authentifier Azure MCP Server, Copilot vous invite à vous connecter à Azure à l’aide du navigateur.

Remarque

Copilot ne vous invite pas à vous connecter à Azure si vous êtes déjà authentifié via d’autres outils locaux tels que l’interface de ligne de commande Azure.
Copilot demande l'autorisation d'exécuter l'opération nécessaire du serveur Azure MCP pour votre commande. Sélectionnez Continuer ou utiliser la flèche pour sélectionner un comportement plus spécifique :
- La session active exécute toujours l’opération dans la session en mode Agent Copilot GitHub actuelle.
- L’espace de travail actuel exécute toujours la commande pour l’espace de travail Visual Studio Code actuel.
- Toujours autoriser configure l'opération pour qu'elle soit toujours exécutée pour toute session en mode Agent Copilot GitHub ou tout espace de travail Visual Studio Code.
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

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 .NET personnalisé
Exécuter des commandes pour tester le fonctionnement du serveur MCP Azure et gérer les ressources Azure.

Conditions préalables

Un compte Azure avec un abonnement actif
.NET 9.0
Node.JS

Remarque

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.

Remarque

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 hôte .NET

Effectuez les étapes suivantes pour créer une application console .NET. 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.

Créer le projet

Ouvrez un terminal dans un dossier vide dans lequel vous souhaitez créer le projet.
Exécutez la commande suivante pour créer une application console .NET :
```
dotnet new console -n MCPHostApp
```
Accédez au dossier de projet nouvellement créé :
```
cd MCPHostApp
```
Ouvrez le dossier du projet dans votre éditeur de choix, par exemple Visual Studio Code :
```
code .
```

Ajouter les dépendances

Dans le terminal, exécutez les commandes suivantes pour ajouter les packages NuGet nécessaires :

dotnet add package Azure.AI.OpenAI --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Extensions.AI --prerelease
dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
dotnet add package ModelContextProtocol --prerelease

Vérifiez que les packages ont été ajoutés en vérifiant le MCPHostApp.csproj fichier.
Exécutez la commande suivante pour générer le projet et vérifier que tout est configuré correctement :
```
dotnet build
```

Ajoutez le code de l’application

Remplacez le contenu de Program.cs par le code suivant :

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Extensions.AI;
using ModelContextProtocol.Client;
using ModelContextProtocol.Protocol.Transport;

// Create an IChatClient
IChatClient client =
    new ChatClientBuilder(
        new AzureOpenAIClient(new Uri("<your-Azure-OpenAI-endpoint>"), 
        new DefaultAzureCredential())
        .GetChatClient("gpt-4o").AsIChatClient())
    .UseFunctionInvocation()
    .Build();

// Create the MCP client
var mcpClient = await McpClientFactory.CreateAsync(
    new StdioClientTransport(new()
    {
        Command = "npx",
        Arguments = ["-y", "@azure/mcp@latest", "server", "start"],
        Name = "Azure MCP",
    }));

// Get all available tools from the MCP server
Console.WriteLine("Available tools:");
var tools = await mcpClient.ListToolsAsync();
foreach (var tool in tools)
{
    Console.WriteLine($"{tool}");
}
Console.WriteLine();

// Conversational loop that can utilize the tools
List<ChatMessage> messages = [];
while (true)
{
    Console.Write("Prompt: ");
    messages.Add(new(ChatRole.User, Console.ReadLine()));

    List<ChatResponseUpdate> updates = [];
    await foreach (var update in client
        .GetStreamingResponseAsync(messages, new() { Tools = [.. tools] }))
    {
        Console.Write(update);
        updates.Add(update);
    }
    Console.WriteLine();

    messages.AddMessages(updates);
}

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

Initialise une abstraction IChatClient en utilisant les bibliothèques Microsoft.Extensions.AI.
Crée un client MCP pour interagir avec le serveur Azure MCP à l’aide d’un transport d’E/S standard. La commande fournie npx et les arguments correspondants téléchargent et démarrent le serveur Azure MCP.
Récupère et affiche une liste d’outils disponibles à partir du serveur MCP, qui est une fonction MCP standard.
Implémente une boucle conversationnelle qui traite les requêtes des utilisateurs et utilise les outils pour formuler des réponses.

Exécuter et tester l’application

Effectuez les étapes suivantes pour tester votre application hôte .NET :

Dans une fenêtre de terminal ouverte à la racine de votre projet, exécutez la commande suivante pour démarrer l’application :
```
dotnet run
```

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

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 commandes pour tester le fonctionnement du serveur MCP Azure et gérer les ressources Azure.

Conditions préalables

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

Remarque

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.

Remarque

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

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
```

Ajoutez 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.
Configurez le client Azure OpenAI en utilisant les bibliothèques azure-identity et openai.
Initialise un client MCP pour interagir avec le serveur Azure MCP à l’aide d’un transport d’E/S standard.
Récupère et affiche une liste d’outils disponibles à partir du serveur MCP.
Implémente une boucle conversationnelle pour traiter les invites utilisateur, utiliser des outils et gérer les appels d’outils.

Exécuter et tester l’application

Effectuez les étapes suivantes pour tester votre application hôte .NET :

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
```

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

Partager via

Conditions préalables

Installer le serveur Azure MCP

Utiliser des instructions pour tester le serveur Azure MCP

Conditions préalables

Connexion pour le développement local

Créer l’application hôte .NET

Créer le projet

Ajouter les dépendances

Ajoutez le code de l’application

Exécuter et tester l’application

Conditions préalables

Connexion pour le développement local

Créer l’application Python

Créer le projet

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

Ajoutez le code de l’application

Exécuter et tester l’application

Étapes suivantes

Commentaires

Ressources supplémentaires