Skip to main content
Glama

K8sCortex — Kubernetes MCP Server

CI npm version License: MIT

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.

Claude Code, signed in as a developer, finds that checkout 1.5.0 in prod cannot reach its database and is denied the rollback; a release manager is blocked by the prod policy; an SRE previews the rollback, applies it and confirms 2/2 healthy

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 cluster parameter; writes require an explicit cluster when several are registered

  • Any 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=k8scortex

Plain 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:latest

Run 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-library and the jose dependency of jwks-rsa need it)

  • A Kubernetes cluster (minikube, kind, GKE, EKS, AKS or OpenShift)

  • kubectl configured 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 dev

Connect with MCP Inspector

npx @modelcontextprotocol/inspector sse http://localhost:3001/mcp

Connect 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

CLUSTERS_CONFIG=/path/clusters.json

Set

Clusters listed in the file, across any providers

Azure Key Vault

AZURE_KEYVAULT_URI set

The Key Vault cluster index

kubeconfig

Otherwise (or USE_LOCAL_KUBECONFIG=true)

Every context in KUBECONFIG / ~/.kube/config, or the in-cluster service account

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

kubeconfig

Whatever the context uses, including exec plugins (aws eks get-token, gke-gcloud-auth-plugin, kubelogin)

context, kubeconfigPath

eks

Default AWS chain (IRSA, EKS Pod Identity, instance profile, env, SSO), optionally assuming roleArn; tokens are presigned STS URLs refreshed every 14 minutes

region, eksClusterName, roleArn

gke

Application Default Credentials (GKE Workload Identity, service account, gcloud auth application-default login)

project, location, gkeClusterName, usePrivateEndpoint

azure-keyvault

Managed identity; base64 kubeconfig in secret kubeconfig-<name> (or secretName)

keyVaultUri, secretName

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:

  • minRole raises the role required on matching clusters (appliesTo: "mutating" limits it to write tools)

  • denyTools disables 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

OIDC_ISSUER

Issuer URL(s), comma-separated; JWKS is discovered from /.well-known/openid-configuration

OIDC_AUDIENCE

Expected audience(s), comma-separated

OIDC_JWKS_URI

Optional JWKS URL override

OIDC_ROLES_CLAIM

Claim holding roles/groups (default roles; e.g. groups, cognito:groups, realm_access.roles)

OIDC_ROLE_MAP

JSON map from IdP group names to K8sCortex roles, e.g. {"k8s-admins":"platform-engineer"}

ENTRA_TENANT_ID / ENTRA_CLIENT_ID

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

List pods with status and IP

Workload

get_pod_logs

Fetch container logs

Workload

describe_deployment

Full deployment spec

Workload

list_statefulsets

List StatefulSets with rollout status

Workload

describe_statefulset

Detailed StatefulSet spec/status

Workload

list_daemonsets

List DaemonSets with scheduling status

Workload

describe_daemonset

Detailed DaemonSet spec/status

Workload

list_nodes

Cluster nodes with Ready status

Deploy

scale_deployment

Scale replicas (dry-run default)

Deploy

restart_pod

Delete pod to trigger restart

Config

get_configmap

Read ConfigMap data

Config

describe_namespace_quota

Resource quota usage

Config

list_events

Recent namespace events

Config

list_persistent_volume_claims

PVC status, bound volume, storage class, capacity

Config

get_effective_permissions

ServiceAccount SubjectAccessReview matrix

Generic Read

list_k8s_resources

Generic list for arbitrary resource kinds

Generic Read

get_k8s_resource

Generic get for arbitrary resource kinds

Observe

get_hpa_status

HPA metrics and scaling

Observe

list_warning_events

Warning events for triage

Observe

get_node_pressure

Node memory/disk/PID pressure

Multi

list_clusters

All registered clusters

Multi

get_cluster_info

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 / local

Security

  • 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 policies

  • Audit: 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 objectives

Testing

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

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

MIT

Available Tools

75 tools
compare_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

    B3.2/5.0

    Scored across 75 tools

    Disambiguation5/5

    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.

    Naming Consistency4/5

    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.

    Tool Count1/5

    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.

    Completeness4/5

    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

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      An 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.
      20
      Apache 2.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      A 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.
      1
      MIT
    • A
      license
      C
      quality
      B
      maintenance
      An MCP server that provides complete Kubernetes API operations, enabling cluster management, resource CRUD, diagnostics, backup/restore, and multi-cluster configuration via natural language.
      32
      2
      MIT