devtools MCP server
Commit Nov 11, 2026Provides an AI-ready interface for development tools including Go, Node.js, testing, linting, and Git workflows to improve code generation accuracy.
Also known as rshade/mcp-devtools-server
- Stars
- 5
- Tools
- 35
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 11, 2026
- License
- Apache-2.0
What is devtools MCP?
devtools provides an AI-ready interface for development tools including Go, Node.js, testing, linting, and Git workflows to improve code generation accuracy. It exposes 35 tools, such as eslint, markdownlint-cli, make_lint.
Summary generated from the project's README
About devtools MCP server
Developers using Claude Code can improve code generation accuracy and error correction by connecting this server to their local development environment. It provides a standardized interface for AI assistants to interact with common programming tools, reducing mistakes through consistent patterns and automated workflows. The server includes an onboarding wizard that automatically detects project types, frameworks, and build systems to generate a configuration file without manual input.
The toolset features extensive support for Go and Node.js/TypeScript, offering over 40 specialized tools. For Go developers, it includes commands for testing with race detection, building with custom ldflags, and vulnerability scanning via go_vulncheck. Node.js users can perform TypeScript type checking, security audits, and performance profiling. It also manages general tasks like linting Markdown and YAML files, running Make-based commands, and validating GitHub Actions workflows with actionlint. Intelligent caching is used throughout to improve performance during repeated queries.
What you can do with it
- 1Automated project environment setupAn AI can automatically configure its own development environment by detecting the project type and build system.
- 2Go language quality assuranceA developer can ask the AI to run Go tests with coverage and check for race conditions.
Written from the project's README. Every use case is checked against a quote from it.
devtools MCP tools 35
Detected from the READMEeslintmarkdownlint-climake_lintmake_testmake_dependmake_buildmake_cleango_testgo_buildgo_fmtgo_lintgo_vet
| eslint | — | |
| markdownlint-cli | — | |
| make_lint | — | |
| make_test | — | |
| make_depend | — | |
| make_build | — | |
| make_clean | — | |
| go_test | — | |
| go_build | — | |
| go_fmt | — | |
| go_lint | — | |
| go_vet | — |
Show all 35 toolsShow fewer tools
go_mod_tidygo_mod_downloadgo_benchmarkgo_generatego_workgo_vulncheckstaticcheckgo_project_infonodejs_project_infonodejs_testnodejs_lintnodejs_formatnodejs_check_typesnodejs_install_depsnodejs_versionnodejs_securitynodejs_buildnodejs_scriptsnodejs_benchmarknodejs_update_depsnodejs_compatibilitynodejs_profilejq_query
| go_mod_tidy | — | |
| go_mod_download | — | |
| go_benchmark | — | |
| go_generate | — | |
| go_work | — | |
| go_vulncheck | — | |
| staticcheck | — | |
| go_project_info | — | |
| nodejs_project_info | — | |
| nodejs_test | — | |
| nodejs_lint | — | |
| nodejs_format | — | |
| nodejs_check_types | — | |
| nodejs_install_deps | — | |
| nodejs_version | — | |
| nodejs_security | — | |
| nodejs_build | — | |
| nodejs_scripts | — | |
| nodejs_benchmark | — | |
| nodejs_update_deps | — | |
| nodejs_compatibility | — | |
| nodejs_profile | — | |
| jq_query | — |
Configuration
LOG_LEVEL
| Name | Description | |
|---|---|---|
| LOG_LEVEL | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablershade/mcp-devtools-server is public and reachablegithub.com/rshade/mcp-devtools-server ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-11github.com/rshade/mcp-devtools-server ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model35 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubMCP DevTools Server
An MCP (Model Context Protocol) server that standardizes and binds specific patterns for development tools, enabling Claude Code to generate code more efficiently with fewer errors and better autocorrection capabilities.
🚧 Project Status
Alpha - This project is in early development and actively evolving.
🎉 Major Milestone: Complete Language Support - We now have comprehensive support for both Go (13 tools) and Node.js/TypeScript (14 tools), making this a powerful DevTools server for modern development workflows. With intelligent caching, AI-powered suggestions, and zero-configuration onboarding, we're ready for the 0.0.1 release!
Documentation
- 📚 Full Documentation - Complete guide with examples and tutorials
- 🚀 Quick Start - Get started in 5 minutes
- 🛠️ Tools Reference - All 40+ available tools
- Contributing Guidelines - How to contribute to this project
- Code of Conduct - Community standards and expectations
- Security Policy - How to report security vulnerabilities
- Caching System - Intelligent caching for 3-5x performance improvements
- API Documentation - TypeDoc generated API documentation (run
npm run docs:api)
Overview
This MCP server creates a standardized interface between development tools and AI assistants like Claude Code. By establishing consistent patterns and best practices, it helps:
- Reduce code generation errors
- Enable better autocorrection of common issues
- Standardize development workflows
- Improve efficiency when working with Claude Code
Features
🎯 Zero-Configuration Onboarding Wizard
The onboarding wizard automatically detects your project type and generates optimal MCP DevTools configuration with zero user input required.
Quick Start:
# Run complete onboarding (auto-detects everything)
mcp-devtools onboarding_wizard
# Preview changes without writing files
mcp-devtools onboarding_wizard --dry-run true
# Detect project type only
mcp-devtools detect_project
Available Tools:
-
onboarding_wizard - Complete automated setup workflow
- Detects project type (Node.js, Python, Go, Rust, Java, .NET, Mixed)
- Identifies framework (React, Express, Django, Gin, etc.)
- Discovers build system (Make, npm, go, cargo, etc.)
- Generates
.mcp-devtools.jsonconfiguration - Verifies tool availability
- Creates backup of existing config
- Provides actionable recommendations
-
detect_project - Analyze project characteristics
- Returns comprehensive project profile
- Lists detected configuration files
- Identifies linting tools and test frameworks
- Shows Make targets if available
-
generate_config - Preview configuration without writing
- Generates configuration based on detection
- Validates against schema
- Shows warnings and errors
-
validate_setup - Validate existing configuration
- Checks command availability
- Verifies tool installation
- Validates configuration schema
- Provides health score (0-100)
- Lists errors, warnings, and recommendations
-
rollback_setup - Restore previous configuration
- Rollback from automatic backup
- Backups stored in
.mcp-devtools-backups/
Example Output:
## Onboarding Wizard Results
**Status:** ✅ Success
**Duration:** 2847ms
**Configuration:** /path/to/project/.mcp-devtools.json
**Backup:** /path/to/project/.mcp-devtools-backups/2025-11-04T10-30-00.json
### ⚠️ Skipped Tools (2)
- eslint
- markdownlint-cli
### 💡 Recommendations
#### High Priority
- **Install missing required tools** (tool)
Install eslint and markdownlint-cli for complete linting support
### Validation
**Score:** 95/100
**Errors:** 0
**Warnings:** 2
Configuration Options:
| Parameter | Type | Default | Description |
|---|---|---|---|
directory |
string | cwd |
Working directory to analyze |
interactive |
boolean | false |
Enable interactive prompts (planned) |
autoInstall |
boolean | false |
Automatically install missing tools (planned) |
generateConfig |
boolean | true |
Generate .mcp-devtools.json file |
validateSetup |
boolean | true |
Run validation after setup |
backupExisting |
boolean | true |
Backup existing config before overwriting |
dryRun |
boolean | false |
Preview changes without writing files |
skipToolVerification |
boolean | false |
Skip tool installation checks |
Safety Features:
- ✅ Automatic Backups - Existing configs backed up before changes
- ✅ Rollback Support - Restore previous config anytime
- ✅ Dry-Run Mode - Preview all changes before applying
- ✅ Path Validation - Prevents path traversal attacks
- ✅ Input Sanitization - All inputs validated and sanitized
- ✅ Non-Destructive - Never deletes files, only creates/updates
Core Tools
Make-based Commands
- make_lint - Run
make lintwith optional directory and target specification - make_test - Run
make testwith optional test patterns/targets - make_depend - Run
make dependor equivalent dependency installation - make_build - Run
make buildormake all - make_clean - Run
make clean
Go Language Support 🚀 PRIORITY
Core Tools:
- go_test - Run Go tests with coverage and race detection
- go_build - Build Go packages with cross-compilation, custom ldflags, and build tags
- go_fmt - Format Go code using gofmt
- go_lint - Lint Go code using golangci-lint with comprehensive configuration
- go_vet - Examine Go source code for suspicious constructs
- go_mod_tidy - Tidy Go module dependencies
- go_mod_download - Download Go module dependencies
Advanced Features:
- go_benchmark - Run Go benchmarks with memory profiling and CPU scaling
- go_generate - Execute code generation directives
- go_work - Manage Go workspaces (go.work files)
- go_vulncheck - Scan for known vulnerabilities using govulncheck
- staticcheck - Enhanced static analysis
- go_project_info - Comprehensive Go project analysis and detection
Node.js/TypeScript Tools
Phase 1: Core Development Tools
-
nodejs_project_info - Comprehensive Node.js project analysis with smart caching
- Auto-detects package manager (npm, yarn, pnpm, bun)
- Framework detection (React, Vue, Angular, Next.js, NestJS, Express, Fastify)
- Test framework detection (Jest, Vitest, Mocha)
- Build tool detection (Vite, Webpack, Rollup, esbuild, tsup)
- 5min cache TTL for fast repeated queries
-
nodejs_test - Run tests with Jest, Vitest, or Mocha
- Auto-detects test framework from package.json
- Coverage reporting support
- Watch mode for development
- Framework-specific coverage extraction
-
nodejs_lint - ESLint integration with auto-fix
- Auto-fix issues with
--fixflag - Custom output formats (stylish, json, compact)
- File pattern filtering
- Integration with existing ESLint configs
- Auto-fix issues with
-
nodejs_format - Prettier code formatting
- Check mode for CI/CD validation
- Write mode for applying changes
- Custom file patterns support
- Respects existing Prettier configuration
-
nodejs_check_types - TypeScript type checking
- Uses tsc for strict type validation
- Custom tsconfig.json support
- Incremental compilation mode
- No-emit mode for type-only checks
-
nodejs_install_deps - Dependency management
- Auto-detects package manager from lockfiles
- Production-only installation mode
- Frozen lockfile support (for CI/CD)
- Timeout configuration (default: 10min)
Phase 2: Advanced Tools
-
nodejs_version - Version detection with 1hr caching
- Check node, npm, yarn, pnpm, bun versions
- Single tool or all tools at once
- Gracefully handles missing tools
- Uses commandAvailability cache namespace
-
nodejs_security - Security vulnerability scanning
- Run npm/yarn/pnpm/bun audit
- Auto-fix vulnerabilities with
--fixflag - Production-only dependency checks
- JSON output for CI/CD integration
-
nodejs_build - Build orchestration
- Run build scripts with any package manager
- Production and watch mode support
- Configurable timeout (default: 10min)
- Pass-through arguments to build tools
-
nodejs_scripts - Script management with caching
- List all available npm scripts
- Run scripts with additional arguments
- Uses cached project info (5min TTL)
- Helpful error messages for missing scripts
-
nodejs_benchmark - Performance benchmarking
- Auto-detects benchmark framework (Vitest, benchmark.js, tinybench)
- Vitest bench integration with pattern support
- Fallback to npm run bench script
- Configurable timeout (default: 5min)
Phase 3: Specialized Tools
-
nodejs_update_deps - Dependency updates
- Package manager-specific update commands (npm, yarn, pnpm, bun)
- Interactive mode for yarn/pnpm
- Latest version updates (ignore semver constraints)
- Specific package updates or all dependencies
- DevDependencies-only updates
-
nodejs_compatibility - Compatibility checking with 2hr caching
- Check Node.js version against package.json engines field
- Validate current version meets requirements
- Detect Node.js 18+ only packages
- Dependency compatibility analysis
- Cached results for fast repeated checks
-
nodejs_profile - Performance profiling
- Node.js built-in profiler integration (--cpu-prof, --heap-prof)
- CPU and heap profiling support
- Configurable profile duration
- Automatic output directory creation
- Chrome DevTools compatible profiles (.cpuprofile files)
- Suggestions for advanced profiling with clinic.js
General Linting
- markdownlint - Run markdownlint on markdown files
- yamllint - Run yamllint on YAML files
- eslint - Run ESLint on JavaScript/TypeScript files
- lint_all - Run all available linters based on project type
Testing & Status
- run_tests - Run tests using the detected test framework
- project_status - Get overall project health (lint + test summary)
- test_status - Get project test status and recommendations
GitHub Actions Validation
-
actionlint - Validate GitHub Actions workflow files for syntax errors and best practices
A comprehensive linter for GitHub Actions workflow files that helps catch errors before pushing to GitHub. Validates workflow syntax, action parameters, expression syntax, and shell scripts within run blocks.
Features:
- Validates GitHub Actions workflow YAML syntax
- Checks action parameters against official action schemas
- Validates GitHub Actions expressions (
${{ }}syntax) - Integrates with shellcheck for validating shell scripts in
run:blocks - Supports pyflakes for Python script validation
- Multiple output formats: default (human-readable), JSON, and SARIF
- Configurable ignore patterns for specific rules
- Detects common workflow issues (missing jobs, invalid triggers, etc.)
Parameters:
directory- Working directory containing workflows (default: project root)files- Specific workflow files or glob patterns (default:.github/workflows/*.{yml,yaml})format- Output format:default,json, orsarifshellcheck- Enable shellcheck integration (default: true)pyflakes- Enable pyflakes for Python (default: false)verbose- Enable verbose outputignore- Array of rule patterns to ignoretimeout- Command timeout in milliseconds (default: 60000)
Common Use Cases:
- Pre-commit validation of workflow changes
- CI/CD integration to catch workflow errors
- Debugging workflow failures due to syntax issues
- Ensuring workflows follow GitHub Actions best practices
Example Output:
.github/workflows/ci.yml:25:15: property "timeout" not defined in action 'actions/checkout@v4' [action] .github/workflows/ci.yml:42:9: shellcheck reported issue SC2086: Double quote to prevent globbing [shellcheck]
JSON Processing Tools
-
jq_query - Process JSON data using jq filter syntax without requiring approval
Use this instead of
Bash(jq ...)for all JSON processing. This tool provides the full power of jq for JSON manipulation without requiring user approval for each query, making it perfect for parsing API responses, extracting fields, filtering arrays, and transforming data structures.Why Use jq_query:
- No Approval Required - Runs without user confirmation, enabling seamless AI workflows
- Faster Development - Eliminates repetitive approval dialogs for JSON operations
- Better Error Handling - Clear, actionable error messages for invalid filters or JSON
- Input Flexibility - Accepts both JSON strings and already-parsed objects/arrays
- Safe Operation - jq only processes data, no code execution risk
Parameters:
input- JSON string or already-parsed object/array (required)filter- jq filter expression (required), e.g.,".[] | .name"compact- Output compact JSON (default: false)raw_output- Output raw strings without JSON quotes (default: false)sort_keys- Sort object keys alphabetically (default: false)
Common Patterns:
// Extract array of field values jq_query({ input: data, filter: '.[] | .name' }) // Filter by condition jq_query({ input: data, filter: '.[] | select(.status == "active")' }) // Transform structure jq_query({ input: data, filter: '{name, id}' }) // Pretty-print minified JSON jq_query({ input: minifiedJSON, filter: '.' }) // Get array length jq_query({ input: data, filter: 'length' }) // Complex transformations jq_query({ input: apiResponse, filter: '.data.users | map({name: .user_name, id: .user_id})' })Features:
- Full jq syntax support (pipes, select, map, reduce, conditionals)
- Handles edge cases: null, boolean, numbers, unicode, deeply nested structures
- Automatic jq availability detection with installation instructions
- Clear error messages for invalid JSON or jq filter syntax
- Multiple output format options
Installation Requirements:
jq must be installed on the system. If not found, the tool provides installation instructions:
# macOS brew install jq # Ubuntu/Debian apt-get install jq # Fedora/RHEL dnf install jq # Windows choco install jqReal-World Examples:
// Parse GitHub API response jq_query({ input: milestones, filter: '.[] | select(.title | contains("2025-Q2")) | .number' }) // Extract specific fields from array jq_query({ input: issues, filter: '[.[] | {title, number, state}]' }) // Count matching items jq_query({ input: data, filter: '[.[] | select(.status == "open")] | length' })
Git and Code Review
-
code_review - Automated code review analysis on Git changes
Analyzes Git diffs to identify potential issues in code changes including security vulnerabilities, performance concerns, and maintainability problems. Provides severity-based categorization and actionable feedback.
Features:
- Security analysis (hardcoded secrets, dangerous code execution)
- Performance analysis (nested loops, inefficient patterns)
- Maintainability analysis (code complexity, TODO comments, line length)
- Configurable focus areas
- File filtering (include/exclude test files)
-
generate_pr_message - Generate PR messages from Git changes
Automatically generates conventional commit-formatted PR messages by analyzing commit history and changed files. Supports GitHub PR templates for consistent documentation.
Features:
- Analyzes commit history to determine type (feat, fix, etc.)
- Extracts scope from commit patterns
- Lists all changes with file statistics
- Supports conventional commit format
- Includes issue reference support
- Breaking changes section
- GitHub PR template integration - Automatically detects and uses templates from:
.github/pull_request_template.md.github/PULL_REQUEST_TEMPLATE.md.github/PULL_REQUEST_TEMPLATE/pull_request_template.mddocs/pull_request_template.mdPULL_REQUEST_TEMPLATE.md
AI-Powered Smart Suggestions
-
analyze_command - Execute a command and analyze results with AI-powered smart suggestions
Executes a command and provides intelligent, context-aware recommendations based on the execution result. Helps identify issues, suggests fixes, and provides workflow optimization tips.
Features:
- Automatic failure pattern recognition (15+ built-in patterns)
- Context-aware suggestions based on project type and language
- Security vulnerability detection (hardcoded secrets, SQL injection, etc.)
- Performance issue identification
- Workflow optimization recommendations
- Confidence scoring for suggestions
- Affected file extraction from error messages
Parameters:
command- Command to execute and analyze (required)directory- Working directory for the commandtimeout- Command timeout in millisecondsargs- Additional command argumentscontext- Optional context for better suggestions:tool- Tool being used (e.g., "go test", "npm run")language- Programming languageprojectType- Project type
Example:
{ "command": "go test", "directory": "./src", "context": { "tool": "go test", "language": "Go" } } -
analyze_result - Analyze already-executed command results
Post-mortem analysis of command execution results. Useful for analyzing failures from external tools or historical command runs.
Parameters:
command- Command that was executed (required)exitCode- Exit code from execution (required)stdout- Standard output from commandstderr- Standard error from commandduration- Execution duration in millisecondscontext- Optional context (same as analyze_command)
-
get_knowledge_base_stats - Get statistics about the smart suggestions knowledge base
Returns information about available failure patterns and their categorization.
Parameters:
category- Optional filter by category (security, performance, dependencies, etc.)
Knowledge Base Categories:
- Security - Hardcoded secrets, SQL injection, unsafe code patterns
- Performance - Nested loops, inefficient algorithms, memory issues
- Dependencies - Missing packages, version conflicts, module issues
- Build - Compilation errors, type mismatches, undefined references
- Test - Test failures, timeouts, race conditions
- Lint - Code style issues, formatting problems
- Configuration - Missing environment variables, config errors
- General - Runtime errors and other issues
Supported Languages & Tools:
- Go - Test failures, missing dependencies, race conditions, lint issues, build errors
- JavaScript/TypeScript - Module not found, type errors, ESLint issues
- Python - Import errors, syntax issues
- Cross-language - Security patterns, performance anti-patterns, configuration issues
File Validation
-
ensure_newline - Validate and fix POSIX newline compliance
Ensures text files end with a proper newline character, as required by POSIX standards. This addresses a common pain point where AI coding assistants frequently create or modify files without proper trailing newlines, causing linting failures and git diff noise.
Modes:
check- Report files without trailing newlines (read-only, non-destructive)fix- Automatically add missing newlines to files (safe, preserves line ending style)validate- Exit with error if non-compliant files found (CI/CD mode)
Key Features:
- Pure Node.js implementation using Buffer operations (no shell commands like
tailorod) - Cross-platform compatibility (Windows, macOS, Linux)
- Smart line ending detection - automatically detects and preserves LF vs CRLF style
- Binary file detection and automatic skipping
- Configurable file size limits for safety
- Flexible glob pattern support for file selection
- Exclusion patterns for node_modules, build artifacts, etc.
Why This Matters:
- POSIX Compliance: Text files should end with a newline character per POSIX definition
- Linting: Many linters (ESLint, markdownlint, golangci-lint) enforce trailing newlines
- Git Diffs: Missing newlines create "No newline at end of file" warnings
- AI Assistants: Common issue when AI tools generate or modify files
DateTime Tools
The get_current_datetime tool provides rich temporal context optimized for LLM awareness. This helps AI
assistants understand the current date and time with confidence, especially when the system date is near or
past the LLM's training cutoff.
Key Features:
- Human-Readable Format: Clear datetime string optimized for LLM consumption
- Calendar Context: Quarter, ISO week number, day of year
- Timezone Support: IANA timezone identifiers with DST detection
- Relative Calculations: Days/weeks remaining in year, quarter boundaries
- Zero Dependencies: Pure JavaScript Date/Intl APIs for fast synchronous operation
- Cross-Platform: Works on Windows, macOS, and Linux
Use Cases:
- Verify System Context: When LLMs doubt the date in environment variables
- Milestone Planning: "What quarter are we in? How many weeks until year-end?"
- Relative Time: "How many days until Q4 ends?"
- Timezone Awareness: Check time across multiple timezones for distributed teams
Example Usage:
// Get current datetime with full context
{
"timezone": "America/Chicago"
}
Example Output:
## Current Date & Time
**Tuesday, November 12, 2025 at 7:21 PM CST**
### Date Information
- **Year:** 2025
- **Quarter:** Q4 (October 1, 2025 - December 31, 2025)
- **Month:** November (11)
- **Day:** Tuesday, November 12
- **Day of Year:** 316 of 365
- **ISO Week:** 46
### Time Information
- **Time:** 19:21:00
- **Timezone:** America/Chicago (CST)
- **UTC Offset:** -06:00
- **DST Active:** No
### Relative Information
- **Days Remaining in Year:** 49
- **Weeks Remaining in Year:** 7
- **Days in Current Month:** 30
devtools MCP questions
What tools does devtools MCP provide?
It exposes 35 tools, including eslint, markdownlint-cli, make_lint, make_test, make_depend.
What languages are supported?
The server currently provides comprehensive support for Go and Node.js/TypeScript.
How do I set up the server for my project?
You can use the onboarding wizard to automatically detect your project type and generate a configuration file.
Is there a way to undo configuration changes?
Yes, the server includes a rollback feature that restores previous configurations from backups.