feat(toolsets): add support for multiple toolsets in configuration (#323)

Users can now enable or disable different toolsets either by providing
a command-line flag or by setting the toolsets array field in the TOML
configuration.

Downstream Kubernetes API developers can declare toolsets for their
APIs by creating a new nested package in pkg/toolsets and registering
it in pkg/mcp/modules.go

Signed-off-by: Marc Nuri <[email protected]>

Author: manusa

Makefile

@@ -111,3 +111,7 @@ golangci-lint: ## Download and install golangci-lint if not already installed
 .PHONY: lint
 lint: golangci-lint ## Lint the code
 	$(GOLANGCI_LINT) run --verbose --print-resources-usage
+
+.PHONY: update-readme-tools
+update-readme-tools: ## Update the README.md file with the latest toolsets
+	go run ./internal/tools/update-readme/main.go README.md

README.md

@@ -0,0 +1,8 @@
+package test
+
+func Must[T any](v T, err error) T {
+	if err != nil {
+		panic(err)
+	}
+	return v
+}

internal/test/test.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"maps"
+	"os"
+	"slices"
+	"strings"
+
+	internalk8s "github.com/containers/kubernetes-mcp-server/pkg/kubernetes"
+	"github.com/containers/kubernetes-mcp-server/pkg/toolsets"
+
+	_ "github.com/containers/kubernetes-mcp-server/pkg/toolsets/config"
+	_ "github.com/containers/kubernetes-mcp-server/pkg/toolsets/core"
+	_ "github.com/containers/kubernetes-mcp-server/pkg/toolsets/helm"
+)
+
+type OpenShift struct{}
+
+func (o *OpenShift) IsOpenShift(ctx context.Context) bool {
+	return true
+}
+
+var _ internalk8s.Openshift = (*OpenShift)(nil)
+
+func main() {
+	readme, err := os.ReadFile(os.Args[1])
+	if err != nil {
+		panic(err)
+	}
+	// Available Toolsets
+	toolsetsList := toolsets.Toolsets()
+	maxNameLen, maxDescLen := len("Toolset"), len("Description")
+	for _, toolset := range toolsetsList {
+		nameLen := len(toolset.GetName())
+		descLen := len(toolset.GetDescription())
+		if nameLen > maxNameLen {
+			maxNameLen = nameLen
+		}
+		if descLen > maxDescLen {
+			maxDescLen = descLen
+		}
+	}
+	availableToolsets := strings.Builder{}
+	availableToolsets.WriteString(fmt.Sprintf("| %-*s | %-*s |\n", maxNameLen, "Toolset", maxDescLen, "Description"))
+	availableToolsets.WriteString(fmt.Sprintf("|-%s-|-%s-|\n", strings.Repeat("-", maxNameLen), strings.Repeat("-", maxDescLen)))
+	for _, toolset := range toolsetsList {
+		availableToolsets.WriteString(fmt.Sprintf("| %-*s | %-*s |\n", maxNameLen, toolset.GetName(), maxDescLen, toolset.GetDescription()))
+	}
+	updated := replaceBetweenMarkers(
+		string(readme),
+		"<!-- AVAILABLE-TOOLSETS-START -->",
+		"<!-- AVAILABLE-TOOLSETS-END -->",
+		availableToolsets.String(),
+	)
+
+	// Available Toolset Tools
+	toolsetTools := strings.Builder{}
+	for _, toolset := range toolsetsList {
+		toolsetTools.WriteString("<details>\n\n<summary>" + toolset.GetName() + "</summary>\n\n")
+		tools := toolset.GetTools(&OpenShift{})
+		for _, tool := range tools {
+			toolsetTools.WriteString(fmt.Sprintf("- **%s** - %s\n", tool.Tool.Name, tool.Tool.Description))
+			for _, propName := range slices.Sorted(maps.Keys(tool.Tool.InputSchema.Properties)) {
+				property := tool.Tool.InputSchema.Properties[propName]
+				toolsetTools.WriteString(fmt.Sprintf("  - `%s` (`%s`)", propName, property.Type))
+				if slices.Contains(tool.Tool.InputSchema.Required, propName) {
+					toolsetTools.WriteString(" **(required)**")
+				}
+				toolsetTools.WriteString(fmt.Sprintf(" - %s\n", property.Description))
+			}
+			toolsetTools.WriteString("\n")
+		}
+		toolsetTools.WriteString("</details>\n\n")
+	}
+	updated = replaceBetweenMarkers(
+		updated,
+		"<!-- AVAILABLE-TOOLSETS-TOOLS-START -->",
+		"<!-- AVAILABLE-TOOLSETS-TOOLS-END -->",
+		toolsetTools.String(),
+	)
+
+	if err := os.WriteFile(os.Args[1], []byte(updated), 0o644); err != nil {
+		panic(err)
+	}
+}
+
+func replaceBetweenMarkers(content, startMarker, endMarker, replacement string) string {
+	startIdx := strings.Index(content, startMarker)
+	if startIdx == -1 {
+		return content
+	}
+	endIdx := strings.Index(content, endMarker)
+	if endIdx == -1 || endIdx <= startIdx {
+		return content
+	}
+	return content[:startIdx+len(startMarker)] + "\n\n" + replacement + "\n" + content[endIdx:]
+}

internal/tools/update-readme/main.go

@@ -20,7 +20,7 @@ type Toolset interface {
 	// Examples: "core", "metrics", "helm"
 	GetName() string
 	GetDescription() string
-	GetTools(k *internalk8s.Manager) []ServerTool
+	GetTools(o internalk8s.Openshift) []ServerTool
 }
 
 type ToolCallRequest interface {

pkg/api/toolsets.go

@@ -20,6 +20,7 @@ type StaticConfig struct {
 	ReadOnly bool `toml:"read_only,omitempty"`
 	// When true, disable tools annotated with destructiveHint=true
 	DisableDestructive bool     `toml:"disable_destructive,omitempty"`
+	Toolsets           []string `toml:"toolsets,omitempty"`
 	EnabledTools       []string `toml:"enabled_tools,omitempty"`
 	DisabledTools      []string `toml:"disabled_tools,omitempty"`
 
@@ -50,22 +51,32 @@ type StaticConfig struct {
 	ServerURL            string   `toml:"server_url,omitempty"`
 }
 
+func Default() *StaticConfig {
+	return &StaticConfig{
+		ListOutput: "table",
+		Toolsets:   []string{"core", "config", "helm"},
+	}
+}
+
 type GroupVersionKind struct {
 	Group   string `toml:"group"`
 	Version string `toml:"version"`
 	Kind    string `toml:"kind,omitempty"`
 }
 
-// ReadConfig reads the toml file and returns the StaticConfig.
-func ReadConfig(configPath string) (*StaticConfig, error) {
+// Read reads the toml file and returns the StaticConfig.
+func Read(configPath string) (*StaticConfig, error) {
 	configData, err := os.ReadFile(configPath)
 	if err != nil {
 		return nil, err
 	}
+	return ReadToml(configData)
+}
 
-	var config *StaticConfig
-	err = toml.Unmarshal(configData, &config)
-	if err != nil {
+// ReadToml reads the toml data and returns the StaticConfig.
+func ReadToml(configData []byte) (*StaticConfig, error) {
+	config := Default()
+	if err := toml.Unmarshal(configData, config); err != nil {
 		return nil, err
 	}
 	return config, nil