Desencadenador de solicitud de MCP para Azure Functions (versión preliminar pública)

El soporte de Go no está disponible actualmente para esta asignación.

Este código crea un punto de conexión para exponer un mensaje de revisión 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 crea un punto de conexión para exponer un símbolo del sistema de resumen que toma dos argumentos topic y 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.
        """;
}

Los argumentos de solicitud del símbolo del sistema también se pueden configurar en Program.cs mediante el ConfigureMcpPrompt generador:

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 obtener el ejemplo de código completo, vea FunctionsMcpPrompts ejemplo en GitHub.

Este código crea un punto de conexión para exponer un mensaje de revisión de código con varios argumentos (uno obligatorio, uno 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 crea un punto de conexión para exponer un mensaje de resumen con un único argumento necesario:

@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 obtener el ejemplo de código completo, vea PromptExamples.java ejemplo en GitHub.

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

El código de ejemplo para JavaScript no está disponible actualmente. Consulte los ejemplos de TypeScript para obtener instrucciones generales mediante Node.js.

Este código crea un punto de conexión para exponer un mensaje de revisión 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 crea un punto de conexión para exponer un símbolo del sistema de generación de documentos con 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 obtener el ejemplo de código completo, vea mcp-prompts ejemplo en GitHub.

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

Este código usa el mcp_prompt_trigger decorador para crear un punto de conexión para exponer un símbolo del sistema denominado 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 crea un punto de conexión para exponer una solicitud con argumentos para generar documentación 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 obtener el ejemplo de código completo, vea FunctionsMcpPrompts ejemplo en GitHub.

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

Attributes

Las bibliotecas de C# usan McpPromptTriggerAttribute para definir el desencadenador de función.

El constructor del atributo toma los parámetros siguientes:

El atributo también admite las siguientes propiedades con nombre:

Consulte Uso para obtener información sobre cómo definir argumentos del símbolo del sistema como parámetros de entrada.

Annotations

Use la @McpPromptTrigger anotación para crear una función que exponga un punto de conexión de solicitud en el servidor MCP remoto.

La anotación admite las siguientes opciones de configuración:

Use la @McpPromptArgument anotación para definir argumentos de solicitud individuales. Anote cada parámetro de argumento de la función con esta anotación.

La @McpPromptArgument anotación admite las siguientes opciones de configuración:

Decoradores

Solo se aplica al modelo de programación de Python v2.

Se admiten las siguientes propiedades del desencadenador del símbolo del sistema de MCP en mcp_prompt_trigger:

Configuración

Defina las opciones de enlace del desencadenador en el código. En la tabla siguiente se describe cada opción:

Para obtener ejemplos completos, consulte la sección Ejemplo.

El desencadenador de solicitud de MCP puede enlazarse a los siguientes tipos:

El PromptInvocationContext tipo proporciona las siguientes propiedades:

La @McpPromptTrigger anotación se enlaza a un String parámetro que contiene el contexto de invocación de solicitud como una cadena JSON. La función de desencadenador recibe valores de argumento a través de parámetros anotados con @McpPromptArgument.

La función del controlador de mensajes tiene dos parámetros:

Argumentos prompt

Los clientes mcP invocan mensajes con argumentos para proporcionar datos y contexto para generar el mensaje de solicitud. Los clientes saben cómo recopilar y pasar estos argumentos en función de las definiciones de argumentos que anuncia la solicitud como parte del protocolo. Los argumentos se definen para el símbolo del sistema en el código de función.

Al definir un argumento prompt, consítelo de forma predeterminada. El cliente puede omitirlo al invocar el símbolo del sistema. Marque explícitamente los argumentos según sea necesario si el símbolo del sistema no puede funcionar sin ellos.

En C#, puede definir argumentos para las solicitudes de varias maneras. Qué enfoque se usa es una cuestión de preferencia de estilo de código. Las opciones son:

• La función toma parámetros de entrada mediante el McpPromptArgument atributo .
• FunctionsApplicationBuilder Use para definir argumentos en el Program.cs archivo.

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

Puede configurar argumentos prompt en el campo de la definición del prompt_arguments desencadenador, que es una lista de PromptArgument objetos.

Se PromptArgument construye como:

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

Los campos de son PromptArgument :

En Java, defina argumentos prompt mediante la anotación @McpPromptArgument en parámetros de función individuales. Anota cada parámetro que representa un argumento prompt con esta anotación. Especifique el nombre del argumento, la descripción y si es necesario.

Puede ver estas anotaciones usadas en los ejemplos.

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

Tipos de retorno

El desencadenador de solicitud de MCP admite los siguientes tipos de valor devuelto:

El desencadenador de solicitud de MCP admite los siguientes tipos de valor devuelto:

El desencadenador de solicitud de MCP admite los siguientes tipos de valor devuelto:

La función debe devolver un string objeto que contiene el texto del mensaje de solicitud. La cadena se ajusta como un único mensaje de texto de rol de usuario en MCP GetPromptResult.

Detección de mensajes

Cuando se inicia una aplicación de funciones, registra todas las funciones del desencadenador del símbolo del sistema con el servidor MCP. Los clientes detectan mensajes disponibles llamando al método MCP prompts/list . Este método devuelve el nombre, el título, la descripción, los argumentos, los iconos y los metadatos de cada símbolo del sistema (a través del meta campo). Los clientes invocan una solicitud mediante una llamada prompts/get con el nombre del símbolo del sistema y los argumentos.

Sesiones

La SessionId propiedad de PromptInvocationContext identifica la sesión de MCP que realiza la solicitud. Use esta propiedad para mantener el estado por sesión o aplicar lógica específica de la sesión al generar avisos.

configuración de host.json

El archivo host.json contiene la configuración que controla los comportamientos del desencadenador MCP. Consulte la sección de configuración de host.json para más información sobre las opciones de configuración disponibles.