Agent skill

Init GPU Server

by drawthingsai in drawthingsai/draw-things-community

Initialize a Draw Things GPU server with GPUScript, including script sync, Docker/CUDA/NVIDIA runtime setup, 7T data disk mounting, mergerfs, and end-to-end GPU verification.

GPL-3.0Auto-check passedDevOps & Cloud

Install Init GPU Server

skills CLI
$ npx skills add drawthingsai/draw-things-community --skill init-gpu-server -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install drawthingsai/draw-things-community init-gpu-server --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/drawthingsai/draw-things-community.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/init-gpu-server .claude/skills/init-gpu-server && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
init-gpu-server
GitHub stars
579
Token cost
~2.2k tokens
SKILL.md length
532 words
Files
1
Skills in repo
8
Repo updated
First seen
Licence
GPL-3.0

At a glance

Initialize a Draw Things GPU server with GPUScript, including script sync, Docker/CUDA/NVIDIA runtime setup, 7T data disk mounting, mergerfs, and end-to-end GPU verification.

  • Tasks that involve Containers
  • SKILL.md covers Goal, Source Scripts, Script Hygiene and Upload Scripts, plus 8 more sections
  • Calls ssh, bash and apt-get

What it does

Init GPU Server is an agent skill from drawthingsai/draw-things-community. Initialize a Draw Things GPU server with GPUScript, including script sync, Docker/CUDA/NVIDIA runtime setup, 7T data disk mounting, mergerfs, and end-to-end GPU verification.

Its SKILL.md is about 2.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in DevOps & Cloud, covering Containers. It works with CUDA, Docker and NVIDIA AI Platform. The repository describes itself as: The community repository for the Draw Things app. The licence is GPL-3.0.

When your agent uses it

  • Tasks that involve Containers

Example prompts

  • “/init-gpu-server”

Requirements

  • Python 3
  • Docker

What it can do on your machine

Read from SKILL.md and the folder at commit 3cac075. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • ssh
    • bash
    • apt-get
    • docker

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use ssh and docker, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Init GPU Server loads about 2.2k tokens when it runs. Until then it costs about 48 tokens; SKILL.md has 532 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~48
When it runs · the whole SKILL.md, loaded when a task matches
~2.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from drawthingsai/draw-things-community at commit 3cac075, republished under its GPL-3.0 licence (© drawthingsai). 532 words, ~2,203 tokens.

Download SKILL.mdSave it as .claude/skills/init-gpu-server/SKILL.md (or your agent's skills folder).
name
init-gpu-server
description
Initialize a Draw Things GPU server with GPUScript, including script sync, Docker/CUDA/NVIDIA runtime setup, 7T data disk mounting, mergerfs, and end-to-end GPU verification.

Init GPU Server Skill

Use this workflow when bringing up a new Draw Things GPU server reachable as root@HOST.

Goal

Prepare the server for Draw Things GPU workloads:

  • sync GPUScript utilities to /root/utils
  • install Docker, CUDA Toolkit, NVIDIA Container Toolkit, mergerfs, and Python utilities
  • mount data disks at /mnt/models and /mnt/loraModels
  • expose a merged model path at /mnt/official-models
  • verify Docker can access all GPUs

Source Scripts

Repo source:

sh
Scripts/ServerManagement/GPUScript

Important files:

  • update_scripts.sh: uploads files from files_to_copy.txt to /root/utils/
  • init_gpu_server.sh: installs Docker/CUDA/NVIDIA runtime, Python deps, network sysctl, and the Draw Things Docker image
  • LaunchGPU/remount_disk.sh: historical reference for disk remounting and mergerfs setup
  • verify_gpu_setup.sh: remote verification helper

Script Hygiene

Before running the init script:

sh
bash -n Scripts/ServerManagement/GPUScript/init_gpu_server.sh

If working from an older branch, make sure init_gpu_server.sh has these properties:

  • Uses noninteractive apt/dpkg with a lock timeout:
sh
export DEBIAN_FRONTEND=noninteractive
apt-get -o DPkg::Lock::Timeout=600 \
  -o Dpkg::Options::=--force-confdef \
  -o Dpkg::Options::=--force-confold ...
  • Uses the remote OS version for the CUDA repo, not a hardcoded Ubuntu release:
sh
CUDA_REPO_ID=$( . /etc/os-release && echo "ubuntu$(echo "$VERSION_ID" | tr -d ".")" )
  • Propagates the remote SSH exit code from init_server; do not force return 0.
  • Does not require ssh -t for automation.
  • Disk prompt read lines tolerate EOF, for example read -p "..." DISK1 || DISK1="".
  • Avoids single quotes inside the large single-quoted INIT_COMMANDS string.

Upload Scripts

Accept the SSH host key if needed:

sh
ssh -o BatchMode=yes -o ConnectTimeout=10 -o StrictHostKeyChecking=accept-new root@HOST 'echo ok'

Upload the GPUScript files:

sh
bash Scripts/ServerManagement/GPUScript/update_scripts.sh root@HOST

Expected remote destination:

text
/root/utils/

Run Init

Run:

sh
bash Scripts/ServerManagement/GPUScript/init_gpu_server.sh root@HOST

This should install/configure:

  • Docker CE and containerd
  • CUDA Toolkit
  • NVIDIA Container Toolkit
  • mergerfs
  • /opt/draw-things-venv with tqdm, schedule, and boto3
  • network sysctl tuning for large TCP buffers and BBR
  • drawthingsai/draw-things-grpc-server-cli:latest

It is acceptable to skip disk mounting inside this script. Mount disks explicitly after inspecting lsblk.

Apt/Dpkg Recovery

If apt or dpkg fails on a conffile prompt, such as /etc/cloud/cloud.cfg, repair the remote package state:

sh
ssh root@HOST 'DEBIAN_FRONTEND=noninteractive dpkg --force-confdef --force-confold --configure -a'
ssh root@HOST 'DEBIAN_FRONTEND=noninteractive apt-get -y -f install -o Dpkg::Options::=--force-confdef -o Dpkg::Options::=--force-confold'

If a new run hits an apt lock, inspect first:

sh
ssh root@HOST 'pgrep -af apt; pgrep -af dpkg'

If an earlier init process is still installing packages, wait. Do not kill package-manager processes unless the user explicitly asks.

Disk Inspection

Inspect block devices and current mounts before changing disks:

sh
ssh root@HOST 'lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS,FSTYPE,UUID; echo ---; blkid || true; echo ---; df -h'

Target shape:

text
DISK_Ap1 -> /mnt/models
DISK_Bp1 -> /mnt/loraModels
/mnt/models/official-models:/mnt/loraModels/models_extra -> /mnt/official-models

Do not assume device names. Pick the two 7T data disks from actual lsblk output. On one validated host the mapping was:

text
/dev/nvme1n1p1 -> /mnt/models
/dev/nvme0n1p1 -> /mnt/loraModels
Show full SKILL.md (199 more words)Show less

Raw 7T Disk Setup

If the two 7T disks are raw disks with no partitions and no filesystem, get explicit user approval before partitioning and formatting. This destroys data on those disks.

After approval, replace MODELS_DISK and LORA_DISK with the inspected devices:

sh
ssh root@HOST 'set -euo pipefail
export DEBIAN_FRONTEND=noninteractive
apt-get -o DPkg::Lock::Timeout=600 -o Dpkg::Options::=--force-confdef -o Dpkg::Options::=--force-confold update
apt-get -o DPkg::Lock::Timeout=600 -o Dpkg::Options::=--force-confdef -o Dpkg::Options::=--force-confold install -y parted mergerfs

MODELS_DISK=/dev/nvme1n1
LORA_DISK=/dev/nvme0n1

for disk in "$MODELS_DISK" "$LORA_DISK"; do
  test -b "$disk"
  if lsblk -nrpo NAME "$disk" | tail -n +2 | grep -q .; then
    echo "Refusing to repartition $disk because it already has child block devices" >&2
    lsblk "$disk" >&2
    exit 1
  fi
done

parted -s "$MODELS_DISK" mklabel gpt mkpart primary ext4 0% 100%
parted -s "$LORA_DISK" mklabel gpt mkpart primary ext4 0% 100%
partprobe "$MODELS_DISK" "$LORA_DISK" || true
udevadm settle

mkfs.ext4 -F -L models "${MODELS_DISK}p1"
mkfs.ext4 -F -L loraModels "${LORA_DISK}p1"
'

For non-NVMe disks, adjust partition paths accordingly. NVMe partition paths normally use the p1 suffix.

Mount And Persist

After partitions/filesystems exist, mount them by UUID and persist in /etc/fstab:

sh
ssh root@HOST 'set -euo pipefail
mkdir -p /mnt/models /mnt/loraModels /mnt/official-models

MODEL_PART=/dev/nvme1n1p1
LORA_PART=/dev/nvme0n1p1
MODEL_UUID=$(blkid -s UUID -o value "$MODEL_PART")
LORA_UUID=$(blkid -s UUID -o value "$LORA_PART")

cp /etc/fstab "/etc/fstab.drawthings.$(date +%Y%m%d%H%M%S).bak"
grep -vE "/mnt/models|/mnt/loraModels|/mnt/official-models|/mnt/official_models" /etc/fstab > /etc/fstab.drawthings.new
mv /etc/fstab.drawthings.new /etc/fstab

{
  echo "UUID=$MODEL_UUID /mnt/models ext4 defaults,nofail 0 2"
  echo "UUID=$LORA_UUID /mnt/loraModels ext4 defaults,nofail 0 2"
  echo "/mnt/models/official-models:/mnt/loraModels/models_extra /mnt/official-models fuse.mergerfs allow_other,use_ino,ro,nofail 0 0"
} >> /etc/fstab

if grep -q "^#user_allow_other" /etc/fuse.conf; then
  sed -i "s/^#user_allow_other/user_allow_other/" /etc/fuse.conf
elif ! grep -q "^user_allow_other" /etc/fuse.conf; then
  echo user_allow_other >> /etc/fuse.conf
fi

mountpoint -q /mnt/official-models && umount /mnt/official-models || true
mountpoint -q /mnt/models || mount /mnt/models
mountpoint -q /mnt/loraModels || mount /mnt/loraModels
mkdir -p /mnt/models/official-models /mnt/loraModels/models_extra /mnt/official-models
mountpoint -q /mnt/official-models || mount /mnt/official-models

lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS,FSTYPE,UUID
df -h | grep -E "Filesystem|/mnt/models|/mnt/loraModels|/mnt/official-models"
'

Use /mnt/official-models, not /mnt/official_models, for Draw Things GPU server conventions.

Verification

Always verify directly, even if the init script prints success:

sh
ssh root@HOST 'set -e
echo "=== GPUs ==="
nvidia-smi --query-gpu=name,driver_version --format=csv,noheader
echo "=== CUDA ==="
/usr/local/cuda/bin/nvcc --version
echo "=== NVIDIA Container Toolkit ==="
nvidia-ctk --version
echo "=== Docker ==="
docker --version
docker info --format "Runtimes={{json .Runtimes}} Default={{.DefaultRuntime}}"
echo "=== Draw Things image ==="
docker image inspect drawthingsai/draw-things-grpc-server-cli:latest --format "{{.Id}} {{.RepoTags}}"
echo "=== Mounts ==="
lsblk -o NAME,SIZE,TYPE,MOUNTPOINTS,FSTYPE
df -h | grep -E "Filesystem|/mnt/models|/mnt/loraModels|/mnt/official-models"
'

Then run an end-to-end Docker GPU test:

sh
ssh root@HOST 'docker run --rm --gpus all nvidia/cuda:12.0.0-base-ubuntu22.04 nvidia-smi'

Success means the container sees GPUs through the NVIDIA runtime.

Expected Healthy State

For an 8x RTX 5090 host, a healthy result looked like:

  • nvidia-smi lists 8 GPUs
  • host driver version is 580.173.02
  • /usr/local/cuda/bin/nvcc --version reports CUDA Toolkit 13.3
  • nvidia-ctk --version reports NVIDIA Container Toolkit 1.19.1
  • Docker has an nvidia runtime
  • drawthingsai/draw-things-grpc-server-cli:latest exists locally
  • Docker GPU test container runs nvidia-smi successfully
  • lsblk shows both 7T partitions mounted:
text
nvme1n1p1 /mnt/models     ext4
nvme0n1p1 /mnt/loraModels ext4
  • df -h shows /mnt/models, /mnt/loraModels, and /mnt/official-models

Reboot

If /var/run/reboot-required exists, tell the user. GPU/Docker may work before reboot, but reboot is the clean final state after kernel, firmware, CUDA, or driver setup:

sh
ssh root@HOST 'test -f /var/run/reboot-required && cat /var/run/reboot-required || echo no'

© drawthingsai, GPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/init-gpu-server of drawthingsai/draw-things-community.

Open the folder on GitHubat commit 3cac075

Compare with similar skills

Init GPU Server next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Init GPU Server compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Init GPU Server this skilldrawthingsai/draw-things-community579—~2.2kAutomated safety check: PassGPL-3.0
Kermt SetupNVIDIA/skills3.5k1 repos~1.7kAutomated safety check: PassApache-2.0
Tao Setup Nvidia GPU HostNVIDIA/skills3.5k—~3.4kAutomated safety check: NotesApache-2.0
Holoscan Install ContainerNVIDIA/skills3.5k—~1.9kAutomated safety check: PassApache-2.0
Cuopt InstallNVIDIA/skills3.5k—~1.1kAutomated safety check: PassApache-2.0
Tao Run On DockerNVIDIA/skills3.5k—~5kAutomated safety check: WarnApache-2.0

Similar skills

  • Kermt Setup

    NVIDIA/skills

    Official

    Bootstrap the KERMT agent environment — verify host docker + nvidia-container-toolkit, build the kermt:latest image from the repo's Dockerfile if it doesn't yet exist, and run a GPU smoke test…

    3.5k GitHub starsUsed in 1 repo~1.7k tokens
    DevOps & CloudAuto-check passed
  • Official

    Host setup for TAO GPU backends. An agent skill from NVIDIA/skills.

    3.5k GitHub stars~3.4k tokensUpdated today
    DevOps & CloudAuto-check: notes
  • Official

    Install Holoscan SDK via the NGC Docker container. An agent skill from NVIDIA/skills.

    3.5k GitHub stars~1.9k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Cuopt Install

    NVIDIA/skills

    Official

    Install cuOpt for Python, C, or server via pip, conda, or Docker; verify the install.

    3.5k GitHub stars~1.1k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Tao Run On Docker

    NVIDIA/skills

    Official

    The Docker execution platform for TAO jobs — a local daemon or a remote GPU box via DOCKERHOST=ssh://user@host.

    3.5k GitHub stars~5k tokensUpdated today
    DevOps & CloudAuto-check: warnings
  • Vllm Deploy Docker

    vllm-project/vllm-skills

    Deploy vLLM using Docker (pre-built images or build-from-source) with NVIDIA GPU support and run the OpenAI-compatible server.

    103 GitHub stars~2.5k tokensUpdated 6 mo ago
    AI & LLM EngineeringAuto-check: notes

More from drawthingsai/draw-things-community

All 8 skills in this repo
  • Run Longcat Avatar Video

    drawthingsai/draw-things-community

    Generate, benchmark, validate, and troubleshoot LongCat-Video-Avatar 1.5 videos with draw-things-cli.

    579 GitHub stars~2.8k tokensUpdated yesterday
    Auto-check passed
  • Setup Cpu Proxy Server

    drawthingsai/draw-things-community

    Set up and verify a new Draw Things CPU proxy and Envoy server using the scripts in Scripts/ServerManagement/CPUScript.

    579 GitHub stars~3.8k tokensUpdated yesterday
    Auto-check passed
  • Use Drawthings CLI

    drawthingsai/draw-things-community

    Use and troubleshoot an already installed Homebrew draw-things-cli for model discovery, authentication, local, cloud, or remote image generation, basic image-to-image and video generation, output…

    579 GitHub stars~3k tokensUpdated yesterday
    Auto-check passed
  • New Model Integration

    drawthingsai/draw-things-community

    Add a new image or video generative model to the Draw Things app / CLI with a compile-first, end-to-end workflow across SwiftDiffusion, tokenizer plumbing, text encoder, fixed encoder, UNet / DiT…

    579 GitHub stars~4.8k tokensUpdated yesterday
    Auto-check passed
  • Train Lora

    drawthingsai/draw-things-community

    Validate Draw Things LoRA training end to end with draw-things-cli, including tiny-dataset training, loss and scaler checks, checkpoint sanity, and base-versus-LoRA generation comparison.

    579 GitHub stars~2k tokensUpdated yesterday
    Auto-check passed
  • Trainer Integration

    drawthingsai/draw-things-community

    Add or tighten Draw Things LoRA trainer support for generative models available in the Draw Things app / CLI, covering LoRA builders, trainer dispatch, tokenizer and fixed-encoder wiring, checkpoint…

    579 GitHub stars~2.6k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Init GPU Server

What does Init GPU Server do?

Initialize a Draw Things GPU server with GPUScript, including script sync, Docker/CUDA/NVIDIA runtime setup, 7T data disk mounting, mergerfs, and end-to-end GPU verification. Init GPU Server is an agent skill from drawthingsai/draw-things-community. Initialize a Draw Things GPU server with GPUScript, including script sync, Docker/CUDA/NVIDIA runtime setup, 7T data disk mounting, mergerfs, and end-to-end GPU verification.

When should I use Init GPU Server?

Init GPU Server fits situations like: tasks that involve Containers.

How do I install Init GPU Server in Claude Code?

Run `npx skills add drawthingsai/draw-things-community --skill init-gpu-server -a claude-code`. Or copy the skill folder (.agents/skills/init-gpu-server in drawthingsai/draw-things-community) into .claude/skills/init-gpu-server in your project. Claude Code loads it when a task matches its description.

How do I install Init GPU Server in Codex?

Run `npx skills add drawthingsai/draw-things-community --skill init-gpu-server -a codex`. Or copy the skill folder (.agents/skills/init-gpu-server in drawthingsai/draw-things-community) into .agents/skills/init-gpu-server in your project. Codex loads it when a task matches its description.

Can I use Init GPU Server in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add drawthingsai/draw-things-community --skill init-gpu-server -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/init-gpu-server, .gemini/skills/init-gpu-server, .github/skills/init-gpu-server and .opencode/skills/init-gpu-server in your project.

What does Init GPU Server need to run?

Going by SKILL.md and its folder, Init GPU Server needs the command-line tools its instructions call (ssh, bash, apt-get and docker). Our summary lists: Python 3; Docker.

Does Init GPU Server access the network?

SKILL.md contains no URLs. Its commands use ssh and docker, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Init GPU Server safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Init GPU Server use?

Init GPU Server is published under the GPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Init GPU Server use?

About 2.2k tokens (SKILL.md is roughly 8.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Init GPU Server?

Skills that share tags, products or a category with Init GPU Server: Kermt Setup (NVIDIA/skills, 3.5k stars), Tao Setup Nvidia GPU Host (NVIDIA/skills, 3.5k stars), Holoscan Install Container (NVIDIA/skills, 3.5k stars) and Cuopt Install (NVIDIA/skills, 3.5k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Init GPU Server?

drawthingsai (a GitHub organization) maintains it in drawthingsai/draw-things-community, which has 579 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on October 6, 2026.

Source: drawthingsai/draw-things-community on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.