SonarQube
oficialFornece integração perfeita com o SonarQube Server ou Cloud, e permite a análise de trechos de código diretamente no contexto do agente.
O que você pode fazer com SonarQube MCP?
- Conecte-se ao SonarQube Cloud ou Server — Configure o contêiner
sonarsource/sonarqube-mcpcom um token, uma chave de organização ou a URL do servidor para conectar seu assistente ao SonarQube. - Analise trechos de código — Peça ao assistente para analisar um trecho de código ou arquivo, usando uma montagem do workspace para ler arquivos diretamente do disco.
- Pesquise e gerencie problemas — Encontre e atualize problemas do SonarQube por meio do conjunto de ferramentas
issues. - Revise pontos críticos de segurança — Pesquise e revise pontos críticos de segurança por meio do conjunto de ferramentas
security-hotspots. - Explore projetos e quality gates — Consulte chaves de projetos, quality gates, regras, métricas e dados de cobertura.
- Limite conjuntos de ferramentas e use o modo somente leitura — Use
SONARQUBE_TOOLSETSeSONARQUBE_READ_ONLYpara controlar quais ferramentas são carregadas e bloquear operações de gravação.
Documentação
Servidor MCP do SonarQube
O servidor MCP do SonarQube é um servidor do Model Context Protocol (MCP) que permite a integração perfeita com o SonarQube Server ou Cloud para qualidade e segurança do código. Ele também oferece suporte à análise de trechos de código diretamente no contexto do agente.
Comece pela configuração rápida ou saiba mais sobre a família de produtos SonarQube.
Configuração rápida
Práticas recomendadas de segurança
🔒 Importante: seu token do SonarQube é uma credencial confidencial. Siga estas práticas de segurança:
Ao usar comandos CLI:
- Evite inserir tokens diretamente no código nos argumentos da linha de comando – eles são salvos no histórico do shell
- Use variáveis de ambiente – defina os tokens em variáveis de ambiente antes de executar os comandos
Ao usar arquivos de configuração:
- Nunca faça commit de tokens no controle de versão
- Use a substituição de variáveis de ambiente nos arquivos de configuração sempre que possível
🚀 Gere sua configuração
A maneira mais rápida de começar é usar o Gerador de configuração do servidor MCP do SonarQube – uma ferramenta interativa que gera uma configuração pronta para uso para o cliente do seu agente de IA preferido.
Configuração manual
Se preferir configurar tudo por conta própria, o método mais simples é usar nossa imagem de contêiner em sonarsource/sonarqube-mcp. Use sonarsource/sonarqube-mcp para atualizações automáticas (com --pull=always) ou fixe uma tag de versão (por exemplo, sonarsource/sonarqube-mcp:1.19.0.2785) para implantações reproduzíveis. Algumas versões também são marcadas com a versão do SonarQube Server à qual estão alinhadas, no formato <SQS major>.<SQS minor>.<patch> (por exemplo, sonarsource/sonarqube-mcp:2026.5.0), em que o número do patch é incrementado a cada versão do MCP destinada àquela versão do SonarQube Server. Leia abaixo se quiser compilá-lo localmente.
Observação: embora os exemplos abaixo usem
docker, qualquer ambiente de execução de contêiner compatível com OCI funciona (por exemplo, Podman, nerdctl). Basta substituirdockerpela ferramenta de sua preferência.
Antigravity
O servidor MCP do SonarQube está disponível na MCP Store do Antigravity. Siga estas instruções:
- Abra o Painel lateral do agente
- Clique nos três pontos (...) no canto superior direito e selecione Servidores MCP
- Pesquise
SonarQubee selecione Instalar - Informe o token de usuário do SonarQube necessário. Você também pode informar a chave da organização para o SonarQube Cloud ou a URL do SonarQube se estiver se conectando ao SonarQube Server.
Para o SonarQube Cloud US, defina a URL como https://sonarqube.us.
Como alternativa, você pode configurar manualmente o servidor por meio de mcp_config.json:
- Para se conectar ao SonarQube Cloud:
In the Agent Side Panel, click the three dots (...) -> MCP Store -> Manage MCP Servers -> View raw config, and add the following:
{
"mcpServers": {
"sonarqube": {
"command": "docker",
"args": ["run", "--init", "--pull=always", "-i", "--rm", "-e", "SONARQUBE_TOKEN", "-e", "SONARQUBE_ORG", "sonarsource/sonarqube-mcp"],
"env": {
"SONARQUBE_TOKEN": "<YOUR_TOKEN>",
"SONARQUBE_ORG": "<YOUR_ORG>"
}
}
}
}
Para o SonarQube Cloud US, adicione "SONARQUBE_URL": "https://sonarqube.us" à seção env e "-e", "SONARQUBE_URL" à matriz args.
- Para se conectar ao SonarQube Server:
{
"mcpServers": {
"sonarqube": {
"command": "docker",
"args": ["run", "--init", "--pull=always", "-i", "--rm", "-e", "SONARQUBE_TOKEN", "-e", "SONARQUBE_URL", "sonarsource/sonarqube-mcp"],
"env": {
"SONARQUBE_TOKEN": "<YOUR_USER_TOKEN>",
"SONARQUBE_URL": "<YOUR_SERVER_URL>"
}
}
}
}
Claude Code
- Para se conectar ao SonarQube Cloud:
claude mcp add sonarqube \
--env SONARQUBE_TOKEN=$SONAR_TOKEN \
--env SONARQUBE_ORG=$SONAR_ORG \
-- docker run --init --pull=always -i --rm -e SONARQUBE_TOKEN -e SONARQUBE_ORG sonarsource/sonarqube-mcp
Para o SonarQube Cloud US, adicione --env SONARQUBE_URL=https://sonarqube.us ao comando.
- Para se conectar ao SonarQube Server:
claude mcp add sonarqube \
--env SONARQUBE_TOKEN=$SONAR_USER_TOKEN \
--env SONARQUBE_URL=$SONAR_URL \
-- docker run --init --pull=always -i --rm -e SONARQUBE_TOKEN -e SONARQUBE_URL sonarsource/sonarqube-mcp
Codex CLI
Edite manualmente o arquivo de configuração em ~/.codex/config.toml e adicione a seguinte configuração:
- Para se conectar ao SonarQube Cloud:
[mcp_servers.sonarqube]
command = "docker"
args = ["run", "--init", "--pull=always", "--rm", "-i", "-e", "SONARQUBE_TOKEN", "-e", "SONARQUBE_ORG", "sonarsource/sonarqube-mcp"]
env = { "SONARQUBE_TOKEN" = "<YOUR_USER_TOKEN>", "SONARQUBE_ORG" = "<YOUR_ORG>" }
Para o SonarQube Cloud US, adicione "SONARQUBE_URL" = "https://sonarqube.us" à seção env e "-e", "SONARQUBE_URL" à matriz args.
- Para se conectar ao SonarQube Server:
[mcp_servers.sonarqube]
command = "docker"
args = ["run", "--init", "--pull=always", "--rm", "-i", "-e", "SONARQUBE_TOKEN", "-e", "SONARQUBE_URL", "sonarsource/sonarqube-mcp"]
env = { "SONARQUBE_TOKEN" = "<YOUR_TOKEN>", "SONARQUBE_URL" = "<YOUR_SERVER_URL>" }
Cursor
- Para se conectar ao SonarQube Cloud:
Para o SonarQube Cloud US, adicione manualmente "SONARQUBE_URL": "https://sonarqube.us" à seção env da sua configuração MCP após a instalação.
- Para se conectar ao SonarQube Server:
Gemini CLI
Observação: a extensão do Gemini CLI foi movida para o repositório sonarqube-agent-plugins. Instale-a por lá daqui em diante.
Você pode instalar nossa extensão do servidor MCP usando o seguinte comando:
gemini extensions install https://github.com/SonarSource/sonarqube-agent-plugins
Será necessário definir as variáveis de ambiente necessárias antes de iniciar o Gemini:
Variáveis de ambiente necessárias:
-
Para o SonarQube Cloud:
SONARQUBE_TOKEN- Seu token do SonarQube CloudSONARQUBE_ORG- Sua chave da organizaçãoSONARQUBE_URL- (Opcional) Defina comohttps://sonarqube.uspara o SonarQube Cloud US
-
Para o SonarQube Server:
SONARQUBE_TOKEN- Seu token de usuário do SonarQube ServerSONARQUBE_URL- A URL do seu SonarQube Server
Após a instalação, a extensão será instalada em <home>/.gemini/extensions/sonarqube/gemini-extension.json.
GitHub Copilot CLI
Após iniciar o Copilot CLI, execute o seguinte comando para adicionar o servidor MCP do SonarQube:
/mcp add
Você precisará fornecer informações diferentes sobre o servidor MCP; use a tecla Tab para navegar entre os campos.
- Para se conectar ao SonarQube Cloud:
Server Name: sonarqube
Server Type: Local (Press 1)
Command: docker
Arguments: run, --init, --pull=always, --rm, -i, -e, SONARQUBE_TOKEN, -e, SONARQUBE_ORG, sonarsource/sonarqube-mcp
Environment Variables: SONARQUBE_TOKEN=<YOUR_TOKEN>,SONARQUBE_ORG=<YOUR_ORG>
Tools: *
Para o SonarQube Cloud US, adicione -e, SONARQUBE_URL aos argumentos e SONARQUBE_URL=https://sonarqube.us às variáveis de ambiente.
- Para se conectar ao SonarQube Server:
Server Name: sonarqube
Server Type: Local (Press 1)
Command: docker
Arguments: run, --init, --pull=always, --rm, -i, -e, SONARQUBE_TOKEN, -e, SONARQUBE_URL, sonarsource/sonarqube-mcp
Environment Variables: SONARQUBE_TOKEN=<YOUR_USER_TOKEN>,SONARQUBE_URL=<YOUR_SERVER_URL>
Tools: *
O arquivo de configuração está localizado em ~/.copilot/mcp-config.json.
Agente de codificação do GitHub Copilot
O agente de codificação do GitHub Copilot pode usar diretamente o servidor MCP do SonarQube no seu CI/CD.
Para adicionar os segredos ao seu ambiente do Copilot, siga a documentação do Copilot. Somente os segredos cujos nomes começam com COPILOT_MCP_ estarão disponíveis para sua configuração MCP.
No seu repositório do GitHub, acesse Settings -> Copilot -> Coding agent e adicione a seguinte configuração na seção de configuração MCP:
- Para se conectar ao SonarQube Cloud:
{
"mcpServers": {
"sonarqube": {
"type": "local",
"command": "docker",
"args": [
"run",
"--init",
"--pull=always",
"--rm",
"-i",
"-e",
"SONARQUBE_TOKEN",
"-e",
"SONARQUBE_ORG",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_TOKEN": "COPILOT_MCP_SONARQUBE_TOKEN",
"SONARQUBE_ORG": "COPILOT_MCP_SONARQUBE_ORG"
},
"tools": ["*"]
}
}
}
Para o SonarQube Cloud US, adicione "-e", "SONARQUBE_URL" à matriz args e "SONARQUBE_URL": "COPILOT_MCP_SONARQUBE_URL" à seção env; em seguida, defina o segredo COPILOT_MCP_SONARQUBE_URL=https://sonarqube.us.
- Para se conectar ao SonarQube Server:
{
"mcpServers": {
"sonarqube": {
"type": "local",
"command": "docker",
"args": [
"run",
"--init",
"--pull=always",
"--rm",
"-i",
"-e",
"SONARQUBE_TOKEN",
"-e",
"SONARQUBE_URL",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_TOKEN": "COPILOT_MCP_SONARQUBE_USER_TOKEN",
"SONARQUBE_URL": "COPILOT_MCP_SONARQUBE_URL"
},
"tools": ["*"]
}
}
}
Kiro
Crie um arquivo .kiro/settings/mcp.json no diretório do seu espaço de trabalho (ou edite-o, se já existir) e adicione a seguinte configuração:
- Para se conectar ao SonarQube Cloud:
{
"mcpServers": {
"sonarqube": {
"command": "docker",
"args": [
"run",
"--init",
"--pull=always",
"-i",
"--rm",
"-e",
"SONARQUBE_TOKEN",
"-e",
"SONARQUBE_ORG",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_TOKEN": "<YOUR_TOKEN>",
"SONARQUBE_ORG": "<YOUR_ORG>"
},
"disabled": false,
"autoApprove": []
}
}
}
Para o SonarQube Cloud US, adicione "-e", "SONARQUBE_URL" à matriz args e "SONARQUBE_URL": "https://sonarqube.us" à seção env.
- Para se conectar ao SonarQube Server:
{
"mcpServers": {
"sonarqube": {
"command": "docker",
"args": [
"run",
"--init",
"--pull=always",
"-i",
"--rm",
"-e",
"SONARQUBE_TOKEN",
"-e",
"SONARQUBE_URL",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_TOKEN": "<YOUR_USER_TOKEN>",
"SONARQUBE_URL": "<YOUR_SERVER_URL>"
},
"disabled": false,
"autoApprove": []
}
}
}
VS Code
Você pode usar os botões a seguir para simplificar o processo de instalação no VS Code.
Para o SonarQube Cloud US, adicione manualmente "SONARQUBE_URL": "https://sonarqube.us" à seção env da sua configuração MCP após a instalação.
Windsurf
O servidor MCP do SonarQube está disponível como um plugin do Windsurf. Siga estas instruções:
- Abra Settings > Cascade > MCP Servers do Windsurf e selecione Open MCP Marketplace
- Pesquise
sonarqubeno Cascade MCP Marketplace - Escolha SonarQube MCP Server e selecione Install
- Adicione o token de usuário do SonarQube necessário. Opcionalmente, adicione uma chave de organização padrão para o SonarQube Cloud ou a URL do SonarQube para o SonarQube Server ou Community Build.
Para o SonarQube Cloud US, defina a URL como https://sonarqube.us.
Zed
Acesse a visualização Extensions no Zed e pesquise SonarQube MCP Server. Ao instalar a extensão, será solicitado que você informe as variáveis de ambiente necessárias:
- Ao usar o SonarQube Cloud:
{
"sonarqube_token": "YOUR_SONARQUBE_TOKEN",
"sonarqube_org": "SONARQUBE_ORGANIZATION_KEY",
"docker_path": "DOCKER_PATH"
}
Para o SonarQube Cloud US, adicione "sonarqube_url": "https://sonarqube.us" à configuração.
- Ao usar o SonarQube Server:
{
"sonarqube_token": "YOUR_SONARQUBE_USER_TOKEN",
"sonarqube_url": "YOUR_SONARQUBE_SERVER_URL",
"docker_path": "DOCKER_PATH"
}
docker_path é o caminho para um executável do Docker. Exemplos:
Linux/macOS: /usr/bin/docker ou /usr/local/bin/docker
Windows: C:\Program Files\Docker\Docker\resources\bin\docker.exe
💡 Dica: recomendamos baixar a imagem mais recente regularmente ou antes de relatar problemas, para garantir que você tenha os recursos e as correções mais atualizados.
Instalação manual
Você pode instalar manualmente o servidor MCP do SonarQube copiando o trecho a seguir para o arquivo de configuração dos servidores MCP:
- Para se conectar ao SonarQube Cloud:
{
"sonarqube": {
"command": "docker",
"args": [
"run",
"--init",
"--pull=always",
"-i",
"--rm",
"-e",
"SONARQUBE_TOKEN",
"-e",
"SONARQUBE_ORG",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_TOKEN": "<token>",
"SONARQUBE_ORG": "<org>"
}
}
}
- Para se conectar ao SonarQube Server:
{
"sonarqube": {
"command": "docker",
"args": [
"run",
"--init",
"--pull=always",
"-i",
"--rm",
"-e",
"SONARQUBE_TOKEN",
"-e",
"SONARQUBE_URL",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_TOKEN": "<token>",
"SONARQUBE_URL": "<url>"
}
}
}
Integração com o SonarQube for IDE
O servidor MCP do SonarQube pode se integrar ao SonarQube for IDE para aprimorar ainda mais seu fluxo de desenvolvimento, oferecendo análises e insights de código melhores diretamente no seu IDE.
Configuração
Ao usar o SonarQube for IDE, a variável de ambiente SONARQUBE_IDE_PORT deve ser definida com o número de porta correto. O SonarQube for VS Code inclui um botão de instalação rápida que define automaticamente a configuração correta da porta.
Por exemplo, com o SonarQube Cloud:
{
"sonarqube": {
"command": "docker",
"args": [
"run",
"--init",
"--pull=always",
"-i",
"--rm",
"-e",
"SONARQUBE_TOKEN",
"-e",
"SONARQUBE_ORG",
"-e",
"SONARQUBE_IDE_PORT",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_TOKEN": "<token>",
"SONARQUBE_ORG": "<org>",
"SONARQUBE_IDE_PORT": "<64120-64130>"
}
}
}
Ao executar o servidor MCP em um contêiner no Linux, o contêiner não consegue acessar o servidor integrado do SonarQube for IDE em execução no localhost. Para permitir que o contêiner se conecte ao servidor do SonarQube for IDE, adicione a opção
--network=hostao comando de execução do contêiner.
Configuração
Dependendo do seu ambiente, você deve fornecer variáveis de ambiente específicas.
Básico
Você deve adicionar a seguinte variável ao executar o servidor MCP:
| Variável de ambiente | Descrição |
|---|---|
STORAGE_PATH | Caminho absoluto obrigatório para um diretório gravável onde o SonarQube MCP Server armazenará seus arquivos (por exemplo, para criação, atualizações e persistência); ele é fornecido automaticamente ao usar a imagem do contêiner |
SONARQUBE_PROJECT_KEY | Chave de projeto padrão opcional. Quando definida, todas as ferramentas que exigem uma chave de projeto usarão esse valor automaticamente — o parâmetro projectKey será removido completamente do esquema delas. Útil ao trabalhar em um único projeto. |
SONARQUBE_IDE_PORT | Número de porta opcional entre 64120 e 64130 usado para conectar o SonarQube MCP Server ao SonarQube for IDE. |
SONARQUBE_FORCE_LOCAL_ANALYSIS | Defina como true para usar analyze_code_snippet em vez da análise Vortex no Cloud stdio, inclusive para organizações com direito de uso. Requer o conjunto de ferramentas analysis. Padrão: false. Não tem efeito no SonarQube Server nem no Cloud HTTP. |
SONARQUBE_DEBUG_ENABLED | Quando definido como true, ativa o registro de depuração. Os logs de depuração são gravados tanto no arquivo de log quanto em STDERR. Útil para solucionar problemas de conectividade ou configuração. Padrão: false. |
SONARQUBE_LOG_TO_FILE_DISABLED | Quando definido como true, desativa completamente a gravação de logs em disco. Nenhum arquivo de log será criado em STORAGE_PATH/logs/. Útil em ambientes conteinerizados ou efêmeros nos quais o registro em arquivo é indesejável. Padrão: false. |
Montagem do espaço de trabalho (redução do excesso de contexto)
Por padrão, a ferramenta de análise analyze_code_snippet exige que o agente passe o conteúdo completo do arquivo como argumento fileContent. Para arquivos grandes ou ao analisar muitos arquivos em uma sessão, isso aumenta significativamente o uso da janela de contexto e o custo.
Solução: monte o diretório do projeto no contêiner em /app/mcp-workspace. Quando essa montagem é detectada, o servidor lê os arquivos diretamente do disco usando o argumento filePath relativo ao projeto — o conteúdo dos arquivos nunca passa pelo contexto do agente.
{
"args": [
"run", "-i", "--rm", "--init", "--pull=always",
"-e", "SONARQUBE_TOKEN",
"-e", "SONARQUBE_ORG",
"-v", "/path/to/your/project:/app/mcp-workspace",
"sonarsource/sonarqube-mcp"
]
}
Com uma montagem, as ferramentas de análise leem os arquivos diretamente usando filePath; fileContent não é necessário.
No stdio, a análise é selecionada na inicialização (sujeita aos conjuntos de ferramentas ativados):
- SonarQube Cloud: análise Vortex (
run_advanced_code_analysis) com uma montagem do espaço de trabalho e pelo menos uma organização com direito de uso; análise local nos demais casos. A análise Vortex aceita apenas organizações com direito de uso. - SonarQube Server: análise Vortex para instâncias com direito de uso (requer uma montagem do espaço de trabalho); análise local para instâncias sem Vortex.
A análise local usa o SonarQube for IDE se estiver conectado ou analyze_code_snippet. Sem uma montagem, a análise de trechos de código exige fileContent.
No Cloud stdio, SONARQUBE_ORG limita a verificação de direito de uso a essa organização. Para usar trechos de código em todas as organizações, defina SONARQUBE_FORCE_LOCAL_ANALYSIS=true, ative o conjunto de ferramentas analysis e reinicie. Essa configuração afeta apenas o Cloud stdio.
Por HTTP/HTTPS, Cloud e Server oferecem suporte a analyze_code_snippet quando o servidor MCP tem um SONARQUBE_TOKEN de inicialização e o conjunto de ferramentas analysis está ativado. O token de inicialização é necessário para inicializar o analisador (os downloads de plug-ins do Cloud são anônimos); as chamadas usam o token do chamador e, no Cloud, a organização selecionada para a solicitação para recuperar os perfis de qualidade e as regras ativas. Sem um token de inicialização, a análise de trechos de código e os downloads do analisador ficam desativados, mesmo com SONARQUBE_FORCE_LOCAL_ANALYSIS=true. Não é necessário ter direito de uso do Vortex.
Ativação seletiva de ferramentas
Os clientes MCP carregam todas as ferramentas ativadas — seus nomes, descrições e esquemas de entrada — no contexto do agente em cada conversa. Limitar essa lista com SONARQUBE_TOOLSETS reduz o uso de contexto e o custo de tokens de cada sessão.
Por padrão, apenas os conjuntos de ferramentas importantes são ativados. Ative conjuntos adicionais somente quando precisar deles.
| Variável de ambiente | Descrição |
|---|---|
SONARQUBE_TOOLSETS | Lista separada por vírgulas dos conjuntos de ferramentas a ativar. Quando definida, somente esses conjuntos de ferramentas estarão disponíveis. Se não for definida, os conjuntos de ferramentas importantes padrão serão ativados (analysis, ide, issues, projects, quality-gates, rules, duplications, measures, security-hotspots, dependency-risks, coverage, cag). Observação: o conjunto de ferramentas projects está sempre ativado, pois é necessário para encontrar chaves de projeto para outras operações. As ferramentas de contexto Vortex (nome obsoleto: Context Augmentation/CAG) e as ferramentas de análise Vortex (nome obsoleto: Advanced Analysis/A3S) estão disponíveis apenas no modo stdio e compartilham um único direito de uso combinado por organização — uma organização precisa ter direito de uso de ambos para usar qualquer um deles. A análise integrada do Cloud verifica a organização selecionada em tempo de execução; as ferramentas de contexto por proxy usam a organização de inicialização. No SonarQube Server, o stdio lista o contexto Vortex e run_advanced_code_analysis quando os hubs CAG e A3S têm direito de uso. Prefira a chave unificada do conjunto de ferramentas vortex. As chaves obsoletas cag e analysis ainda funcionam; um aviso de inicialização e uma nota de descontinuação nas instruções do servidor são emitidos quando elas são usadas sem vortex. No modo Streamable HTTP, os clientes podem enviar um cabeçalho HTTP SONARQUBE_TOOLSETS para restringir ainda mais cada solicitação, mas não podem ativar conjuntos de ferramentas além daqueles com os quais o servidor foi iniciado (consulte Transporte Streamable HTTP abaixo). |
SONARQUBE_READ_ONLY | Quando definido como true, ativa o modo somente leitura, que desativa todas as operações de gravação (como alterar o status de um problema). Esse filtro é cumulativo com SONARQUBE_TOOLSETS se ambos estiverem definidos. Padrão: false. No modo Streamable HTTP, os clientes podem enviar um cabeçalho HTTP SONARQUBE_READ_ONLY para restringir ainda mais solicitações individuais ao modo somente leitura, mas não podem remover uma restrição de somente leitura definida no nível do servidor (consulte Transporte Streamable HTTP abaixo). |
Conjuntos de ferramentas disponíveis
| Conjunto de ferramentas | Chave | Descrição | |-----------------------|---------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------| | **Análise** | `analysis` | Ferramentas de análise de código (análise local via `analyze_code_snippet`, **obsoleto** em favor da análise `analyze_file_list`/Vortex) | | **IDE** | `ide` | Ferramentas de integração do SonarQube for IDE (análise de arquivos, alternância da análise automática) — atualmente também incluídas em `analysis` | | **Problemas** | `issues` | Pesquisar e gerenciar problemas do SonarQube | | **Pontos de acesso de segurança** | `security-hotspots` | Pesquisar e revisar pontos de acesso de segurança | | **Projetos** | `projects` | Navegar e pesquisar projetos do SonarQube | | **Quality Gates** | `quality-gates` | Acessar quality gates e seus status | | **Regras** | `rules` | Navegar e pesquisar regras do SonarQube | | **Código-fonte** | `sources` | Acessar o código-fonte e as informações do SCM | | **Duplicações** | `duplications` | Encontrar duplicações de código entre projetos | | **Métricas** | `measures` | Recuperar métricas e medidas (inclui ferramentas de medidas e métricas) | | **Linguagens** | `languages` | Listar linguagens de programação compatíveis | | **Portfólios** | `portfolios` | Gerenciar portfólios e empresas (Cloud e Server) | | **Sistema** | `system` | Ferramentas de administração do sistema (somente Server) | | **Webhooks** | `webhooks` | Gerenciar webhooks | | **Riscos de dependências** | `dependency-risks` | Analisar riscos de dependências e problemas de segurança (SCA) | | **Cobertura** | `coverage` | Ferramentas de análise e melhoria da cobertura de testes | | **Contexto do Vortex** | `cag` | Ferramentas de contexto do Vortex — somente stdio. **Obsoleto** em favor de `vortex` (nome antigo: Context Augmentation/CAG) | | **Vortex** | `vortex` | Conjunto unificado e **recomendado** de ferramentas que reúne ferramentas de contexto e análise do Vortex sob um único nome (somente stdio; Cloud requer autorização combinada da organização; Server requer autorização para ambos os hubs) | | **Prontidão para agentes** | `agentic-readiness` | Ferramentas de avaliação da prontidão para agentes (SonarQube Cloud, requer autorização da organização) | | **Arquitetura** | `architecture` | Ler a arquitetura, substituir modelos pretendidos e gerenciar diretivas do projeto (não habilitado por padrão) |Exemplos
Habilitar os conjuntos de ferramentas de análise, problemas e quality gates (usando Docker com SonarQube Cloud):
docker run --init --pull=always -i --rm \
-e SONARQUBE_TOKEN="<token>" \
-e SONARQUBE_ORG="<org>" \
-e SONARQUBE_TOOLSETS="analysis,issues,quality-gates" \
sonarsource/sonarqube-mcp
Observação: O conjunto de ferramentas projects é sempre habilitado automaticamente, portanto não é necessário incluí-lo em SONARQUBE_TOOLSETS.
Habilitar o modo somente leitura (usando Docker com SonarQube Cloud):
docker run --init --pull=always -i --rm \
-e SONARQUBE_TOKEN="<token>" \
-e SONARQUBE_ORG="<org>" \
-e SONARQUBE_READ_ONLY="true" \
sonarsource/sonarqube-mcp
SonarQube Cloud
Para stdio, configure as seguintes variáveis de ambiente:
| Variável de ambiente | Descrição | Obrigatória |
|---|---|---|
SONARQUBE_TOKEN | Seu token do SonarQube Cloud | Sim |
SONARQUBE_ORG | Chave opcional de organização do SonarQube Cloud | Não |
SONARQUBE_URL | URL personalizada do SonarQube Cloud (o padrão é https://sonarcloud.io). Use esta opção para o SonarQube Cloud US: https://sonarqube.us | Não |
Exemplos:
- SonarQube Cloud: Somente
SONARQUBE_TOKENé obrigatório.SONARQUBE_ORGfixa a organização quando definido. - SonarQube Cloud US: Defina
SONARQUBE_TOKENeSONARQUBE_URL=https://sonarqube.us;SONARQUBE_ORGé opcional.
SonarQube Server
| Variável de ambiente | Descrição | Obrigatória |
|---|---|---|
SONARQUBE_TOKEN | Seu token de USUÁRIO do SonarQube Server | Sim |
SONARQUBE_URL | URL do SonarQube Server | Sim |
Requisito de versão: É necessário usar o SonarQube Server 2025.1 (SQS) ou 25.1 (SonarQube Community Build) ou posterior. Na inicialização, o servidor MCP lê a versão da instância conectada e encerra com um erro se ela for muito antiga (por exemplo, versões legadas 9.x/10.x do Server e a versão 24.x do Community Build não são compatíveis). O SonarQube Cloud não está sujeito a essa verificação.
⚠️ A conexão com o SonarQube Server requer um token do tipo USER e não funcionará corretamente se forem usados tokens de projeto ou tokens globais.
💡 Dica de configuração (modo stdio): Um token sem URL usa o SonarQube Cloud por padrão. Defina
SONARQUBE_URLpara o SonarQube Server ou para outra região do Cloud.SONARQUBE_ORGfixa a organização do Cloud quando definido.
No stdio, definir SONARQUBE_ORG fixa a organização do Cloud. Os argumentos da ferramenta organization são omitidos dos esquemas e rejeitados, assim como projectKey quando SONARQUBE_PROJECT_KEY está definido.
Com SONARQUBE_ORG não definido, os agentes podem chamar list_organizations para descobrir as chaves, os nomes, os IDs e os UUIDs das organizações acessíveis à conta de usuário e, em seguida, passar uma chave como argumento opcional organization nas ferramentas que aceitam organizações. O stdio mantém como padrão uma organização detectada de forma exclusiva; se nenhuma ou várias organizações forem encontradas, ela permanece indefinida. Um argumento de ferramenta se aplica somente àquela chamada e nunca altera a organização padrão detectada. As consultas de perfis de snippets e regras usam a organização selecionada para aquela chamada.
Para solicitações HTTP/HTTPS com token, o SONARQUBE_ORG no nível do servidor continua sendo compatível por motivos de compatibilidade, mas está obsoleto e gera um aviso na inicialização. Ele fixa a organização para todas as solicitações e rejeita cabeçalhos de organização do cliente e argumentos organization de ferramentas. Quando nenhuma organização do servidor estiver configurada, um cabeçalho opcional SONARQUBE_ORG do cliente fixa a organização para aquela solicitação e não permite argumentos organization de ferramentas. Sem o cabeçalho, use o argumento da ferramenta. As ferramentas que exigem uma organização fornecem orientações para descobri-la quando todos esses valores estão ausentes. A descoberta de organizações e as ferramentas cujas APIs consomem apenas identificadores de recursos não exigem um argumento de organização. A pesquisa de problemas com suporte a organizações e as verificações de autorização para riscos de dependências usam a organização selecionada. Quando o OAuth está configurado, o SONARQUBE_ORG no nível do servidor é rejeitado. As solicitações OAuth também rejeitam cabeçalhos de organização; selecione as organizações por meio dos argumentos das ferramentas.
As ferramentas de contexto do Vortex usam a organização configurada ou detectada de forma exclusiva na inicialização. Os argumentos de organização em tempo de execução não reconfiguram o mecanismo de contexto intermediário; organizações indefinidas na inicialização ignoram esse proxy. A ferramenta integrada run_advanced_code_analysis verifica a autorização combinada do Vortex para a organização selecionada em cada invocação.
Modos de transporte
A especificação MCP define dois mecanismos de transporte: Stdio e Streamable HTTP. O SonarQube MCP Server oferece suporte a ambos:
| Transporte MCP | Modo do servidor | Uso típico |
|---|---|---|
| Stdio | Padrão (sem SONARQUBE_TRANSPORT) | Clientes MCP locais que iniciam o servidor como um subprocesso (Cursor, Claude Code, VS Code etc.) |
| Streamable HTTP | SONARQUBE_TRANSPORT=http ou https | Implantações remotas ou multiusuário; os clientes se conectam a /mcp por HTTP(S) (por exemplo, Windsurf com uma URL de servidor auto-hospedado) |
Observação: Streamable HTTP é o transporte de rede MCP atual. O transporte HTTP antigo, somente com SSE, de versões anteriores do MCP está obsoleto e não é compatível.
1. Stdio (padrão — recomendado para desenvolvimento local)
O modo recomendado para desenvolvimento local e configurações de usuário único, usado pela maioria dos clientes MCP.
Exemplo — Docker com SonarQube Cloud:
{
"mcpServers": {
"sonarqube": {
"command": "docker",
"args": ["run", "--init", "--pull=always", "-i", "--rm", "-e", "SONARQUBE_TOKEN", "-e", "SONARQUBE_ORG", "sonarsource/sonarqube-mcp"],
"env": {
"SONARQUBE_TOKEN": "<your-token>",
"SONARQUBE_ORG": "<your-org>"
}
}
}
}
2. HTTP (Streamable HTTP)
Transporte Streamable HTTP sem criptografia. Use HTTPS em vez disso para implantações multiusuário.
⚠️ Não recomendado: Use Stdio para desenvolvimento local ou HTTPS (Streamable HTTP) para implantações de produção multiusuário.
| Variável de ambiente | Descrição | Padrão |
|---|---|---|
SONARQUBE_TRANSPORT | Defina como http para habilitar o transporte Streamable HTTP | Não definido (stdio) |
SONARQUBE_HTTP_PORT | Número da porta (1024-65535) ou 0 para uma porta atribuída pelo sistema operacional | 8080 |
SONARQUBE_HTTP_HOST | Host ao qual vincular (o padrão é localhost por segurança) | 127.0.0.1 |
SONARQUBE_HTTP_ALLOWED_ORIGINS | Origens do navegador permitidas para CORS, separadas por vírgulas (por exemplo, https://my-app.example.com) | Não definido |
SONARQUBE_MCP_IN_CONTAINER | Defina como true ao executar dentro de um contêiner. A imagem oficial do Docker define isso automaticamente; defina manualmente ao usar outros ambientes de execução OCI (Podman, Kubernetes, Nomad etc.). | false |
Observação: HTTP/HTTPS aceita o token do usuário do SonarQube por meio de Authorization: Bearer <token>. O serviço Cloud hospedado do Sonar também oferece suporte a OAuth. Para solicitações de token do SonarQube Cloud, a organização é resolvida da seguinte forma: |
SONARQUBE_ORGé um cabeçalho de solicitação opcional que fixa a organização para essa solicitação. A configuração obsoleta no nível do servidor fixa a organização para todas as solicitações e rejeita cabeçalhos de organização do cliente e argumentos de organização das ferramentas.- As ferramentas que reconhecem organizações aceitam um argumento opcional
organizationquando nem a configuração do servidor nem o cabeçalho da solicitação fixam a organização. O fornecimento do argumento quando a organização está fixa é rejeitado. - Sem um padrão, os agentes podem chamar
list_organizationsusando apenas o token e, em seguida, passar a chave escolhida para as ferramentas subsequentes.
Os clientes também podem restringir as ferramentas visíveis por solicitação fornecendo os cabeçalhos SONARQUBE_TOOLSETS e/ou SONARQUBE_READ_ONLY; eles aplicam filtragem adicional sobre a configuração no nível do servidor — só podem reduzir o escopo, nunca ampliá-lo.
Nenhum estado de sessão é mantido entre as solicitações.
Obsoleto: Para tokens do SonarQube, o cabeçalho de solicitação
SONARQUBE_TOKENainda é aceito por compatibilidade com versões anteriores, mas será removido em uma versão futura. Migre paraAuthorization: Bearer <token>.
3. HTTPS (HTTP Streamable sobre TLS) (Recomendado para implantações de produção multiusuário)
Transporte HTTP Streamable seguro com criptografia TLS. Requer certificados SSL.
✅ Recomendado para produção: Use HTTPS ao implantar o servidor MCP para vários usuários por HTTP Streamable. Por segurança, o servidor se vincula a
127.0.0.1(localhost) por padrão.
| Variável de ambiente | Descrição | Padrão |
|---|---|---|
SONARQUBE_TRANSPORT | Defina como https para habilitar o transporte HTTP Streamable por TLS | Não definido (stdio) |
SONARQUBE_HTTP_PORT | Número da porta (normalmente 8443 para HTTPS) ou 0 para uma porta atribuída pelo sistema operacional | 8080 |
SONARQUBE_HTTP_HOST | Host ao qual se vincular (por segurança, o padrão é localhost) | 127.0.0.1 |
SONARQUBE_HTTP_ALLOWED_ORIGINS | Origens de navegador separadas por vírgulas permitidas para CORS (por exemplo, https://my-app.example.com) | Não definido |
SONARQUBE_MCP_IN_CONTAINER | Defina como true ao executar dentro de um contêiner. A imagem oficial do Docker define isso automaticamente; defina você mesmo ao usar outros ambientes de execução OCI (Podman, Kubernetes, Nomad etc.). | false |
Configuração do certificado SSL (opcional):
| Variável de ambiente | Descrição | Padrão |
|---|---|---|
SONARQUBE_HTTPS_KEYSTORE_PATH | Caminho para o arquivo do keystore (.p12 ou .jks) | /etc/ssl/mcp/keystore.p12 |
SONARQUBE_HTTPS_KEYSTORE_PASSWORD | Senha do keystore | sonarlint |
SONARQUBE_HTTPS_KEYSTORE_TYPE | Tipo de keystore (PKCS12 ou JKS) | PKCS12 |
Exemplo - Docker com SonarQube Cloud:
Observação: Ao executar em um contêiner, defina
SONARQUBE_HTTP_HOST=0.0.0.0para que o contêiner escute em todas as interfaces e o mapeamento de portas do ambiente de execução funcione, e definaSONARQUBE_MCP_IN_CONTAINER=truepara informar ao servidor que ele está dentro de um contêiner. A imagem oficial do Docker define este último automaticamente; defina-o você mesmo ao usar outros ambientes de execução OCI (Podman, Kubernetes, Nomad etc.). A opção de porta do host controla quem pode acessar o servidor de fora do contêiner.SONARQUBE_HTTP_HOST=0.0.0.0controla apenas onde o servidor escuta dentro do contêiner — o CORS do navegador ainda permite origens localhost por padrão.
Para um servidor em execução localmente na sua máquina (acessível apenas por localhost):
docker run --init --pull=always -p 127.0.0.1:8443:8443 \
-v $(pwd)/keystore.p12:/etc/ssl/mcp/keystore.p12:ro \
-e SONARQUBE_TRANSPORT=https \
-e SONARQUBE_HTTP_HOST=0.0.0.0 \
-e SONARQUBE_HTTP_PORT=8443 \
sonarsource/sonarqube-mcp
Para um servidor acessível pela rede (implantações remotas):
docker run --init --pull=always -p 8443:8443 \
-v $(pwd)/keystore.p12:/etc/ssl/mcp/keystore.p12:ro \
-e SONARQUBE_TRANSPORT=https \
-e SONARQUBE_HTTP_HOST=0.0.0.0 \
-e SONARQUBE_HTTP_PORT=8443 \
sonarsource/sonarqube-mcp
Configuração do cliente (SonarQube Cloud):
Para solicitações de token do SonarQube, defina opcionalmente SONARQUBE_ORG nos cabeçalhos do cliente para fixar a organização da solicitação ou omita-o para selecionar organizações por meio dos argumentos das ferramentas.
{
"mcpServers": {
"sonarqube-https": {
"url": "https://your-server:8443/mcp",
"headers": {
"Authorization": "Bearer <your-token>",
"SONARQUBE_TOOLSETS": "issues,quality-gates",
"SONARQUBE_READ_ONLY": "true"
}
}
}
}
Configuração do cliente (SonarQube Server):
{
"mcpServers": {
"sonarqube-https": {
"url": "https://your-server:8443/mcp",
"headers": {
"Authorization": "Bearer <your-token>",
"SONARQUBE_TOOLSETS": "issues,quality-gates",
"SONARQUBE_READ_ONLY": "true"
}
}
}
}
Observação:
SONARQUBE_TOOLSETSeSONARQUBE_READ_ONLYsão cabeçalhos opcionais por solicitação que restringem o conjunto de ferramentas no nível do servidor para essa solicitação específica. Eles só podem reduzir o escopo — não podem habilitar conjuntos de ferramentas nem remover restrições além do que foi definido ao iniciar o servidor.
Observação: Para desenvolvimento local, use o transporte Stdio (o padrão). O HTTP Streamable por HTTPS destina-se a implantações de produção multiusuário com certificados SSL adequados.
OAuth hospedado do SonarQube Cloud
O suporte a OAuth destina-se ao serviço MCP hospedado do SonarQube Cloud. Use um cliente MCP compatível com OAuth e entre quando solicitado; não é necessário configurar o servidor OAuth na configuração do cliente. Os clientes existentes que usam tokens do SonarQube continuam sendo compatíveis.
Os escopos mcp:tools:read e mcp:tools:write controlam de forma independente o acesso às ferramentas de leitura e gravação, sujeitos às suas permissões do Cloud. Use list_organizations e os argumentos organization das ferramentas para selecionar uma organização.
As implantações auto-hospedadas continuam usando tokens do SonarQube; o OAuth para SonarQube Server ainda não é compatível.
Endpoints de serviço
Ao executar no modo HTTP Streamable (http ou https), o servidor expõe alguns endpoints de serviço sem autenticação, além do endpoint MCP em /mcp. Eles destinam-se ao uso entre serviços (monitoramento, orquestração, verificações de compatibilidade de clientes) e não exigem um cabeçalho Authorization.
| Endpoint | Método | Descrição | Exemplo de resposta |
|---|---|---|---|
/health | GET | Verificação de atividade. Retorna 200 OK com um corpo vazio quando o servidor começa a aceitar solicitações. | (corpo vazio) |
/info | GET | Retorna a versão do servidor MCP como JSON. Útil para verificar a versão implantada do servidor. | {"version":"1.16.0"} |
Esses endpoints não estão disponíveis ao executar com o transporte Stdio.
Certificados personalizados
Se o seu SonarQube Server usar um certificado autoassinado ou um certificado de uma Autoridade Certificadora (CA) privada, você poderá adicionar certificados personalizados ao contêiner, onde serão instalados automaticamente.
Configuração
Usando uma montagem de volume
Monte um diretório que contenha seus certificados ao executar o contêiner:
docker run --init --pull=always -i --rm \
-v /path/to/your/certificates/:/usr/local/share/ca-certificates/:ro \
-e SONARQUBE_TOKEN="<token>" \
-e SONARQUBE_URL="<url>" \
sonarsource/sonarqube-mcp
Formatos de certificado compatíveis
O contêiner é compatível com os seguintes formatos de certificado:
- arquivos
.crt(codificados em PEM ou DER) - arquivos
.pem(codificados em PEM)
Configuração do MCP com certificados
Ao usar certificados personalizados, você pode modificar a configuração do MCP para montar os certificados:
{
"sonarqube": {
"command": "docker",
"args": [
"run",
"--init",
"--pull=always",
"-i",
"--rm",
"-v",
"/path/to/your/certificates/:/usr/local/share/ca-certificates/:ro",
"-e",
"SONARQUBE_TOKEN",
"-e",
"SONARQUBE_URL",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_TOKEN": "<token>",
"SONARQUBE_URL": "<url>"
}
}
}
Observação: Está executando o servidor a partir de um JAR em vez de usar o contêiner? A montagem de volume acima instala os certificados no repositório de confiança do sistema operacional do contêiner, que também é lido pelo servidor. Se não puder usar o repositório de confiança do sistema operacional — especialmente no Windows, onde ele não é consultado — aponte a JVM para um repositório de confiança Java que contenha o certificado da CA:
-Djavax.net.ssl.trustStore=/path/to/truststore.p12 -Djavax.net.ssl.trustStoreType=PKCS12 -Djavax.net.ssl.trustStorePassword=<passphrase>. Ele é adicionado aos certificados confiáveis padrão.
Proxy
O SonarQube MCP Server oferece suporte a proxies HTTP e SOCKS5 por meio das propriedades padrão do sistema de proxy do Java.
Configuração
Proxy HTTP/HTTPS
Você pode configurar as definições de proxy usando propriedades do sistema Java. Elas podem ser definidas como variáveis de ambiente ou passadas como argumentos da JVM.
Propriedades comuns de proxy:
| Propriedade | Descrição | Exemplo |
|---|---|---|
http.proxyHost | Nome do host do proxy HTTP | proxy.example.com |
http.proxyPort | Porta do proxy HTTP | 8080 |
https.proxyHost | Nome do host do proxy HTTPS | proxy.example.com |
https.proxyPort | Porta do proxy HTTPS | 8443 |
http.nonProxyHosts | Hosts que ignoram o proxy (separados por barra vertical) | localhost|127.0.0.1|*.internal.com |
Autenticação do proxy HTTP/HTTPS:
| Propriedade | Descrição | Exemplo |
|---|---|---|
http.proxyUser | Nome de usuário do proxy HTTP | myuser |
http.proxyPassword | Senha do proxy HTTP | mypassword |
https.proxyUser | Nome de usuário do proxy HTTPS | myuser |
https.proxyPassword | Senha do proxy HTTPS | mypassword |
Proxy SOCKS5
Há suporte a proxies SOCKS5.
| Propriedade | Descrição | Padrão | Exemplo |
|---|---|---|---|
socksProxyHost | Nome do host do proxy SOCKS5 | — | localhost |
socksProxyPort | Porta do proxy SOCKS5 | 1080 | 1080 |
java.net.socks.username | Nome de usuário SOCKS5 (se a autenticação for necessária) | — | myuser |
java.net.socks.password | Senha SOCKS5 (se a autenticação for necessária) | — | mypassword |
Certificado do cliente (TLS mútuo)
Se o seu SonarQube Server exigir que os clientes apresentem um certificado durante o handshake TLS (TLS mútuo), você poderá fornecer um keystore PKCS12 montando-o no contêiner e passando sua localização por meio de JAVA_OPTS.
Configuração
Usando um keystore PKCS12
Monte seu arquivo .p12 ou .pfx no contêiner e defina a variável de ambiente JAVA_OPTS com as propriedades do keystore:
docker run --init --pull=always -i --rm \
-v /path/to/client.p12:/etc/ssl/mcp/client.p12:ro \
-e JAVA_OPTS="-Djavax.net.ssl.keyStore=/etc/ssl/mcp/client.p12 -Djavax.net.ssl.keyStoreType=PKCS12 -Djavax.net.ssl.keyStorePassword=<passphrase>" \
-e SONARQUBE_TOKEN="<token>" \
-e SONARQUBE_URL="<url>" \
sonarsource/sonarqube-mcp
Observação: O arquivo de certificado precisa ser legível pelo processo do contêiner. Verifique e corrija as permissões, se necessário:
ls -la /path/to/client.p12 # look for -rw-r--r-- (644) or wider chmod 644 /path/to/client.p12 # grant read access to the container user
Omita -Djavax.net.ssl.keyStorePassword se o keystore não tiver uma frase secreta. Observe que a frase secreta usada aqui ficará visível por meio de docker inspect ou na lista de processos.
Configuração do MCP com um certificado do cliente
{
"sonarqube": {
"command": "docker",
"args": [
"run", "--init", "--pull=always", "-i", "--rm",
"-v", "/path/to/client.p12:/etc/ssl/mcp/client.p12:ro",
"-e", "JAVA_OPTS",
"-e", "SONARQUBE_TOKEN",
"-e", "SONARQUBE_URL",
"sonarsource/sonarqube-mcp"
],
"env": {
"JAVA_OPTS": "-Djavax.net.ssl.keyStore=/etc/ssl/mcp/client.p12 -Djavax.net.ssl.keyStoreType=PKCS12 -Djavax.net.ssl.keyStorePassword=<passphrase>",
"SONARQUBE_TOKEN": "<token>",
"SONARQUBE_URL": "<url>"
}
}
}
Usando um keystore PKCS12 com um JAR independente
Ao executar o servidor a partir de um JAR, passe as propriedades do keystore como argumentos da JVM antes de -jar:
java \
-Djavax.net.ssl.keyStore=/path/to/client.p12 \
-Djavax.net.ssl.keyStoreType=PKCS12 \
-Djavax.net.ssl.keyStorePassword=<passphrase> \
-jar <path_to_sonarqube_mcp_server_jar>
Omita -Djavax.net.ssl.keyStorePassword se o keystore não tiver uma frase secreta.
Configuração do MCP com um certificado do cliente (JAR)
{
"sonarqube": {
"command": "java",
"args": [
"-Djavax.net.ssl.keyStore=/path/to/client.p12",
"-Djavax.net.ssl.keyStoreType=PKCS12",
"-Djavax.net.ssl.keyStorePassword=<passphrase>",
"-jar",
"<path_to_sonarqube_mcp_server_jar>"
],
"env": {
"SONARQUBE_TOKEN": "<token>",
"SONARQUBE_URL": "<url>"
}
}
}
Observação: Os arquivos de certificado e chave PEM (arquivos separados
.crt/.key) precisam ser convertidos primeiro para o formato PKCS12. Useopenssl pkcs12 -export -in client.crt -inkey client.key -out client.p12para convertê-los.
Ferramentas
Análise
-
analyze_code_snippet - Analisa o conteúdo de arquivos com os analisadores do SonarQube para identificar problemas de qualidade e segurança do código. Sempre analisa o conteúdo completo do arquivo para garantir a precisão. Opcionalmente, filtra os resultados para um trecho de código específico.
Obsoleto:
analyze_code_snippetserá removido em uma versão futura. Conecte o SonarQube for IDE para usaranalyze_file_list, ou habilite a análise do Vortex para sua organização para usarrun_advanced_code_analysis(veja abaixo).Uso:
- Com workspace montado (recomendado): passe
filePath(relativo ao projeto) — o servidor lê o arquivo diretamente, mantendo o conteúdo do arquivo fora da janela de contexto do agente - Sem workspace montado: passe o
fileContentcompleto para analisar o arquivo inteiro (relata todos os problemas) - Adicione
codeSnippetopcional para filtrar os resultados — somente os problemas dentro do trecho serão relatados (localização do trecho detectada automaticamente)
Parâmetros:
organization- Chave da organização do SonarQube Cloud - String opcional, somente CloudprojectKey- Chave do projeto do SonarQube - String obrigatória (Ignorada quandoSONARQUBE_PROJECT_KEYestiver definido)filePath- Caminho relativo ao projeto do arquivo a ser analisado (por exemplo,src/main/java/MyClass.java). Usado quando o workspace está montado em/app/mcp-workspace- StringfileContent- Conteúdo completo do arquivo como uma string. Obrigatório quando o workspace não está montado - StringcodeSnippet- Trecho de código para filtrar problemas (deve corresponder ao conteúdo de fileContent) - Stringlanguage- Linguagem do código (por exemplo, 'java', 'python', 'js', 'ts', 'tsx', 'jsx') - Stringscope- Escopo do arquivo: MAIN ou TEST (padrão: MAIN) - String
Linguagens compatíveis: Java, Kotlin, Python, Ruby, Go, JavaScript (
js,jsx), TypeScript (ts,tsx), JSP, PHP, XML, HTML, CSS, CloudFormation, Kubernetes, Terraform, Azure Resource Manager, Ansible, Docker, detecção de segredos - Com workspace montado (recomendado): passe
Quando a integração com o SonarQube for IDE estiver habilitada: (essas duas ferramentas são marcadas nos conjuntos de ferramentas analysis e ide)
-
analyze_file_list - Analisa arquivos no diretório de trabalho atual usando o SonarQube for IDE. Esta ferramenta se conecta a uma instância em execução do SonarQube for IDE para realizar uma análise de qualidade do código em uma lista de arquivos.
file_absolute_paths- Lista de caminhos absolutos dos arquivos a serem analisados - String[] obrigatório
-
toggle_automatic_analysis - Habilita ou desabilita a análise automática do SonarQube for IDE. Quando habilitada, o SonarQube for IDE analisa automaticamente os arquivos à medida que são modificados no diretório de trabalho. Quando desabilitada, a análise automática é desativada.
enabled- Habilita ou desabilita a análise automática - Boolean obrigatório
No SonarQube Server, stdio lista as ferramentas de contexto do Vortex e run_advanced_code_analysis quando os hubs CAG e A3S têm direito de uso.
Quando a análise do Vortex estiver disponível:
Requer que o workspace esteja montado em
/app/mcp-workspace
- run_advanced_code_analysis - Executa a análise do Vortex em um único arquivo. O SonarQube Server usa o placeholder nil UUID.
organization- Chave da organização do SonarQube Cloud - String opcional, somente CloudprojectKey- Chave do projeto - String obrigatória (Ignorada quandoSONARQUBE_PROJECT_KEYestiver definido)branch- Nome da branch usado para recuperar o contexto da análise mais recente - String obrigatóriofilePath- Caminho relativo ao projeto do arquivo a ser analisado (por exemplo,src/main/java/MyClass.java). - String obrigatóriofileScope- Define o escopo de origem do arquivo: 'MAIN' ou 'TEST' (padrão: MAIN) - String
Cobertura
-
search_files_by_coverage - Pesquisa arquivos em um projeto, ordenados por cobertura (crescente — primeiro a pior cobertura). Esta ferramenta ajuda a identificar arquivos que precisam de melhorias na cobertura de testes.
projectKey- Chave do projeto a pesquisar - String obrigatória (Ignorada quandoSONARQUBE_PROJECT_KEYestiver definido)branch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - StringmaxCoverage- Limite máximo de cobertura (0-100). Retorna somente arquivos com cobertura <= este valor - NumberpageIndex- Índice da página (baseado em 1, padrão: 1) - NumberpageSize- Tamanho da página (padrão: 100, máximo: 500) - Number
-
get_file_coverage_details - Obtém informações de cobertura linha por linha de um arquivo específico, incluindo as linhas exatas sem cobertura e as que têm branches parcialmente cobertas. Esta ferramenta ajuda a identificar precisamente onde adicionar cobertura de testes. Use-a após identificar arquivos com baixa cobertura por meio de search_files_by_coverage.
key- Chave do arquivo (por exemplo, my_project:src/foo/Bar.java) - String obrigatóriabranch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - Stringfrom- Primeira linha a analisar (baseada em 1, padrão: 1) - Numberto- Última linha a analisar (inclusiva). Se não especificada, todas as linhas serão retornadas - Number
Riscos de dependências
Observação: os riscos de dependências exigem o SonarQube Advanced Security. No SonarQube Server, é necessária a versão 2025.4 Enterprise ou superior.
- search_dependency_risks - Pesquisa problemas de análise de composição de software (riscos de dependências) de um projeto do SonarQube, associados a versões presentes no projeto, aplicativo ou portfólio analisado.
organization- Chave da organização do SonarQube Cloud - String opcional, somente CloudprojectKey- Chave do projeto - String obrigatória (Ignorada quandoSONARQUBE_PROJECT_KEYestiver definido)branch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - StringpageIndex- Índice opcional da página (baseado em 1, padrão: 1) - IntegerpageSize- Tamanho opcional da página. Deve ser maior que 0 e menor ou igual a 500 (padrão: 100) - Integer
Empresas
Observação: as empresas estão disponíveis somente ao se conectar ao SonarQube Cloud.
- list_enterprises - Lista as empresas disponíveis no SonarQube Cloud às quais você tem acesso. Use esta ferramenta para descobrir IDs de empresas que podem ser usados com outras ferramentas.
enterpriseKey- Chave opcional da empresa para filtrar os resultados - String
Problemas
-
change_sonar_issue_status - Altera o status de um problema do SonarQube para "accept", "falsepositive" ou "reopen".
key- Chave do problema - String obrigatóriastatus- Novo status do problema - Enum obrigatório {"accept", "falsepositive", "reopen"}comment- Comentário opcional explicando a alteração de status - String
-
search_sonar_issues_in_projects - Pesquisa problemas do SonarQube nos projetos da minha organização.
organization- Chave da organização do SonarQube Cloud - String opcional, somente CloudprojectKeys- Lista opcional de chaves de projetos do SonarQube - String[]branch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - Stringseverities- Lista opcional de severidades para filtrar. Valores possíveis: INFO, LOW, MEDIUM, HIGH, BLOCKER - String[]impactSoftwareQualities- Lista opcional de qualidades de software para filtrar. Valores possíveis: MAINTAINABILITY, RELIABILITY, SECURITY - String[]issueStatuses- Lista opcional de status de problemas para filtrar. Valores possíveis: OPEN, CONFIRMED, FALSE_POSITIVE, ACCEPTED, FIXED, IN_SANDBOX - String[]tags- Lista opcional de tags de problemas para filtrar. As tags estão em letras minúsculas - String[]inNewCodePeriod- Retorna somente problemas no período de código novo. Exige exatamente uma entrada entreprojectKeysefiles- BooleanissueKey- Chave opcional do problema para buscar um problema específico - StringpageIndex- Índice opcional da página, baseado em 1 (padrão: 1) - IntegerpageSize- Tamanho opcional da página. Deve ser maior que 0 e menor ou igual a 500 (padrão: 100) - Integer
Hotspots de segurança
-
search_security_hotspots - Pesquisa hotspots de segurança em um projeto do SonarQube.
projectKey- Chave do projeto ou aplicativo - String obrigatória (Ignorada quandoSONARQUBE_PROJECT_KEYestiver definido)hotspotKeys- Lista separada por vírgulas de chaves específicas de hotspots de segurança a recuperar - String[]branch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - Stringfiles- Lista opcional de caminhos de arquivos para filtrar - String[]status- Filtro opcional de status: TO_REVIEW, REVIEWED - Stringresolution- Filtro opcional de resolução: FIXED, SAFE, ACKNOWLEDGED - StringsinceLeakPeriod- Filtra hotspots criados desde o período de referência (código novo) - BooleanonlyMine- Mostra somente hotspots atribuídos a mim - BooleanpageIndex- Índice opcional da página, baseado em 1 (padrão: 1) - IntegerpageSize- Tamanho opcional da página. Deve ser maior que 0 e menor ou igual a 500 (padrão: 100) - Integer
-
show_security_hotspot - Obtém informações detalhadas sobre um hotspot de segurança específico, incluindo detalhes da regra, contexto do código, fluxos e comentários.
hotspotKey- Chave do hotspot de segurança - String obrigatória
-
change_security_hotspot_status - Revisa um hotspot de segurança alterando seu status. Ao marcá-lo como REVIEWED, é necessário especificar uma resolução (FIXED, SAFE ou ACKNOWLEDGED).
hotspotKey- Chave do hotspot de segurança - String obrigatóriastatus- Novo status - Enum obrigatório {"TO_REVIEW", "REVIEWED"}resolution- Resolução quando o status for REVIEWED - Enum {"FIXED", "SAFE", "ACKNOWLEDGED"}comment- Comentário opcional da revisão - String
Linguagens
- list_languages - Lista todas as linguagens de programação compatíveis com esta instância do SonarQube.
q- Padrão opcional para corresponder às chaves/nomes das linguagens - String
Métricas
- get_component_measures - Obtém métricas do SonarQube para um componente (projeto, diretório, arquivo).
projectKey- Chave do projeto - String obrigatória quandoSONARQUBE_PROJECT_KEYnão estiver configuradobranch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringmetricKeys- Chaves opcionais das métricas a recuperar (por exemplo, ncloc, complexity, violations, coverage) - String[]pullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - String
Métricas
- search_metrics - Pesquisa métricas do SonarQube.
pageIndex- Índice opcional da página, baseado em 1 (padrão: 1) - IntegerpageSize- Tamanho opcional da página. Deve ser maior que 0 e menor ou igual a 500 (padrão: 100) - Integer
Portfólios
-
list_portfolios - Lista portfólios empresariais disponíveis no SonarQube, com opções de filtragem e paginação.
Para SonarQube Server:
q- Consulta de pesquisa opcional para filtrar portfólios por nome ou chave - Stringfavorite- Se true, retorna somente portfólios favoritos - BooleanpageIndex- Número opcional da página, baseado em 1 (padrão: 1) - IntegerpageSize- Tamanho opcional da página, máximo de 500 (padrão: 100) - Integer Para SonarQube Cloud:enterpriseId- UUID da empresa. Pode ser omitido somente se o parâmetro 'favorite' for fornecido com o valor true - Stringq- Consulta de pesquisa opcional para filtrar portfólios por nome - Stringfavorite- Deve ser true se o parâmetro 'enterpriseId' for omitido. Se true, retorna somente os portfólios favoritados pelo usuário conectado. Não pode ser true quando 'draft' for true - Booleandraft- Se true, retorna somente os rascunhos criados pelo usuário conectado. Não pode ser true quando 'favorite' for true - BooleanpageIndex- Índice opcional da página a buscar (padrão: 1) - IntegerpageSize- Tamanho opcional da página a buscar (padrão: 50) - Integer
Projetos
-
list_organizations - Lista as organizações do SonarQube Cloud das quais um usuário é membro, incluindo chaves, nomes, IDs e UUIDs. Use uma chave retornada como
organizationem ferramentas subsequentes. -
search_my_sonarqube_projects - Encontra projetos do SonarQube. A resposta é paginada.
organization- Chave da organização do SonarQube Cloud - Optional String, Cloud onlypageIndex- Índice opcional da página, começando em 1 (padrão: 1) - IntegerpageSize- Tamanho opcional da página. Deve ser maior que 0 e menor ou igual a 500 (padrão: 500) - Integerq- Consulta de pesquisa opcional para filtrar projetos por nome (correspondência parcial) ou chave (correspondência exata) - String
-
list_branches - Lista as branches analisadas de um projeto.
- SonarQube Cloud: retorna branches de longa duração (
LONG) e de curta duração (SHORT) com os campostypeemergeBranch. Filtro opcionalbranchTypes:ALL(padrão),LONGouSHORT. - SonarQube Server: retorna todas as branches analisadas (nome, quality gate, data da análise). Não há filtro
type,mergeBranchoubranchTypes. - Use os nomes de branches retornados como parâmetro
branchem outras ferramentas. Para análise de pull request, uselist_pull_requests. projectKey- Chave do projeto (por exemplo, my_project) - Required String (Ignorado quandoSONARQUBE_PROJECT_KEYestá definido)branchTypes- (Somente SonarQube Cloud) Filtro opcional:ALL(padrão),LONGouSHORT- Enum {"ALL", "LONG", "SHORT"}
- SonarQube Cloud: retorna branches de longa duração (
-
list_pull_requests - Lista todas as pull requests de um projeto. Use esta ferramenta para descobrir pull requests de análises com decoração de PR (cobertura, problemas, quality gate). Retorna a chave/ID da pull request, que pode ser usada com outras ferramentas. Para análises baseadas em branches sem pull requests, use
list_branches.projectKey- Chave do projeto (por exemplo, my_project) - Required String (Ignorado quandoSONARQUBE_PROJECT_KEYestá definido)
Quality Gates
-
get_project_quality_gate_status - Obtém o status do Quality Gate do projeto SonarQube.
analysisId- ID opcional da análise - Stringbranch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringprojectId- ID opcional do projeto - StringprojectKey- Chave opcional do projeto - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - String
-
list_quality_gates - Lista todos os quality gates no meu SonarQube.
organization- Chave da organização do SonarQube Cloud - Optional String, Cloud only
Regras
- show_rule - Exibe informações detalhadas sobre uma regra do SonarQube.
organization- Chave da organização do SonarQube Cloud - Optional String, Cloud onlykey- Chave da regra - Required String
Duplicações
-
search_duplicated_files - Pesquisa arquivos com duplicações de código em um projeto SonarQube. Por padrão, busca automaticamente todos os arquivos duplicados em todas as páginas (até o máximo de 10.000 arquivos). Retorna somente arquivos com duplicações.
projectKey- Chave do projeto - Required String (Ignorado quandoSONARQUBE_PROJECT_KEYestá definido)branch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - StringpageSize- Número opcional de resultados por página para paginação manual (máx.: 500). Se não for especificado, busca automaticamente todos os arquivos duplicados - IntegerpageIndex- Número opcional da página para paginação manual (começa em 1). Se não for especificado, busca automaticamente todos os arquivos duplicados - Integer
-
get_duplications - Obtém as duplicações de um arquivo. Requer permissão Browse no projeto do arquivo.
key- Chave do arquivo - Required Stringbranch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - String
Fontes
-
get_raw_source - Obtém o código-fonte como texto bruto do SonarQube. Requer a permissão 'See Source Code' no arquivo.
key- Chave do arquivo - Required Stringbranch- Nome opcional da branch para análise baseada em branch. Uselist_branchespara descobrir nomes válidos - StringpullRequest- Chave/ID opcional da pull request. Uselist_pull_requestspara descobrir chaves válidas - String
-
get_scm_info - Obtém informações de SCM dos arquivos-fonte do SonarQube. Requer a permissão See Source Code no projeto do arquivo.
key- Chave do arquivo - Required Stringcommits_by_line- Agrupa as linhas por commit de SCM se o valor for false; caso contrário, exibe os commits de cada linha - Stringfrom- Primeira linha a retornar. Começa em 1 - Numberto- Última linha a retornar (inclusiva) - Number
Sistema
Observação: as ferramentas do sistema só estão disponíveis ao conectar-se ao SonarQube Server.
-
get_system_health - Obtém o status de integridade da instância do SonarQube Server. Retorna GREEN (totalmente operacional), YELLOW (utilizável, mas requer atenção) ou RED (não operacional).
-
get_system_info - Obtém informações detalhadas sobre a configuração do sistema SonarQube Server, incluindo estado da JVM, banco de dados, índices de pesquisa e configurações. Requer permissões 'Administer'.
-
get_system_logs - Obtém os logs do sistema SonarQube Server em formato de texto simples. Requer permissão de administração do sistema.
name- Nome opcional dos logs a obter. Valores possíveis: access, app, ce, deprecation, es, web. Padrão: app - String
-
ping_system - Envia um ping ao sistema SonarQube Server para verificar se está ativo. Retorna 'pong' como texto simples.
-
get_system_status - Obtém informações sobre o estado do SonarQube Server. Retorna status (STARTING, UP, DOWN, RESTARTING, DB_MIGRATION_NEEDED, DB_MIGRATION_RUNNING), versão e id.
Webhooks
-
create_webhook - Cria um novo webhook para a organização ou projeto do SonarQube. Requer a permissão 'Administer' no projeto especificado ou a permissão global 'Administer'.
organization- Chave da organização do SonarQube Cloud - Optional String, Cloud onlyname- Nome do webhook - Required Stringurl- URL do webhook - Required StringprojectKey- Chave opcional do projeto para webhook específico do projeto - Stringsecret- Segredo opcional do webhook para proteger o payload do webhook - String
-
list_webhooks - Lista todos os webhooks da organização ou do projeto do SonarQube. Requer a permissão 'Administer' no projeto especificado ou a permissão global 'Administer'.
organization- Chave da organização do SonarQube Cloud - Optional String, Cloud onlyprojectKey- Chave opcional do projeto para listar webhooks específicos do projeto - String
Aumento de contexto
Ferramentas de arquitetura
-
search_by_signature_patterns - Encontra elementos de código (classes, métodos, interfaces, ...) por suas assinaturas de declaração usando padrões regex.
include_code_regex_list- Lista de padrões regex para comparar com as assinaturas - Required String[]exclude_code_regex_list- Lista de padrões regex a excluir dos resultados - String[]include_glob- Padrão glob de filtro de arquivos (por exemplo,*.java) - Stringexclude_glob- Padrão glob de exclusão de arquivos - Stringfields- Lista separada por vírgulas dos campos a incluir na resposta - Stringlimit- Número máximo de resultados a retornar (padrão: 10) - Integerregex_lists_operator- Como combinar vários padrões:OR(padrão) ouAND- String
-
search_by_body_patterns - Encontra elementos de código por seus corpos de implementação usando padrões regex. Útil para localizar onde APIs ou padrões são realmente usados.
include_code_regex_list- Lista de padrões regex para comparar com os corpos do código - Required String[]exclude_code_regex_list- Lista de padrões regex a excluir dos resultados - String[]include_glob- Padrão glob de filtro de arquivos - Stringexclude_glob- Padrão glob de exclusão de arquivos - Stringfields- Lista separada por vírgulas dos campos a incluir na resposta - Stringlimit- Número máximo de resultados a retornar (padrão: 10) - Integerregex_lists_operator- Como combinar vários padrões:OR(padrão) ouAND- String
-
get_upstream_call_flow - Rastreia quais funções chamam uma determinada função. Útil para encontrar todos os chamadores e pontos de entrada, e entender o que pode falhar se uma assinatura mudar.
fqn- Nome totalmente qualificado da função - Required Stringdepth- Profundidade da cadeia de chamadas (0=somente função, 1=chamadores diretos etc.) - Integerfields- Lista separada por vírgulas dos campos a incluir na resposta - String
-
get_downstream_call_flow - Rastreia quais funções são chamadas por uma determinada função. Útil para análise de impacto e para entender o fluxo de execução.
fqn- Nome totalmente qualificado da função - Required Stringdepth- Profundidade da cadeia de chamadas (0=somente função, 1=funções chamadas diretamente etc.) - Integerfields- Lista separada por vírgulas dos campos a incluir na resposta - String
-
get_source_code - Obtém o código-fonte completo (assinatura e corpo) de um elemento de código pelo nome totalmente qualificado.
fqn- Nome totalmente qualificado do elemento - Required Stringfields- Lista separada por vírgulas dos campos a incluir na resposta - String
-
get_type_hierarchy - Obtém a hierarquia completa de herança de uma estrutura semelhante a uma classe (classe, interface, enum, record, exceção, struct). Essencial para entender árvores de herança e refatorar.
fqn- Nome totalmente qualificado da estrutura semelhante a uma classe - Required Stringfields- Lista separada por vírgulas dos campos a incluir na resposta - String
-
get_references - Obtém referências diretas de código de entrada e saída para uma classe ou módulo. Retorna somente referências diretas (não transitivas).
fqn- Nome totalmente qualificado da classe ou módulo - Required Stringfields- Lista separada por vírgulas dos campos a incluir na resposta - String
-
get_current_architecture - Obtém um grafo hierárquico da arquitetura filtrado por prefixo de caminho e profundidade. Útil para explorar a estrutura dos módulos e dependências de alto nível.
depth- Profundidade da hierarquia (0=somente raiz, 1=raiz + filhos etc.) - Required Integerpath_prefix- Prefixo de caminho opcional para filtrar nós (por exemplo,com.example.service) - Stringecosystem- Ecossistema opcional para filtrar por (java,cs,py,js,ts) - String
-
get_intended_architecture - Obter as restrições arquiteturais definidas pelo usuário, especificando quais módulos podem depender de outros.
Ferramentas de diretrizes
- get_guidelines - Obter diretrizes de codificação com base em problemas do projeto no SonarQube, categorias do catálogo ou uma combinação de ambos.
mode- Modo de recuperação de diretrizes:project_based,category_basedoucombined- String obrigatóriocategories- Lista de nomes de categorias (obrigatória para os modoscategory_basedecombined) - String[]languages- Lista de linguagens de destino no formato de chave de repositório do SonarQube (obrigatória quandocategoriesé fornecido) - String[]file_paths- Lista opcional de caminhos de arquivo para filtrar as diretrizes - String[]
Ferramentas de dependências de terceiros
- check_dependency - Verificar uma dependência de terceiros quanto a vulnerabilidades de segurança, malware na cadeia de suprimentos e conformidade de licenças antes de adicioná-la ou atualizá-la.
purl- Package URL (purl) com versão, conforme purl-spec. Formato:pkg:<type>/<namespace>/<name>@<version>(por exemplo,pkg:npm/lodash@4.17.21,pkg:maven/org.apache.logging.log4j/log4j-core@2.14.1,pkg:pypi/django@3.2.0) - String obrigatório
Variáveis de ambiente de Context Augmentation
| Variável | Descrição | Obrigatória | Padrão |
|---|---|---|---|
SONARQUBE_URL | URL do SonarQube Cloud | Sim | https://sonarcloud.io |
SONARQUBE_TOKEN | Token de autenticação | Sim | Nenhum |
SONARQUBE_ORG | Organização na nuvem; passada ao proxy pela configuração de inicialização ou detecção exclusiva | Não | Nenhum |
SONARQUBE_PROJECT_KEY | Chave do projeto no SonarQube Cloud | Sim | Nenhum |
SONAR_SQ_BRANCH | Substituição explícita da branch do SonarQube * | Não | Nenhum |
SONARQUBE_DEBUG_ENABLED | Ativar registro de depuração (para solução de problemas) | Não | False |
SONAR_LOG_LEVEL | Nível de detalhamento do registro (TRACE, DEBUG, INFO, WARNING, ERROR) | Não | INFO |
- Deve ser fornecida quando o git não estiver sendo usado ou quando o nome da branch do git não corresponder ao nome da branch no SonarQube.
Configuração específica do projeto (recomendada)
Primeiro, exporte a SONARQUBE_TOKEN variável de ambiente com um Personal Access Token (PAT) válido para seu projeto.
# macOS/Linux (Bash/Zsh)
export SONARQUBE_TOKEN="{<YourUserToken>}"
Em seguida, monte o workspace do projeto para dar ao servidor Context Augmentation acesso direto aos seus arquivos de origem:
{
"mcpServers": {
"sonarqube-mcp-server": {
"command": "docker",
"args": [
"run", "-i", "--rm", "--pull=always",
"-e", "SONARQUBE_URL",
"-e", "SONARQUBE_TOKEN",
"-e", "SONARQUBE_ORG",
"-e", "SONARQUBE_PROJECT_KEY",
"-e", "SONARQUBE_TOOLSETS",
"-v", "/ABSOLUTE/PATH/TO/YOUR/PROJECT:/app/mcp-workspace:rw",
"sonarsource/sonarqube-mcp"
],
"env": {
"SONARQUBE_URL": "https://sonarcloud.io",
"SONARQUBE_ORG": "<YourOrganizationKey>",
"SONARQUBE_PROJECT_KEY": "<YourProjectKey>",
"SONARQUBE_TOOLSETS": "cag"
}
}
}
}
Importante: em uma configuração com escopo de projeto, não coloque SONARQUBE_TOKEN no bloco env. Exporte-a como variável de ambiente (export SONARQUBE_TOKEN=...). O Docker a encaminhará para o contêiner por meio de -e SONARQUBE_TOKEN.
Prontidão para agentes
Observação: as ferramentas de prontidão para agentes estão disponíveis apenas no SonarQube Cloud e exigem que o recurso esteja habilitado para sua organização.
O sinalizador do recurso é verificado na inicialização no modo stdio. Em HTTP/HTTPS, adicione agentic-readiness ao SONARQUBE_TOOLSETS do servidor para habilitar as ferramentas.
-
start_agentic_readiness_assessment - Iniciar uma avaliação de prontidão para agentes de um projeto. Retorna imediatamente com o status
PENDINGe umassessmentId. Useget_agentic_readiness_assessmentpara consultar os resultados.projectKey- A chave do projeto - String obrigatório (Ignorada quandoSONARQUBE_PROJECT_KEYestá definido)branch- Branch a avaliar. Omita para usar a branch padrão do projeto - String
-
get_agentic_readiness_assessment - Recuperar o resultado de uma avaliação. Chame novamente com o mesmo
assessmentIdaté que o status sejaCOMPLETED,FAILEDouINTERRUPTED. Quando concluída, retorna o nível geral e uma análise por pilar, com ações recomendadas e evidências.assessmentId- O ID da avaliação retornado porstart_agentic_readiness_assessment- String obrigatório
-
list_agentic_readiness_assessments - Listar todas as avaliações de um projeto, começando pela mais recente. Use
get_agentic_readiness_assessmentpara obter resultados completos por pilar.projectKey- A chave do projeto cujas avaliações serão listadas - String obrigatório (Ignorada quandoSONARQUBE_PROJECT_KEYestá definido)branch- Filtrar avaliações pelo nome da branch. Omita para listar avaliações de todas as branches - StringpageIndex- Índice da página, começando em 1 (padrão: 1) - NumberpageSize- Número de itens por página, máximo de 100 (padrão: 50) - Number
Arquitetura
Observação: habilite estas ferramentas com SONARQUBE_TOOLSETS=architecture no modo stdio ou HTTP/HTTPS. O SonarQube Cloud exige um plano Team ou Enterprise. O SonarQube Server exige a versão 2026.6 ou posterior e a edição Developer ou superior; as ferramentas não estão disponíveis em versões anteriores nem no Community Build. Consulte fluxos de trabalho de arquitetura e recuperação.
-
architecture_get - Ler dependências atuais, arquitetura pretendida, diretivas do projeto ou Findings (desvios, falhas e problemas de qualidade).
target-current,intended,directivesoufindings; a disponibilidade depende da compilação do MCP e do Server - Enum obrigatórioprojectKey- A chave do projeto - String obrigatório (Ignorada quandoSONARQUBE_PROJECT_KEYestá definido)organization- Chave da organização do SonarQube Cloud quando nenhuma estiver configurada - String opcional, somente Cloudcomponent- Chave exata do nó atual ou caminho do grupo pretendido; nível superior quando omitido - Stringdepth- Somente atual/pretendida: níveis abaixo do início; padrão 1 para atual, todos para pretendida - Numberlanguage- Somente atual/pretendida/findings:java,cs,js,tsoupy- EnumdirectiveId- Diretiva completa por UUID, incluindo descrição; use em vez da paginação - Stringcategory/type- Somente Findings: filtrar desvios, falhas ou problemas de qualidade pelo tipo anunciado - EnumpageIndex- Diretivas/Findings: índice da página, começando em 1 (padrão: 1) - NumberpageSize- Diretivas: resumos, padrão/máximo de 50. Findings: padrão de 50, máximo de 1000; 0 retorna apenas a contagem - Number
-
architecture_set - Substituir toda a arquitetura pretendida ou criar, atualizar e excluir diretivas do projeto. Disponível em compilações compatíveis do Cloud e do Server quando as gravações estão habilitadas.
target-intendedoudirectives- Enum obrigatórioprojectKey- A chave do projeto - String obrigatório (Ignorada quandoSONARQUBE_PROJECT_KEYestá definido)organization- Chave da organização do SonarQube Cloud quando nenhuma estiver configurada - String opcional, somente Cloudmodel- String JSON: exportação completa da arquitetura pretendida ou matrizmodels(o conteúdo omitido é removido), ou alterações nas diretivas com matrizescreate,updateedelete- String obrigatóriodryRun-truepara visualizar,falsepara aplicar - Boolean obrigatóriorevision- Somente arquitetura pretendida: revisão dearchitecture_get; o padrão é a revisão da exportação completa. Obrigatório ao aplicar uma limpeza - String
Exemplos de prompts
Depois de configurar o SonarQube MCP Server, veja alguns exemplos de prompts para cenários comuns do mundo real:
Corrigir uma Quality Gate com falha
My quality gate is failing for my project. Can you help me understand why and fix the most critical issues?
The quality gate on my feature branch is red. What do I need to fix to get it passing before I can merge to main?
Verificações antes de uma versão e de um merge
I'm about to merge my pull request <#247> for the <web-app> project. Can you check if there are any quality issues I should address first?
We're deploying to production tomorrow. Can you check the quality gate status and alert me to any critical issues in this branch?
Melhorar a qualidade do código
I want to reduce technical debt in my project. What are the top issues I should prioritize?
Our code coverage dropped below 70%. Can you identify which files have the lowest coverage and help me improve it?
Entender e corrigir problemas
I have 15 new code smells in my latest commit. Can you explain what they are and help me fix them?
SonarQube flagged a critical security vulnerability in <AuthController.java>. What's the issue and how do I fix it?
Segurança e gerenciamento de dependências
We need to pass a security audit. Can you check all our projects for security vulnerabilities and create a prioritized list of what needs to be fixed?
Are there any known vulnerabilities in our dependencies? Check this project for dependency risks.
Assistência para revisão de código
I just wrote this authentication function. Can you analyze it for security issues and code quality problems before I commit?
Review the changes in <src/database/migrations> for any potential bugs or security issues.
Monitoramento da integridade do projeto
Give me a health report for my project: quality gate status, number of bugs, Security Hotspots, and code coverage.
Compare code quality between our main branch and the develop branch. Are we introducing new issues?
Colaboração em equipe
What are the most common rule violations across all our projects? We might need to update our coding standards.
Show me all the issues that were marked as false positives in the last month. Are we seeing patterns that suggest our rules need adjustment?
Compilação
Prefira a imagem de contêiner sonarsource/sonarqube-mcp.
Para executar o servidor como um JAR independente sem Docker, baixe uma versão pré-compilada do repositório de binários da SonarSource. Cada versão lançada é publicada lá como sonarqube-mcp-server-<version>.jar (por exemplo, sonarqube-mcp-server-1.19.0.2785.jar).
Executar a partir de um JAR
Baixe o JAR da versão desejada no repositório de binários e configure seu cliente MCP para executá-lo com Java 21 ou posterior:
- Para conectar ao SonarQube Cloud:
{
"sonarqube": {
"command": "java",
"args": [
"-jar",
"<path_to_sonarqube_mcp_server_jar>"
],
"env": {
"STORAGE_PATH": "<path_to_your_mcp_storage>",
"SONARQUBE_TOKEN": "<token>",
"SONARQUBE_ORG": "<org>"
}
}
}
- Para conectar ao SonarQube Server:
{
"sonarqube": {
"command": "java",
"args": [
"-jar",
"<path_to_sonarqube_mcp_server_jar>"
],
"env": {
"STORAGE_PATH": "<path_to_your_mcp_storage>",
"SONARQUBE_TOKEN": "<token>",
"SONARQUBE_URL": "<url>"
}
}
}
Compilar a partir do código-fonte
O SonarQube MCP Server exige um Java Development Kit (JDK) versão 21 ou posterior para ser compilado.
Execute o seguinte comando Gradle para limpar o projeto e compilar o aplicativo:
./gradlew clean build -x test
O arquivo JAR será criado em build/libs/.
Depois de adicionar ou atualizar dependências, gere novamente os arquivos de lock:
./gradlew :dependencies --write-locks
./gradlew :its:dependencies --write-locks
Use a configuração Executar a partir de um JAR acima, apontando <path_to_sonarqube_mcp_server_jar> para o JAR em build/libs/.
Solução de problemas
Por padrão, os registros do aplicativo são gravados no arquivo STORAGE_PATH/logs/mcp.log. Para desativar completamente o registro em arquivo, defina SONARQUBE_LOG_TO_FILE_DISABLED=true.
Problemas comuns
"A versão do servidor SonarQube não é compatível"
O servidor MCP verifica a versão do SonarQube Server conectado durante a inicialização. Se a instância for anterior à 2025.1 (SQS) ou à 25.1 (SQCB), a inicialização falhará com:
SonarQube server version is not supported, minimal version is SQS 2025.1 or SQCB 25.1
Solução: atualize o SonarQube Server para uma versão compatível. Essa verificação se aplica somente ao conectar ao SonarQube Server (SONARQUBE_URL sem SONARQUBE_ORG), não ao SonarQube Cloud.
"O recurso não está funcionando" ou "Ferramentas/funcionalidades ausentes"
Você pode estar usando uma imagem Docker desatualizada. O Docker armazena imagens em cache localmente, então você não receberá atualizações automaticamente.
Solução: atualize para a versão mais recente:
docker pull sonarsource/sonarqube-mcp
Depois de baixar a imagem mais recente, reinicie seu cliente MCP para usar a versão atualizada.
Opcionalmente, adicione o sinalizador --pull=always ao comando docker run para sempre verificar e baixar a versão mais recente:
docker run --init --pull=always -i --rm -e SONARQUBE_TOKEN -e SONARQUBE_ORG sonarsource/sonarqube-mcp
"Quero fixar uma versão específica"
Consulte as tags disponíveis em sonarsource/sonarqube-mcp e indique a versão desejada:
docker pull sonarsource/sonarqube-mcp:1.19.0.2785
docker run --init -i --rm \
-e SONARQUBE_TOKEN -e SONARQUBE_ORG \
sonarsource/sonarqube-mcp:1.19.0.2785
Na configuração do cliente MCP, use sonarsource/sonarqube-mcp:<version> em vez de sonarsource/sonarqube-mcp e remova --pull=always para que o Docker não atualize a imagem silenciosamente.
Dados e telemetria
Este servidor coleta dados de uso anônimos e os envia à SonarSource para ajudar a melhorar o produto. Nenhum código-fonte ou endereço IP é coletado, e a SonarSource não compartilha os dados com ninguém. A coleta de telemetria pode ser desativada com a seguinte propriedade do sistema ou variável de ambiente: TELEMETRY_DISABLED=true. Clique aqui para ver uma amostra dos dados coletados.
Licença
Copyright 2025 SonarSource.
Licenciado sob a SONAR Source-Available License v1.0. O uso do SonarQube MCP Server em conformidade com esta documentação é uma Finalidade Não Competitiva e, portanto, é permitido sob a SSAL.
Seu uso do SonarQube via MCP é regido pelos Termos de Serviço do SonarQube Cloud ou pelos Termos e Condições do SonarQube Server, incluindo o uso dos Dados de Resultados exclusivamente para fins internos de desenvolvimento de software.