Documentation | ModelPilot

Introduction

Set up a dedicated model workspace, supply the workflow’s inputs, and review the result. ModelPilot handles GPU deployment and lifecycle controls; you still choose the workflow and judge its output.

Start your first workspace

Create an account — Sign up with email or Google/GitHub
Add credits — Go to Billing and add prepaid credits (starting at $5).
Deploy a model — Use Quick Deploy for a listed configuration, or use the wizard to review the model, GPU, storage, and rate before launching.
Use your model — Access via the built-in web UI (ComfyUI or OpenWebUI) or the OpenAI-compatible API.
Stop when done — Click Stop on your dashboard to stop compute billing. Retained storage may still incur charges; remove the deployment when you have finished with its stored files to release those resources. Deployments do not auto-stop on idle. Low-balance protection is a safety net, not an idle timer; check the dashboard when you finish.

Key Features:

Quick Deployment: Review a listed model and its GPU recommendation in the deployment wizard
Multiple Model Types: Browse text, image, video, and audio configurations; each has its own input and runtime requirements
Persistent Storage: Configured persistent storage keeps files in its mounted directories; review those paths and any retained-storage charges
Pay As You Go: Dedicated GPU charges follow actual running time
Privacy Controls: The public workflow checker analyzes JSON server-side without storing it
Workspace Interfaces: Open the interface named by your deployment, such as OpenWebUI or ComfyUI. A template can still require a workflow import and your own input files

Getting Started

Creating an Account

To get started with ModelPilot, follow these steps:

Visit the homepage and click "Get started"
Create an account with email/password or use Google/GitHub login
You'll be taken to your dashboard
Add credits through the billing page to start deploying models

Quick Deploy Guide

The recommended deployment path uses the selected model’s configured requirements to prepare a workspace:

Reads your selected configuration and suggests a GPU. Custom resolution, batch size, nodes, or model files can change the memory requirement
Applies the configuration’s defaults for the instance and runtime. Review template instructions for any manual workflow, model, or input settings
Reports startup progress while the instance starts and model files download. Timing varies, and running GPU time during startup can be billable

Steps for Quick Deployment:

Select the model type offered by the wizard: Text, Image, Video, or Audio
Choose from pre-configured models or enter a Hugging Face model ID
Review the suggested instance and hourly rate, then customize if your workflow needs different resources
Monitor deployment progress through the dashboard
Access your running model through the provided web interface URL

Billing & Cost Management

ModelPilot uses prepaid credits:

Credits: The basic unit of payment (1 credit = $1.00 USD)
Actual-Time Billing: Dedicated deployment charges are calculated from actual running time
Pay for What You Use: Running deployments incur compute charges. Retained storage may still incur charges after compute stops.

Model Types & Interfaces

Browse the model catalog for configured models, and the workflow guides for specific graphs and required inputs. Each configuration names its interface and setup requirements. Voice choices, editing inputs, output formats, and model controls vary; they are not shared by every model in a category.

Read Choosing a model to compare requirements, or the interface guide to prepare a ComfyUI or OpenWebUI workspace. Dedicated catalog entries are separate from the supported image and speech API models.

Using Your Deployments

Dashboard Operations

Manage your deployments through the dashboard:

Start/Stop: Control when your deployments are running (and being billed)
Access: Get direct links to your model interfaces
Monitor: View deployment status and resource usage
Logs: Debug issues with deployment logs

Deployment States

Your deployments go through several states:

Building: Docker image is being created. This label alone does not establish GPU charges.
Starting: Container or models are preparing. Running GPU time can already be billable.
Running: GPU compute is running; wait for the interface health check before opening it.
Stopped: Not running (no compute billing); retained storage may still cost money.

Data Persistence

Configured persistent storage can retain files in its mounted directories. Check the paths for your deployment; it does not automatically cover every file. Examples include:

Model weights and configurations
Generated images, videos, and other outputs
Chat history and conversation data
Custom workflows and settings
Download important files before deleting resources

API Integration

OpenAI-Compatible Endpoints

Use the chat-completions request format with a text model already deployed in your account. Image and speech generation have separate per-request routes. Check the supported parameters for the route you use; API compatibility does not make model behavior identical.

Chat Completions: Use /api/v1/chat/completions with your deployed text models
Health Monitoring: Check deployment status with /api/deployments/{podId}/health
API Keys: Create API keys in your dashboard with proxy permissions
Client Integration: Configure your client’s base URL, API key, and deployed model ID. Test the response fields your application depends on

→ View complete API documentation with examples

Quick Migration Example

// Before (OpenAI)
const openai = new OpenAI({
  apiKey: 'sk-...',
  baseURL: 'https://api.openai.com/v1'
});

// After (ModelPilot)
const openai = new OpenAI({
  apiKey: 'mp_live_your_api_key',
  baseURL: 'https://your-domain.com/api/v1'
});

// Send a chat-completions request to your deployed model.
const response = await openai.chat.completions.create({
  model: 'mistral',  // Your deployed model
  messages: [{ role: 'user', content: 'Hello' }]
});