Como Usar Servidores MCP do Azure Functions (Guia para Iniciantes)

O Protocolo de Contexto de Modelo (MCP) é um padrão emergente que permite que aplicações forneçam contexto e capacidades a grandes modelos de linguagem (LLMs). Uma característica chave do MCP é sua capacidade de definir ferramentas que agentes de IA podem utilizar para realizar tarefas. O Azure Functions MCP fecha a lacuna entre computação em nuvem sem servidor e capacidades de assistente de IA, permitindo que desenvolvedores construam ferramentas escaláveis que possam ser acessadas por agentes de IA.

Neste tutorial, vamos explorar o que é o Azure Functions MCP, como instalá-lo, como iniciar um servidor MCP e como utilizá-lo com o GitHub Copilot. Ao final deste guia, você terá um servidor MCP funcional em execução que pode ser acessado por agentes de IA para realizar tarefas úteis.

Dica Pro: Ao construir seus servidores MCP, você precisará testar esses pontos de extremidade de API minuciosamente. Recomendo fortemente experimentar o Apidog - é a melhor alternativa ao Postman que encontrei para testes e desenvolvimento de APIs.

botão

Diferente das ferramentas tradicionais de API, o Apidog oferece servidores mock integrados, testes automatizados e um espaço de trabalho colaborativo que é particularmente útil ao trabalhar com arquiteturas orientadas a eventos como o Azure Functions.

botão

A capacidade de visualizar fluxos de SSE em tempo real será inestimável enquanto você depura suas implementações de servidor MCP. Você pode obtê-lo em apidog.com para simplificar seu fluxo de desenvolvimento.

botão

O que é o Servidor Azure Functions MCP?

O Servidor Azure Functions MCP é um recurso experimental que adiciona suporte ao Protocolo de Contexto de Modelo (MCP) ao Azure Functions, a solução de computação sem servidor da Microsoft. Ele introduz gatilhos e vinculadores especializados especificamente projetados para criar ferramentas que agentes de IA podem usar via MCP.

Essa integração permite que os desenvolvedores construam servidores MCP remotos em escala de nuvem com eventos enviados pelo servidor (SSE) que podem ser utilizados por modelos de IA, como os do GitHub Copilot. O Azure Functions MCP fornece uma maneira contínua de desenvolver ferramentas assistivas de IA orientadas a eventos que podem escalar automaticamente em ambientes Python, Node.js (TypeScript) e .NET (C#).

O componente chave é o gatilho de ferramenta MCP, que permite que funções atuem como ferramentas com propriedades definidas que agentes de IA podem descobrir e invocar com base no contexto.

Como Instalar o Servidor Azure Functions MCP

Vamos explorar os passos para instalar e configurar o Azure Functions MCP:

Pré-requisitos

Visual Studio Code
Azure Functions Core Tools
.NET SDK 6.0 ou posterior (para desenvolvimento em C#)
Node.js (para desenvolvimento em TypeScript)
Python 3.8 ou posterior (para desenvolvimento em Python)
Azure CLI (para implantação no Azure)

Passos de Instalação

Crie um projeto Azure Functions: Comece criando um novo projeto Azure Functions na sua linguagem preferida. Você pode seguir a documentação do Azure Functions para Visual Studio Code para criar um projeto.

Adicione a extensão MCP:

Para C#:

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Mcp --version 1.0.0-preview.1

Para Python e Node.js, você precisará adicionar um pacote de extensão experimental ao seu arquivo host.json:

"extensionBundle": {
  "id": "Microsoft.Azure.Functions.ExtensionBundle.Experimental",
  "version": "[4.*, 5.0.0)"
}

Instale o Azurite (para desenvolvimento local): Como a extensão MCP utiliza armazenamento em blob, você precisará executar o Azurite, o emulador de Armazenamento do Azure, localmente:

Abra o painel de comandos (Shift + Ctrl + P)

Selecione "Azurite: Iniciar"

Atualize seu local.settings.json para utilizá-lo:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated"
  }
}

Como Iniciar o Servidor Azure Functions MCP

Agora que você instalou a extensão MCP, vamos criar e executar um servidor MCP:

Criando uma Ferramenta MCP

Aqui está um exemplo de como criar uma ferramenta simples de utilidade de tempo em C#:

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Mcp;
using System.Globalization;
using System.Text.Json;

namespace AzfuncMcp;

public class TimeUtil
{
    [Function(nameof(GetCurrentTime))]
    public string GetCurrentTime(
        [McpToolTrigger("getcurrenttime", "Obtém a hora atual. Se nenhum fuso horário for especificado, a ferramenta retornará a hora em UTC.")] ToolInvocationContext context,
        [McpToolProperty("timezone", "string", "O nome do fuso horário.")] string timezone = "UTC")
    {
        try
        {
            TimeZoneInfo timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(timezone);
            DateTime currentTime = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, timeZoneInfo);

            var response = new {
                timezone = timeZoneInfo.StandardName,
                time = currentTime.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture),
                displayName = timeZoneInfo.DisplayName
            };

            return JsonSerializer.Serialize(response);
        }
        catch (TimeZoneNotFoundException)
        {
            return $"O fuso horário '{timezone}' não foi encontrado.";
        }
        catch (InvalidTimeZoneException)
        {
            return $"O fuso horário '{timezone}' é inválido.";
        }
        catch
        {
            return "Não foi possível obter a hora atual.";
        }
    }
}

Configurando Program.cs para MCP

Atualize seu arquivo Program.cs para registrar a ferramenta MCP:

using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;
using AzfuncMcp;

var builder = FunctionsApplicationBuilder.CreateBuilder(args);
builder.ConfigureFunctionsWebApplication();
builder.EnableMcpToolMetadata();
builder.ConfigureMcpTool(nameof(TimeUtil.GetCurrentTime))
    .WithProperty("timezone", "string", "O fuso horário.");

builder.Build().Run();

Iniciando o Servidor

Para iniciar o servidor MCP localmente:

Certifique-se de que o Azurite esteja em execução.

Abra um terminal no diretório do seu projeto.

Execute este comando:

func start

Ou use os recursos de depuração do Visual Studio Code:

Abra a exibição "Executar e Depurar"
Selecione "Anexar às Funções .NET"
Pressione F5 ou clique no botão verde de reproduzir

Uma vez iniciado, seu servidor MCP estará acessível em: http://localhost:7071/runtime/webhooks/mcp/sse

Como Usar o Servidor Azure Functions MCP com GitHub Copilot

Agora que seu servidor MCP está em execução, vamos conectá-lo ao GitHub Copilot:

Configurando GitHub Copilot para Usar Seu Servidor MCP

Adicione seu servidor MCP ao VS Code:

Abra o Painel de Comandos (Shift + Ctrl + P)
Digite e selecione "MCP: Adicionar Servidor"

Escolha a opção "HTTP (eventos enviados pelo servidor)"

Insira a URL: http://localhost:7071/runtime/webhooks/mcp/sse
Dê um nome ao seu servidor (ex: "meu-servidor-azfunc-mcp")

Verifique a configuração: O arquivo settings.json em seu espaço de trabalho do VS Code deve ser atualizado com algo como:

"mcp": {
  "inputs": [],
  "servers": {
    "meu-servidor-azfunc-mcp": {
      "type": "sse",
      "url": "<http://localhost:7071/runtime/webhooks/mcp/sse>"
    }
  }
}

Remova servidores de exemplo, se necessário: Se houver servidores de exemplo pré-configurados (como "mcp-server-time"), você pode querer removê-los para evitar conflitos com sua implementação.

Usando Seu Servidor MCP com GitHub Copilot

Abra o GitHub Copilot Chat:

Certifique-se de que o modo esteja definido como "Modo Agente" (isso é essencial para a funcionalidade MCP)

Ative seu servidor MCP:

Clique no ícone de configurações do MCP (ícone de chave e chave de fenda)
Certifique-se de que seu servidor MCP adicionado esteja ativado

Interaja com sua ferramenta:

Na janela de chat, faça uma pergunta que exigiria sua ferramenta MCP
Por exemplo, com nossa ferramenta de utilidade de tempo, você poderia perguntar "Que horas são agora?" ou "Qual é a hora atual em Tóquio?"
O GitHub Copilot solicitará sua permissão para usar a ferramenta externa MCP
Após clicar em "Continuar", o Copilot invocará sua ferramenta MCP e exibirá os resultados

Veja sua função em ação: Se você estiver executando no modo de depuração, poderá definir pontos de interrupção em sua função e vê-los sendo acionados quando o GitHub Copilot invocar sua ferramenta.

Implantando no Azure

Para uso em produção, você vai querer implantar seu servidor MCP no Azure:

Implante seu aplicativo de função usando Azure Functions Core Tools ou Azure Developer CLI:

func azure functionapp publish <nome-do-seu-aplicativo-de-função>

azd up

Configure o cliente MCP com autenticação: Ao acessar uma Função do Azure implantada, você precisará fornecer autenticação. Atualize seu settings.json:

"mcp": {
  "inputs": [
    {
      "type": "promptString",
      "id": "functions-mcp-extension-system-key",
      "description": "Chave do Sistema da Extensão MCP do Azure Functions",
      "password": true
    }
  ],
  "servers": {
    "meu-servidor-azfunc-mcp": {
      "type": "sse",
      "url": "<nome-do-seu-aplicativo>.azurewebsites.net/runtime/webhooks/mcp/sse",
      "headers": {
        "x-functions-key": "${input:functions-mcp-extension-system-key}"
      }
    }
  }
}

Obtenha sua chave de função:

Navegue até seu aplicativo de função no Azure Portal
Vá para Chaves do Aplicativo
Copie a chave do sistema mcp_extension

Exemplos de Casos de Uso

O Azure Functions MCP pode ser utilizado para vários cenários:

Gerenciamento de trechos de código: Crie ferramentas para salvar e recuperar trechos de código
Recuperação de dados: Acesse bancos de dados ou APIs para buscar informações específicas
Cálculos: Realize cálculos complexos que não podem ser facilmente feitos pelo LLM
Integração de sistemas externos: Conecte-se a sistemas empresariais, APIs ou serviços

Limitações e Considerações

Este é um preview experimental inicial, então espere alterações que possam quebrar a compatibilidade conforme o recurso evolui.
No momento da escrita, a hospedagem do Azure Functions no Windows pode ter problemas com MCP; a hospedagem no Linux é recomendada.
Embora o MCP atualmente suporte ferramentas, outros recursos como prompts serão adicionados com o tempo.
Como este é um recurso em preview, ele ainda não qualifica para planos de suporte padrão do Azure.

Conclusão

O Azure Functions MCP fornece uma maneira poderosa de estender agentes de IA com ferramentas personalizadas que podem aproveitar todo o potencial do ecossistema Azure. Ao seguir este guia, você aprendeu como instalar, configurar e usar o Azure Functions MCP com o GitHub Copilot.

À medida que o MCP se torna mais amplamente adotado, ter essas habilidades permitirá que você crie aplicações cada vez mais sofisticadas com IA que combinam as capacidades de raciocínio de grandes modelos de linguagem com as capacidades de execução do seu código personalizado.

Lembre-se de que o MCP é um padrão em evolução e o Azure Functions MCP está em preview, portanto, fique atento à documentação oficial e aos fóruns da comunidade para atualizações e melhores práticas.

Recursos

Ao seguir este guia, agora você possui o conhecimento para aproveitar o Azure Functions MCP para criar ferramentas poderosas que podem ser usadas por agentes de IA através do GitHub Copilot e outras interfaces compatíveis com MCP.