Stacksfinder

by hoklims

302 downloads

Not rated

GitHub

About

Tech stack recommendations for developers. 4 free tools + Pro features with API key. Deterministic scoring across 30+ technologies.

Details

Author: hoklims
Downloads: 302
Categories: Other, Developer Tools

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Stacksfinder

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

From the repository

Install by adding the configuration to an MCP client with "command": "npx", "args": ["-y", "@stacksfinder/mcp-server"] and an optional STACKSFINDER_API_KEY environment variable for Pro features. Invoke tools like list_technologies, analyze_tech, compare_techs, or recommend_stack (1 free per day).

`list_technologies`

Lists all available technology IDs grouped by category. Essential starting point for discovery. **Prerequisites**: None - this is typically the first tool to call. **Next Steps**: - Analyze a specific tech: `analyze_tech({ technology: "nextjs" })` - Compare techs: `compare_techs({ technologies: ["nextjs", "sveltekit"] })` - Get stack recommendation: `recommend_stack_demo({ projectType: "saas" })` **Categories**: frontend, backend, meta-framework, database, orm, auth, hosting, payments, cms **Example**: `list_technologies({ category: "frontend" })`

`analyze_tech`

Detailed analysis of a technology with 6-dimension scores, strengths, weaknesses, and compatible technologies. **Prerequisites**: Use `list_technologies` first to discover valid technology IDs. **Next Steps**: - Compare with alternatives: `compare_techs({ technologies: ["tech1", "tech2"] })` - Get full stack recommendation: `recommend_stack_demo({ projectType: "saas" })` **Dimensions scored**: Developer Experience, Performance, Scalability, Security, Ecosystem, Cost **Common Pitfalls**: - Unknown technology ID: Use exact IDs from list_technologies (e.g., "nextjs" not "Next.js") **Example**: `analyze_tech({ technology: "nextjs", context: "mvp" })`

`compare_techs`

Side-by-side comparison of 2-4 technologies with per-dimension winners and compatibility matrix. **Prerequisites**: Use `list_technologies` first to discover valid technology IDs. **Next Steps**: - Deep dive into winner: `analyze_tech({ technology: "winner-id" })` - Get full stack: `recommend_stack_demo({ projectType: "saas" })` **Output includes**: - Score comparison table - Per-dimension winners - Compatibility between compared techs - Overall recommendation **Common Pitfalls**: - Must provide 2-4 technologies (not 1, not 5+) - Use exact IDs from list_technologies **Example**: `compare_techs({ technologies: ["nextjs", "sveltekit", "remix"], context: "mvp" })`

`recommend_stack_demo`

Quick tech stack recommendation based on project type and scale. **Prerequisites**: None - great starting point for new users. **Next Steps**: - Analyze a specific tech: `analyze_tech({ technology: "recommended-id" })` - Full recommendation with priorities: `recommend_stack()` **Output includes**: - Optimal technology for each category (frontend, backend, database, etc.) - Score and grade for each recommendation - Based on 100% deterministic scoring (no AI hallucinations) **Example**: `recommend_stack_demo({ projectType: "saas", scale: "mvp" })`

`recommend_stack`

Recommends the best tech stack for a project using real-time scoring with context adjustments.

`get_blueprint`

Fetches an existing blueprint by ID. Blueprints are generated via the StacksFinder web UI or this tool.

`create_blueprint`

Creates a new tech stack blueprint for a project. The blueprint generation is asynchronous. By default, this tool waits for completion and returns the full blueprint. Set waitForCompletion=false to get the job ID immediately for manual polling. Example usage: - Create a SaaS MVP: projectType="saas", scale="mvp", priorities=["time-to-market", "cost-efficiency"] - Create an enterprise API: projectType="api", scale="enterprise", priorities=["security", "scalability"]

`setup_api_key`

Authenticates with your StacksFinder account and creates an API key using email/password. **Next Steps**: - Verify key created: `list_api_keys()` - Use Pro features: `recommend_stack()`, `create_audit()`, `create_blueprint()` **Common Pitfalls**: - For ChatGPT OAuth users: Prefer `create_api_key()` instead (no email/password needed) - If using ChatGPT with OAuth, you may need to pass dummy email/password values **Example**: `setup_api_key({ email: "you@example.com", password: "your-password", keyName: "my-key" })`

`list_api_keys`

Lists your StacksFinder API keys. Requires a configured API key.

`revoke_api_key`

Revokes an API key. This action cannot be undone.

`create_api_key`

Creates a new API key using OAuth authentication (preferred for ChatGPT users). **Tier**: Requires Pro or Team subscription **Prerequisites**: Authenticated via OAuth (ChatGPT Actions automatically handles this) **Next Steps**: - Verify key created: `list_api_keys()` - Use Pro features: `recommend_stack()`, `create_audit()`, `create_blueprint()` **Why use this over setup_api_key**: - No email/password required - Works seamlessly with ChatGPT OAuth integration - Preferred method for ChatGPT users **Common Pitfalls**: - Key is shown only once - save it securely **Example**: `create_api_key({ keyName: "my-chatgpt-key" })`

`create_audit`

Create a technical debt audit for your tech stack. Analyzes for deprecated packages, security vulnerabilities, EOL versions, and upgrade recommendations. **Tier**: Requires Pro or Team subscription (OR OAuth session) **Prerequisites**: - Pro/Team account or authenticated via OAuth - List of technologies with versions (use package.json data) **Next Steps**: - Get full report: `get_audit({ auditId: "returned-uuid" })` - Get migration plan: `get_migration_recommendation({ auditId: "uuid" })` - Compare over time: `compare_audits({ baseAuditId, compareAuditId })` **Output includes**: - Health score (0-100) - Findings by severity (critical/high/medium/low/info) - Actionable upgrade recommendations - CVE detection for known vulnerabilities **Common Pitfalls**: - Include version numbers for accurate vulnerability detection - Use technology names as they appear in package managers **Example**: `create_audit({ name: "Q1 2026 Stack Review", technologies: [{ name: "React", version: "17.0.0" }, { name: "Node.js", version: "14.0.0" }] })`

`get_audit`

Fetch a completed audit report by ID. Returns all findings and health score.

`list_audits`

List your audit reports with pagination. Shows name, status, health score, and creation date.

`compare_audits`

Compare two audit reports to track technical debt trends over time. Shows new issues introduced, issues resolved, and health score change. Useful for measuring progress on debt reduction.

`get_audit_quota`

Check your remaining audit quota for this month.

`get_migration_recommendation`

Analyze an audit report for migration opportunities. Returns a detailed migration recommendation including: - Technologies that should be replaced - Recommended modern alternatives - Migration roadmap with phases - Risk assessment - Builder constraints to pre-fill for generating a migration blueprint Use this after create_audit to get actionable migration guidance.

`import_better_t_stack`

Import a Better-T-Stack project and create an audit. **Use case**: If a project was scaffolded with Better-T-Stack CLI, you can import it directly for a technical debt audit. **Input options**: 1. GitHub URL - We'll fetch the package.json automatically 2. Raw package.json content - Paste the file contents directly **What happens**: - Detects technologies from dependencies - Calculates a "BTS confidence score" (higher = more likely a Better-T-Stack project) - Creates and runs an audit automatically - Returns findings and health score **Tier**: Requires Pro or Team subscription (OR OAuth session) **Example (GitHub)**: ```json { "type": "github", "url": "https://github.com/username/my-bts-app", "name": "My BTS App Audit" } ``` **Example (package.json)**: ```json { "type": "package-json", "content": "{"name": "my-app", "dependencies": {...}}" } ``` **Next Steps after import**: - Get migration plan: `get_migration_recommendation({ auditId: "uuid" })` - Compare with future audits: `compare_audits({ baseAuditId, compareAuditId })`

`generate_mcp_kit`

Generate a complete project kit with optimal tech stack and MCP recommendations based on your project description. Describe your project and get: 1. **Optimal Tech Stack**: Best technologies for each category (frontend, backend, database, auth, hosting, payments) 2. **MCP Recommendations**: AI-assistant tools tailored to your chosen technologies 3. **Install Configurations**: Ready-to-use configs for Claude Desktop, Cursor, and Windsurf Example prompts: - "I'm building a SaaS for project management with real-time collaboration" - "Building an MVP for a marketplace connecting freelancers with clients" - "Creating an e-commerce platform with Stripe payments and PostgreSQL"

`analyze_repo_mcps`

Analyze your current repository to detect the tech stack and recommend relevant MCP servers. This tool examines your project files (package.json, .env, config files, etc.) to: 1. Detect frontend, backend, database, auth, hosting, and payment technologies 2. Find already installed MCP servers 3. Recommend new MCPs that would enhance your development workflow 4. Generate ready-to-use install configurations for Cursor, Claude Desktop, and Windsurf Example use cases: - "What MCPs would help with my project?" - "Analyze my repo and suggest useful MCP servers" - "Which MCPs am I missing based on my tech stack?"

`prepare_mcp_installation`

Analyze your repository and generate a .env-mcp configuration file for MCP server installation. This tool: 1. Detects your tech stack from project files (package.json, .env, etc.) 2. Identifies which MCP servers would benefit your project 3. Finds already installed MCPs to avoid duplicates 4. Generates a .env-mcp template file with all required environment variables The generated .env-mcp file contains: - INSTALL_xxx flags to control which MCPs to install - Required and optional environment variables for each MCP - Documentation links and examples After running this tool: 1. Open the generated .env-mcp file 2. Fill in the API keys and configuration values 3. Set INSTALL_xxx=false for MCPs you don't want 4. Run execute_mcp_installation to complete the setup Example use cases: - "Prepare MCP installation for my project" - "Generate .env-mcp for my tech stack" - "What MCPs do I need and what credentials do they require?"

`execute_mcp_installation`

Read a .env-mcp configuration file and generate installation commands for the MCPs. This tool: 1. Reads the .env-mcp file generated by prepare_mcp_installation 2. Validates that required environment variables are present 3. Generates installation commands for the target IDE/client 4. Returns post-installation instructions Prerequisites: - Run prepare_mcp_installation first to generate .env-mcp - Fill in the required API keys and credentials in .env-mcp - Set INSTALL_xxx=false for MCPs you want to skip Supported targets: - claude-code: Generates 'claude mcp add-json' commands - claude-desktop: Generates JSON config for claude_desktop_config.json - cursor: Generates JSON config for Cursor MCP settings - vscode: Generates JSON config for VS Code MCP extension - windsurf: Generates JSON config for Windsurf Output: - Individual commands/configs for each ready MCP - Aggregate command (for Claude Code) or config (for others) - List of MCPs missing required credentials - Post-installation instructions

`check_mcp_compatibility`

Check compatibility between MCP servers. Detects conflicts (e.g., two database providers), redundancies (e.g., two ORMs), and synergies (e.g., GitHub + Vercel). Returns a health score (0-100) with grade (A/B/C/D) and detailed breakdown. **Examples:** - Check database compatibility: `["supabase-mcp", "neon-mcp"]` → conflict detected - Check ORM redundancy: `["prisma-mcp", "drizzle-mcp"]` → redundancy warning - Check synergies: `["stripe-mcp", "resend-mcp"]` → synergy detected **Supported MCP IDs include:** - supabase-mcp - neon-mcp - planetscale-mcp - turso-mcp - prisma-mcp - drizzle-mcp - clerk-mcp - auth0-mcp - stripe-mcp - paddle-mcp ...and more. **Aliases supported:** - "supabase" → "supabase-mcp" - "@neondatabase/mcp" → "neon-mcp" - "stripe" → "stripe-mcp"

`get_workflow_guide`

Intelligent workflow guide that recommends the next tool to use based on your goal and context. **When to use**: - You're unsure which StacksFinder tool to call next - You want to understand the recommended workflow for your goal - You need help navigating Pro vs Free features **Supported Goals**: - discover: Explore available technologies - setup_api_key: Get Pro features access - get_recommendation: Get a stack recommendation - audit_project: Audit technical debt - migrate_stack: Get migration recommendations - install_mcp: Set up MCP in your IDE - compare_techs: Compare technologies side-by-side - create_blueprint: Create and save a blueprint **Example**: get_workflow_guide({ current_goal: "audit_project", user_tier: "free" })

`estimate_project`

Estimate scope, pricing, and analyze market for a software project. Provides: - Detailed hour breakdown by feature (with complexity assessment) - Price ranges by team seniority level (junior/mid/senior/expert) - Competitor analysis and market trends (real-time via Perplexity) - Market size and gaps identification - Risk identification with mitigation suggestions Perfect for freelancers and agencies creating quotes. **Pricing is 100% deterministic** - same inputs always produce same outputs. Market analysis is best-effort and may vary with web data changes.

`get_estimate_quota`

Check your remaining estimate quota for this week and month.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "stacksfinder": {
            "stacksfinder": {
                "command": "npx",
                "args": [
                    "-y",
                    "@stacksfinder/mcp-server"
                ],
                "env": {
                    "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
                }
            }
        }
    }
}

McpServers

{
    "stacksfinder": {
        "command": "npx",
        "args": [
            "-y",
            "@stacksfinder/mcp-server"
        ],
        "env": {
            "STACKSFINDER_API_KEY": "<YOUR_API_KEY>"
        }
    }
}

StacksFinder MCP Server

Tech stack recommendations powered by deterministic scoring — not LLM opinions. ## Free Tools (no account required) - list_technologies — Browse 30+ technologies by category - analyze_tech — 6-dimension scoring with strengths/weaknesses - compare_techs — Side-by-side comparison of 2-4 technologies - recommend_stack — 1 free recommendation per day ## Pro Tools (requires API key) - Unlimited stack recommendations - Blueprint creation with AI-generated narratives - API key management ## Score Dimensions | Dimension | Description | |-----------|-------------| | Performance | Runtime speed, bundle size | | DX | Learning curve, tooling, docs | | Ecosystem | Community, integrations | | Maintainability | Long-term code health | | Cost | Hosting, licensing | | Compliance | Security, audit readiness | ## Installation ```json { "mcpServers": { "stacksfinder": { "command": "npx", "args": ["-y", "@stacksfinder/mcp-server"], "env": { "STACKSFINDER_API_KEY": "<YOUR_API_KEY>" } } } } Get your API key at https://stacksfinder.com/pricing

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

list_technologies

analyze_tech

compare_techs

recommend_stack_demo

recommend_stack

get_blueprint

create_blueprint

setup_api_key

list_api_keys

revoke_api_key

create_api_key

create_audit

get_audit

list_audits

compare_audits

get_audit_quota

get_migration_recommendation

import_better_t_stack

generate_mcp_kit

analyze_repo_mcps

prepare_mcp_installation

execute_mcp_installation

check_mcp_compatibility

get_workflow_guide

estimate_project

get_estimate_quota

Claude Desktop / Cursor

McpServers

StacksFinder MCP Server

Install

More like this

Sequential Thinking

Sentry

Github

Filesystem

EverArt

Google Drive

`list_technologies`

`analyze_tech`

`compare_techs`

`recommend_stack_demo`

`recommend_stack`

`get_blueprint`

`create_blueprint`

`setup_api_key`

`list_api_keys`

`revoke_api_key`

`create_api_key`

`create_audit`

`get_audit`

`list_audits`

`compare_audits`

`get_audit_quota`

`get_migration_recommendation`

`import_better_t_stack`

`generate_mcp_kit`

`analyze_repo_mcps`

`prepare_mcp_installation`

`execute_mcp_installation`

`check_mcp_compatibility`

`get_workflow_guide`

`estimate_project`

`get_estimate_quota`