ComfyUI + Open WebUI: Integra Generación de Imágenes con tu Chatbot Local (Guía Completa 2025)

¿Tienes Ollama + Open WebUI funcionando y quieres añadir generación de imágenes? ComfyUI es la solución perfecta: un motor de generación de imágenes ultra-optimizado que puedes integrar con tu chatbot local para crear un asistente multimodal completo (texto + imágenes).

En esta guía completa te enseño a integrar ComfyUI con Open WebUI, crear un stack Docker Compose funcional, y generar imágenes directamente desde el chat. Todo con ejemplos prácticos, código copy-paste, y soluciones a los problemas más comunes que encontrarás en el camino.

Después de seguir esta guía, tendrás un asistente local que puede responder preguntas Y generar imágenes en la misma conversación. Sin dependencias de servicios externos. Sin límites de uso. Todo funcionando en tu homelab.

📋 TL;DR

¿Qué es? Integración de ComfyUI (generación de imágenes) con Open WebUI (chatbot local) para crear un asistente multimodal completo.

¿Qué necesitas? Docker, GPU NVIDIA (mínimo 4GB VRAM), y 30 minutos de tu tiempo.

¿Resultado? Chatbot que puede generar imágenes desde el chat, todo funcionando localmente en tu homelab.

Lo que conseguirás:

• ✅ Stack completo Ollama + ComfyUI + Open WebUI funcionando
• ✅ Generación de imágenes desde el chat con prompts simples
• ✅ API REST de ComfyUI configurada y lista para automatización
• ✅ Workflows reutilizables para diferentes estilos de imágenes

⏱️ Tiempo de lectura: 20 minutos | Nivel: Intermedio

📚 Tabla de Contenidos

1. ¿Qué es la Integración ComfyUI + Open WebUI?
2. Arquitectura del Stack
3. Requisitos y Preparación
4. Instalación con Docker Compose
5. Configuración de ComfyUI
6. Integración con Open WebUI
7. Ejemplos Prácticos
8. Comparativa: ComfyUI vs AUTOMATIC1111
9. Troubleshooting Común
10. Mejores Prácticas
11. Descargar Ejemplos
12. Preguntas Frecuentes
13. Conclusión

¿Qué es la Integración ComfyUI + Open WebUI? {#que-es}

El Problema

Tienes un chatbot local funcionando con Ollama + Open WebUI. Puede responder preguntas, escribir código, analizar documentos… pero no puede generar imágenes. Si le pides «crea una imagen de un robot punk», te responde con texto explicando cómo sería, pero no genera la imagen real.

La Solución

ComfyUI es un motor de generación de imágenes basado en Stable Diffusion que funciona localmente. Tiene una API REST completa que permite generar imágenes desde cualquier aplicación. Al integrarlo con Open WebUI, puedes crear un asistente que:

• Responde preguntas de texto (Ollama)
• Genera imágenes desde prompts (ComfyUI)
• Todo en una interfaz unificada (Open WebUI)

¿Qué es ComfyUI?

ComfyUI es una interfaz basada en nodos y grafos para ejecutar modelos de difusión (Stable Diffusion, FLUX, etc.). A diferencia de AUTOMATIC1111 que usa formularios, ComfyUI permite diseñar workflows visuales conectando bloques.

Características clave:

• ✅ API REST completa para automatización
• ✅ Workflows exportables en JSON
• ✅ Optimización extrema de VRAM (funciona con 4GB)
• ✅ Multi-modelo: SD1.5, SDXL, FLUX, video, audio, 3D
• ✅ Control granular de cada paso del pipeline

¿Qué es Open WebUI?

Open WebUI es una interfaz web tipo ChatGPT pero self-hosted que se conecta a Ollama (y otros backends LLM). Permite tener un asistente conversacional local con múltiples funciones.

Características clave:

• ✅ Interfaz limpia estilo ChatGPT
• ✅ Soporte RAG (embeddings)
• ✅ Multi-usuario
• ✅ Historial de conversaciones
• ✅ Soporte para generación de imágenes (mediante funciones personalizadas)

Arquitectura del Stack {#arquitectura}

El stack completo se compone de tres servicios principales:

┌─────────────┐
│  Open WebUI │  ← Interfaz web (puerto 3000)
│  (Frontend) │
└──────┬──────┘
       │ HTTP API
       │
       ├──────────────┐
       │              │
       ▼              ▼
┌──────────┐    ┌──────────┐
│  Ollama  │    │ ComfyUI  │
│  (LLM)   │    │ (Images) │
│ :11434   │    │ :8188    │
└──────────┘    └──────────┘

Flujo de trabajo:

1. Usuario escribe prompt en Open WebUI (ej: «Crea una imagen de un robot punk»)
2. Open WebUI detecta que requiere imagen (mediante función personalizada)
3. Open WebUI llama a ComfyUI API con el prompt procesado
4. ComfyUI genera la imagen usando Stable Diffusion
5. ComfyUI devuelve la imagen a Open WebUI
6. Open WebUI muestra la imagen en el chat

Ventajas de esta arquitectura:

• ✅ Servicios independientes (puedes usar cada uno por separado)
• ✅ Escalable (añade más GPUs o servicios según necesites)
• ✅ Flexible (puedes cambiar Ollama por otro LLM, ComfyUI por AUTOMATIC1111)
• ✅ Todo local (sin dependencias externas)

Requisitos y Preparación {#requisitos}

Hardware

GPUs recomendadas:

• Mínimo: GTX 1060 6GB, RTX 3060 12GB
• Recomendado: RTX 4060 Ti 16GB, RTX 4070
• Óptimo: RTX 4090, RTX 5090

Software

• ✅ Docker y Docker Compose instalados
• ✅ NVIDIA Container Toolkit configurado (para GPU)
• ✅ Git (para clonar ejemplos)

Verificar GPU

# Verificar que Docker puede usar GPU
docker run --rm --gpus all nvidia/cuda:12.0.0-base-ubuntu22.04 nvidia-smi

Si ves la salida de nvidia-smi, tu GPU está lista.

Instalación con Docker Compose {#instalacion}

Paso 1: Crear Estructura de Carpetas

mkdir -p comfyui-open-webui-stack
cd comfyui-open-webui-stack

# Crear carpetas para modelos y outputs
mkdir -p comfyui_models/Stable-diffusion
mkdir -p comfyui_models/VAE
mkdir -p comfyui_models/Lora
mkdir -p comfyui_output
mkdir -p workflows

Paso 2: Crear docker-compose.yml

Crea el archivo docker-compose.yml:

version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

  comfyui:
    image: yanwk/comfyui-boot:cu126
    container_name: comfyui
    ports:
      - "8188:8188"
    volumes:
      - ./comfyui_models:/comfyui/models
      - ./comfyui_output:/comfyui/output
      - ./workflows:/comfyui/user/default/workflows
    environment:
      - CLI_ARGS=--listen 0.0.0.0
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    volumes:
      - open_webui_data:/app/backend/data
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - ENABLE_IMAGE_GENERATION=True
    depends_on:
      - ollama
      - comfyui
    restart: unless-stopped

volumes:
  ollama_data:
  open_webui_data:

Paso 3: Levantar Servicios

# Levantar todos los servicios
docker-compose up -d

# Ver logs
docker-compose logs -f

Verificar que todo funciona:

# Ollama
curl http://localhost:11434/api/tags

# ComfyUI
curl http://localhost:8188/queue

# Open WebUI
curl http://localhost:3000

Paso 4: Descargar Modelos

Modelo LLM para Ollama:

docker exec -it ollama ollama pull llama3.1:8b

Modelo Stable Diffusion para ComfyUI:

Descarga un modelo desde Civitai o Hugging Face:

# Ejemplo: Realistic Vision v5
cd comfyui_models/Stable-diffusion
wget https://civitai.com/api/download/models/130072 -O realistic_vision_v5.safetensors

Modelos recomendados según VRAM:

Configuración de ComfyUI {#configuracion-comfyui}

Verificar API

ComfyUI expone una API REST en el puerto 8188. Verifica que funciona:

# Ver estado de la cola
curl http://localhost:8188/queue

# Debe devolver JSON con queue_running y queue_pending

Probar Generación Manual

Crea un script de prueba test_comfyui.py:

import requests
import json
import time

def generate_image(prompt):
    # Workflow básico
    workflow = {
        "1": {
            "inputs": {"text": prompt, "clip": ["4", 0]},
            "class_type": "CLIPTextEncode"
        },
        "3": {
            "inputs": {"ckpt_name": "realistic_vision_v5.safetensors"},
            "class_type": "CheckpointLoaderSimple"
        },
        "4": {
            "inputs": {"width": 512, "height": 512, "batch_size": 1},
            "class_type": "EmptyLatentImage"
        },
        "5": {
            "inputs": {
                "seed": int(time.time()),
                "steps": 20,
                "cfg": 7.0,
                "sampler_name": "euler",
                "scheduler": "normal",
                "denoise": 1.0,
                "model": ["3", 0],
                "positive": ["1", 0],
                "negative": ["2", 0],
                "latent_image": ["4", 0]
            },
            "class_type": "KSampler"
        },
        "6": {
            "inputs": {"samples": ["5", 0], "vae": ["3", 2]},
            "class_type": "VAEDecode"
        },
        "7": {
            "inputs": {"filename_prefix": "ComfyUI", "images": ["6", 0]},
            "class_type": "SaveImage"
        }
    }
    
    # Enviar a cola
    response = requests.post(
        "http://localhost:8188/prompt",
        json={"prompt": workflow}
    )
    return response.json()

# Probar
result = generate_image("a cyberpunk robot with red mohawk")
print(f"Prompt ID: {result['prompt_id']}")

Ejecuta:

pip install requests
python3 test_comfyui.py

La imagen se guardará en comfyui_output/.

Integración con Open WebUI {#integracion-open-webui}

Limitación Actual

Open WebUI no tiene soporte nativo directo para ComfyUI (solo para AUTOMATIC1111 mediante AUTOMATIC1111_BASE_URL). Por lo tanto, necesitamos usar una de estas opciones:

Opción 1: Función Personalizada (Recomendada)

Crea una función Python que Open WebUI pueda llamar:

1. Crear script comfyui_function.py:

import requests
import time
import base64
from pathlib import Path

def generate_image_with_comfyui(prompt: str) -> str:
    """
    Genera una imagen usando ComfyUI basado en el prompt del usuario.
    
    Args:
        prompt: Descripción de la imagen a generar
    
    Returns:
        URL o base64 de la imagen generada
    """
    # Workflow básico (simplificado)
    workflow = {
        "1": {
            "inputs": {"text": prompt, "clip": ["4", 0]},
            "class_type": "CLIPTextEncode"
        },
        "2": {
            "inputs": {"text": "blurry, low quality", "clip": ["4", 0]},
            "class_type": "CLIPTextEncode"
        },
        "3": {
            "inputs": {"ckpt_name": "realistic_vision_v5.safetensors"},
            "class_type": "CheckpointLoaderSimple"
        },
        "4": {
            "inputs": {"width": 512, "height": 512, "batch_size": 1},
            "class_type": "EmptyLatentImage"
        },
        "5": {
            "inputs": {
                "seed": int(time.time()),
                "steps": 20,
                "cfg": 7.0,
                "sampler_name": "euler",
                "scheduler": "normal",
                "denoise": 1.0,
                "model": ["3", 0],
                "positive": ["1", 0],
                "negative": ["2", 0],
                "latent_image": ["4", 0]
            },
            "class_type": "KSampler"
        },
        "6": {
            "inputs": {"samples": ["5", 0], "vae": ["3", 2]},
            "class_type": "VAEDecode"
        },
        "7": {
            "inputs": {"filename_prefix": "ComfyUI", "images": ["6", 0]},
            "class_type": "SaveImage"
        }
    }
    
    # Enviar a ComfyUI
    response = requests.post(
        "http://comfyui:8188/prompt",
        json={"prompt": workflow}
    )
    result = response.json()
    prompt_id = result["prompt_id"]
    
    # Esperar a que termine
    while True:
        queue = requests.get("http://comfyui:8188/queue").json()
        if not any(item[1] == prompt_id for item in queue.get("queue_running", [])):
            break
        time.sleep(1)
    
    # Obtener imagen (buscar archivo más reciente)
    output_dir = Path("/comfyui/output")
    images = sorted(output_dir.glob("*.png"), key=lambda p: p.stat().st_mtime, reverse=True)
    if images:
        image_data = images[0].read_bytes()
        image_b64 = base64.b64encode(image_data).decode('utf-8')
        return f"data:image/png;base64,{image_b64}"
    
    return "Error: No se pudo generar la imagen"

2. Añadir función a Open WebUI:

En Open WebUI, ve a Settings → Functions y añade esta función. Open WebUI la detectará automáticamente cuando el usuario pida generar una imagen.

Opción 2: Usar n8n como Intermediario

Si ya usas n8n, puedes crear un workflow que:

1. Recibe webhook de Open WebUI
2. Llama a ComfyUI API
3. Devuelve imagen a Open WebUI

Ventaja: Más flexible, permite lógica compleja.

Desventaja: Requiere n8n corriendo.

Opción 3: Modificar Open WebUI (Avanzado)

Fork del repositorio de Open WebUI y añadir soporte para COMFYUI_BASE_URL similar a AUTOMATIC1111_BASE_URL.

Ventaja: Integración nativa, funciona igual que AUTOMATIC1111.

Desventaja: Requiere mantener fork actualizado.

Ejemplos Prácticos {#ejemplos}

Ejemplo 1: Generar Imagen desde Python

import requests
import time
from pathlib import Path

class ComfyUIAPI:
    def __init__(self, base_url="http://localhost:8188"):
        self.base_url = base_url
    
    def generate_image(self, prompt, negative="", steps=20, cfg=7.0):
        workflow = {
            # ... (workflow completo como arriba)
        }
        
        # Enviar
        response = requests.post(
            f"{self.base_url}/prompt",
            json={"prompt": workflow}
        )
        result = response.json()
        prompt_id = result["prompt_id"]
        
        # Esperar
        while True:
            queue = requests.get(f"{self.base_url}/queue").json()
            if not any(item[1] == prompt_id for item in queue.get("queue_running", [])):
                break
            time.sleep(1)
        
        # Obtener imagen
        output_dir = Path("comfyui_output")
        images = sorted(output_dir.glob("*.png"), key=lambda p: p.stat().st_mtime, reverse=True)
        return images[0] if images else None

# Uso
comfy = ComfyUIAPI()
image = comfy.generate_image("a cyberpunk robot with red mohawk")
print(f"Imagen guardada: {image}")

Ejemplo 2: Workflow Reutilizable

Guarda este workflow en workflows/cyberpunk_robot.json:

{
  "1": {
    "inputs": {
      "text": "a cyberpunk robot with red mohawk, neon lights, detailed, 4k",
      "clip": ["4", 0]
    },
    "class_type": "CLIPTextEncode"
  },
  "2": {
    "inputs": {
      "text": "blurry, low quality, distorted, watermark",
      "clip": ["4", 0]
    },
    "class_type": "CLIPTextEncode"
  },
  "3": {
    "inputs": {
      "ckpt_name": "realistic_vision_v5.safetensors"
    },
    "class_type": "CheckpointLoaderSimple"
  },
  "4": {
    "inputs": {
      "width": 768,
      "height": 768,
      "batch_size": 1
    },
    "class_type": "EmptyLatentImage"
  },
  "5": {
    "inputs": {
      "seed": 12345,
      "steps": 30,
      "cfg": 7.5,
      "sampler_name": "dpmpp_2m",
      "scheduler": "karras",
      "denoise": 1.0,
      "model": ["3", 0],
      "positive": ["1", 0],
      "negative": ["2", 0],
      "latent_image": ["4", 0]
    },
    "class_type": "KSampler"
  },
  "6": {
    "inputs": {
      "samples": ["5", 0],
      "vae": ["3", 2]
    },
    "class_type": "VAEDecode"
  },
  "7": {
    "inputs": {
      "filename_prefix": "cyberpunk_robot",
      "images": ["6", 0]
    },
    "class_type": "SaveImage"
  }
}

Carga el workflow en ComfyUI y úsalo como template.

Ejemplo 3: Integración con n8n

Crea un workflow n8n que:

1. Webhook recibe prompt de Open WebUI
2. HTTP Request llama a ComfyUI API
3. Wait espera a que termine
4. HTTP Request obtiene imagen
5. Respond to Webhook devuelve imagen a Open WebUI

Comparativa: ComfyUI vs AUTOMATIC1111 {#comparativa}

¿Cuándo usar cada uno?

Usa ComfyUI si:

• ✅ Tienes GPU con poca VRAM (<8GB)
• ✅ Necesitas workflows complejos repetibles
• ✅ Quieres máxima optimización
• ✅ Estás dispuesto a aprender la interfaz de nodos

Usa AUTOMATIC1111 si:

• ✅ Quieres integración fácil con Open WebUI
• ✅ Prefieres interfaz tradicional tipo formulario
• ✅ Tienes GPU con 8GB+ VRAM
• ✅ Quieres usar muchas extensiones populares

Recomendación: Si tienes VRAM limitada o necesitas workflows complejos, ComfyUI es superior. Si quieres simplicidad y integración fácil, AUTOMATIC1111 es mejor.

Troubleshooting Común {#troubleshooting}

1. ComfyUI no responde a peticiones API

Síntoma: Connection refused o timeout al llamar a http://localhost:8188/prompt

Soluciones:

# Verificar que ComfyUI está corriendo
docker ps | grep comfyui

# Verificar que el puerto 8188 está expuesto
docker port comfyui

# Ver logs
docker logs comfyui

# Reiniciar si es necesario
docker restart comfyui

Causa común: ComfyUI debe iniciarse con --listen 0.0.0.0 (no solo --listen). Verifica en docker-compose.yml:

environment:
  - CLI_ARGS=--listen 0.0.0.0  # ✅ Correcto
  # - CLI_ARGS=--listen         # ❌ Incorrecto

2. Open WebUI no puede conectar con ComfyUI

Síntoma: Open WebUI no genera imágenes aunque ComfyUI funciona

Soluciones:

• Usar nombre del servicio Docker: http://comfyui:8188 (no localhost)
• Si están en hosts diferentes, usar IP: http://192.168.1.100:8188
• Verificar que ambos contenedores están en la misma red Docker
• Verificar firewall no bloquea puerto 8188

3. Error «Out of Memory» en ComfyUI

Síntoma: ComfyUI falla al generar imágenes con error CUDA OOM

Soluciones:

# Reducir resolución en workflow (512x512 en lugar de 1024x1024)
# Usar modelo más pequeño (SD1.5 en lugar de SDXL)
# Cerrar otros procesos que usen GPU
docker stop ollama  # Temporalmente para liberar VRAM

# Usar --lowvram flag en ComfyUI
# Editar docker-compose.yml:
environment:
  - CLI_ARGS=--listen 0.0.0.0 --lowvram

4. Imágenes generadas no aparecen en Open WebUI

Síntoma: ComfyUI genera imagen pero Open WebUI no la muestra

Soluciones:

• Verificar que la función personalizada devuelve formato correcto (base64 o URL)
• Revisar logs de Open WebUI: docker logs open-webui
• Verificar permisos de archivos en comfyui_output/
• Usar volumen compartido entre ComfyUI y Open WebUI para acceso directo

5. Workflow JSON inválido

Síntoma: Error 400 al enviar workflow a ComfyUI API

Soluciones:

• Validar JSON antes de enviar (usar json.loads())
• Usar workflow de ejemplo de ComfyUI y modificarlo gradualmente
• Verificar que todos los nodos referenciados existen
• Revisar documentación de nodos: https://github.com/comfyanonymous/ComfyUI/wiki

Mejores Prácticas {#mejores-practicas}

1. Optimización de VRAM

Compartir GPU entre Ollama y ComfyUI:

# Limitar VRAM de Ollama
docker exec -it ollama ollama run llama3.1:8b --num-gpu-layers 20

Modelos pequeños:

• SD1.5 (4GB) en lugar de SDXL (8GB) si VRAM es limitada
• Batch size 1: No generar múltiples imágenes simultáneamente

Cerrar otros servicios:

• Detener AUTOMATIC1111 si usas ComfyUI
• Cerrar otros contenedores que usen GPU

2. Workflows Reutilizables

• Exportar workflows: Guardar JSON de workflows que funcionen bien
• Versionar workflows: Usar Git para control de versiones
• Templates: Crear templates base para diferentes estilos (realista, anime, etc.)

3. Seguridad

• No exponer ComfyUI a Internet: Solo accesible desde red local
• API keys: Si expones API, usar autenticación
• Rate limiting: Limitar peticiones por minuto para evitar abuso

4. Monitoreo

# Logs
docker logs -f comfyui

# Recursos GPU
nvidia-smi -l 1

# Queue status
curl http://localhost:8188/queue

Descargar Ejemplos {#descargar}

Todos los ejemplos de código, docker-compose.yml, y scripts están disponibles en GitHub:

🔗 Ejemplos en GitHub

Incluye:

• ✅ docker-compose.yml completo
• ✅ Scripts Python para ComfyUI API (scripts/comfyui_api.py)
• ✅ Workflows JSON reutilizables (workflows/basic_workflow.json)
• ✅ Script de instalación automatizada (scripts/setup.sh)
• ✅ Scripts adicionales de configuración y troubleshooting

Clonar todo:

git clone https://github.com/ziruelen/learningaiagents.git
cd learningaiagents/comfyui/comfyui-open-webui

Preguntas Frecuentes {#faqs}

¿Puedo usar ComfyUI sin Open WebUI?

Sí, ComfyUI funciona perfectamente de forma independiente. Tiene su propia interfaz web en http://localhost:8188 y una API REST completa.

¿ComfyUI funciona con CPU?

Sí, pero es extremadamente lento (5-10 minutos por imagen). Se recomienda GPU NVIDIA con mínimo 4GB VRAM.

¿Puedo usar AUTOMATIC1111 en lugar de ComfyUI?

Sí, AUTOMATIC1111 tiene mejor integración nativa con Open WebUI mediante AUTOMATIC1111_BASE_URL. Sin embargo, ComfyUI es más optimizado y rápido.

¿Qué modelos de Stable Diffusion puedo usar?

Cualquier modelo compatible con Stable Diffusion 1.5, SDXL, o FLUX. Descarga desde Civitai o Hugging Face.

¿Cuánto tiempo tarda en generar una imagen?

Depende de tu GPU:

• RTX 3060 12GB: 3-5 segundos (512×512)
• RTX 4090: 1-2 segundos (512×512)
• RTX 5090: <1 segundo (512x512)

¿Puedo generar múltiples imágenes a la vez?

Sí, ajusta batch_size en el workflow. Sin embargo, consume más VRAM. Recomendado: batch_size 1 para máxima compatibilidad.

¿ComfyUI soporta ControlNet y LoRA?

Sí, ComfyUI tiene excelente soporte para ControlNet, LoRA, y otras extensiones mediante custom nodes.

¿Cómo actualizo ComfyUI?

docker-compose pull comfyui
docker-compose up -d comfyui

¿Puedo usar ComfyUI con AMD GPU?

Sí, pero requiere configuración adicional con ROCm. NVIDIA CUDA es más fácil y mejor soportado.

¿Open WebUI tiene soporte nativo para ComfyUI?

No actualmente. Solo tiene soporte nativo para AUTOMATIC1111. ComfyUI requiere integración manual mediante funciones personalizadas.

¿Puedo usar ComfyUI con otros LLMs además de Ollama?

Sí, ComfyUI es independiente. Puedes usarlo con cualquier aplicación que pueda hacer HTTP requests a su API.

¿Qué resolución máxima puedo generar?

Depende de tu VRAM:

• 4GB: 512×512 máximo
• 8GB: 768×768 máximo
• 16GB+: 1024×1024 o superior

¿ComfyUI consume mucha VRAM cuando no está generando?

No, ComfyUI solo carga el modelo en VRAM cuando está generando. Cuando está idle, consume ~1GB VRAM.

¿Puedo usar ComfyUI en producción?

Sí, la API REST es estable y está diseñada para producción. Añade autenticación y rate limiting si expones a Internet.

¿Cómo guardo y reutilizo workflows?

Exporta el workflow desde la interfaz de ComfyUI (botón «Save») y guárdalo como JSON. Luego cárgalo cuando lo necesites.

🔗 Enlaces Relacionados

Continúa aprendiendo con estas guías complementarias:

• Ollama vs LM Studio: ¿Cuál Elegir para Ejecutar LLMs Locales? – Elige la mejor herramienta para ejecutar LLMs locales
• ComfyUI vs Stable Diffusion WebUI: ¿Cuál Elegir? – Comparativa completa entre interfaces de generación de imágenes
• AnythingLLM + Ollama: RAG Local Sin Código – Crea un asistente conversacional con RAG
• Home Assistant + n8n + Ollama: Automatiza tu Casa con IA – Stack completo de automatización con IA local
• Homelab con GPU 24GB+: Guía Completa – Configura tu homelab para IA con GPU
• SwarmUI: Integración con n8n para Generación de Imágenes – Alternativa a ComfyUI para automatización

Conclusión {#conclusion}

Integrar ComfyUI con Open WebUI te permite crear un asistente multimodal completo que puede responder preguntas Y generar imágenes desde el mismo chat. Aunque requiere un poco más de configuración que AUTOMATIC1111, ComfyUI ofrece:

• ✅ Mejor optimización de VRAM (funciona con 4GB)
• ✅ Mayor velocidad de generación (10-30% más rápido)
• ✅ Workflows reutilizables en formato JSON
• ✅ API REST completa para automatización

Próximos pasos:

1. ✅ Instala el stack completo siguiendo esta guía
2. ✅ Descarga modelos de Stable Diffusion
3. ✅ Configura la integración con Open WebUI
4. ✅ Experimenta con diferentes workflows y estilos

¿Necesitas ayuda? Revisa la documentación oficial de ComfyUI o consulta los ejemplos de código incluidos en este artículo.

Artículos relacionados:

• ComfyUI vs Stable Diffusion WebUI: ¿Cuál Elegir?
• Ollama Web Search + Qwen3-VL: Tu ChatGPT Local con Internet
• Homelab con GPU 24GB+: Guía Completa de Modelos IA

¿Ya tienes ComfyUI + Open WebUI funcionando? Comparte tus workflows favoritos en los comentarios. 🚀