ComfyUI: Workflow Berbasis Node untuk Stable Diffusion

ComfyUI adalah lingkungan grafis berbasis node untuk menjalankan Stable Diffusion dan model difusi terkait. Alih-alih menyembunyikan pipeline generasi di balik satu tombol "Generate", ComfyUI menampilkan setiap langkah sebagai node yang bisa Anda sambungkan, periksa, dan gunakan ulang. Tutorial ini menjelaskan cara kerja graf-nya, cara membangun workflow umum, dan cara mengendalikan ComfyUI secara programatik melalui HTTP API miliknya.

Daftar Isi

Apa Itu ComfyUI dan Mengapa Graf Membantu

Pipeline generasi gambar difusi adalah rangkaian operasi yang berbeda-beda: memuat model, meng-encode prompt teks, menyiapkan latent kosong, menjalankan loop sampling, men-decode latent kembali menjadi piksel, lalu menyimpan hasilnya. Sebagian besar alat membungkus semua ini menjadi sebuah form berisi slider. ComfyUI sebaliknya merepresentasikan tiap operasi sebagai node, dan Anda menyambungkan output sebuah node ke input node berikutnya.

Desain ini memiliki keunggulan praktis dibanding UI berbasis form seperti Automatic1111:

• Transparansi. Anda bisa melihat persis model mana, conditioning mana, dan sampler mana yang menghasilkan sebuah gambar. Tidak ada nilai default tersembunyi yang diterapkan di belakang layar.
• Reprodusibilitas. Graf itu sendiri adalah resepnya. Membagikan JSON workflow berarti membagikan pipeline lengkap yang siap dijalankan, bukan sekadar tangkapan layar pengaturan yang harus diketik ulang orang lain.
• Pipeline kompleks. Alur multi-tahap, misalnya pass dasar diikuti refiner lalu upscale, sulit diekspresikan dengan satu form. Dalam graf, semua itu hanya berupa node tambahan yang dirangkai berurutan.
• Caching. ComfyUI menyimpan output setiap node. Jika Anda hanya mengubah seed, ComfyUI menjalankan ulang sampler tetapi memakai kembali model yang sudah dimuat dan prompt yang sudah di-encode, sehingga iterasi terasa cepat.

Automatic1111 ramah untuk generasi gambar tunggal yang cepat dan punya ekosistem ekstensi yang besar. ComfyUI menukar sebagian kemudahan itu demi kontrol, dan lebih cocok ketika pipeline sama pentingnya dengan output, atau ketika Anda berniat mengotomatiskannya.

Instalasi

ComfyUI berjalan di Windows, Linux, dan macOS. Anda memerlukan Python 3.10 atau lebih baru dan, untuk kecepatan yang wajar, GPU NVIDIA dengan minimal 6 GB VRAM untuk SD1.5 atau 10 GB untuk SDXL. Mode CPU-only bisa berjalan, tetapi lambat.

Instalasi manual dengan git

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

Buat environment terisolasi
python -m venv venv
source venv/bin/activate        # Di Windows: venv\Scripts\activate

Pasang PyTorch yang sesuai dengan versi CUDA Anda terlebih dahulu
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

Lalu sisa dependensinya
pip install -r requirements.txt

Jalankan server-nya:

python main.py

Secara default, antarmuka web disajikan di http://127.0.0.1:8188. Beberapa flag yang berguna antara lain --listen 0.0.0.0 untuk membukanya ke jaringan, --port 8000 untuk mengganti port, serta --lowvram atau --cpu untuk perangkat keras terbatas.

Portable build (Windows)

Bagi pengguna Windows yang tidak ingin mengelola Python, proyek ini menyediakan arsip portable berisi Python tertanam beserta semua dependensinya. Unduh dari halaman rilis, ekstrak, lalu jalankan dengan runnvidiagpu.bat atau runcpu.bat. Ini adalah cara dengan hambatan paling kecil untuk memulai.

ComfyUI/
  models/
    checkpoints/      # Checkpoint penuh SD1.5 / SDXL (.safetensors, .ckpt)
    loras/            # Berkas LoRA
    vae/              # Bobot VAE mandiri
    controlnet/       # Model ControlNet
    upscalemodels/   # ESRGAN dan upscaler sejenis
    clipvision/      # Encoder CLIP vision

Positif: foto seekor rubah merah di hutan bersalju, cahaya pagi lembut, fokus tajam
Negatif: buram, kualitas rendah, watermark, teks, bentuk cacat

• seed — noise awal acak. Seed yang sama dengan input identik akan mereproduksi gambar yang sama.
• steps — jumlah iterasi denoising. 20 hingga 30 adalah angka umum; lebih banyak step memakan waktu dengan hasil yang makin sedikit bertambah.
• cfg — skala classifier-free guidance. Nilai lebih tinggi mengikuti prompt lebih ketat. 6 hingga 8 adalah rentang wajar untuk SD1.5.
• samplername — algoritma sampling, misalnya euler, dpmpp2m, atau dpmpp2msde.
• scheduler — jadwal noise, misalnya normal, karras, atau exponential.
• denoise — seberapa banyak latent input ditimpa dengan konten baru. Untuk text-to-image nilai ini tetap 1.0.

denoise = 0.3   -> perubahan halus, mempertahankan komposisi dan sebagian besar detail
denoise = 0.6   -> reinterpretasi terlihat jelas, struktur terjaga
denoise = 0.9   -> hanya panduan longgar dari gambar asli

Load Checkpoint -> Load LoRA -> KSampler (MODEL)
Load Checkpoint -> Load LoRA -> CLIP Text Encode (CLIP)

Tiap node Load LoRA memiliki nilai strengthmodel dan strengthclip yang independen, biasanya antara 0.5 dan 1.0. Untuk menumpuk beberapa LoRA, rangkai beberapa node Load LoRA sehingga output yang dimodifikasi dari satu node menjadi input node berikutnya.

KSampler (pass 1) -> Upscale Latent -> KSampler (pass 2, denoise 0.5) -> VAE Decode

Node Upscale Image (using Model) menerapkan jaringan upscaling khusus seperti model ESRGAN 4x dari models/upscalemodels. Node ini bekerja pada gambar RGB hasil decode dan murni merupakan langkah super-resolution, tanpa difusi sama sekali. Ia cepat dan mempertajam detail halus, tetapi menciptakan lebih sedikit konten baru dibanding pass latent.

Pola berkualitas tinggi yang umum memakai keduanya: latent upscale dengan pass sampling kedua yang ringan untuk menambah detail yang koheren, diikuti model upscale untuk mencapai resolusi akhir.

ComfyUI Manager dan Custom Node

Sebagian besar kemampuan ComfyUI datang dari custom node komunitas. ComfyUI Manager adalah alat standar untuk menemukan dan memasangnya. Pasang dengan meng-clone ke direktori customnodes:

cd ComfyUI/customnodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git

Mulai ulang ComfyUI dan tombol "Manager" akan muncul di menu. Dari sana Anda bisa memasang paket custom node, memperbaruinya, dan memasang node yang hilang yang dirujuk oleh workflow yang Anda muat. Fitur "Install Missing Custom Nodes" sangat berguna ketika Anda membuka workflow milik orang lain dan beberapa node tampil merah karena paketnya belum ada.

Bersikaplah selektif dengan custom node. Setiap paket adalah kode pihak ketiga yang berjalan di environment Anda, dan paket yang kurang terawat bisa rusak saat ComfyUI diperbarui. Pasang hanya yang benar-benar dibutuhkan workflow dan jaga agar jumlahnya tetap sedikit.

Menyimpan dan Memuat Workflow

Sebuah workflow dapat diekspor ke berkas JSON dari menu. Ada dua format yang perlu Anda ketahui:

• Format editor (disimpan via Save) mempertahankan posisi node dan graf visual lengkap untuk dibuka kembali di UI.
• Format API (Save (API Format), yang memerlukan pengaktifan opsi developer di pengaturan) adalah representasi yang diratakan dengan kunci berupa ID node, ditujukan untuk HTTP API.

ComfyUI juga menanamkan workflow format editor langsung ke metadata setiap PNG yang disimpannya. Artinya Anda bisa menyeret PNG hasil generasi kembali ke kanvas dan graf persis yang menghasilkannya akan dipulihkan, sehingga gambar yang dibagikan menjadi terdokumentasi dengan sendirinya. Perlu diingat metadata ini akan hilang jika gambar di-encode ulang atau diproses alat yang membuang chunk teks PNG.

Mengendalikan ComfyUI dari HTTP API

ComfyUI menyediakan HTTP dan WebSocket API pada port yang sama dengan UI, sehingga mudah diintegrasikan ke dalam layanan backend. Alurnya adalah: muat workflow dalam format API, edit field yang Anda inginkan, POST ke /prompt, lalu tunggu penyelesaiannya melalui WebSocket dan ambil gambar hasilnya.

Pertama, ekspor graf Anda menggunakan Save (API Format). Hasilnya berupa dictionary dengan kunci ID node. Contoh di bawah mengasumsikan node 4 adalah Load Checkpoint, node 6 adalah CLIP Text Encode positif, dan node 3 adalah KSampler. Periksa JSON ekspor Anda sendiri untuk memastikan ID-nya.

import json
import uuid
import urllib.request
import urllib.parse
import websocket  # pip install websocket-client

SERVER = "127.0.0.1:8188"
CLIENTID = str(uuid.uuid4())



def loadworkflow(path):
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)


def queueprompt(workflow):

    """Mengirim workflow dan mengembalikan promptid."""
    payload = {"prompt": workflow, "clientid": CLIENTID}
    data = json.dumps(payload).encode("utf-8")
    req = urllib.request.Request(f"http://{SERVER}/prompt", data=data)
    req.addheader("Content-Type", "application/json")

    with urllib.request.urlopen(req) as resp:
        return json.load(resp)["promptid"]


def gethistory(promptid):
    url = f"http://{SERVER}/history/{promptid}"

    with urllib.request.urlopen(url) as resp:
        return json.load(resp)


def getimage(filename, subfolder, foldertype):

    params = urllib.parse.urlencode(
        {"filename": filename, "subfolder": subfolder, "type": foldertype}
    )
    with urllib.request.urlopen(f"http://{SERVER}/view?{params}") as resp:
        return resp.read()

Sekarang edit prompt dan seed, kirim, lalu tunggu sinyal executing di WebSocket yang menandai penyelesaian:

def waitforcompletion(promptid):
    """Memblokir sampai prompt yang diberikan selesai, memakai feed WebSocket."""
    ws = websocket.WebSocket()
    ws.connect(f"ws://{SERVER}/ws?clientId={CLIENTID}")
    try:
        while True:
            message = ws.recv()
            if isinstance(message, str):
                event = json.loads(message)
                if event["type"] == "executing":
                    data = event["data"]
                    # node bernilai None dan promptid cocok => prompt ini selesai

                    if data["node"] is None and data["promptid"] == promptid:

                        break
    finally:
        ws.close()


def run(workflowpath, positiveprompt, seed):

    workflow = loadworkflow(workflowpath)


    # Edit field-nya. ID node berasal dari JSON format API hasil ekspor Anda.
    workflow["6"]["inputs"]["text"] = positiveprompt
    workflow["3"]["inputs"]["seed"] = seed

    promptid = queueprompt(workflow)
    waitforcompletion(promptid)


    # Ambil nama berkas output dari history lalu unduh gambarnya.
    history = gethistory(promptid)[promptid]
    images = []
    for nodeoutput in history["outputs"].values():

        for image in nodeoutput.get("images", []):
            data = getimage(image["filename"], image["subfolder"], image["type"])

            images.append((image["filename"], data))
    return images


if name == "main":
    results = run(
        "workflowapi.json",
        positiveprompt="sebuah mercusuar di tebing saat senja, awan dramatis",

        seed=12345,
    )
    for filename, data in results:
        with open(filename, "wb") as f:
            f.write(data)
        print("Tersimpan", filename)

Jika Anda lebih suka polling daripada WebSocket, Anda bisa memanggil /history/{promptid} berulang kali dan menganggap prompt selesai begitu ID tersebut muncul di respons dengan outputs yang terisi. WebSocket lebih disarankan di produksi karena ia juga mengalirkan progres dan menghindari request yang tidak perlu. Format API yang diharapkan /prompt terlihat seperti ini untuk satu node:

{
  "3": {
    "classtype": "KSampler",

    "inputs": {
      "seed": 12345,
      "steps": 25,
      "cfg": 7.0,
      "samplername": "dpmpp2m",

      "scheduler": "karras",
      "denoise": 1.0,
      "model": ["4", 0],
      "positive": ["6", 0],
      "negative": ["7", 0],
      "latentimage": ["5", 0]
    }
  }
}

Setiap input berupa nilai literal atau array dua elemen [nodeid, outputindex] yang merepresentasikan kabel dari output node lain. Ini adalah model koneksi yang sama dengan yang Anda lihat secara visual di editor.

Catatan SDXL vs SD1.5

Kedua keluarga model ini berbeda dalam beberapa hal yang memengaruhi graf Anda:

• Resolusi native. SD1.5 dilatih pada 512x512; SDXL pada 1024x1024. Atur Empty Latent Image sesuai dengan itu. Meminta SD1.5 menghasilkan 1024x1024 secara langsung cenderung menghasilkan subjek yang terduplikasi.
• Text encoder. SDXL memakai dua encoder CLIP, sehingga node conditioning-nya (CLIP Text Encode SDXL) menampilkan field tambahan, dan pipeline SDXL penuh sering memasangkan model base dengan model refiner dalam pengaturan sampler dua tahap.
• VRAM. SDXL membutuhkan memori yang jauh lebih besar. Pada kartu 8 GB gunakan --lowvram atau andalkan node tiled VAE decode.
• Sampler dan CFG. SDXL umumnya bekerja baik pada CFG yang sedikit lebih rendah (sekitar 5 hingga 7) dibanding SD1.5.

Untuk mempelajari model node, SD1.5 lebih ringan dan lebih cepat untuk iterasi. Beralihlah ke SDXL ketika kualitas output menjadi prioritas dan perangkat keras Anda memungkinkan.

Praktik Terbaik dan Tips

• Beri nama dan kelompokkan node. Klik kanan untuk memberi judul node dan gunakan kotak grup untuk melabeli bagian seperti "base pass" atau "upscale." Graf yang berlabel jauh lebih mudah dikunjungi kembali berminggu-minggu kemudian.
• Gunakan node primitive dan reroute. Tampilkan nilai bersama seperti seed atau resolusi melalui node Primitive agar Anda mengubahnya di satu tempat. Node reroute menjaga kabel panjang tetap rapi.
• Versikan JSON workflow Anda. Simpan ekspor format API dan format editor dalam repositori git beserta catatan checkpoint apa yang mereka harapkan.
• Kunci seed saat beriterasi. Tetapkan seed ketika menyetel prompt atau CFG agar Anda membandingkan hal yang setara, lalu kembali ke acak saat bereksplorasi.
• Jaga direktori model tetap terorganisir. Gunakan nama berkas dan subfolder yang jelas; ComfyUI menampilkan apa pun yang ada, dan folder checkpoint yang berantakan akan memperlambat Anda.
• Pisahkan server dari kode klien Anda. Saat memakai API, jalankan ComfyUI sebagai layanan yang berumur panjang dan biarkan aplikasi Anda mengirim job. Ini memakai ulang model yang sudah dimuat lintas request dan menghindari biaya startup berulang.

Kesimpulan dan Poin Penting

ComfyUI memperlakukan generasi gambar sebagai graf yang eksplisit dan dapat diperiksa, bukan satu aksi tak transparan. Struktur itulah yang memberinya kekuatan utama: Anda bisa melihat dan mereproduksi persis bagaimana sebuah gambar dibuat, membangun pipeline multi-tahap yang akan merepotkan di UI berbasis form, dan mengotomatiskan keseluruhannya melalui HTTP API yang rapi.

Poin penting yang perlu dibawa ke depan:

• Graf text-to-image bawaan adalah fondasinya: Load Checkpoint, CLIP Text Encode, Empty Latent Image, KSampler, VAE Decode, Save Image.
• Semua terjadi di ruang latent hingga VAE Decode, itulah sebabnya latent upscaling dan refinement multi-pass tersusun dengan begitu alami.
• LoRA dan ControlNet ditambahkan dengan menyisipkan node ke dalam alur yang sudah ada, bukan dengan mengonfigurasi ulang.
• Workflow bersifat portabel sebagai JSON, dan ComfyUI menanamkannya di PNG yang disimpan untuk output yang terdokumentasi sendiri.
• Endpoint /prompt, /history, dan WebSocket memungkinkan Anda memuat workflow format API, mengedit prompt dan seed, mengirimnya, lalu mengambil gambar dari kode Anda sendiri.

Mulailah dari graf bawaan SD1.5, pelajari bagaimana kabel membawa MODEL, CONDITIONING, dan LATENT antar node, lalu berkembanglah dari situ ke LoRA, ControlNet, upscaling, dan akhirnya otomasi berbasis API.