Quickstart: Servidores anfitriões construídos com SDKs MCP no Azure Functions

Neste início rápido, aprenderás como alojar em servidores Azure Functions Model Context Protocol (MCP) que criarás usando SDKs MCP oficiais. O alojamento do plano Flex Consumption permite-lhe aproveitar a escala sem servidores do Azure Functions, o modelo de faturação pague pelo que usar e as funcionalidades de segurança integradas. É perfeito para servidores MCP que usam o transporte HTTP transmissível.

Este artigo utiliza um projeto de servidor MCP de exemplo construído a partir de SDKs oficiais MCP.

Sugestão

O Functions também disponibiliza uma extensão MCP que permite criar servidores MCP utilizando o modelo de programação Azure Functions. Para mais informações, consulte Quickstart: Construa um servidor MCP remoto personalizado usando Azure Functions.

Como o novo servidor funciona num plano Flex Consumption, que segue um modelo de faturação pay-as-you-go, completar este quickstart implica um pequeno custo de alguns cêntimos ou menos na sua conta do Azure.

Importante

Embora alojar os seus servidores MCP usando Handlers Personalizados seja suportado para todas as linguagens de programação, atualmente este cenário de início rápido só tem exemplos para C#, Python e TypeScript. Para completar este quickstart, selecione uma destas línguas suportadas no topo do artigo.

Pré-requisitos

• SDK do .NET 8

• Node.js 22 ou acima

• Python 3.11 ou superior
• uv para gestão de pacotes Python

• Visual Studio Code com estas extensões:

  • Extensão do Azure Functions. Esta extensão requer Azure Functions Core Tools v4.5.0 ou superior e tenta instalá-la quando não está disponível.

  • Extensão CLI do Azure Developer.

• Azure Developer CLI v1.17.2 ou superior

• Azure CLI (Interface de Linha de Comandos). Você também pode executar comandos da CLI do Azure no Azure Cloud Shell.

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.

Observação

Este exemplo exige que tenha permissão para criar uma aplicação Microsoft Entra na subscrição Azure que utiliza.

Comece com um projeto de exemplo

A forma mais fácil de começar é clonar um projeto de exemplo de servidor MCP construído com SDKs oficiais MCP:

1. No Visual Studio Code, abra uma pasta ou espaço de trabalho onde você deseja criar seu projeto.

2. No Terminal, execute este comando para inicializar o exemplo .NET:

   azd init --template mcp-sdk-functions-hosting-dotnet -e mcpsdkserver-dotnet
   

   Este comando extrai os arquivos de projeto do repositório de modelos e inicializa o projeto na pasta atual. O -e sinalizador define um nome para o ambiente atual. No azd, o ambiente mantém um contexto de implantação exclusivo para seu aplicativo e você pode definir mais de um. Também é usado nos nomes dos recursos que crias no Azure.

2. No Terminal, execute este comando para inicializar o exemplo TypeScript:

   azd init --template mcp-sdk-functions-hosting-node  -e mcpsdkserver-node
   

   Este comando extrai os arquivos de projeto do repositório de modelos e inicializa o projeto na pasta atual. O -e sinalizador define um nome para o ambiente atual. No azd, o ambiente mantém um contexto de implantação exclusivo para seu aplicativo e você pode definir mais de um. Também é usado nos nomes dos recursos que crias no Azure.

2. No Terminal, execute este comando para inicializar o exemplo em Python:

   azd init --template mcp-sdk-functions-hosting-python -e mcpsdkserver-python
   

   Este comando extrai os arquivos de projeto do repositório de modelos e inicializa o projeto na pasta atual. O -e sinalizador define um nome para o ambiente atual. No azd, o ambiente mantém um contexto de implantação exclusivo para seu aplicativo e você pode definir mais de um. Também é usado nos nomes dos recursos que crias no Azure.

O modelo do projeto de código é para um servidor MCP com ferramentas que acedem a APIs meteorológicas públicas.

Execute o servidor MCP localmente

O Visual Studio Code integra-se com o Azure Functions Core Tools para permitir que execute este projeto no seu computador local de desenvolvimento.

1. Abra o Terminal no editor (Ctrl+Shift+` )

2. No diretório raiz, execute func start para iniciar o servidor. O painel Terminal exibe a saída das Ferramentas Principais.

2. No diretório raiz, execute npm install para instalar dependências, depois execute npm run build.
3. Para iniciar o servidor, execute func start.

2. No diretório raiz, execute uv run func start para criar um ambiente virtual, instale dependências e inicie o servidor.

Servidor de teste usando o GitHub Copilot

Para verificar o seu servidor usando o GitHub Copilot no Visual Studio Code, siga estes passos:

1. Abra o mcp.json arquivo no diretório .vscode.

2. Inicie o servidor selecionando o botão Start acima da local-mcp-server configuração.

3. Na janela do Copilot Chat , certifique-se de que o modelo Agente está selecionado, selecione o ícone Configurar ferramentas e confirme que está MCP Server:local-mcp-server ativado no chat.

4. Executa este prompt no chat:

   Return the weather forecast for New York City using #local-mcp-server
   

   O Copilot deveria ligar para uma das ferramentas meteorológicas para ajudar a responder a esta questão. Quando lhe for solicitado executar a ferramenta, selecione Permitir neste Workspace para não ter que estar sempre a reatribuir esta permissão.

Depois de verificares a funcionalidade da ferramenta localmente, podes parar o servidor e implementar o código do projeto no Azure.

Publicar no Azure

Este projeto está configurado para usar o azd up comando para implantar esse projeto em um novo aplicativo de função em um plano de Consumo Flex no Azure. O projeto inclui um conjunto de ficheiros Bicep que azd servem para criar uma implementação segura que segue as melhores práticas.

1. Entre no Azure:

   azd login
   

2. Configure o Visual Studio Code como uma aplicação cliente pré-autorizada:

   azd env set PRE_AUTHORIZED_CLIENT_IDS aebc6443-996d-45c2-90f0-388ff96faa56
   

   Uma aplicação pré-autorizada pode autenticar-se e aceder ao seu servidor MCP sem exigir mais pedidos de consentimento.

3. No Visual Studio Code, pressione F1 para abrir a paleta de comandos. Procure e execute o comando Azure Developer CLI (azd): Package, Provision and Deploy (up). Em seguida, entre usando sua conta do Azure.

4. Quando solicitado, forneça estes parâmetros de implantação necessários:

   Parâmetro	Description
   Subscrição do Azure	Subscrição na qual os seus recursos são criados.
   localização do Azure	Região do Azure na qual criar o grupo de recursos que contém os novos recursos do Azure. Apenas as regiões que atualmente suportam o plano Flex Consumption são mostradas.

   Depois de o comando ser concluído com sucesso, vês ligações para os recursos que criaste e para o endpoint do teu servidor MCP implementado. Anota o nome da tua aplicação de função, que precisas para a próxima secção.

   Sugestão

   Se ocorrer um erro ao executar o azd up comando, basta reexecutá-lo. Podes correr azd up repetidamente porque evita criar quaisquer recursos que já existam. Também pode ligar azd up novamente ao implementar atualizações no seu serviço.

Liga-te ao servidor MCP remoto

Seu servidor MCP agora está em execução no Azure. Para ligar o GitHub Copilot ao seu servidor remoto, configure-o nas definições do seu espaço de trabalho.

1. No ficheiro mcp.json, altere para o servidor remoto selecionando Parar para a configuração local-mcp-server e Iniciar na configuração remote-mcp-server.

2. Quando solicitado o domínio da sua app de função, introduza o nome da sua app de função que mencionou na secção anterior. Quando for solicitado para autenticar na Microsoft, selecione Permitir e depois escolha a sua conta Azure.

3. Verifique o servidor remoto fazendo uma pergunta como:

   Return the weather forecast for Seattle using #remote-mcp-server.
   

   O Copilot liga para uma das ferramentas meteorológicas para responder à questão.

Sugestão

Pode ver a saída de um servidor selecionando Mais...>Mostrar resultados. A saída fornece informações úteis sobre possíveis falhas de ligação. Também pode selecionar o ícone de engrenagem para alterar os níveis de log para Rastros e obter mais detalhes sobre as interações entre o cliente (Visual Studio Code) e o servidor.

Rever o código (opcional)

Pode rever o código que define o servidor MCP:

O código do servidor MCP está definido na raiz do projeto. O servidor utiliza o SDK oficial C# MCP para definir estas ferramentas relacionadas com o tempo:

using ModelContextProtocol;
using ModelContextProtocol.Server;
using System.ComponentModel;
using System.Globalization;
using System.Text.Json;

namespace QuickstartWeatherServer.Tools;

[McpServerToolType]
public sealed class WeatherTools
{
    [McpServerTool, Description("Get weather alerts for a US state.")]
    public static async Task<string> GetAlerts(
        HttpClient client,
        [Description("The US state to get alerts for. Use the 2 letter abbreviation for the state (e.g. NY).")] string state)
    {
        using var jsonDocument = await client.ReadJsonDocumentAsync($"/alerts/active/area/{state}");
        var jsonElement = jsonDocument.RootElement;
        var alerts = jsonElement.GetProperty("features").EnumerateArray();

        if (!alerts.Any())
        {
            return "No active alerts for this state.";
        }

        return string.Join("\n--\n", alerts.Select(alert =>
        {
            JsonElement properties = alert.GetProperty("properties");
            return $"""
                    Event: {properties.GetProperty("event").GetString()}
                    Area: {properties.GetProperty("areaDesc").GetString()}
                    Severity: {properties.GetProperty("severity").GetString()}
                    Description: {properties.GetProperty("description").GetString()}
                    Instruction: {properties.GetProperty("instruction").GetString()}
                    """;
        }));
    }

    [McpServerTool, Description("Get weather forecast for a location.")]
    public static async Task<string> GetForecast(
        HttpClient client,
        [Description("Latitude of the location.")] double latitude,
        [Description("Longitude of the location.")] double longitude)
    {
        var pointUrl = string.Create(CultureInfo.InvariantCulture, $"/points/{latitude},{longitude}");
        using var jsonDocument = await client.ReadJsonDocumentAsync(pointUrl);
        var forecastUrl = jsonDocument.RootElement.GetProperty("properties").GetProperty("forecast").GetString()
            ?? throw new Exception($"No forecast URL provided by {client.BaseAddress}points/{latitude},{longitude}");

        using var forecastDocument = await client.ReadJsonDocumentAsync(forecastUrl);
        var periods = forecastDocument.RootElement.GetProperty("properties").GetProperty("periods").EnumerateArray();

        return string.Join("\n---\n", periods.Select(period => $"""
                {period.GetProperty("name").GetString()}
                Temperature: {period.GetProperty("temperature").GetInt32()}°F
                Wind: {period.GetProperty("windSpeed").GetString()} {period.GetProperty("windDirection").GetString()}
                Forecast: {period.GetProperty("detailedForecast").GetString()}
                """));
    }
}

Pode ver o modelo completo do projeto no repositório GitHub de Azure Functions .NET MCP SDK.

O código do servidor MCP está definido no server.py ficheiro. O servidor utiliza o SDK oficial Python MCP para definir ferramentas relacionadas com o clima. Esta é a definição da get_forecast ferramenta:

import os
import sys
import warnings
import logging
from typing import Any
from pathlib import Path

import httpx
from azure.identity import OnBehalfOfCredential, ManagedIdentityCredential
from mcp.server.fastmcp import FastMCP
from fastmcp.server.dependencies import get_http_request
from starlette.requests import Request
from starlette.responses import HTMLResponse

# Initialize FastMCP server
mcp = FastMCP("weather", stateless_http=True)

# Constants
NWS_API_BASE = "https://api.weather.gov"
USER_AGENT = "weather-app/1.0"
@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
    """Get weather forecast for a location.

    Args:
        latitude: Latitude of the location
        longitude: Longitude of the location
    """
    # First get the forecast grid endpoint
    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
    points_data = await make_nws_request(points_url)

    if not points_data:
        return "Unable to fetch forecast data for this location."

    # Get the forecast URL from the points response
    forecast_url = points_data["properties"]["forecast"]
    forecast_data = await make_nws_request(forecast_url)

    if not forecast_data:
        return "Unable to fetch detailed forecast."

    # Format the periods into a readable forecast
    periods = forecast_data["properties"]["periods"]
    forecasts = []
    for period in periods[:5]:  # Only show next 5 periods
        forecast = f"""
{period['name']}:
Temperature: {period['temperature']}°{period['temperatureUnit']}
Wind: {period['windSpeed']} {period['windDirection']}
Forecast: {period['detailedForecast']}
"""
        forecasts.append(forecast)

    return "\n---\n".join(forecasts)

Pode ver o modelo completo do projeto no Azure Functions Python MCP SDK que hospeda o repositório GitHub.

O código do servidor MCP é definido na src pasta. O servidor utiliza o SDK oficial Node.js MCP para definir ferramentas relacionadas com o clima. Esta é a definição da get-forecast ferramenta:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";
import { ManagedIdentityCredential, OnBehalfOfCredential } from '@azure/identity';

const NWS_API_BASE = "https://api.weather.gov";
const USER_AGENT = "weather-app/1.0";

// Function to create a new server instance for each request (stateless)
export const createServer = () => {
  const server = new McpServer({
    name: "weather",
    version: "1.0.0",
  });
  server.registerTool(
    "get-forecast",
    {
      title: "Get Weather Forecast",
      description: "Get weather forecast for a location",
      inputSchema: {
        latitude: z.number().min(-90).max(90).describe("Latitude of the location"),
        longitude: z
          .number()
          .min(-180)
          .max(180)
          .describe("Longitude of the location"),
      },
      outputSchema: z.object({
        forecast: z.string(),
      }),
    },
    async ({ latitude, longitude }) => {
      // Get grid point data
      const pointsUrl = `${NWS_API_BASE}/points/${latitude.toFixed(4)},${longitude.toFixed(4)}`;
      const pointsData = await makeNWSRequest<PointsResponse>(pointsUrl);

      if (!pointsData) {
        const output = { forecast: `Failed to retrieve grid point data for coordinates: ${latitude}, ${longitude}. This location may not be supported by the NWS API (only US locations are supported).` };
        return {
          content: [{ type: "text", text: JSON.stringify(output) }],
          structuredContent: output,
        };
      }

      const forecastUrl = pointsData.properties?.forecast;
      if (!forecastUrl) {
        const output = { forecast: "Failed to get forecast URL from grid point data" };
        return {
          content: [{ type: "text", text: JSON.stringify(output) }],
          structuredContent: output,
        };
      }

      // Get forecast data
      const forecastData = await makeNWSRequest<ForecastResponse>(forecastUrl);
      if (!forecastData) {
        const output = { forecast: "Failed to retrieve forecast data" };
        return {
          content: [{ type: "text", text: JSON.stringify(output) }],
          structuredContent: output,
        };
      }

      const periods = forecastData.properties?.periods || [];
      if (periods.length === 0) {
        const output = { forecast: "No forecast periods available" };
        return {
          content: [{ type: "text", text: JSON.stringify(output) }],
          structuredContent: output,
        };
      }

      // Format forecast periods
      const formattedForecast = periods.map((period: ForecastPeriod) =>
        [
          `${period.name || "Unknown"}:`,
          `Temperature: ${period.temperature || "Unknown"}°${period.temperatureUnit || "F"}`,
          `Wind: ${period.windSpeed || "Unknown"} ${period.windDirection || ""}`,
          `${period.shortForecast || "No forecast available"}`,
          "---",
        ].join("\n"),
      );

      const forecastText = `Forecast for ${latitude}, ${longitude}:\n\n${formattedForecast.join("\n")}`;
      const output = { forecast: forecastText };

      return {
        content: [{ type: "text", text: forecastText }],
        structuredContent: output,
      };
    },
  );
  return server;
}

Pode ver o modelo completo do projeto no Azure Functions TypeScript MCP SDK, que hospeda o repositório GitHub.

Limpeza de recursos

Quando terminar de trabalhar com seu servidor MCP e recursos relacionados, use este comando para excluir o aplicativo de função e seus recursos relacionados do Azure para evitar incorrer em custos adicionais:

azd down