What can you do with this server?

The CanIUse MCP server provides intelligent browser compatibility checking and automated toolchain configuration for web development projects. • Smart Project Scanning: Automatically detect CSS/JS features in your codebase and analyze compatibility across configurable browser targets • Feature Compatibility Checking: Test specific features (e.g., css-variables, promise-allsettled) or files against multiple browser environments with detailed analysis • Actionable Remediation: Get polyfill recommendations, npm installation commands, and code examples for unsupported features • Build Tool Configuration: Generate complete configurations for Babel, PostCSS, Webpack, CI/CD, and Git hooks tailored to your browser targets • Configuration Management: Set browser baselines, manage polyfills, create custom targets, and define feature overrides • Polyfill-Aware Analysis: Account for implemented polyfills when determining feature support for accurate compatibility reporting • Framework Support: Works with React, Vue, Angular, and vanilla JavaScript projects • MCP Integration: Designed for AI-powered clients like Cursor IDE and Claude Desktop

Which integrations are available for this server?

Generates Autoprefixer configurations for CSS browser compatibility and provides PostCSS setup with custom browser targets Automatically generates Babel configurations with browser-specific presets and polyfill recommendations for JavaScript compatibility Analyzes CSS features and properties for browser compatibility, detects unsupported features in codebases, and provides fallback strategies Supports Firefox browser compatibility checking including Firefox ESR versions for enterprise environments Integrates browser compatibility checking into Git workflows through pre-commit hooks and automated project scanning Provides CI/CD pipeline integration for automated browser compatibility checking in GitHub Actions workflows Analyzes JavaScript features and APIs for browser support, detects compatibility issues in JS codebases, and recommends polyfills Provides specific npm install commands for polyfills and compatibility tools, manages package recommendations for browser support Generates PostCSS configurations with browser-specific plugins and autoprefixer settings for CSS compatibility Integrates browser compatibility checking into pre-commit hooks using Husky for automated code quality validation Provides React-specific browser compatibility configurations and build tool setup for React applications Supports Safari browser compatibility checking including iOS Safari versions for mobile web development Generates Webpack configurations optimized for specific browser targets with appropriate polyfills and build settings

How do I use CanIUse MCP?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@CanIUse MCP scan my project for browser compatibility issues" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

CanIUse MCP

by Amirmahdi-Kaheh

Overview Schema Source Related Servers Discussions Admin

JavaScript

Remote

🚀 CanIUse MCP Server - Browser Compatibility Intelligence

A powerful Model Context Protocol (MCP) server that provides intelligent CSS/JS feature compatibility checking with configurable browser targets, polyfill support, and smart project scanning. Perfect for web developers using AI-powered tools like Cursor, Claude, and other MCP-compatible clients.

npm version License: MIT

✨ Key Features

🔍 Smart Project Scanning: Automatically detect CSS/JS features in your codebase
🎯 Configurable Browser Targets: Support for any browser version with custom baselines
💊 Polyfill-Aware Checking: Mark features as "supported" when you have polyfills available
⚡ Batch Compatibility Analysis: Check entire projects across multiple browsers instantly
🛠️ Actionable Remediation: Get specific npm install commands, code examples, and configs
📋 Complete Toolchain Generation: Auto-generate Babel, PostCSS, Webpack, and CI configurations
🔧 Runtime Configuration: Configure via files, environment variables, or MCP commands

Related MCP server: Error Debugging MCP Server

📦 Installation

Global Installation (Recommended)

npm install -g caniuse-mcp-server

Local Installation

npm install caniuse-mcp-server

🔌 Setup for MCP Clients

Option 1: Global Installation (Recommended)

First, install the package globally:

npm install -g caniuse-mcp-server

Cursor IDE

Add to your Cursor settings (Cmd/Ctrl + , → MCP):

{
  "mcpServers": {
    "caniuse": {
      "command": "caniuse-mcp-server",
      "args": [],
      "env": {}
    }
  }
}

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "caniuse": {
      "command": "caniuse-mcp-server",
      "args": [],
      "env": {}
    }
  }
}

Option 2: Using npx (Alternative)

If global installation doesn't work, use npx:

Cursor IDE

{
  "mcpServers": {
    "caniuse": {
      "command": "npx",
      "args": ["caniuse-mcp-server"],
      "env": {}
    }
  }
}

Claude Desktop

{
  "mcpServers": {
    "caniuse": {
      "command": "npx",
      "args": ["caniuse-mcp-server"],
      "env": {}
    }
  }
}

Option 3: Direct Node.js Path

If you have issues with command resolution:

Find your global npm bin path:

npm config get prefix
# On macOS/Linux, usually: /usr/local/bin or ~/.npm-global/bin
# On Windows: C:\Users\[username]\AppData\Roaming\npm

Use full path in MCP configuration:

{
  "mcpServers": {
    "caniuse": {
      "command": "/usr/local/bin/caniuse-mcp-server",
      "args": [],
      "env": {}
    }
  }
}

⚡ Quick Start

1. Basic Compatibility Check

// Check your project against default baseline (Chrome 37)
scan_project

2. Configure Your Target Browser

// Set up for Chrome 57 with CSS Variables polyfill
manage_config {
  "action": "set_baseline",
  "baseline": "chrome-57"
}

manage_config {
  "action": "add_polyfill", 
  "polyfill": "css-variables"
}

3. Check Specific Features

// Check if features work in your target browsers
check_compatibility {
  "features": ["css-variables", "promise-allsettled"],
  "targets": ["chrome-57", "firefox-70"]
}

4. Get Fix Recommendations

// Get actionable remediation steps
get_fixes {
  "features": ["css-grid", "arrow-functions"],
  "includeCommands": true,
  "includeExamples": true
}

🛠️ Available Tools

Core Tools

`scan_project` - Smart Project Analysis

Automatically scans your project and detects compatibility issues.

// Basic project scan
scan_project

// Advanced scanning with custom targets
scan_project {
  "projectPath": "./src",
  "targets": ["chrome-57", "firefox-esr", "safari-12"],
  "maxDepth": 3,
  "excludeDirs": ["node_modules", "dist"]
}

`check_compatibility` - Feature Testing

Check specific features or files against browser targets.

// Test specific features
check_compatibility {
  "features": ["css-variables", "promise-allsettled"],
  "targets": ["chrome-57", "firefox-70"]
}

// Analyze specific files
check_compatibility {
  "files": ["src/styles/main.css", "src/utils/async.js"],
  "targets": ["chrome-57"]
}

`get_fixes` - Get Solutions

Receive actionable remediation steps and polyfill recommendations.

get_fixes {
  "features": ["css-variables", "promise-allsettled"],
  "priority": "critical",
  "includeExamples": true,
  "includeCommands": true
}

`generate_configs` - Build Tool Setup

Generate complete build configurations for your toolchain.

generate_configs {
  "configType": "all",
  "target": "chrome-57",
  "includePolyfills": true,
  "projectType": "react"
}

`manage_config` - Configuration Management

Configure baselines, polyfills, and browser targets.

// View current configuration
manage_config { "action": "view" }

// Set baseline browser
manage_config { 
  "action": "set_baseline", 
  "baseline": "chrome-57" 
}

// Add polyfill support
manage_config { 
  "action": "add_polyfill", 
  "polyfill": "css-variables" 
}

// Add custom browser target
manage_config {
  "action": "add_target",
  "targetName": "chrome-65",
  "browser": "chrome",
  "version": "65"
}

🎯 Browser Targets Supported

Target	Browser	Version	Use Case
`chrome-37`	Chrome	37	Legacy Android support
`chrome-latest`	Chrome	Latest	Modern development
`firefox-esr`	Firefox	78 ESR	Enterprise compatibility
`safari-12`	Safari	12	iOS 12+ support
`ie-11`	Internet Explorer	11	Legacy Windows support
`edge-legacy`	Edge	18	Pre-Chromium Edge

🔧 Configuration

Configuration File (`.caniuse-config.json`)

Create a .caniuse-config.json in your project root to customize behavior:

{
  "defaultBaseline": "chrome-57",
  "customTargets": {
    "chrome-57": { "browser": "chrome", "version": "57" },
    "chrome-65": { "browser": "chrome", "version": "65" }
  },
  "polyfills": [
    "css-variables", 
    "promise-allsettled"
  ],
  "overrides": {
    "css-variables": "supported",
    "promise-allsettled": "supported"
  }
}

Quick Configuration Setup

// Create a configuration template
manage_config { "action": "create_template" }

// Or use pre-built examples

Copy example configurations from the examples/ directory:

# CSS Variables support for older browsers
cp node_modules/caniuse-mcp-server/examples/css-variables-polyfill.json .caniuse-config.json

# Promise.allSettled polyfill configuration  
cp node_modules/caniuse-mcp-server/examples/promise-allsettled-polyfill.json .caniuse-config.json

# Enterprise multi-browser support
cp node_modules/caniuse-mcp-server/examples/enterprise-config.json .caniuse-config.json

Environment Variables

Configure via environment variables for CI/CD:

# Set default baseline
export CANIUSE_DEFAULT_BASELINE="chrome-57"

# Configure polyfills
export CANIUSE_POLYFILLS='["css-variables","promise-allsettled"]'

# Set feature overrides
export CANIUSE_OVERRIDES='{"css-variables":"supported","promise-allsettled":"supported"}'

💡 Real-World Use Cases

1. CSS Variables Polyfill Support

// Set up CSS Variables for older browsers
manage_config {
  "action": "add_polyfill",
  "polyfill": "css-variables" 
}

manage_config {
  "action": "set_override",
  "feature": "css-variables",
  "override": "supported"
}

// Now CSS Variables will be treated as supported
check_compatibility {
  "features": ["css-variables"],
  "targets": ["chrome-40", "ie-11"]
}

2. Promise.allSettled Polyfill Support

// Configure Promise.allSettled polyfill
manage_config {
  "action": "add_polyfill",
  "polyfill": "promise-allsettled"
}

// Set baseline to older Chrome that needs polyfill
manage_config {
  "action": "set_baseline", 
  "baseline": "chrome-60"
}

// Check compatibility - will show as supported due to polyfill
check_compatibility {
  "features": ["promise-allsettled"],
  "targets": ["chrome-60", "firefox-70"]
}

// Get implementation guidance
get_fixes {
  "features": ["promise-allsettled"],
  "includeCommands": true,
  "includeExamples": true
}

3. Enterprise Legacy Browser Support

// Scan for enterprise browser compatibility
scan_project {
  "targets": ["chrome-50", "firefox-esr", "safari-12", "ie-11"]
}

// Configure extensive polyfill support
manage_config { "action": "create_template" }
// Edit .caniuse-config.json to include:
// "polyfills": ["css-variables", "promise-allsettled", "fetch", "object-assign"]

4. Modern Development with Progressive Enhancement

// Check latest browser features
check_compatibility {
  "features": ["css-container-queries", "css-cascade-layers"],
  "targets": ["chrome-latest", "firefox-latest", "safari-latest"]
}

// Get fallback strategies
get_fixes {
  "features": ["css-container-queries"],
  "includeExamples": true
}

📈 Enhanced Output Examples

Scan Project Output

{
  "status": "completed",
  "project": {
    "path": "./src",
    "scanned": "24 files",
    "jsFiles": 12,
    "cssFiles": 8,
    "featuresDetected": 15
  },
  "compatibility": {
    "targets": ["chrome-37"],
    "overallScore": 73,
    "criticalIssues": 3,
    "commonUnsupported": ["css-grid", "arrow-functions", "const"]
  },
  "recommendations": [
    {
      "type": "critical",
      "title": "Critical Features Unsupported",
      "message": "These essential features are unsupported: css-grid, arrow-functions",
      "action": "Implement polyfills or use alternative approaches immediately"
    }
  ],
  "nextSteps": [
    {
      "step": 1,
      "title": "Get specific fixes",
      "command": "Use get_fixes tool with features: css-grid, arrow-functions, const",
      "priority": "high"
    }
  ]
}

Get Fixes Output

{
  "features": ["css-grid"],
  "fixes": [
    {
      "feature": "css-grid",
      "priority": "critical",
      "alternatives": ["flexbox", "CSS tables", "float layouts"],
      "polyfills": ["CSS Grid Polyfill"],
      "commands": [
        {
          "type": "install",
          "description": "Install css-grid polyfills",
          "command": "npm install postcss-grid-kiss --save-dev"
        }
      ],
      "cssExample": "/* Instead of Grid */\n.container { display: grid; }\n\n/* Use Flexbox */\n.container { display: flex; }"
    }
  ],
  "quickStart": [
    {
      "step": 1,
      "title": "Install critical polyfills",
      "command": "npm install css-grid-polyfill --save",
      "priority": "critical"
    }
  ]
}

🔧 Configuration Examples

Babel Configuration (.babelrc)

{
  "presets": [
    ["@babel/preset-env", {
      "targets": { "chrome": "37" },
      "useBuiltIns": "usage",
      "corejs": 3
    }],
    "@babel/preset-react"
  ]
}

PostCSS Configuration

module.exports = {
  plugins: {
    'autoprefixer': {
      overrideBrowserslist: ['Chrome >= 37']
    },
    'postcss-custom-properties': {
      preserve: false
    }
  }
};

🏗️ Development Workflow Integration

Git Hooks

# .husky/pre-commit
echo "🔍 Checking browser compatibility..."
npx caniuse-mcp-server scan_project

CI/CD Pipeline

# .github/workflows/compatibility.yml
- name: Check Browser Compatibility
  run: |
    npm install -g caniuse-mcp-server
    caniuse-mcp-server scan_project
    caniuse-mcp-server get_fixes --features="css-grid,promise-allsettled"

🚨 Troubleshooting

Common Issues

"No tools found" Error in Cursor/Claude

This is the most common issue. Try these solutions in order:

1. Verify Global Installation

# Check if package is installed globally
npm list -g caniuse-mcp-server

# If not installed, install globally
npm install -g caniuse-mcp-server

# Test the command directly
caniuse-mcp-server
# Should show: "🚀 Enhanced CanIUse MCP Server running on stdio"

2. Check Your PATH

# Verify npm global bin is in your PATH
echo $PATH | grep $(npm config get prefix)/bin

# If not found, add to your shell profile (~/.bashrc, ~/.zshrc, etc.)
export PATH="$(npm config get prefix)/bin:$PATH"

# Then restart your terminal and MCP client

3. Try Different Installation Methods

# Method 1: Clean reinstall
npm uninstall -g caniuse-mcp-server
npm install -g caniuse-mcp-server

# Method 2: Install without global flag and use npx
npm install caniuse-mcp-server
# Then use "npx caniuse-mcp-server" in MCP config

# Method 3: Install via different package manager
# Using yarn
yarn global add caniuse-mcp-server

# Using pnpm
pnpm add -g caniuse-mcp-server

4. Update MCP Configuration Format Make sure your Cursor/Claude configuration uses the correct format:

❌ Incorrect:

{
  "mcpServers": {
    "caniuse": {
      "command": "caniuse-mcp-server"
    }
  }
}

✅ Correct:

{
  "mcpServers": {
    "caniuse": {
      "command": "caniuse-mcp-server",
      "args": [],
      "env": {}
    }
  }
}

5. Test MCP Server Manually

# Test if the server responds to MCP protocol
echo '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}' | caniuse-mcp-server

# Should return a JSON response with available tools

Other Common Issues

"Module not found" errors

# Make sure package is installed correctly
npm install -g caniuse-mcp-server

# Clear npm cache if needed
npm cache clean --force

# Or use npx for one-time execution
npx caniuse-mcp-server

Configuration not loading

# Check if config file exists and is valid JSON
cat .caniuse-config.json | jq '.'

# Reset to defaults if corrupted
manage_config { "action": "reset" }

Polyfills not working

// Verify polyfill is added
manage_config { "action": "view" }

// Check override is set
manage_config {
  "action": "set_override",
  "feature": "css-variables",
  "override": "supported"
}

Permission errors on macOS/Linux

# Fix npm permissions
sudo chown -R $(whoami) $(npm config get prefix)/{lib/node_modules,bin,share}

# Or reinstall npm with a node version manager
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install node

Platform-Specific Issues

macOS

# If using Homebrew node
brew reinstall node

# Check npm prefix
npm config set prefix ~/.npm-global
export PATH=~/.npm-global/bin:$PATH

Windows

# Run as Administrator and install globally
npm install -g caniuse-mcp-server

# Add npm global path to system PATH
# Usually: C:\Users\[username]\AppData\Roaming\npm

Linux

# Use node version manager to avoid permission issues
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

Debug Mode

Enable verbose logging with environment variables:

export DEBUG="caniuse-mcp-server*"
caniuse-mcp-server

Still Having Issues?

Check Node.js version: Requires Node.js 18+
```
node --version
```
Verify npm configuration:
```
npm config list
npm doctor
```

Try a clean environment:

# Create a test directory
mkdir test-caniuse && cd test-caniuse
npx caniuse-mcp-server

Report the issue: If none of the above work, please open an issue at https://github.com/Amirmahdi-Kaheh/caniuse-mcp/issues with:
- Your operating system
- Node.js version (node --version)
- npm version (npm --version)
- Complete error message
- MCP client you're using (Cursor, Claude Desktop, etc.)

🔗 Links & Resources

NPM Package: https://www.npmjs.com/package/caniuse-mcp-server
Can I Use Database: https://caniuse.com
Model Context Protocol: https://docs.anthropic.com/en/docs/build-with-claude/mcp
Cursor IDE: https://cursor.sh
Claude Desktop: https://claude.ai/desktop

🤝 Contributing

We welcome contributions! Please see our contributing guidelines:

Report Issues: Found a bug or missing feature? Open an issue
Feature Requests: Have ideas for new functionality? Let us know
Pull Requests: Want to contribute code? Fork and submit a PR
Documentation: Help improve our docs and examples

Development Setup

git clone <your-fork-url>
cd caniuse-mcp-server
npm install
npm run dev  # Start in development mode

📊 Why Use CanIUse MCP?

Before

Manual caniuse.com lookups
Guessing at polyfill needs
Trial-and-error browser testing
Separate compatibility checking tools

After

AI-powered compatibility analysis
Automated polyfill recommendations
Smart project-wide scanning
Integrated development workflow

70% faster compatibility checking with actionable results 🚀

📄 License

Built for the developer community - Free to use, modify, and distribute.

Available Tools

5 tools

check_compatibilityCompatibility CheckerC

Check specific features or files against multiple browser targets with detailed analysis

ParametersJSON Schema

Name	Required	Description
`features`	No	Specific caniuse feature names to check (e.g., 'flexbox', 'css-grid')
`files`	No	Specific file paths to analyze for features
`targets`	No	Browser targets (chrome-37, firefox-esr, safari-12, ie-11, edge-legacy)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'detailed analysis' but doesn't specify what that entails—e.g., output format, performance implications, rate limits, or authentication needs. For a tool with no annotation coverage, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose. It avoids redundancy and waste, making it easy to parse. However, it could be slightly more structured by explicitly separating feature and file checks, but this is minor.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (3 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits, output format, and usage guidelines. Without annotations or an output schema, the agent is left guessing about the tool's full behavior and results, making this inadequate for effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds minimal value beyond the schema by implying the tool checks 'specific features or files' against 'multiple browser targets,' but it doesn't provide additional syntax, format details, or usage examples. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Check specific features or files against multiple browser targets with detailed analysis.' It specifies the verb ('check'), resources ('features or files'), and scope ('multiple browser targets'). However, it doesn't explicitly differentiate from sibling tools like 'scan_project' or 'get_fixes,' which might have overlapping functionality, preventing a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'scan_project' or 'get_fixes,' nor does it specify prerequisites, exclusions, or typical use cases. This leaves the agent without context for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_configsConfig GeneratorC

Generate complete build configurations, CI/CD setups, and workflow files for browser compatibility

ParametersJSON Schema

Name	Required	Description	Default
`configType`	No	Type of configuration to generate	all
`target`	No	Primary browser target for configuration	chrome-37
`includePolyfills`	No	Include polyfill configurations
`projectType`	No	Project framework type	react

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'generates' configurations, implying a creation/write operation, but doesn't disclose critical traits like whether this overwrites existing files, requires specific permissions, has side effects, or handles errors. For a tool with no annotations and potential file system impacts, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose without unnecessary details. Every word contributes to understanding the tool's function, and there is no redundancy or wasted phrasing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (generating multiple configuration types with 4 parameters) and the absence of both annotations and an output schema, the description is incomplete. It doesn't address behavioral risks, output format, or integration context, leaving significant gaps for an AI agent to infer safe and correct usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with all parameters well-documented in the schema itself (e.g., 'configType' with enum values, 'target' as browser target). The description adds no additional parameter semantics beyond what the schema provides, such as explaining interactions between parameters or usage examples. With high schema coverage, the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate complete build configurations, CI/CD setups, and workflow files for browser compatibility.' It specifies the verb 'generate' and the resources (configurations, setups, files) with a clear scope (browser compatibility). However, it doesn't explicitly differentiate from sibling tools like 'manage_config' or 'scan_project', which likely have overlapping domains.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'check_compatibility' or 'manage_config', nor does it specify prerequisites, exclusions, or contextual triggers. Usage is implied by the purpose but not explicitly stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_fixesFix GeneratorA

Get actionable remediation steps, polyfills, and alternatives for unsupported features

ParametersJSON Schema

Name	Required	Description	Default
`features`	Yes	Features that need fixes (from compatibility check results)
`priority`	No	Filter fixes by priority level	all
`includeExamples`	No	Include code examples in the response
`includeCommands`	No	Include terminal commands for installation/setup

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It mentions the types of outputs (remediation steps, polyfills, alternatives) but doesn't disclose behavioral traits like whether this is a read-only operation, potential rate limits, authentication needs, or what happens if features are invalid. For a tool with no annotation coverage, this is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part earns its place by specifying what is retrieved and for what purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description is minimally complete for a tool that likely returns informational content. It covers the purpose but lacks details on behavioral aspects and output format, which are important for an agent to use it correctly without structured output guidance.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add any meaning beyond what the schema provides about parameters like 'features', 'priority', etc. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get' and specifies the resources: 'actionable remediation steps, polyfills, and alternatives for unsupported features'. It distinguishes from siblings like 'check_compatibility' (which likely identifies issues) by focusing on generating solutions rather than detecting problems.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage after compatibility issues are identified (via 'from compatibility check results' in the schema), suggesting it follows 'check_compatibility'. However, it doesn't explicitly state when to use this tool versus alternatives like 'generate_configs' or 'manage_config', leaving some ambiguity about workflow context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

manage_configConfig ManagerC

Configure browser baselines, polyfills, and feature overrides for more accurate compatibility checking

ParametersJSON Schema

Name	Required	Description	Default
`action`	No	Configuration action to perform	view
`baseline`	No	Set default baseline browser target (e.g., 'chrome-37', 'chrome-57')
`polyfill`	No	Feature name to add/remove from polyfills list
`feature`	No	Feature name for override setting
`override`	No	Force feature support status
`targetName`	No	Custom target name (e.g., 'chrome-57')
`browser`	No	Browser name for custom target
`version`	No	Browser version for custom target

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool's purpose but doesn't describe what happens during operations (e.g., whether 'reset' is destructive, if changes persist, authentication needs, rate limits, or error conditions). This is inadequate for a tool with 8 parameters and multiple action types.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded with the core functionality.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 8 parameters, multiple action types, and no annotations or output schema, the description is insufficient. It doesn't explain what the tool returns, how different actions behave, or provide enough context for an agent to understand the tool's full scope and limitations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions the general categories (baselines, polyfills, overrides) but provides no additional syntax, format details, or usage examples.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: configuring browser baselines, polyfills, and feature overrides for compatibility checking. It uses specific verbs ('configure') and resources ('browser baselines, polyfills, and feature overrides'), but doesn't explicitly distinguish it from sibling tools like 'generate_configs' or 'check_compatibility'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'check_compatibility' or 'generate_configs', nor does it specify prerequisites, exclusions, or appropriate contexts for its use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_projectProject ScannerC

Analyze project files to detect CSS/JS features and check compatibility across browser targets

ParametersJSON Schema

Name	Required	Description	Default
`projectPath`	No	Path to the project directory to scan (default: current directory)	.
`targets`	No	Browser targets to check (e.g., 'chrome-37', 'firefox-esr', 'safari-12')
`maxDepth`	No	Maximum directory depth to scan
`excludeDirs`	No	Directories to exclude from scanning

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. While it mentions what the tool does (analyzing and checking compatibility), it doesn't describe important behavioral aspects: whether this is a read-only operation, what the output format looks like, whether it modifies files, performance characteristics, or error handling. For a scanning tool with 4 parameters and no annotations, this leaves significant gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for the tool's complexity and front-loads the core functionality. Every word earns its place by conveying essential information about what the tool does.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a scanning tool with 4 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what the output looks like (compatibility reports? feature lists? error summaries?), doesn't mention whether this is a safe read operation, and provides no context about performance or limitations. The agent would be left guessing about important operational aspects.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all 4 parameters thoroughly with descriptions and defaults. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters, provide examples beyond what's in the schema, or clarify edge cases. The baseline of 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Analyze project files to detect CSS/JS features and check compatibility across browser targets.' It specifies the verb ('analyze'), resource ('project files'), and what it detects ('CSS/JS features') plus the compatibility checking function. However, it doesn't explicitly differentiate from sibling tools like 'check_compatibility' or 'get_fixes' which might have overlapping functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'check_compatibility' or 'get_fixes'. It doesn't mention prerequisites, when-not-to-use scenarios, or how it differs from sibling tools. The agent would have to infer usage from the tool name and description alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

13 tool updatesv1.0.0Jan 3, 2026
- Changedcheck_compatibility3 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
  - removedInput schema / required
```
Removed value: -[]
```
- Removedcheck_css_modules_compatibility
- Removedcheck_feature_support
- Removedcheck_multiple_features
- Removedcheck_react_compatibility
- Removedgenerate_component_template
- Changedgenerate_configs3 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
  - removedInput schema / required
```
Removed value: -[]
```
- Removedgenerate_css_fallbacks
- Removedget_build_config
- Changedget_fixes2 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedmanage_config3 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
  - removedInput schema / required
```
Removed value: -[]
```
- Changedscan_project3 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
  - removedInput schema / required
```
Removed value: -[]
```
- Removedsuggest_alternatives
13 tool updatesSep 20, 2025
- First observedcheck_compatibility
- First observedcheck_css_modules_compatibility
- First observedcheck_feature_support
- First observedcheck_multiple_features
- First observedcheck_react_compatibility
- First observedgenerate_component_template
- First observedgenerate_configs
- First observedgenerate_css_fallbacks
- First observedget_build_config
- First observedget_fixes
- First observedmanage_config
- First observedscan_project
- First observedsuggest_alternatives

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.6/5.0

Scored 2026-04-18 08:35 across 5 tools

Disambiguation5/5

Each tool has a clearly distinct purpose with no overlap: check_compatibility for specific feature analysis, generate_configs for build setup, get_fixes for remediation, manage_config for configuration, and scan_project for project-wide analysis. The descriptions clearly differentiate their scopes, making misselection unlikely.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern (e.g., check_compatibility, generate_configs, get_fixes, manage_config, scan_project). The naming is uniform and predictable, using snake_case throughout with clear action-oriented verbs.

Tool Count5/5

With 5 tools, the count is well-scoped for a browser compatibility server. Each tool earns its place by covering distinct aspects of the domain, from checking and scanning to configuration and remediation, without being too sparse or bloated.

Completeness5/5

The tool set provides complete coverage for browser compatibility workflows: checking features, scanning projects, generating configurations, managing settings, and getting fixes. There are no obvious gaps, as it supports the full lifecycle from detection to resolution.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Reddit Discussion

Related Servers

Related MCP Connectors

browser-compat-mcp-server A
io.github.cyanheads
Browser compatibility and Baseline status for any web feature — offline, from bundled MDN data.
Developer Tools Documentation Access
51
can-i-use A
ai.kaiv
Browser support for web features, live from caniuse. From which version, and is it safe to ship?
Developer Tools Browser Automation Documentation Access
31
dropcoin-a11y A
io.github.freshfos
Accessibility pre-checks (WCAG/BFSG) in a real browser + statement drafts. Pay per call.
Testing & QA Tools Browser Automation
21
validator
dev.swatchdog
On-demand drift checks: declared CSS color, radius, spacing & type vs your own tokens or a pack
Design Tools Developer Tools
26

Related MCP Servers

Dev Advisor MCP Server
Developer Tools Code Analysis Documentation Access
mukiwu
A
license
A
quality
D
maintenance
Analyzes JavaScript/TypeScript projects for code modernization opportunities, checks browser compatibility via Can I Use, searches MDN documentation, and recommends modern Web API alternatives to reduce bundle size and improve performance.
Updated 9 months ago (2025-12-12 18:08 UTC)
6
5 npm
5
MIT
Error Debugging MCP Server
Developer Tools Code Analysis Testing & QA Tools
firozanam
A
license
Not graded
quality
D
maintenance
Provides intelligent error detection and debugging capabilities across multiple programming languages with real-time monitoring of build, lint, runtime, console, and test errors. Offers AI-enhanced error analysis with automated resolution suggestions and context-aware debugging.
Updated a year ago (2025-07-03 05:15 UTC)
MIT
MCP Frontend Tools Server
Developer Tools Code Analysis Design Tools
ashios15
F
license
A
quality
D
maintenance
Provides AI assistants with frontend development tools including component scaffolding, bundle analysis, accessibility checks, and responsive design guidance. Enables automated generation of React components with tests and stories, bundle optimization recommendations, and WCAG compliance fixes.
Updated 4 months ago (2026-05-21 14:42 UTC)
6
-
Baseline Checker
Developer Tools Code Analysis
htshongany
A
license
A
quality
D
maintenance
Enables checking web feature compatibility with Baseline standards, analyzing HTML, CSS, and JavaScript code to provide detailed reports on Baseline status, browser support, and recommendations.
Updated a year ago (2025-10-06 12:17 UTC)
2
MIT

🚀 CanIUse MCP Server - Browser Compatibility Intelligence

✨ Key Features

📦 Installation

Global Installation (Recommended)

Local Installation

🔌 Setup for MCP Clients

Option 1: Global Installation (Recommended)

Cursor IDE

Claude Desktop

Option 2: Using npx (Alternative)

Cursor IDE

Claude Desktop

Option 3: Direct Node.js Path

Find your global npm bin path:

Use full path in MCP configuration:

⚡ Quick Start

1. Basic Compatibility Check

2. Configure Your Target Browser

3. Check Specific Features

4. Get Fix Recommendations

🛠️ Available Tools

Core Tools

scan_project - Smart Project Analysis

check_compatibility - Feature Testing

get_fixes - Get Solutions

generate_configs - Build Tool Setup

manage_config - Configuration Management

🎯 Browser Targets Supported

🔧 Configuration

Configuration File (.caniuse-config.json)

Quick Configuration Setup

Environment Variables

💡 Real-World Use Cases

1. CSS Variables Polyfill Support

2. Promise.allSettled Polyfill Support

3. Enterprise Legacy Browser Support

4. Modern Development with Progressive Enhancement

📈 Enhanced Output Examples

Scan Project Output

Get Fixes Output

🔧 Configuration Examples

Babel Configuration (.babelrc)

PostCSS Configuration

🏗️ Development Workflow Integration

Git Hooks

CI/CD Pipeline

🚨 Troubleshooting

Common Issues

"No tools found" Error in Cursor/Claude

Other Common Issues

Platform-Specific Issues

macOS

Windows

Linux

Debug Mode

Still Having Issues?

🔗 Links & Resources

🤝 Contributing

Development Setup

📊 Why Use CanIUse MCP?

Before

After

📄 License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

`scan_project` - Smart Project Analysis

`check_compatibility` - Feature Testing

`get_fixes` - Get Solutions

`generate_configs` - Build Tool Setup

`manage_config` - Configuration Management

Configuration File (`.caniuse-config.json`)