Trigger del prompt MCP per Funzioni di Azure (anteprima pubblica)

Il supporto Go non è attualmente disponibile per questo binding.

Questo codice crea un endpoint per esporre una richiesta di revisione del codice:

[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.
        """;
}

Questo codice crea un endpoint per esporre un prompt di riepilogo che accetta due argomenti e 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.
        """;
}

Gli argomenti del prompt per il prompt possono essere configurati anche in Program.cs usando il ConfigureMcpPrompt generatore:

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

Per l'esempio di codice completo, vedere FunctionsMcpPrompts esempio su GitHub.

Questo codice crea un endpoint per esporre una richiesta di revisione del codice con più argomenti (uno obbligatorio, uno facoltativo):

@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```";
}

Questo codice crea un endpoint per esporre un prompt di riepilogo con un singolo argomento obbligatorio:

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

Per l'esempio di codice completo, vedere PromptExamples.java esempio su GitHub.

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

Il codice di esempio per JavaScript non è attualmente disponibile. Vedere gli esempi di TypeScript per indicazioni generali sull'uso di Node.js.

Questo codice crea un endpoint per esporre una richiesta di revisione del codice:

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');
    },
});

Questo codice crea un endpoint per esporre una richiesta di generazione di documenti con argomenti:

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');
    },
});

Per l'esempio di codice completo, vedere mcp-prompts esempio in GitHub.

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

Questo codice usa l'elemento mcp_prompt_trigger Decorator per creare un endpoint per esporre un prompt denominato 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."""

Questo codice crea un endpoint per esporre un prompt con argomenti per la generazione della documentazione dell'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."""

Per l'esempio di codice completo, vedere FunctionsMcpPrompts esempio su GitHub.

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

Attributes

Le librerie C# usano McpPromptTriggerAttribute per definire il trigger di funzione.

Il costruttore dell'attributo accetta i parametri seguenti:

L'attributo supporta anche le proprietà denominate seguenti:

Vedere Utilizzo per informazioni su come definire gli argomenti della richiesta come parametri di input.

Annotations

Usare l'annotazione @McpPromptTrigger per creare una funzione che espone un endpoint prompt nel server MCP remoto.

L'annotazione supporta le opzioni di configurazione seguenti:

Usare l'annotazione @McpPromptArgument per definire singoli argomenti del prompt. Annotare ogni parametro di argomento nella funzione con questa annotazione.

L'annotazione @McpPromptArgument supporta le opzioni di configurazione seguenti:

Elementi Decorator

Si applica solo al modello di programmazione Python v2.

Le proprietà del trigger del prompt MCP seguenti sono supportate in mcp_prompt_trigger:

Configuration

Definire le opzioni di associazione del trigger nel codice. La tabella seguente descrive ogni opzione:

Per esempi completi, vedere la sezione Esempio.

Il trigger del prompt MCP può essere associato ai tipi seguenti:

Il PromptInvocationContext tipo fornisce le proprietà seguenti:

L'annotazione @McpPromptTrigger viene associata a un String parametro che contiene il contesto di chiamata al prompt come stringa JSON. La funzione trigger riceve i valori degli argomenti tramite parametri annotati con @McpPromptArgument.

La funzione del gestore prompt ha due parametri:

Argomenti del prompt

I client MCP richiamano richieste con argomenti per fornire dati e contesto per la generazione del messaggio di richiesta. I client sanno come raccogliere e passare questi argomenti in base alle definizioni di argomento annunciate dal prompt come parte del protocollo. Si definiscono gli argomenti per il prompt nel codice della funzione.

Quando si definisce un argomento prompt, renderlo facoltativo per impostazione predefinita. Il client può ometterlo quando si richiama il prompt. Contrassegnare in modo esplicito gli argomenti come richiesto se il prompt non può funzionare senza di essi.

In C# è possibile definire argomenti per le richieste in diversi modi. L'approccio usato è una questione di preferenza per lo stile del codice. Le opzioni sono:

• La funzione accetta parametri di input usando l'attributo McpPromptArgument .
• Usare per FunctionsApplicationBuilder definire gli argomenti nel Program.cs file.

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

È possibile configurare gli argomenti del prompt nel campo della definizione del prompt_arguments trigger, ovvero un elenco di PromptArgument oggetti.

Un PromptArgument oggetto viene costruito come segue:

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

I campi di un PromptArgument oggetto sono:

In Java definire gli argomenti del prompt usando l'annotazione @McpPromptArgument sui singoli parametri di funzione. Annotare ogni parametro che rappresenta un argomento prompt con questa annotazione. Specificare il nome dell'argomento, la descrizione e se è obbligatorio.

È possibile visualizzare queste annotazioni usate negli esempi.

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

Tipi restituiti

Il trigger del prompt MCP supporta i tipi restituiti seguenti:

Il trigger del prompt MCP supporta i tipi restituiti seguenti:

Il trigger del prompt MCP supporta i tipi restituiti seguenti:

La funzione deve restituire un oggetto string contenente il testo del messaggio di richiesta. La stringa viene sottoposta a wrapping come singolo messaggio di testo del ruolo utente nel mcp GetPromptResult.

Individuazione richiesta

All'avvio di un'app per le funzioni registra tutte le funzioni trigger di prompt con il server MCP. I client individuano le richieste disponibili chiamando il metodo MCP prompts/list . Questo metodo restituisce il nome, il titolo, la descrizione, gli argomenti, le icone e i metadati di ogni prompt (tramite il meta campo). I client richiamano una richiesta chiamando prompts/get con il nome e gli argomenti del prompt.

Sessioni

La SessionId proprietà in PromptInvocationContext identifica la sessione MCP che effettua la richiesta. Usare questa proprietà per mantenere lo stato per sessione o applicare la logica specifica della sessione durante la generazione di richieste.

impostazioni host.json

Il file host.json contiene le impostazioni che controllano i comportamenti dei trigger MCP. Per informazioni dettagliate sulle impostazioni disponibili, vedere la sezione impostazioni host.json .