MCP Helm Server

by zekker6

26 stars

370 downloads

Not rated

GitHub

About

The MCP Helm Server is a Model Context Protocol server that provides tools for AI assistants to query Helm repositories and charts without requiring a local Helm installation. Its purpose is to avoid LLMs making up the format of values.yaml and chart contents, offering a…

Details

Author: zekker6
GitHub stars: 26
Downloads: 370
Categories: Developer Tools, Other, Infrastructure

- List all charts in a Helm repository (list_repository_charts)
- List all available versions for a chart (list_chart_versions)
- Get the latest version of a chart (get_latest_version_of_chart)
- Retrieve a chart’s values file (get_chart_values)
- Retrieve full chart contents including templates and metadata (get_chart_contents)
- Extract chart dependencies from Chart.yaml (get_chart_dependencies)
- Extract container images used in a chart (get_chart_images)
- Supports both HTTP Helm repositories and OCI registries

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name MCP Helm Server

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

From the repository

Install it via Docker, a pre-built binary from the releases page, Mise, go install, or building from source. Then configure your MCP client to connect using the server’s SSE mode (e.g., -mode=sse) or Streamable HTTP mode. Authentication credentials for private repositories can be passed with command-line flags like -username, -password-file, and -registry-credentials.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "mcp helm server": {
            "mcp-helm": {
                "command": "docker",
                "args": [
                    "run",
                    "-d",
                    "--name",
                    "mcp-helm",
                    "-p",
                    "8012:8012",
                    "ghcr.io/zekker6/mcp-helm:v1.3.0",
                    "-mode=sse"
                ]
            }
        }
    }
}

McpServers

{
    "mcp-helm": {
        "command": "docker",
        "args": [
            "run",
            "-d",
            "--name",
            "mcp-helm",
            "-p",
            "8012:8012",
            "ghcr.io/zekker6/mcp-helm:v1.3.0",
            "-mode=sse"
        ]
    }
}

MCP Helm Server

An MCP (Model Context Protocol) server that provides tools for interacting with Helm repositories and charts. This
server enables AI assistants to query Helm repositories, retrieve chart information, and access chart values without
requiring local Helm installation.

The purpose of using MCP for Helm is to avoid making up format of values.yaml and contents of the charts when working
with LLMs.
Instead, the server provides a standardized way to access this information, making it easier for AI assistants to
interact with Helm charts and repositories.

This MCP server is and will be providing tools for working with Helm repositories only. If you need to work with other
Kubernetes resources, consider using a separate MCP server that provides tools for Kubernetes resources.

Features

The MCP Helm server provides the following tools:

- list_repository_charts - Lists all charts available in a Helm repository (or chart name for OCI registries)
- list_chart_versions - Lists all available versions/tags for a chart
- get_latest_version_of_chart - Retrieves the latest version of a specific chart
- get_chart_values - Retrieves the values file for a chart (latest version or specific version)
- get_chart_contents - Retrieves the contents of a chart (including templates, values, and metadata)
- get_chart_dependencies - Retrieves the dependencies of a chart as defined in its Chart.yaml file
- get_chart_images - Extracts container images used in a Helm chart by rendering templates and parsing Kubernetes
manifests

Repository Types

All tools support both traditional HTTP Helm repositories and OCI registries:

| Repository Type | Example URL |
|------------------|------------------------------------|
| HTTP Repository | https://charts.example.com |
| OCI Registry | oci://ghcr.io/org/charts/mychart |
| OCI (Docker Hub) | oci://docker.io/library/mysql |

OCI Registry Support

OCI (Open Container Initiative) registries store Helm charts as OCI artifacts. Unlike HTTP repositories where multiple
charts share an index, OCI registries typically contain one chart per repository with multiple version tags.

Example usage with OCI:

repository_url: oci://ghcr.io/nginxinc/charts/nginx-ingress
chart_name: (empty - chart name is in the URL)

Try without installation

There is a publicly available instance of the MCP Helm server that you can use to test the features without installing
it: https://mcp-helm.zekker.dev/mcp

Installation

Run with docker

You can run the MCP Helm server using Docker. This is the easiest way to get started without needing to install Go or
build from source.

docker run -d --name mcp-helm -p 8012:8012 ghcr.io/zekker6/mcp-helm:v1.3.0 -mode=sse

Note that the --mode=sse flag is used to enable Server-Sent Events mode, which used by MCP clients to connect.
Alternatively, you can use -mode=http to enable Streamable HTTP mode.

Via pre-build binary

Download binary from the releases page.

Example for Linux x86_64 (note that other architectures and platforms are also available):

latest=$(curl -s https://api.github.com/repos/zekker6/mcp-helm/releases/latest | grep 'tag_name' | cut -d\" -f4)
wget https://github.com/zekker6/mcp-helm/releases/download/$latest/mcp-helm_Linux_x86_64.tar.gz
tar axvf mcp-helm_Linux_x86_64.tar.gz

Via Mise

Mise (mise-en-place) is a development environment setup tool.

mise i ubi:zekker6/mcp-helm@latest

Install with Go

> Note: Go 1.24.3 is required.

go install github.com/zekker6/mcp-helm/cmd/mcp-helm@latest

Build from Source

> Note: Go 1.24.3 is required.

1. Clone the repository:

   git clone https://github.com/zekker6/mcp-helm.git

   cd mcp-helm

2. Build the binary:

   go build -o mcp-helm ./cmd/mcp-helm

3. Run the server:

   ./mcp-helm

Configuration

Configure your MCP client to connect to this server. The server implements the standard MCP protocol for tool discovery
and execution.

Authentication

The server supports authentication for both OCI registries and HTTP Helm repositories.

Command-Line Flags

| Flag | Description |
|-----------------------------|-----------------------------------------------------------------------|
| -username | Username for basic authentication (HTTP repos, and OCI registries not covered by -registry-credentials) |
| -password-file | Path to file containing password |
| -registry-credentials | Path to Docker-style credentials file (e.g., ~/.docker/config.json); authoritative for the OCI registries it lists |
| -registry-plain-http | Use plain HTTP for OCI registries (insecure, for development only) |
| -tls-cert | Path to TLS client certificate file for HTTP repositories |
| -tls-key | Path to TLS client key file for HTTP repositories |
| -tls-ca | Path to CA certificate file for verifying server certificates |
| -tls-insecure-skip-verify | Skip TLS certificate verification (insecure) |
| -pass-credentials-all | Pass credentials to all domains when following redirects |

Basic Authentication

For repositories requiring username/password authentication:

```bash

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

MCP Helm Server

Features

Repository Types

OCI Registry Support

Try without installation

Installation

Run with docker

Via pre-build binary

Via Mise

Install with Go

Build from Source

Configuration

Authentication

Command-Line Flags

Basic Authentication

Install

More like this

Sequential Thinking

Sentry

Github

Filesystem

EverArt

Google Drive