Mcp K8s

What is MCP-K8s?

MCP-K8s, or Model Control Protocol for Kubernetes, is a server designed to facilitate interaction with Kubernetes clusters through various MCP tools. This project aims to simplify the management and orchestration of Kubernetes resources, making it easier for developers and operators to deploy and manage applications in a cloud-native environment.

Features of MCP-K8s

• Seamless Integration: MCP-K8s integrates effortlessly with existing Kubernetes clusters, allowing users to leverage their current infrastructure without significant changes.
• User-Friendly Interface: The project provides a straightforward interface for managing Kubernetes resources, making it accessible for users of all skill levels.
• Extensible Architecture: MCP-K8s is built with extensibility in mind, allowing developers to add custom functionalities and tools as needed.
• Robust Documentation: Comprehensive documentation is available, guiding users through installation, configuration, and usage of the MCP-K8s server.
• Community Support: As an open-source project, MCP-K8s benefits from a vibrant community that contributes to its development and provides support to users.

How to Use MCP-K8s

1. Installation: Begin by cloning the MCP-K8s repository from GitHub. Use the command:

   git clone https://github.com/silenceper/mcp-k8s.git
   

2. Configuration: After cloning, navigate to the project directory and configure the server settings according to your Kubernetes cluster requirements.
3. Running the Server: Start the MCP-K8s server using the provided scripts or commands. Ensure that your Kubernetes cluster is running and accessible.
4. Interacting with the Cluster: Utilize the MCP tools to interact with your Kubernetes resources. You can deploy applications, manage services, and monitor cluster health through the MCP-K8s interface.
5. Extending Functionality: If needed, explore the extensibility options to add custom features or integrate additional tools that suit your workflow.

Frequently Asked Questions

Q1: What is the primary purpose of MCP-K8s?

A1: The primary purpose of MCP-K8s is to provide a server that enables easy interaction with Kubernetes clusters through various tools, simplifying the management of Kubernetes resources.

Q2: Is MCP-K8s suitable for beginners?

A2: Yes, MCP-K8s is designed with a user-friendly interface and robust documentation, making it accessible for users with varying levels of experience in Kubernetes.

Q3: Can I contribute to the MCP-K8s project?

A3: Absolutely! MCP-K8s is an open-source project, and contributions are welcome. You can participate by reporting issues, submitting pull requests, or improving documentation.

Q4: Where can I find more information about MCP-K8s?

A4: More information, including installation guides and usage instructions, can be found on the official MCP-K8s documentation page.

Q5: What license does MCP-K8s use?

A5: MCP-K8s is licensed under the Apache-2.0 license, allowing for both personal and commercial use with proper attribution.

mcp-k8s

A Kubernetes MCP (Model Control Protocol) server that enables interaction with Kubernetes clusters through MCP tools.

Features

• Query supported Kubernetes resource types (built-in resources and CRDs)
• Kubernetes resource operations with fine-grained control
  • Read operations: get resource details, list resources by type with filtering options
  • Write operations: create, update, and delete resources (each can be independently enabled/disabled)
  • Support for all Kubernetes resource types, including custom resources
• Connects to Kubernetes cluster using kubeconfig
• Helm support with fine-grained control
  • Helm releases management (list, get, install, upgrade, uninstall)
  • Helm repositories management (list, add, remove)
  • Each operation can be independently enabled/disabled

Preview

Interaction through cursor

Use Cases

1. Kubernetes Resource Management via LLM

• Interactive Resource Management: Manage Kubernetes resources through natural language interaction with LLM, eliminating the need to memorize complex kubectl commands
• Batch Operations: Describe complex batch operation requirements in natural language, letting LLM translate them into specific resource operations
• Resource Status Queries: Query cluster resource status using natural language and receive easy-to-understand responses

2. Automated Operations Scenarios

• Intelligent Operations Assistant: Serve as an intelligent assistant for operators in daily cluster management tasks
• Problem Diagnosis: Assist in cluster problem diagnosis through natural language problem descriptions
• Configuration Review: Leverage LLM's understanding capabilities to help review and optimize Kubernetes resource configurations

3. Development and Testing Support

• Quick Prototype Validation: Developers can quickly create and validate resource configurations through natural language
• Environment Management: Simplify test environment resource management, quickly create, modify, and clean up test resources
• Configuration Generation: Automatically generate resource configurations that follow best practices based on requirement descriptions

4. Education and Training Scenarios

• Interactive Learning: Newcomers can learn Kubernetes concepts and operations through natural language interaction
• Best Practice Guidance: LLM provides best practice suggestions during resource operations
• Error Explanation: Provide easy-to-understand error explanations and correction suggestions when operations fail

Architecture

1. Project Overview

An stdio-based MCP server that connects to Kubernetes clusters and provides the following capabilities:

• Query Kubernetes resource types (including built-in resources and CRDs)
• CRUD operations on Kubernetes resources (with configurable write operations)
• Helm operations for release and repository management

2. Technical Stack

• Go
• mcp-go SDK
• Kubernetes client-go library
• Helm v3 client library
• Stdio for communication

3. Core Components

1. MCP Server: Uses mcp-go's mcp-k8s package to create an stdio-based MCP server
2. K8s Client: Uses client-go to connect to Kubernetes clusters
3. Helm Client: Uses Helm v3 library for Helm operations
4. Tool Implementations: Implements various MCP tools for different Kubernetes operations

4. Available Tools

Resource Type Query Tools

• get_api_resources: Get all supported API resource types in the cluster

Resource Operation Tools

• get_resource: Get detailed information about a specific resource
• list_resources: List all instances of a resource type
• create_resource: Create new resources (can be disabled)
• update_resource: Update existing resources (can be disabled)
• delete_resource: Delete resources (can be disabled)

Helm Operation Tools

• list_helm_releases: List all Helm releases in the cluster
• get_helm_release: Get detailed information about a specific Helm release
• install_helm_chart: Install a Helm chart (can be disabled)
• upgrade_helm_chart: Upgrade a Helm release (can be disabled)
• uninstall_helm_chart: Uninstall a Helm release (can be disabled)
• list_helm_repositories: List configured Helm repositories
• add_helm_repository: Add a new Helm repository (can be disabled)
• remove_helm_repository: Remove a Helm repository (can be disabled)

Usage

mcp-k8s supports two communication modes:

1. Stdio Mode (Default)

In stdio mode, mcp-k8s communicates with the client through standard input/output streams. This is the default mode and is suitable for most use cases.

### Run in stdio mode (default)
{
    "mcpServers":
    {
        "mcp-k8s":
        {
            "command": "/path/to/mcp-k8s",
            "args":
            [
                "-kubeconfig",
                "/path/to/kubeconfig",
                "-enable-create",
                "-enable-delete",
                "-enable-update",
                "-enable-list",
                "-enable-helm-install",
                "-enable-helm-upgrade"
            ]
        }
    }
}

2. SSE Mode

In SSE (Server-Sent Events) mode, mcp-k8s exposes an HTTP endpoint to mcp client. You can deploy the service on a remote server (but you need to pay attention to security)

### Run in SSE mode
./bin/mcp-k8s -kubeconfig=/path/to/kubeconfig -transport=sse -port=8080 -host=localhost -enable-create -enable-delete -enable-list -enable-update -enable-helm-install
### This command will open all operations

mcp config

{
  "mcpServers": {
    "mcp-k8s": {
      "url": "http://localhost:8080/sse",
      "args": []
    }
  }
}

SSE mode configuration:

• -transport: Set to "sse" to enable SSE mode
• -port: HTTP server port (default: 8080)
• --host: HTTP server host (default: "localhost")

3. Docker environment

SSE Mode

1. Complete Example Assuming your image name is mcp-k8s and you need to map ports and set environment parameters, you can run:

docker run --rm -p 8080:8080 -i -v ~/.kube/config:/root/.kube/config ghcr.io/silenceper/mcp-k8s:latest -transport=sse

stdio Mode

{
  "mcpServers": {
    "mcp-k8s": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "-v",
        "~/.kube/config:/root/.kube/config",
        "--rm",
        "ghcr.io/silenceper/mcp-k8s:latest"
      ]
    }
  }
}

Getting Started

Direct Usage

You can directly download the binary for your platform from the releases page and use it immediately.

Go Install

go install github.com/silenceper/mcp-k8s/cmd/mcp-k8s@latest

Build

git clone https://github.com/silenceper/mcp-k8s.git
cd mcp-k8s
go build -o bin/mcp-k8s cmd/mcp-k8s/main.go

Command Line Arguments

Kubernetes Resource Operations

• -kubeconfig: Path to Kubernetes configuration file (uses default config if not specified)
• -enable-create: Enable resource creation operations (default: false)
• -enable-update: Enable resource update operations (default: false)
• -enable-delete: Enable resource deletion operations (default: false)
• -enable-list: Enable resource list operations (default: true)

Helm Operations

• -enable-helm-release-list: Enable Helm release list operations (default: true)
• -enable-helm-release-get: Enable Helm release get operations (default: true)
• -enable-helm-install: Enable Helm chart installation (default: false)
• -enable-helm-upgrade: Enable Helm chart upgrade (default: false)
• -enable-helm-uninstall: Enable Helm chart uninstallation (default: false)
• -enable-helm-repo-list: Enable Helm repository list operations (default: true)
• -enable-helm-repo-add: Enable Helm repository add operations (default: false)
• -enable-helm-repo-remove: Enable Helm repository remove operations (default: false)

Transport Configuration

• -transport: Transport type (stdio or sse) (default: "stdio")
• -host: Host for SSE transport (default "localhost")
• -port: TCP port for SSE transport (default 8080)

Integration with MCP Clients

mcp-k8s is an stdio-based MCP server that can be integrated with any MCP-compatible LLM client. Refer to your MCP client's documentation for integration instructions.

Security Considerations

• Write operations are strictly controlled through independent configuration switches
• Uses RBAC to ensure K8s client has only necessary permissions
• Validates all user inputs to prevent injection attacks
• Helm operations follow the same security principles with read operations enabled by default and write operations disabled by default

Follow WeChat Official Account