Démarrage rapide : Créer un serveur MCP distant personnalisé à l’aide de Azure Functions

Cet article prend en charge la version 4 du modèle de programmation Node.js pour Azure Functions.

Cet article prend en charge la version 2 du modèle de programmation Python pour Azure Functions.

Prerequisites

• .NET SDK 8.0

• kit de développement Java 17
  • Si vous utilisez une autre version prise en charge de Java, mettez à jour le fichier pom.xml du projet.
  • Définissez la variable d’environnement JAVA_HOME sur l’emplacement d’installation de la version correcte du kit de développement Java (JDK).
• Apache Maven 3.8.x

• Node.js 22

• Python 3.11

• Visual Studio Code avec les extensions suivantes :

  • extension Azure Functions. Cette extension nécessite Azure Functions Core Tools et tente de l’installer lorsqu’elle n’est pas disponible.

  • Extension CLI pour développeur Azure.

• Émulateur de stockage Azurite

• 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.

Initialiser le projet

Utilisez la commande azd init pour créer un projet de code Azure Functions local à partir d’un modèle.

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 azd init commande :

   azd init --template remote-mcp-functions-dotnet -e mcpserver-dotnet
   

   Cette commande extrait les fichiers projet du dépôt template 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 fait également partie du nom du groupe de ressources que vous créez dans Azure.

2. Dans votre terminal local ou invite de commandes, exécutez cette azd init commande :

   azd init --template remote-mcp-functions-java -e mcpserver-java
   

   Cette commande extrait les fichiers projet du dépôt template 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 fait également partie des noms des ressources que vous créez dans Azure.

2. Dans votre terminal local ou invite de commandes, exécutez cette azd init commande :

   azd init --template remote-mcp-functions-javascript -e mcpserver-js
   

   Cette commande extrait les fichiers projet du dépôt template 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 fait également partie des noms des ressources que vous créez dans Azure.

2. Dans votre terminal local ou invite de commandes, exécutez cette azd init commande :

   azd init --template remote-mcp-functions-typescript -e mcpserver-ts
   

   Cette commande extrait les fichiers projet du dépôt template 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 fait également partie des noms des ressources que vous créez dans Azure.

2. Dans votre terminal local ou invite de commandes, exécutez cette azd init commande :

   azd init --template remote-mcp-functions-python -e mcpserver-python
   

   Cette commande extrait les fichiers projet du dépôt template 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 fait également partie des noms des ressources que vous créez dans Azure.

Démarrer l’émulateur de stockage

Utilisez l’émulateur Azurite pour simuler une connexion de compte stockage Azure lors de l’exécution locale de votre projet de code.

1. Si ce n’est déjà fait, installez Azurite.

2. Appuyez sur F1. Dans la palette de commandes, recherchez et exécutez la commande Azurite: Start pour démarrer l’émulateur de stockage local.

Exécuter votre serveur MCP localement

Dans une fenêtre de terminal, accédez au dossier du FunctionsMcpTool projet :

cd src/FunctionsMcpTool

Dans une fenêtre de terminal, accédez au dossier du FunctionsMcpTool projet :

cd samples/FunctionsMcpTool

Visual Studio Code s’intègre à Azure Functions Outils Core pour vous permettre d’exécuter ce projet sur votre ordinateur de développement local. Pour démarrer votre application Functions localement, appuyez sur F5 ou sélectionnez l’icône Exécuter et déboguer dans la barre d’activité de gauche.

Le panneau Terminal affiche la sortie des outils principaux. Votre application démarre dans le panneau Terminal et vous pouvez voir les noms des fonctions exécutées localement.

Vérifier à l’aide de GitHub Copilot

Le modèle de projet inclut un .vscode/mcp.json fichier qui définit déjà un local-mcp-function serveur pointant vers votre point de terminaison MCP local. Utilisez cette configuration pour vérifier votre code à l’aide de GitHub Copilot dans Visual Studio Code :

1. Ouvrez le .vscode/mcp.json fichier et sélectionnez le bouton Démarrer au-dessus de la local-mcp-function configuration.

2. Dans la fenêtre Copilot Chat, vérifiez que le mode Agent est sélectionné, sélectionnez l’icône Configure tools et vérifiez que MCP Server:local-mcp-function est activé dans la conversation.

3. Exécutez cette invite :

   Say Hello
   

   Lorsque vous êtes invité à exécuter l’outil, sélectionnez Autoriser dans cet espace de travail afin de ne pas avoir à accorder l’autorisation. La commande s’exécute et retourne une réponse Hello World, et les informations d’exécution de la fonction sont écrites dans les journaux.

4. À présent, sélectionnez du code dans l’un de vos fichiers de projet et exécutez cette invite :

   Save this snippet as snippet1
   

   Copilot stocke l’extrait de code et répond à votre demande avec des informations sur la façon de récupérer l’extrait à l’aide de l’outil getSnippets. Encore une fois, vous pouvez passer en revue l’exécution de la fonction dans les journaux et vérifier que la fonction saveSnippets s’est exécutée.

5. Dans le chat de Copilot, exécutez ce message d'invite :

   Retrieve snippet1 and apply to NewFile
   

   Copilot récupère les extraits de code, l’ajoute à un fichier appelé NewFile, et fait ce qu’il pense être nécessaire pour que l’extrait de code fonctionne dans votre projet. Les journaux Functions indiquent que le point de terminaison getSnippets a été appelé.

6. Lorsque vous avez terminé le test, appuyez sur Ctrl+C pour arrêter l’hôte Functions.

Examiner le code (facultatif)

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

Le code de fonction des outils serveur MCP est défini dans le src/functions dossier. L’inscription de la fonction MCP expose ces fonctions en tant qu’outils de serveur MCP :

const PROPERTY_TYPE = "string";

// Hello function - responds with hello message
async function mcpToolHello(_toolArguments, context) {
    console.log(_toolArguments);
    // Get name from the tool arguments
    const mcptoolargs = context.triggerMetadata.mcptoolargs;
    const name = mcptoolargs?.name;

    console.info(`Hello ${name}, I am MCP Tool!`);
    
    return `Hello ${name || 'World'}, I am MCP Tool!`;
}

// Register the hello tool
app.mcpTool('hello', {
    toolName: 'hello',
    description: 'Simple hello world MCP Tool that responses with a hello message.',

  const mcptoolargs = context.triggerMetadata.mcptoolargs;

  const snippetName = mcptoolargs?.snippetname;
  const snippet = mcptoolargs?.snippet;

  if (!snippetName) {
    return "No snippet name provided";
  }

  if (!snippet) {
    return "No snippet content provided";
  }

  // Save the snippet to blob storage using the output binding
  context.extraOutputs.set(blobOutputBinding, snippet);

  console.info(`Saved snippet: ${snippetName}`);
  return snippet;
}

// Register the GetSnippet tool
app.mcpTool("getSnippet", {
  toolName: GET_SNIPPET_TOOL_NAME,
  description: GET_SNIPPET_TOOL_DESCRIPTION,
  toolProperties: {
    [SNIPPET_NAME_PROPERTY_NAME]: arg.string().describe(SNIPPET_NAME_PROPERTY_DESCRIPTION)
  },
  extraInputs: [blobInputBinding],
  handler: getSnippet,
});

Vous pouvez afficher le modèle de projet complet dans le référentiel Azure Functions serveur MCP JavaScript GitHub.

Le code de fonction des outils serveur MCP est défini dans le src dossier. L’attribut McpToolTrigger expose les fonctions en tant qu’outils MCP Server :

[Function(nameof(SayHello))]
public string SayHello(
    [McpToolTrigger(HelloToolName, HelloToolDescription)] ToolInvocationContext context
)
{
    logger.LogInformation("C# MCP tool trigger function processed a request.");
    return "Hello I am MCP Tool!";
}

public class SnippetsTool(ILogger<SnippetsTool> logger)
{
    private const string BlobPath = "snippets/{mcptoolargs.Name}.json";

    private static BlobServiceClient GetBlobServiceClient() =>
        new(Environment.GetEnvironmentVariable("AzureWebJobsStorage"));

    [Function(nameof(GetSnippet))]
    public Snippet? GetSnippet(
        [McpToolTrigger(GetSnippetToolName, GetSnippetToolDescription)]
            ToolInvocationContext context,
        [McpToolProperty(SnippetNamePropertyName, SnippetNamePropertyDescription, true)]
            string name,
        [BlobInput(BlobPath)] string? snippetContent
    )
    {
        if (snippetContent is null)
        {
            return null;
        }

        return new Snippet { Name = name, Content = snippetContent };
    }

Vous pouvez afficher le modèle de projet complet dans le référentiel Azure Functions .NET MCP Server GitHub.

Le code de fonction des outils serveur MCP est défini dans le samples/FunctionsMcpTool/src/main/java/com/function/ dossier. L’annotation @McpToolTrigger expose les fonctions en tant qu’outils de serveur MCP :

@FunctionName("HelloWorld")
public String logCustomTriggerInput(
        @McpToolTrigger(
                name = "helloWorld",
                description = "Says hello and logs the messages that are provided.")
        McpToolInvocationContext mcpToolInvocationContext,
        @McpToolProperty(
            name = "messages",
            propertyType = "string",
            description = "The messages to be logged.",
            isRequired = true,
            isArray = true)
        String messages,
        final ExecutionContext functionExecutionContext
) {

@FunctionName("SaveSnippets")
@StorageAccount("AzureWebJobsStorage")
public String saveSnippet(
        @McpToolTrigger(
                name = "saveSnippets",
                description = "Saves a text snippet to your snippets collection.")
        String mcpToolInvocationContext,
        @McpToolProperty(
            name = SNIPPET_NAME_PROPERTY_NAME,
            propertyType = "string",
            description = "The name of the snippet.",
            isRequired = true)
        String snippetName,
        @McpToolProperty(
            name = SNIPPET_PROPERTY_NAME,
            propertyType = "string",
            description = "The content of the snippet.",
            isRequired = true)
        String snippet,
        @BlobOutput(name = "outputBlob", path = BLOB_PATH)
        OutputBinding<String> outputBlob,
        final ExecutionContext functionExecutionContext
) {
    // Log the entire incoming JSON for debugging
    functionExecutionContext.getLogger().info(mcpToolInvocationContext);

    // Log the snippet name and content
    functionExecutionContext.getLogger().info("Saving snippet with name: " + snippetName);
    functionExecutionContext.getLogger().info("Snippet content:\n" + snippet);

    // Write the snippet content to the output blob
    outputBlob.setValue(snippet);
    
    return "Successfully saved snippet '" + snippetName + "' with " + snippet.length() + " characters.";

Vous pouvez afficher le modèle de projet complet dans le référentiel Azure Functions Java MCP Server GitHub.

Le code de fonction des outils serveur MCP est défini dans le src/function_app.py fichier. Les annotations de fonction MCP exposent ces fonctions en tant qu’outils de serveur MCP :

from hello_tool_with_auth import bp as auth_bp
app.register_blueprint(auth_bp)

# Constants for the Azure Blob Storage container, file, and blob path
_SNIPPET_NAME_PROPERTY_NAME = "snippetname"
_BLOB_PATH = "snippets/{mcptoolargs." + _SNIPPET_NAME_PROPERTY_NAME + "}.json"

    """Hello world."""
    return "Hello I am MCPTool!"


@app.mcp_tool()
@app.mcp_tool_property(arg_name="snippetname", description="The name of the snippet.")
@app.blob_input(arg_name="file", connection="AzureWebJobsStorage", path=_BLOB_PATH)
def get_snippet(file: func.InputStream, snippetname: str) -> str:
    """Retrieve a snippet by name from Azure Blob Storage."""
    snippet_content = file.read().decode("utf-8")
    logging.info(f"Retrieved snippet: {snippet_content}")
    return snippet_content


@app.mcp_tool()

Vous pouvez afficher le modèle de projet complet dans le référentiel Azure Functions Python MCP Server GitHub.

Le code de fonction des outils serveur MCP est défini dans le mcp-tools/src dossier. L’inscription de la fonction MCP expose ces fonctions en tant qu’outils de serveur MCP :

// Hello function - responds with hello message
export async function mcpToolHello(_toolArguments: unknown, context: InvocationContext): Promise<string> {
    const mcptoolargs = context.triggerMetadata.mcptoolargs as {
        name?: string;
    };
    const name = mcptoolargs?.name;

    context.log(`Hello ${name}, I am MCP Tool!`);

    return `Hello ${name || 'World'}, I am MCP Tool!`;
}

// Register the hello tool
app.mcpTool('hello', {
    toolName: 'hello',
    description: 'Simple hello world MCP Tool that responds with a hello message.',
    toolProperties: {
        name: arg.string().describe('Required property to identify the caller.').optional()
    },
    handler: mcpToolHello
});

// Register the GetSnippet tool
app.mcpTool("getSnippet", {
  toolName: GET_SNIPPET_TOOL_NAME,
  description: GET_SNIPPET_TOOL_DESCRIPTION,
  toolProperties: {
    [SNIPPET_NAME_PROPERTY_NAME]: arg.string().describe(SNIPPET_NAME_PROPERTY_DESCRIPTION)
  },
  extraInputs: [blobInputBinding],
  handler: getSnippet,
});

// Register the SaveSnippet tool
app.mcpTool("saveSnippet", {
  toolName: SAVE_SNIPPET_TOOL_NAME,
  description: SAVE_SNIPPET_TOOL_DESCRIPTION,
  toolProperties: {
    [SNIPPET_NAME_PROPERTY_NAME]: arg.string().describe(SNIPPET_NAME_PROPERTY_DESCRIPTION),
    [SNIPPET_PROPERTY_NAME]: arg.string().describe(SNIPPET_PROPERTY_DESCRIPTION)
  },
  extraOutputs: [blobOutputBinding],
  handler: saveSnippet,
});

Vous pouvez afficher le modèle de projet complet dans le référentiel Azure Functions TypeScript MCP Server GitHub.

Après avoir vérifié les outils de serveur MCP localement, vous pouvez publier le projet sur Azure.

Déployer sur Azure

Ce projet est configuré pour utiliser azd pour déployer ce projet sur une nouvelle application de fonction dans un plan Flex Consumption dans Azure. Le projet inclut un ensemble de fichiers Bicep que azd exploite afin de réaliser un déploiement sécurisé vers un plan Consommation flexible conforme aux meilleures pratiques.

1. 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.

2. Lorsque vous y êtes invité, sélectionnez les paramètres de déploiement requis suivants :

   Paramètre	Descriptif
   abonnement Azure	Abonnement dans lequel vos ressources sont créées.
   emplacement Azure	Région Azure pour 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.
   vnetEnabled	False pour ignorer la création de ressources de réseau virtuel, ce qui simplifie le déploiement.

   Une fois la commande terminée, vous voyez des liens vers les ressources que vous avez créées.

Se connecter à votre serveur MCP distant

Votre serveur MCP s’exécute maintenant dans Azure. Le modèle de projet inclut une remote-mcp-function entrée dans .vscode/mcp.json, déjà configurée pour se connecter à votre serveur distant. Étant donné que l’autorisation MCP intégrée est activée par défaut, Visual Studio Code gère automatiquement le flux de connexion OAuth lorsque vous vous connectez.

1. Obtenez le nom de l’application de fonction à partir de votre déploiement en exécutant cette commande dans le terminal :

   azd env get-value AZURE_FUNCTION_NAME
   

2. Dans .vscode/mcp.json, sélectionnez Démarrer au-dessus de la remote-mcp-function configuration.

3. Lorsque vous y êtes invité, saisissez le nom de la Function App indiqué à l’étape précédente.

4. Visual Studio Code vous invite à vous connecter avec Microsoft Entra. Suivez les invites d’authentification pour autoriser l’accès à votre serveur MCP distant.

Vérifier votre déploiement

Vous pouvez maintenant avoir GitHub Copilot utiliser vos outils MCP distants comme vous l’avez fait localement, mais maintenant le code s’exécute en toute sécurité dans Azure. Relisez les mêmes commandes que celles que vous avez utilisées précédemment pour vous assurer que tout fonctionne correctement.

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 de Azure pour éviter d'entraîner d'autres coûts :

azd down