Trigger de prompt MCP para Funções do Azure (pré-visualização pública)

O suporte Go não está atualmente disponível para esta ligação.

Este código cria um endpoint para expor um prompt de revisão de código:

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

Este código cria um ponto final para expor um prompt de resumo que utiliza dois argumentos, topic e audience:

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

Os argumentos do prompt para o prompt também podem ser configurados Program.cs usando o ConfigureMcpPrompt builder:

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

Para o exemplo completo de código, veja FunctionsMcpPrompts exemplo no GitHub.

Este código cria um endpoint para expor um prompt de revisão de código com múltiplos argumentos (um obrigatório, outro opcional):

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

Este código cria um ponto final para expor um prompt de resumo com um único argumento necessário:

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

Para o exemplo completo do código, veja o exemplo PromptExamples.java sobre GitHub.

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

O código de exemplo para JavaScript não está disponível no momento. Consulte os exemplos do TypeScript para obter orientações gerais sobre o uso do Node.js.

Este código cria um endpoint para expor um prompt de revisão de código:

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

Este código cria um endpoint para expor um prompt de geração de documentos com argumentos:

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

Para o exemplo completo do código, veja mcp-prompts exemplo sobre GitHub.

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

Este código usa o mcp_prompt_trigger decorador para criar um endpoint que expõe um prompt chamado 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."""

Este código cria um endpoint para expor um prompt com argumentos para gerar documentação de 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."""

Para o exemplo completo de código, veja FunctionsMcpPrompts exemplo no GitHub.

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

Attributes

As bibliotecas C# são usadas McpPromptTriggerAttribute para definir o gatilho de função.

O construtor do atributo usa os seguintes parâmetros:

O atributo também suporta as seguintes propriedades nomeadas:

Consulte Utilização para aprender como definir os argumentos do prompt como parâmetros de entrada.

Annotations

Use a @McpPromptTrigger anotação para criar uma função que exponha um endpoint de prompt no seu servidor MCP remoto.

A anotação suporta as seguintes opções de configuração:

Use a @McpPromptArgument anotação para definir argumentos individuais de prompt. Anota cada parâmetro de argumento na tua função com esta anotação.

A @McpPromptArgument anotação suporta as seguintes opções de configuração:

Decoradores

Aplica-se apenas ao modelo de programação Python v2.

As seguintes propriedades de disparo de prompt MCP são suportadas em:mcp_prompt_trigger

Configuração

Defina as opções de vinculação do gatilho no seu código. A tabela seguinte descreve cada opção:

Para exemplos completos, veja a secção de Exemplos.

O gatilho de prompt MCP pode ser ligado aos seguintes tipos:

O PromptInvocationContext tipo fornece as seguintes propriedades:

A @McpPromptTrigger anotação liga-se a um String parâmetro que contém o contexto de invocação do prompt como uma string JSON. A função de disparo recebe valores de argumento através de parâmetros anotados com @McpPromptArgument.

A função handler de prompts tem dois parâmetros:

Argumentos rápidos

Os clientes MCP invocam prompts com argumentos para fornecer dados e contexto para gerar a mensagem de prompt. Os clientes sabem como recolher e transmitir estes argumentos com base nas definições de argumentos que o prompt anuncia como parte do protocolo. Defines argumentos para o prompt no teu código de função.

Quando defines um argumento de prompt, torna-o opcional por defeito. O cliente pode omiti-lo ao invocar o prompt. Marque explicitamente os argumentos como necessários se o prompt não puder funcionar sem eles.

Em C#, podes definir argumentos para os teus prompts de várias formas. A abordagem que você usa é uma questão de preferência de estilo de código. As opções são:

• A sua função recebe parâmetros de entrada usando o McpPromptArgument atributo.
• Usas o FunctionsApplicationBuilder para definir argumentos no teu Program.cs ficheiro.

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

Podes configurar argumentos de prompt no campo da definição prompt_arguments do trigger, que é uma lista de PromptArgument objetos.

A PromptArgument é construído como:

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

Os corpos de um PromptArgument são:

Em Java, defina argumentos de prompt usando a anotação @McpPromptArgument em parâmetros individuais da função. Anote cada parâmetro que represente um argumento de prompt com esta anotação. Especifique o nome do argumento, a descrição e se é obrigatório.

Você pode ver essas anotações usadas nos Exemplos.

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

Tipos de devolução

O gatilho de prompt MCP suporta os seguintes tipos de retorno:

O gatilho de prompt MCP suporta os seguintes tipos de retorno:

O gatilho de prompt MCP suporta os seguintes tipos de retorno:

A função deve devolver um string texto contendo a mensagem de prompt. A cadeia é enrolada como uma única mensagem de texto de papel de utilizador no MCP GetPromptResult.

Descoberta rápida

Quando uma aplicação de funções inicia, regista todas as funções de prompt trigger no servidor MCP. Os clientes encontram os prompts disponíveis ligando para o método MCP prompts/list . Este método devolve o nome, título, descrição, argumentos, ícones e metadados de cada prompt (através do meta campo). Os clientes invocam um prompt ligando prompts/get com o nome e argumentos do prompt.

Sessões

A SessionId propriedade em PromptInvocationContext identifica a sessão MCP que faz o pedido. Use esta propriedade para manter o estado por sessão ou aplicar lógica específica da sessão ao gerar prompts.

configurações host.json

O arquivo host.json contém configurações que controlam comportamentos de gatilho MCP. Consulte a seção Configurações de host.json para obter detalhes sobre as configurações disponíveis.