ls-comfy-to-liteimage

name: ls-comfy-to-liteimage description: "Translate ComfyUI workflows into LiteImage API calls. Use when the user provides a ComfyUI workflow JSON, mentions ComfyUI, asks about node graphs, wants to convert or replicate a ComfyUI pipeline, or references ComfyUI templates. Also use when the user asks how to do something 'like in ComfyUI' or wants to run a workflow locally. Triggers on 'comfy', 'ComfyUI', 'comfyui', 'workflow JSON', 'node graph', 'convert this workflow', 'translate this workflow', 'run this workflow', 'I have a workflow', 'KSampler', 'LoraLoader', 'exported workflow', 'comfy template', 'what this comfy workflow does', 'equivalent in LiteImage', 'how do I do that here', 'make it work here'."

ComfyUI → LiteImage Workflow Translator

Translate ComfyUI workflow JSON into LiteImage REST API call sequences. ComfyUI uses a node graph where each node is a processing step. LiteImage collapses these into parameterized API calls — no nodes, no wiring, just endpoints.

Requirements: This skill requires LiteImage to be installed and running. All API calls target http://127.0.0.1:7426 (LiteImage's default port). Start LiteImage before running any generated commands.

How to Use This Skill

1. User provides a ComfyUI workflow (JSON file, pasted JSON, or describes a ComfyUI pipeline)
2. Parse the workflow to identify the intent (what nodes are present, how they connect)
3. Map each node/group to the equivalent LiteImage API call(s)
4. Output a ready-to-run sequence of curl commands (or describe the MCP tool calls)

Node → API Mapping Reference

Model Loading

Key insight: ComfyUI makes you wire model + VAE + CLIP + LoRA as separate nodes. LiteImage handles all of this automatically when you POST /load_model. The only thing you need to extract from loader nodes is the model filename and any LoRA names.

Text-to-Image Generation

Sampler name mapping:

Scheduler mapping:

Image-to-Image

Rule: If you see a LoadImage feeding into a KSampler (via VAEEncode or directly), it's img2img. The denoise parameter on KSampler = LiteImage's strength.

Inpainting

Rule: If you see a mask being loaded or created, it's inpaint. Extract the mask image path and pass as mask_path.

ControlNet

Rule: ControlNet in ComfyUI is a separate loader + apply node. In LiteImage, just add control_net_model, control_image_path, and control_strength to your /generate call. Note: ControlNet only works with SD1.5 and SDXL in LiteImage.

Upscaling

Video Generation (Wan 2.1 / LTX)

Video is async: POST /video/generate returns a job_id. Poll GET /video/status/{id} for progress.

Face Swap

Multi-Step Pipelines

Nodes With No LiteImage Equivalent

These ComfyUI nodes have no direct mapping — note them to the user:

Translation Process

When given a ComfyUI workflow JSON (API format), follow this process:

Step 1: Identify the workflow type

Read the nodes and classify:

• txt2img: Has EmptyLatentImage + KSampler + CLIPTextEncode, no LoadImage
• img2img: Has LoadImage feeding into KSampler (denoise < 1.0)
• inpaint: Has LoadImage for mask OR SetLatentNoiseMask
• controlnet: Has ControlNetLoader + ControlNetApply
• upscale: Has UpscaleModelLoader + ImageUpscaleWithModel
• video: Has Wan/LTX video nodes
• multi-step: Multiple KSamplers chained, or post-processing after generation

Step 2: Extract parameters

From the node inputs, extract:

• Model: checkpoint filename from CheckpointLoaderSimple.ckpt_name
• LoRAs: names from LoraLoader.lora_name — convert to <lora:name> prompt tags
• Prompt: text from CLIPTextEncode connected to positive conditioning
• Negative: text from CLIPTextEncode connected to negative conditioning
• Dimensions: EmptyLatentImage.width and .height (multiply by 8 if "latent" dimensions)
• Steps: KSampler.steps
• CFG: KSampler.cfg → guidance_scale
• Seed: KSampler.seed (or noise_seed)
• Sampler: KSampler.sampler_name → map using table above
• Scheduler: KSampler.scheduler → map using table above
• Denoise: KSampler.denoise → strength (for img2img)

Step 3: Generate API calls

Output a numbered sequence of curl commands. Example for a txt2img + upscale workflow:

# 1. Load the model
curl -X POST http://127.0.0.1:7426/load_model \
  -H "Content-Type: application/json" \
  -d '{"file_path": "C:/Models/dreamshaper_8.safetensors"}'

# 2. Generate the image
RESULT=$(curl -s -X POST http://127.0.0.1:7426/generate \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a majestic castle on a hill, fantasy art",
    "negative_prompt": "ugly, blurry",
    "width": 512, "height": 768,
    "steps": 25, "guidance_scale": 7.0,
    "seed": 42, "sampling_method": "dpm++2m", "scheduler": "karras"
  }')
IMAGE=$(echo $RESULT | jq -r '.imagePath')

# 3. Upscale the result
curl -X POST http://127.0.0.1:7426/upscale \
  -H "Content-Type: application/json" \
  -d "{\"image_path\": \"$IMAGE\", \"upscale_model\": \"C:/Models/RealESRGAN_x4plus.pth\"}"

Step 4: Handle unknowns

If the workflow contains nodes you can't map:

1. List the unmapped nodes and explain why
2. Suggest the closest LiteImage approximation
3. Note any quality differences the user should expect

Example Translations

ComfyUI: Simple txt2img with LoRA

{
  "3": {
    "class_type": "KSampler",
    "inputs": {
      "seed": 42,
      "steps": 20,
      "cfg": 7.5,
      "sampler_name": "euler_ancestral",
      "scheduler": "karras",
      "denoise": 1.0
    }
  },
  "4": {
    "class_type": "CheckpointLoaderSimple",
    "inputs": { "ckpt_name": "dreamshaper_8.safetensors" }
  },
  "5": {
    "class_type": "LoraLoader",
    "inputs": { "lora_name": "add_detail.safetensors", "strength_model": 0.8 }
  },
  "6": { "class_type": "CLIPTextEncode", "inputs": { "text": "a beautiful forest" } },
  "7": {
    "class_type": "EmptyLatentImage",
    "inputs": { "width": 512, "height": 768, "batch_size": 1 }
  }
}

LiteImage translation:

curl -X POST http://127.0.0.1:7426/load_model \
  -d '{"file_path": "C:/Models/dreamshaper_8.safetensors"}'

curl -X POST http://127.0.0.1:7426/generate \
  -d '{
    "prompt": "a beautiful forest <lora:add_detail:0.8>",
    "width": 512, "height": 768,
    "steps": 20, "guidance_scale": 7.5,
    "seed": 42, "sampling_method": "euler_a", "scheduler": "karras"
  }'

What changed: LoRA became a prompt tag <lora:name:weight>. VAE/CLIP nodes disappeared (automatic). KSampler params became /generate params.

ComfyUI: Image-to-Video (Wan 2.1)

{
  "1": { "class_type": "LoadImage", "inputs": { "image": "input.png" } },
  "2": { "class_type": "WanVideoModelLoader", "inputs": { "model": "wan2.1-i2v-14b" } },
  "3": { "class_type": "WanVideoSampler", "inputs": { "steps": 25, "cfg": 5.0, "seed": 42 } },
  "4": { "class_type": "VHS_VideoCombine", "inputs": { "fps": 15, "frame_count": 60 } }
}

LiteImage translation:

# Video generation is async — returns job_id
JOB=$(curl -s -X POST http://127.0.0.1:7426/video/generate \
  -d '{
    "prompt": "cinematic motion",
    "init_image_path": "C:/images/input.png",
    "steps": 25, "guidance_scale": 5.0, "seed": 42,
    "frames": 60, "fps": 15
  }' | jq -r '.job_id')

# Poll until done
while true; do
  STATUS=$(curl -s http://127.0.0.1:7426/video/status/$JOB)
  [ "$(echo $STATUS | jq -r '.status')" = "complete" ] && break
  sleep 5
done
echo "MP4: $(echo $STATUS | jq -r '.result.mp4Path')"

Model Path Resolution

ComfyUI uses short names like dreamshaper_8.safetensors. LiteImage needs full paths. To resolve:

1. Call GET /models to list all available models
2. Match the ComfyUI checkpoint name against displayName or filename in the path
3. If no match, call GET /loras for LoRA names
4. If still no match, tell the user: "Model 'X' not found. Available models: ..." and list them

# Find the model
MODELS=$(curl -s http://127.0.0.1:7426/models)
# Search for match
echo $MODELS | jq '.models[] | select(.displayName | test("dreamshaper"; "i"))'

ComfyUI Workflow Template Library

The official ComfyUI template library at Comfy-Org/workflow_templates on GitHub contains 250+ categorized workflow templates. Use this as a reference when the user describes what they want semantically (e.g., "I want to animate this image" or "make it look like a product ad").

How to search the library

Fetch the index to find matching templates by intent:

# Fetch the template index (cached for 15 min)
gh api repos/Comfy-Org/workflow_templates/contents/templates/index.json --jq '.content' | base64 -d > /tmp/comfy-templates.json

Then search by keyword against template names, titles, descriptions, and tags. For example, if the user says "I want to turn my photo into a video":

• Search for: image to video, i2v, animate
• Matches: video_wan2_2_14B_i2v, image_to_video_wan, ltxv_image_to_video, etc.

Fetch a specific workflow

# Download the actual workflow JSON
gh api repos/Comfy-Org/workflow_templates/contents/templates/<name>.json --jq '.content' | base64 -d > /tmp/workflow.json

Then parse it using the translation process below to generate LiteImage API calls.

Template categories

What's directly translatable to LiteImage

Templates in these categories map cleanly to LiteImage API calls:

• Image txt2img/img2img — All Flux, SDXL, SD1.5, SD3, Z-Image, Klein, Chroma templates
• Video — Wan 2.1/2.2 templates (T2V, I2V) via /video/generate
• Upscale — GAN upscaler, utility upscale templates via /upscale
• Inpaint — Flux Fill, inpaint templates via /generate with mask_path
• ControlNet — Canny, depth, pose templates via /generate with control_net_model

Templates that use API partner nodes (Kling, Runway, DALL-E, etc.) are cloud-only and can't run locally in LiteImage — note this to the user.

Notes

• LiteImage uses sd-cli.exe (stable-diffusion.cpp) — not ComfyUI's Python backend. Some nodes have no equivalent.
• ComfyUI's "API format" JSON (exported via Graph → Export as API) is what this skill reads. The "regular" format with node positions is also parseable but the API format is cleaner.
• LoRA weight syntax: <lora:name:weight> in the prompt string. Weight defaults to 1.0 if omitted.
• Video model must be configured separately (it's not the same as the loaded checkpoint). Use /video/readiness to check.
• Pipeline steps in LiteImage are fixed types: upscale, faceswap, inpaint, controlnet, save. For anything else, chain individual API calls.