How to Selectively Enable or Disable Tool Categories in Chrome DevTools MCP

Use the --no-category-<name> CLI flags (e.g., --no-category-emulation, --no-category-network) when starting the server, or pass equivalent options programmatically via parseArguments() to filter which tool sets are registered.

Chrome DevTools MCP (Model Context Protocol) organizes its automation capabilities into distinct tool categories such as emulation, network, performance, and extensions. When running the ChromeDevTools/chrome-devtools-mcp server, you can selectively enable or disable these categories to control which tools are exposed to AI clients, reducing overhead and limiting scope to only the capabilities you need.

Understanding Tool Categories in MCP

The MCP server categorizes tools to allow granular control over the Chrome DevTools Protocol (CDP) surface area exposed to LLMs.

Where Categories Are Defined

Tool categories are enumerated in src/tools/categories.ts. The ToolCategory enum defines the available classifications:

// src/tools/categories.ts
export enum ToolCategory {
  EMULATION = 'emulation',
  NETWORK = 'network',
  PERFORMANCE = 'performance',
  EXTENSIONS = 'extensions',
}

Each tool definition in the codebase (e.g., src/tools/emulation.ts, src/tools/network.ts) annotates its ToolDefinition with a category property drawn from this enum.

CLI Flag Definitions

The command-line interface declares boolean flags for each category in src/cli.ts. By default, emulation, network, and performance are enabled (true), while extensions is disabled (false):

// src/cli.ts (simplified)
.option('categoryEmulation', {
  type: 'boolean',
  default: true,
  description: 'Enable tools in the emulation category'
})
.option('categoryNetwork', {
  type: 'boolean',
  default: true,
  description: 'Enable tools in the network category'
})
// ... similar for performance and extensions

The yargs library automatically generates negated forms (--no-<flag>), allowing you to disable categories via --no-category-emulation, --no-category-network, etc.

How to Disable Specific Tool Categories

You can selectively disable tool categories when launching the MCP server from the command line or programmatically.

Disabling Emulation Tools

To disable all device emulation, viewport manipulation, and user agent spoofing tools:

npx chrome-devtools-mcp@latest --no-category-emulation

This sets categoryEmulation to false, causing the server to skip registration of any tool where category === ToolCategory.EMULATION.

Disabling Network Tools

To disable network interception, throttling, and request blocking capabilities:

npx chrome-devtools-mcp@latest --no-category-network

Disabling Performance Tools

To disable performance monitoring, tracing, and profiling tools:

npx chrome-devtools-mcp@latest --no-category-performance

Handling Extensions (Disabled by Default)

The extensions category is unique in that it defaults to false. To enable extension management tools (loading, unloading, and querying Chrome extensions):

npx chrome-devtools-mcp@latest --category-extensions

To explicitly keep it disabled (redundant but explicit):

npx chrome-devtools-mcp@latest --no-category-extensions

Programmatic Configuration

When embedding the MCP server as a library, you can pass category flags directly to the argument parser.

Using parseArguments()

Import parseArguments from src/cli.ts and provide an array of CLI-style flags:

import { parseArguments } from './src/cli.js';
import { runServer } from './src/main.js';

// Disable emulation and network, enable extensions
const args = parseArguments('1.0.0', [
  '--no-category-emulation',
  '--no-category-network',
  '--category-extensions',
]);

// Start the server with filtered categories
await runServer(args);

The args object returned by parseArguments() contains boolean properties (categoryEmulation, categoryNetwork, etc.) that runServer uses to filter tool registration.

How Category Filtering Works Under the Hood

The selective enable/disable mechanism is implemented in src/main.ts within the registerTool() function.

The Registration Guard

When the server initializes, it iterates over all tool definitions. For each tool, registerTool() checks the corresponding category flag:

// src/main.ts (conceptual flow)
function registerTool(tool: ToolDefinition, args: Arguments) {
  // Check if the tool's category is enabled
  if (tool.category === ToolCategory.EMULATION && !args.categoryEmulation) {
    return; // Skip registration
  }
  if (tool.category === ToolCategory.NETWORK && !args.categoryNetwork) {
    return;
  }
  // ... similar checks for performance and extensions
  
  // If we reach here, register the tool with the MCP server
  server.tool(tool.name, tool.description, tool.schema, tool.handler);
}

If a category flag is false, the function returns early and the tool is never exposed to the MCP client. This reduces the tool surface area visible to AI models and eliminates unnecessary CDP overhead for disabled categories.

Summary

• Tool categories (emulation, network, performance, extensions) are defined in src/tools/categories.ts via the ToolCategory enum.
• CLI flags (--category-emulation, --category-network, etc.) control activation, with negated forms (--no-category-*) available to disable categories.
• Default behavior: Emulation, network, and performance are enabled by default; extensions are disabled by default.
• Registration filtering occurs in src/main.ts where registerTool() skips tools whose category flag is false, preventing them from appearing in the MCP protocol.

Frequently Asked Questions

What are the default category settings in Chrome DevTools MCP?

By default, the emulation, network, and performance categories are enabled (true), while the extensions category is disabled (false). This default configuration is hardcoded in src/cli.ts and can be overridden using the respective CLI flags.

Can I enable extensions while disabling other categories?

Yes. Since extensions default to false, you must explicitly enable them with --category-extensions while disabling other categories with their --no-category-* counterparts. For example: npx chrome-devtools-mcp@latest --category-extensions --no-category-emulation --no-category-network.

How does MCP handle tools when their category is disabled?

When a category is disabled, the registerTool() function in src/main.ts performs an early return before registering those tools with the MCP server. Consequently, disabled tools never appear in the tool list sent to AI clients and cannot be invoked, effectively removing that CDP surface area from the session.

Is it possible to toggle categories after the server starts?

No. Category selection is determined at server startup during the argument parsing phase in src/cli.ts and the subsequent tool registration loop in src/main.ts. There is no runtime API to dynamically enable or disable categories after initialization; you must restart the server with different flags to change the active tool set.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}