MCP-195 Let users selectively enable tools

Author: nquinquenel

README.md

@@ -478,6 +478,49 @@ You should add the following variable when running the MCP Server:
 | `STORAGE_PATH`       | Mandatory absolute path to a writable directory where SonarQube MCP Server will store its files (e.g., for creation, updates, and persistence), it is automatically provided when using Docker |
 | `SONARQUBE_IDE_PORT` | Optional port number between 64120 and 64130 used to connect SonarQube MCP Server with SonarQube for IDE.                                                                                      |
 
+### Selective Tool Enablement
+
+By default, all tools are enabled. You can selectively enable specific toolsets to reduce context overhead and focus on specific functionality.
+
+| Environment variable   | Description                                                                                                       |
+|------------------------|-------------------------------------------------------------------------------------------------------------------|
+| `SONARQUBE_TOOLSETS`   | Comma-separated list of toolsets to enable. When set, only these toolsets will be available. If not set, all tools are enabled. **Note:** The `projects` toolset is always enabled as it's required to find project keys for other operations. |
+
+<details>
+
+**<summary>Available Toolsets</summary>**
+
+| Toolset            | Key                 | Description                                                          |
+|--------------------|---------------------|----------------------------------------------------------------------|
+| **Analysis**       | `analysis`          | Code analysis tools (analyze code snippets and files)                |
+| **Issues**         | `issues`            | Search and manage SonarQube issues                                   |
+| **Projects**       | `projects`          | Browse and search SonarQube projects                                 |
+| **Quality Gates**  | `quality-gates`     | Access quality gates and their status                                |
+| **Rules**          | `rules`             | Browse and search SonarQube rules                                    |
+| **Sources**        | `sources`           | Access source code and SCM information                               |
+| **Measures**       | `measures`          | Retrieve metrics and measures (includes both measures and metrics tools) |
+| **Languages**      | `languages`         | List supported programming languages                                 |
+| **Portfolios**     | `portfolios`        | Manage portfolios and enterprises (Cloud and Server)                 |
+| **System**         | `system`            | System administration tools (Server only)                            |
+| **Webhooks**       | `webhooks`          | Manage webhooks                                                      |
+| **Dependency Risks**| `dependency-risks` | Analyze dependency risks and security issues (SCA)                   |
+
+#### Example
+
+**Enable analysis, issues, and quality gates toolsets (using Docker with SonarQube Cloud):**
+
+```bash
+docker run -i --name sonarqube-mcp-server --rm \
+  -e SONARQUBE_TOKEN="<token>" \
+  -e SONARQUBE_ORG="<org>" \
+  -e SONARQUBE_TOOLSETS="analysis,issues,quality-gates" \
+  mcp/sonarqube
+```
+
+Note: The `projects` toolset is always enabled automatically, so you don't need to include it in `SONARQUBE_TOOLSETS`.
+
+</details>
+
 #### SonarQube Cloud
 
 To enable full functionality, the following environment variables must be set before starting the server:

src/main/java/org/sonarsource/sonarqube/mcp/SonarQubeMcpServer.java

@@ -150,40 +150,42 @@ private void initializeServices() {
     LOG.info("Startup initialization completed");
   }
   private void initTools() {
+    var allTools = new ArrayList<Tool>();
+    
     boolean useIdeBridge = false;
     if (!mcpConfiguration.isHttpEnabled() && mcpConfiguration.getSonarQubeIdePort() != null) {
       var sonarqubeIdeBridgeClient = initializeBridgeClient(mcpConfiguration);
       if (sonarqubeIdeBridgeClient.isAvailable()) {
         LOG.info("SonarQube for IDE integration detected - loading IDE specific tools");
         backendService.notifySonarQubeIdeIntegration();
-        this.supportedTools.add(new AnalyzeFileListTool(sonarqubeIdeBridgeClient));
-        this.supportedTools.add(new ToggleAutomaticAnalysisTool(sonarqubeIdeBridgeClient));
+        allTools.add(new AnalyzeFileListTool(sonarqubeIdeBridgeClient));
+        allTools.add(new ToggleAutomaticAnalysisTool(sonarqubeIdeBridgeClient));
         useIdeBridge = true;
       }
     }
 
     // Load standard analysis tool when IDE bridge is not used
     if (!useIdeBridge) {
       LOG.info("SonarQube for IDE integration not detected - loading standard analysis tool");
-      this.supportedTools.add(new AnalysisTool(backendService, this));
+      allTools.add(new AnalysisTool(backendService, this));
     }
 
     // SonarQube Cloud specific tools
     if (mcpConfiguration.isSonarCloud()) {
       LOG.info("SonarQube Cloud detected - loading SonarQube Cloud specific tools");
-      this.supportedTools.add(new ListEnterprisesTool(this));
+      allTools.add(new ListEnterprisesTool(this));
     } else {
       LOG.info("SonarQube Server detected - loading SonarQube Server specific tools");
       // SonarQube Server specific tools
-      this.supportedTools.addAll(List.of(
+      allTools.addAll(List.of(
         new SystemHealthTool(this),
         new SystemInfoTool(this),
         new SystemLogsTool(this),
         new SystemPingTool(this),
         new SystemStatusTool(this)));
     }
 
-    this.supportedTools.addAll(List.of(
+    allTools.addAll(List.of(
       new ChangeIssueStatusTool(this),
       new SearchMyProjectsTool(this),
       new SearchIssuesTool(this),
@@ -200,6 +202,13 @@ private void initTools() {
       new ListWebhooksTool(this),
       new ListPortfoliosTool(this, mcpConfiguration.isSonarCloud()),
       new SearchDependencyRisksTool(this, sonarQubeVersionChecker)));
+      
+    // Filter tools based on enabled categories
+    this.supportedTools.addAll(allTools.stream()
+      .filter(tool -> mcpConfiguration.isToolCategoryEnabled(tool.getCategory()))
+      .toList());
+      
+    LOG.info("Loaded " + this.supportedTools.size() + " tools after category filtering");
   }
 
   public void start() {

src/main/java/org/sonarsource/sonarqube/mcp/configuration/McpServerLaunchConfiguration.java

@@ -21,11 +21,13 @@
 import java.nio.file.Paths;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Set;
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.jetbrains.annotations.NotNull;
 import org.sonarsource.sonarqube.mcp.SonarQubeMcpServer;
 import org.sonarsource.sonarqube.mcp.authentication.AuthMode;
+import org.sonarsource.sonarqube.mcp.tools.ToolCategory;
 
 import static java.util.Objects.requireNonNull;
 
@@ -41,6 +43,9 @@ public class McpServerLaunchConfiguration {
   private static final String SONARQUBE_IDE_PORT_ENV = "SONARQUBE_IDE_PORT";
   private static final String TELEMETRY_DISABLED = "TELEMETRY_DISABLED";
 
+  // Tool category configuration
+  private static final String SONARQUBE_TOOLSETS = "SONARQUBE_TOOLSETS";
+  
   // HTTP/HTTPS transport configuration
   private static final String SONARQUBE_TRANSPORT = "SONARQUBE_TRANSPORT";
   private static final String SONARQUBE_HTTP_PORT = "SONARQUBE_HTTP_PORT";
@@ -89,6 +94,9 @@ public class McpServerLaunchConfiguration {
   private final String httpsTruststoreType;
   @Nullable
   private final AuthMode authMode;
+  
+  // Tool category configuration
+  private final Set<ToolCategory> enabledToolsets;
 
   public McpServerLaunchConfiguration(Map<String, String> environment) {
     var storagePathString = getValueViaEnvOrPropertyOrDefault(environment, STORAGE_PATH, null);
@@ -137,6 +145,10 @@ public McpServerLaunchConfiguration(Map<String, String> environment) {
     this.httpsTruststoreType = getValueViaEnvOrPropertyOrDefault(environment, SONARQUBE_HTTPS_TRUSTSTORE_TYPE, DEFAULT_KEYSTORE_TYPE);
 
     this.authMode = parseAuthMode(environment);
+    
+    // Parse tool category configuration
+    var toolsetsStr = getValueViaEnvOrPropertyOrDefault(environment, SONARQUBE_TOOLSETS, null);
+    this.enabledToolsets = ToolCategory.parseCategories(toolsetsStr);
   }
 
   @NotNull
@@ -324,4 +336,29 @@ private AuthMode parseAuthMode(Map<String, String> environment) {
     return null;
   }
 
+  /**
+   * Determines if a tool category should be enabled based on configuration.
+   * Rules:
+   * 1. PROJECTS toolset is always enabled (required to find project keys)
+   * 2. If SONARQUBE_TOOLSETS is set, only those toolsets (plus PROJECTS) are enabled
+   * 3. If SONARQUBE_TOOLSETS is not set, all toolsets are enabled (default)
+   */
+  public boolean isToolCategoryEnabled(ToolCategory category) {
+    // PROJECTS is always enabled as it's required to find project keys
+    if (category == ToolCategory.PROJECTS) {
+      return true;
+    }
+    
+    // If toolsets is explicitly set, only enable those
+    if (!enabledToolsets.isEmpty()) {
+      return enabledToolsets.contains(category);
+    }
+    // Default: enable all categories
+    return true;
+  }
+
+  public Set<ToolCategory> getEnabledToolsets() {
+    return Set.copyOf(enabledToolsets);
+  }
+
 }

src/main/java/org/sonarsource/sonarqube/mcp/tools/Tool.java

@@ -24,15 +24,21 @@
 
 public abstract class Tool {
   private final McpSchema.Tool definition;
+  private final ToolCategory category;
 
-  protected Tool(McpSchema.Tool definition) {
+  protected Tool(McpSchema.Tool definition, ToolCategory category) {
     this.definition = definition;
+    this.category = category;
   }
 
   public McpSchema.Tool definition() {
     return definition;
   }
 
+  public ToolCategory getCategory() {
+    return category;
+  }
+
   public abstract Result execute(Arguments arguments);
 
   public static class Arguments {

src/main/java/org/sonarsource/sonarqube/mcp/tools/ToolCategory.java

@@ -0,0 +1,88 @@
+/*
+ * SonarQube MCP Server
+ * Copyright (C) 2025 SonarSource
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+package org.sonarsource.sonarqube.mcp.tools;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
+/**
+ * Categories of tools that can be selectively enabled or disabled.
+ * Each tool belongs to exactly one category.
+ */
+public enum ToolCategory {
+  ANALYSIS("analysis"),
+  ISSUES("issues"),
+  PROJECTS("projects"),
+  QUALITY_GATES("quality-gates"),
+  RULES("rules"),
+  SOURCES("sources"),
+  MEASURES("measures"),
+  LANGUAGES("languages"),
+  PORTFOLIOS("portfolios"),
+  SYSTEM("system"),
+  WEBHOOKS("webhooks"),
+  DEPENDENCY_RISKS("dependency-risks");
+
+  private final String key;
+
+  ToolCategory(String key) {
+    this.key = key;
+  }
+
+  public String getKey() {
+    return key;
+  }
+
+  @CheckForNull
+  public static ToolCategory fromKey(@Nullable String key) {
+    if (key == null || key.isBlank()) {
+      return null;
+    }
+    var normalizedKey = key.trim().toLowerCase(Locale.getDefault());
+    for (ToolCategory category : values()) {
+      if (category.key.equals(normalizedKey)) {
+        return category;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Parses a comma-separated list of category keys into a Set of ToolCategory.
+   * Invalid keys are silently ignored.
+   */
+  public static Set<ToolCategory> parseCategories(@Nullable String categoriesStr) {
+    if (categoriesStr == null || categoriesStr.isBlank()) {
+      return Set.of();
+    }
+    return Arrays.stream(categoriesStr.split(","))
+      .map(String::trim)
+      .map(ToolCategory::fromKey)
+      .filter(Objects::nonNull)
+      .collect(Collectors.toSet());
+  }
+
+  public static Set<ToolCategory> all() {
+    return Set.of(values());
+  }
+}
+

src/main/java/org/sonarsource/sonarqube/mcp/tools/analysis/AnalysisTool.java

@@ -34,6 +34,7 @@
 import org.sonarsource.sonarqube.mcp.slcore.BackendService;
 import org.sonarsource.sonarqube.mcp.tools.SchemaToolBuilder;
 import org.sonarsource.sonarqube.mcp.tools.Tool;
+import org.sonarsource.sonarqube.mcp.tools.ToolCategory;
 
 import static java.util.stream.Collectors.toMap;
 import static org.sonarsource.sonarqube.mcp.analysis.LanguageUtils.getSonarLanguageFromInput;
@@ -59,7 +60,8 @@ public AnalysisTool(BackendService backendService, ServerApiProvider serverApiPr
       .addRequiredStringProperty(SNIPPET_PROPERTY, "Code snippet or full file content")
       .addStringProperty(LANGUAGE_PROPERTY, "Language of the code snippet")
       .setReadOnlyHint()
-      .build());
+      .build(),
+      ToolCategory.ANALYSIS);
     this.backendService = backendService;
     this.serverApiProvider = serverApiProvider;
   }

src/main/java/org/sonarsource/sonarqube/mcp/tools/analysis/AnalyzeFileListTool.java

@@ -20,6 +20,7 @@
 import org.sonarsource.sonarqube.mcp.bridge.SonarQubeIdeBridgeClient;
 import org.sonarsource.sonarqube.mcp.tools.SchemaToolBuilder;
 import org.sonarsource.sonarqube.mcp.tools.Tool;
+import org.sonarsource.sonarqube.mcp.tools.ToolCategory;
 
 public class AnalyzeFileListTool extends Tool {
   private static final McpLogger LOG = McpLogger.getInstance();
@@ -37,7 +38,8 @@ public AnalyzeFileListTool(SonarQubeIdeBridgeClient bridgeClient) {
         "This tool connects to a running SonarQube for IDE instance to perform code quality analysis on a list of files.")
       .addArrayProperty(FILE_ABSOLUTE_PATHS_PROPERTY, "string", "List of absolute file paths to analyze")
       .setReadOnlyHint()
-      .build());
+      .build(),
+      ToolCategory.ANALYSIS);
     this.bridgeClient = bridgeClient;
   }
 

src/main/java/org/sonarsource/sonarqube/mcp/tools/analysis/ToggleAutomaticAnalysisTool.java

@@ -19,6 +19,7 @@
 import org.sonarsource.sonarqube.mcp.bridge.SonarQubeIdeBridgeClient;
 import org.sonarsource.sonarqube.mcp.tools.SchemaToolBuilder;
 import org.sonarsource.sonarqube.mcp.tools.Tool;
+import org.sonarsource.sonarqube.mcp.tools.ToolCategory;
 
 public class ToggleAutomaticAnalysisTool extends Tool {
 
@@ -35,7 +36,8 @@ public ToggleAutomaticAnalysisTool(SonarQubeIdeBridgeClient bridgeClient) {
         "When enabled, SonarQube for IDE will automatically analyze files as they are modified in the working directory. " +
         "When disabled, automatic analysis is turned off.")
       .addBooleanProperty(ENABLED_PROPERTY, "Enable or disable the automatic analysis")
-      .build());
+      .build(),
+      ToolCategory.ANALYSIS);
     this.bridgeClient = bridgeClient;
   }
 

src/main/java/org/sonarsource/sonarqube/mcp/tools/dependencyrisks/SearchDependencyRisksTool.java

@@ -22,6 +22,7 @@
 import org.sonarsource.sonarqube.mcp.serverapi.sca.response.DependencyRisksResponse;
 import org.sonarsource.sonarqube.mcp.tools.SchemaToolBuilder;
 import org.sonarsource.sonarqube.mcp.tools.Tool;
+import org.sonarsource.sonarqube.mcp.tools.ToolCategory;
 
 public class SearchDependencyRisksTool extends Tool {
 
@@ -43,7 +44,8 @@ public SearchDependencyRisksTool(ServerApiProvider serverApiProvider, SonarQubeV
       .addStringProperty(BRANCH_KEY_PROPERTY, "The branch key")
       .addStringProperty(PULL_REQUEST_KEY_PROPERTY, "The pull request key")
       .setReadOnlyHint()
-      .build());
+      .build(),
+      ToolCategory.DEPENDENCY_RISKS);
     this.serverApiProvider = serverApiProvider;
     this.sonarQubeVersionChecker = sonarQubeVersionChecker;
   }

src/main/java/org/sonarsource/sonarqube/mcp/tools/enterprises/ListEnterprisesTool.java

@@ -21,6 +21,7 @@
 import org.sonarsource.sonarqube.mcp.serverapi.enterprises.response.ListResponse;
 import org.sonarsource.sonarqube.mcp.tools.SchemaToolBuilder;
 import org.sonarsource.sonarqube.mcp.tools.Tool;
+import org.sonarsource.sonarqube.mcp.tools.ToolCategory;
 
 public class ListEnterprisesTool extends Tool {
 
@@ -30,7 +31,7 @@ public class ListEnterprisesTool extends Tool {
   private final ServerApiProvider serverApiProvider;
 
   public ListEnterprisesTool(ServerApiProvider serverApiProvider) {
-    super(createToolDefinition());
+    super(createToolDefinition(), ToolCategory.PORTFOLIOS);
     this.serverApiProvider = serverApiProvider;
   }