MCP 服务器可以连接到 Kubernetes 集群并对其进行管理。
https://github.com/user-attachments/assets/f25f8f4e-4d04-479b-9ae0-5dac452dd2ed
{
"mcpServers": {
"kubernetes": {
"command": "npx",
"args": ["mcp-server-kubernetes"]
}
}
}服务器将自动连接到您当前的 kubectl 上下文。请确保您已：
kubectl 已安装并位于您的 PATH 中
已配置上下文的有效 kubeconfig 文件
访问为 kubectl 配置的 Kubernetes 集群（例如 minikube、Rancher Desktop、GKE 等）
已安装 Helm v3 并将其添加到您的 PATH 中（无需 Tiller）。如果您不打算使用 Helm，则此步骤可选。
您可以通过要求 Claude 列出您的 pod 或创建测试部署来验证您的连接。
如果出现错误，请打开标准终端并运行kubectl get pods以查看是否可以连接到集群而没有凭据问题。
Related MCP server: MCP Remote Server for Kubernetes
mcp-chat是 MCP 服务器的 CLI 聊天客户端。您可以使用它与 Kubernetes 服务器进行交互。
npx mcp-chat --server "npx mcp-server-kubernetes"或者，将您现有的 Claude Desktop 配置文件从上面传递给它（Linux 应该将正确的路径传递给配置）：
苹果：
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] 列出所有 pod、服务、部署
[x] 列出、描述节点
[x] 创建、描述、删除 Pod
[x] 列出所有命名空间，创建命名空间
[x] 创建自定义 pod 和部署配置，更新部署副本
[x] 创建、描述、删除、更新服务
[x] 创建、获取、更新、删除 ConfigMap
[x] 从 pod 获取日志以进行调试（支持 pod、部署、作业和标签选择器）
[x] 支持 Helm v3 安装图表
安装具有自定义值的图表
卸载版本
升级现有版本
支持命名空间
支持版本规范
支持自定义存储库
[x] kubectl explain 和 kubectl api-resources 支持
[x] 从集群获取 Kubernetes 事件
[x] 端口转发到 Pod 或服务
[x] 创建、列出和描述 cronjobs
[x] 用于读取和仅创建/更新集群访问的非破坏性模式
确保已安装 bun 。克隆 repo 并安装依赖项：
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使用Inspector进行本地测试
npx @modelcontextprotocol/inspector node dist/index.js
# Follow further instructions on terminal for Inspector link使用 Claude 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 。
请参阅此DeepWiki 链接，了解 Devin 创建的更深入的架构概述。
本节介绍 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}”语义版本格式输入新版本号，创建一个新标签。然后，输入发布标题“Release v{major}.{minor}.{patch}”，并根据需要添加描述/更新日志，然后点击“发布版本”。
这将创建一个新标签，并通过 cd.yml 工作流触发新的版本构建。成功后，新版本将发布到npm 。请注意，无需手动更新 package.json 版本，因为工作流会自动更新 package.json 文件中的版本号并将提交推送到主分支。
身份验证/向 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.
