Mkp

MKP is a Model Context Protocol (MCP) server specifically designed for Kubernetes, providing tools for interacting with Kubernetes clusters and supporting resource query and application operations.

Developer tools Cloud platform #K8s Interaction #Model Protocol #Resource Management #Go Implementation .Go

rating : 2.5 points

downloads : 5.4K

update time : 2025-04-28

Open Site

What is MKP?

MKP is a Model Context Protocol (MCP) server specifically designed for Kubernetes. It allows large language model (LLM) applications to interact with Kubernetes clusters through a standard protocol, performing operations such as viewing resources, retrieving logs, and applying configurations.

How to use MKP?

MKP can be accessed via a simple REST API or the MCP protocol. You need to configure Kubernetes access permissions, and then you can manage cluster resources by sending requests in JSON format.

Use cases

MKP is particularly suitable for scenarios where Kubernetes management needs to be integrated into AI workflows, such as automated operations, intelligent monitoring, and natural language-based cluster management.

Main Features

Resource List

List all supported resource types in the Kubernetes cluster, including custom resources (CRD).

Get Resources

Get detailed information about specific resources, including sub - resources such as status, extended information, and logs.

Apply Resources

Create or update Kubernetes resources, supporting cluster - scoped and namespace - scoped resources.

Universal Resource Support

Support all Kubernetes resource types through an unstructured client without the need for specific handlers.

Advantages

Natively implemented in Go, perfectly integrated with Kubernetes

Directly use the Kubernetes API without relying on external tools such as kubectl

Support all Kubernetes resource types, including custom resources

Lightweight design, easy to extend and maintain

Production - ready architecture with comprehensive error handling

Limitations

Requires access permissions to the Kubernetes cluster

Read - only mode by default, write operations need to be explicitly enabled

In large clusters, resource discovery may consume more memory

How to Use

Install MKP

Clone the repository and install dependencies

Build the server

Compile the MKP server

Run the server

Start the server with the default kubeconfig

Configure access permissions

Ensure that your kubeconfig file is correctly configured with cluster access permissions

Usage Examples

Get Deployment status

Check the status of the nginx - deployment in the default namespace

View Pod logs

Get the logs of a specific container in the past hour

Create Deployment

Create an nginx Deployment in the default namespace

Frequently Asked Questions

What permissions does MKP need to run?

How to restrict MKP access to specific namespaces?

Which versions of Kubernetes does MKP support?

How to improve the performance of MKP?

What's the difference between MKP and kubectl?

Related Resources

GitHub Repository

Source code and issue tracking for MKP

Kubernetes Documentation

Official Kubernetes documentation

Model Context Protocol

MCP protocol and ToolHive implementation

🚀 MKP Project Documentation

MKP is a tool designed for interacting with Kubernetes clusters. It offers resource access and services through the Model Context Protocol (MCP). The tool comes with a range of features, including resource discovery, operations, and configuration management.

🚀 Quick Start

📦 Installation

# Clone the repository and build
git clone https://github.com/StacklokLabs/mkp.git
cd mkp
make build

🚀 Running the Server

# Default run
./build/mkp-server

# Specify the kubeconfig file
./build/mkp-server --kubeconfig=/path/to/kubeconfig

# Run in read-only mode (default)
./build/mkp-server --read-only=true

# Disable resource discovery
./build/mkp-server --serve-resources=false

💻 Usage Examples

MCP Tools - Resource Operation Tools

Basic Usage - Getting Resource Information

# Example command
echo '{
  "id": "get_resource",
  "method": "GET",
  "params": {
    "uri": "k8s://clustered/apps/v1/deployments/nginx-deployment"
  }
}' | ./build/mkp-server --tool stdout

Listing Resources

# Example command
echo '{
  "id": "list_resources",
  "method": "GET",
  "params": {
    "uri": "k8s://clustered/apps/v1/deployments"
  }
}' | ./build/mkp-server --tool stdout

Applying Resource Configuration

# Example command
echo '{
  "id": "apply_resource", 
  "method": "POST",
  "params": {
    "uri": "k8s://namespaced/default/apps/v1/deployments/nginx-deployment",
    "manifest": {
      "apiVersion": "apps/v1",
      "kind": "Deployment",
      "metadata": {
        "name": "nginx-deployment",
        "namespace": "default"
      },
      "spec": {
        "replicas": 3,
        "selector": {
          "matchLabels": {
            "app": "nginx"
          }
        },
        "template": {
          "metadata": {
            "labels": {
              "app": "nginx"
            }
          },
          "spec": {
            "containers": [
              {
                "name": "nginx",
                "image": "nginx:latest",
                "ports": [80]
              }
            ]
          }
        }
      }
    }
  }
}' | ./build/mkp-server --tool stdout

📚 Documentation

Resource Discovery and Service Modes

Configuration Options

Resource Discovery: Control whether to enable the resource discovery function via the --serve-resources parameter.
Service Mode: The default is read-only mode. Use --read-only or --read-write to set read and write permissions.

Development Information

Code Testing

make test

Code Formatting

make fmt

Dependency Management

go mod tidy

Integration with ToolHive

Running an Instance

# Start the MCP server
./build/mkp-server --tool stdout

# Deploy using ToolHive
poetry run mcp run \
    --name mkp-service \
    --image ./build/mkp-server \
    --command "mkp-server" \
    --port 8080