Skip to main content
Glama
askuma

Generate Tech Stack

generate-tech-stack

Scan any project and generate a visual TECH_STACK.html page — light/dark theme, auto-adapting, zero config.

Works as a Claude Code skill, MCP server, or GitHub Copilot Extension.

Live demo → — generated from fastapi/full-stack-fastapi-template, unmodified.

Running generate-tech-stack against fastapi/full-stack-fastapi-template, from pip install to the generated page

(real CLI output, unscripted — static screenshot if you'd rather not autoplay)


What it produces

Every generated page contains:

Section

Description

Stat row

Total tools · Categories · AI Backends · Data Stores

Architecture diagram

Layered flow diagram (Consumer → API → AI/NLP → Data/Obs/Frontend)

Bar chart

Horizontal bars per category, colour-matched

Tool cards

One card per category; each tool shows a dot, name, description, and badge

Badge legend

Explains pip, dep, optional, core, deploy, ci, etc.

Footer

Project name · tool count · generation date

Guided tour

Spotlight walkthrough of every section, shown automatically the first time a report is opened; replay anytime with the ? button

Theme toggle

Sun/moon button next to the tour button switches between dark and light mode


Related MCP server: mcp-repo-graph

Repository layout

~/.claude/skills/generate-tech-stack/
├── SKILL.md                  ← Claude Code skill definition
├── INSTALL.md                ← detailed per-platform installation guide
├── README.md                 ← this file
├── scripts/
│   └── analyze.py            ← core scanner + HTML renderer (no dependencies)
├── mcp/
│   ├── server.py             ← MCP stdio server (pip install mcp)
│   └── requirements.txt
└── copilot/
    ├── index.js              ← GitHub Copilot Extension (Express)
    ├── package.json
    └── openai_function.json  ← OpenAI / Antigravity function definition

Usage

pip (CLI + MCP server)

pip install generate-tech-stack-mcp

generate-tech-stack . TECH_STACK.html    # CLI: scan and write the report
generate-tech-stack-mcp                   # stdio MCP server

With pip installed, any MCP host config reduces to:

{
  "mcpServers": {
    "generate-tech-stack": { "command": "generate-tech-stack-mcp" }
  }
}

Claude Code

/generate-tech-stack

Run it from any project directory. The skill calls scripts/analyze.py and opens the result in your browser.

MCP (Claude Desktop, VS Code, Cursor, Zed, Windsurf, Continue)

pip install mcp

Add to your host's MCP config (replace the path with your actual home directory):

{
  "mcpServers": {
    "generate-tech-stack": {
      "command": "python3",
      "args": ["/home/<you>/.claude/skills/generate-tech-stack/mcp/server.py"]
    }
  }
}

Then ask: generate my tech stack or /generate-tech-stack.

MCP tools exposed:

  • generate_tech_stack — scans a project, writes TECH_STACK.html, opens in browser

  • list_tech_stack — returns a JSON summary, no file written

GitHub Copilot Extension

cd copilot
npm install
npm start        # listens on port 3000
ngrok http 3000  # expose for GitHub to reach

Register a GitHub App with Copilot Extension enabled, set the Agent URL to https://your-url/agent, and install it on your account. Then in Copilot Chat:

@generate-tech-stack /generate-tech-stack
@generate-tech-stack /generate-tech-stack /path/to/project

Command line (standalone)

python3 ~/.claude/skills/generate-tech-stack/scripts/analyze.py /path/to/project
# output: /path/to/project/TECH_STACK.html

# custom output path:
python3 scripts/analyze.py . ~/Desktop/TECH_STACK.html

analyze.py has no third-party dependencies — just Python 3.8+.


What gets detected

Source file

Detected tools

requirements.txt / pyproject.toml

Python packages (web, DB, AI, testing, observability, security…)

package.json

Node / npm packages (frameworks, frontend, DB drivers, tooling)

go.mod

Go language

Cargo.toml

Rust language

pom.xml / build.gradle

Java / Kotlin

Gemfile

Ruby

composer.json

PHP

**/*.py source

Optional/dynamic SDKs via importlib.find_spec() patterns

docker-compose.yml / .env

PostgreSQL, Redis, MongoDB, SQLite connection strings

Dockerfile

Docker

docker-compose.yml

Docker Compose

.github/workflows/

GitHub Actions

.gitlab-ci.yml

GitLab CI

alembic.ini

Alembic migrations

nginx.conf / Caddyfile

Reverse proxy

tsconfig.json / src/**/*.ts

TypeScript


Detected categories

Category

Colour

Examples

Language & Runtime

Green

Python, Go, Rust, TypeScript

Web / API Framework

Purple

FastAPI, Express, Django, Next.js

Database / Storage

Green

SQLAlchemy, Prisma, Redis, ChromaDB

AI SDKs

Blue

OpenAI, Anthropic, LangChain, GuardrailsAI, NVIDIA NeMo, Presidio

NLP / ML

Teal

spaCy, Transformers, Sentence Transformers

Observability

Teal

Prometheus, OpenTelemetry, Sentry, Loguru

Testing

Yellow

pytest, Jest, Cypress, Playwright

Security / Auth

Rose

PyJWT, bcrypt, Authlib, Helmet

Infrastructure / Deploy

Orange

Docker, Kubernetes, Celery, Boto3

Frontend / Dashboard

Gray

React, Vue, Tailwind, Recharts

Messaging / Comms

Blue

Kafka, RabbitMQ, Socket.io

Dev Tools

Gray

ESLint, Prettier, Vite, TypeScript


Design

Dark by default with a light-mode toggle (top-right corner, no persistence — resets to dark on reload). Fonts: IBM Plex Sans (body) + JetBrains Mono (code/badges), loaded from Google Fonts. Vanilla JS powers the guided tour and theme toggle only — everything else is plain HTML + CSS. Self-contained single file, opens in any browser offline.


See also

  • INSTALL.md — per-platform setup instructions

  • SKILL.md — Claude Code skill specification

Available Tools

2 tools
generate_tech_stackA

Scan a project directory and generate a TECH_STACK.html visual page. Includes a stat row, layered architecture diagram, bar chart summary, and colour-coded tool cards. Detects languages, frameworks, databases, AI SDKs, testing, observability, security, and infrastructure tools.

ParametersJSON Schema
NameRequiredDescriptionDefault
output_fileNoPath for the output HTML. Defaults to <project_dir>/TECH_STACK.html.
project_dirNoAbsolute path to the project root. Defaults to cwd.
open_browserNoOpen the file in the default browser after creation.

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, description carries full burden. It explains the tool scans and generates an HTML file, but does not disclose whether it overwrites existing files, requires specific permissions, or has side effects beyond file creation. Some behavioral details (e.g., file overwrite behavior) are missing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description consists of two concise sentences. The first states core purpose with verb and resource, the second enumerates output features and detection scope. No redundant or extraneous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema and no annotations, the description covers inputs (project_dir), output details (HTML components), and detection categories. It is fairly complete but could mention error handling (e.g., invalid path) or whether overwrite is allowed. Still, it provides sufficient context for most use cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

All three parameters (output_file, project_dir, open_browser) are fully described in the input schema (100% coverage). The description adds no additional semantic context beyond what the schema provides, so baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool scans a project directory and generates a TECH_STACK.html visual page. It lists specific components (stat row, diagram, bar chart, tool cards) and detection categories (languages, frameworks, etc.), distinguishing it from sibling list_tech_stack which likely only lists without generating visuals.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Description implies use when a visual tech stack page is needed, but does not explicitly state when to use vs not, nor does it mention alternatives or prerequisites (e.g., project must be a valid directory). No guidance on exclusion scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_tech_stackA

Scan a project and return the tech stack as structured JSON (no HTML file written). Good for programmatic use.

ParametersJSON Schema
NameRequiredDescriptionDefault
project_dirNoAbsolute path to the project root.

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full responsibility. It mentions no file writing, implying a read-only operation, but does not disclose other behavioral traits such as whether the scan requires internet access, the typical depth of scanning, or any potential performance impact. The description is adequate but lacks richer behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is one concise sentence that immediately conveys the core function and differentiator. It is front-loaded with the key action and result, with no unnecessary words. Every part earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has one optional parameter and no output schema, the description is mostly complete. It explains what the tool does and when to use it (programmatic use). However, it could benefit from describing the structure of the returned JSON to help the agent understand the output format, especially in the absence of an output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and the parameter 'project_dir' is described in the schema as 'Absolute path to the project root.' The tool description does not add any additional meaning or usage guidance beyond this, so it meets the baseline with no extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool scans a project and returns the tech stack as structured JSON, explicitly noting it does not write an HTML file. This distinguishes it from the sibling tool 'generate_tech_stack', which likely produces HTML output.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description says 'Good for programmatic use,' which implies this tool is for automated consumption. While it doesn't explicitly state when not to use it or name alternatives, the sibling context and the phrase 'no HTML file written' indirectly guide users to choose this over 'generate_tech_stack' for machine-readable output.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 2 tool updatesv0.1.0
    • First observedgenerate_tech_stack
    • First observedlist_tech_stack

TDQS

A4.2/5.0
Disambiguation5/5

The two tools have clearly distinct purposes: one generates a visual HTML report, the other returns structured JSON for programmatic use. No overlap in functionality.

Naming Consistency4/5

Both tools use 'tech_stack' noun consistently, but the verbs differ ('generate' vs 'list') which is a minor inconsistency. Mostly follows verb_noun pattern.

Tool Count5/5

Two tools are appropriate for the narrow domain of detecting and outputting a tech stack. The pair covers the essential use cases without unnecessary bloat.

Completeness5/5

The tools cover both visual and data-driven outputs, which are the primary needs for tech stack generation. No obvious gaps for the stated purpose.

Maintenance

ActivitySlowing
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/askuma/generate-tech-stack'

If you have feedback or need assistance with the MCP directory API, please join our Discord server