Introdução ao uso do Servidor MCP do Azure com o .NET

O Servidor MCP do Azure usa o PROTOCOLO MCP (Model Context Protocol) para padronizar as integrações entre aplicativos de IA e ferramentas externas e fontes de dados, permitindo que os sistemas de IA executem operações com reconhecimento de contexto dos recursos do Azure.

Neste artigo, você aprenderá a concluir as seguintes tarefas:

• Instalar e autenticar no Servidor MCP do Azure
• Conectar-se ao Servidor MCP do Azure usando um cliente .NET personalizado
• Executar prompts para testar as operações do Servidor MCP do Azure e gerenciar recursos do Azure

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa
• .NET 9.0 ou superior instalado
• Node.js LTS instalado

Entrada para desenvolvimento local

O Servidor MCP do Azure fornece uma experiência de autenticação perfeita usando a autenticação baseada em token por meio da ID do Microsoft Entra. Internamente, o Servidor MCP do Azure usa da biblioteca de Identidade do DefaultAzureCredentialAzure para autenticar usuários.

Você precisa entrar em uma das ferramentas compatíveis DefaultAzureCredential localmente com sua conta do Azure para trabalhar com o Servidor MCP do Azure. Entre usando uma janela de terminal, como o terminal do Visual Studio Code:

az login

Connect-AzAccount

azd auth login

Depois de entrar com êxito em uma das ferramentas anteriores, o Servidor MCP do Azure pode descobrir automaticamente suas credenciais e usá-las para autenticar e executar operações nos serviços do Azure.

Criar o aplicativo host .NET

Conclua as etapas a seguir para criar um aplicativo de console do .NET. O aplicativo se conecta a um modelo de IA e atua como um host para um cliente MCP que se conecta a um servidor MCP do Azure.

Criar o projeto

1. Abra um terminal para uma pasta vazia em que você deseja criar o projeto.

2. Execute o seguinte comando para criar um novo aplicativo de console do .NET:

   dotnet new console -n MCPHostApp
   

3. Navegue até a pasta de projeto recém-criada:

   cd MCPHostApp
   

4. Abra a pasta do projeto no editor de sua escolha, como o Visual Studio Code:

   code .
   

Adicionar as dependências

1. No terminal, execute os seguintes comandos para adicionar os pacotes NuGet necessários:

   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
   

2. Verifique se os pacotes foram adicionados verificando o MCPHostApp.csproj arquivo.

3. Execute o seguinte comando para criar o projeto e garantir que tudo esteja configurado corretamente:

   dotnet build
   

Adicionar o código do aplicativo

Substitua o conteúdo de Program.cs pelo seguinte código:

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

// 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 McpClient.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);
}

O código anterior realiza as seguintes tarefas:

• Inicializa uma IChatClient abstração usando as Microsoft.Extensions.AI bibliotecas.
• Cria um cliente MCP para interagir com o Servidor MCP do Azure usando um transporte de E/S padrão. O comando fornecido npx e os argumentos correspondentes baixam e iniciam o Servidor MCP do Azure.
• Recupera e exibe uma lista de ferramentas disponíveis do servidor MCP, que é uma função MCP padrão.
• Implementa um loop de conversa que processa prompts do usuário e utiliza as ferramentas para respostas.

Executar e testar o aplicativo

Conclua as seguintes etapas para testar seu aplicativo host .NET:

1. Em uma janela de terminal aberta para a raiz do projeto, execute o seguinte comando para iniciar o aplicativo:

   dotnet run
   

2. Depois que o aplicativo estiver em execução, insira o seguinte prompt de teste:

   List all of the resource groups in my subscription
   

   A saída do prompt anterior deve ser semelhante ao seguinte texto:

   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. Explore e teste as operações do MCP do Azure usando outros prompts relevantes, como:

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

Próximas etapas