VictoriaMetrics MCP Server

Acesse as APIs do VictoriaMetrics para monitoramento, observabilidade e depuração.

GitHub
235
Experimente este MCPPatrocinado

Documentação

vm-community-icon VictoriaMetrics MCP Server

Latest Release Trust Score License Slack X Reddit

A implementação do servidor Model Context Protocol (MCP) para VictoriaMetrics.

Isso fornece acesso à sua instância VictoriaMetrics e integração perfeita com as APIs do VictoriaMetrics e documentação. Pode oferecer uma interface abrangente para tarefas de monitoramento, observabilidade e depuração relacionadas às suas instâncias VictoriaMetrics, permitindo automação avançada e capacidades de interação para engenheiros e ferramentas.

Recursos

Este servidor MCP permite usar quase todas as APIs somente leitura do VictoriaMetrics, ou seja, todas as funções disponíveis no VMUI:

  • Consultar métricas e explorar dados (até mesmo desenhar gráficos se o seu cliente suportar)
  • Listar e exportar métricas disponíveis, labels, valores de labels e séries inteiras
  • Analisar e testar suas regras de alerta e gravação e alertas
  • Exibir parâmetros da sua instância VictoriaMetrics
  • Explorar a cardinalidade dos seus dados e estatísticas de uso de métricas
  • Analisar, rastrear, embelezar e explicar suas consultas
  • Depurar suas regras de relabeling, downsampling e configurações de política de retenção
  • Integração com VictoriaMetrics Cloud
  • Interface com instruções de configuração e inspeção de ferramentas no endpoint raiz (somente no modo Streamable HTTP)

Além disso, o servidor MCP contém documentação atualizada incorporada e é capaz de pesquisá-la sem acesso online.

image

Mais detalhes sobre as ferramentas e prompts exatos disponíveis podem ser encontrados na seção Uso.

Você pode combinar a funcionalidade das ferramentas, pesquisa de documentação em seus prompts e inventar ótimos cenários de uso para sua instância VictoriaMetrics. Basta verificar a seção Exemplo de diálogo para ver como isso pode funcionar. E observe que a qualidade do servidor MCP e suas respostas depende muito das capacidades do seu cliente e da qualidade do modelo que você está usando.

Você também pode combinar o servidor MCP com outros servidores MCP relacionados a observabilidade ou pesquisa de documentação e obter resultados ainda mais poderosos.

Experimente sem instalação

Existe uma instância publicamente disponível do VictoriaMetrics MCP Server que você pode usar para testar os recursos sem instalá-lo:

https://play-mcp.victoriametrics.com/mcp

Atenção! Esta URL não deve ser aberta em um navegador, ela é destinada ao uso em clientes MCP.

Está disponível no modo Streamable HTTP e configurado para funcionar com o Public VictoriaMetrics Playground.

Aqui está um exemplo de configuração para Claude Desktop:

image

Requisitos

Instalação

Binários

Basta baixar a versão mais recente da página Releases e colocá-la no seu PATH.

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/VictoriaMetrics/mcp-victoriametrics/releases/latest | grep 'tag_name' | cut -d\" -f4)
wget https://github.com/VictoriaMetrics/mcp-victoriametrics/releases/download/$latest/mcp-victoriametrics_Linux_x86_64.tar.gz
tar axvf mcp-victoriametrics_Linux_x86_64.tar.gz

Docker

Você pode executar o VictoriaMetrics MCP Server 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-victoriametrics \
  -e VM_INSTANCE_ENTRYPOINT=https://play.victoriametrics.com \
  -e VM_INSTANCE_TYPE=cluster \
  -e MCP_SERVER_MODE=sse \
  -e MCP_LISTEN_ADDR=:8080 \
  -p 8080:8080 \
  ghcr.io/victoriametrics/mcp-victoriametrics

Você deve substituir as variáveis de ambiente pelos seus próprios parâmetros.

Observe que o flag MCP_SERVER_MODE=http é usado para habilitar o modo Streamable HTTP. Mais detalhes sobre os modos de servidor podem ser encontrados na seção Configuração.

Veja as imagens docker disponíveis no registro do github.

Consulte também a seção Usando Docker em vez de binário para mais detalhes sobre o uso do Docker com o servidor MCP com clientes no modo stdio.

Código-fonte

Para compilar o binário a partir do código-fonte, você pode usar a seguinte abordagem:

  • Clone o repositório:

    git clone https://github.com/VictoriaMetrics/mcp-victoriametrics.git
cd mcp-victoriametrics

  • Compile o binário a partir do código-fonte clonado:

    make build
# after that you can find binary mcp-victoriametrics and copy this file to your PATH or run inplace

  • Compile a imagem a partir do código-fonte clonado:

    docker build -t mcp-victoriametrics .
# after that you can use docker image mcp-victoriametrics for running or pushing

Helm

Consulte a documentação do VictoriaMetrics MCP Server Helm chart para mais detalhes sobre a instalação usando Helm.

Configuração

O MCP Server para VictoriaMetrics é configurado por meio de variáveis de ambiente:

VariávelDescriçãoObrigatórioPadrãoValores permitidos
VM_INSTANCE_ENTRYPOINT / VMC_API_KEYURL da instância VictoriaMetrics (deve ser a URL raiz / do vmsingle ou vmselect)Sim (se você não usar VMC_API_KEY)--
VM_INSTANCE_TYPETipo da instância VictoriaMetricsSim (se você não usar VMC_API_KEY)-single, cluster
VM_INSTANCE_BEARER_TOKENToken de autenticação para a API do VictoriaMetricsNão--
VM_INSTANCE_HEADERSCabeçalhos HTTP personalizados para enviar com as requisições (pares chave=valor separados por vírgula)Não--
MCP_PASSTHROUGH_HEADERSNomes de cabeçalhos HTTP para encaminhar das requisições MCP recebidas para o VictoriaMetrics (lista separada por vírgula). Substitui VM_INSTANCE_HEADERS em caso de colisão. Aplica-se apenas nos modos sse/http.Não--
VM_DEFAULT_TENANT_IDID de tenant padrão para o modo cluster. Formato: accountID ou accountID:projectID (inteiros de 32 bits). Veja documentação do cluster VictoriaMetricsNão0-
VMC_API_KEYChave de API do VictoriaMetrics Cloud ConsoleNão--
MCP_SERVER_MODEModo de operação do servidor. Veja Modos para detalhes.Nãostdiostdio, sse, http
MCP_LISTEN_ADDREndereço para o servidor SSE ou HTTP escutarNãolocalhost:8080-
MCP_DISABLED_TOOLSLista separada por vírgula de ferramentas para desabilitarNão'export,flags,metric_relabel_debug,downsampling_filters_debug,retention_filters_debug,test_rules'-
MCP_DISABLE_RESOURCESDesabilitar todos os recursos (a ferramenta de documentação continuará funcionando)Nãofalsefalse, true
MCP_HEARTBEAT_INTERVALDefine o intervalo de heartbeat para o protocolo streamable-http.
Isso significa que o servidor MCP enviará um heartbeat ao cliente através da conexão GET,
para manter a conexão ativa e evitar que seja fechada pela infraestrutura de rede (ex.: gateways)		Não30s-
MCP_LOG_FORMATFormato de saída de logNãotexttext, json
MCP_LOG_LEVELNível mínimo de logNãoinfodebug, info, warn, error

Você pode usar duas opções para conectar à sua instância VictoriaMetrics:

  • Usando as variáveis de ambiente VM_INSTANCE_ENTRYPOINT + VM_INSTANCE_TYPE + VM_INSTANCE_BEARER_TOKEN (opcional) para conectar a qualquer instância single-node ou cluster do VictoriaMetrics.
  • Usando a variável de ambiente VMC_API_KEY para trabalhar com suas instâncias VictoriaMetrics Cloud.

Modos

O MCP Server suporta os seguintes modos de operação (transports):

  • stdio - Modo de entrada/saída padrão, onde o servidor lê comandos da entrada padrão e escreve respostas na saída padrão. Este é o modo padrão e é adequado para servidores locais.
  • sse - Server-Sent Events. O servidor exporá os endpoints /sse e /message para conexões SSE.
  • http - Streamable HTTP. O servidor exporá o endpoint /mcp para conexões HTTP.

Mais informações sobre transports você pode encontrar na documentação do MCP:

Exemplos de configuração

# For a single-node instance
export VM_INSTANCE_ENTRYPOINT="http://localhost:8428"
export VM_INSTANCE_TYPE="single"
export VM_INSTANCE_BEARER_TOKEN="your-token"
export MCP_PASSTHROUGH_HEADERS="X-Token,X-Access-Key"

# For a cluster
export VM_INSTANCE_ENTRYPOINT="https://play.victoriametrics.com"
export VM_INSTANCE_TYPE="cluster"
export MCP_DISABLED_TOOLS="export,metric_statistics,test_rules" # disable export, statistics and rules unit test tools

# For VictoriaMetrics Cloud
export VMC_API_KEY="<you-api-key>"

# Server mode
export MCP_SERVER_MODE="sse"
export MCP_LISTEN_ADDR="0.0.0.0:8080"

# Custom headers for authentication (e.g., behind a reverse proxy)
# Expected syntax is key=value separated by commas
export VM_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"

Endpoints

Nos modos SSE e HTTP, o servidor MCP fornece os seguintes endpoints:

EndpointDescrição
/Página inicial com ajuda de configuração e inspeção de ferramentas
/sse + /messageEndpoints para mensagens no modo SSE (para clientes MCP que suportam SSE)
/mcpEndpoint HTTP para streaming de mensagens no modo HTTP (para clientes MCP que suportam Streamable HTTP)
/metricsMétricas no formato Prometheus para monitoramento do servidor MCP
/health/livenessEndpoint de verificação de liveness para garantir que o servidor está em execução
/health/readinessEndpoint de verificação de readiness para garantir que o servidor está pronto para aceitar requisições

Configuração em clientes

Cursor

Vá para: Settings -> Cursor Settings -> MCP -> Add new global MCP server e cole a seguinte configuração no seu arquivo ~/.cursor/mcp.json do Cursor:

{
  "mcpServers": {
    "victoriametrics": {
      "command": "/path/to/mcp-victoriametrics",
      "env": {
        "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
        "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
        "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
        "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
      }
    }
  }
}

Consulte a documentação do Cursor MCP para mais informações.

Claude Desktop

Adicione isto ao seu arquivo claude_desktop_config.json do Claude Desktop (você pode encontrá-lo se abrir Settings -> Developer -> Edit config):

{
  "mcpServers": {
    "victoriametrics": {
      "command": "/path/to/mcp-victoriametrics",
      "env": {
        "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
        "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
        "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
        "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
      }
    }
  }
}

Consulte a documentação do Claude Desktop MCP para mais informações.

Claude Code

Execute o comando:

claude mcp add victoriametrics -- /path/to/mcp-victoriametrics \
  -e VM_INSTANCE_ENTRYPOINT=<YOUR_VM_INSTANCE> \
  -e VM_INSTANCE_TYPE=<YOUR_VM_INSTANCE_TYPE>
  -e VM_INSTANCE_BEARER_TOKEN=<YOUR_VM_BEARER_TOKEN>
  -e VM_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"

Consulte a documentação do Claude Code MCP para mais informações.

Codex

O Codex CLI e a extensão do IDE usam o mesmo arquivo de configuração MCP: ~/.codex/config.toml (ou .codex/config.toml em um projeto confiável).

Execute o comando:

codex mcp add victoriametrics \
  --env VM_INSTANCE_ENTRYPOINT=<YOUR_VM_INSTANCE> \
  --env VM_INSTANCE_TYPE=<YOUR_VM_INSTANCE_TYPE> \
  --env VM_INSTANCE_BEARER_TOKEN=<YOUR_VM_BEARER_TOKEN> \
  --env VM_INSTANCE_HEADERS="<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>" \
  -- /path/to/mcp-victoriametrics

Ou adicione o seguinte ao seu arquivo ~/.codex/config.toml do Codex:

[mcp_servers.victoriametrics]
command = "/path/to/mcp-victoriametrics"

[mcp_servers.victoriametrics.env]
VM_INSTANCE_ENTRYPOINT = "<YOUR_VM_INSTANCE>"
VM_INSTANCE_TYPE = "<YOUR_VM_INSTANCE_TYPE>"
VM_INSTANCE_BEARER_TOKEN = "<YOUR_VM_BEARER_TOKEN>"
VM_INSTANCE_HEADERS = "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"

Se você executar o servidor no modo Streamable HTTP, você pode registrá-lo com:

codex mcp add victoriametrics --url http://localhost:8080/mcp

Consulte a documentação do Codex MCP para mais informações.

Visual Studio Code

Adicione isto ao seu arquivo de configuração MCP do VS Code:

{
  "servers": {
    "victoriametrics": {
      "type": "stdio",
      "command": "/path/to/mcp-victoriametrics",
      "env": {
        "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
        "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
        "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
        "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
      }
    }
  }
}

Consulte a documentação do VS Code MCP para mais informações.

Zed

Adicione o seguinte ao seu arquivo de configuração do Zed:

  "context_servers": {
    "victoriametrics": {
      "command": {
        "path": "/path/to/mcp-victoriametrics",
        "args": [],
        "env": {
          "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
          "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
          "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
          "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
        }
      },
      "settings": {}
    }
  }

Consulte a documentação do Zed MCP para mais informações.

IDEs JetBrains

  • Abra Settings -> Tools -> AI Assistant -> Model Context Protocol (MCP).
  • Clique em Add (+)
  • Selecione As JSON
  • Coloque o seguinte no campo de entrada:
{
  "mcpServers": {
    "victoriametrics": {
      "command": "/path/to/mcp-victoriametrics",
      "env": {
        "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
        "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
        "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
        "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
      }
    }
  }
}

Windsurf

Adicione o seguinte ao seu arquivo de configuração MCP do Windsurf.

{
  "mcpServers": {
    "victoriametrics": {
      "command": "/path/to/mcp-victoriametrics",
      "env": {
        "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
        "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
        "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
        "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
      }
    }
  }
}

Consulte a documentação do Windsurf MCP para mais informações.

Usando Docker em vez do binário

Você pode executar o servidor MCP VictoriaMetrics usando Docker em vez do binário local.

Você deve substituir o comando de execução nos exemplos de configuração acima da seguinte forma:

{
  "mcpServers": {
    "victoriametrics": {
      "command": "docker",
        "args": [
          "run",
          "-i", "--rm",
          "-e", "VM_INSTANCE_ENTRYPOINT",
          "-e", "VM_INSTANCE_TYPE",
          "-e", "VM_INSTANCE_BEARER_TOKEN",
          "-e", "VM_INSTANCE_HEADERS",
          "ghcr.io/victoriametrics/mcp-victoriametrics",
        ],
      "env": {
        "VM_INSTANCE_ENTRYPOINT": "<YOUR_VM_INSTANCE>",
        "VM_INSTANCE_TYPE": "<YOUR_VM_INSTANCE_TYPE>",
        "VM_INSTANCE_BEARER_TOKEN": "<YOUR_VM_BEARER_TOKEN>",
        "VM_INSTANCE_HEADERS": "<HEADER>=<HEADER_VALUE>,<HEADER>=<HEADER_VALUE>"
      }
    }
  }
}

Uso

Após instalar e configurar o servidor MCP, você pode começar a usá-lo com seu cliente MCP favorito.

Você pode iniciar um diálogo com o assistente de IA a partir da frase:

Use MCP VictoriaMetrics in the following answers

Mas não é obrigatório, você pode simplesmente começar a fazer perguntas e o assistente usará automaticamente as ferramentas e a documentação para fornecer as melhores respostas. Basta dar uma olhada na seção Exemplo de diálogo para entender melhor o que você pode fazer com ele.

Conjunto de ferramentas

O MCP VictoriaMetrics fornece diversas ferramentas para interagir com sua instância VictoriaMetrics.

Aqui está uma lista de ferramentas comuns disponíveis:

FerramentaDescriçãoHabilitada por padrão
queryExecutar consultas instantâneas PromQL/MetricsQL✅
query_rangeExecutar consultas de intervalo PromQL/MetricsQL em um período de tempo✅
metricsListar métricas disponíveis✅
metrics_metadataMetadados de métricas armazenadas (tipo, ajuda e unidade)✅
labelsListar nomes de labels disponíveis✅
label_valuesListar valores para um label específico✅
seriesListar séries temporais disponíveis✅
exportExportar dados brutos de séries temporais para JSON ou CSV❌
rulesVisualizar regras de alerta e gravação✅
alertsVisualizar alertas atuais (disparados e pendentes)✅
flagsVisualizar flags não padrão da instância VictoriaMetrics❌
metric_statisticsObter estatísticas de uso de métricas (em consultas)✅
active_queriesVisualizar consultas em execução no momento✅
top_queriesVisualizar consultas mais frequentes ou mais lentas✅
tsdb_statusVisualizar estatísticas de cardinalidade do TSDB✅
tenantsListar tenants disponíveis em configuração de cluster multi-tenant✅
documentationPesquisar na documentação embutida do VictoriaMetrics✅
metric_relabel_debugDepurar regras de relabeling compatíveis com Prometheus❌
downsampling_filters_debugDepurar configuração de downsampling❌
retention_filters_debugDepurar configuração de filtros de retenção❌
prettify_queryEmbelezar e formatar consultas PromQL/MetricsQL✅
explain_queryAnalisar consultas PromQL/MetricsQL e explicar como funciona✅
test_rulesTestar unitariamente regras de alerta e gravação usando a ferramenta vmalert❌

Aqui estão algumas ferramentas adicionais disponíveis para usuários do VictoriaMetrics Cloud (com a especificação do parâmetro VMC_API_KEY):

FerramentaDescriçãoHabilitada por padrão
deploymentsListar deployments disponíveis no VictoriaMetrics Cloud✅
cloud_providersListar provedores de nuvem disponíveis no VictoriaMetrics Cloud✅
regionsListar regiões de provedores de nuvem disponíveis no VictoriaMetrics Cloud✅
tiersListar níveis de deployment disponíveis no VictoriaMetrics Cloud✅
access_tokensListar tokens de acesso de deployment disponíveis no VictoriaMetrics Cloud✅
rule_filenamesListar nomes de arquivos de regras de alerta e gravação disponíveis no VictoriaMetrics Cloud✅
rule_fileConteúdo de um arquivo específico de regra de alerta ou gravação no VictoriaMetrics Cloud✅

Prompts

O servidor inclui prompts pré-definidos para tarefas comuns.

Estes são apenas exemplos no momento, a biblioteca de prompts será ampliada no futuro:

PromptDescrição
unused_metricsEncontrar métricas que nunca são consultadas e criar configs de relabel para parar de ingeri-las
documentationPesquisar na documentação do VictoriaMetrics por tópicos específicos
rarely_used_metrics_with_high_cardinalityIdentificar métricas de alta cardinalidade que raramente são consultadas

Exemplo de diálogo

Este é apenas um exemplo de diálogo com o Assistente usando o MCP Server que pode ajudar a entender como ele funciona (mas é um diálogo real usando o servidor MCP Victoria Metrics com Claude Desktop e configurado para instância de playground pública):

  • Você: Quais tenants estão disponíveis na minha VM?

  • Assistente Na sua instância VictoriaMetrics, os seguintes tenants estão disponíveis 0:0 (tenant padrão), 1:0, 10:0, 100:0

  • Você: A partir de agora, use apenas o tenant padrão

  • Assistente: Entendido. A partir de agora, usarei apenas o tenant padrão (0:0) para todas as operações com sua instância VictoriaMetrics.

  • Você: Quais métricas temos?

  • Assistente: Existem muitas métricas disponíveis na sua instância VictoriaMetrics. A lista inclui métricas de vários sistemas e componentes, como:

    • Métricas do sistema (node_, machine_, etc.),
    • Métricas do Kubernetes (kube_, container_, apiserver_, etc.),
    • Métricas específicas do VictoriaMetrics (vm_, vmagent_, vmalert_, etc.),
    • Métricas do runtime Go (go_),
    • Métricas relacionadas ao Prometheus (scrape_, promhttp_),
    • Várias métricas de aplicações (argocd_, alertmanager_).

    Esta é uma lista abrangente de mais de 2000 métricas disponíveis para consulta. Há algum tipo específico de métrica que você tenha interesse em explorar mais a fundo?

  • Você: Ok, vamos trabalhar com métricas do Kubernetes a partir de agora. Por favor, mostre quais dessas métricas nunca foram consultadas?

  • Assistente: Com base nos resultados, posso ver que há duas métricas do Kubernetes que nunca foram consultadas (contagem de consultas é 0):

    • kube_persistentvolumeclaim_deletion_timestamp - Esta métrica fornece informações sobre quando PersistentVolumeClaims foram marcados para exclusão.
    • kube_pod_init_container_status_last_terminated_reason - Esta métrica mostra o motivo pelo qual os contêineres init em pods foram encerrados pela última vez.

    Essas métricas podem ser valiosas para fins de monitoramento e solução de problemas:

    • A métrica de timestamp de exclusão de PVC pode ajudar a rastrear padrões de exclusão ou identificar PVCs travados.
    • A métrica de motivo de encerramento de contêiner init pode ajudar a identificar padrões comuns de falha em seus contêineres de inicialização.

    Gostaria que eu explicasse mais sobre o que essas métricas rastreiam ou sugerisse algumas consultas úteis para começar a monitorá-las?

  • Você: Sim, por favor. E também, você pode criar regras de relabeling para parar de ingerir essas métricas?

  • Assistente: Vou criar uma configuração de relabel para excluir essas métricas nunca consultadas da coleta. Isso ajudará a reduzir a sobrecarga de armazenamento e processamento. Aqui está a configuração de relabel que você pode adicionar à sua configuração de scrape do VictoriaMetrics:

    relabel_configs:
- action: drop
  source_labels: [__name__]
  regex: kube_persistentvolumeclaim_deletion_timestamp|kube_pod_init_container_status_last_terminated_reason

    Esta configuração irá:

    1. Observar o nome de cada métrica (o rótulo __name__)
    2. Verificar se corresponde a alguma das métricas especificadas
    3. Descartar as métricas que correspondem, impedindo que sejam coletadas e armazenadas

    Você pode adicionar isso ao seu arquivo de configuração do VictoriaMetrics ou às configurações relevantes do job de scrape na sua configuração do Prometheus, se estiver usando o Prometheus como scraper para o VictoriaMetrics. Se quiser testar esta configuração de relabel antes de implementá-la, você pode usar a ferramenta de depuração de relabel de métricas para ver como ela afetaria suas métricas.

  • Você: Sim, por favor, depure esta configuração de relabel em séries temporais reais para ver como ela afetaria minhas métricas

  • Assistente: Perfeito! A configuração de relabel funciona como esperado:

    • Os dois primeiros casos de teste mostram que ambas as métricas kube_persistentvolumeclaim_deletion_timestamp e kube_pod_init_container_status_last_terminated_reason são corretamente descartadas (os rótulos resultantes são vazios {}).
    • O terceiro caso de teste confirma que outras métricas como kube_pod_status_phase são preservadas e não afetadas pela nossa regra de descarte.

    Você pode adicionar esta configuração de relabel com confiança à sua configuração do VictoriaMetrics ou do Prometheus para parar de coletar essas métricas não utilizadas. Isso economizará espaço de armazenamento e reduzirá a sobrecarga de processamento sem afetar suas capacidades atuais de monitoramento.

  • Você: Mas estou usando o recurso vmagent do operador VictoriaMetrics, você poderia me dar parte da especificação para meu agente com esta configuração de relabel?

  • Assistente: Você está certo, já que está usando o Operador VictoriaMetrics e o recurso personalizado VMAgent, a configuração precisa estar no formato apropriado para esse CR. Aqui está como você pode adicionar a configuração de relabel à sua especificação VMAgent:

    apiVersion: operator.victoriametrics.com/v1beta1
kind: VMAgent
metadata:
name: seu-nome-vmagente
spec:
  # ... sua configuração existente ...
  
  # Adicione esta seção para configurar o relabeling global de métricas
  inlineRelabelConfig:
    - action: drop
      sourceLabels: ["__name__"]
      regex: kube_persistentvolumeclaim_deletion_timestamp|kube_pod_init_container_status_last_terminated_reason
  
  # ... resto da sua configuração ...

    Pontos-chave:

    • Na especificação VMAgent, você usa inlineRelabelConfig para regras de relabeling inline
    • O campo é chamado sourceLabels (não source_labels como na configuração do Prometheus)
    • Este é um relabeling global que será aplicado a todas as métricas antes de serem armazenadas

  • Você: Decidi não remover essas métricas, mas apenas reduzir a taxa de amostragem para elas usando Downsampling. Quais parâmetros de downsampling tenho agora?

  • Assistente: Posso ver que você atualmente tem a seguinte configuração de downsampling:

    -downsampling.period="7d:1m,30d:5m,180d:30m"

    Isso significa:

    • Dados mais recentes que 7 dias são mantidos na resolução original
    • Dados entre 7-30 dias são reduzidos para resolução de 1 minuto
    • Dados entre 30-180 dias são reduzidos para resolução de 5 minutos
    • Dados mais antigos que 180 dias são reduzidos para resolução de 30 minutos

    Agora, se você quiser adicionar regras específicas de downsampling para essas métricas raramente consultadas, você pode usar a ferramenta de depuração de filtros de downsampling para testar como novas regras funcionariam. Vamos testar uma configuração onde aplicamos um downsampling mais agressivo para essas métricas específicas:

    ...obtendo séries e usando o depurador de filtros de downsampling...

    Ótimo! Agora nosso teste está funcionando corretamente. Com base na configuração atual e em nossos testes, aqui está uma configuração de downsampling sugerida para seu CR VMAgent que aplicaria um downsampling mais agressivo para essas métricas raramente consultadas:

    apiVersion: operator.victoriametrics.com/v1beta1
kind: VMCluster
metadata:
  name: monitoring-vm-cluster
spec:
  # ... sua configuração existente ...
  
  # Atualize a seção vmstorage com os novos parâmetros de downsampling
  vmstorage:
    extraArgs:
      downsampling.period: '{__name__=\"kube_persistentvolumeclaim_deletion_timestamp\"}:1d:10m,{__name__=\"kube_pod_init_container_status_last_terminated_reason\"}:1d:10m,7d:1m,30d:5m,180d:30m'
  
  # ... resto da sua configuração ...

    Esta configuração:

    - Aplica downsampling de resolução de 10 minutos para as métricas raramente consultadas após apenas 1 dia - Mantém sua política de downsampling existente para todas as outras métricas

    A ordem das regras de downsampling é importante - regras mais específicas devem ser listadas primeiro.

Durante este diálogo, o assistente estava usando as seguintes ferramentas:

  • tenants para obter a lista de tenants disponíveis
  • documentation para obter informações sobre funcionalidades e formatos de dados
  • metrics para obter a lista de métricas disponíveis
  • metrics_staistics para obter informações sobre o uso de métricas
  • series para obter as séries temporais para depuração
  • metric_relabel_debug para depurar regras de relabeling
  • flags para obter informações sobre parâmetros da instância
  • downsampling_filters_debug para depurar a configuração de downsampling

Mas você pode usar quaisquer outras ferramentas e combiná-las da sua própria maneira.

Monitoramento

Nos modos SSE e HTTP, o MCP Server fornece métricas no formato Prometheus (veja endpoints) e você pode encontrar um dashboard grafana simples no repositório para essas métricas.

FAQ

Por que o servidor MCP está usando mais recursos do que eu esperaria de um simples proxy de API?

O servidor contém um banco de dados vetorial embutido com documentação do VictoriaMetrics e postagens de blog para a ferramenta documentation. Isso ajuda a responder perguntas complexas sobre o VictoriaMetrics sem fornecer todos os dados ao LLM. Esta é a principal fonte de uso de recursos. Para reduzir isso, adicione documentation à variável de ambiente MCP_DISABLED_TOOLS para desabilitar completamente o carregamento do banco de dados vetorial.

Como usar uma instância do servidor MCP para várias instâncias do VictoriaMetrics?

Você pode usar o parâmetro MCP_PASSTHROUGH_HEADERS no MCP Server junto com roteamento baseado em cabeçalhos no vmauth para rotear chamadas MCP entre instâncias com base nos valores de cabeçalho HTTP da configuração do seu cliente MCP.

Roadmap

  • Suporte à ferramenta "Prettify query" (concluído em v0.0.5)
  • Suporte à ferramenta "Explain query" (concluído em v0.0.6)
  • Suporte ao pipeline de CI para construir e enviar imagens docker multiarquitetura (concluído em v1.0.0)
  • Suporte à ferramenta para testes unitários de regras de alerta e gravação (concluído em v0.0.7)
  • Suporte à integração opcional com VictoriaMetrics Cloud (via chaves de API) (concluído em v0.0.9)
  • Adicionar conhecimento extra ao servidor além da ferramenta de documentação atual:
  • Implementar versão multitenant do MCP (que suporte várias implantações)
  • Adicionar ferramenta de validação de flags/configurações
  • Suporte a ferramentas para a API do vmagent
  • Suporte à nova API do vmalert
  • Habilitar/desabilitar ferramentas via configuração (concluído em v0.0.8)
  • Ferramentas para APIs do Alertmanager #6
  • Suporte para metadados de métricas no caso de implementação no VictoriaMetrics
  • Suporte à autenticação
  • Adicionar página de índice estática com descrição e links para documentação

Menções

How to Use an AI Assistant with Your Monitoring System – VictoriaMetrics MCP Server

MCP Server Integration & Much More: What's New in VictoriaMetrics Cloud Q2 2025

Aviso Legal

Serviços de IA e agentes, juntamente com servidores MCP como este, não podem garantir a precisão, integridade e confiabilidade dos resultados. Você deve verificar novamente os resultados obtidos com IA.

A qualidade do MCP Server e suas respostas depende muito das capacidades do seu cliente e da qualidade do modelo que você está usando.

Contribuindo

Contribuições para o projeto MCP VictoriaMetrics são bem-vindas!

Sinta-se à vontade para enviar issues, solicitações de recursos ou pull requests.