Wyzwalacz monitu MCP dla Azure Functions (publiczna wersja zapoznawcza)

Wsparcie Go nie jest obecnie dostępne dla tego przypisania.

Ten kod tworzy punkt końcowy w celu uwidocznienia monitu o przegląd kodu:

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

Ten kod tworzy punkt końcowy w celu uwidocznienia monitu podsumowania, który przyjmuje dwa argumenty i 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.
        """;
}

Argumenty monitu dla monitu można również skonfigurować Program.cs za pomocą konstruktora 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();

Pełny przykład kodu można znaleźć w przykładzie FunctionsMcpPrompts przykładu w GitHub.

Ten kod tworzy punkt końcowy w celu uwidocznienia monitu o przegląd kodu z wieloma argumentami (jeden wymagany, jeden opcjonalny):

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

Ten kod tworzy punkt końcowy w celu uwidocznienia monitu podsumowania przy użyciu jednego wymaganego argumentu:

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

Pełny przykład kodu można znaleźć w przykładzie PromptExamples.java w GitHub.

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

Przykładowy kod dla języka JavaScript nie jest obecnie dostępny. Zapoznaj się z przykładami języka TypeScript, aby uzyskać ogólne wskazówki dotyczące korzystania z Node.js.

Ten kod tworzy punkt końcowy w celu uwidocznienia monitu o przegląd kodu:

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

Ten kod tworzy punkt końcowy w celu uwidocznienia monitu generowania dokumentu z argumentami:

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

Aby zapoznać się z kompletnym przykładem kodu, zobacz przykład mcp-prompts w GitHub.

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

Ten kod używa dekoratora mcp_prompt_trigger do utworzenia punktu końcowego w celu uwidocznienia monitu o nazwie 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."""

Ten kod tworzy punkt końcowy w celu uwidocznienia monitu z argumentami na potrzeby generowania dokumentacji interfejsu 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."""

Pełny przykład kodu można znaleźć w przykładzie FunctionsMcpPrompts przykładu w GitHub.

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

Attributes

Biblioteki języka C# służą McpPromptTriggerAttribute do definiowania wyzwalacza funkcji.

Konstruktor atrybutu przyjmuje następujące parametry:

Atrybut obsługuje również następujące nazwane właściwości:

Zobacz Użycie , aby dowiedzieć się, jak definiować argumenty monitu jako parametry wejściowe.

Annotations

@McpPromptTrigger Użyj adnotacji, aby utworzyć funkcję, która uwidacznia punkt końcowy monitu na zdalnym serwerze MCP.

Adnotacja obsługuje następujące opcje konfiguracji:

Użyj adnotacji @McpPromptArgument , aby zdefiniować poszczególne argumenty monitu. Dodaj adnotację do każdego parametru argumentu w funkcji przy użyciu tej adnotacji.

Adnotacja @McpPromptArgument obsługuje następujące opcje konfiguracji:

Dekoratory

Dotyczy tylko modelu programowania w wersji 2 języka Python.

Następujące właściwości wyzwalacza monitu MCP są obsługiwane w systemie mcp_prompt_trigger:

Configuration

Zdefiniuj opcje powiązania wyzwalacza w kodzie. W poniższej tabeli opisano każdą opcję:

Aby zapoznać się z kompletnymi przykładami, zobacz sekcję Przykład.

Wyzwalacz monitu MCP może wiązać się z następującymi typami:

Typ PromptInvocationContext zawiera następujące właściwości:

Adnotacja @McpPromptTrigger wiąże się z parametrem String zawierającym kontekst wywołania monitu jako ciąg JSON. Funkcja wyzwalacza odbiera wartości argumentów za pomocą parametrów z adnotacjami .@McpPromptArgument

Funkcja obsługi monitów ma dwa parametry:

Argumenty monitu

Klienci MCP wywołują monity z argumentami, aby podać dane i kontekst do wygenerowania komunikatu monitu. Klienci wiedzą, jak zbierać i przekazywać te argumenty na podstawie definicji argumentów, które monit anonsuje jako część protokołu. Argumenty dla monitu są definiowane w kodzie funkcji.

Podczas definiowania argumentu monitu ustaw go jako opcjonalny domyślnie. Klient może pominąć go podczas wywoływania monitu. Jawne oznaczanie argumentów jako wymaganych, jeśli monit nie może działać bez nich.

W języku C#można zdefiniować argumenty dla monitów na kilka sposobów. Którego podejścia używasz, jest kwestią preferencji stylu kodu. Dostępne opcje:

• Funkcja przyjmuje parametry wejściowe przy użyciu atrybutu McpPromptArgument .
• Argumenty w FunctionsApplicationBuilder pliku służą Program.cs do definiowania argumentów.

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

Argumenty monitu można skonfigurować w polu definicji prompt_arguments wyzwalacza, który jest listą PromptArgument obiektów.

Element A PromptArgument jest skonstruowany jako:

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

Pola elementu PromptArgument to:

W Java zdefiniuj argumenty monitu przy użyciu adnotacji @McpPromptArgument dla poszczególnych parametrów funkcji. Dodaj adnotację do każdego parametru reprezentującego argument monitu z tą adnotacją. Określ nazwę argumentu, opis i określ, czy jest to wymagane.

Te adnotacje można zobaczyć w przykładach.

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

Typy zwracane

Wyzwalacz monitu MCP obsługuje następujące typy zwracane:

Wyzwalacz monitu MCP obsługuje następujące typy zwracane:

Wyzwalacz monitu MCP obsługuje następujące typy zwracane:

Funkcja powinna zwrócić string tekst komunikatu z monitem. Ciąg jest owinięty jako pojedynczy komunikat tekstowy roli użytkownika w programie MCP GetPromptResult.

Monitowanie o odnajdywanie

Po uruchomieniu aplikacji funkcji rejestruje wszystkie funkcje wyzwalacza monitu z serwerem MCP. Klienci odnajdują dostępne monity, wywołując metodę MCP prompts/list . Ta metoda zwraca nazwę, tytuł, opis, argumenty, ikony i metadane każdego monitu meta (za pośrednictwem pola). Klienci wywołują monit, wywołując prompts/get polecenie z nazwą monitu i argumentami.

Sesji

Właściwość SessionId na PromptInvocationContext stronie identyfikuje sesję MCP wysyłającą żądanie. Użyj tej właściwości, aby zachować stan sesji lub zastosować logikę specyficzną dla sesji podczas generowania monitów.

ustawienia pliku host.json

Plik host.json zawiera ustawienia kontrolujące zachowania wyzwalacza MCP. Aby uzyskać szczegółowe informacje dotyczące dostępnych ustawień, zobacz sekcję host.json settings (Ustawienia host.json).