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

O Servidor MCP do Azure usa o Protocolo de Contexto de Modelo (MCP) para padronizar integrações entre aplicativos de IA e ferramentas externas e fontes de dados, permitindo que os sistemas de IA executem operações sensíveis ao contexto de seus 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 subscrição ativa
• .NET 9.0 ou superior instalado
• Node.js LTS instalado

Login para desenvolvimento local

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

Tem de iniciar sessão numa das ferramentas suportadas localmente DefaultAzureCredential com a sua conta do Azure para trabalhar com o Azure MCP Server. Entre usando uma janela de terminal, como o terminal de código do Visual Studio:

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 .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 onde você deseja criar o projeto.

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

   dotnet new console -n MCPHostApp
   

3. Navegue até a pasta do 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 construir o projeto e garantir que tudo esteja configurado corretamente:

   dotnet build
   

Adicionar o código do aplicativo

Substitua o conteúdo do 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ção que processa solicitações 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 seu projeto, execute o seguinte comando para iniciar o aplicativo:

   dotnet run
   

2. Quando o aplicativo estiver em execução, digite o seguinte prompt de teste:

   List all of the resource groups in my subscription
   

   A saída para o 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 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óximos passos