MCP-promptutlösare för Azure Functions (offentlig förhandsversion)

Go-stöd finns för närvarande inte tillgängligt för denna bindning.

Den här koden skapar en slutpunkt för att exponera en kodgranskningsprompt:

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

Den här koden skapar en slutpunkt för att exponera en sammanfattningsprompt som tar två argument och 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.
        """;
}

Promptargumenten för prompten kan också konfigureras i Program.cs med hjälp av byggverktyget ConfigureMcpPrompt :

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

Det fullständiga kodexemplet finns i FunctionsMcpPrompts exempel på GitHub.

Den här koden skapar en slutpunkt för att exponera en kodgranskningsprompt med flera argument (ett krävs, ett valfritt):

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

Den här koden skapar en slutpunkt för att exponera en sammanfattningsprompt med ett enda obligatoriskt argument:

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

Det fullständiga kodexemplet finns i PromptExamples.java exempel på GitHub.

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

Exempelkod för JavaScript är inte tillgänglig för närvarande. Se TypeScript-exemplen för allmän vägledning med hjälp av Node.js.

Den här koden skapar en slutpunkt för att exponera en kodgranskningsprompt:

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

Den här koden skapar en slutpunkt för att exponera en fråga om dokumentgenerering med argument:

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

Det fullständiga kodexemplet finns i mcp-prompts exempel på GitHub.

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

Den här koden använder dekoratören mcp_prompt_trigger för att skapa en slutpunkt för att exponera en fråga med namnet 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."""

Den här koden skapar en slutpunkt för att exponera en fråga med argument för att generera API-dokumentation:

@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."""

Det fullständiga kodexemplet finns i FunctionsMcpPrompts exempel på GitHub.

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

Attributes

C#-bibliotek används McpPromptTriggerAttribute för att definiera funktionsutlösaren.

Attributets konstruktor tar följande parametrar:

Attributet stöder även följande namngivna egenskaper:

Se Användning för att lära dig hur du definierar argument för prompten som indataparametrar.

Annotations

Använd kommentaren @McpPromptTrigger för att skapa en funktion som exponerar en promptslutpunkt på din fjärranslutna MCP-server.

Kommentaren stöder följande konfigurationsalternativ:

Använd kommentaren @McpPromptArgument för att definiera enskilda promptargument. Kommentera varje argumentparameter i funktionen med den här kommentaren.

Kommentaren @McpPromptArgument stöder följande konfigurationsalternativ:

Dekoratörer

Gäller endast för python v2-programmeringsmodellen.

Följande egenskaper för MCP-promptutlösare stöds på mcp_prompt_trigger:

Konfiguration

Definiera utlösarens bindningsalternativ i koden. I följande tabell beskrivs varje alternativ:

Fullständiga exempel finns i avsnittet Exempel.

MCP-promptutlösaren kan binda till följande typer:

Typen PromptInvocationContext innehåller följande egenskaper:

Kommentaren @McpPromptTrigger binder till en String parameter som innehåller promptanropskontexten som en JSON-sträng. Utlösarfunktionen tar emot argumentvärden via parametrar som kommenterats med @McpPromptArgument.

Funktionen prompthanterare har två parametrar:

Fråga argument

MCP-klienter anropar uppmaningar med argument för att tillhandahålla data och kontext för att generera promptmeddelandet. Klienter vet hur de samlar in och skickar dessa argument baserat på de argumentdefinitioner som uppmaningen annonserar som en del av protokollet. Du definierar argument för prompten i funktionskoden.

När du definierar ett promptargument gör du det valfritt som standard. Klienten kan utelämna det när du anropar kommandotolken. Markera uttryckligen argument som nödvändiga om prompten inte kan fungera utan dem.

I C# kan du definiera argument för dina frågor på flera sätt. Vilken metod du använder handlar om inställningar för kodformat. Alternativen är:

• Funktionen tar indataparametrar med hjälp av attributet McpPromptArgument .
• Du använder FunctionsApplicationBuilder för att definiera argument i Program.cs filen.

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

Du kan konfigurera promptargument i utlösardefinitionens prompt_arguments fält, som är en lista över PromptArgument objekt.

A PromptArgument konstrueras som:

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

Fälten i en PromptArgument är:

I Java definierar du promptargument med hjälp av @McpPromptArgument anteckning på enskilda funktionsparametrar. Kommentera varje parameter som representerar ett promptargument med den här kommentaren. Ange argumentnamn, beskrivning och om det krävs.

Du kan se de här anteckningarna som används i Exemplen.

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

Returtyper

MCP-promptutlösaren stöder följande returtyper:

MCP-promptutlösaren stöder följande returtyper:

MCP-promptutlösaren stöder följande returtyper:

Funktionen ska returnera en string som innehåller meddelandets text. Strängen omsluts som ett textmeddelande med en enskild användarroll i MCP GetPromptResult.

Fråga identifiering

När en funktionsapp startar registreras alla promptutlösarfunktioner med MCP-servern. Klienter identifierar tillgängliga frågor genom att anropa MCP-metoden prompts/list . Den här metoden returnerar varje frågas namn, rubrik, beskrivning, argument, ikoner och metadata (via fältet meta ). Klienter anropar en uppmaning genom att anropa prompts/get med kommandotolkens namn och argument.

Sessioner

Egenskapen SessionId på PromptInvocationContext identifierar MCP-sessionen som gör begäran. Använd den här egenskapen för att upprätthålla status per session eller tillämpa sessionsspecifik logik när du genererar prompter.

host.json inställningar

Filen host.json innehåller inställningar som styr MCP-utlösarbeteenden. Mer information om tillgängliga inställningar finns i avsnittet host.json.