add support to read prompts from toml config

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

Author: nader-ziada

README.md

@@ -196,6 +196,34 @@ uvx kubernetes-mcp-server@latest --help
 | `--toolsets`              | Comma-separated list of toolsets to enable. Check the [🛠️ Tools and Functionalities](#tools-and-functionalities) section for more information.                                                                                                                                               |
 | `--disable-multi-cluster` | If set, the MCP server will disable multi-cluster support and will only use the current context from the kubeconfig file. This is useful if you want to restrict the MCP server to a single cluster.                                                                                          |
 
+#### Custom Prompts Configuration
+
+The server supports defining custom [MCP prompts](https://modelcontextprotocol.io/docs/concepts/prompts) directly in your configuration file, allowing you to create custom workflows without recompiling. See [docs/PROMPTS.md](docs/PROMPTS.md) for detailed documentation.
+
+**Configuration file example:**
+
+```toml
+# Define prompts inline in your config.toml
+[[prompts]]
+name = "my-custom-prompt"
+description = "A custom troubleshooting workflow"
+
+[[prompts.arguments]]
+name = "resource_name"
+required = true
+
+[[prompts.messages]]
+role = "user"
+content = "Help me troubleshoot {{resource_name}}"
+
+[[prompts.messages]]
+role = "assistant"
+content = "I'll investigate {{resource_name}} for you."
+
+# Optionally disable built-in embedded prompts
+disable_embedded_prompts = false
+```
+
 ## 🛠️ 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

@@ -1,6 +1,6 @@
 # MCP Prompts Support
 
-The Kubernetes MCP Server now supports [MCP Prompts](https://modelcontextprotocol.io/docs/concepts/prompts), which provide pre-defined workflow templates and guidance to AI assistants. Prompts help standardize common Kubernetes operations and provide structured approaches to troubleshooting and deployment tasks.
+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?
 
@@ -9,217 +9,188 @@ MCP Prompts are pre-defined templates that guide AI assistants through specific
 - **Parameterization**: Arguments that customize the prompt for specific contexts
 - **Conversation templates**: Pre-formatted messages that guide the interaction
 
-## Available Prompts
+## Available Built-in Prompts
 
-The Kubernetes MCP Server currently provides the following prompts in the `core` toolset:
+The server provides these prompts in the `core` toolset:
 
-### 1. `troubleshoot-pod`
-Guide for troubleshooting a failing or crashed pod in Kubernetes.
+1. **troubleshoot-pod** - Debug failing or crashed pods
+2. **deploy-application** - Deploy new applications
+3. **scale-deployment** - Scale deployments safely
+4. **investigate-cluster-health** - Check overall cluster health
+5. **debug-networking** - Debug connectivity issues
+6. **review-resource-usage** - Analyze resource consumption
 
-**Arguments:**
-- `namespace` (required): The namespace where the pod is located
-- `pod_name` (required): The name of the pod to troubleshoot
+## Creating Custom Prompts
 
-**Usage:**
-```
-When to use: Pod is failing, crashing, or not working as expected
-What it does: Systematically investigates pod status, events, logs, and resource constraints
-```
+Define custom prompts in your `config.toml` file - no code changes or recompilation needed!
 
-### 2. `deploy-application`
-Workflow for deploying a new application to Kubernetes.
+### Basic Example
 
-**Arguments:**
-- `app_name` (required): The name of the application to deploy
-- `namespace` (optional): The namespace to deploy to (defaults to 'default')
+```toml
+[[prompts]]
+name = "check-pod-logs"
+description = "Quick way to check pod logs"
 
-**Usage:**
-```
-When to use: Deploying a new application to the cluster
-What it does: Guides through namespace setup, manifest creation, deployment, and verification
-```
+[[prompts.arguments]]
+name = "pod_name"
+description = "Name of the pod"
+required = true
 
-### 3. `scale-deployment`
-Guide for scaling a deployment up or down.
+[[prompts.arguments]]
+name = "namespace"
+description = "Namespace of the pod"
+required = false
 
-**Arguments:**
-- `deployment_name` (required): The name of the deployment to scale
-- `namespace` (required): The namespace of the deployment
-- `replicas` (required): The desired number of replicas
+[[prompts.messages]]
+role = "user"
+content = "Show me the logs for pod {{pod_name}} in {{namespace}}"
 
-**Usage:**
-```
-When to use: Need to scale application replicas
-What it does: Checks current status, scales deployment, and monitors the scaling process
+[[prompts.messages]]
+role = "assistant"
+content = "I'll retrieve and analyze the logs for you."
 ```
 
-### 4. `investigate-cluster-health`
-Comprehensive workflow for investigating overall cluster health.
+### Complex Example with Multi-Step Workflow
 
-**Arguments:** None
+```toml
+[[prompts]]
+name = "troubleshoot-deployment"
+description = "Comprehensive deployment troubleshooting"
 
-**Usage:**
-```
-When to use: Want to understand overall cluster status and health
-What it does: Checks nodes, system pods, events, resource usage, and namespaces
-```
+[[prompts.arguments]]
+name = "deployment_name"
+required = true
 
-### 5. `debug-networking`
-Workflow for debugging networking issues between pods or services.
+[[prompts.arguments]]
+name = "namespace"
+required = true
 
-**Arguments:**
-- `source_pod` (optional): The source pod name
-- `source_namespace` (optional): The source pod namespace
-- `target_service` (optional): The target service name
+[[prompts.messages]]
+role = "user"
+content = """
+My deployment {{deployment_name}} in {{namespace}} is having issues.
+Can you investigate?
+"""
 
-**Usage:**
-```
-When to use: Experiencing connectivity or networking problems
-What it does: Investigates pod IPs, service configuration, network policies, DNS, and connectivity
-```
+[[prompts.messages]]
+role = "assistant"
+content = """
+I'll troubleshoot deployment {{deployment_name}}. Let me:
 
-### 6. `review-resource-usage`
-Analyze resource usage across the cluster or specific namespace.
+1. **Check Deployment Status**
+   - Review current vs desired replicas
+   - Check rollout status
 
-**Arguments:**
-- `namespace` (optional): Focus on specific namespace (leave empty for cluster-wide)
+2. **Investigate Pods**
+   - List pod states
+   - Review pod events and logs
 
-**Usage:**
-```
-When to use: Need to understand resource consumption and identify bottlenecks
-What it does: Analyzes CPU and memory usage, identifies top consumers, and provides recommendations
+3. **Analyze Resources**
+   - Check CPU/memory limits
+   - Verify quotas
+
+Starting investigation...
+"""
 ```
 
-## Creating Custom Prompts
+### Argument Substitution
 
-Toolsets can provide their own prompts by implementing the `GetPrompts()` method and creating YAML definition files.
-
-### YAML Prompt Definition Format
-
-Prompts are defined in YAML files with the following structure:
-
-```yaml
-- name: prompt-name
-  description: Human-readable description of what this prompt does
-  arguments:
-    - name: argument_name
-      description: What this argument is for
-      required: true/false
-  messages:
-    - role: user
-      content: |
-        The user's initial message with {{argument_name}} placeholders
-    - role: assistant
-      content: |
-        The assistant's response template
-```
+Use `{{argument_name}}` in message content to insert values:
 
-### Example: Creating a Custom Prompt
-
-**Step 1: Create a YAML file** (`pkg/toolsets/yourname/prompts.yaml`):
-
-```yaml
-- name: check-pod-logs
-  description: Retrieve and analyze logs from a specific pod
-  arguments:
-    - name: pod_name
-      description: The name of the pod to check
-      required: true
-    - name: namespace
-      description: The namespace of the pod
-      required: false
-  messages:
-    - role: user
-      content: |
-        I need to check the logs for pod {{pod_name}}{{#namespace}} in namespace {{namespace}}{{/namespace}}.
-    - role: assistant
-      content: |
-        I'll retrieve the logs for {{pod_name}}. Let me:
-        1. Verify the pod exists and its status
-        2. Retrieve the latest logs
-        3. Analyze for errors or warnings
+```toml
+[[prompts.messages]]
+role = "user"
+content = "Check {{resource_type}} named {{resource_name}}"
 ```
 
-**Step 2: Embed the YAML file** in your Go code:
+### Overriding Built-in Prompts
 
-```go
-package yourname
+Replace built-in prompts by using the same name:
 
-import (
-	_ "embed"
-	"github.com/containers/kubernetes-mcp-server/pkg/api"
-)
+```toml
+[[prompts]]
+name = "troubleshoot-pod"  # This overrides the built-in version
+description = "Our custom pod troubleshooting process"
 
-//go:embed prompts.yaml
-var promptsYAML []byte
+[[prompts.arguments]]
+name = "pod_name"
+required = true
 
-func initPrompts() []api.ServerPrompt {
-	loader := api.NewPromptLoader()
-	if err := loader.LoadFromBytes(promptsYAML); err != nil {
-		return nil
-	}
-	return loader.GetServerPrompts()
-}
-```
-
-**Step 3: Implement `GetPrompts()`** in your toolset:
+[[prompts.messages]]
+role = "user"
+content = "Pod {{pod_name}} needs help"
 
-```go
-func (t *Toolset) GetPrompts(_ internalk8s.Openshift) []api.ServerPrompt {
-	return initPrompts()
-}
+[[prompts.messages]]
+role = "assistant"
+content = "Using our custom troubleshooting workflow..."
 ```
 
-### Argument Substitution
+### Disabling Built-in Prompts
+
+Use only your custom prompts:
 
-Prompts support template variable substitution using `{{argument_name}}` syntax:
+```toml
+# Disable all built-in prompts
+disable_embedded_prompts = true
 
-- `{{argument_name}}` - Replaced with the argument value
-- Simple string replacement is performed automatically by the prompt loader
+# Then define your own
+[[prompts]]
+name = "my-prompt"
+# ...
+```
 
-### Advanced: Custom Prompt Handlers
+## For Toolset Developers
 
-For more complex prompt logic, you can create custom handlers instead of using YAML:
+If you're creating a custom toolset, define prompts directly in Go code (similar to how tools are defined):
 
 ```go
-func customPromptHandler(params api.PromptHandlerParams) (*api.PromptCallResult, error) {
-	args := params.GetArguments()
+// pkg/toolsets/yourtoolset/prompts.go
+package yourtoolset
 
-	// Custom logic here
-	namespace := args["namespace"]
-	podName := args["pod_name"]
+import (
+	"fmt"
+	"github.com/containers/kubernetes-mcp-server/pkg/api"
+)
 
-	// Build dynamic messages
-	messages := []api.PromptMessage{
+func (t *Toolset) GetPrompts(_ internalk8s.Openshift) []api.ServerPrompt {
+	return []api.ServerPrompt{
 		{
-			Role: "user",
-			Content: api.PromptContent{
-				Type: "text",
-				Text: fmt.Sprintf("Check pod %s in namespace %s", podName, namespace),
+			Prompt: api.Prompt{
+				Name:        "your-prompt",
+				Description: "What it does",
+				Arguments: []api.PromptArgument{
+					{
+						Name:        "arg1",
+						Description: "First argument",
+						Required:    true,
+					},
+				},
 			},
-		},
-		{
-			Role: "assistant",
-			Content: api.PromptContent{
-				Type: "text",
-				Text: "I'll check the pod status...",
+			Handler: func(params api.PromptHandlerParams) (*api.PromptCallResult, error) {
+				args := params.GetArguments()
+				arg1, _ := args["arg1"]
+
+				messages := []api.PromptMessage{
+					{
+						Role: "user",
+						Content: api.PromptContent{
+							Type: "text",
+							Text: fmt.Sprintf("Message with %s", arg1),
+						},
+					},
+					{
+						Role: "assistant",
+						Content: api.PromptContent{
+							Type: "text",
+							Text: "Response template",
+						},
+					},
+				}
+
+				return api.NewPromptCallResult("What it does", messages, nil), nil
 			},
 		},
 	}
-
-	return api.NewPromptCallResult("Custom prompt", messages, nil), nil
 }
 ```
 
-## Using Prompts with AI Assistants
-
-When using the Kubernetes MCP Server with an AI assistant (like Claude):
-
-1. **List available prompts**: The assistant can discover available prompts via the MCP protocol
-2. **Invoke a prompt**: The assistant can call a prompt with specific arguments
-3. **Follow the workflow**: The prompt provides structured guidance for the task
-
-### Example Interaction
-
-```
-User: "My pod is crashing, can you help?"