init-app-mcp
This server helps MCP-compatible AI clients understand the init-app CLI and build valid, ready-to-run commands from a user's project needs without executing anything.
Explains the
init-appCLI contract, flags, allowed values, and recommended workflow viaget_init_app_command_metadata.Lists all supported web and specialized project blueprints via
list_project_blueprints.Converts natural-language requirements into suggested flags and follow-up questions via
recommend_init_app_flags.Validates confirmed selections and returns exact
init-appcommand arguments viabuild_init_app_command.Supports options like framework, strategy, database, server, venv, DRF, output directory, and project name.
Provides advisory-only behavior: no file creation, shell execution, or direct
init-appinvocation.
Translates Docker containerization requirements into the appropriate init-app production strategy when generating project scaffolding commands.
Selects the FastAPI web framework as the project blueprint when building init-app scaffolding commands.
Configures Gunicorn as the production WSGI server in generated init-app project commands.
Translates Kubernetes orchestration requirements into the appropriate init-app production strategy when generating project scaffolding commands.
Maps PostgreSQL database requirements to the init-app database option in generated scaffolding commands.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@init-app-mcp I need a production REST API with PostgreSQL, Docker, and Kubernetes."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
init-app-mcp
An independent FastMCP server that helps MCP-compatible AI clients understand
the init-app CLI and construct valid commands from a user's project needs.
init-app-mcp does not import, install, or execute init-app. It owns a
versioned capability catalog and returns metadata, recommendations, and command
arguments only. The client or its user decides whether and where to run the
returned command.
What it does
Explains the
init-appcommand contract and valid flags.Lists supported web and specialized project blueprints.
Converts plain-English requirements into relevant, supported flag choices.
Validates confirmed choices and returns the exact command arguments.
Exposes parent tool domains for research, writing, resume, code, and init-app, with validated multi-tool selections under each domain.
Never creates files, starts processes, or runs shell commands.
Related MCP server: Agent Blueprint
Requirements
Python 3.10 or later
FastMCP v2 (
fastmcp>=2,<3)
Installation
Install from a clone:
git clone https://github.com/ashmeet07/init-app-mcp.git
cd init-app-mcp
python -m pip install .When published to PyPI, install it with:
python -m pip install init-app-mcpFor development:
python -m pip install -e ".[dev]"
python -m pytestMCP client configuration
Configure an MCP client to use stdio transport:
{
"mcpServers": {
"init-app": {
"command": "init-app-mcp"
}
}
}Horizon Deploy
For Horizon Deploy's repository form, use these values:
Field | Value |
Server name |
|
Entrypoint |
|
Requirements |
|
Transport | Streamable HTTP |
The root server.py is a deployment wrapper that exposes the same mcp
server defined by the source package. It exists because Horizon asks for a
Python file path rather than a Python import string. When Horizon runs this
file, it uses Streamable HTTP automatically and honors its HOST and PORT
environment variables.
If your client requires an absolute Python executable, use:
{
"mcpServers": {
"init-app": {
"command": "/absolute/path/to/python",
"args": ["-m", "init_app_mcp.server"]
}
}
}Manual diagnostics
The default command starts a stdio MCP server, so it expects JSON-RPC messages from an MCP client such as VS Code. Do not press Enter after starting it in a terminal; a blank line is not a valid MCP request.
Use these commands to inspect the installed server manually instead:
.\.venv\Scripts\init-app-mcp.exe --list-tools
.\.venv\Scripts\init-app-mcp.exe --metadataTo run a local HTTP MCP endpoint for manual client testing, use:
.\.venv\Scripts\init-app-mcp.exe --transport streamable-http --port 8001It listens on http://127.0.0.1:8001/mcp. Choose another available port if
needed. Keep that terminal open while your
MCP client is connected. Press Ctrl+C to stop it.
Tools
Use list_tool_domains to discover parent domains and their child tools, then
call select_domain_tools with a domain and a list such as
["build_resume", "improve_bullets"]. The init-app command builder also
supports env_manager values venv, uv, and none; uv maps to
init-app ... --env-manager uv.
Tool | Purpose |
| Returns the CLI contract, flag definitions, allowed values, and recommended workflow. |
| Lists all web and specialized project blueprints supported by the catalog. |
| Maps a user's natural-language requirements to suggested flags, reasoning, and follow-up questions. |
| Validates user-confirmed options and returns portable |
Recommended client workflow
Call
get_init_app_command_metadatato learn the command schema.Call
recommend_init_app_flagswith the user's request.Show the suggested flags and answer any follow-up questions with the user.
Call
build_init_app_commandusing the confirmed values.Present the final command for the user to run.
Example user request:
I need a production REST API with PostgreSQL, Docker, and Kubernetes.The recommendation tool suggests a selection similar to:
{
"framework": "fastapi",
"strategy": "production",
"database": "postgresql",
"server": "gunicorn",
"venv": true
}After the project name and output directory are confirmed, call
build_init_app_command. It returns arguments equivalent to:
init-app billing-api --framework fastapi --type production --db postgresql --venv y --server gunicorn --output-dir ./projectsThe 0.2.0 catalog targets init-app 3.2.0. It includes metadata and command
building support for JSON specifications, dry runs, safe overwrite opt-in,
custom app names, folders, and packages. Use dry_run: true before asking a
user to run a generation command.
Development
python -m pytest
python -m py_compile src/init_app_mcp/server.py src/init_app_mcp/service.py src/init_app_mcp/catalog.pyContinuous integration runs this validation on Python 3.10 through 3.13 for
every pull request to main.
The project uses a source layout. Its capability catalog lives in
src/init_app_mcp/catalog.py; update that catalog and its tests whenever
init-app adds or changes CLI capabilities.
Safety model
This package is intentionally advisory. It does not access a user's project
directory, execute init-app, write files, or invoke a shell. A compatible
client must obtain user confirmation before running any recommended command.
Release checklist
Before releasing a catalog update:
Compare
src/init_app_mcp/catalog.pywith the supportedinit-appCLI.Update catalog tests for every new or changed flag or blueprint.
Run the development checks above and inspect
--list-tools.Open a pull request from
feattomainand let CI pass before merging.
License
Distributed under the MIT License.
Available Tools
4 toolsbuild_init_app_commandB
Final step: validate confirmed user selections and return an init-app command without running it.
Inputs: project_name (required), drf, venv, server, +4 more. Returns: object
get_init_app_command_metadataA
First step: return init-app command metadata, flags, values, and workflow.
Inputs: no named parameters. Returns: object
list_project_blueprintsA
List every web and specialized project type supported by init-app.
Inputs: no named parameters. Returns: result
recommend_init_app_flagsB
Second step: derive supported init-app flags and clarification questions from a user query.
Inputs: requirements (required). Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a distinct role in the workflow: metadata retrieval, blueprint listing, flag recommendation, and command construction. The descriptions clearly separate responsibilities, though 'recommend_init_app_flags' and 'build_init_app_command' could overlap slightly in purpose, but context disambiguates them.
All tools follow a verb_object pattern (get, list, recommend, build). The only deviation is 'list_project_blueprints' missing the 'init_app' domain qualifier that the other three share, which is a minor inconsistency in naming scope rather than syntax.
Four tools is an ideal size for a focused init-command helper. Each tool serves a clear step in the process without redundancy or unnecessary surface area, making the set well-scoped and easy to navigate.
The workflow is explicitly covered from metadata through blueprint listing, flag recommendation, and final command construction. The only notable gap is that there is no tool to actually execute the command, but this appears intentional for a command-builder server, so completeness is high for its stated purpose.
Maintenance
Related MCP Connectors
Convert, lint and generate LLM tool schemas for OpenAI, Anthropic, Gemini and MCP
List, read, edit, and deploy your GenMB AI-generated apps from any MCP client.
Read-only discovery of ChatGXT's integration catalog and public MCP capabilities.
Free MCP tools to validate multi-agent coordination thread turns and retrieve schema/samples.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceDynamically exposes CLI/bash commands as MCP tools and creates structured AI prompt templates through simple YAML configuration files, enabling users to transform any command-line tool into an MCP-compatible interface without writing code.20Apache 2.0

Agent Blueprintofficial
AlicenseAqualityCmaintenanceCLI and MCP server for AI agent strategy and deployment. Read blueprints, business cases, implementation plans, and specs from your coding agent. 18 tools for listing, retrieving, downloading, and updating blueprints. Exports full implementation specs as Agent Skills directories.23311 npm3MIT- AlicenseNot gradedqualityDmaintenanceTurn any CLI tool into an MCP server by leveraging its --help output, enabling natural language interaction with tools like gh, az, git, etc.16 npm25MIT
- FlicenseAqualityBmaintenanceEnables AI assistants to directly invoke higpertext-cli capabilities as validated MCP tools, covering grep search, git diff and ls-files, smart reading, code skeletonization, knowledge lookup, memory management, committing, secret scanning, and quality resolution without routing through Bash.3-