devtools MCP server
Commit 11. Nov. 2026Bietet eine KI-bereite Schnittstelle für Entwicklungstools wie Go, Node.js, Testing, Linting und Git-Workflows, um die Genauigkeit der Codegenerierung zu verbessern.
Auch bekannt als rshade/mcp-devtools-server
- Stars
- 5
- Tools
- 35
- Downloads, 30 Tage
- —
- Neueste Version
- —
- Letzter Commit
- 11. Nov. 2026
- Lizenz
- Apache-2.0
Was ist devtools MCP?
Bietet eine KI-bereite Schnittstelle für Entwicklungstools wie Go, Node.js, Testing, Linting und Git-Workflows, um die Genauigkeit der Codegenerierung zu verbessern. Er stellt 35 Tools bereit, etwa eslint, markdownlint-cli, make_lint.
Zusammenfassung generiert aus dem README des Projekts
Über devtools MCP server
Entwickler, die Claude Code nutzen, können die Genauigkeit der Codegenerierung und die Fehlerkorrektur verbessern, indem sie diesen Server mit ihrer lokalen Entwicklungsumgebung verbinden. Er bietet eine standardisierte Schnittstelle, damit KI-Assistenten mit gängigen Programming-Tools interagieren können, was Fehler durch konsistente Patterns und automatisierte Workflows reduziert. Der Server enthält einen Onboarding-Wizard, der Projekttypen, Frameworks und Build-Systeme automatisch erkennt, um eine Config-Datei ohne manuellen Input zu generieren.
Das Toolset bietet umfangreiche Unterstützung für Go und Node.js/TypeScript mit über 40 spezialisierten Tools. Für Go-Entwickler umfasst es Commands für Testing mit Race Detection, Building mit benutzerdefinierten ldflags und Vulnerability Scanning via go_vulncheck. Node.js-Nutzer können TypeScript Type Checking, Security Audits und Performance Profiling durchführen. Er verwaltet auch allgemeine Aufgaben wie das Linting von Markdown- und YAML-Dateien, das Ausführen von Make-basierten Commands und die Validierung von GitHub Actions Workflows mit actionlint. Überall wird intelligentes Caching eingesetzt, um die Performance bei wiederholten Queries zu verbessern.
Was du damit machen kannst
- 1Automatisierte Einrichtung der ProjektumgebungEine KI kann ihre eigene Entwicklungsumgebung automatisch konfigurieren, indem sie den Projekttyp und das Build-System erkennt.
- 2Qualitätssicherung in GoEin Entwickler kann die KI anweisen, Go-Tests mit Coverage auszuführen und nach Race Conditions zu suchen.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
devtools MCP tools 35
Erkannt aus dem 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 | — |
Alle 35 Tools anzeigenWeniger Tools anzeigen
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 | — |
Konfiguration
LOG_LEVEL
| Name | Beschreibung | Typ |
|---|---|---|
| LOG_LEVEL | — |
Automatisierte Checks
Geluften am 14. Nov. 2026Vollständiger Bericht →Noch nicht verifiziert. Ein Server benötigt einen Score von 80, keine kritischen Befunde und genug Daten für unsere Prüfung. Wie die Checks funktionieren · Was du für mehr Punkte verbessern kannst
- Source Repository verknüpft und erreichbarrshade/mcp-devtools-server is public and reachablegithub.com/rshade/mcp-devtools-server ↗Bestanden
- Paket nennt dieses Repository als QuelleNicht geprüft
- Build-Provenienz (Sigstore-Attestierung)Nicht geprüft
- Open Source Lizenz (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Bestanden
- Commit oder Release im letzten JahrLast commit or release 2026-11-11github.com/rshade/mcp-devtools-server ↗Bestanden
- OpenSSF ScorecardNicht geprüft
- Package-Name ähnelt keinem populären PackageNicht geprüft
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenNicht geprüft
- Keine versteckten Anweisungen an das Modell35 tool descriptions and the README read; no override phrases, credential paths or hidden charactersBestanden
- Destruktive Tools sind markiertNo tool named like delete, drop or execBestanden
- Remote-Endpoint beantwortet den MCP-HandshakeNicht geprüft
README
Auf GitHub ansehenMCP 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 Fragen
Welche Tools bietet devtools MCP?
Er stellt 35 Tools bereit, darunter eslint, markdownlint-cli, make_lint, make_test, make_depend.
Welche Sprachen werden unterstützt?
Der Server bietet derzeit umfassende Unterstützung für Go und Node.js/TypeScript.
Wie richte ich den Server für mein Projekt ein?
Du kannst den Onboarding-Wizard nutzen, um deinen Projekttyp automatisch zu erkennen und eine Config-Datei zu generieren.
Gibt es eine Möglichkeit, Konfigurationsänderungen rückgängig zu machen?
Ja, der Server enthält eine Rollback-Funktion, die vorherige Konfigurationen aus Backups wiederherstellt.