Déclencheur d’invite MCP pour Azure Functions (préversion publique)

Le support Go n’est pas disponible pour ce liaison pour le moment.

Ce code crée un point de terminaison pour exposer une invite de révision de code :

[Function(nameof(CodeReviewChecklist))]
public string CodeReviewChecklist(
    [McpPromptTrigger(CodeReviewPromptName, Description = CodeReviewPromptDescription)]
        PromptInvocationContext context)
{
    logger.LogInformation("Code review checklist prompt invoked.");

    return """
        You are a senior software engineer performing a code review.
        Use the following checklist to evaluate the code:

        1. **Correctness** — Does the code do what it's supposed to?
        2. **Error Handling** — Are edge cases and failures handled?
        3. **Security** — Are there any vulnerabilities (injection, auth, secrets)?
        4. **Performance** — Are there obvious inefficiencies?
        5. **Readability** — Is the code clear and well-named?
        6. **Tests** — Are there adequate tests for the changes?

        Provide your feedback in a structured format with a severity level
        (critical, warning, suggestion) for each finding.
        """;
}

Ce code crée un point de terminaison pour exposer une invite de synthèse qui prend deux arguments et topicaudience:

[Function(nameof(SummarizeContent))]
public string SummarizeContent(
    [McpPromptTrigger(SummarizePromptName, Description = SummarizePromptDescription)]
        PromptInvocationContext context,
    [McpPromptArgument("topic", "The topic or content to summarize.", isRequired: true)]
        string topic,
    [McpPromptArgument("audience", "Target audience (e.g., 'executive', 'developer', 'beginner').")]
        string? audience)
{
    logger.LogInformation("Summarize prompt invoked for topic: {Topic}", topic);

    var audienceInstruction = audience is not null
        ? $"Tailor the summary for a **{audience}** audience."
        : "Write the summary for a general technical audience.";

    return $"""
        Summarize the following topic concisely and accurately:

        **Topic:** {topic}

        {audienceInstruction}

        Guidelines:
        - Start with a one-sentence overview.
        - Include 3–5 key points as bullet items.
        - End with a brief conclusion or recommendation.
        - Keep the total length under 300 words.
        """;
}

Les arguments d’invite de l’invite peuvent également être configurés à Program.cs l’aide du ConfigureMcpPrompt générateur :

var builder = FunctionsApplication.CreateBuilder(args);

builder.ConfigureFunctionsWebApplication();

builder
    .ConfigureMcpPrompt(SummarizePromptName)
    .WithArgument("topic", "The topic or content to summarize.", required: true)
    .WithArgument("audience", "Target audience (e.g., 'executive', 'developer', 'beginner').");

builder.Build().Run();

Pour obtenir l’exemple de code complet, consultez FunctionsMcpPrompts sur GitHub.

Ce code crée un point de terminaison pour exposer une invite de révision de code avec plusieurs arguments (un argument obligatoire, un facultatif) :

@FunctionName("CodeReviewPrompt")
public String codeReviewPrompt(
        @McpPromptTrigger(
                name = "code_review",
                description = "Generates a code review prompt for the given code snippet",
                title = "Code Review")
        String context,
        @McpPromptArgument(
                name = "code",
                description = "The code to review",
                isRequired = true)
        String code,
        @McpPromptArgument(
                name = "language",
                description = "The programming language")
        String language,
        final ExecutionContext executionContext) {

    executionContext.getLogger().info("Generating code review prompt");

    String lang = (language != null && !language.isEmpty()) ? language : "unknown";
    String snippet = (code != null && !code.isEmpty()) ? code : "// no code provided";

    return "Please review the following " + lang + " code and suggest improvements:\n\n```"
            + lang + "\n" + snippet + "\n```";
}

Ce code crée un point de terminaison pour exposer une invite de synthèse avec un seul argument obligatoire :

@FunctionName("SummarizePrompt")
public String summarizePrompt(
        @McpPromptTrigger(
                name = "summarize",
                description = "Summarizes the provided text",
                title = "Summarize Text")
        String context,
        @McpPromptArgument(
                name = "text",
                description = "The text to summarize",
                isRequired = true)
        String text,
        final ExecutionContext executionContext) {

    executionContext.getLogger().info("Generating summarize prompt");

    String input = (text != null && !text.isEmpty()) ? text : "No text provided";
    return "Please provide a concise summary of the following text:\n\n" + input;
}

Pour obtenir l’exemple de code complet, consultez PromptExamples.java exemple sur GitHub.

<extensionBundle>
  <id>Microsoft.Azure.Functions.ExtensionBundle.Preview</id>
  <version>[4.41, 5.0.0)</version>
</extensionBundle>

L’exemple de code pour JavaScript n’est actuellement pas disponible. Consultez les exemples TypeScript pour obtenir des conseils généraux à l’aide de Node.js.

Ce code crée un point de terminaison pour exposer une invite de révision de code :

app.mcpPrompt('CodeReviewChecklist', {
    promptName: CodeReviewPromptName,
    description: CodeReviewPromptDescription,
    handler: async (_ctx: PromptInvocationContext, context: InvocationContext) => {
        context.log('Code review checklist prompt invoked.');

        return [
            "You are a senior software engineer performing a code review.",
            'Use the following checklist to evaluate the code:',
            '',
            "1. **Correctness** \u2014 Does the code do what it's supposed to?",
            '2. **Error Handling** \u2014 Are edge cases and failures handled?',
            '3. **Security** \u2014 Are there any vulnerabilities (injection, auth, secrets)?',
            '4. **Performance** \u2014 Are there obvious inefficiencies?',
            '5. **Readability** \u2014 Is the code clear and well-named?',
            '6. **Tests** \u2014 Are there adequate tests for the changes?',
            '',
            'Provide your feedback in a structured format with a severity level',
            '(critical, warning, suggestion) for each finding.',
        ].join('\n');
    },
});

Ce code crée un point de terminaison pour exposer une invite de génération de documents avec des arguments :

app.mcpPrompt('GenerateDocumentation', {
    promptName: GenerateDocsPromptName,
    description: GenerateDocsPromptDescription,
    promptArguments: {
        function_name: promptArg.describe("The function to document.").isRequired(),
        style: promptArg.describe("Documentation style (e.g., 'concise', 'verbose')."),
    },
    handler: async (ctx: PromptInvocationContext, context: InvocationContext) => {
        const functionName = ctx.arguments.function_name ?? '(unknown)';
        const style = ctx.arguments.style ?? 'concise';

        context.log(`Generate docs prompt invoked for function: ${functionName}`);

        return [
            `Generate API documentation for the function named **${functionName}**.`,
            '',
            `Documentation style: **${style}**`,
            '',
            'Include the following sections:',
            '- **Description** \u2014 What the function does.',
            '- **Parameters** \u2014 List each parameter with its type and purpose.',
            '- **Return Value** \u2014 What the function returns.',
            '- **Example Usage** \u2014 A short code example showing how to call it.',
        ].join('\n');
    },
});

Pour obtenir l’exemple de code complet, consultez mcp-prompts sur GitHub.

"extensionBundle": {
  "id": "Microsoft.Azure.Functions.ExtensionBundle.Preview",
  "version": "[4.41, 5.0.0)"
}

Ce code utilise le mcp_prompt_trigger décorateur pour créer un point de terminaison pour exposer une invite nommée code_review_checklist:

@app.mcp_prompt_trigger(
    arg_name="context",
    prompt_name="code_review_checklist",
    description="Returns a structured code review checklist prompt for evaluating code changes."
)
def code_review_checklist(context: func.PromptInvocationContext) -> str:
    logging.info("Code review checklist prompt invoked.")

    return """You are a senior software engineer performing a code review.
Use the following checklist to evaluate the code:

1. **Correctness** — Does the code do what it's supposed to?
2. **Error Handling** — Are edge cases and failures handled?
3. **Security** — Are there any vulnerabilities (injection, auth, secrets)?
4. **Performance** — Are there obvious inefficiencies?
5. **Readability** — Is the code clear and well-named?
6. **Tests** — Are there adequate tests for the changes?

Provide your feedback in a structured format with a severity level
(critical, warning, suggestion) for each finding."""

Ce code crée un point de terminaison pour exposer une invite avec des arguments pour générer la documentation de l’API :

@app.mcp_prompt_trigger(
    arg_name="context",
    prompt_name="generate_documentation",
    prompt_arguments=[
        func.PromptArgument("function_name", "The name of the function to document.", required=False),
        func.PromptArgument("style", "Documentation style: 'concise', 'detailed', or 'tutorial'.", required=False)
    ],
    description="Generates API documentation for a function. Arguments are configured in Program.cs."
)
def generate_documentation(context: func.PromptInvocationContext) -> str:
    function_name = context.arguments.get("function_name", "(unknown)")
    style = context.arguments.get("style", "concise")

    logging.info(f"Generate docs prompt invoked for function: {function_name}")

    return f"""Generate API documentation for the function named **{function_name}**.

Documentation style: **{style}**

Include the following sections:
- **Description** — What the function does.
- **Parameters** — List each parameter with its type and purpose.
- **Return Value** — What the function returns.
- **Example Usage** — A short code example showing how to call it."""

Pour obtenir l’exemple de code complet, consultez FunctionsMcpPrompts sur GitHub.

"extensionBundle": {
  "id": "Microsoft.Azure.Functions.ExtensionBundle.Preview",
  "version": "[4.41, 5.0.0)"
}

Attributs

Les bibliothèques C# utilisent McpPromptTriggerAttribute pour définir le déclencheur de fonction.

Le constructeur de l’attribut accepte les paramètres suivants :

L’attribut prend également en charge les propriétés nommées suivantes :

Consultez Utilisation pour savoir comment définir des arguments de l’invite en tant que paramètres d’entrée.

Annotations

Utilisez l’annotation @McpPromptTrigger pour créer une fonction qui expose un point de terminaison d’invite dans votre serveur MCP distant.

L’annotation prend en charge les options de configuration suivantes :

Utilisez l’annotation @McpPromptArgument pour définir des arguments d’invite individuels. Annotez chaque paramètre d’argument dans votre fonction avec cette annotation.

L’annotation @McpPromptArgument prend en charge les options de configuration suivantes :

Décorateurs

S’applique uniquement au modèle de programmation Python v2.

Les propriétés de déclencheur d’invite MCP suivantes sont prises en charge sur mcp_prompt_trigger:

Configuration

Définissez les options de liaison du déclencheur dans votre code. Le tableau suivant décrit chaque option :

Pour obtenir des exemples complets, consultez la section Exemple.

Le déclencheur d’invite MCP peut être lié aux types suivants :

Le PromptInvocationContext type fournit les propriétés suivantes :

L’annotation @McpPromptTrigger est liée à un String paramètre qui contient le contexte d’appel d’invite sous forme de chaîne JSON. La fonction de déclencheur reçoit des valeurs d’argument par le biais de paramètres annotés avec @McpPromptArgument.

La fonction de gestionnaire d’invite a deux paramètres :

Arguments d’invite

Les clients MCP appellent des invites avec des arguments pour fournir des données et un contexte pour générer le message d’invite. Les clients savent comment collecter et transmettre ces arguments en fonction des définitions d’arguments publiées par l’invite dans le cadre du protocole. Vous définissez des arguments pour l’invite dans votre code de fonction.

Lorsque vous définissez un argument d’invite, faites-le facultatif par défaut. Le client peut l’omettre lors de l’appel de l’invite. Marquez explicitement les arguments comme requis si l’invite ne peut pas fonctionner sans eux.

En C#, vous pouvez définir des arguments pour vos invites de plusieurs façons. Quelle approche vous utilisez est une question de préférence de style de code. Les options sont les suivantes :

• Votre fonction prend des paramètres d’entrée à l’aide de l’attribut McpPromptArgument .
• Vous utilisez la méthode FunctionsApplicationBuilder pour définir des arguments dans votre Program.cs fichier.

var builder = FunctionsApplication.CreateBuilder(args);

builder.ConfigureFunctionsWebApplication();

builder
    .ConfigureMcpPrompt("code_review")
    .WithArgument("code", "The code to review", required: true)
    .WithArgument("language", "The programming language");

// other configuration

builder.Build().Run();

Vous pouvez configurer des arguments d’invite dans le champ de la définition du prompt_arguments déclencheur, qui est une liste d’objets PromptArgument .

Un PromptArgument est construit comme suit :

func.PromptArgument("argument_name", "Description of the argument", required=True)

Les champs d’un PromptArgument sont les suivants :

Dans Java, définissez des arguments d’invite à l’aide de l’annotation @McpPromptArgument sur des paramètres de fonction individuels. Annotez chaque paramètre qui représente un argument d’invite avec cette annotation. Spécifiez le nom, la description et le nom de l’argument, et indiquez s’il est nécessaire.

Vous pouvez voir ces annotations utilisées dans les exemples.

  promptArguments: {
    code: promptArg.describe("The code to review").isRequired(),
    language: promptArg.describe("The programming language"),
  }

Types de retour

Le déclencheur d’invite MCP prend en charge les types de retour suivants :

Le déclencheur d’invite MCP prend en charge les types de retour suivants :

Le déclencheur d’invite MCP prend en charge les types de retour suivants :

La fonction doit retourner un string texte contenant le message d’invite. La chaîne est encapsulée en tant que message texte à rôle utilisateur unique dans le MCP GetPromptResult.

Détection d’invite

Lorsqu’une application de fonction démarre, elle inscrit toutes les fonctions de déclencheur d’invite auprès du serveur MCP. Les clients découvrent les invites disponibles en appelant la méthode MCP prompts/list . Cette méthode retourne le nom, le titre, la description, les arguments, les icônes et les métadonnées de chaque invite (via le meta champ). Les clients appellent une invite en appelant prompts/get avec le nom et les arguments de l’invite.

Sessions

La SessionId propriété sur PromptInvocationContext identifie la session MCP qui effectue la requête. Utilisez cette propriété pour maintenir l’état par session ou appliquer une logique spécifique à la session lors de la génération d’invites.

Paramètres host.json

Le fichier host.json contient des paramètres qui contrôlent les comportements des déclencheurs MCP. Pour plus d’informations sur les paramètres disponibles, consultez la section host.json.