Démarrage rapide : Serveurs hôtes créés avec des kits SDK MCP sur Azure Functions

Prerequisites

• SDK .NET 8

• Node.js 22 ou versions ultérieures

• Python 3.11 ou version ultérieure
• uv pour la gestion des packages Python

• Visual Studio Code avec ces extensions :

  • Extension Azure Functions Cette extension nécessite Azure Functions Core Tools v4.5.0 ou version ultérieure et tente de l’installer lorsqu’elle n’est pas disponible.

  • Extension Azure Developer CLI

• Azure Developer CLI v1.17.2 ou version ultérieure

• Azure CLI. Vous pouvez également exécuter des commandes Azure CLI dans Azure Cloud Shell.

• Un compte Azure avec un abonnement actif. Créez un compte gratuitement.

Commencez avec un projet d'exemple

Le moyen le plus simple de commencer consiste à cloner un exemple de projet de serveur MCP créé avec des kits SDK MCP officiels :

1. Dans Visual Studio Code, ouvrez un dossier ou un espace de travail dans lequel vous souhaitez créer votre projet.

2. Dans le terminal, exécutez cette commande pour initialiser l’exemple .NET :

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

   Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier actif. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans les noms des ressources que vous créez dans Azure.

2. Dans le terminal, exécutez cette commande pour initialiser l’exemple TypeScript :

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

   Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier actif. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans les noms des ressources que vous créez dans Azure.

2. Dans le terminal, exécutez cette commande pour initialiser l’exemple Python :

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

   Cette commande extrait les fichiers projet du référentiel de modèles et initialise le projet dans le dossier actif. L’indicateur -e définit un nom pour l’environnement actuel. Dans azd, l’environnement gère un contexte de déploiement unique pour votre application et vous pouvez en définir plusieurs. Il est également utilisé dans les noms des ressources que vous créez dans Azure.

Le modèle de projet de code est destiné à un serveur MCP avec des outils qui accèdent aux API météorologiques publiques.

Exécuter le serveur MCP localement

Visual Studio Code s’intègre à Azure Functions Core Tools pour vous permettre d’exécuter ce projet sur votre ordinateur de développement local.

1. Ouvrir Terminal dans l’éditeur (Ctrl+Shift+` )

2. Dans le répertoire racine, exécutez func start pour démarrer le serveur. Le panneau Terminal affiche la sortie des outils principaux.

2. Dans le répertoire racine, exécutez npm install pour installer les dépendances, puis exécutez npm run build.
3. Pour démarrer le serveur, exécutez func start.

2. Dans le répertoire racine, exécutez uv run func start pour créer un environnement virtuel, installer des dépendances et démarrer le serveur.

Serveur de test à l’aide de GitHub Copilot

Pour vérifier votre serveur à l’aide de GitHub Copilot dans Visual Studio Code, procédez comme suit :

1. Ouvrez le fichier mcp.json dans le répertoire .vscode.

2. Démarrez le serveur en sélectionnant le bouton Démarrer au-dessus de la local-mcp-server configuration.

3. Dans la fenêtre Conversation Copilot, vérifiez que le modèle Agent est sélectionné, sélectionnez l’icône Configurer les outils et vérifiez qu’il MCP Server:local-mcp-server est activé dans la conversation.

4. Exécutez cette invite dans la conversation :

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

   Copilot devrait appeler l’un des outils météorologiques pour aider à répondre à cette question. Lorsque vous êtes invité à exécuter l’outil, sélectionnez Autoriser dans cet espace de travail afin que vous n’ayez pas à conserver cette autorisation.

Après avoir vérifié la fonctionnalité d’outil localement, vous pouvez arrêter le serveur et déployer le code du projet sur Azure.

Déployer sur Azure

Ce projet est configuré pour utiliser la commande azd up visant à déployer ce projet dans une nouvelle application de fonction dans un plan Consommation flexible dans Azure. Le projet inclut un ensemble de fichiers Bicep que azd utilise pour créer un déploiement sécurisé qui suit les meilleures pratiques.

1. Connectez-vous à Azure :

   azd login
   

2. Configurez Visual Studio Code en tant qu’application cliente pré-autorisée :

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

   Une application pré-autorisée peut s’authentifier auprès de votre serveur MCP et y accéder sans nécessiter d’invites de consentement supplémentaires.

3. Dans Visual Studio Code, appuyez sur F1 pour ouvrir la palette de commandes. Recherchez et exécutez la commande Azure Developer CLI (azd): Package, Provision and Deploy (up). Ensuite, connectez-vous à l’aide de votre compte Azure.

4. Lorsque vous y êtes invité, fournissez ces paramètres de déploiement requis :

   Paramètre	Descriptif
   Abonnement Azure	Abonnement dans lequel vos ressources sont créées.
   Emplacement Azure	Région Azure dans laquelle créer le groupe de ressources qui contient les nouvelles ressources Azure. Seules sont montrées les régions qui prennent actuellement en charge le plan Consommation flexible.

   Une fois la commande terminée, vous voyez des liens vers les ressources que vous avez créées et le point de terminaison de votre serveur MCP déployé. Notez le nom de votre application de fonction, dont vous avez besoin pour la section suivante.

   Conseil / Astuce

   Si une erreur se produit lors de l’exécution de la azd up commande, réexécutez simplement la commande. Vous pouvez exécuter azd up à plusieurs reprises, car il ignore la création de toutes les ressources qui existent déjà. Vous pouvez également appeler azd up à nouveau lors du déploiement de mises à jour sur votre service.

Se connecter au serveur MCP distant

Votre serveur MCP s’exécute désormais dans Azure. Pour connecter GitHub Copilot à votre serveur distant, configurez-le dans les paramètres de votre espace de travail.

1. Dans le mcp.json fichier, basculez vers le serveur distant en sélectionnant Arrêter pour la local-mcp-server configuration et Démarrer sur la remote-mcp-server configuration.

2. Lorsque vous êtes invité à entrer le domaine de l’application de fonction, entrez le nom de votre application de fonction que vous avez notée dans la section précédente. Lorsque vous êtes invité à s’authentifier auprès de Microsoft, sélectionnez Autoriser , puis choisissez votre compte Azure.

3. Vérifiez le serveur distant en posant une question telle que :

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

   Copilot appelle l’un des outils météorologiques pour répondre à la requête.

Examiner le code (facultatif)

Vous pouvez consulter le code qui définit le serveur MCP :

Le code du serveur MCP est défini à la racine du projet. Le serveur utilise le SDK MCP C# officiel pour définir ces outils météorologiques :

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()}
                """));
    }
}

Vous pouvez consulter le modèle de projet complet dans le dépôt GitHub hébergeant le kit de développement logiciel (SDK) Azure Functions .NET MCP.

Le code du serveur MCP est défini dans le server.py fichier. Le serveur utilise le Kit de développement logiciel (SDK) Python MCP officiel pour définir des outils liés aux conditions météorologiques. Il s’agit de la définition de l’outil get_forecast :

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)

Vous pouvez consulter le modèle de projet complet dans le dépôt GitHub hébergeant le SDK Python MCP d'Azure Functions.

Le code du serveur MCP est défini dans le src dossier. Le serveur utilise le kit de développement logiciel (SDK) MCP officiel Node.js pour définir des outils liés aux conditions météorologiques. Il s’agit de la définition de l’outil get-forecast :

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;
}

Vous pouvez consulter le modèle de projet complet dans le dépôt GitHub d'hébergement Azure Functions TypeScript MCP SDK.

Nettoyer les ressources

Lorsque vous avez terminé d’utiliser votre serveur MCP et vos ressources associées, utilisez cette commande pour supprimer l’application de fonction et ses ressources associées d’Azure afin d’éviter les coûts supplémentaires :

azd down