vulcai-mcp-forge-cli 0.1.21

Generate MCP servers instantly from any OpenAPI, GraphQL, codebase, CLI or website

vulcai-mcp-forge

Generate production-ready MCP servers instantly from any source — OpenAPI spec, GraphQL schema, codebase, CLI tool, or website.

pip install vulcai-mcp-forge-cli
mcp-forge run https://petstore3.swagger.io/api/v3/openapi.json

What it does

mcp-forge analyses your source, extracts all callable operations, optionally enriches them with an LLM, and writes a fully working MCP server (server.py + requirements.txt) ready to plug into Claude Desktop or any MCP client.

Supported sources

Source	Example
OpenAPI / Swagger	mcp-forge run https://api.example.com/openapi.json
GraphQL	mcp-forge run https://countries.trevorblades.com/graphql
Codebase (20+ languages)	mcp-forge run ./my-project
CLI application	mcp-forge run git
Website	mcp-forge run https://docs.example.com

Supported languages for codebase analysis: Python, JavaScript, TypeScript, Go, Rust, Java, C/C++, C#, PHP, Ruby, Kotlin, Swift, Scala, Dart, Elixir, R, Fortran, Bash, PowerShell, Groovy, Julia, Lua, COBOL.

Installation

pip install vulcai-mcp-forge-cli

Requires:

• Python 3.11+
• Node.js 18+ — used by mcp-forge test to launch the MCP Inspector
• uv — used to run the generated servers

Install uv:

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

For website scraping support (JS-heavy pages / SPAs):

pip install "vulcai-mcp-forge-cli[web]"
playwright install chromium

License

Get your license key at app.mcp-forge.io then register it once:

mcp-forge set-license mfg_live_...

This saves the key to a .env file in the current directory and it will be picked up automatically on every mcp-forge run call.

Quick start

# From an OpenAPI URL
mcp-forge run https://petstore3.swagger.io/api/v3/openapi.json

# From a local GraphQL schema
mcp-forge run ./schema.graphql --type graphql

# From a codebase
mcp-forge run ./my-python-project

# From a CLI tool
mcp-forge run ffmpeg --type cli_app

# Specify output directory and server name
mcp-forge run https://api.example.com/openapi.json --output ~/mcp-servers --name my_api

The generated server is written to ../mcp-forge-output/<server_name>/ by default (outside the project directory).

Options

mcp-forge run [SOURCE] [OPTIONS]

Arguments:
  SOURCE    URL, OpenAPI file, GraphQL schema, CLI command, or directory

Options:
  --mode, -m        auto | semi | guided  (default: auto)
  --output, -o      Output directory      (default: ../mcp-forge-output)
  --type, -t        Force source type: openapi | graphql | codebase | cli_app | website
  --name, -n        Server name           (default: inferred from source)
  --name-style, -ns short | exhaustive    (default: short)
  --no-llm          Skip LLM enrichment
  --smoke-test      Run smoke test after generation
  --functional-test Run functional MCP test after generation
  --config, -c      Path to mcp-forge.yaml config file
  --api-key         Anthropic API key (or set ANTHROPIC_API_KEY)

Modes

Mode	Description
auto	Fully automatic — no prompts, JSON output on stdout
semi	Confirms key decisions, interactive where needed
guided	Step-by-step with full control over every tool

LLM enrichment

By default, mcp-forge uses Claude (Anthropic) to improve tool names and descriptions. Set your API key:

export ANTHROPIC_API_KEY=sk-ant-...
mcp-forge run https://api.example.com/openapi.json

To skip enrichment:

mcp-forge run https://api.example.com/openapi.json --no-llm

Config file

Create mcp-forge.yaml in your project root (see mcp-forge.example.yaml):

source: https://api.example.com/openapi.json
mode: auto
output: ../mcp-servers
name_style: short
no_llm: false
functional_test: true

Run with:

mcp-forge --config mcp-forge.yaml

Testing generated servers

# Smoke test — checks import and mcp object
mcp-forge smoke-test ../mcp-forge-output/my_server

# Functional test — starts server, MCP handshake, calls every tool
mcp-forge functional-test ../mcp-forge-output/my_server

Connecting the generated server to an AI agent

Once mcp-forge has generated your server, you need to register it in your AI client so it can call the tools.

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "my_api": {
      "command": "uv",
      "args": ["run", "--with", "mcp", "mcp", "run", "server.py"],
      "cwd": "/path/to/mcp-forge-output/my_api"
    }
  }
}

Restart Claude Desktop — your tools appear automatically in the conversation.

Claude Code (CLI)

claude mcp add my_api uv -- run --with mcp mcp run server.py \
  --cwd /path/to/mcp-forge-output/my_api

Or edit .mcp.json at the root of your project:

{
  "mcpServers": {
    "my_api": {
      "command": "uv",
      "args": ["run", "--with", "mcp", "mcp", "run", "server.py"],
      "cwd": "/path/to/mcp-forge-output/my_api"
    }
  }
}

Cursor

Open Settings > MCP > Add new global MCP server and paste:

{
  "my_api": {
    "command": "uv",
    "args": ["run", "--with", "mcp", "mcp", "run", "server.py"],
    "cwd": "/path/to/mcp-forge-output/my_api"
  }
}

VS Code (Copilot / Continue)

In .vscode/mcp.json at the root of your workspace:

{
  "servers": {
    "my_api": {
      "type": "stdio",
      "command": "uv",
      "args": ["run", "--with", "mcp", "mcp", "run", "server.py"],
      "cwd": "/path/to/mcp-forge-output/my_api"
    }
  }
}

Windsurf

Open Windsurf Settings > Cascade > MCP servers > Add Server:

{
  "my_api": {
    "command": "uv",
    "args": ["run", "--with", "mcp", "mcp", "run", "server.py"],
    "cwd": "/path/to/mcp-forge-output/my_api"
  }
}

Any MCP-compatible client (generic)

All clients that implement the MCP spec accept a STDIO transport. The pattern is always the same:

command : uv
args    : run --with mcp mcp run server.py
cwd     : /path/to/mcp-forge-output/<server_name>
env     : { "MY_API_KEY": "..." }   ← optional, for authenticated APIs

Tip — authenticated APIs: if your server was generated from an API that requires authentication, set the relevant environment variable in the env block. The generated server.py reads credentials from environment variables — no secrets are hardcoded.

---

CI/CD integration

GitHub Actions, Jenkins and GitLab CI pipeline templates are included in the ci/ directory and generated alongside each server.

Example GitHub Actions step:

- name: Generate MCP server
  run: |
    pip install vulcai-mcp-forge-cli
    mcp-forge run https://api.example.com/openapi.json --mode auto --no-llm

License

MIT — see LICENSE.