Helm MCP

Servidor MCP para trabalhar com charts Helm

Documentação

Servidor MCP Helm

Um servidor MCP (Model Context Protocol) que fornece ferramentas para interagir com repositórios e charts do Helm. Este servidor permite que assistentes de IA consultem repositórios Helm, obtenham informações de charts e acessem os valores dos charts sem exigir instalação local do Helm.

O objetivo de usar MCP para Helm é evitar inventar o formato de values.yaml e o conteúdo dos charts ao trabalhar com LLMs. Em vez disso, o servidor fornece uma maneira padronizada de acessar essas informações, facilitando a interação de assistentes de IA com charts e repositórios Helm.

Este servidor MCP fornece e continuará fornecendo ferramentas para trabalhar apenas com repositórios Helm. Se você precisar trabalhar com outros recursos do Kubernetes, considere usar um servidor MCP separado que forneça ferramentas para recursos do Kubernetes.

Recursos

O servidor MCP Helm fornece as seguintes ferramentas:

list_repository_charts - Lista todos os charts disponíveis em um repositório Helm (ou nome do chart para registros OCI)
list_chart_versions - Lista todas as versões/tags disponíveis para um chart
get_latest_version_of_chart - Obtém a versão mais recente de um chart específico
get_chart_values - Obtém o arquivo de valores de um chart (versão mais recente ou versão específica)
get_chart_contents - Obtém o conteúdo de um chart (incluindo templates, valores e metadados)
get_chart_dependencies - Obtém as dependências de um chart conforme definido em seu arquivo Chart.yaml
get_chart_images - Extrai imagens de contêiner usadas em um chart Helm renderizando templates e analisando manifestos do Kubernetes

Tipos de Repositório

Todas as ferramentas suportam tanto repositórios Helm HTTP tradicionais quanto registros OCI:

Tipo de Repositório	URL de Exemplo
Repositório HTTP	`https://charts.example.com`
Registro OCI	`oci://ghcr.io/org/charts/mychart`
OCI (Docker Hub)	`oci://docker.io/library/mysql`

Suporte a Registros OCI

Registros OCI (Open Container Initiative) armazenam charts Helm como artefatos OCI. Diferentemente dos repositórios HTTP, onde vários charts compartilham um índice, os registros OCI normalmente contêm um chart por repositório com várias tags de versão.

Exemplo de uso com OCI:

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

Experimente sem instalação

Há uma instância publicamente disponível do servidor MCP Helm que você pode usar para testar os recursos sem instalá-la: https://mcp-helm.zekker.dev/mcp

Instalação

Executar com Docker

Você pode executar o servidor MCP Helm usando Docker. Esta é a maneira mais fácil de começar sem precisar instalar Go ou compilar a partir do código-fonte.

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

Observe que a flag --mode=sse é usada para habilitar o modo Server-Sent Events, que é usado pelos clientes MCP para conectar-se. Alternativamente, você pode usar -mode=http para habilitar o modo Streamable HTTP.

Via binário pré-compilado

Baixe o binário da página de releases.

Exemplo para Linux x86_64 (observe que outras arquiteturas e plataformas também estão disponíveis):

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) é uma ferramenta de configuração de ambiente de desenvolvimento.

mise i ubi:zekker6/mcp-helm@latest

Instalar com Go

Nota: Go 1.24.3 é necessário.

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

Compilar a partir do código-fonte

Nota: Go 1.24.3 é necessário.

Clone o repositório:

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

Compile o binário:
```
go build -o mcp-helm ./cmd/mcp-helm
```
Execute o servidor:
```
./mcp-helm
```

Configuração

Configure seu cliente MCP para conectar-se a este servidor. O servidor implementa o protocolo MCP padrão para descoberta e execução de ferramentas.

Autenticação

O servidor suporta autenticação tanto para registros OCI quanto para repositórios Helm HTTP.

Flags de Linha de Comando

Flag	Descrição
`-username`	Nome de usuário para autenticação básica (repositórios HTTP e registros OCI não cobertos por `-registry-credentials`)
`-password-file`	Caminho para o arquivo que contém a senha
`-registry-credentials`	Caminho para o arquivo de credenciais no estilo Docker (por exemplo, `~/.docker/config.json`); é autoritativo para os registros OCI que lista
`-registry-plain-http`	Usar HTTP simples para registros OCI (inseguro, apenas para desenvolvimento)
`-tls-cert`	Caminho para o arquivo de certificado TLS do cliente para repositórios HTTP
`-tls-key`	Caminho para o arquivo de chave TLS do cliente para repositórios HTTP
`-tls-ca`	Caminho para o arquivo de certificado CA para verificação de certificados do servidor
`-tls-insecure-skip-verify`	Ignorar verificação de certificado TLS (inseguro)
`-pass-credentials-all`	Enviar credenciais para todos os domínios ao seguir redirecionamentos

Autenticação Básica

Para repositórios que exigem autenticação com nome de usuário/senha:

# Create a password file (recommended for security)
echo "your-password" > /path/to/password.txt
chmod 600 /path/to/password.txt

# Run with basic auth
./mcp-helm -username myuser -password-file /path/to/password.txt

Autenticação de Registro OCI

Para registros OCI privados, a autenticação pode ser configurada por meio de:

Credenciais Docker - O servidor usa automaticamente as credenciais de ~/.docker/config.json
Arquivo de credenciais explícito - Use a flag -registry-credentials

# Using Docker login (credentials stored in ~/.docker/config.json)
docker login ghcr.io
echo $GITHUB_TOKEN | docker login ghcr.io -u USERNAME --password-stdin

# Using explicit credentials file
./mcp-helm -registry-credentials /path/to/docker/config.json

# Using basic auth for OCI registry
./mcp-helm -username myuser -password-file /path/to/password.txt

Combinando autenticação básica com um arquivo de credenciais de registro

Uma única instância pode atender repositórios HTTP privados e registros OCI privados ao mesmo tempo. Quando tanto -username/-password-file quanto -registry-credentials estão definidos, as solicitações OCI são roteadas por host de registro:

Se o arquivo de credenciais resolver uma credencial para o host do registro do chart, essa credencial por host é usada (auths, credHelpers e credsStore são todos consultados, usando a mesma resolução de credenciais Docker do CLI Helm, de modo que a chave canônica https://index.docker.io/v1/ do Docker Hub seja correspondida corretamente).
Caso contrário, a autenticação básica estática -username/-password-file é usada.

Isso permite que -registry-credentials continue sendo autoritativo para os registros OCI que cobre, enquanto a autenticação básica ainda se aplica a repositórios HTTP (e a qualquer registro OCI que o arquivo de credenciais não resolver).

# HTTP repos use basic auth; OCI hosts in config.json use their per-host creds
./mcp-helm \
  -username myuser -password-file /path/to/password.txt \
  -registry-credentials /path/to/docker/config.json

Credenciais por trás de um armazenamento de credenciais externo (credsStore) ou auxiliar por registro (credHelpers) são resolvidas invocando esse binário auxiliar em tempo de execução. Se o auxiliar não estiver disponível no ambiente de execução, os registros afetados voltam para autenticação básica; um aviso é registrado na inicialização para que isso fique visível. O roteamento considera apenas o arquivo passado para -registry-credentials (sem fallback implícito para ~/.docker/config.json), portanto, liste cada registro OCI privado necessário nesse arquivo.

Configuração TLS/mTLS

Para repositórios com requisitos TLS personalizados:

# Custom CA certificate (for self-signed or internal CAs)
./mcp-helm -tls-ca /path/to/ca.crt

# Client certificate authentication (mTLS)
./mcp-helm -tls-cert /path/to/client.crt -tls-key /path/to/client.key

# Combined: mTLS with custom CA
./mcp-helm -tls-cert client.crt -tls-key client.key -tls-ca ca.crt

# Skip TLS verification (development only, not recommended for production)
./mcp-helm -tls-insecure-skip-verify

Configuração Docker

Exemplo com Docker, fornecendo autenticação:

# With basic auth
docker run -d --name mcp-helm -p 8012:8012 \
  -v /path/to/password.txt:/secrets/password.txt:ro \
  ghcr.io/zekker6/mcp-helm:v1.3.0 \
  -mode=sse -username myuser -password-file /secrets/password.txt

# With Docker credentials
docker run -d --name mcp-helm -p 8012:8012 \
  -v ~/.docker/config.json:/root/.docker/config.json:ro \
  ghcr.io/zekker6/mcp-helm:v1.3.0 \
  -mode=sse