add configurable prompts support

Enable administrators to define custom MCP prompts in config.toml
using template substitution with {{argument}} syntax.

Features:
- PromptLoader for loading prompts from TOML config
- Core prompt types (ServerPrompt, Prompt, PromptArgument, PromptMessage)
- Template argument substitution with {{variable}} syntax
- Required argument validation
- Integration with MCP server to register and serve config prompts

Signed-off-by: Nader Ziada <[email protected]>

Author: nader-ziada

README.md

@@ -292,6 +292,27 @@ vim /etc/kubernetes-mcp-server/conf.d/99-local.toml
 pkill -HUP kubernetes-mcp-server
 ```
 
+### MCP Prompts
+
+The server supports MCP prompts for workflow templates. Define custom prompts in `config.toml`:
+
+```toml
+[[prompts]]
+name = "my-workflow"
+title = "my workflow"
+description = "Custom workflow"
+
+[[prompts.arguments]]
+name = "resource_name"
+required = true
+
+[[prompts.messages]]
+role = "user"
+content = "Help me with {{resource_name}}"
+```
+
+See docs/PROMPTS.md for detailed documentation.
+
 ## 🛠️ Tools and Functionalities <a id="tools-and-functionalities"></a>
 
 The Kubernetes MCP server supports enabling or disabling specific groups of tools and functionalities (tools, resources, prompts, and so on) via the `--toolsets` command-line flag or `toolsets` configuration option.

docs/PROMPTS.md

@@ -0,0 +1,62 @@
+# MCP Prompts Support
+
+The Kubernetes MCP Server supports [MCP Prompts](https://modelcontextprotocol.io/docs/concepts/prompts), which provide pre-defined workflow templates and guidance to AI assistants.
+
+## What are MCP Prompts?
+
+MCP Prompts are pre-defined templates that guide AI assistants through specific workflows. They combine:
+- **Structured guidance**: Step-by-step instructions for common tasks
+- **Parameterization**: Arguments that customize the prompt for specific contexts
+- **Conversation templates**: Pre-formatted messages that guide the interaction
+
+## Creating Custom Prompts
+
+Define custom prompts in your `config.toml` file - no code changes or recompilation needed!
+
+### Example
+
+```toml
+[[prompts]]
+name = "check-pod-logs"
+title = "Check Pod Logs"
+description = "Quick way to check pod logs"
+
+[[prompts.arguments]]
+name = "pod_name"
+description = "Name of the pod"
+required = true
+
+[[prompts.arguments]]
+name = "namespace"
+description = "Namespace of the pod"
+required = false
+
+[[prompts.messages]]
+role = "user"
+content = "Show me the logs for pod {{pod_name}} in {{namespace}}"
+
+[[prompts.messages]]
+role = "assistant"
+content = "I'll retrieve and analyze the logs for you."
+```
+
+## Configuration Reference
+
+### Prompt Fields
+- **name** (required): Unique identifier for the prompt
+- **title** (optional): Human-readable display name
+- **description** (required): Brief explanation of what the prompt does
+- **arguments** (optional): List of parameters the prompt accepts
+- **messages** (required): Conversation template with role/content pairs
+
+### Argument Fields
+- **name** (required): Argument identifier
+- **description** (optional): Explanation of the argument's purpose
+- **required** (optional): Whether the argument must be provided (default: false)
+
+### Argument Substitution
+Use `{{argument_name}}` placeholders in message content. The template engine replaces these with actual values when the prompt is called.
+
+## Configuration File Location
+
+Place your prompts in the `config.toml` file used by the MCP server. Specify the config file path using the `--config` flag when starting the server.

pkg/api/prompt_config.go

@@ -0,0 +1,22 @@
+package api
+
+import (
+	"context"
+
+	"github.com/BurntSushi/toml"
+	"github.com/containers/kubernetes-mcp-server/pkg/config"
+)
+
+// promptsParser parses prompts from TOML configuration
+func promptsParser(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (interface{}, error) {
+	var prompts []PromptDefinition
+	if err := md.PrimitiveDecode(primitive, &prompts); err != nil {
+		return nil, err
+	}
+	return prompts, nil
+}
+
+func init() {
+	// Register the prompts parser with the config package
+	config.RegisterPromptsParser(promptsParser)
+}

pkg/api/prompt_loader.go

@@ -0,0 +1,126 @@
+package api
+
+import (
+	"fmt"
+	"strings"
+)
+
+// PromptDefinition represents a prompt definition loaded from config
+type PromptDefinition struct {
+	Name        string                  `yaml:"name" toml:"name" json:"name"`
+	Title       string                  `yaml:"title,omitempty" toml:"title,omitempty" json:"title,omitempty"`
+	Description string                  `yaml:"description" toml:"description" json:"description"`
+	Arguments   []PromptArgumentDef     `yaml:"arguments,omitempty" toml:"arguments,omitempty" json:"arguments,omitempty"`
+	Messages    []PromptMessageTemplate `yaml:"messages" toml:"messages" json:"messages"`
+}
+
+// PromptArgumentDef represents an argument definition
+type PromptArgumentDef struct {
+	Name        string `yaml:"name" toml:"name" json:"name"`
+	Description string `yaml:"description" toml:"description" json:"description"`
+	Required    bool   `yaml:"required" toml:"required" json:"required"`
+}
+
+// PromptMessageTemplate represents a message template
+type PromptMessageTemplate struct {
+	Role    string `yaml:"role" toml:"role" json:"role"`
+	Content string `yaml:"content" toml:"content" json:"content"`
+}
+
+// PromptLoader loads prompt definitions from TOML config
+type PromptLoader struct {
+	definitions []PromptDefinition
+}
+
+// NewPromptLoader creates a new prompt loader
+func NewPromptLoader() *PromptLoader {
+	return &PromptLoader{
+		definitions: make([]PromptDefinition, 0),
+	}
+}
+
+// GetServerPrompts converts loaded definitions to ServerPrompt instances
+func (l *PromptLoader) GetServerPrompts() []ServerPrompt {
+	prompts := make([]ServerPrompt, 0, len(l.definitions))
+	for _, def := range l.definitions {
+		prompts = append(prompts, l.convertToServerPrompt(def))
+	}
+	return prompts
+}
+
+// convertToServerPrompt converts a PromptDefinition to a ServerPrompt
+func (l *PromptLoader) convertToServerPrompt(def PromptDefinition) ServerPrompt {
+	arguments := make([]PromptArgument, 0, len(def.Arguments))
+	for _, arg := range def.Arguments {
+		arguments = append(arguments, PromptArgument(arg))
+	}
+
+	return ServerPrompt{
+		Prompt: Prompt{
+			Name:        def.Name,
+			Title:       def.Title,
+			Description: def.Description,
+			Arguments:   arguments,
+		},
+		Handler: l.createHandler(def),
+	}
+}
+
+// createHandler creates a prompt handler function for a prompt definition
+func (l *PromptLoader) createHandler(def PromptDefinition) PromptHandlerFunc {
+	return func(params PromptHandlerParams) (*PromptCallResult, error) {
+		args := params.GetArguments()
+
+		// Validate required arguments
+		for _, argDef := range def.Arguments {
+			if argDef.Required {
+				if _, exists := args[argDef.Name]; !exists {
+					return nil, fmt.Errorf("required argument '%s' is missing", argDef.Name)
+				}
+			}
+		}
+
+		// Render messages with argument substitution
+		messages := make([]PromptMessage, 0, len(def.Messages))
+		for _, msgTemplate := range def.Messages {
+			content := l.substituteArguments(msgTemplate.Content, args)
+			messages = append(messages, PromptMessage{
+				Role: msgTemplate.Role,
+				Content: PromptContent{
+					Type: "text",
+					Text: content,
+				},
+			})
+		}
+
+		return NewPromptCallResult(def.Description, messages, nil), nil
+	}
+}
+
+// substituteArguments replaces {{argument}} placeholders in content with actual values
+func (l *PromptLoader) substituteArguments(content string, args map[string]string) string {
+	result := content
+	for key, value := range args {
+		placeholder := fmt.Sprintf("{{%s}}", key)
+		result = strings.ReplaceAll(result, placeholder, value)
+	}
+	return result
+}
+
+// LoadFromParsedConfig loads prompts from already-parsed config data
+// The input should be a slice of PromptDefinition (stored as interface{} in config to maintain abstraction)
+func (l *PromptLoader) LoadFromParsedConfig(parsedPrompts interface{}) error {
+	if parsedPrompts == nil {
+		return nil
+	}
+
+	// Type assert to []PromptDefinition
+	// This works because the registered parser in pkg/api/prompt_config.go returns []PromptDefinition
+	defs, ok := parsedPrompts.([]PromptDefinition)
+	if !ok {
+		return fmt.Errorf("unexpected type for parsed prompts: %T, expected []api.PromptDefinition", parsedPrompts)
+	}
+
+	l.definitions = append(l.definitions, defs...)
+	return nil
+}

pkg/api/prompts.go

@@ -0,0 +1,84 @@
+package api
+
+import (
+	"context"
+
+	internalk8s "github.com/containers/kubernetes-mcp-server/pkg/kubernetes"
+)
+
+// ServerPrompt represents a prompt that can be registered with the MCP server.
+// Prompts provide pre-defined workflow templates and guidance to AI assistants.
+type ServerPrompt struct {
+	Prompt         Prompt
+	Handler        PromptHandlerFunc
+	ClusterAware   *bool
+	ArgumentSchema map[string]PromptArgument
+}
+
+// IsClusterAware indicates whether the prompt can accept a "cluster" or "context" parameter
+// to operate on a specific Kubernetes cluster context.
+// Defaults to true if not explicitly set
+func (s *ServerPrompt) IsClusterAware() bool {
+	if s.ClusterAware != nil {
+		return *s.ClusterAware
+	}
+	return true
+}
+
+// Prompt represents the metadata and content of an MCP prompt
+type Prompt struct {
+	Name        string           `yaml:"name" json:"name"`
+	Title       string           `yaml:"title,omitempty" json:"title,omitempty"`
+	Description string           `yaml:"description" json:"description,omitempty"`
+	Arguments   []PromptArgument `yaml:"arguments,omitempty" json:"arguments,omitempty"`
+}
+
+// PromptArgument defines a parameter that can be passed to a prompt
+type PromptArgument struct {
+	Name        string `yaml:"name" json:"name"`
+	Description string `yaml:"description" json:"description,omitempty"`
+	Required    bool   `yaml:"required" json:"required"`
+}
+
+// PromptMessage represents a single message in a prompt template
+type PromptMessage struct {
+	Role    string        `yaml:"role" json:"role"`
+	Content PromptContent `yaml:"content" json:"content"`
+}
+
+// PromptContent represents the content of a prompt message
+type PromptContent struct {
+	Type string `yaml:"type" json:"type"`
+	Text string `yaml:"text,omitempty" json:"text,omitempty"`
+}
+
+// PromptCallRequest interface for accessing prompt call arguments
+type PromptCallRequest interface {
+	GetArguments() map[string]string
+}
+
+// PromptCallResult represents the result of executing a prompt
+type PromptCallResult struct {
+	Description string
+	Messages    []PromptMessage
+	Error       error
+}
+
+// NewPromptCallResult creates a new PromptCallResult
+func NewPromptCallResult(description string, messages []PromptMessage, err error) *PromptCallResult {
+	return &PromptCallResult{
+		Description: description,
+		Messages:    messages,
+		Error:       err,
+	}
+}
+
+// PromptHandlerParams contains the parameters passed to a prompt handler
+type PromptHandlerParams struct {
+	context.Context
+	*internalk8s.Kubernetes
+	PromptCallRequest
+}
+
+// PromptHandlerFunc is a function that handles prompt execution
+type PromptHandlerFunc func(params PromptHandlerParams) (*PromptCallResult, error)