Gatilho de prompt do MCP para Azure Functions (versão prévia pública)

O suporte do Go não está disponível para essa ligação no momento.

Esse código cria um ponto de extremidade 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.
        """;
}

Esse código cria um ponto de extremidade para expor um prompt de resumo que usa 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 de prompt para o prompt também podem ser configurados Program.cs usando o ConfigureMcpPrompt construtor:

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 obter o exemplo de código completo, consulte FunctionsMcpPrompts exemplo em GitHub.

Esse código cria um ponto de extremidade para expor um prompt de revisão de código com vários argumentos (um necessário, um 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```";
}

Esse código cria um ponto de extremidade 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 obter o exemplo de código completo, consulte PromptExamples.java exemplo no 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 de TypeScript para obter diretrizes gerais usando Node.js.

Esse código cria um ponto de extremidade 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');
    },
});

Esse código cria um ponto de extremidade 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 obter o exemplo de código completo, consulte mcp-prompts exemplo em GitHub.

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

Esse código usa o mcp_prompt_trigger decorador para criar um ponto de extremidade para expor 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."""

Esse código cria um ponto de extremidade para expor um prompt com argumentos para gerar documentação da 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 obter o exemplo de código completo, consulte FunctionsMcpPrompts exemplo em GitHub.

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

Atributos

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

O construtor do atributo recebe os seguintes parâmetros:

O atributo também dá suporte às seguintes propriedades nomeadas:

Consulte Uso para saber como definir argumentos do prompt como parâmetros de entrada.

Annotations

Use a @McpPromptTrigger anotação para criar uma função que expõe um ponto de extremidade de prompt em seu servidor MCP remoto.

A anotação dá suporte às seguintes opções de configuração:

Use a @McpPromptArgument anotação para definir argumentos de prompt individuais. Anote cada parâmetro de argumento em sua função com essa anotação.

A @McpPromptArgument anotação dá suporte às seguintes opções de configuração:

Decoradores

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

Há suporte para as seguintes propriedades de gatilho de prompt do MCP em mcp_prompt_trigger:

Configuration

Defina as opções de associação do gatilho em seu código. A tabela a seguir descreve cada opção:

Para obter exemplos completos, consulte a seção Exemplo.

O gatilho de prompt do MCP pode ser associado aos seguintes tipos:

O PromptInvocationContext tipo fornece as seguintes propriedades:

A @McpPromptTrigger anotação se associa a um String parâmetro que contém o contexto de invocação de prompt como uma cadeia de caracteres JSON. A função de gatilho recebe valores de argumento por meio de parâmetros anotados com @McpPromptArgument.

A função de manipulador de prompt tem dois parâmetros:

Argumentos de prompt

Os clientes MCP invocam prompts com argumentos para fornecer dados e contexto para gerar a mensagem de prompt. Os clientes sabem como coletar e passar esses argumentos com base nas definições de argumento que o prompt anuncia como parte do protocolo. Você define argumentos para o prompt em seu código de função.

Quando você define um argumento de prompt, torne-o opcional por padrão. O cliente pode omitê-lo ao invocar o prompt. Marque explicitamente os argumentos conforme necessário se o prompt não puder operar sem eles.

No C#, você pode definir argumentos para seus prompts de várias maneiras. Qual abordagem você usa é uma questão de preferência de estilo de código. As opções são:

• Sua função usa parâmetros de entrada usando o McpPromptArgument atributo.
• Você usa os FunctionsApplicationBuilder argumentos para definir em seu Program.cs arquivo.

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

Você pode configurar argumentos de prompt no campo da definição de prompt_arguments gatilho, que é uma lista de PromptArgument objetos.

Um PromptArgument é construído como:

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

Os campos de um PromptArgument são:

Em Java, defina argumentos de prompt usando a anotação @McpPromptArgument em parâmetros de função individuais. Anotar cada parâmetro que representa um argumento prompt com essa anotação. Especifique o nome do argumento, a descrição e se ele é necessá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 retorno

O gatilho de prompt do MCP dá suporte aos seguintes tipos de retorno:

O gatilho de prompt do MCP dá suporte aos seguintes tipos de retorno:

O gatilho de prompt do MCP dá suporte aos seguintes tipos de retorno:

A função deve retornar um string texto contendo a mensagem de prompt. A cadeia de caracteres é encapsulada como uma única mensagem de texto de função de usuário no MCP GetPromptResult.

Descoberta de prompt

Quando um aplicativo de funções é iniciado, ele registra todas as funções de gatilho de prompt com o servidor MCP. Os clientes descobrem os prompts disponíveis chamando o método MCP prompts/list . Esse método retorna o nome, o título, a descrição, os argumentos, os ícones e os metadados de cada prompt (por meio do meta campo). Os clientes invocam um prompt chamando prompts/get com o nome e os argumentos do prompt.

Sessões

A SessionId propriedade na PromptInvocationContext qual identifica a sessão MCP que está fazendo a solicitação. Use essa propriedade para manter o estado por sessão ou aplicar a lógica específica da sessão ao gerar prompts.

configurações de host.json

O arquivo host.json contém configurações que controlam os comportamentos do gatilho MCP. Confira a seção Configurações de host.json para obter detalhes em relação às configurações disponíveis.