Cómo instalar SwarmUI e integrarlo con n8n para automatizar la generación de imágenes con GPU local

Advertencia: SwarmUI requiere una tarjeta gráfica potente y moderna. No es recomendable intentar la instalación si tienes una GPU integrada antigua (por ejemplo, Intel HD Graphics de hace más de 5 años) o tarjetas con menos de 8 GB de VRAM. Para modelos avanzados (como SDXL), se recomiendan al menos 12 GB de VRAM. Lo ideal es una NVIDIA RTX 3060 o superior, o una AMD RX 6700 XT con drivers ROCm configurados.

Requisitos mínimos generales

• GPU dedicada moderna (NVIDIA recomendado, mínimo 8 GB VRAM)
• 16 GB de RAM y SSD rápido
• Espacio libre en disco (al menos 15 GB recomendados para modelos y recursos)
• Conexión a internet para la descarga inicial

Instalación de SwarmUI

En Windows (instalador automático)

1. Accede al repositorio oficial de SwarmUI en GitHub.
2. Descarga el archivo Install-Windows.bat y guárdalo en una carpeta dedicada, por ejemplo C:\SwarmUI (evita “Archivos de programa”).
3. Haz doble clic en Install-Windows.bat para iniciar la instalación automática. Si la ventana se cierra sin avanzar, vuelve a ejecutarlo (puede requerir dos intentos).
4. Al finalizar, utiliza el acceso directo creado en el escritorio o ejecuta launch-windows.bat desde la carpeta de instalación.
5. La interfaz se abrirá en http://localhost:7800 (o http://localhost:7801).
6. Sigue las instrucciones en pantalla para descargar el modelo base (por ejemplo, SDXL Base).

En Linux

1. Abre una terminal y actualiza el sistema:
   sudo apt update && sudo apt upgrade -y
2. Instala dependencias básicas:
   sudo apt install python3.10-venv python3-pip git -y
3. Clona el repositorio y crea el entorno virtual:
   git clone https://github.com/Stability-AI/SwarmUI.git cd SwarmUI python3 -m venv .venv source .venv/bin/activate
4. Instala PyTorch con soporte para tu GPU:
   Para NVIDIA (CUDA 12.1): pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 Para AMD (ROCm 5.7): pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm5.7
5. Instala el resto de dependencias:
   pip install -r requirements.txt
6. Crea un archivo .env en la raíz del proyecto con:
   USE_GPU=1 MODEL_CACHE_DIR=./model_cache
7. Descarga el modelo base:
   python scripts/download_model.py --model sdxl --variant base-1.0
8. Inicia SwarmUI:
   python main.py Accede a http://localhost:7800.

Con Docker

Si prefieres aislar dependencias y facilitar la gestión, puedes usar Docker. Consulta nuestra guía de instalación de Docker si lo necesitas.

docker run -it --gpus all -p 7800:7800 stabilityai/swarmui:latest

Tras el primer arranque, accede a http://localhost:7800 (o el puerto/ip que uses) y sigue los pasos para descargar el modelo base.

Solución de errores comunes

Prueba de la API de SwarmUI con cURL

Antes de integrar con n8n, es fundamental verificar que la API responde correctamente. El primer paso es obtener un session_id válido:

1. Obtener session_id

curl -X POST http://192.168.60.46:7801/API/GetNewSession \
  -H "Content-Type: application/json" \
  -d '{}'

La respuesta será similar a:

{"session_id":"fdb2eb8c39b8a3046901b0450d9b2151d0071b96","user_id":"local","output_append_user":true,"version":"0.9.6.1.GIT-a367218d","server_id":"12343b41-31ca-4817-ad4a-a6ef464a1d28","permissions":["*","shutdown","edit_wildcards","comfy_backend_generate","gridgen_read_grids","reset_metadata","read_user_settings","toggle_backends","add_remove_backends","read_server_info_panels","comfy_direct_calls","param_backend_type","fundamental_generate_tab_access","comfy_dynamic_custom_workflows","edit_user_settings","extra_loras","restart_backends","pickle2safetensors","user_delete_image","edit_server_settings","local_image_folder","view_server_tab","control_mem_clean","gridgen_generate_grids","use_tokenizer","restart","fundamental","comfy_stored_custom_workflows","view_image_history","view_others_outputs","edit_backends","manage_extensions","comfy_read_workflows","user_star_images","download_models","server_debug_message","fundamental_model_access","delete_models","admin_debug","edit_params","gridgen_save_grids","manage_presets","model_params","edit_model_metadata","param_controlnet","param_backend_id","create_tensorrt","view_logs","basic_image_generation","param_video","comfy_edit_workflows","configure_roles","manage_users","load_models_now","install","read_server_settings","view_backends_list","install_features","control_model_refresh","imagebatcher_use_image_batcher","scorersext_use_scorers"]}%

• Consejo: Guarda el session_id obtenido, ya que lo necesitarás para las peticiones de generación de imágenes.
• Si reinicias SwarmUI, deberás repetir este paso para obtener un nuevo session_id.

Importación del comando cURL en n8n: Obtener session_id

Ahora vamos a llevar nuestro comando cURL probado a n8n para automatizar el proceso. Empezaremos importando el comando para obtener el session_id.

Paso 1: Crear y configurar el primer nodo HTTP Request

1. Arrastra un nodo HTTP Request al canvas de n8n
2. Haz clic en el nodo para abrirlo
3. Busca y haz clic en el botón «Import cURL» (generalmente en la parte superior del panel de configuración)
4. Pega exactamente el comando que ya probamos: curl -X POST http://192.168.60.46:7801/API/GetNewSession -H "Content-Type: application/json" -d '{}'
5. Haz clic en «Import»

Configuración automática generada

n8n habrá configurado automáticamente:

• Method: POST
• URL: http://192.168.60.46:7801/API/GetNewSession
• Headers: Content-Type: application/json
• Body: {} (objeto JSON vacío)

Resultado esperado al ejecutar el nodo

Cuando ejecutes este nodo (usando el botón «Execute Node»), recibirás una respuesta similar a esta:

En la respuesta JSON verás:

• session_id: «fdb2eb8c39b8a3046901b0450d9b2151d0071b96» (el que necesitamos)
• user_id: «local»
• permissions: Lista completa de lo que puede hacer esta sesión

✅ Punto clave: Una vez que este nodo se ejecute correctamente, el session_id estará disponible como variable {{ $json.session_id }} para el siguiente nodo. Esto nos permitirá usar ese session_id dinámicamente en la generación de imágenes sin necesidad de copiarlo manualmente.

Verificación del nodo

Para asegurar que todo funciona:

1. Ejecuta el nodo usando «Execute Node»
2. Verifica que aparece una respuesta JSON en el panel de salida
3. Confirma que el campo session_id contiene un valor como el mostrado en la imagen
4. Si hay errores, revisa que SwarmUI esté ejecutándose en la IP y puerto correctos

2. Generar imagen usando el session_id

curl -X POST http://192.168.60.46:7801/API/GenerateText2Image \
  -H "Content-Type: application/json" \
  -d '{
    "session_id": "9D3534E30DA38499DE782BC38211976A58555AA6",
    "images": 1,
    "prompt": "punkminion estilo cyberpunk",
    "model": "Flux/flux1-dev-fp8",
    "sampler": "euler_ancestral",
    "steps": 60,
    "cfg_scale": 7,
    "width": 1152,
    "height": 896
  }'

La respuesta será un JSON con la imagen generada (una URL).

Explicación de parámetros clave

Uso de variables dinámicas en n8n

Una de las ventajas más potentes de integrar SwarmUI con n8n es la capacidad de usar variables dinámicas. Esto permite que el prompt, parámetros y descargas se adapten automáticamente según los datos de nodos anteriores.

Configuración del prompt dinámico

En lugar de usar un prompt fijo, puedes tomar el texto desde cualquier nodo anterior. Por ejemplo, si tienes un nodo que procesa texto con IA y quieres generar una imagen basada en ese resultado:

{
  "session_id": "361789f768b1511a97f1ed82a7dd03629f7671e0",
  "images": 1,
  "prompt": "{{ $json.output }}",
  "model": "Flux/flux1-dev-fp8",
  "sampler": "euler_ancestral",
  "steps": 60,
  "cfg_scale": 7,
  "width": 1152,
  "height": 896
}

En este ejemplo, {{ $json.output }} toma automáticamente el resultado del nodo anterior y lo usa como prompt para generar la imagen.

Otras variables útiles que puedes usar

Importación del comando de generación de imágenes en n8n

Una vez tenemos el session_id dinámico, importaremos el comando cURL para generar imágenes y lo adaptaremos para usar variables desde nodos anteriores.

Paso 1: Importar el comando de generación

1. Crea un nuevo nodo HTTP Request
2. Haz clic en «Import cURL» y pega tu comando de generación:
   curl -X POST http://192.168.60.46:7801/API/GenerateText2Image \ -H "Content-Type: application/json" \ -d '{ "session_id": "SESSION_FIJO", "images": 1, "prompt": "TEXTO_FIJO", "model": "Flux/flux1-dev-fp8", "sampler": "euler_ancestral", "steps": 60, "cfg_scale": 7, "width": 1152, "height": 896 }'
3. Haz clic en Import para cargar la configuración automática

Paso 2: Conversión a variables dinámicas

Modifica los campos fijos para usar datos del flujo:

En el campo Body (JSON):

{
  "session_id": "{{ $json.session_id }}",  // ← Session ID dinámico
  "images": 1,
  "prompt": "{{ $json.prompt }}",         // ← Prompt desde nodo anterior
  "model": "Flux/flux1-dev-fp8",
  "sampler": "euler_ancestral",
  "steps": 60,
  "cfg_scale": 7,
  "width": 1152,
  "height": 896
}

Explicación de las variables:

• {{ $json.session_id }}: Toma el ID de sesión del nodo anterior
• {{ $json.prompt }}: Usa el texto generado por nodos previos (ej: salida de ChatGPT)

Paso 3: Conectar los nodos

Arrastra una conexión desde el nodo de session_id hacia este nuevo nodo:

Resultado esperado

Al ejecutar este nodo, SwarmUI generará una imagen usando:

• El session_id actual (no uno fijo que caduque)
• El prompt dinámico que viene del flujo de trabajo
• Los parámetros de calidad configurados

✅ Importante: La respuesta JSON incluirá la ruta de la imagen generada en "images": ["ruta/imagen.png"], que usaremos en el siguiente paso para descargarla.

Configuración del nodo de descarga

Una vez que SwarmUI genera la imagen, necesitas descargarla usando la ruta devuelta en la respuesta JSON. Configura un nuevo nodo HTTP Request con método GET:

Configuración del nodo de descarga:

• Method: GET
• URL: http://192.168.60.46:7801/{{ $json.images[0] }}
• Authentication: None

La variable {{ $json.images[0] }} toma automáticamente la primera imagen del array «images» devuelto por SwarmUI, construyendo la URL completa para la descarga.

Flujo completo de generación de imágenes en n8n

Basado en un flujo real de producción, aquí se muestra cómo acaba integrado SwarmUI en un workflow completo de n8n que genera imágenes automáticamente y las sube a WordPress en el que se aplica lo que hemos aprendido:

Desglose del bloque «Set Image for WordPress Post»

Este bloque (marcado en amarillo) contiene la secuencia completa para generar y gestionar imágenes:

1. Generar Imagen: Nodo HTTP Request que usa el cURL de SwarmUI que probamos anteriormente: curl -X POST http://192.168.60.46:7801/API/GenerateText2Image \ -H "Content-Type: application/json" \ -d '{ "session_id": "{{ $json.session_id }}", "images": 1, "prompt": "{{ $json.prompt }}", "model": "Flux/flux1-dev-fp8", "sampler": "euler_ancestral", "steps": 60, "cfg_scale": 7, "width": 1152, "height": 896 }'
2. Imagen a archivo: Nodo que convierte la respuesta de SwarmUI (base64 o URL) en un archivo descargable usando HTTP Request con método GET
3. Upload Image to WordPress: Sube la imagen descargada a la biblioteca de medios de WordPress usando la API REST de WordPress
4. Set Image on WordPress Post: Asigna la imagen subida como imagen destacada del post que se está creando
5. Send Success Message to Telegram: Envía una notificación de éxito al canal de Telegram confirmando que la imagen se generó y subió correctamente

Ventajas de este flujo integrado

• Automatización completa: Desde la idea hasta la imagen publicada, sin intervención manual
• Control de calidad: Los parámetros están optimizados para el tipo de contenido específico
• Gestión de errores: Notificaciones automáticas si algo falla en el proceso
• Escalabilidad: Puede procesar múltiples posts simultáneamente

Configuración clave para WordPress

Para que la integración con WordPress funcione correctamente, asegúrate de configurar:

• API REST de WordPress: Habilitada en tu instalación
• Credenciales de aplicación: Usuario con permisos para subir medios y editar posts
• Formato de imagen: Recomendado PNG o JPG, dependiendo del contenido
• Tamaño optimizado: 1152×896 funciona bien para imágenes destacadas

Conclusión y próximos pasos

Y hasta aquí esta guía completa para instalar, configurar e integrar SwarmUI con n8n, una herramienta que nos permite automatizar la generación de imágenes con GPU local de forma eficiente y escalable.

Esperamos que esta guía te haya resultado útil y práctica, y que te anime a experimentar con estas tecnologías para potenciar tus proyectos y flujos de trabajo. Recuerda que la clave está en adaptar cada paso a tus necesidades y en aprovechar la flexibilidad que ofrece n8n para crear automatizaciones a tu medida.

En eldiarioia.es seguimos comprometidos con ofrecer contenido auténtico, riguroso y cercano, que te ayude a entender y aplicar la inteligencia artificial y la automatización en el día a día. No dudes en compartir tus dudas, experiencias o sugerencias para seguir creciendo juntos.

¡A currar y a automatizar sin miedo!