ComfyUI: flujos por nodos, VRAM, automatización y despliegue local

Un grafo visible en lugar de una caja cerrada

En ComfyUI, un flujo enlaza nodos para cargar checkpoints, codificar texto, generar latentes, aplicar control, decodificar y guardar resultados. El usuario puede inspeccionar la ruta de datos, reutilizar partes y fijar parámetros. Esto facilita reproducibilidad y automatización.

La documentación oficial incluye plantillas con nodos del núcleo y permite instalar en Windows, macOS y Linux. También existe un ecosistema amplio de nodos personalizados. Conviene empezar con plantillas del núcleo porque reducen dependencias y simplifican el diagnóstico.

ComfyUI puede producir imagen, vídeo, audio, objetos tridimensionales y otros medios según los modelos y nodos disponibles. No todas las funciones son locales: ciertos nodos de socios o APIs pueden enviar datos a servicios externos.

Un flujo básico y sus puntos de memoria

El checkpoint no es el único consumidor de memoria. Text encoders, VAE, ControlNet, adaptadores, modelos de vídeo, cachés y lotes pueden coincidir en GPU. Algunos nodos descargan componentes a RAM, lo que reduce memoria de GPU a cambio de tiempo.

Un flujo guardado debe conservar también sus modelos, versiones y nodos. La imagen generada puede contener metadatos del flujo, pero no reemplaza un inventario de producción.

Elige el método según el uso

La instalación manual oficial recomienda un entorno virtual para no contaminar el Python del sistema. En producción, fija versiones y conserva el archivo de dependencias. Una actualización de ComfyUI puede requerir actualizar paquetes.

No existe un umbral universal

La memoria necesaria depende de checkpoint, precisión, resolución, lote, número de fotogramas, atención, ControlNet, adaptadores y nodos. Dos flujos con la misma resolución pueden tener requisitos muy distintos.

Para un flujo que cabe en una GPU rápida, su ancho de banda suele ofrecer mejor rendimiento. La RTX PRO 6000 de 96 GB es una opción profesional. DGX Spark aporta 128 GB coherentes cuando la capacidad pesa más, pero necesita una prueba controlada.

Los nodos personalizados son software de terceros

• Revisa el repositorio, el mantenedor, las dependencias y la actividad antes de instalar.
• Ejecuta ComfyUI con una cuenta sin privilegios y sin acceso innecesario a otros archivos.
• Fija una revisión concreta en producción; no actualices todos los nodos automáticamente.
• Mantén una lista permitida y una imagen de entorno reproducible.
• Bloquea salida de red salvo para componentes autorizados.
• Prueba la apertura de flujos recibidos: pueden solicitar modelos o nodos desconocidos.
• Conserva copia de flujos y configuración antes de actualizar.

El formato API es un contrato distinto

ComfyUI representa los flujos como JSON. Para una llamada programática se utiliza un formato API específico, distinto del formato visual de guardado. Exporta el flujo para API y trata los identificadores de nodo y entradas como un contrato versionado.

Aplicación → valida parámetros → construye workflow API → envía a ComfyUI
           → consulta estado → recoge salida → registra modelo y versión

No permitas que un usuario modifique arbitrariamente rutas de archivo, nodos o URLs. Crea una plantilla permitida y expón solo parámetros controlados como prompt, semilla, resolución dentro de límites y número de resultados.

De una estación creativa a un servicio

• Versiones de ComfyUI, Python, controladores y nodos fijadas
• Modelos, hashes y licencias inventariados
• Plantillas API permitidas y parámetros validados
• Límites de resolución, lote, tiempo y cola
• Salida de red bloqueada salvo nodos autorizados
• Almacenamiento de entrada y salida con retención definida
• Copia y reversión probadas
• Métricas de VRAM, tiempo, fallos y cola

Instalar ComfyUI sin convertir el entorno en una colección de dependencias frágiles

ComfyUI es una interfaz por nodos y, al mismo tiempo, un motor de ejecución. La aplicación ocupa poco en comparación con los pesos: checkpoints, VAE, LoRA, ControlNet, modelos de texto, upscalers y modelos de vídeo son archivos independientes. Antes de instalar, separa tres ubicaciones: aplicación, modelos y resultados. Esa decisión simplifica copias, actualizaciones y recuperación.

1. Actualiza el controlador de la GPU. Comprueba primero que el sistema reconoce el acelerador; no diagnostiques ComfyUI mientras el controlador todavía es incierto.
2. Instala en una ruta sin permisos ambiguos. Evita ejecutar como administrador de forma permanente. El proceso solo necesita acceso a aplicación, modelos, entrada y salida.
3. Arranca sin nodos de terceros. La primera prueba debe utilizar únicamente nodos del núcleo. Así separas un problema de instalación de un conflicto introducido por extensiones.
4. Añade un único checkpoint compatible. Colócalo en la carpeta indicada por el nodo cargador y reinicia o refresca la lista de modelos.
5. Guarda el flujo y una imagen de referencia. La reproducción exige conocer workflow, modelo, VAE, semilla, resolución, sampler, scheduler y versiones.
6. Documenta la salida de consola. Los mensajes de inicio muestran dispositivo, memoria detectada, rutas y nodos que fallan al cargar.

Regla de mantenimiento: una instalación estable no se actualiza durante un trabajo crítico. Primero se clona o se crea un entorno de ensayo, se abre una copia del flujo y se compara el resultado.

Qué archivo necesita cada nodo y por qué no basta con descargar «un modelo»

En muchos workflows, CLIP o el codificador de texto transforma el prompt en representaciones que el modelo utiliza durante el muestreo. Según la arquitectura puede venir dentro del checkpoint o como archivo separado; no intercambies codificadores sin comprobar compatibilidad.

Utiliza nombres internos coherentes y conserva una ficha por flujo. Debe indicar procedencia y licencia de cada peso, hash o identificador, ubicación, finalidad, versión de ComfyUI, nodos personalizados y una salida esperada. Si el mismo repositorio de modelos se comparte entre instalaciones, configura rutas adicionales en lugar de duplicar cientos de gigabytes.

Construir y verificar el primer flujo de texto a imagen paso a paso

El flujo mínimo sirve para comprender dónde se carga el modelo y dónde aumenta la memoria. No empieces con una plantilla de decenas de nodos. Crea una cadena que puedas explicar de izquierda a derecha.

1. Carga el checkpoint. El nodo cargador entrega el modelo de difusión, el codificador de texto y, según el formato, el VAE.
2. Codifica el prompt positivo. Describe sujeto, encuadre, iluminación y restricciones relevantes. Evita depender de listas interminables de adjetivos.
3. Codifica el prompt negativo cuando la arquitectura lo utilice. Añade solo exclusiones que hayas comprobado; un negativo genérico puede eliminar detalles deseados.
4. Crea el latente vacío. Fija anchura, altura y lote. Duplicar el lote no equivale a ejecutar trabajos independientes y puede elevar mucho la memoria.
5. Configura el sampler. Conserva semilla, número de pasos, scheduler y nivel de guía. Cambia una variable por prueba para poder atribuir el resultado.
6. Decodifica mediante el VAE. La salida latente se transforma en imagen. Un error aquí suele indicar incompatibilidad o falta de memoria.
7. Previsualiza y guarda. Separa la vista temporal de la salida persistente y define una ruta con retención conocida.

Checkpoint → Modelo ───────────────┐
             Texto positivo ──────┤
             Texto negativo ──────┤→ Sampler → VAE Decode → Guardar
Latente vacío ────────────────────┘

Una prueba reproducible necesita más que la semilla

Guarda el workflow en JSON y conserva una imagen con metadatos cuando el formato lo permita. Anota modelo, hash, VAE, LoRA, intensidades, resolución, lote, pasos, sampler, scheduler, guía, semilla y versión de cada nodo personalizado. Una misma semilla no garantiza el mismo resultado si cambia cualquiera de esos elementos.

Cómo comparar dos configuraciones

Fija prompt, semilla, resolución y modelo. Cambia una sola variable. Registra tiempo total, pico de memoria, errores, calidad visual y consistencia. Para vídeo o lotes, añade fotogramas, duración y tiempo por unidad. No elijas hardware por una captura aislada: utiliza el workflow más exigente que esperas mantener.

Diagnosticar la VRAM antes de reducir calidad de forma indiscriminada

El consumo no depende únicamente del checkpoint. Resolución, lote, precisión, atención, VAE, ControlNet, upscaling, vídeo y nodos auxiliares compiten por memoria. Cuando falta VRAM, ComfyUI puede descargar componentes a RAM o ejecutar modos de bajo consumo; el flujo quizá termine, pero con una latencia muy superior.

1. Mide el pico real. Ejecuta una cola corta con la resolución, lote y nodos finales.
2. Deja margen. Una prueba que consume toda la VRAM no es una configuración estable para trabajo continuo.
3. Optimiza la fase limitante. Reducir la resolución inicial no ayuda si el pico ocurre en el upscaler o en el VAE.
4. Separa trabajos concurrentes. Dos usuarios pueden duplicar cachés y componentes aunque utilicen el mismo workflow.
5. Compara capacidad y velocidad. Una GPU discreta es normalmente más rápida si todo cabe; una plataforma de memoria amplia puede completar flujos que la VRAM convencional no admite.

Instalar nodos personalizados como software, no como simples bloques visuales

Un nodo personalizado ejecuta código con los permisos del proceso de ComfyUI. Puede instalar dependencias, leer archivos, abrir conexiones y modificar resultados. El hecho de aparecer en un workflow compartido no constituye una revisión de seguridad.

No importes y ejecutes un workflow desconocido de inmediato. Revisa nodos ausentes, modelos solicitados, rutas de archivo y cualquier bloque que llame a servicios externos. La interfaz visual no muestra por sí sola todo lo que hace el código.

Pasar del lienzo a una cola de producción sin perder trazabilidad

ComfyUI puede recibir workflows en formato API, encolarlos y devolver identificadores de ejecución. El JSON para API no debe confundirse con el archivo de edición normal. Exporta el formato correcto, identifica los campos que la aplicación podrá cambiar y valida cada entrada antes de enviarla.

1. Congela un workflow aprobado. El equipo creativo valida una versión y la registra como plantilla.
2. Expón solo parámetros permitidos. Prompt, semilla o dimensiones deben pasar por listas, rangos y límites; no permitas sustituir rutas o nodos arbitrarios.
3. Asigna un identificador al trabajo. Relaciona solicitud, plantilla, usuario, modelos y salida sin guardar más contenido del necesario.
4. Utiliza una cola. Controla concurrencia, cancelación, prioridad y tiempo máximo. No envíes varios flujos pesados directamente al mismo proceso.
5. Recoge salida y errores. Comprueba que el archivo pertenece al trabajo y no devuelvas rutas internas al cliente.
6. Aplica retención. Limpia entradas temporales, previsualizaciones y resultados según la finalidad.

En un servicio compartido, coloca ComfyUI detrás de una aplicación que aporte autenticación, autorización, límites y registro. No publiques el puerto de la interfaz directamente en Internet.