Kubernetes 클러스터에 연결하여 관리할 수 있는 MCP 서버입니다.
https://github.com/user-attachments/assets/f25f8f4e-4d04-479b-9ae0-5dac452dd2ed
지엑스피1
서버가 현재 kubectl 컨텍스트에 자동으로 연결됩니다. 다음 사항을 확인하세요.
kubectl이 설치되었고 PATH에 있습니다.
컨텍스트가 구성된 유효한 kubeconfig 파일
kubectl에 대해 구성된 Kubernetes 클러스터에 대한 액세스(예: minikube, Rancher Desktop, GKE 등)
Helm v3가 설치되어 PATH에 등록되어 있어야 합니다(Tiller는 필요 없습니다). Helm을 사용하지 않을 경우 선택 사항입니다.
Claude에게 포드를 나열하거나 테스트 배포를 생성하도록 요청하여 연결을 확인할 수 있습니다.
오류가 발생하면 표준 터미널을 열고 kubectl get pods 실행하여 자격 증명 문제 없이 클러스터에 연결할 수 있는지 확인하세요.
Related MCP server: MCP Remote Server for Kubernetes
mcp-chat 은 MCP 서버용 CLI 채팅 클라이언트입니다. 쿠버네티스 서버와 상호 작용하는 데 사용할 수 있습니다.
npx mcp-chat --server "npx mcp-server-kubernetes"또는 위에서 언급한 기존 Claude Desktop 구성 파일을 전달하세요(Linux는 config에 대한 올바른 경로를 전달해야 함).
스코틀랜드 사람:
npx mcp-chat --config "~/Library/Application Support/Claude/claude_desktop_config.json"윈도우:
npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"[x] Kubernetes 클러스터에 연결
[x] 모든 포드, 서비스, 배포를 나열합니다.
[x] 목록, 노드 설명
[x] 포드 생성, 설명, 삭제
[x] 모든 네임스페이스 나열, 네임스페이스 생성
[x] 사용자 정의 포드 및 배포 구성 생성, 배포 복제본 업데이트
[x] 서비스 생성, 설명, 삭제, 업데이트
[x] ConfigMap 생성, 가져오기, 업데이트, 삭제
[x] 디버깅을 위해 포드에서 로그 가져오기(포드, 배포, 작업 및 레이블 선택기 지원)
[x] 차트 설치를 위한 Helm v3 지원
사용자 정의 값으로 차트 설치
릴리스 제거
기존 릴리스 업그레이드
네임스페이스 지원
버전 사양 지원
사용자 정의 저장소 지원
[x] kubectl explain 및 kubectl api-resources support
[x] 클러스터에서 Kubernetes 이벤트 가져오기
[x] 포드 또는 서비스로 포트 포워딩
[x] Cronjob을 생성, 나열 및 설명합니다.
[x] 클러스터에 대한 읽기 및 생성/업데이트 전용 액세스를 위한 비파괴 모드
bun이 설치되어 있는지 확인하세요. 저장소를 복제하고 종속성을 설치하세요.
git clone https://github.com/Flux159/mcp-server-kubernetes.git
cd mcp-server-kubernetes
bun install개발 모드로 서버를 시작합니다(파일 변경 사항을 감시합니다):
bun run dev단위 테스트 실행:
bun run test프로젝트를 빌드하세요:
bun run build검사관 과 함께하는 로컬 테스트
npx @modelcontextprotocol/inspector node dist/index.js
# Follow further instructions on terminal for Inspector linkClaude Desktop을 사용한 로컬 테스트
{
"mcpServers": {
"mcp-server-kubernetes": {
"command": "node",
"args": ["/path/to/your/mcp-server-kubernetes/dist/index.js"]
}
}
}mcp-chat을 사용한 로컬 테스트
bun run chat자세한 내용은 CONTRIBUTING.md 파일을 참조하세요.
SSE 전송 사용, ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS 사용한 비파괴 모드와 같은 고급 정보는 ADVANCED_README.md 를 참조하세요.
Devin이 만든 보다 자세한 아키텍처 개요를 보려면 이 DeepWiki 링크를 참조하세요.
이 섹션에서는 MCP Kubernetes 서버의 고수준 아키텍처를 설명합니다.
아래의 시퀀스 다이어그램은 요청이 시스템을 통해 흐르는 방식을 보여줍니다.
sequenceDiagram
participant Client
participant Transport as StdioTransport
participant Server as MCP Server
participant Handler as Request Handler
participant K8sManager as KubernetesManager
participant K8s as Kubernetes API
Client->>Transport: Send Request via STDIO
Transport->>Server: Forward Request
alt Tools Request
Server->>Handler: Route to tools handler
Handler->>K8sManager: Execute tool operation
K8sManager->>K8s: Make API call
K8s-->>K8sManager: Return result
K8sManager-->>Handler: Process response
Handler-->>Server: Return tool result
else Resource Request
Server->>Handler: Route to resource handler
Handler->>K8sManager: Get resource data
K8sManager->>K8s: Query API
K8s-->>K8sManager: Return data
K8sManager-->>Handler: Format response
Handler-->>Server: Return resource data
end
Server-->>Transport: Send Response
Transport-->>Client: Return Final Response릴리스 페이지 로 이동하여 "새 릴리스 초안 작성"을 클릭하고 "태그 선택"을 클릭한 후, "v{major}.{minor}.{patch}" semver 형식으로 새 버전 번호를 입력하여 새 태그를 만드세요. 그런 다음 릴리스 제목을 "Release v{major}.{minor}.{patch}"로 입력하고, 필요한 경우 설명/변경 로그를 입력한 후 "릴리스 게시"를 클릭하세요.
이렇게 하면 cd.yml 워크플로를 통해 새 릴리스 빌드를 트리거하는 새 태그가 생성됩니다. 성공하면 새 릴리스가 npm 에 게시됩니다. package.json 버전을 수동으로 업데이트할 필요는 없습니다. 워크플로가 package.json 파일의 버전 번호를 자동으로 업데이트하고 main에 커밋을 푸시하기 때문입니다.
인증/kubectx에 클러스터 추가.
Get documentation for a Kubernetes resource or field
| Name | Required | Description | Default |
|---|---|---|---|
| output | No | Output format (plaintext or plaintext-openapiv2) | plaintext |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| resource | Yes | Resource name or field path (e.g. 'pods' or 'pods.spec.containers') | |
| recursive | No | Print the fields of fields recursively | |
| apiVersion | No | API version to use (e.g. 'apps/v1') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description's addition of 'Get documentation' is consistent but adds no new behavioral insights. The tool's non-destructive nature is clear, but there is no mention of authorization requirements or data source (e.g., cluster API or bundled docs).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, making it concise and front-loaded. However, it lacks structure and could benefit from a second sentence clarifying the tool's relationship to kubectl explain. The brevity sacrifices nuance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of Kubernetes resources, the absence of context about document format (e.g., plaintext), scope (e.g., cluster API docs), and how it differs from describe/list is a shortcoming. The description is too minimal for the tool's role among 20+ siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter having a description. The tool description repeats 'Kubernetes resource or field', which mirrors the resource parameter's role. It adds no extra meaning beyond what the schema already provides, meeting the baseline expectation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves documentation for a Kubernetes resource or field, which is a specific verb+resource combination. It distinguishes itself from sibling tools like kubectl_get (list/retrieve resources) and kubectl_describe (detailed info on live resources) by focusing on API documentation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use explain_resource versus alternatives such as kubectl_describe or list_api_resources. The description lacks explicit context for tool selection, leaving the agent to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Install a Helm chart with support for both standard and template-based installation
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the Helm release | |
| repo | No | Helm repository URL (optional if using local chart path) | |
| chart | Yes | Chart name (e.g., 'nginx') or path to chart directory | |
| values | No | Custom values to override chart defaults | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| namespace | Yes | Kubernetes namespace | default |
| valuesFile | No | Path to values file (alternative to values object). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'values' to pass the values inline instead. | |
| useTemplate | No | Use helm template + kubectl apply instead of helm install (bypasses auth issues) | |
| createNamespace | No | Create namespace if it doesn't exist |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The destructiveHint annotation already signals potential destructiveness. The description adds mention of two installation modes but does not elaborate on behavioral traits such as error handling, rollback behavior, or prerequisites like Helm being installed. Given the annotation coverage, a score of 3 is appropriate as the description adds some but limited context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no redundancy. It is concise and front-loaded with the core purpose, though it could benefit from a brief expansion on usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex tool with 9 parameters, destructive potential, and no output schema, the description is incomplete. It does not cover return values, error scenarios, prerequisites, or when to choose between installation modes. The schema and annotations provide partial context, but the description should bridge remaining gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The tool description does not add meaningful extra semantics beyond referencing the two installation modes (standard/template), which is already covered in the 'useTemplate' parameter description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool installs a Helm chart and highlights support for standard and template-based installations, which differentiates it from sibling tools like upgrade_helm_chart and kubectl commands.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description lacks explicit guidance on when to use this tool versus alternatives or which installation mode to choose. The parameter schema hints at use cases for the 'useTemplate' flag, but the description itself does not provide decision points.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Apply a Kubernetes YAML manifest from a string or file
| Name | Required | Description | Default |
|---|---|---|---|
| force | No | If true, immediately remove resources from API and bypass graceful deletion | |
| dryRun | No | If true, only validate the resource, don't actually execute the operation | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| filename | No | Path to a YAML file to apply (optional - use either manifest or filename). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead. | |
| manifest | No | YAML manifest to apply | |
| namespace | No | Kubernetes namespace | default |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide destructiveHint=true. Description adds no additional behavioral context beyond the schema's parameter descriptions. No contradiction, but no extra value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single 9-word sentence, front-loaded with verb and resource, zero wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description should explain return values or errors, but does not. However, the tool is a standard kubectl operation; description is adequate but incomplete for a mutation tool with no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. Description only hints at 'string or file' but adds no meaningful semantic detail beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Apply a Kubernetes YAML manifest from a string or file', specifying the action (apply) and resource (YAML manifest). It distinguishes from siblings like kubectl_create, which creates resources differently.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use apply versus siblings like kubectl_create or kubectl_patch. Usage is implied but not differentiated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage Kubernetes contexts - list, get, or set the current context
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | Name of the context to set as current (required for set operation) | |
| output | No | Output format | json |
| detailed | No | Include detailed information about the context | |
| operation | Yes | Operation to perform: list contexts, get current context, or set current context | list |
| showCurrent | No | When listing contexts, highlight which one is currently active |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotation readOnlyHint: true contradicts the description's claim of a 'set' operation, which modifies the current context. This is a serious inconsistency. The description fails to disclose this behavioral trait or any side effects, and it contradicts the available annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the tool's purpose and operations. No words are wasted, and it is appropriately sized for a straightforward tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters, no output schema, and conflicting annotations, the description is too brief. It omits critical details such as what the 'set' operation actually modifies, return values, or prerequisites. The agent lacks sufficient information to use the tool safely and effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all parameters having clear descriptions. The tool description itself adds no extra meaning beyond what the schema provides. Baseline 3 is appropriate as the schema already handles parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool manages Kubernetes contexts and enumerates the three specific operations: list, get, or set the current context. This distinguishes it from sibling tools like kubectl_get or kubectl_apply, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention when to choose list over get, or when using the set operation is appropriate. No exclusions or conditions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create Kubernetes resources using various methods (from file or using subcommands)
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | Name of the resource to create | |
| port | No | Port that the container exposes | |
| image | No | Image to use for the containers in the deployment | |
| dryRun | No | If true, only validate the resource, don't actually execute the operation | |
| labels | No | Labels to apply to the resource (e.g. ["key1=value1", "key2=value2"]) | |
| output | No | Output format. One of: json|yaml|name|go-template|go-template-file|template|templatefile|jsonpath|jsonpath-as-json|jsonpath-file | yaml |
| command | No | Command to run in the container | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| suspend | No | Whether to suspend the CronJob | |
| tcpPort | No | Port pairs for tcp service (e.g. ["80:8080", "443:8443"]) | |
| filename | No | Path to a YAML file to create resources from. The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead. | |
| fromFile | No | Path to file for creating configmap/secret (e.g. ["key1=/path/to/file1", "key2=/path/to/file2"]). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use "fromFileContent" to pass file contents directly instead. | |
| manifest | No | YAML manifest to create resources from | |
| replicas | No | Number of replicas to create for the deployment | |
| schedule | No | Cron schedule expression for the CronJob (e.g. "*/5 * * * *") | |
| validate | No | If true, validate resource schema against server schema | |
| namespace | No | Kubernetes namespace | default |
| secretType | No | Type of secret to create (generic, docker-registry, tls) | |
| annotations | No | Annotations to apply to the resource (e.g. ["key1=value1", "key2=value2"]) | |
| fromLiteral | No | Key-value pair for creating configmap (e.g. ["key1=value1", "key2=value2"]) | |
| serviceType | No | Type of service to create (clusterip, nodeport, loadbalancer, externalname) | |
| resourceType | No | Type of resource to create (namespace, configmap, deployment, service, etc.) | |
| fromFileContent | No | Inline file contents for creating a configmap/secret, provided by the client instead of a server-side path (e.g. [{"key": "app.conf", "content": "..."}]). Safe on all transports; use this instead of "fromFile" on remote (SSE/Streamable HTTP) servers. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states 'Create', implying a mutation, but does not elaborate on idempotency, error behavior, permission requirements, or side effects. The parameter 'dryRun' hints at validation support, but the description itself adds no further behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, which is concise. However, it could be more structured by front-loading the two creation methods and possibly indicating that the tool supports many resource types. It is not verbose but lacks a clear structure that aids quick scanning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (23 parameters, no output schema, no annotations), the description is insufficient. It does not explain how parameters interact, which resource types are supported, or what the return value looks like. The user must rely entirely on the schema, which is unusual for such a versatile tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so every parameter has a description in the schema. The tool description adds minimal value beyond the schema; it only mentions two methods without linking them to specific parameters. The baseline is 3 because the schema already documents all parameters, and the description does not compensate for any gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Create Kubernetes resources using various methods (from file or using subcommands)'. It identifies the tool's function (creating resources) and distinguishes it from siblings like kubectl_apply (which applies updates) and kubectl_patch (which modifies existing resources). The verb 'Create' and resource type 'Kubernetes resources' are specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any guidance on when to use this tool versus alternatives such as kubectl_apply, kubectl_patch, or exec_in_pod. It mentions two methods (file or subcommands) but does not explain which scenarios favor one method over the other. There are no prerequisites, exclusions, or context on when not to use the tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Describe Kubernetes resources by resource type, name, and optionally namespace
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the resource to describe | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| namespace | No | Kubernetes namespace | default |
| resourceType | Yes | Type of resource to describe (e.g., pods, deployments, services, etc.) | |
| allNamespaces | No | If true, describe resources across all namespaces |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint: true, so the agent knows this is a safe read operation. The description adds that it describes resources, which is consistent. It does not mention output format or other behavioral traits, but with the annotation covering the safety profile, a 3 is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 11 words. It conveys the action and essential parameters without any filler, making it extremely concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 5 parameters (2 required) and no output schema. The description covers the core purpose and the most important parameters, but it does not explain the output format or how to use optional parameters. For a read-only describe tool, this is minimally adequate but could be improved by noting that output is detailed resource information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so all parameters are described in the schema. The description summarizes three parameters (resource type, name, namespace) but does not add extra meaning beyond the schema for optional parameters like context or allNamespaces. Baseline 3 is correct when schema covers all parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'describe' and identifies the resource as 'Kubernetes resources'. It clearly lists the key parameters (resource type, name, optionally namespace), making the tool's purpose unambiguous and distinguishing it from sibling tools like kubectl_get or kubectl_logs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by stating 'describe...by resource type, name, and optionally namespace', but it does not explicitly state when to choose this tool over alternatives (e.g., kubectl_get for listing, kubectl_logs for logs) or when not to use it. The context is clear but lacks explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get or list Kubernetes resources by resource type, name, and optionally namespace
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | Name of the resource (optional - if not provided, lists all resources of the specified type) | |
| output | No | Output format | json |
| sortBy | No | Sort events by a field (default: lastTimestamp). Only applicable for events. | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| namespace | No | Kubernetes namespace | default |
| resourceType | Yes | Type of resource to get (e.g., pods, deployments, services, configmaps, events, etc.) | |
| allNamespaces | No | If true, list resources across all namespaces | |
| fieldSelector | No | Filter resources by field selector (e.g. 'metadata.name=my-pod') | |
| labelSelector | No | Filter resources by label selector (e.g. 'app=nginx') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true. The description confirms read behavior (get/list) but adds no further behavioral details (e.g., pagination, rate limits, or side effects). It does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action and key parameters. Every word adds value; no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate for a simple read tool but lacks mention of default values (e.g., namespace default), allNamespaces, and output formats. Since schema covers these, completeness is acceptable but not thorough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%; each parameter has a description. The tool description only mentions three parameters (resourceType, name, namespace) without adding new meaning. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: get or list Kubernetes resources by type, name, and namespace. It uses specific verbs and resource, and the action is distinct from sibling tools like kubectl_describe or kubectl_delete.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like kubectl_describe (for detailed info) or kubectl_logs. With many sibling tools, explicit usage context is lacking.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get logs from Kubernetes resources like pods, deployments, or jobs
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the resource | |
| tail | No | Number of lines to show from end of logs | |
| since | No | Show logs since relative time (e.g. '5s', '2m', '3h') | |
| follow | No | Follow logs output (not recommended, may cause timeouts) | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| previous | No | Include logs from previously terminated containers | |
| container | No | Container name (required when pod has multiple containers) | |
| namespace | Yes | Kubernetes namespace | default |
| sinceTime | No | Show logs since absolute time (RFC3339) | |
| timestamps | No | Include timestamps in logs | |
| resourceType | Yes | Type of resource to get logs from | |
| labelSelector | No | Filter resources by label selector |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations set readOnlyHint=true, and the description's 'get logs' is consistent. However, the description does not elaborate on behavioral traits beyond the annotation, such as potential side effects of the 'follow' parameter or that logs are from stdout/stderr. The description adds minimal value over the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no redundancy. It is appropriately concise for the tool's simplicity. However, it could include key parameter hints without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 12 parameters and no output schema, the description is too sparse. It omits important contextual details such as the need for container when multi-container pods exist, the meaning of labelSelector, and the risk of timeouts with follow. The description fails to fully equip an agent to handle complex log retrieval scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all 12 parameters with descriptions (100% coverage). The description does not add high-level semantics or explain parameter interactions (e.g., mutual exclusivity of since/sinceTime). Baseline is 3 due to full schema coverage, and the description provides no additional benefit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets logs from Kubernetes resources and lists examples (pods, deployments, jobs). The name kubectl_logs is self-explanatory, but the description adds specificity by mentioning resource types. It distinguishes from sibling tools like kubectl_get which retrieve resource definitions, not logs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving logs but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention when not to use it (e.g., for live streaming which may cause timeouts). No exclusions or context for sibling tools are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update field(s) of a resource using strategic merge patch, JSON merge patch, or JSON patch
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the resource to patch | |
| dryRun | No | If true, only validate the resource, don't actually execute the operation | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| namespace | No | Kubernetes namespace | default |
| patchData | No | Patch data as a JSON object | |
| patchFile | No | Path to a file containing the patch data (alternative to patchData). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'patchData' to pass the patch contents instead. | |
| patchType | No | Type of patch to apply | strategic |
| resourceType | Yes | Type of resource to patch (e.g., pods, deployments, services) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide destructiveHint=true. Description adds patch types but no additional behavioral context (e.g., side effects, rollback). Adequate but minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no fluff, efficiently conveys core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 8 parameters and nested objects, the description is too brief. Lacks explanation of patch type differences or return values, though schema covers parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. Description adds no extra parameter meaning beyond what schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool updates fields of a resource using specific patch types, distinguishing it from sibling tools like kubectl_apply or kubectl_create.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives; lacks context on selecting patch type or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Reconnect to the Kubernetes API server by recreating all API clients. Use this after cluster upgrades (e.g., EKS control plane upgrades that rotate ENIs/IPs) to force fresh DNS resolution and new TCP connections.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false, and the description adds behavioral detail: it recreates API clients and forces fresh DNS resolution and TCP connections. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose and usage. No redundancy; every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters and no output schema, the description covers purpose, usage context, and behavioral effects completely and concisely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters (0 params, 100% coverage), so the description need not explain parameters. Baseline 4 for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Reconnect' and the resource 'Kubernetes API server by recreating all API clients'. It distinguishes from siblings by specifying a concrete use case: after cluster upgrades that rotate ENIs/IPs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool ('after cluster upgrades...') and why ('to force fresh DNS resolution and new TCP connections'). It does not mention alternatives, but the guidance is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage the rollout of a resource (e.g., deployment, daemonset, statefulset)
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the resource | |
| watch | No | Watch the rollout status in real-time until completion | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| timeout | No | The length of time to wait before giving up (e.g., '30s', '1m', '2m30s') | |
| revision | No | Revision to rollback to (for undo subcommand) | |
| namespace | Yes | Kubernetes namespace | default |
| subCommand | Yes | Rollout subcommand to execute | status |
| toRevision | No | Revision to roll back to (for history subcommand) | |
| resourceType | Yes | Type of resource to manage rollout for | deployment |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description does not add behavioral context beyond the annotation destructiveHint=true. It does not explain potential impacts (e.g., rollback causing downtime) or required permissions. Since annotations already indicate destructiveness, a score of 3 is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short (one sentence, 7 words), but it is underinformative for a tool with 9 parameters and multiple subcommands. While concise, it sacrifices necessary detail, so a score of 3 is warranted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple subcommands, no output schema), the description is too minimal. It lacks information about return values, when to use each subcommand, and execution behavior, making it incomplete for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters are described in the input schema. The tool description adds no additional meaning beyond what the schema provides, resulting in a baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool manages the rollout of a resource, with examples of resource types (deployment, daemonset, statefulset). This distinguishes it from sibling tools like kubectl_apply or kubectl_scale, which do not handle rollout operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description does not mention specific use cases (e.g., viewing history, pausing, rolling back) nor does it compare with other kubectl tools that may have overlapping functionality.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scale a Kubernetes deployment
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the deployment to scale | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| replicas | Yes | Number of replicas to scale to | |
| namespace | No | Kubernetes namespace | default |
| resourceType | No | Resource type to scale (deployment, replicaset, statefulset) | deployment |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotation 'destructiveHint: true' already indicates state modification. The description adds no further behavioral context, such as that scaling triggers pod creation/termination, or whether the operation is immediate and idempotent. Given the annotation presence, a score of 3 is appropriate as the description does not contradict but adds little value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at one sentence. While it is front-loaded, it may be insufficient for a tool with 5 parameters and potential variations. A slightly longer description with key details would improve usability without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool performs a simple mutation, but the description lacks mention that it can scale resources other than deployments (e.g., replicasets, statefulsets). No output schema exists, but for a scaling operation, the return value is often the updated resource or status; the description could hint at that. Overall, it meets minimum viability but has gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The tool description does not add any meaning beyond the parameter descriptions in the schema. It provides no examples, constraints, or relationships between parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Scale' and resource 'Kubernetes deployment'. However, it omits that the tool can also scale other resource types (replicaset, statefulset) as indicated by the 'resourceType' parameter. Among siblings like kubectl_apply and kubectl_patch, it could be more distinctive.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., kubectl_apply for broader changes). No prerequisites or conditions are mentioned, such as requiring the target resource to exist. The description does not help the agent decide between scaling and other operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List the API resources available in the cluster
| Name | Required | Description | Default |
|---|---|---|---|
| verbs | No | List of verbs to filter by | |
| output | No | Output format (wide, name, or no-headers) | wide |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| apiGroup | No | API group to filter by | |
| namespaced | No | If true, only show namespaced resources |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already indicates a read-only operation. The description adds no additional behavioral context beyond stating the action 'List'. No details on scope, safety, or response characteristics are provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no superfluous words. However, it is overly brief given the complexity of the tool and its parameters, but this is not penalized heavily under conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite 5 parameters and many sibling tools, the description lacks critical context such as what the output looks like (no output schema) and when to use this tool. The description is insufficient for effective tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add any extra meaning beyond what the schema already explains for each parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List the API resources available in the cluster' clearly states the verb and resource, but it does not distinguish this tool from siblings like kubectl_get or explain_resource, which also list API resources. The term 'API resources' is ambiguous; it could mean resource types or instances.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as kubectl_get or kubectl_describe. There is no mention of context, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Verify that the counterpart is still responsive and the connection is alive.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide readOnlyHint: true, indicating safety. The description adds that it verifies responsiveness and connection, which aligns with annotations and provides additional behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that is concise, front-loaded, and contains no unnecessary words. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no output schema), the description is complete enough for an agent to understand its purpose and use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist. Baseline is 4 for zero parameters, and the description doesn't need to add parameter info beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: verifying the counterpart is responsive and the connection is alive. It distinguishes from sibling tools like kubectl_get or exec_in_pod which perform other operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance is given. However, from context it's implied for connectivity checks before other operations, but no alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Forward a local port to a port on a Kubernetes resource
| Name | Required | Description | Default |
|---|---|---|---|
| localPort | Yes | ||
| namespace | No | ||
| targetPort | Yes | ||
| resourceName | Yes | ||
| resourceType | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide no readDestructive hints. The description only states the basic operation without disclosing behavioral traits such as network activity duration, port conflict handling, or cleanup requirements. For a tool that opens a tunnel, more context is needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (one sentence), but it is too terse for a tool with 5 parameters. It would benefit from additional structure without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (forwarding ports, multiple parameters, no output schema), the description is incomplete. It does not mention supported resource types, error cases, how to stop the forward, or relationship to sibling tool 'stop_port_forward'. The agent lacks sufficient context for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%. The description does not explain any parameters. Parameter names (resourceType, resourceName, etc.) are self-explanatory but lack syntax, constraints, or examples. The description should add meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action and resource: 'Forward a local port to a port on a Kubernetes resource'. It uses a specific verb and resource, distinguishing it from sibling tools like 'stop_port_forward' and other kubectl operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., exec_in_pod, kubectl_logs). No prerequisites, exclusions, or context for when port forwarding is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Stop a port-forward process
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations beyond title; the description does not disclose behavioral traits such as side effects (e.g., terminating network connections), permissions needed, or whether the operation is reversible.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short (one sentence) but it is underspecified. It lacks sufficient content to be useful, crossing from conciseness into incompleteness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, no parameter explanations, and minimal description, the tool definition is inadequate for an agent to correctly select and invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'id' has no description in the schema, and the tool description adds no meaning. With 0% schema description coverage, the description fails to clarify what 'id' represents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Stop a port-forward process' is a specific verb+resource, but it's vague and doesn't clarify what 'a port-forward process' refers to. It distinguishes from the sibling 'port_forward' but lacks detail.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'port_forward' or when it's appropriate. The description provides no context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upgrade an existing Helm chart release
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Name of the Helm release to upgrade | |
| repo | No | Helm repository URL (optional if using local chart path) | |
| chart | Yes | Chart name or path to chart directory | |
| values | No | Custom values to override chart defaults | |
| context | No | Kubeconfig Context to use for the command (optional - defaults to null) | |
| namespace | Yes | Kubernetes namespace | default |
| valuesFile | No | Path to values file (alternative to values object). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'values' to pass the values inline instead. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as destructive (destructiveHint=true). The description adds no additional behavioral context, such as authorization needs, side effects, or rollback behavior, which would be valuable for an upgrade operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, which is concise but lacks sufficient detail. It could be expanded slightly without sacrificing conciseness, e.g., by mentioning that the release must already exist.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema is present, and the description does not explain return values, error handling, or the upgrade process. For a tool with 7 parameters and a nested object, this is incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema coverage, the input schema already describes all parameters. The description does not add extra meaning beyond the schema, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('upgrade') and resource ('existing Helm chart release'), clearly indicating what the tool does. However, it does not distinguish itself from the sibling tool 'install_helm_chart' for new installations, which would be a minor improvement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the release must exist ('existing') but provides no explicit guidance on when to use this tool versus alternatives like 'install_helm_chart'. No prerequisites or when-not-to-use advice is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v4.1.9exec_in_podv4.1.1kubectl_patch1 field changedInput schema / properties / patchFile / descriptionPrevious value: -"Path to a file containing the patch data (alternative to patchData)"New value: +"Path to a file containing the patch data (alternative to patchData). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'patchData' to pass the patch contents instead."v4.1.0install_helm_chart1 field changedInput schema / properties / valuesFile / descriptionPrevious value: -"Path to values file (alternative to values object)"New value: +"Path to values file (alternative to values object). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'values' to pass the values inline instead."kubectl_apply1 field changedInput schema / properties / filename / descriptionPrevious value: -"Path to a YAML file to apply (optional - use either manifest or filename)"New value: +"Path to a YAML file to apply (optional - use either manifest or filename). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead."upgrade_helm_chart1 field changedInput schema / properties / valuesFile / descriptionPrevious value: -"Path to values file (alternative to values object)"New value: +"Path to values file (alternative to values object). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'values' to pass the values inline instead."v4.0.2kubectl_create3 fields changedInput schema / properties / filename / descriptionPrevious value: -"Path to a YAML file to create resources from"New value: +"Path to a YAML file to create resources from. The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use 'manifest' to pass the file's contents instead."Input schema / properties / fromFile / descriptionPrevious value: -"Path to file for creating configmap (e.g. [\"key1=/path/to/file1\", \"key2=/path/to/file2\"])"New value: +"Path to file for creating configmap/secret (e.g. [\"key1=/path/to/file1\", \"key2=/path/to/file2\"]). The path is read on the machine running the MCP server, so it is rejected when the server runs over a remote (SSE/Streamable HTTP) transport; use \"fromFileContent\" to pass file contents directly instead."Input schema / properties / fromFileContentAdded value: +{
+ "description": "Inline file contents for creating a configmap/secret, provided by the client instead of a server-side path (e.g. [{\"key\": \"app.conf\", \"content\": \"...\"}]). Safe on all transports; use this instead of \"fromFile\" on remote (SSE/Streamable HTTP) servers.",
+ "items": {
+ "additionalProperties": false,
+ "properties": {
+ "content": {
+ "description": "The file content to store",
+ "type": "string"
+ },
+ "key": {
+ "description": "Key to store the content under in the configmap/secret",
+ "type": "string"
+ }
+ },
+ "required": [
+ "key",
+ "content"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+}v3.5.1kubectl_get1 field changedInput schema / requiredPrevious value: -[
- "resourceType",
- "name",
- "namespace"
-]New value: +[
+ "resourceType"
+]kubectl_reconnectv1.0.0exec_in_podexplain_resourceinstall_helm_chartkubectl_applykubectl_contextkubectl_createkubectl_describekubectl_getkubectl_logskubectl_patchkubectl_rolloutkubectl_scalelist_api_resourcespingport_forwardstop_port_forwardupgrade_helm_chartScored across 17 tools
Most tools are clearly differentiated by resource and action, but kubectl_create and kubectl_apply overlap because both can create resources. kubectl_patch, kubectl_scale, and kubectl_rollout also all mutate resources, though their scopes are distinct enough for an agent to choose correctly.
All names use snake_case, which is readable, but prefixing is inconsistent: many tools use kubectl_* while others use bare verbs or nouns like ping, port_forward, and install_helm_chart. There is no single predictable verb_noun pattern across the entire set.
17 tools is slightly above the typical 3-15 range, but Kubernetes is a broad domain and each tool covers a distinct operation or resource. The count is justifiable, though it borders on heavy for a single MCP server.
The surface covers read, create, update, logs, rollout, Helm, and port-forward operations, but lacks a delete operation, which is a core lifecycle gap. Other missing operations like exec or cp exist, but the absence of delete is the most notable incompleteness.
Deploy and operate Kubernetes: clusters, stacks, apps, logs, metrics and security, with OAuth.
A TypeScript MCP server for Home Assistant, enabling programmatic management of entities, automati…
Manage Kubernetes clusters, deployments, databases, secrets and observability on Mengi Cloud.
Deploy containers on Kubernetes with x402 billing. 9 workload types and source builds.
