Skip to main content
Glama

Tech Debt MCP Server

npm version Add to MCP SQALE Rating

16 Tools · 2 Resources · 14 Languages · 10 Dependency Ecosystems

A Model Context Protocol (MCP) server for analyzing technical debt across multiple programming languages. Designed to integrate with GitHub Copilot, Claude, Cursor, and other MCP-compatible tools.

Features

  • Multi-language support: JavaScript, TypeScript, Python, Java, Swift, Kotlin, Objective-C, C++, C, C#, Go, Rust, Ruby, PHP

  • Comprehensive analysis: Detects various types of tech debt including code quality issues, security vulnerabilities, and maintainability problems

  • SQALE Metrics: Calculate technical debt with SQALE rating system (A-E scale)

  • SwiftUI Analysis: Specialized checks for SwiftUI patterns, state management, memory leaks, view nesting, and concurrency issues

  • Custom Rules: Define your own pattern-based checks with regex support

  • Dependency Analysis: Parse package manifests across 10 ecosystems (npm, pip, Maven/Gradle, Cargo, Go Modules, Composer, Bundler, NuGet, C/C++, Swift)

  • Inline Suppression: Suppress false positives with // techdebt-ignore-next-line or block comments

  • Config Validation: Validate .techdebtrc.json configuration files for schema correctness

  • Actionable recommendations: Provides prioritized suggestions for addressing technical debt

  • Flexible filtering: Filter results by severity, category, or language

Related MCP server: project-advisors-mcp

Supported Languages

Language

Extensions

Key Checks

JavaScript

.js, .mjs, .cjs, .jsx

console.log, debugger, eslint-disable, usage of dynamic code execution, var usage

TypeScript

.ts, .tsx, .mts, .cts

any type, @ts-ignore, non-null assertions, type assertions

Python

.py, .pyw, .pyi

bare except, print statements, global usage, dynamic code execution

Java

.java

System.out, printStackTrace, empty catch, @SuppressWarnings

Swift

.swift

force unwrap (!), force cast (as!), force try, retain cycles, SwiftUI patterns

Kotlin

.kt, .kts

!!, lateinit abuse, @Suppress, unchecked casts

Objective-C

.m, .mm, .h

NSLog, retain cycles, deprecated methods, massive view controllers

C++

.cpp, .cc, .hpp, .h

raw pointers, C-style casts, goto, using namespace std

C

.c, .h

malloc without free, goto, unsafe functions, null checks

C#

.cs

Console.WriteLine, async void, empty catch, dispose pattern

Go

.go

ignored errors, blank imports, fmt.Print, panic, global variables

Rust

.rs

unwrap, expect, unsafe, allow attributes, panic, println

Ruby

.rb

puts, binding.pry, rubocop disable, dynamic code execution, global variables

PHP

.php

var_dump, print_r, die/exit, dynamic code execution, error suppression

Installation

One-Click Install

VS Code (via Terminal):

code --add-mcp '{"name":"tech-debt-mcp","command":"npx","args":["-y","tech-debt-mcp@latest"]}'

One-Click Install

Cursor (via Terminal):

cursor --add-mcp '{"name":"tech-debt-mcp","command":"npx -y tech-debt-mcp@latest"}'

Claude Code (via Terminal):

claude mcp add tech-debt-mcp -- npx -y tech-debt-mcp@latest

Claude Desktop — add to your claude_desktop_config.json:

{
  "mcpServers": {
    "tech-debt-mcp": {
      "command": "npx",
      "args": ["-y", "tech-debt-mcp@latest"]
    }
  }
}

Add to your Windsurf MCP configuration (~/.codeium/windsurf/mcp_config.json):

{
  "mcpServers": {
    "tech-debt-mcp": {
      "command": "npx",
      "args": ["-y", "tech-debt-mcp@latest"]
    }
  }
}

Via AI Assistant — open Settings > Tools > AI Assistant > Model Context Protocol (MCP), click +, select As JSON, and paste:

{
  "mcpServers": {
    "tech-debt-mcp": {
      "command": "npx",
      "args": ["-y", "tech-debt-mcp@latest"]
    }
  }
}

Via GitHub Copilot for Xcode — open Settings > MCP tab > Edit Config (mcp.json):

{
  "servers": {
    "tech-debt-mcp": {
      "command": "npx",
      "args": ["-y", "tech-debt-mcp@latest"]
    }
  }
}

Manual Setup

Add to your MCP client config:

{
  "mcpServers": {
    "tech-debt-mcp": {
      "command": "npx",
      "args": ["-y", "tech-debt-mcp@latest"]
    }
  }
}

For development: npm run dev

Tools

Category

Tool

Description

Analysis

analyze_project

Analyze entire project — filter by language, category, severity, maxFiles

analyze_file

Analyze a single file

get_debt_summary

Quick summary with health score and issue counts

get_sqale_metrics

SQALE rating, remediation time, debt ratio, breakdowns

Filtering

get_recommendations

Prioritized fix suggestions (configurable limit)

get_issues_by_severity

Issues filtered by severity level

get_issues_by_category

Issues filtered by debt category

list_supported_languages

All languages with their checks

Custom Rules

add_custom_rule

Add regex-based tech debt rule

remove_custom_rule

Remove a custom rule by ID

list_custom_rules

List active rules with stats

execute_custom_rules

Run custom rules against code or file

validate_custom_pattern

Test a pattern before adding it

Dependencies

check_dependencies

Scan package manifests across 10 ecosystems

get_vulnerability_report

Offline dependency inventory for CVE review

validate_config

Validate .techdebtrc.json schema

analyze_project

Analyze an entire project for technical debt.

  • path (required): Absolute path to the project root

  • languages (optional): Array of languages to analyze

  • categories (optional): Filter by debt categories

  • severity (optional): Minimum severity level (low, medium, high, critical)

  • maxFiles (optional): Maximum files to analyze

analyze_file

Analyze a single file for technical debt.

  • path (required): Absolute path to the file

get_debt_summary

Get a quick summary of technical debt in a project.

  • path (required): Absolute path to the project root

get_sqale_metrics

Get SQALE technical debt metrics including remediation time, debt ratio, and rating.

  • path (required): Absolute path to the project root

  • developmentTime (optional): Estimated development time in hours (for debt ratio calculation)

Output includes SQALE rating (A-E) with star visualization, total remediation time, debt ratio, and breakdowns by severity and category.

get_recommendations

Get prioritized recommendations for addressing technical debt.

  • path (required): Absolute path to the project root

  • limit (optional): Maximum recommendations to return

get_issues_by_severity

Get all issues of a specific severity level.

  • path (required): Absolute path to the project root

  • severity (required): low, medium, high, or critical

get_issues_by_category

Get all issues of a specific category.

  • path (required): Absolute path to the project root

  • category (required): dependency, code-quality, architecture, documentation, testing, security, performance, or maintainability

list_supported_languages

List all supported programming languages with their checks. No parameters.

add_custom_rule

Add a custom pattern-based tech debt rule.

  • id (required): Unique identifier for the rule

  • pattern (required): Regex pattern to match

  • message (required): Issue title/message

  • severity (required): low, medium, high, or critical

  • category (required): One of the debt categories

  • suggestion (optional): How to fix the issue

  • languages (optional): Apply only to specific languages

  • flags (optional): Regex flags (g, i, m, s, etc.)

Example custom rules:

[
  {
    "id": "no-magic-numbers",
    "pattern": "=\\s*\\d{3,}",
    "severity": "medium",
    "category": "maintainability",
    "message": "Magic number detected",
    "suggestion": "Extract to named constant"
  },
  {
    "id": "forbidden-library",
    "pattern": "import.*moment.*from",
    "severity": "medium",
    "category": "dependency",
    "message": "moment.js is deprecated",
    "suggestion": "Use native Date or date-fns instead",
    "languages": ["javascript", "typescript"]
  }
]

remove_custom_rule

Remove a custom rule by ID.

  • id (required): ID of the rule to remove

list_custom_rules

List all active custom rules with their statistics. No parameters.

execute_custom_rules

Run all custom rules against code or a file.

  • path (optional): Path to the file to analyze

  • code (optional): Code content to analyze directly

  • language (optional): Programming language for filtering rules

Either path or code must be provided.

validate_custom_pattern

Validate a custom pattern before adding it as a rule.

  • id (required): Unique identifier for the rule

  • pattern (required): Regex pattern to validate

  • message (required): Issue title/message

  • severity (required): low, medium, high, or critical

  • category (required): One of the debt categories

check_dependencies

Scan a project for package manifests and return a structured dependency report.

  • path (required): Absolute path to the project root

  • includeDev (optional): boolean (default: true) — include dev/test dependencies

Detects manifests for npm, pip, Maven/Gradle, Cargo, Go Modules, Composer, Bundler, NuGet, C/C++, and Swift Package Manager. Separates production vs development dependencies and reports files that failed to parse.

validate_config

Validate a .techdebtrc.json configuration file for schema correctness.

  • path (required): Absolute path to the project root directory or directly to a .techdebtrc.json file

get_vulnerability_report

Generate an offline dependency inventory for vulnerability review. Lists all dependencies by ecosystem in a tabular format. See ROADMAP.md for planned online CVE lookup.

  • path (required): Absolute path to the project root

  • includeDev (optional): boolean (default: false) — include dev dependencies in the report

Resources

URI

Description

debt://summary/{+projectPath}

Health score, debt score, issue counts, SQALE metrics (JSON)

debt://issues/{+projectPath}

Filterable list of all tech debt issues (JSON) — supports severity, category, limit query params

Configuration

Create a .techdebtrc.json file in your project root:

{
  "ignore": ["vendor/**", "generated/**"],
  "rules": {
    "maxFileLines": 500,
    "maxFunctionLines": 50,
    "maxComplexity": 10,
    "maxNestingDepth": 4
  },
  "severity": {
    "todo-comment": "low",
    "console-log": "medium"
  },
  "ruleExclusions": {
    "debugger": ["**/src/analyzers/**"],
    "ts-ignore": ["**/src/analyzers/**"]
  },
  "customPatterns": [
    {
      "id": "no-console-log",
      "pattern": "console\\.log",
      "severity": "low",
      "category": "code-quality",
      "message": "Remove console.log() statements",
      "suggestion": "Use proper logging library instead",
      "languages": ["javascript", "typescript"]
    }
  ]
}

Rule Exclusions

Use ruleExclusions to suppress specific rules for files matching glob patterns. Patterns use forward slashes (/) on all platforms. Use **/ prefixed patterns (e.g., **/src/analyzers/**) for reliable matching regardless of path format.

Inline Suppression

Suppress specific issues directly in source code. Both // and # comment prefixes are supported across all languages.

Single-line — suppresses the next line:

// techdebt-ignore-next-line debugger
debugger; // only the 'debugger' rule is suppressed
# techdebt-ignore-next-line print-statement
print("debug output")  # will not be reported

Block — suppresses all lines between start and end:

// techdebt-ignore-start ts-ignore
issues.push(...this.checkPattern(filePath, content, /@ts-ignore/g, { ... }));
// techdebt-ignore-end ts-ignore

Without a rule name, all rules are suppressed. Blocks can be nested. Suppression comments must appear on their own line.

SQALE Metrics

Tech Debt MCP uses SQALE methodology to quantify technical debt:

Rating

Debt Ratio

Quality

A

≤5%

Excellent

B

6-10%

Good

C

11-20%

Fair

D

21-50%

Poor

E

>50%

Critical

Effort-to-time mapping: trivial (≤5m) · small (5-30m) · medium (30m-2h) · large (2-4h) · xlarge (4h+)

SwiftUI Analysis

14 specialized checks for SwiftUI apps covering state management (excessive @State, @ObservedObject misuse, environment value safety), memory & lifecycle (Combine retain cycles, timer cleanup, task cancellation, closure retain cycles), performance (missing .id() modifiers, expensive body calculations, deep nesting, GeometryReader misuse), and best practices (AnyView type erasure, deprecated NavigationLink, main thread safety).

State Management Issues

  • Excessive @State Variables - Detects views with >5 @State variables that should use a ViewModel

  • @ObservedObject Misuse - Flags @ObservedObject with initialization (should use @StateObject)

  • Environment Value Safety - Detects force unwrapping of @Environment values

Memory & Lifecycle

  • Combine Circular References - Finds missing [weak self] in Combine sinks

  • Missing Timer Cleanup - Detects Timers without cleanup in onDisappear

  • Missing Task Cancellation - Flags async Tasks without cancellation handling

  • Retain Cycles in Closures - Detects self captures in onChange/onReceive without [weak self]

Performance & View Hierarchy

  • Missing .id() Modifiers - Detects ForEach without stable identifiers

  • Expensive View Body Calculations - Flags reduce/sort/filter in view bodies

  • Deep View Nesting - Warns when nesting depth exceeds 6 levels

  • GeometryReader Misuse - Detects GeometryReader at view root

SwiftUI Best Practices

  • AnyView Type Erasure - Suggests using generics or @ViewBuilder instead

  • Deprecated NavigationLink - Flags old-style NavigationLink patterns

  • Main Thread Safety - Ensures UI updates happen on main thread

Example Issues Detected

// Excessive @State - should use ViewModel
struct UserView: View {
  @State private var firstName = ""
  @State private var lastName = ""
  @State private var email = ""
  @State private var phone = ""
  @State private var address = ""
  @State private var city = ""  // 6+ @State variables!
}

// @ObservedObject with initialization
struct ContentView: View {
  @ObservedObject var viewModel = UserViewModel()  // Should be @StateObject!
}

// Missing Timer cleanup
struct TimerView: View {
  var body: some View {
    Text("Hello")
      .onAppear {
        Timer.scheduledTimer(...)  // Missing .onDisappear cleanup!
      }
  }
}

// Retain cycle in Combine
publisher
  .sink { value in
    self.updateUI(value)  // Missing [weak self]!
  }

Example Output

# Tech Debt Analysis Report

## Health Score: 72/100

### Issues by Severity
| Severity | Count |
|----------|-------|
| Critical | 2 |
| High | 15 |
| Medium | 45 |
| Low | 120 |

## Top Recommendations

1. **Address Critical Issues Immediately**
   Fix 2 critical security issues.

2. **Clean Up TODO/FIXME Comments**
   Found 45 TODO comments - consider creating tracked issues.

Code Quality

Tech Debt MCP practices what it preaches — built with AI-assisted vibe coding, it maintains an A rating by regularly scanning itself.

Self-Scan Results (March 2026)

  • SQALE Rating: A (Excellent)

  • Debt Ratio: 4.6% (Target: <5%)

  • Total Issues: 118 (0 critical, 12 high, 49 medium, 57 low)

  • Remediation Time: ~96 hours

  • Health Score: 42.4/100

Issue count increased from 81 to 118 due to wider scan scope in v2.0.1 (more files analyzed), not regression. See TECH_DEBT_SCAN.md for full results.

Development

npm install       # Install dependencies
npm run build     # Compile TypeScript
npm run dev       # Run with ts-node
npm run watch     # Watch mode
npm test          # Run tests

Documentation

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines and CODE_OF_CONDUCT.md for our community standards.

Releases

License

MIT

Available Tools

16 tools
add_custom_ruleC

Add a custom pattern-based tech debt rule.

Inputs: id (required), message (required), pattern (required), category (required), +4 more.

analyze_fileC

Analyze a single file for technical debt issues.

Inputs: path (required).

analyze_projectA

Analyze an entire project for technical debt. Scans all supported files and returns a comprehensive report with issues, metrics, and recommendations.

Inputs: path (required), maxFiles, severity, languages, +1 more.

check_dependenciesC

Analyze project dependencies across multiple package managers.

Inputs: path (required), includeDev.

execute_custom_rulesB

Execute all custom rules against code or a file.

Inputs: code, path, language.

get_debt_summaryC

Get a quick summary of technical debt in a project.

Inputs: path (required).

get_issues_by_categoryC

Get all issues of a specific category.

Inputs: path (required), category (required).

get_issues_by_severityC

Get all issues of a specific severity level.

Inputs: path (required), severity (required).

get_recommendationsB

Get prioritized recommendations for addressing technical debt.

Inputs: path (required), limit.

get_sqale_metricsB

Get SQALE technical debt metrics including remediation time, debt ratio, and rating.

Inputs: path (required), developmentTime.

get_vulnerability_reportA

Generate an offline dependency report listing all project dependencies for vulnerability review. Note: actual CVE lookups require Phase 2b online integration.

Inputs: path (required), includeDev.

list_custom_rulesA

List all active custom rules with their statistics.

Inputs: no named parameters.

list_supported_languagesA

List all programming languages supported by the analyzer.

Inputs: no named parameters.

remove_custom_ruleB

Remove a custom rule by ID.

Inputs: id (required).

validate_configB

Validate a .techdebtrc.json configuration file for syntax and schema correctness.

Inputs: path (required).

validate_custom_patternB

Validate a custom pattern before adding it as a rule.

Inputs: id (required), message (required), pattern (required), category (required), +1 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 16 tools

    Disambiguation4/5

    Most tools target distinct operations: whole-project vs single-file analysis, severity vs category filtering, and the custom-rule lifecycle (add/remove/list/execute/validate) are clearly separated. The main overlap is check_dependencies vs get_vulnerability_report, whose description ('offline dependency report listing all project dependencies') suggests it largely duplicates dependency analysis rather than delivering the CVE lookups its name implies.

    Naming Consistency5/5

    Every tool follows a consistent snake_case verb_noun pattern (analyze_project, get_sqale_metrics, list_custom_rules, add_custom_rule, validate_custom_pattern). Verb choices (analyze/get/list/add/remove/execute/check/validate) are conventional and predictable for their actions.

    Tool Count4/5

    16 tools is slightly above the comfortable band but justified by the breadth of the domain (analysis, metrics, issue filtering, recommendations, custom rules, dependencies, config). Each tool maps to a real user need rather than being redundant filler.

    Completeness4/5

    The surface covers the core lifecycle: analysis (project/file), summary and SQALE metrics, filtered issue retrieval, recommendations, full custom-rule management, dependency checking, and config validation. The one notable gap is that vulnerability reporting stops at an offline dependency listing with no actual CVE data, leaving a dead end for security review.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      Exposes technical debt management to AI coding assistants, enabling them to find, prioritize, and resolve TODO/FIXME/BUG comments across codebases via MCP tools.
      6
      51 npm
      1
      MIT
    • F
      license
      B
      quality
      C
      maintenance
      Enables AI agents to perform comprehensive, zero-infrastructure codebase analysis through 24 MCP tools, covering security, quality, architecture, type safety, git history, and dead code detection with high precision and local privacy.
      45
      -
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI coding agents to analyze repository architecture, changed-file and diff impact, dependency and endpoint exposure, API contract compatibility, architecture boundaries, bounded capacity simulations, and security/quality evidence through MCP tools.
      3
      Apache 2.0