k8scortex-mcp
K8sCortex is a governed Kubernetes MCP gateway for AI agents to inspect, troubleshoot, and safely operate multiple Kubernetes clusters.
Read and inspect workloads, pods, deployments, StatefulSets, DaemonSets, nodes, namespaces, jobs, CronJobs, ConfigMaps, Secrets, services, ingresses, PVCs, events, quotas, HPAs, PDBs, VPAs, storage classes, node pools, add-ons, and workload identity.
Fetch pod logs, describe resources, check rollout status, service endpoints, resource utilization/recommendations, node pressure, warning events, and ServiceAccount permissions.
Perform governed writes such as scaling, restarting, rollback, creating/deleting deployments and namespaces, creating jobs, managing ConfigMaps/Secrets/services/network policies/HPAs, updating ingresses, setting resource limits, suspending/resuming CronJobs, cordoning/draining/tainting nodes, and syncing/suspending/resuming GitOps resources.
Use generic read tools for arbitrary Kubernetes resources by API group/version/resource.
Manage multi-cluster and multi-cloud registries, target clusters per call, compare applications across clusters, and inspect cluster/node-pool/cloud metadata.
Work with GitOps via ArgoCD and Flux status, diff, sync, suspend/resume, sources, alerts, Kustomizations, and HelmReleases.
Enforce security and governance with OIDC authentication, role-based tool access, per-cluster policies, structured audit logging, short-lived cloud credentials, and dry-run defaults for destructive operations.
Connect via stdio for local clients or SSE/HTTP as a shared team service.
Provides a natural-language interface to manage Kubernetes clusters, including workloads, deployments, configurations, observability, and multi-cluster operations.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@k8scortex-mcp List all pods in the default namespace"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
K8sCortex — Kubernetes MCP Server
Give your AI agents Kubernetes access your security team will sign off on. K8sCortex is one governed MCP gateway for GKE, EKS, AKS, OpenShift and local clusters: SSO on every request, role tiers, per-cluster policies, dry-run by default, and an audit log of who asked for what.
Most Kubernetes MCP servers hand an agent your kubeconfig. K8sCortex sits in between: it decides, per person and per cluster, which of its 75 tools may run, and records every call. Clusters from different clouds live in one registry, with credentials minted on demand.

A real Claude Code session with K8sCortex as its only tool, on a throwaway prod cluster: the developer is denied the rollback, the release manager is blocked by the prod policy, the SRE fixes it. Watch all five scenarios (97 s): incident, release drift, flash-sale scaling, password rotation, node maintenance. How it was recorded.
Features
Curated multi-domain toolset across workload, deployment, configuration, observability, jobs, networking, GitOps, cluster admin, and generic read paths
Multi-cloud cluster providers — kubeconfig contexts, Amazon EKS (IAM/IRSA), Google GKE (Workload Identity) and Azure Key Vault, mixed in one registry
Multi-cluster routing — target any registered cluster with a single
clusterparameter; writes require an explicit cluster when several are registeredAny OIDC identity provider (Entra ID, Okta, Cognito, Keycloak, Google) with per-tool RBAC (5-tier role hierarchy) and per-cluster policies
Structured audit logging — every tool call recorded with caller identity, arguments, and outcome
Dual transport — SSE/HTTP for programmatic clients + stdio for Claude Desktop
Short-lived credentials — EKS and GKE tokens are minted on demand and cached only until they expire
Dry-run safety — destructive tools default to simulation mode
Generic read coverage — list/get support for resources outside curated write paths to avoid troubleshooting dead-ends
Related MCP server: k8s-mcp-server
Install
Claude Desktop, Claude Code, Cursor and other MCP clients (stdio)
Requires Node.js 22+ and a working kubeconfig. Add to your client's MCP configuration (Claude Desktop: claude_desktop_config.json):
{
"mcpServers": {
"k8scortex": {
"command": "npx",
"args": ["-y", "k8scortex-mcp"],
"env": { "K8SCORTEX_STDIO_ROLES": "developer" }
}
}
}developer gives a read-only session; remove it for the full toolset. With Claude Code: claude mcp add k8scortex -- npx -y k8scortex-mcp.
As a shared service for a team (HTTP + OIDC)
With the Helm chart (read-only RBAC by default; see the chart README for writes and more clouds):
helm install k8scortex ./charts/k8scortex -n platform-mcp --create-namespace \
--set auth.oidc.issuer=https://login.example.com --set auth.oidc.audience=k8scortexPlain manifests rendered from the chart are in kubernetes/. Or run the image directly:
docker run -p 3000:3000 \
-e OIDC_ISSUER=https://login.example.com -e OIDC_AUDIENCE=k8scortex \
-e CLUSTERS_CONFIG=/config/clusters.json -v "$PWD/clusters.json:/config/clusters.json:ro" \
ghcr.io/apatilgtn/k8scortex-mcp:latestRun it in a management cluster with Workload Identity / IRSA / managed identity for the cloud providers, expose /mcp internally, and ship the audit log to your SIEM. See Multi-cloud setup and Authentication.
Develop
Prerequisites
Node.js ≥ 22 (the GKE provider's
google-auth-libraryand thejosedependency ofjwks-rsaneed it)A Kubernetes cluster (minikube, kind, GKE, EKS, AKS or OpenShift)
kubectlconfigured with a valid context
Install & Run
# Clone
git clone https://github.com/apatilgtn/k8scortex-mcp.git
cd k8scortex-mcp
# Install
npm install
# Build
npm run build
# Run (local dev mode — auth bypassed)
DISABLE_AUTH=true PORT=3001 npm run devConnect with MCP Inspector
npx @modelcontextprotocol/inspector sse http://localhost:3001/mcpConnect Claude Desktop to a local build
Point the client at your build instead of the npm package:
{
"mcpServers": {
"k8scortex": {
"command": "node",
"args": ["<path-to>/k8scortex-mcp/dist/stdio.js"]
}
}
}Restart Claude Desktop. Ask: "List all pods in the default namespace".
Every context in your kubeconfig is available as a cluster, so you can ask "Compare the web app's ArgoCD revision between kind-dev and prod-eks". Set K8SCORTEX_STDIO_ROLES=developer to give the local session read-only tools.
Multi-cloud setup
K8sCortex picks its cluster source from the environment:
Source | When | Clusters |
| Set | Clusters listed in the file, across any providers |
Azure Key Vault |
| The Key Vault cluster index |
kubeconfig | Otherwise (or | Every context in |
DEFAULT_CLUSTER chooses the cluster used when a tool call names none. Read-only tools fall back to it; mutating tools require an explicit cluster whenever more than one cluster is registered.
Cluster registry file
{
"defaultCluster": "dev",
"clusters": [
{ "name": "dev", "provider": "kubeconfig", "context": "kind-dev", "labels": { "env": "dev" } },
{ "name": "prod-eks", "provider": "eks", "region": "us-east-1", "eksClusterName": "prod",
"roleArn": "arn:aws:iam::111122223333:role/k8scortex", "labels": { "env": "prod" } },
{ "name": "prod-gke", "provider": "gke", "project": "my-project", "location": "us-central1",
"gkeClusterName": "prod", "labels": { "env": "prod" } },
{ "name": "prod-aks", "provider": "azure-keyvault", "cloud": "aks", "region": "australiaeast",
"keyVaultUri": "https://my-vault.vault.azure.net", "labels": { "env": "prod" } }
],
"policies": [
{ "labels": { "env": "prod" }, "minRole": "sre", "appliesTo": "mutating" },
{ "match": "prod-*", "denyTools": ["drain_node", "delete_namespace"] }
]
}Provider | Credentials | Fields |
| Whatever the context uses, including exec plugins ( |
|
| Default AWS chain (IRSA, EKS Pod Identity, instance profile, env, SSO), optionally assuming |
|
| Application Default Credentials (GKE Workload Identity, service account, |
|
| Managed identity; base64 kubeconfig in secret |
|
The EKS and GKE providers use optional dependencies (@aws-sdk/client-eks, @aws-sdk/credential-providers, @smithy/signature-v4, @aws-crypto/sha256-js, google-auth-library) that npm installs by default. The identity needs eks:DescribeCluster plus an EKS access entry, or container.clusters.get plus Kubernetes RBAC on GKE.
Per-cluster policies
Policies match clusters by name glob (match) and/or labels, and can only tighten the global role table:
minRoleraises the role required on matching clusters (appliesTo: "mutating"limits it to write tools)denyToolsdisables tools for everyone on matching clusters
compare_clusters is checked against both clusters it reads.
Authentication
HTTP mode refuses to start unless an identity provider is configured (or DISABLE_AUTH=true):
Variable | Description |
| Issuer URL(s), comma-separated; JWKS is discovered from |
| Expected audience(s), comma-separated |
| Optional JWKS URL override |
| Claim holding roles/groups (default |
| JSON map from IdP group names to K8sCortex roles, e.g. |
| Shorthand for Entra ID (sets issuer, audience and JWKS) |
Tools
K8sCortex intentionally keeps writes curated and governed, while allowing flexible read access for diagnostics.
Domain | Tool | Description |
Workload |
| List pods with status and IP |
Workload |
| Fetch container logs |
Workload |
| Full deployment spec |
Workload |
| List StatefulSets with rollout status |
Workload |
| Detailed StatefulSet spec/status |
Workload |
| List DaemonSets with scheduling status |
Workload |
| Detailed DaemonSet spec/status |
Workload |
| Cluster nodes with Ready status |
Deploy |
| Scale replicas (dry-run default) |
Deploy |
| Delete pod to trigger restart |
Config |
| Read ConfigMap data |
Config |
| Resource quota usage |
Config |
| Recent namespace events |
Config |
| PVC status, bound volume, storage class, capacity |
Config |
| ServiceAccount SubjectAccessReview matrix |
Generic Read |
| Generic list for arbitrary resource kinds |
Generic Read |
| Generic get for arbitrary resource kinds |
Observe |
| HPA metrics and scaling |
Observe |
| Warning events for triage |
Observe |
| Node memory/disk/PID pressure |
Multi |
| All registered clusters |
Multi |
| Node count, versions, architecture |
For the evolving full catalog, see docs/developer-guide.md.
Managed Risk
The largest functional risk in Kubernetes MCP is dead-end visibility on non-curated resources (for example StatefulSets, DaemonSets, PVCs, or CRDs). K8sCortex addresses this by combining:
Governed writes: high-impact operations remain explicit, role-gated, and often dry-run by default.
Flexible reads: generic read tools cover arbitrary resource kinds for diagnostics.
This keeps the governance posture strong while preserving practical troubleshooting coverage.
Scope Boundaries (v1)
K8sCortex is designed as a governed platform interface, not an unrestricted Kubernetes super-client.
Generic write for any resource: intentionally out of scope in v1. Writes are curated and role-gated by design.
Pod exec interactive sessions: intentionally out of scope in v1. This requires stronger session controls and command-level auditing that are planned for a later version.
Architecture
Claude / IDE agents / CI-CD
│
▼
┌──────────────────────────────┐
│ K8sCortex MCP Server │
│ OIDC → RBAC → Policy → Tool │
│ → Audit │
│ │ │
│ Cluster Registry │
│ kubeconfig│EKS│GKE│KeyVault │
└──────────┬───────────────────┘
│
┌──────┼──────┬──────┐
▼ ▼ ▼ ▼
AKS EKS GKE OpenShift / localSecurity
Authentication: OIDC tokens (issuer, audience and signature) validated on every request; sessions are bound to the user that created them
Authorization: Role-based tool access (
developer→platform-engineer), tightened per cluster by policiesAudit: JSON-structured log per invocation with user, tool, cluster, provider and outcome; secret values are redacted
Network: ClusterIP only — no public endpoint
Credentials: Short-lived EKS/GKE tokens or Key Vault kubeconfigs, cached only until expiry
Project Structure
src/
├── index.ts # HTTP server (StreamableHTTP + SSE)
├── stdio.ts # Stdio entry point (Claude Desktop)
├── server.ts # Tool registry, authorization and dispatch
├── auth.ts # OIDC middleware
├── roles.ts # RBAC role hierarchy and per-cluster policies
├── audit.ts # Audit logger with redaction
├── context.ts # AsyncLocalStorage user context
├── cluster-store.ts # Per-cluster K8s client cache
├── clusters/
│ ├── registry.ts # Cluster registry and CLUSTERS_CONFIG loader
│ ├── kubeconfig.ts # kubeconfig contexts provider
│ ├── eks.ts # Amazon EKS provider
│ ├── gke.ts # Google GKE provider
│ └── azure-keyvault.ts # Azure Key Vault provider
└── tools/ # 75 tools in 14 modules: workload, deployment, configuration,
# config_management, workload_creation, jobs, network, observability,
# resource_intelligence, cloud_awareness, cluster_admin, gitops,
# generic_read, multicluster
tests/
├── *.test.ts # Unit and auth/audit integration tests (vitest)
└── e2e/
├── kwok/ # 164-scenario matrix on two simulated clusters (runs in CI)
└── gke/ # Every tool, both GKE providers and policies on a real GKE cluster
charts/k8scortex/ # Helm chart for the shared HTTP service (tested on kind in CI)
kubernetes/ # The chart rendered to plain manifests, with example values
Dockerfile # Image published to ghcr.io/apatilgtn/k8scortex-mcp
docs/
├── developer-guide.md # End-user documentation
├── operator-runbook.md # Platform team operations
└── slos.md # Service level objectivesTesting
Every push runs lint, typecheck, unit tests, auth/audit integration tests and a 164-scenario end-to-end matrix on two KWOK clusters (GKE-like and EKS-like). Releases are also checked against a real GKE cluster with npm run test:e2e:gke: v1.1.1 passed 100/100 on GKE 1.36, and that run found the three GKE-specific bugs fixed in the changelog.
Documentation
Developer Guide — How to connect, available tools, example queries
Operator Runbook — Deploy, upgrade, rotate credentials, incident response
SLOs — Availability, latency, and alerting targets
Contributing
Issues and pull requests are welcome. Run npm run release:gate before opening a PR; new tools need a role in src/roles.ts and a case in the KWOK matrix.
License
Available Tools
75 toolscompare_clustersB
Compares the running version/state of an application across two clusters.
Inputs: engine (required), appName (required), clusterA (required), clusterB (required), +1 more.
cordon_nodeB
Marks a node as unschedulable.
Inputs: nodeName (required), dryRun, cluster.
create_configmapA
Creates a new ConfigMap. Use either basic key-value data or provide a raw YAML manifest.
Inputs: namespace (required), data, dryRun, cluster, +2 more.
create_deploymentA
Creates a new Deployment. Use either basic configuration or provide a raw YAML manifest.
Inputs: namespace (required), port, image, dryRun, +4 more.
create_horizontal_pod_autoscalerA
Creates an HPA for a Deployment. Use either basic configuration or provide a raw YAML manifest.
Inputs: namespace (required), dryRun, cluster, hpaName, +5 more.
create_jobB
Creates a new Job. Use either basic configuration or provide a raw YAML manifest.
Inputs: namespace (required), image, dryRun, cluster, +3 more.
create_namespaceC
Creates a new Kubernetes Namespace.
Inputs: namespaceName (required), dryRun, cluster.
create_network_policyA
Creates a new NetworkPolicy. Use either basic configuration or provide a raw YAML manifest.
Inputs: namespace (required), dryRun, cluster, policyName, +3 more.
create_secretA
Creates a new Opaque Secret. Use either basic stringData or provide a raw YAML manifest. stringData values will be base64-encoded automatically.
Inputs: namespace (required), dryRun, cluster, secretName, +2 more.
create_serviceA
Creates a new Service. Use either basic configuration or provide a raw YAML manifest.
Inputs: namespace (required), port, type, dryRun, +5 more.
delete_deploymentC
Deletes an existing Deployment.
Inputs: namespace (required), deploymentName (required), dryRun, cluster.
delete_namespaceB
Deletes an existing Kubernetes Namespace.
Inputs: namespaceName (required), dryRun, cluster.
describe_daemonsetB
Shows details of a DaemonSet.
Inputs: namespace (required), daemonSetName (required), cluster.
describe_deploymentC
Shows details of a deployment.
Inputs: namespace (required), deploymentName (required), cluster.
describe_namespace_quotaB
Reads resource quotas for a namespace.
Inputs: namespace (required), cluster.
describe_podA
Shows detailed pod status including container states, conditions, resource settings, and recent events.
Inputs: podName (required), namespace (required), cluster.
describe_statefulsetB
Shows details of a StatefulSet.
Inputs: namespace (required), statefulSetName (required), cluster.
drain_nodeC
Cordons the node and evicts/deletes non-daemonset pods.
Inputs: nodeName (required), force, dryRun, cluster.
get_addon_healthA
Checks health of common kube-system addons (CoreDNS, metrics-server, kube-proxy, CNI).
Inputs: cluster.
get_cluster_infoA
Returns API server URL, Kubernetes version, node count, and cloud metadata for a given cluster.
Inputs: cluster (required).
get_cluster_resource_utilisationB
Returns CPU and Memory usage vs capacity across all nodes.
Inputs: cluster.
get_configmapC
Reads data from a ConfigMap.
Inputs: namespace (required), configMapName (required), cluster.
get_effective_permissionsB
Evaluates effective Kubernetes API permissions for a ServiceAccount using SubjectAccessReview checks.
Inputs: namespace (required), serviceAccountName (required), cluster.
get_flux_helm_releaseA
Gets detailed status of a Flux HelmRelease including chart version, values, and condition history.
Inputs: name (required), namespace (required), cluster.
get_gitops_app_statusB
Gets the health and sync status of an ArgoCD Application or Flux Kustomization.
Inputs: engine (required), appName (required), namespace (required), cluster.
get_gitops_diffA
Gets out-of-sync resources (ArgoCD) or managed resource inventory with revision drift (Flux Kustomization).
Inputs: engine (required), appName (required), namespace (required), cluster.
get_hpa_statusB
Retrieves Horizontal Pod Autoscaler metrics and status.
Inputs: hpaName (required), namespace (required), cluster.
get_k8s_resourceA
Generic read: get a single Kubernetes resource by group/version/resource/name.
Inputs: name (required), version (required), resource (required), cluster, +3 more.
get_node_pool_detailB
Returns detailed node, spot/preemptible, and optional metrics view for a specific node pool.
Inputs: poolName (required), cluster.
get_node_pressureB
Analyzes node resource pressure for a specific node.
Inputs: nodeName (required), cluster.
get_pdb_statusB
Returns detailed status and covered pods for a PodDisruptionBudget.
Inputs: pdbName (required), namespace (required), cluster.
get_pod_logsB
Retrieves logs for a specific pod.
Inputs: podName (required), namespace (required), cluster, tailLines, +1 more.
get_resource_recommendationsB
Suggests optimal resource requests/limits based on current metrics heuristically.
Inputs: namespace (required), deploymentName (required), cluster.
get_service_endpointsC
Shows endpoint addresses backing a Service.
Inputs: namespace (required), serviceName (required), cluster.
get_storage_classA
Returns details for a specific StorageClass.
Inputs: storageClassName (required), cluster.
get_vpa_recommendationA
Returns VPA recommendation lower/target/upper bounds for a workload when available.
Inputs: vpaName (required), namespace (required), cluster.
get_workload_identity_configA
Returns workload identity annotation configuration for a ServiceAccount (AKS/EKS/GKE conventions).
Inputs: namespace (required), serviceAccountName (required), cluster.
list_clustersB
Lists all registered Kubernetes clusters managed by KubeNexus.
Inputs: no named parameters.
list_cronjobsB
Lists CronJobs in a specific namespace.
Inputs: namespace (required), cluster.
list_daemonsetsB
Lists DaemonSets in a specific namespace.
Inputs: namespace (required), cluster.
list_eventsC
Lists recent cluster events for a namespace.
Inputs: namespace (required), cluster.
list_flux_alertsB
Lists Flux Notification Alert objects showing which events trigger which providers.
Inputs: cluster, namespace.
list_flux_helm_releasesA
Lists all Flux HelmReleases in a namespace with chart name, version, and ready/suspended status.
Inputs: cluster, namespace.
list_flux_kustomizationsA
Lists all Flux Kustomizations in a namespace with their ready/suspended/revision status.
Inputs: cluster, namespace.
list_flux_sourcesA
Lists Flux source objects (GitRepository, HelmRepository, OCIRepository, Bucket) with their URL, ref, and ready status.
Inputs: cluster, namespace, sourceType.
list_ingressesB
Lists Ingress resources in a namespace.
Inputs: namespace (required), cluster.
list_jobsB
Lists Jobs in a specific namespace.
Inputs: namespace (required), cluster.
list_k8s_resourcesC
Generic read: list Kubernetes resources by group/version/resource.
Inputs: version (required), resource (required), cluster, apiGroup, +3 more.
list_limit_rangesC
Lists LimitRange objects in a namespace and default resource constraints.
Inputs: namespace (required), cluster.
list_node_poolsA
Groups nodes by managed-cloud node pool labels (AKS/EKS/GKE) and reports pool health.
Inputs: cluster.
list_nodesB
Lists cluster nodes.
Inputs: cluster.
list_persistent_volume_claimsB
Lists PersistentVolumeClaims in a specific namespace with binding and capacity details.
Inputs: namespace (required), cluster.
list_pod_disruption_budgetsA
Lists PodDisruptionBudgets in a namespace with budget satisfaction status.
Inputs: namespace (required), cluster.
list_podsB
Lists pods in a specific namespace.
Inputs: namespace (required), cluster.
list_statefulsetsB
Lists StatefulSets in a specific namespace.
Inputs: namespace (required), cluster.
list_storage_classesA
Lists StorageClasses and indicates default class.
Inputs: cluster.
list_vpasA
Lists VerticalPodAutoscaler objects in a namespace and their update mode/recommendation state.
Inputs: namespace (required), cluster.
list_warning_eventsC
Filters cluster events for warnings in a namespace.
Inputs: namespace (required), cluster.
remove_taintB
Removes a specific taint from a node by key.
Inputs: key (required), nodeName (required), dryRun, cluster.
restart_podA
Deletes a pod to force a restart. Usually managed by a deployment/replicaset.
Inputs: podName (required), namespace (required), dryRun, cluster.
resume_cronjobB
Resumes a suspended CronJob.
Inputs: namespace (required), cronJobName (required), dryRun, cluster.
resume_flux_resourceB
Resumes reconciliation of a suspended Flux Kustomization or HelmRelease.
Inputs: name (required), namespace (required), resourceType (required), dryRun, +1 more.
rollout_statusA
Checks deployment rollout status (complete, in-progress, or stalled).
Inputs: namespace (required), deploymentName (required), cluster.
rollout_undoB
Rolls a deployment back to the previous ReplicaSet template.
Inputs: namespace (required), deploymentName (required), dryRun, cluster.
scale_deploymentC
Scales replicas for a deployment.
Inputs: replicas (required), namespace (required), deploymentName (required), dryRun, +1 more.
set_resource_limitsB
Sets CPU and Memory requests and limits for a specific container in a Deployment.
Inputs: namespace (required), containerName (required), deploymentName (required), dryRun, +5 more.
suspend_cronjobB
Suspends an active CronJob.
Inputs: namespace (required), cronJobName (required), dryRun, cluster.
suspend_flux_resourceB
Suspends reconciliation of a Flux Kustomization or HelmRelease to pause automated deployments.
Inputs: name (required), namespace (required), resourceType (required), dryRun, +1 more.
sync_gitops_appA
Forces a sync/reconciliation of an ArgoCD Application, Flux Kustomization, or Flux HelmRelease.
Inputs: engine (required), appName (required), namespace (required), dryRun, +2 more.
taint_nodeB
Adds a taint to a node.
Inputs: key (required), value (required), effect (required), nodeName (required), +2 more.
uncordon_nodeB
Marks a node as schedulable.
Inputs: nodeName (required), dryRun, cluster.
update_configmapB
Updates an existing ConfigMap by patching its data.
Inputs: data (required), namespace (required), configMapName (required), dryRun, +1 more.
update_ingressB
Updates an existing Ingress. Merges new rules or annotations into the existing Ingress.
Inputs: namespace (required), ingressName (required), rules, dryRun, +2 more.
update_secretA
Updates an existing Secret by patching its stringData. KNOWN LIMITATION: The Kubernetes API never returns stringData on read (it is write-only); the API server stores values as base64 in the data field. This means the client-side merge only contains the keys passed in args.stringData — existing keys not included in the request will be silently dropped. If you need to preserve existing keys, read them first via get_secret and re-supply all values.
Inputs: namespace (required), secretName (required), stringData (required), dryRun, +1 more.
validate_workload_identityC
Validates identity chain from ServiceAccount annotation to pods using that ServiceAccount.
Inputs: namespace (required), serviceAccountName (required), cluster.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 75 tools
Each tool targets a distinct resource and action, with detailed descriptions that clearly separate them. Despite the high number, there is no ambiguity between tools like list_pods, get_pod_logs, and describe_pod.
Most tools follow a verb_noun pattern in snake_case (e.g., list_pods, create_deployment). However, there is a mix of 'get_' and 'describe_' for similar operations, and some verbs like 'cordon' and 'drain' are non-standard, causing slight inconsistency.
With 75 tools, the server is extremely overloaded. Even for a comprehensive Kubernetes management server, this number far exceeds the typical well-scoped range (3-15) and qualifies as an extreme mismatch, making it difficult for agents to navigate.
The tool set covers a wide range of Kubernetes resources and GitOps operations, including CRUD for many resources and additional utilities. Minor gaps like missing update_deployment and delete_pod exist, but the overall surface is quite complete for cluster management.
Maintenance
Related MCP Connectors
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Zero-log MCP server with 49 tools for AI guardrails, secret scanning, MCP linting & EU compliance.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
MCP server for building and testing AI agents with multi-model experimentation and insights.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that enables AI assistants to interact with Kubernetes clusters by translating natural language into kubectl and Helm operations. It allows users to query, manage, and diagnose Kubernetes resources and cluster states through a seamless integration.20Apache 2.0
- AlicenseNot gradedqualityDmaintenanceAn MCP server that lets AI assistants safely inspect and operate on Kubernetes clusters through natural conversation.13 PyPIMIT
- AlicenseNot gradedqualityDmaintenanceA lightweight MCP server that enables natural language interaction with Kubernetes clusters, allowing management of pods, deployments, namespaces, and cluster resources through conversational queries or API endpoints.1MIT
- AlicenseCqualityBmaintenanceAn MCP server that provides complete Kubernetes API operations, enabling cluster management, resource CRUD, diagnostics, backup/restore, and multi-cluster configuration via natural language.322MIT