← Guías y plantillas

Estudio de imágenes con IA en local (ComfyUI)

Guía · IA de imágenesActualizada el
  • IA
  • ComfyUI
  • Imágenes
  • Local
  • Stable Diffusion
🖥️ Ver como presentación

Monta en tu propio ordenador un estudio completo de imágenes con IA —texto→imagen, edición por instrucciones, inpainting, personajes consistentes— usando ComfyUI y modelos abiertos. Todo local, gratis y sin límites de uso.

Esta guía está optimizada para GPUs modestas: el entorno de referencia corre en una RTX 3050 Laptop de 4 GB de VRAM con 16 GB de RAM. Elegimos modelos cuantizados (GGUF) y versiones "turbo" precisamente para que quepan ahí. Si tienes más VRAM, todo irá aún más rápido.

⚡ Atajo: si solo quieres borrar objetos de una foto, ve directo a la sección IOPaint al final. Para todo lo demás, ComfyUI.

Qué vas a montar

Herramienta Para qué sirve Cómo se arranca URL local
ComfyUI Texto→imagen, edición por texto, inpainting, personaje consistente, música ./start-comfyui.sh http://127.0.0.1:8188
IOPaint (LaMa) Borrar objetos pintando encima (1 clic, sin prompts) ./start-iopaint.sh http://127.0.0.1:8080

Los 8 flujos (workflows) que construiremos

# Workflow Qué hace Modelo Velocidad (RTX 3050 4 GB)
1 Texto→imagen rápido Iteración veloz a 512–768 px DreamShaper 8 (SD 1.5) ~10–20 s
2 Texto→imagen calidad 1024 px en solo 7 pasos DreamShaper XL Turbo v2 (SDXL) ~40–90 s
3 Inpainting Rellenar/quitar zonas enmascaradas DreamShaper 8 Inpainting ~15–25 s
4 Editar con texto "cambia el cielo a atardecer" FLUX.1 Kontext dev (GGUF Q4) 3–8 min (offload a RAM)
7 Personaje consistente Mismo personaje en otra escena IP-Adapter Plus (SD 1.5) ~10 s
8 Personaje consistente HQ Igual, con más calidad IP-Adapter Plus (SDXL) ~35 s
9 Z-Image Turbo Manos y texto dentro de la imagen fiables Z-Image Turbo (GGUF Q4) ~45–50 s
10 Música de fondo Pista instrumental desde tags ACE-Step v1 (3.5B) ~35 s/min

Requisitos previos

  • GPU NVIDIA con drivers CUDA al día (nvidia-smi debe funcionar). Con 4 GB vas sobrado para esta guía; con menos, quédate en los workflows SD 1.5.
  • Python 3.10–3.12 (el entorno de referencia usa 3.12) y git.
  • ~40–60 GB de disco para todos los modelos. Puedes bajar solo los que uses.
  • Sistema Linux, Windows o macOS. Los comandos son de Linux/macOS; en Windows usa python en vez de python3 y activa el venv con venv\\Scripts\\activate.

Paso 1 · Instalar ComfyUI

Clona el repositorio, crea un entorno virtual e instala PyTorch con CUDA y las dependencias:

# 1. Clonar
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# 2. Entorno virtual aislado
python3 -m venv venv
source venv/bin/activate        # Windows: venv\Scripts\activate

# 3. PyTorch con CUDA (elige el índice de tu versión de CUDA en pytorch.org)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# 4. Dependencias de ComfyUI
pip install -r requirements.txt

De momento no lo arranques: primero instalamos los nodos y los modelos.

Paso 2 · Instalar los nodos personalizados

Tres flujos usan nodos que no vienen de serie. Se instalan clonándolos dentro de custom_nodes/:

cd custom_nodes

# Gestor de nodos y modelos (imprescindible; hace fácil todo lo demás)
git clone https://github.com/ltdrdata/ComfyUI-Manager.git

# Cargar modelos cuantizados .gguf (workflows 4 y 9)
git clone https://github.com/city96/ComfyUI-GGUF.git

# Personaje consistente por IP-Adapter (workflows 7 y 8)
git clone https://github.com/cubiq/ComfyUI_IPAdapter_plus.git

cd ..
pip install gguf          # dependencia del nodo GGUF

Con ComfyUI-Manager instalado, a partir de aquí podrás instalar cualquier otro nodo o modelo desde la propia interfaz (botón Manager), sin volver a la terminal. Si algún día abres un flujo y ves nodos en rojo (faltan), pulsa Manager → Install Missing Custom Nodes.

Paso 3 · Descargar los modelos (en detalle)

Esta es la parte que más gente atasca. Dos reglas de oro:

  1. Cada tipo de modelo va en su subcarpeta dentro de ComfyUI/models/.
  2. El nombre del archivo importa: los flujos referencian el modelo por su nombre, así que si lo renombras, tendrás que seleccionarlo de nuevo en el nodo.

3.1 · Cómo se organizan las carpetas

Carpeta Qué guarda
models/checkpoints/ Modelos "todo en uno" SD 1.5 / SDXL (DreamShaper, ACE-Step)
models/unet/ Difusores sueltos en GGUF (FLUX Kontext, Z-Image)
models/clip/ Codificadores de texto de FLUX (T5-XXL, CLIP-L)
models/text_encoders/ Codificador de texto de Z-Image (Qwen3-4B)
models/vae/ VAEs sueltos (FLUX, Z-Image)
models/clip_vision/ Codificador de imagen para IP-Adapter (CLIP-ViT-H)
models/ipadapter/ Adaptadores IP-Adapter (personaje consistente)

3.2 · Método A — el Model Manager (el más fácil) 🟢

  1. Termina de instalar (Paso 4) y arranca ComfyUI.
  2. Pulsa el botón Manager (esquina) → Model Manager (o Install Models).
  3. En el buscador, escribe el nombre del modelo (p. ej. DreamShaper, Z-Image, ACE-Step, IP-Adapter), pulsa Install y lo descarga a la carpeta correcta automáticamente.
  4. Cuando termine, pulsa Refresh (o reinicia ComfyUI) para que aparezca en los nodos.

Es la vía recomendada para todos los modelos, y la única cómoda para Z-Image y ACE-Step. Usa la tabla del método B solo para verificar dónde debe caer cada archivo.

3.3 · Método B — descarga manual con wget 🔧

Si prefieres la terminal (o el Manager no encuentra alguno), aquí están las fuentes fiables. Descarga solo lo de los flujos que vayas a usar.

Encoders y VAE para FLUX Kontext (workflow 4):

cd ComfyUI/models

wget -P clip/ https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget -P clip/ https://huggingface.co/city96/t5-v1_1-xxl-encoder-gguf/resolve/main/t5-v1_1-xxl-encoder-Q5_K_M.gguf
wget -P unet/ https://huggingface.co/QuantStack/FLUX.1-Kontext-dev-GGUF/resolve/main/flux1-kontext-dev-Q4_K_S.gguf
# VAE de FLUX (ae.safetensors): el repo oficial pide aceptar licencia.
#   https://huggingface.co/black-forest-labs/FLUX.1-dev  ->  ae.safetensors  ->  models/vae/
# Más fácil: instálalo desde el Model Manager (busca "FLUX VAE" o "ae.safetensors").

IP-Adapter — personaje consistente (workflows 7 y 8):

cd ComfyUI/models

# Adaptadores (van en models/ipadapter/)
wget -P ipadapter/ https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter-plus_sd15.safetensors
wget -P ipadapter/ https://huggingface.co/h94/IP-Adapter/resolve/main/models/ip-adapter-plus-face_sd15.safetensors
wget -P ipadapter/ https://huggingface.co/h94/IP-Adapter/resolve/main/sdxl_models/ip-adapter-plus_sdxl_vit-h.safetensors
wget -P ipadapter/ https://huggingface.co/h94/IP-Adapter/resolve/main/sdxl_models/ip-adapter-plus-face_sdxl_vit-h.safetensors

# Codificador de imagen CLIP-ViT-H (en clip_vision/, renombrado al nombre que espera el loader)
wget -O clip_vision/CLIP-ViT-H-14-laion2B-s32B-b79K.safetensors \
  https://huggingface.co/h94/IP-Adapter/resolve/main/models/image_encoder/model.safetensors

Checkpoints DreamShaper (workflows 1, 2, 3, 7, 8): están en civitai.com (autor Lykon). Busca cada uno, descarga la variante en .safetensors y déjalo en models/checkpoints/ con exactamente este nombre:

Busca en Civitai Guarda como Carpeta
DreamShaper 8 (versión pruned) DreamShaper_8_pruned.safetensors models/checkpoints/
DreamShaper XL (versión Turbo v2) DreamShaperXL_Turbo_v2.safetensors models/checkpoints/
DreamShaper 8 (versión Inpainting) DreamShaper_8_INPAINTING.inpainting.safetensors models/checkpoints/

Z-Image Turbo (workflow 9) y ACE-Step (workflow 10): más cómodo desde el Model Manager (busca "Z-Image" y "ACE-Step"). Descarga estos archivos a:

Archivo Carpeta
z-image-turbo-Q4_K_M.gguf models/unet/
qwen_3_4b_fp4_mixed.safetensors models/text_encoders/
z_image_ae.safetensors models/vae/
ace_step_v1_3.5b.safetensors models/checkpoints/

🔻 Los modelos son grandes (SD 1.5 ~2 GB, SDXL ~6 GB, los GGUF Q4 varios GB). Empieza por los workflows 1–3 (los más ligeros) y ya irás sumando el resto.

Paso 4 · Arrancar ComfyUI

En 4 GB de VRAM la clave es el flag --lowvram, que descarga capas a la RAM según hace falta. Crea un script start-comfyui.sh para no teclearlo cada vez:

#!/usr/bin/env bash
# Arranca ComfyUI optimizado para GPUs de poca VRAM (4 GB)
cd "$(dirname "$0")/ComfyUI"
exec ./venv/bin/python main.py --lowvram --preview-method auto "$@"

chmod +x start-comfyui.sh
./start-comfyui.sh          # luego abre http://127.0.0.1:8188

Cómo se construye un flujo en ComfyUI

Un "flujo" (workflow) es un grafo de nodos: cada nodo hace una cosa (cargar el modelo, codificar el texto, muestrear, decodificar…) y los conectas en cadena. Lo básico que necesitas saber:

  • Añadir un nodo: doble clic en el lienzo vacío → escribe el nombre en el buscador → Enter. (También: clic derecho → Add Node.)
  • Conectar: arrastra desde el punto de salida (derecha de un nodo) hasta el punto de entrada (izquierda de otro). Solo encajan puntos del mismo color/tipo.
  • Valores: los campos numéricos y de texto se editan directamente sobre el nodo.
  • Ejecutar: pulsa Queue o Ctrl+Enter. Las imágenes salen en ComfyUI/output/.

Los colores de los conectores (te guían para no equivocarte):

Color Tipo Qué transporta
🟪 Morado MODEL El modelo de difusión
🟨 Amarillo CLIP El codificador de texto
🟧 Naranja CONDITIONING El prompt ya codificado
🟥 Rojo VAE Conversor latente ↔ píxeles
🩷 Rosa LATENT La imagen en espacio latente
🟦 Azul IMAGE La imagen en píxeles

💡 Todos los flujos de imagen siguen el mismo esqueleto: cargar modelo → codificar prompt (+ y −) → KSampler → VAE Decode → Save Image. Una vez montas el nº 1, los demás son variaciones. Los prompts van en inglés.

Paso 5 · Construir cada flujo, paso a paso

Flujo 1 · Texto → imagen rápido (SD 1.5)

El esqueleto base. 7 nodos:

  1. Load Checkpoint — en ckpt_name elige DreamShaper_8_pruned.safetensors.
  2. CLIP Text Encode (Prompt) — el positivo. Ej.: a cozy wooden cabin in a snowy forest at golden hour, warm light in the windows, highly detailed, masterpiece, best quality.
  3. CLIP Text Encode (Prompt) — el negativo. Ej.: blurry, low quality, watermark, text, deformed, ugly, bad anatomy.
  4. Empty Latent Image — width 512, height 768, batch_size 1.
  5. KSampler.
  6. VAE Decode.
  7. Save Image — filename_prefix: sd15.

Conexiones:

  • Load Checkpoint MODEL → KSampler model
  • Load Checkpoint CLIP → los dos CLIP Text Encode clip
  • Load Checkpoint VAE → VAE Decode vae
  • CLIP Text Encode positivo → KSampler positive
  • CLIP Text Encode negativo → KSampler negative
  • Empty Latent Image → KSampler latent_image
  • KSampler LATENT → VAE Decode samples
  • VAE Decode IMAGE → Save Image images

Valores del KSampler: seed 42, steps 25, cfg 7.0, sampler_name dpmpp_2m, scheduler karras, denoise 1.0. Pulsa Queue y en ~15 s tienes tu imagen.

Flujo 2 · Texto → imagen calidad (SDXL Turbo)

Idéntico al flujo 1, cambiando solo 3 cosas:

  • Load Checkpoint → DreamShaperXL_Turbo_v2.safetensors.
  • Empty Latent Image → 1024 × 1024.
  • KSampler → steps 7, cfg 2.0, sampler_name dpmpp_sde, scheduler karras.

Los modelos Turbo dan calidad con pocos pasos y cfg bajo: no subas esos valores.

Flujo 3 · Quitar/reemplazar objetos (inpainting)

Aquí pintas una máscara sobre la zona a rehacer. 8 nodos:

  1. Load Checkpoint — DreamShaper_8_INPAINTING.inpainting.safetensors.
  2. Load Image — sube tu foto. Luego clic derecho → Open in MaskEditor, pinta la zona a eliminar y Save.
  3. VAE Encode (for Inpainting) — grow_mask_by 16.
  4. CLIP Text Encode positivo — qué debe aparecer, ej.: empty background, seamless, natural continuation of the scene (para borrar sin más).
  5. CLIP Text Encode negativo — ej.: object, person, watermark, text, blurry, low quality.
  6. KSampler — seed 42, steps 25, cfg 7.0, dpmpp_2m, karras.
  7. VAE Decode.
  8. Save Image — prefix inpaint.

Conexiones nuevas frente al flujo 1:

  • Load Image IMAGE → VAE Encode (for Inpainting) pixels
  • Load Image MASK → VAE Encode (for Inpainting) mask
  • Load Checkpoint VAE → VAE Encode (for Inpainting) vae
  • VAE Encode (for Inpainting) LATENT → KSampler latent_image

El resto (MODEL, CLIP, positive/negative, decode, save) igual que el flujo 1.

Flujo 4 · Editar imágenes con texto (FLUX Kontext) 🧠

El más potente y el más lento. Usa nodos GGUF (Paso 2). 13 nodos:

  1. Unet Loader (GGUF) — flux1-kontext-dev-Q4_K_S.gguf.
  2. DualCLIPLoader (GGUF) — clip_name1: t5-v1_1-xxl-encoder-Q5_K_M.gguf, clip_name2: clip_l.safetensors, type: flux.
  3. Load VAE — ae.safetensors.
  4. Load Image — la foto a editar.
  5. FluxKontextImageScale — reescala la imagen a una resolución que el modelo admite.
  6. VAE Encode — pasa la imagen a latente.
  7. CLIP Text Encode — la instrucción en inglés, ej.: change the sky to a dramatic orange sunset, keep everything else identical.
  8. ReferenceLatent — inyecta la imagen original como referencia.
  9. FluxGuidance — guidance 2.5 (sube a 3.0 para que obedezca más).
  10. ConditioningZeroOut — genera el "negativo vacío" que FLUX necesita.
  11. KSampler — seed 42, steps 20, cfg 1.0, euler, simple.
  12. VAE Decode.
  13. Save Image — prefix kontext.

Conexiones (sigue el hilo):

  • Unet Loader → KSampler model
  • DualCLIPLoader → CLIP Text Encode clip
  • Load Image → FluxKontextImageScale → VAE Encode pixels; Load VAE → VAE Encode vae
  • CLIP Text Encode → ReferenceLatent conditioning; VAE Encode LATENT → ReferenceLatent latent
  • ReferenceLatent → FluxGuidance → KSampler positive
  • CLIP Text Encode → ConditioningZeroOut → KSampler negative
  • VAE Encode LATENT → KSampler latent_image
  • KSampler → VAE Decode (con Load VAE) → Save Image

⏳ En 4 GB no cabe (12B parámetros): corre con offload a RAM → 3–8 min por edición. Añade "keep everything else identical" para preservar el resto de la imagen.

Flujo 7 · Personaje consistente (IP-Adapter)

Mantiene cara, pelo y ropa de un personaje en escenas nuevas. Usa el nodo IPAdapter_plus (Paso 2). 10 nodos:

Imagen de referencia del personaje

  1. Load Checkpoint — DreamShaper_8_pruned.safetensors.
  2. Load Image — la imagen maestra del personaje (frontal y limpia, mejor).
  3. IPAdapter Unified Loader — preset: PLUS (high strength).
  4. IPAdapter — weight 0.65, start_at 0.0, end_at 0.8, weight_type standard.
  5. CLIP Text Encode positivo — la nueva escena (no re-describas al personaje), ej.: young woman sitting at a table in a busy cozy cafe, holding a coffee cup, bokeh background with warm lights, photorealistic, detailed face, best quality.
  6. CLIP Text Encode negativo — blurry, low quality, watermark, text, deformed, ugly, bad anatomy.
  7. Empty Latent Image — 512 × 768.
  8. KSampler — seed 99, steps 28, cfg 6.5, dpmpp_2m, karras.
  9. VAE Decode.
  10. Save Image — prefix personaje.

La cadena clave del IP-Adapter:

  • Load Checkpoint MODEL → IPAdapter Unified Loader model
  • IPAdapter Unified Loader MODEL y IPADAPTER → nodo IPAdapter (entradas model e ipadapter)
  • Load Image → IPAdapter image
  • IPAdapter MODEL → KSampler model ← el modelo "cargado" con el personaje

El resto (CLIP, prompts, latente, decode, save) es el esqueleto del flujo 1.

El mismo personaje en una escena nueva

Ajustes útiles del nodo IPAdapter:

  • weight (0.65): subir = más fiel al personaje pero la escena pierde fuerza. Rango 0.5–0.9.
  • end_at (0.8): baja este valor para dar más libertad de pose/escena.
  • Para clavar solo la cara (cambiando ropa), pon el preset PLUS FACE (portraits).
  • Si se cuela el fondo de la referencia, súbele start_at a 0.15–0.2.

Flujo 8 · Personaje consistente en alta calidad (SDXL)

Igual que el flujo 7, cambiando:

  • Load Checkpoint → DreamShaperXL_Turbo_v2.safetensors.
  • Empty Latent Image → 896 × 1152.
  • IPAdapter → weight 0.7.
  • KSampler → steps 8, cfg 2.0, dpmpp_sde, karras.

El Unified Loader detecta que es SDXL y usa los adaptadores ...sdxl_vit-h automáticamente (por eso descargamos las 4 variantes).

Flujo 9 · Z-Image Turbo — manos y texto fiables

Modelo DiT de 2025 con encoder LLM. Usa GGUF. 10 nodos:

Z-Image renderiza texto legible dentro de la imagen

  1. Unet Loader (GGUF) — z-image-turbo-Q4_K_M.gguf.
  2. Load CLIP — clip_name: qwen_3_4b_fp4_mixed.safetensors, type: lumina2.
  3. Load VAE — z_image_ae.safetensors.
  4. ModelSamplingAuraFlow — shift 3.0.
  5. CLIP Text Encode — el prompt (¡largo y descriptivo funciona!). Para texto dentro de la imagen, ponlo entre comillas: … holding a wooden sign. The sign says "Pan Casero" …. ⚠️ Sin tildes en el texto literal ("Recien", no "Recién").
  6. ConditioningZeroOut — el negativo (no se usa: cfg 1.0).
  7. Empty SD3 Latent Image — 1024 × 1024.
  8. KSampler — seed 42, steps 8, cfg 1.0, sampler_name res_multistep, scheduler simple.
  9. VAE Decode.
  10. Save Image — prefix zimage.

Conexiones:

  • Unet Loader → ModelSamplingAuraFlow → KSampler model
  • Load CLIP → CLIP Text Encode
  • CLIP Text Encode → KSampler positive y → ConditioningZeroOut → KSampler negative
  • Empty SD3 Latent Image → KSampler latent_image
  • KSampler → VAE Decode (con Load VAE) → Save Image

Son parámetros de modelo turbo: no subas pasos ni cfg. Consume ~9 GB de RAM en offload; usa Free model and node cache del Manager entre sesiones si aprieta.

Flujo 10 · Música de fondo (ACE-Step)

Genera audio en vez de imagen. 8 nodos:

  1. Load Checkpoint — ace_step_v1_3.5b.safetensors.
  2. TextEncodeAceStepAudio — en tags describe el estilo en inglés (género, instrumentos, BPM, mood), ej.: ambient, calm, cinematic, soft piano, warm pads, instrumental, background music, 80 BPM. En lyrics pon [inst] para instrumental.
  3. ConditioningZeroOut — el negativo.
  4. EmptyAceStepLatentAudio — seconds 60 (la duración).
  5. ModelSamplingSD3 — shift 5.0.
  6. KSampler — seed 42, steps 27, cfg 5.0, euler, simple.
  7. VAE Decode (Audio).
  8. Save Audio (MP3) — quality V0, prefix musica.

Conexiones:

  • Load Checkpoint MODEL → ModelSamplingSD3 → KSampler model
  • Load Checkpoint CLIP → TextEncodeAceStepAudio
  • TextEncodeAceStepAudio → KSampler positive y → ConditioningZeroOut → KSampler negative
  • EmptyAceStepLatentAudio → KSampler latent_image
  • Load Checkpoint VAE → VAE Decode (Audio) → Save Audio (MP3)

El MP3 sale en ComfyUI/output/. Cada seed da una pieza distinta; 60 s tardan ~35 s.

💾 Guarda tus flujos. Cuando tengas uno montado, Workflow → Save para exportarlo a .json y volver a cargarlo con Workflow → Open sin reconstruirlo.

Extra · Borrar objetos en 1 clic (IOPaint)

Para eliminar objetos de una foto sin prompts ni configuración, ComfyUI es exagerado. IOPaint con el modelo LaMa lo hace pintando encima, al instante:

# Instalación (en su propio entorno virtual)
python3 -m venv iopaint-venv
./iopaint-venv/bin/pip install iopaint

# Arranque
./iopaint-venv/bin/iopaint start --model=lama --device=cuda --port=8080
# Abre http://127.0.0.1:8080

Arrastra tu foto, pinta sobre el objeto con el pincel y desaparece al momento. La primera vez descarga LaMa (~200 MB). Sin GPU, cambia --device=cuda por --device=cpu.

Referencia · De los flujos a un producto: Shorts de YouTube con Claude Code

Los flujos por sí solos generan piezas sueltas (una imagen, una pista de música). El siguiente paso es encadenarlos en un producto terminado. Como referencia real, este es un pipeline que convierte un guion en un Short de YouTube completo (vídeo 1080×1920 + miniatura + metadatos), usando Claude Code en dos papeles:

Short generado por el propio pipeline

  • 🖊️ Claude Code como escritor: redacta el guion en JSON — título, descripción y tags para YouTube, y por cada escena el texto de la narración, el subtítulo y el prompt de imagen (en inglés, cinematográfico).
  • 🎛️ Claude Code como orquestador: ejecuta un script (orquestador.py) que llama a los flujos de esta guía por fases (para no recargar modelos en ComfyUI a cada paso):
Fase Herramienta Reutiliza el flujo…
1. Voz por escena Piper TTS (CPU) (voz, sección IOPaint/Piper)
2. Imagen 9:16 por escena + miniatura Z-Image Turbo vía API de ComfyUI Flujo 9
3. Música de fondo ACE-Step Flujo 10
4. Montaje final Remotion (React) → MP4 + metadata.json —

La clave es que ComfyUI expone una API HTTP (POST /prompt): el orquestador manda el mismo JSON de flujo que cargarías a mano y recoge el archivo de salida. Así, los flujos 9 y 10 que montaste antes se vuelven llamadas programáticas.

El guion que escribe Claude Code (estructura, recortado):

{
  "id": "01-god-sees-your-kindness",
  "titulo": "Kindness is never wasted – God sees every good deed 🙏",
  "descripcion": "Every act of kindness matters... #shorts #faith",
  "tags": ["faith", "kindness", "bible verse", "motivation"],
  "voz": "en_US-ryan-high",
  "musica_tags": "ambient, hopeful, cinematic, soft piano, 75 BPM",
  "escenas": [
    {
      "texto": "Nobody saw what you did for that stranger. But Heaven did.",
      "subtitulo": "Nobody saw... but Heaven did 👀",
      "prompt": "cinematic vertical shot, a person helping an elderly stranger on a rainy street, warm golden light, photorealistic"
    }
  ],
  "thumbnail_prompt": "dramatic vertical composition, warm light rays, bold white text overlay says \"GOD SEES YOU\""
}

El flujo de trabajo completo, de principio a fin:

  1. Le pides a Claude Code el tema del Short → escribe el guion.json.
  2. python3 orquestador.py guiones/*.json → genera voces, imágenes y música con ComfyUI.
  3. Libera la RAM de ComfyUI y Remotion monta todo (imágenes + voz + subtítulos + música).
  4. Sale shorts/<id>/ con video.mp4, thumbnail.png y metadata.json listos para subir.

🧩 Es el caso de uso que une toda la guía: Claude Code dirige, los flujos de ComfyUI producen los assets y Remotion los ensambla. El mismo patrón (guion → assets → montaje) sirve para trailers, explicativos o vídeos de producto.

Solución de problemas

  • OOM (out of memory / CUDA out of memory): baja la resolución (SD 1.5 → 512 px, SDXL → 896 px) o cierra apps que usen la GPU. nvidia-smi te dice quién consume VRAM. No abras juegos ni vídeo en Chrome mientras generas.
  • Va lentísimo en FLUX/Z-Image: es normal — no caben en 4 GB y se ejecutan con offload a RAM. Es el precio de correr modelos de 12B/6B en una GPU pequeña.
  • El nodo no encuentra el modelo (desplegable vacío): el archivo no está en la carpeta correcta o se llama distinto. Revisa el Paso 3 y pulsa Refresh en la UI.
  • Nodo en rojo / "undefined": falta el custom node → Manager → Install Missing Custom Nodes y reinicia.
  • Las dos apps a la vez: ComfyUI e IOPaint pueden estar arrancadas simultáneamente, pero no generes en ambas al mismo tiempo (comparten los 4 GB de VRAM).

Añadir más modelos

  • Descarga checkpoints de civitai.com a models/checkpoints/. En 4 GB, quédate en versiones SD 1.5 o SDXL — los Flux/SD3 completos (sin cuantizar) no caben.
  • O usa Manager → Model Manager para instalar modelos, LoRAs y ControlNets con un clic.

Guía basada en el entorno de referencia testing/modelos de Fragua Tech. Ajusta los tiempos a tu GPU: con más VRAM todo va bastante más rápido.