Skip to main content
Glama

Code-MCP 🧠

The AI Coding Brain - A comprehensive Model Context Protocol (MCP) server that turns any AI into a full-stack software engineer.

Deploy on Railway

Features

🛠️ 36 MCP Tools

Category

Tools

Purpose

Cognitive (10)

sequential_thinking, plan_task, reflect_on_code, analyze_architecture, debug_problem, brainstorm_solutions, compare_approaches, estimate_complexity, generate_tests, explain_code

AI reasoning & analysis

Memory (4)

save_memory, read_memory, list_memories, clear_memory

Persistent context

Validation (4)

validate_code, check_imports, lint_code, format_code

Code quality

AI Configs (9)

Cursor, Gemini, Claude, Windsurf, Aider, Cline, Copilot, Continue.dev, Tabnine

Generate AI tool configs

IDE Configs (4)

VSCode tasks/launch, JetBrains

IDE integration

Full-Stack (5)

track_project, check_dependencies, generate_github_actions, full_stack_scaffold, developer_rules

Project automation

📚 130+ MCP Resources

  • 55+ Programming Languages

  • 35+ Databases

  • 43+ Frameworks

  • DevOps, Security, and more

🎭 5 Smart Prompts

  • act_as_architect - System design expert

  • act_as_debugger - Debugging specialist

  • act_as_reviewer - Code review expert

  • act_as_security_auditor - Security analyst

  • setup_project - Project scaffold helper


Quick Start

Local (stdio transport)

git clone https://github.com/millsydotdev/Code-MCP.git
cd Code-MCP
npm install
npm run build
npm start

Cloud (HTTP transport)

npm run start:cloud

Docker

docker build -t code-mcp .
docker run -i code-mcp

Connect to AI Tools

Claude Desktop

{
  "mcpServers": {
    "code-mcp": {
      "command": "node",
      "args": ["/path/to/Code-MCP/dist/index.js"]
    }
  }
}

Cloud Connection

{
  "mcpServers": {
    "code-mcp-cloud": {
      "url": "https://your-deployment.railway.app/mcp",
      "headers": {
        "x-api-key": "your-api-key"
      }
    }
  }
}

Deploy to Cloud

See DEPLOY.md for full deployment instructions.

Platform

Free Tier

Deploy

Railway

500hrs/mo

Deploy

Render

750hrs/mo

Connect GitHub

Fly.io

3 VMs

CLI deploy


API Endpoints (Cloud Mode)

Endpoint

Method

Description

/health

GET

Health check

/tools

GET

List all tools

/tools/:name

POST

Call a tool

/resources

GET

List resources

/prompts

GET

List prompts

/mcp

POST

MCP JSON-RPC


Environment Variables

PORT=3000
CODE_MCP_API_KEY=your-secret-key  # Optional auth

Tech Stack

  • Runtime: Node.js

  • Language: TypeScript

  • Protocol: Model Context Protocol (MCP)

  • Server: Express (cloud mode)

  • Container: Docker


Contributing

Contributions welcome! Feel free to add:

  • New tools

  • More language/framework/database rules

  • Additional AI tool config generators

  • Improved documentation


License

MIT License - Use freely!


Made with 🧠 by millsydotdev

Available Tools

35 tools
analyze_architectureB

Analyzes system architecture, identifying patterns, potential issues, and improvement opportunities. Use for design reviews and technical decisions.

Inputs: description (required), components, concerns.

brainstorm_solutionsC

Generates multiple solution approaches for a problem, with pros/cons for each.

Inputs: problem (required), constraints, preferences.

check_dependenciesB

Analyzes project dependencies for security vulnerabilities, deprecations, and outdated packages. Essential for maintaining healthy projects.

Inputs: packageManager (required), packageFile.

check_importsC

Checks import statements in code for common issues like circular dependencies, unused imports, and missing modules.

Inputs: code (required), language (required).

clear_memoryC

Clear a specific memory by key, or clear all memories for a project.

Inputs: key, project, clearAll.

compare_approachesC

Compares multiple technical approaches on various dimensions to help make informed decisions.

Inputs: approaches (required), criteria.

debug_problemB

Provides a systematic debugging approach for a described problem. Generates hypotheses, test strategies, and resolution steps.

Inputs: problem (required), symptoms, context.

developer_rulesC

Provides comprehensive developer rules and checklists for maintaining high-quality, secure code.

Inputs: category (required).

estimate_complexityC

Estimates the complexity and effort required for a task or feature.

Inputs: task (required), factors.

explain_codeC

Provides a detailed explanation of code, breaking down what each part does.

Inputs: code (required), language (required), level.

format_codeB

Provides formatted version of code following language-specific style guides.

Inputs: code (required), language (required), indent.

full_stack_scaffoldB

Generates a complete full-stack project structure with all necessary files and configurations. One command to create a production-ready project.

Inputs: projectName (required), frontend (required), backend (required), database (required), +1 more.

generate_aider_configC

Generates a .aider.conf.yml file for Aider AI.

Inputs: projectName (required), languages (required), model.

generate_claude_configC

Generates a CLAUDE.md file for Claude Projects/Tasks.

Inputs: projectName (required), languages (required), description.

generate_cline_configC

Generates a .clinerules file for Cline/Roo Code.

Inputs: projectName (required), languages (required).

generate_continue_configC

Generates a .continue/config.json file for Continue.dev.

Inputs: projectName (required), languages (required), model.

generate_copilot_configC

Generates a .github/copilot-instructions.md for GitHub Copilot.

Inputs: projectName (required), languages (required), frameworks.

generate_cursor_rulesB

Generates a .cursorrules file for Cursor AI based on the project stack.

Inputs: projectName (required), languages (required), frameworks, databases.

generate_gemini_configC

Generates a GEMINI.md file for Gemini/Antigravity configuration.

Inputs: projectName (required), languages (required), description.

generate_github_actionsC

Generates GitHub Actions workflow files for CI/CD, testing, security scanning, and deployment.

Inputs: projectType (required), features (required).

generate_jetbrains_configC

Generates a .idea/runConfigurations XML file for JetBrains IDEs.

Inputs: projectName (required), language (required), entryPoint.

generate_tabnine_configC

Generates a .tabnine.json configuration file.

Inputs: projectName (required), languages (required).

generate_testsB

Generates test case suggestions for a feature or function.

Inputs: feature (required), type.

generate_vscode_launchC

Generates a .vscode/launch.json file for debugging.

Inputs: projectName (required), language (required), entryPoint.

generate_vscode_tasksC

Generates a .vscode/tasks.json file for VSCode.

Inputs: projectName (required), language (required), buildCommand, testCommand.

generate_windsurf_configC

Generates a .windsurfrules file for Windsurf IDE.

Inputs: projectName (required), languages (required), description.

lint_codeC

Analyzes code for style issues, potential bugs, and best practice violations.

Inputs: code (required), language (required), rules.

list_memoriesB

List all saved memories, optionally filtered by project scope.

Inputs: project.

plan_taskA

Creates a structured plan for completing a coding task. Breaks down the work into steps with dependencies, validation criteria, and estimated complexity. Use before starting any significant coding work.

Inputs: task (required), context, scope.

read_memoryC

Read a value from persistent memory by key.

Inputs: key (required).

reflect_on_codeB

Provides a structured critique of code, analyzing quality, security, performance, and maintainability. Returns specific improvement suggestions.

Inputs: code (required), language (required), focus.

save_memoryA

Save a key-value pair to persistent memory. Use this to remember user preferences, project decisions, or important context across sessions.

Inputs: key (required), value (required), project.

sequential_thinkingB

A tool to facilitate sequential, structured thinking. It forces the AI to break down complex problems into steps, validating each before moving to the next. Use this when facing a complex coding task or architectural decision.

Inputs: thought (required), step (required), total_steps (required), next_action (required), +1 more.

track_projectA

Analyzes and tracks project structure, keeping inventory of all files, folders, and their purposes. Use at project start and after major changes.

Inputs: projectPath (required), projectName (required), techStack.

validate_codeB

Validates code syntax and formatting using available linters (e.g., Prettier). usage: providing code snippets to check for correctness before finalizing.

Inputs: code (required), language (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 35 tools

    Disambiguation3/5

    The tool set has clear distinct purposes in some areas (e.g., analyze_architecture vs. debug_problem), but significant overlap exists in configuration generation tools (generate_aider_config, generate_claude_config, etc.) which all create config files for different AI tools and could be confused. Additionally, tools like check_dependencies and check_imports both analyze code for issues, potentially causing misselection.

    Naming Consistency4/5

    Most tools follow a consistent verb_noun pattern (e.g., analyze_architecture, brainstorm_solutions, check_dependencies), which is predictable and readable. There are minor deviations like sequential_thinking (adjective_noun) and developer_rules (noun_noun), but the overall convention is well-maintained across the set.

    Tool Count2/5

    With 35 tools, this server feels overloaded for a code assistance domain, especially given the redundancy in configuration generation tools. A more focused set of 10-20 tools could cover the same scope without overwhelming agents, as many tools serve similar purposes or are overly specific.

    Completeness4/5

    The server covers a broad range of code-related tasks from analysis and debugging to planning and configuration, with no obvious major gaps for its purpose. However, minor gaps exist, such as lacking direct code execution or deployment tools, but agents can likely work around these given the comprehensive coverage of other areas.

    Related MCP Connectors