Kubernetes クラスターに接続して管理できる MCP サーバー。
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 にポッドの一覧を表示するかテスト デプロイメントを作成するように依頼することで、接続を確認できます。
エラーが発生した場合は、標準ターミナルを開いて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 は正しいパスを 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 のサポート
[x] クラスターからKubernetesイベントを取得する
[x] ポッドまたはサービスへのポート転送
[x] cronジョブの作成、一覧表示、および説明
[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 buildInspectorを使用したローカルテスト
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}」形式）を入力して新しいタグを作成します。次に、リリースタイトル「Release v{major}.{minor}.{patch}」と、必要に応じて説明/変更履歴を記入し、「リリースを公開」をクリックします。
これにより、cd.yml ワークフローを介して新しいリリースビルドをトリガーする新しいタグが作成されます。成功すると、新しいリリースがnpmに公開されます。ワークフローによって package.json ファイルのバージョン番号が自動的に更新され、main にコミットがプッシュされるため、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.
