sonar-mcp-server

Servidor MCP de solo lectura para SonarQube Community Build 26.4+ autoalojado. Permite que agentes de IA (Claude Code, Cursor, Copilot) listen proyectos, problemas y hotspots de seguridad, profundicen en un hallazgo, obtengan la explicación de la regla y el fragmento de código fuente alrededor — todo lo necesario para el ciclo de "leer hallazgos de Sonar, corregir el código localmente". 13 herramientas enfocadas, sin endpoints de escritura. Java, stdio, imagen Docker en GHCR.

GitHubPrueba este MCPPatrocinado

Documentación

Servidor MCP de Sonar

Un servidor MCP local que proporciona acceso de solo lectura a una instancia de SonarQube Community Build (26.4+) a través de su web-api. Permite que agentes de IA (Claude Code, Cursor, VS Code Copilot, etc.) obtengan la lista de incidencias de un proyecto, los archivos y ubicaciones donde ocurren, descripciones de reglas, fragmentos de código fuente alrededor de las incidencias y Security Hotspots.

Escenario típico: "encontrar y corregir incidencias de Sonar en tal proyecto" — el LLM llama a listIssues, opcionalmente getRule y getIssueSnippets, y edita los archivos localmente.

Por qué este servidor

Existe un servidor MCP oficial de SonarSource, pero está dirigido a SonarQube 10+ (y SonarCloud) y asume un despliegue de estilo cloud. Este servidor está construido para instalaciones autogestionadas de SonarQube Community Build 26.4+ que exponen la web-api clásica /api/. Soporta tanto Standard Experience como modo MQR, manejando los impactos por calidad de software cuando la instancia funciona en modo MQR.

También es intencionalmente más limitado en alcance:

Solo lectura por diseño. El servidor nunca crea, actualiza ni elimina nada en SonarQube — no marca incidencias como falsos positivos, no edita comentarios, no tiene endpoints de administración. Los permisos de escritura del token en SonarQube son irrelevantes porque el servidor nunca llama a esos endpoints.
Conjunto de herramientas seleccionado. En lugar de reflejar la superficie de la API de SonarQube, el servidor expone un conjunto pequeño y enfocado de herramientas (13 en total) elegidas para un único flujo de trabajo: permitir que un agente de IA lea los hallazgos de Sonar y corrija el código basándose en ellos. Listar componentes, incidencias y hotspots, profundizar en un hallazgo individual, obtener la explicación de la regla y extraer el fragmento de código fuente alrededor de la ubicación — y eso es todo. Cualquier cosa fuera de este bucle de "diagnosticar -> corregir el código localmente" se omite deliberadamente para mantener la lista de herramientas pequeña y las opciones del agente inequívocas.

En resumen: un puente enfocado y de solo lectura desde una instalación autogestionada de SonarQube Community Build hacia un agente de IA de codificación.

Inicio rápido

Instala JDK 25+.
Descarga sonar-mcp-server.jar desde la última versión, o compílalo tú mismo: ./gradlew bootJar (ver Build). También se publica una imagen Docker.
Obtén tu URL de SonarQube y token de usuario (ver Configuración).
Añade el JAR a la configuración MCP de tu cliente (ver Conexión a un cliente de IA).

Para Claude Code, eso es un solo comando:

claude mcp add --scope user -e SONAR_URL=https://sonar.example.com -e SONAR_TOKEN=your_token -- sonar java -jar /path/to/sonar-mcp-server.jar

Arquitectura

El servidor solo soporta el transporte stdio.

┌─────────────┐     stdio      ┌──────────────────┐    web-api     ┌──────────┐
│  AI agent   │ <------------> │  sonar-mcp-      │ -------------> │ SonarQube│
│ (Claude Code│   stdin/stdout │  server (Java)   │  HTTP + Bearer  │  CB 26.4+│
│  Cursor...) │                │                  │  auth (token)   │          │
└─────────────┘                └──────────────────┘                └──────────┘

El cliente de IA inicia el servidor como un proceso hijo; la comunicación utiliza el protocolo MCP sobre stdin/stdout. El servidor no abre ningún puerto HTTP y no acepta conexiones entrantes.

Herramientas

El servidor exporta 13 herramientas MCP de solo lectura.

Proyectos

Herramienta	Descripción
`listProjects`	Lista de proyectos de SonarQube. Parámetros: `query` (subcadena del nombre), `limit`, `offset`. Devuelve `key`, `name`, `qualifier`.
`listComponents`	Buscar/navegar componentes dentro de un proyecto usando el árbol de componentes de Sonar. Parámetros: `projectKey`, `query`, `qualifiers`, `branch` / `pullRequest`, `limit`, `offset`. Devuelve valores opacos de `key` de componentes más `path`, `qualifier`, nombre, lenguaje y proyecto. Usa los valores de `key` devueltos sin cambios como `listIssues.componentKeys`; no pases nombres de paquetes Java directamente como claves de componente.
`getProject`	Resumen del proyecto: información de cabecera (nombre, cualificador, visibilidad, descripción, versión, fecha del último análisis), estado del quality gate con condiciones fallidas y métricas seleccionadas (ncloc, bugs, vulnerabilidades, security hotspots, code smells, cobertura, densidad de líneas duplicadas, deuda técnica en minutos, estado de alerta). Parámetros: `projectKey`, `branch` (opc.), `pullRequest` (opc.).
`listProjectBranches`	Lista de ramas analizadas para el proyecto. Cada entrada: `name`, `isMain`, `type` (LONG/SHORT/BRANCH), `excludedFromPurge`, `analysisDate`, `qualityGateStatus`, más conteos de bugs/vulnerabilidades/codeSmells. Sin paginación — Sonar devuelve todas las ramas de una vez.
`listProjectPullRequests`	Lista de análisis de PR para el proyecto. Cada entrada: `key` del PR (úsalo como `pullRequest=` en otros lugares), `title`, `branch` (head), `base`, `url`, `analysisDate`, `qualityGateStatus`, más conteos de bugs/vulnerabilidades/codeSmells. Lista vacía si la instalación de Sonar no tiene integración DevOps.

Incidencias

Herramienta	Descripción
`listIssues`	Lista plana de incidencias para un proyecto. Parámetros: `projectKey` (obligatorio a menos que se use el valor predeterminado), `componentPathPrefix` (opc.) — un único filtro de subárbol-o-archivo relativo a la raíz del proyecto de Sonar (p. ej. `bc-doc/src/main/java/ru/foo` o `bc-doc/src/main/java/ru/foo/Bar.java`); convierte los puntos de los paquetes Java/Kotlin a barras; respeta los límites de directorios (`bc-doc/src` no coincide con `bc-doc/srcExtra`). Más `severities`, `types`, `statuses`, `rules`, `branch` / `pullRequest` (mutuamente excluyentes), `resolved`, `limit`, `offset`. Por defecto devuelve solo incidencias abiertas (`resolved=false`, estados OPEN/CONFIRMED/REOPENED). Cada elemento contiene la regla, severidad, tipo, estado, ruta del archivo, línea, textRange principal y flujos secundarios para reglas entre archivos. Cuando se usa `componentPathPrefix`, el servidor escanea el proyecto y filtra en el lado del cliente; el escaneo tiene un límite (10000 incidencias por defecto) — si se alcanza el límite, `pathPrefixTruncated=true` en la respuesta.
`getIssue`	Detalles de una sola incidencia por clave más su historial de cambios (`changelog`). Acepta `branch` / `pullRequest` opcionales.
`getIssueSnippets`	Fragmentos de código fuente alrededor de todas las ubicaciones de la incidencia (principal más flujos para reglas entre archivos). Para cada ubicación: `componentPath`, lenguaje y un array de líneas de código fuente con información SCM. Útil cuando el repositorio no está disponible localmente o necesitas ver exactamente la versión del archivo que Sonar analizó. Acepta `branch` / `pullRequest` opcionales — importante cuando la incidencia está en una ref que no es main cuyos archivos difieren de main.
`getProjectIssuesSummary`	Resumen agregado de incidencias abiertas en un proyecto: total más desgloses por severidad, tipo, estado, regla, etiqueta y autor SCM. Los parámetros reflejan `listIssues` (incl. `componentPathPrefix`) excepto la paginación.
`getProjectIssuesBreakdown`	Agregación multi-módulo de incidencias por módulo lógico y regla. El módulo se deriva del primer segmento de `componentPath`. Los parámetros reflejan `getProjectIssuesSummary`.

Reglas

Herramienta	Descripción
`getRule`	Detalles de una regla de Sonar por clave (p. ej. `java:S1234`): título, severidad, tipo, lenguaje, etiquetas, secciones de descripción (introducción, causa raíz, cómo corregir, recursos). Respaldado por una caché en memoria — las llamadas repetidas son gratuitas.

Security Hotspots

Herramienta Descripción

listHotspots Lista de Security Hotspots para un proyecto. Los hotspots son una categoría separada de las incidencias, que marcan puntos que requieren revisión de seguridad manual. Por defecto Sonar devuelve hotspots en estado TO_REVIEW. Parámetros: projectKey, componentPathPrefix (opc.) — misma semántica de prefijo que en listIssues, status (opc.), branch / pullRequest (opc., mutuamente excluyentes), limit, offset. Sujeto al mismo límite de escaneo en el lado del cliente (bandera pathPrefixTruncated en la respuesta).

getHotspot Detalles del Security Hotspot: descripción completa de la regla (riesgo, vulnerabilidad, recomendaciones de corrección), textRange principal, flujos secundarios, changelog. Las claves de hotspot son globalmente únicas, por lo que no se necesita el parámetro branch/pullRequest.

Herramienta	Descripción
`listHotspots`	Lista de Security Hotspots para un proyecto. Los hotspots son una categoría separada de las incidencias, que marcan puntos que requieren revisión de seguridad manual. Por defecto Sonar devuelve hotspots en estado `TO_REVIEW`. Parámetros: `projectKey`, `componentPathPrefix` (opc.) — misma semántica de prefijo que en `listIssues`, `status` (opc.), `branch` / `pullRequest` (opc., mutuamente excluyentes), `limit`, `offset`. Sujeto al mismo límite de escaneo en el lado del cliente (bandera `pathPrefixTruncated` en la respuesta).
`getHotspot`	Detalles del Security Hotspot: descripción completa de la regla (riesgo, vulnerabilidad, recomendaciones de corrección), textRange principal, flujos secundarios, changelog. Las claves de hotspot son globalmente únicas, por lo que no se necesita el parámetro `branch`/`pullRequest`.

Todas las herramientas son de solo lectura — no se modifica ningún dato en SonarQube.

Trabajo con ramas y pull requests

Sonar analiza una rama y un pull request como dos ámbitos distintos y mutuamente excluyentes. La web-api de Sonar acepta branch= o pullRequest= en una sola solicitud, nunca ambos.

branch — ramas de larga duración (main, develop, feature/...). Se resuelven como: argumento explícito branch → SONAR_DEFAULT_BRANCH → ninguno (Sonar usa la rama principal del proyecto).
pullRequest — la clave de PR de Sonar, normalmente el número de PR/MR. Independiente de los análisis de rama; los análisis de PR a menudo contienen los hallazgos más relevantes para el trabajo en curso. Las claves de pull request nunca recurren a un valor predeterminado a nivel de servidor — pásalas explícitamente.

Pasar ambos branch y pullRequest a la misma llamada de herramienta es un error. Usa listProjectBranches / listProjectPullRequests para descubrir las refs disponibles.

El ámbito de rama es fundamental. Cada rama de Sonar es un análisis separado: los conteos de incidencias abiertas en main y en una rama de funcionalidad pueden diferir mucho, porque la rama de funcionalidad puede tener nuevas correcciones (o código nuevo) que no se han fusionado. Si el agente omite silenciosamente branch=, lee desde main (o SONAR_DEFAULT_BRANCH) y puede perder trabajo ya realizado en una rama de funcionalidad — o peor, corregir el mismo problema dos veces. Cuando el git local del usuario está en feature/..., los agentes deben llamar a listProjectBranches primero, encontrar la rama de Sonar correspondiente y pasarla explícitamente a cada llamada de incidencias / resumen / desglose.

Como red de seguridad en el lado del servidor, listIssues, getProjectIssuesSummary y getProjectIssuesBreakdown adjuntan un campo branchAdvisory a su respuesta cuando (1) no se pasó ni branch ni pullRequest Y (2) el proyecto tiene otras ramas analizadas en Sonar. El aviso lleva el nombre de la rama efectiva (main) y la lista de ramas que no son main ordenadas por la fecha de análisis más reciente. El campo está ausente en caso contrario.

Stack

Java 25, Spring Boot 4.0.0, Spring AI MCP 2.0.0 (transporte stdio)
Jackson 3 (tools.jackson) para JSON
Gradle 9.3.1 con catálogo de versiones (gradle/libs.versions.toml)

Build

# Point to a JDK 25+ if it's not the default:
export JAVA_HOME="$HOME/.jdks/jdk-25.0.2"

./gradlew build

En Windows: .\gradlew.bat build.

Salida: build/libs/sonar-mcp-server.jar

Configuración

El servidor necesita una URL de SonarQube y un token; el resto es opcional.

Variable	Descripción
`SONAR_URL`	URL base de SonarQube (p. ej. `http://sonar.example.com`)
`SONAR_TOKEN`	Token de usuario de SonarQube
`SONAR_DEFAULT_PROJECT_KEY`	Clave de proyecto de SonarQube predeterminada. Cuando se establece, `listIssues`, `getProjectIssuesSummary`, `listHotspots` se pueden llamar sin `projectKey`.
`SONAR_DEFAULT_BRANCH`	Rama de Sonar predeterminada. Cuando se establece, todas las herramientas que usan ramas (`listIssues`, `getIssue`, `getIssueSnippets`, `getProjectIssuesSummary`, `listHotspots`) recurren a esta rama cuando se omite `branch`. Sin ella, Sonar usa la rama principal del proyecto.
`SONAR_MCP_DATA_DIR`	Directorio de datos local para el servidor; por defecto `~/.sonar-mcp-server`
`SONAR_MCP_PAGINATION_DEFAULT_LIMIT`	Límite de página predeterminado para herramientas de listado; por defecto `50`
`SONAR_MCP_PAGINATION_DEFAULT_OFFSET`	Desplazamiento predeterminado para herramientas de listado; por defecto `0`
`SONAR_MCP_PAGINATION_MAX_LIMIT`	Límite máximo de página (la API de Sonar limita a 500); por defecto `500`
`SONAR_MCP_SNIPPET_MAX_LINES`	Reservado para un futuro límite de líneas por fragmento; actualmente sin uso (Sonar elige la ventana por sí mismo). Por defecto `50`
`SONAR_MCP_PATH_FILTER_MAX_SCANNED_ISSUES`	Límite máximo de incidencias/hotspots escaneados en el lado del cliente cuando se establece `componentPathPrefix`; por defecto `10000`. Si se alcanza el límite, la respuesta lleva `pathPrefixTruncated=true`.

Grupos de herramientas

El manifiesto MCP tools/list se divide en cuatro grupos, cada uno controlado por una variable de entorno. Todos los grupos están activados por defecto, por lo que el manifiesto predeterminado no cambia. Desactiva un grupo para reducir el manifiesto — útil para modelos de contexto pequeño (locales) que de otro modo se verían inundados con esquemas de herramientas y salidas al inicio de la sesión.

Variable	Herramientas en el grupo
`SONAR_MCP_TOOLS_ISSUE`	`listIssues`, `getIssue`, `getIssueSnippets`, `getProjectIssuesSummary`, `getProjectIssuesBreakdown`
`SONAR_MCP_TOOLS_PROJECT`	`listProjects`, `listComponents`, `getProject`, `listProjectBranches`, `listProjectPullRequests`
`SONAR_MCP_TOOLS_HOTSPOT`	`listHotspots`, `getHotspot`
`SONAR_MCP_TOOLS_RULE`	`getRule`

Establece una marca a false (por ejemplo, SONAR_MCP_TOOLS_HOTSPOT=false) para eliminar las herramientas de ese grupo del manifiesto.

Obtener la URL de SonarQube

Abre SonarQube en un navegador y copia la dirección desde la barra de ubicación sin la ruta — solo el esquema y el host.

En la barra de direcciones del navegador	Valor de URL
`https://sonar.example.com/dashboard?id=...`	`https://sonar.example.com`
`http://192.168.1.50:9000/projects`	`http://192.168.1.50:9000`
`http://10.0.0.5/sonar/projects`	`http://10.0.0.5/sonar`

Si SonarQube solo es accesible por IP, usa la IP tal cual. Si está desplegado bajo una subruta (por ejemplo, /sonar), inclúyela también en la URL.

Obtener un token de SonarQube

Inicia sesión en SonarQube con tu cuenta.
Abre Mi cuenta -> Seguridad.
En Generar tokens, introduce un nombre de token y elige el tipo Token de usuario.
Haz clic en Generar — el token se muestra solo una vez. Cópialo inmediatamente.
Usa el valor del token como SONAR_TOKEN.

Si se pierde un token, tienes que regenerarlo — SonarQube no vuelve a mostrar los tokens existentes.

El servidor usa autenticación HTTP Bearer, pasando el token en el encabezado Authorization — este es el esquema estándar de SonarQube Community Build para tokens de usuario.

Ejecución

SONAR_URL=http://sonar.example.com SONAR_TOKEN=your_token \
  java -jar build/libs/sonar-mcp-server.jar

El servidor se ejecuta sobre stdio. Tras un inicio exitoso, no abre ningún puerto HTTP y espera solicitudes MCP a través de stdin/stdout.

Los registros se escriben en ${SONAR_MCP_DATA_DIR:-~/.sonar-mcp-server}/logs/sonar-mcp-server.log. El archivo rota por fecha y tamaño: 10MB, retención de 30 días, límite total de 512MB.

Docker

La imagen se publica en GHCR con cada versión:

docker run -i --rm   -e SONAR_URL=https://sonar.example.com   -e SONAR_TOKEN=your_token   ghcr.io/igorolv/sonar-mcp-server:latest

El mismo comando es lo que un cliente MCP debería lanzar (-i mantiene stdin abierto para el transporte stdio). Monta un directorio del host en /data para conservar los registros entre ejecuciones. Si SonarQube se ejecuta en la misma máquina, usa su nombre de host en lugar de localhost, o añade --network host en Linux. Para construir la imagen localmente: docker build -t sonar-mcp-server .

Conexión a un cliente de IA

{
  "command": "java",
  "args": ["-jar", "<absolute-path>/sonar-mcp-server.jar"],
  "env": {
    "SONAR_URL": "http://sonar.example.com",
    "SONAR_TOKEN": "your_token"
  }
}

Dónde exactamente:

Cliente	Cómo conectarse
Claude Code	`claude mcp add --scope user -e SONAR_URL=... -e SONAR_TOKEN=... -- sonar java -jar /path/to/sonar-mcp-server.jar`
Qwen Code	`~/.qwen/settings.json` -> `"mcpServers"` -> `"sonar"`, o `qwen mcp add --scope user -e SONAR_URL=... -e SONAR_TOKEN=... sonar java -jar /path/to/sonar-mcp-server.jar`
VS Code	`.vscode/mcp.json` -> `"servers"` -> `"sonar"`
Cursor	`.cursor/mcp.json` -> `"mcpServers"` -> `"sonar"`
Claude Desktop	`claude_desktop_config.json` -> `"mcpServers"` -> `"sonar"`

Para clientes CLI también hay comandos para ver y eliminar el registro: claude mcp list / claude mcp remove --scope user sonar (de manera similar para qwen).

Después de añadirlo, reinicia el cliente.

Ejemplos de indicaciones para agentes de IA

Find and fix Sonar issues in project my-project
Show the top 10 rules by number of open issues in project my-project
Show Sonar issues under src/main/java/com/example/foo

Operaciones y seguridad

Este servidor MCP está pensado para ejecutarse localmente junto al cliente de IA. No abre ningún puerto HTTP y no acepta conexiones de red entrantes: el cliente inicia el JAR como un proceso hijo y se comunica con él a través de stdin/stdout.

Modelo de acceso

El servidor actúa con los derechos del usuario de SonarQube cuyo token está en SONAR_TOKEN.
Todas las herramientas MCP son de solo lectura: el servidor no crea, modifica ni elimina problemas, hotspots, reglas o proyectos.
Los proyectos y problemas disponibles están determinados por los permisos del usuario en SonarQube. Si el usuario no puede ver un proyecto en SonarQube, el servidor tampoco debería poder acceder a él.
Trata el token como un secreto. No lo confirmes en el repositorio, scripts de shell, .vscode/mcp.json, .cursor/mcp.json ni en ningún otro archivo compartido del proyecto.

Qué datos se envían al cliente de IA

El cliente de IA recibe exactamente los datos que solicita a través de las herramientas MCP:

la lista de problemas con regla, severidad, tipo, ruta de archivo, número de línea, mensaje, etiquetas, autor SCM;
historial de cambios de problemas;
descripciones de reglas de Sonar (incluyendo HTML/markdown);
fragmentos de código fuente alrededor de las ubicaciones de los problemas (a través de getIssueSnippets);
Security Hotspots y sus detalles.

Antes de conectarte a un cliente de IA externo o basado en la nube, revisa las políticas internas de tu empresa: el código fuente puede contener secretos comerciales.

Diagnóstico

Verificación del entorno:

java -version
echo "$SONAR_URL"
test -n "$SONAR_TOKEN" && echo "SONAR_TOKEN is set"

Verificación de acceso a la web-api de SonarQube (autenticación HTTP Bearer con el token):

curl -H "Authorization: Bearer $SONAR_TOKEN" "$SONAR_URL/api/components/search?qualifiers=TRK&p=1&ps=1"

La respuesta esperada es una lista JSON de proyectos. 401 Unauthorized significa que el token es inválido o ha expirado; 403 significa que el usuario no tiene permiso para la API.

Verificación de compilación:

./gradlew test
./gradlew build

Pruebas de integración contra un SonarQube en vivo:

SONAR_URL=<url> SONAR_TOKEN=<token> ./gradlew integrationTest

Las pruebas de integración requieren un SonarQube accesible y datos reales. Las pruebas unitarias excluyen la etiqueta integration por defecto.

Limitaciones operativas conocidas

Los tiempos de espera HTTP y la política de reintentos aún no son configurables por separado.
La API de Sonar usa paginación basada en páginas (p/ps); las herramientas aceptan offset/limit, y un desplazamiento que no sea múltiplo de limit se redondea hacia abajo al límite de página más cercano. Sonar también limita ps a 500.
componentPathPrefix es un filtro del lado del cliente: el servidor recorre los problemas/hotspots del proyecto y conserva aquellos cuyo componentPath comienza con el prefijo (seguro en límites de directorio). El escaneo está limitado (SONAR_MCP_PATH_FILTER_MAX_SCANNED_ISSUES, por defecto 10000); cuando se alcanza el límite, la respuesta establece pathPrefixTruncated=true y el llamador debe ajustar el prefijo.
El campo author en Issue es el autor SCM de la línea donde ocurrió el problema (poblado por Sonar cuando se configura un proveedor SCM). Sonar no devuelve campos separados scmAuthor/scmDate en issues/search; para SCM a nivel de línea usa getIssueSnippets.

Estructura del proyecto

├── src/main/java/ru/it_spectrum/ai/sonar/mcp/
│   ├── SonarMcpServerApplication.java   — Spring Boot entry point
│   ├── api/                              — stable MCP wire format: records returned by tools/services
│   │   ├── Issue.java, IssuePage.java, IssueDetails.java, IssueLocation.java, IssueFlow.java, IssueImpact.java, IssueSnippets.java
│   │   ├── Project.java, ProjectPage.java, ProjectOverview.java, ProjectMetrics.java, ProjectComponent.java, ProjectComponentPage.java
│   │   ├── RuleDetails.java, RuleSection.java
│   │   ├── Hotspot.java, HotspotDetails.java, HotspotPage.java, HotspotRule.java
│   │   ├── SourceSnippet.java, SnippetLine.java
│   │   ├── ChangelogEntry.java, ChangelogDiff.java
│   │   ├── TextRange.java, FacetCount.java, BranchAdvisory.java
│   │   ├── ProjectIssuesSummary.java, ProjectIssuesBreakdown.java, ModuleIssuesSummary.java
│   │   ├── ProjectBranch.java, ProjectBranches.java, ProjectPullRequest.java, ProjectPullRequests.java
│   │   ├── QualityGateStatus.java, QualityGateCondition.java
│   │   └── Opaque.java
│   ├── client/
│   │   ├── SonarClient.java              — SonarQube web-api wrapper
│   │   └── model/                        — raw DTOs of the SonarQube web-api, not exposed directly via MCP
│   │       └── Sonar*.java
│   ├── config/
│   │   ├── SonarClientProperties.java   — url + token from env
│   │   ├── SonarMcpProperties.java      — all sonar-mcp.* runtime settings
│   │   ├── SonarConfig.java             — RestClient with Bearer auth
│   │   ├── McpServerConfig.java         — stdio MCP customizer with immediateExecution(true)
│   │   └── JsonConfig.java              — ObjectMapper for MCP JSON
│   ├── service/
│   │   ├── ProjectService.java
│   │   ├── IssueService.java
│   │   ├── RuleService.java             — with in-memory rule cache
│   │   ├── SnippetService.java
│   │   ├── HotspotService.java
│   │   ├── PaginationHelper.java        — offset/limit -> p/ps
│   │   └── SonarMappers.java            — client.model -> api mapping
│   └── tools/
│       ├── ProjectTools.java            — 5 MCP tools
│       ├── IssueTools.java              — 5 MCP tools
│       ├── RuleTools.java               — 1 MCP tool
│       ├── HotspotTools.java            — 2 MCP tools
│       ├── ToolDescriptions.java        — shared @McpTool / @McpToolParam description constants
│       ├── SonarPrompts.java            — MCP prompts (analyzePath, fixPath, fixFile, investigateIssue, reviewPullRequest)
│       ├── RefResolver.java             — branch/pullRequest resolution with default-branch fallback
│       └── ToolLogger.java
└── src/main/resources/
    ├── application.yml                  — MCP server configuration (stdio)
    └── logback-spring.xml               — logging configuration

Solución de problemas

"Gradle requires JVM 17 or later" — establece JAVA_HOME a un JDK 25+.
Conexión rechazada / 401 — verifica la URL y el token. Prueba: curl -H "Authorization: Bearer $SONAR_TOKEN" "$SONAR_URL/api/components/search?qualifiers=TRK&p=1&ps=1".
403 Prohibido — el usuario del token no tiene derechos sobre el proyecto o sobre la web-api. Verifica el rol en SonarQube.
El alcance de paquete/módulo devuelve 0 problemas — pasa el prefijo de estilo de ruta como componentPathPrefix (por ejemplo, bc-doc/src/main/java/ru/foo), no una clave de componente de Sonar. Convierte los puntos de paquetes Java/Kotlin a barras. El filtro es seguro en límites de directorio, por lo que bc-doc/src no coincidirá con bc-doc/srcExtra.
pathPrefixTruncated=true en la respuesta — el escaneo del lado del cliente alcanzó SONAR_MCP_PATH_FILTER_MAX_SCANNED_ISSUES antes de llegar al final. Ajusta el prefijo para reducir el escaneo, o aumenta el límite si 10k realmente no es suficiente para tu proyecto.