MCP-prompttrigger voor Azure Functions (openbare preview)

Go-ondersteuning is momenteel niet beschikbaar voor deze binding.

Met deze code wordt een eindpunt gemaakt om een prompt voor codebeoordeling weer te geven:

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

Met deze code wordt een eindpunt gemaakt om een overzichtsprompt weer te geven die twee argumenten gebruikt en 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.
        """;
}

De promptargumenten voor de prompt kunnen ook worden geconfigureerd Program.cs met behulp van de ConfigureMcpPrompt opbouwfunctie:

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

Zie FunctionsMcpPrompts voorbeeld in GitHub voor het volledige codevoorbeeld.

Met deze code wordt een eindpunt gemaakt om een codebeoordelingsprompt weer te geven met meerdere argumenten (één vereist, één optioneel):

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

Met deze code wordt een eindpunt gemaakt om een overzichtsprompt weer te geven met één vereist 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;
}

Zie PromptExamples.java voorbeeld van GitHub voor het volledige codevoorbeeld.

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

Voorbeeldcode voor JavaScript is momenteel niet beschikbaar. Zie de TypeScript-voorbeelden voor algemene richtlijnen met behulp van Node.js.

Met deze code wordt een eindpunt gemaakt om een prompt voor codebeoordeling weer te geven:

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

Met deze code wordt een eindpunt gemaakt om een prompt voor het genereren van documenten weer te geven met argumenten:

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

Zie mcp-prompts voorbeeld van GitHub voor het volledige codevoorbeeld.

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

Deze code maakt gebruik van de decorator om een eindpunt te maken om een prompt met de mcp_prompt_trigger naam 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."""

Met deze code wordt een eindpunt gemaakt om een prompt weer te geven met argumenten voor het genereren van API-documentatie:

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

Zie FunctionsMcpPrompts voorbeeld in GitHub voor het volledige codevoorbeeld.

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

Attributes

C#-bibliotheken gebruiken McpPromptTriggerAttribute om de functietrigger te definiëren.

De constructor van het kenmerk gebruikt de volgende parameters:

Het kenmerk ondersteunt ook de volgende benoemde eigenschappen:

Zie Gebruik voor meer informatie over het definiëren van argumenten van de prompt als invoerparameters.

Annotations

Gebruik de @McpPromptTrigger aantekening om een functie te maken die een prompt-eindpunt beschikbaar maakt op uw externe MCP-server.

De aantekening ondersteunt de volgende configuratieopties:

Gebruik de @McpPromptArgument aantekening om afzonderlijke promptargumenten te definiëren. Aantekeningen toevoegen aan elke argumentparameter in uw functie met deze aantekening.

De @McpPromptArgument aantekening ondersteunt de volgende configuratieopties:

Decorateurs

Is alleen van toepassing op het Python v2-programmeermodel.

De volgende eigenschappen van de MCP-prompttrigger worden ondersteund op mcp_prompt_trigger:

Configuratie

Definieer de bindingsopties van de trigger in uw code. In de volgende tabel wordt elke optie beschreven:

Zie de sectie Voorbeeld voor volledige voorbeelden.

De MCP-prompttrigger kan worden gekoppeld aan de volgende typen:

Het PromptInvocationContext type bevat de volgende eigenschappen:

De @McpPromptTrigger aantekening wordt gekoppeld aan een String parameter die de context van de promptaanroep bevat als een JSON-tekenreeks. De triggerfunctie ontvangt argumentwaarden via parameters met @McpPromptArgumentaantekeningen.

De prompthandlerfunctie heeft twee parameters:

Promptargumenten

MCP-clients roepen prompts aan met argumenten om gegevens en context te bieden voor het genereren van het promptbericht. Clients weten hoe deze argumenten moeten worden verzameld en doorgegeven op basis van de argumentdefinities die door de prompt worden aangekondigd als onderdeel van het protocol. U definieert argumenten voor de prompt in uw functiecode.

Wanneer u een promptargument definieert, moet u dit standaard optioneel maken. De client kan deze weglaten bij het aanroepen van de prompt. Markeer argumenten expliciet zoals vereist als de prompt niet zonder deze kan werken.

In C# kunt u op verschillende manieren argumenten voor uw prompts definiëren. Welke benadering u gebruikt, is een kwestie van codestijlvoorkeur. De opties zijn:

• Uw functie gebruikt invoerparameters met behulp van het McpPromptArgument kenmerk.
• U gebruikt de FunctionsApplicationBuilder functie om argumenten in uw Program.cs bestand te definiëren.

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

U kunt promptargumenten configureren in het veld van prompt_arguments de triggerdefinitie, een lijst PromptArgument met objecten.

Een PromptArgument is opgebouwd als:

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

De velden van een PromptArgument zijn:

Definieer in Java promptargumenten met behulp van de @McpPromptArgument annotatie voor afzonderlijke functieparameters. Aantekeningen toevoegen aan elke parameter die een promptargument vertegenwoordigt met deze aantekening. Geef de naam, beschrijving van het argument en of dit vereist is.

U kunt deze aantekeningen zien die worden gebruikt in de voorbeelden.

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

Retourtypen

De MCP-prompttrigger ondersteunt de volgende retourtypen:

De MCP-prompttrigger ondersteunt de volgende retourtypen:

De MCP-prompttrigger ondersteunt de volgende retourtypen:

De functie moet een string met de tekst van het promptbericht retourneren. De tekenreeks wordt verpakt als een tekstbericht met één gebruikersrol in de MCP GetPromptResult.

Promptdetectie

Wanneer een functie-app wordt gestart, worden alle prompttriggerfuncties geregistreerd bij de MCP-server. Clients detecteren beschikbare prompts door de MCP-methode prompts/list aan te roepen. Deze methode retourneert de naam, titel, beschrijving, argumenten, pictogrammen en metagegevens van elke prompt (via het meta veld). Clients roepen een prompt aan door de promptnaam en argumenten aan te roepen prompts/get .

Sessies

De SessionId eigenschap bij PromptInvocationContext het identificeren van de MCP-sessie die de aanvraag indient. Gebruik deze eigenschap om de status per sessie te behouden of om sessiespecifieke logica toe te passen bij het genereren van prompts.

host.json-instellingen

Het bestand host.json bevat instellingen waarmee het gedrag van MCP-triggers wordt bepaald. Zie de sectie host.json-instellingen voor meer informatie over de beschikbare instellingen.