Turn Your AI Assistant Into a Kubernetes Expert

Stop switching between your AI chat and kubectl. With kom's MCP server, your AI assistant becomes a native Kubernetes operator that can query, manage, and troubleshoot your clusters directly from the conversation.

The Problem with Kubernetes + AI Workflows

You're debugging a production issue. You ask Claude about pod restart patterns, then tab over to kubectl to check actual pod status, then back to Claude to interpret the results, then back to kubectl to grab logs. This context switching kills your flow and slows down incident response.

Most AI tools can't see your actual cluster state. They give generic advice when you need specific insights about your deployments, your resource consumption, your failing pods.

What kom Delivers

kom is a dual-purpose tool: a Go SDK that wraps kubectl/client-go with a fluent API, and an MCP server that exposes 48+ Kubernetes operations directly to AI tools.

For AI Integration:

• Drop a binary on your system, point it at your kubeconfig, and suddenly Claude can kubectl get pods for you
• Works with Claude Desktop, Cursor, Windsurf, and any MCP-compatible AI tool
• Supports both stdio and SSE modes for maximum compatibility

For Go Development:

• SDK-level wrapper around client-go with chainable methods
• Multi-cluster management with automatic context switching
• SQL queries against Kubernetes resources: SELECT * FROM pods WHERE namespace='prod' ORDER BY creationTimestamp DESC

Real-World Use Cases

Incident Response: Ask your AI "What pods are failing in production?" and get real-time data from your cluster. Follow up with "Show me the logs from the failing pod" and get actual log output, not generic troubleshooting steps.

Resource Planning: "Which nodes are running hot?" pulls real CPU/memory usage. "What's using the most storage?" queries your PVCs and shows actual consumption.

Deployment Management: "Scale the frontend deployment to 5 replicas" executes the change. "Rollback the API deployment" handles the rollout for you.

Cross-Resource Analysis: "Show me all services without corresponding pods" runs complex queries across multiple resource types that would take several kubectl commands to piece together.

The 48 Built-in Tools

kom provides comprehensive cluster management through its MCP interface:

• Resource Operations: Get, list, create, update, delete any Kubernetes resource (including CRDs)
• Pod Management: File operations, log streaming, exec into containers, resource usage monitoring
• Deployment Control: Scaling, restart, rollback, pause/resume rollouts, HPA management
• Node Operations: Taint/untaint, cordon/drain, resource usage analysis
• SQL Queries: Query any resource with SQL syntax across namespaces and clusters

Two-Minute Setup

For AI Integration:

# Build the binary
go build -o kom cmd/kom/main.go

# Set your kubeconfig
export KUBECONFIG=/path/to/your/kubeconfig

# Run the MCP server
./kom

Add to your Claude Desktop config:

{
  "mcpServers": {
    "kubernetes": {
      "command": "/path/to/kom",
      "args": []
    }
  }
}

For Go Development:

import "github.com/weibaohui/kom"

// Register clusters
callbacks.RegisterInit()
kom.Clusters().RegisterByPathWithID(kubeconfig, "production")

// Query with SQL
var pods []v1.Pod
err := kom.DefaultCluster().
    Sql("SELECT * FROM pod WHERE namespace='kube-system' ORDER BY creationTimestamp DESC").
    List(&pods).Error

// Chain operations
err := kom.DefaultCluster().
    Resource(&pod).
    Namespace("production").
    Name("api-server").
    Ctl().Pod().
    GetLogs(&stream, &v1.PodLogOptions{})

Multi-Cluster Operations

Manage multiple clusters from a single interface:

// Register multiple clusters
kom.Clusters().RegisterByPathWithID("/Users/me/.kube/prod", "production")
kom.Clusters().RegisterByPathWithID("/Users/me/.kube/staging", "staging")

// Query across clusters
prodPods := kom.Cluster("production").Resource(&v1.Pod{}).List(&pods)
stagingPods := kom.Cluster("staging").Resource(&v1.Pod{}).List(&pods)

Your AI assistant can now switch between clusters contextually: "Show me production pods" vs "Check staging deployment status."

SQL for Kubernetes

Stop writing complex kubectl commands. Query your cluster like a database:

-- Find pods consuming most memory
SELECT * FROM pod WHERE status.phase='Running' 
ORDER BY spec.containers.resources.requests.memory DESC LIMIT 10

-- Cross-namespace service discovery
SELECT * FROM service WHERE metadata.namespace IN ('prod', 'staging')
AND spec.selector.app = 'api'

-- Resource usage analysis
SELECT * FROM node WHERE 
spec.allocatable.cpu > '4' AND 
metadata.labels.zone = 'us-west-2a'

Advanced Pod Operations

kom handles the tedious file operations that kubectl makes awkward:

// Upload configuration
kom.DefaultCluster().
    Namespace("prod").Name("api-pod").
    Ctl().Pod().ContainerName("app").
    SaveFile("/app/config.json", configData)

// Download logs for analysis
kom.DefaultCluster().
    Namespace("prod").Name("api-pod").
    Ctl().Pod().ContainerName("app").
    DownloadFile("/var/log/app.log")

// Execute maintenance commands
kom.DefaultCluster().
    Namespace("prod").Name("api-pod").
    Ctl().Pod().ContainerName("app").
    Command("systemctl", "restart", "nginx").
    ExecuteCommand(&result)

Performance Optimizations

Built-in caching prevents API server overload during batch operations:

// Cache results for 5 seconds during bulk operations
kom.DefaultCluster().
    Resource(&pod).
    WithCache(5 * time.Second).
    List(&pods)

Production-Ready Features

• Multi-cluster management with automatic context switching
• Callback system for custom business logic integration
• Watch capabilities for real-time cluster monitoring
• Resource usage analysis for capacity planning
• Rollout management for deployment operations
• CRD support for custom resources

Getting Started

1. Clone and build:

   git clone https://github.com/weibaohui/kom.git
   cd kom && go build -o kom cmd/kom/main.go
   

2. Configure your cluster:

   export KUBECONFIG=/path/to/your/kubeconfig
   

3. Start the MCP server:

   ./kom  # Runs on http://localhost:9096/sse
   

4. Integrate with your AI tool using the configuration examples above

Now ask your AI assistant: "What pods are running in the kube-system namespace?" and watch it query your actual cluster.

kom bridges the gap between AI assistance and real infrastructure management. Your AI becomes a true operational partner, not just a documentation lookup tool.