An Stdio based MCP server is started that understands all the commands that eksctl provides, interact with EKS via the LLM in natural language and all the eksctl CLI commands are made available as tools

Author: dims

cmd/eksctl/main.go

@@ -7,19 +7,21 @@ import (
 
 	"github.com/kris-nova/logger"
 	"github.com/spf13/cobra"
-	"github.com/weaveworks/eksctl/pkg/ctl/deregister"
-	"github.com/weaveworks/eksctl/pkg/ctl/register"
 
 	"github.com/weaveworks/eksctl/pkg/actions/anywhere"
 	"github.com/weaveworks/eksctl/pkg/ctl/associate"
 	"github.com/weaveworks/eksctl/pkg/ctl/cmdutils"
 	"github.com/weaveworks/eksctl/pkg/ctl/completion"
 	"github.com/weaveworks/eksctl/pkg/ctl/create"
 	"github.com/weaveworks/eksctl/pkg/ctl/delete"
+	"github.com/weaveworks/eksctl/pkg/ctl/deregister"
 	"github.com/weaveworks/eksctl/pkg/ctl/disassociate"
 	"github.com/weaveworks/eksctl/pkg/ctl/drain"
 	"github.com/weaveworks/eksctl/pkg/ctl/enable"
 	"github.com/weaveworks/eksctl/pkg/ctl/get"
+	"github.com/weaveworks/eksctl/pkg/ctl/mcp"
+	"github.com/weaveworks/eksctl/pkg/ctl/misc"
+	"github.com/weaveworks/eksctl/pkg/ctl/register"
 	"github.com/weaveworks/eksctl/pkg/ctl/scale"
 	"github.com/weaveworks/eksctl/pkg/ctl/set"
 	"github.com/weaveworks/eksctl/pkg/ctl/unset"
@@ -45,11 +47,11 @@ func addCommands(rootCmd *cobra.Command, flagGrouping *cmdutils.FlagGrouping) {
 	rootCmd.AddCommand(deregister.Command(flagGrouping))
 	rootCmd.AddCommand(utils.Command(flagGrouping))
 	rootCmd.AddCommand(completion.Command(rootCmd))
+	rootCmd.AddCommand(mcp.Command(rootCmd))
 	//Ensures "eksctl --help" presents eksctl anywhere as a command, but adds no subcommands since we invoke the binary.
 	rootCmd.AddCommand(cmdutils.NewVerbCmd("anywhere", "EKS anywhere", ""))
 
-	cmdutils.AddResourceCmd(flagGrouping, rootCmd, infoCmd)
-	cmdutils.AddResourceCmd(flagGrouping, rootCmd, versionCmd)
+	misc.Command(flagGrouping, rootCmd)
 }
 
 func main() {
@@ -117,6 +119,10 @@ func checkCommand(rootCmd *cobra.Command) {
 		if cmd.RunE != nil {
 			continue
 		}
+		// mcp command does not need a resource type
+		if cmd.Name() == "mcp" {
+			continue
+		}
 		cmd.RunE = func(c *cobra.Command, args []string) error {
 			var e error
 			if len(args) == 0 {

go.mod

@@ -47,6 +47,7 @@ require (
 	github.com/kris-nova/lolgopher v0.0.0-20210112022122-73f0047e8b65
 	github.com/kubicorn/kubicorn v0.0.0-20191114212505-a2c64ce430b9
 	github.com/lithammer/dedent v1.1.0
+	github.com/mark3labs/mcp-go v0.31.0
 	github.com/maxbrunsfeld/counterfeiter/v6 v6.11.2
 	github.com/onsi/ginkgo v1.16.5
 	github.com/onsi/ginkgo/v2 v2.23.4
@@ -397,6 +398,7 @@ require (
 	github.com/yagipy/maintidx v1.0.0 // indirect
 	github.com/yeya24/promlinter v0.3.0 // indirect
 	github.com/ykadowak/zerologlint v0.1.5 // indirect
+	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
 	gitlab.com/bosi/decorder v0.4.2 // indirect
 	go-simpler.org/musttag v0.13.0 // indirect
 	go-simpler.org/sloglint v0.9.0 // indirect

go.sum

@@ -668,6 +668,8 @@ github.com/maratori/testableexamples v1.0.0 h1:dU5alXRrD8WKSjOUnmJZuzdxWOEQ57+7s
 github.com/maratori/testableexamples v1.0.0/go.mod h1:4rhjL1n20TUTT4vdh3RDqSizKLyXp7K2u6HgraZCGzE=
 github.com/maratori/testpackage v1.1.1 h1:S58XVV5AD7HADMmD0fNnziNHqKvSdDuEKdPD1rNTU04=
 github.com/maratori/testpackage v1.1.1/go.mod h1:s4gRK/ym6AMrqpOa/kEbQTV4Q4jb7WeLZzVhVVVOQMc=
+github.com/mark3labs/mcp-go v0.31.0 h1:4UxSV8aM770OPmTvaVe/b1rA2oZAjBMhGBfUgOGut+4=
+github.com/mark3labs/mcp-go v0.31.0/go.mod h1:rXqOudj/djTORU/ThxYx8fqEVj/5pvTuuebQ2RC7uk4=
 github.com/matoous/godox v1.1.0 h1:W5mqwbyWrwZv6OQ5Z1a/DHGMOvXYCBP3+Ht7KMoJhq4=
 github.com/matoous/godox v1.1.0/go.mod h1:jgE/3fUXiTurkdHOLT5WEkThTSuE7yxHv5iWPa80afs=
 github.com/matryer/is v1.4.0 h1:sosSmIWwkYITGrxZ25ULNDeKiMNzFSr4V/eqBQP0PeE=
@@ -1059,6 +1061,8 @@ github.com/yeya24/promlinter v0.3.0 h1:JVDbMp08lVCP7Y6NP3qHroGAO6z2yGKQtS5Jsjqto
 github.com/yeya24/promlinter v0.3.0/go.mod h1:cDfJQQYv9uYciW60QT0eeHlFodotkYZlL+YcPQN+mW4=
 github.com/ykadowak/zerologlint v0.1.5 h1:Gy/fMz1dFQN9JZTPjv1hxEk+sRWm05row04Yoolgdiw=
 github.com/ykadowak/zerologlint v0.1.5/go.mod h1:KaUskqF3e/v59oPmdq1U1DnKcuHokl2/K1U4pmIELKg=
+github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
+github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

pkg/ctl/mcp/README.md

@@ -0,0 +1,103 @@
+# eksctl MCP (Model Context Protocol) Package
+
+## Overview
+
+The `pkg/ctl/mcp` package implements a [Model Context Protocol (MCP)](https://github.com/modelcontextprotocol) server for eksctl. This server enables AI assistants like Amazon Q to interact with eksctl functionality directly through a standardized protocol, allowing for seamless integration of eksctl commands into AI-powered workflows.
+
+## What is MCP?
+
+Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context and tools to Large Language Models (LLMs). It enables AI assistants to:
+
+1. Discover available tools and their capabilities
+2. Execute commands and receive structured responses
+3. Provide contextual information to enhance AI interactions
+
+## How the eksctl MCP Server Works
+
+The eksctl MCP server exposes all eksctl commands as tools that can be invoked by AI assistants. The implementation consists of several key components:
+
+### Core Components
+
+1. **`mcp.go`**: Entry point that defines the `mcp` command and starts the MCP server
+2. **`server.go`**: Creates and configures the MCP server with all eksctl commands
+3. **`tools.go`**: Handles the registration of eksctl commands as MCP tools
+4. **`types.go`**: Defines types and interfaces used by the MCP implementation
+
+### Implementation Details
+
+- The server uses the `mcp-go` library to implement the Model Context Protocol
+- It dynamically registers all eksctl commands (create, get, delete, etc.) as MCP tools
+- Each command's help text, flags, and parameters are exposed through the protocol
+- The server runs as a stdio server, communicating through standard input/output
+
+### Command Registration Process
+
+1. The server recursively traverses the eksctl command tree
+2. For each command, it extracts:
+   - Command description and usage information
+   - Available flags and their descriptions
+   - Required and optional parameters
+
+## Using the eksctl MCP Server with Amazon Q Chat
+
+To use the eksctl MCP server with Amazon Q Chat, you need to register it in the Amazon Q configuration file.
+
+Create or edit the file at `$HOME/.aws/amazonq/mcp.json` with the following content:
+
+```json
+{
+  "mcpServers": {
+    "eks-tools": {
+      "command": "eksctl",
+      "args": [
+        "mcp"
+      ]
+    }
+  }
+}
+```
+
+This configuration tells Amazon Q Chat to:
+1. Register a server named "eks-tools"
+2. Use the `eksctl mcp` command to start the MCP server
+3. Make all eksctl commands available as tools with the prefix `eks___`
+
+## Benefits
+
+- **Seamless Integration**: AI assistants can execute eksctl commands directly
+- **Structured Responses**: Commands return structured data that can be parsed by AI models
+- **Discoverability**: AI assistants can discover available commands and their parameters
+- **Context-Aware**: Provides rich context about EKS clusters and resources
+
+## Development
+
+When extending the MCP server functionality:
+
+1. Add new command registrations in `server.go` if new eksctl commands are created
+2. Extend type definitions in `types.go` as needed
+3. Modify `tools.go` if changes to tool registration logic are required
+
+## Example Usage in Amazon Q Chat
+
+Once configured, users can interact with eksctl through Amazon Q Chat:
+
+```
+User: What EKS clusters do I have?
+Amazon Q: Let me check your EKS clusters.
+[Amazon Q executes the eksctl get cluster command and displays the results]
+
+User: Create a new EKS cluster
+Amazon Q: [Guides the user through cluster creation using eksctl commands]
+```
+
+The MCP server enables these interactions by providing Amazon Q with the ability to execute eksctl commands and interpret their results.
+
+## Quick test for MCP server
+To quickly test the MCP server, you can run the following command in your terminal:
+
+```bash
+echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | eksctl mcp | jq
+```
+
+## Recommendations
+- Monitor background operations for long-running commands. Commands such as cluster creations have a 45-second timeout for command responses but the processes continue in background.

pkg/ctl/mcp/mcp.go

@@ -0,0 +1,65 @@
+// Package mcp implements the Model Context Protocol (MCP) server functionality for eksctl
+// MCP allows eksctl to be used as a tool provider for AI assistants
+package mcp
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/mark3labs/mcp-go/server"
+	"github.com/spf13/cobra"
+
+	"github.com/weaveworks/eksctl/pkg/version"
+)
+
+// Command creates the `mcp` commands
+// This command starts an MCP server that provides eksctl functionality through the Model Context Protocol
+func Command(rootCommand *cobra.Command) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "mcp",
+		Short: "Start an MCP (Model Context Protocol) server",
+		Long:  "Start an MCP server that provides eksctl functionality through the Model Context Protocol",
+		Run: func(_ *cobra.Command, _ []string) {
+			startMCPServer(rootCommand)
+		},
+		Hidden: true, // Hide this command from normal usage
+	}
+
+	return cmd
+}
+
+// startMCPServer initializes and starts the MCP server
+// It creates an eksctl MCP server and connects it to stdin/stdout for communication
+func startMCPServer(rootCommand *cobra.Command) {
+	// Create the MCP server
+	mcpServer, err := newEksctlMCPServer(rootCommand, version.GetVersion())
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error creating MCP server: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Create a stdio server
+	stdioServer := server.NewStdioServer(mcpServer)
+
+	// Start the server
+	if err := stdioServer.Listen(context.Background(), os.Stdin, os.Stdout); err != nil {
+		fmt.Fprintf(os.Stderr, "Error starting MCP server: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+// newEksctlMCPServer creates and configures an MCP server for eksctl
+// It sets up the command structure and registers all eksctl commands as MCP tools
+func newEksctlMCPServer(rootCmd *cobra.Command, version string) (*server.MCPServer, error) {
+
+	// Create a new MCP server with the specified name and version
+	s := server.NewMCPServer("eksctl", version, server.WithInstructions("MCP server for eksctl"))
+
+	// Register all eksctl commands as MCP tools
+	if err := registerTools(s, rootCmd); err != nil {
+		return nil, err
+	}
+
+	return s, nil
+}

pkg/ctl/mcp/mcp_test.go

@@ -0,0 +1,52 @@
+package mcp
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewEksctlMCPServer(t *testing.T) {
+	// Create a simple root command for testing
+	rootCmd := &cobra.Command{
+		Use:   "eksctl",
+		Short: "The official CLI for Amazon EKS",
+	}
+
+	// Add a test subcommand
+	testCmd := &cobra.Command{
+		Use:   "test",
+		Short: "Test command",
+		Run:   func(cmd *cobra.Command, args []string) {},
+	}
+	rootCmd.AddCommand(testCmd)
+
+	// Create the MCP server
+	mcpServer, err := newEksctlMCPServer(rootCmd, "test-version")
+
+	// Verify server creation
+	assert.NoError(t, err)
+	assert.NotNil(t, mcpServer)
+
+	// We can't directly access name and version fields, but we can verify the server was created
+	require.NotNil(t, mcpServer)
+}
+
+func TestCommand(t *testing.T) {
+	// Create a root command
+	rootCmd := &cobra.Command{
+		Use:   "eksctl",
+		Short: "The official CLI for Amazon EKS",
+	}
+
+	// Create the MCP command
+	mcpCmd := Command(rootCmd)
+
+	// Verify command properties
+	assert.Equal(t, "mcp", mcpCmd.Use)
+	assert.True(t, mcpCmd.Hidden)
+	assert.NotEmpty(t, mcpCmd.Short)
+	assert.NotEmpty(t, mcpCmd.Long)
+}

pkg/ctl/mcp/misc_test.go

@@ -0,0 +1,52 @@
+package mcp
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/weaveworks/eksctl/pkg/ctl/cmdutils"
+	"github.com/weaveworks/eksctl/pkg/ctl/misc"
+)
+
+// TestMiscCommandRegistration tests that misc commands are properly registered
+func TestMiscCommandRegistration(t *testing.T) {
+	// Create a root command
+	rootCmd := &cobra.Command{
+		Use:   "eksctl",
+		Short: "The official CLI for Amazon EKS",
+	}
+
+	// Create a flag grouping for the commands
+	flagGrouping := cmdutils.NewGrouping()
+
+	// Register misc commands to the root command
+	misc.Command(flagGrouping, rootCmd)
+
+	// Create the MCP server with the root command
+	mcpServer, err := newEksctlMCPServer(rootCmd, "test-version")
+	require.NoError(t, err)
+	require.NotNil(t, mcpServer)
+
+	// Verify that the version command was registered
+	versionCmd := findCommandInTest(rootCmd, "version")
+	assert.NotNil(t, versionCmd, "version command should be registered")
+
+	// Verify that the info command was registered
+	infoCmd := findCommandInTest(rootCmd, "info")
+	assert.NotNil(t, infoCmd, "info command should be registered")
+}
+
+// findCommandInTest recursively searches for a command by name
+func findCommandInTest(cmd *cobra.Command, name string) *cobra.Command {
+	for _, subCmd := range cmd.Commands() {
+		if subCmd.Name() == name {
+			return subCmd
+		}
+		if found := findCommandInTest(subCmd, name); found != nil {
+			return found
+		}
+	}
+	return nil
+}