DiffuGen

Genera imágenes a partir de texto utilizando los modelos Flux y Stable Diffusion.

GitHub
19
Prueba este MCPPatrocinado

Documentación

DiffuGen - Generador de Imágenes Local Avanzado con Integración MCP

DiffuGen Logo

Tu estudio de arte con IA integrado directamente en el código. Genera, itera y perfecciona conceptos visuales a través de este potente servidor MCP para Cursor, Windsurf y otros IDEs compatibles, utilizando modelos de vanguardia Flux y Stable Diffusion sin interrumpir tu proceso de desarrollo.

Stars Badge Forks Badge Issues Badge License Badge

⭐ Nuevo: Ahora incluye soporte para servidor OpenAPI e integración con OpenWebUI OpenAPI Tools (se requiere OWUI versión 0.60.0) para generación y visualización de imágenes sin interrupciones en interfaces de chat. El OpenAPI es independiente del servidor MCP y permite integraciones en tus propios proyectos.

📃 Tabla de Contenidos

🚀 Introducción

DiffuGen es un potente sistema de generación de imágenes basado en MCP que lleva modelos de IA de vanguardia directamente a tu flujo de trabajo de desarrollo. Integra sin problemas tanto los modelos Flux (Flux Schnell, Flux Dev) como las variantes de Stable Diffusion (SDXL, SD3, SD1.5) en una interfaz unificada, permitiéndote aprovechar las fortalezas únicas de cada familia de modelos sin cambiar de herramienta. Con un control integral de parámetros y soporte multi-GPU, DiffuGen escala desde bocetos conceptuales rápidos en hardware modesto hasta visuales de calidad de producción en sistemas de alto rendimiento.

Construido sobre la implementación altamente optimizada de stable-diffusion.cpp, DiffuGen ofrece un rendimiento excepcional incluso en hardware modesto mientras mantiene una salida de alta calidad.

🧠 Entendiendo MCP y DiffuGen

¿Qué es MCP?

MCP (Protocolo de Contexto de Modelo) es un protocolo que permite a los LLM (Modelos de Lenguaje de Gran Escala) acceder a herramientas y servicios personalizados. En términos simples, un cliente MCP (como Cursor, Windsurf, Roo Code o Cline) puede hacer solicitudes a servidores MCP para acceder a las herramientas que estos proporcionan.

DiffuGen como Servidor MCP

DiffuGen funciona como un servidor MCP que proporciona capacidades de generación de texto a imagen. Implementa el protocolo MCP para permitir que los IDEs compatibles envíen solicitudes de generación y reciban las imágenes generadas.

El servidor expone dos herramientas principales:

  1. generate_stable_diffusion_image: Generar con modelos Stable Diffusion
  2. generate_flux_image: Generar con modelos Flux

Arquitectura Técnica

DiffuGen consta de varios componentes clave:

  • setup-diffugen.sh: La utilidad de instalación completa, descargador y administrador de modelos
  • diffugen.py: El script principal de Python que implementa la funcionalidad del servidor MCP y define las herramientas de generación
  • diffugen.sh: Un script de lanzamiento de shell que configura el entorno y lanza el servidor Python
  • diffugen.json: Archivo de configuración de plantilla para la integración MCP con varios IDEs (para copiar en la configuración MCP del IDE)
  • stable-diffusion.cpp: La implementación optimizada en C++ de Stable Diffusion utilizada para la generación real de imágenes

El sistema funciona de la siguiente manera:

  1. Recibe los datos de prompt y parámetros de un cliente MCP
  2. Procesa la solicitud a través del servidor Python
  3. Llama al binario stable-diffusion.cpp con los parámetros adecuados
  4. Guarda la imagen generada en un directorio de salida configurado
  5. Devuelve la ruta y los metadatos de la imagen generada al cliente

Acerca de stable-diffusion.cpp

stable-diffusion.cpp es una implementación altamente optimizada en C++ del algoritmo de Stable Diffusion. En comparación con la implementación de referencia en Python, ofrece:

  • Velocidad de inferencia significativamente más rápida (hasta 3-4 veces más rápida)
  • Menor uso de memoria (funciona en GPUs con tan solo 4GB de VRAM)
  • Kernels CUDA optimizados para GPUs NVIDIA
  • Soporte para varios métodos de muestreo y formatos de modelo
  • Soporte para cuantización de modelos para un mejor rendimiento
  • Sin dependencias de Python para el proceso de generación principal

Esto permite a DiffuGen proporcionar generación de imágenes de alta calidad con un rendimiento excepcional, incluso en configuraciones de hardware modestas.

✨ Características

  • Soporte de Múltiples Modelos: Genera imágenes usando varios modelos, incluyendo Flux Schnell, Flux Dev, SDXL, SD3 y SD1.5
  • Integración MCP: Se integra sin problemas con IDEs que soportan MCP (Cursor, Windsurf, Roo Code, Cline, etc.)
  • Servidor OpenAPI: Interfaz API REST adicional para acceso HTTP directo a las capacidades de generación de imágenes
  • Multiplataforma: Funciona en Linux, macOS y Windows (nativo o WSL)
  • Control de Parámetros: Ajusta finamente tus generaciones con controles para:
    • Dimensiones de imagen (ancho/alto)
    • Pasos de muestreo
    • Escala CFG
    • Valores de semilla
    • Prompts negativos (solo para modelos SD, Flux no soporta prompts negativos)
    • Métodos de muestreo
  • Aceleración CUDA: Utiliza aceleración por GPU para una generación de imágenes más rápida
  • Interfaz de Lenguaje Natural: Genera imágenes usando comandos simples en lenguaje natural
  • Recuperación Inteligente de Errores: Manejo robusto de errores con procedimientos de recuperación conscientes de la operación
  • Configuración Amigable: Script de configuración interactivo con manejo mejorado de interrupciones
  • Seguimiento de Recursos: Gestión de recursos consciente de la sesión para una limpieza eficiente
  • Interfaz Personalizable: Soporte para logos de arte ANSI personalizados y mejoras visuales

💻 Requisitos del Sistema

Requisitos Mínimos:

  • CPU: Procesador de 4 núcleos (Intel i5/AMD Ryzen 5 o equivalente)
  • RAM: 8GB de memoria del sistema
  • Almacenamiento: 5GB de espacio libre en disco (se prefiere SSD para una carga más rápida de modelos)
  • Python: 3.8 o superior
  • GPU: Gráficos integrados o GPU dedicada de nivel básico (opcional)
  • Red: Conexión de banda ancha para descargas de modelos (5+ Mbps)

Requisitos Recomendados:

  • CPU: Procesador de 8+ núcleos (Intel i7/i9 o AMD Ryzen 7/9)
  • RAM: 16GB+ de memoria del sistema
  • GPU: GPU NVIDIA con 6GB+ de VRAM (RTX 2060 o mejor para un rendimiento óptimo)
  • Almacenamiento: 20GB+ de espacio libre en SSD
  • Python: 3.10 o superior (3.11 ofrece el mejor rendimiento)
  • Red: Conexión de alta velocidad (20+ Mbps) para descargas eficientes de modelos

📥 Instalación

Instalación Automática (Recomendada)

La forma más fácil de instalar DiffuGen es usando el script de configuración proporcionado:

git clone https://github.com/CLOUDWERX-DEV/diffugen.git
cd DiffuGen
chmod +x diffugen.sh
chmod +x setup_diffugen.sh
./setup_diffugen.sh

Sigue las indicaciones interactivas para completar la instalación.

El script de configuración:

  • Instalará las dependencias necesarias
  • Clonará y compilará stable-diffusion.cpp
  • Configurará un entorno virtual de Python
  • Descargará los modelos seleccionados (Nota: Algunos modelos requieren también modelos Clip/VAE)
  • Configurará las rutas de archivo para tu sistema

Instalación Manual

Si prefieres instalar manualmente, sigue estos pasos:

  1. Clona los repositorios:
git clone https://github.com/CLOUDWERX-DEV/diffugen.git
cd DiffuGen
git clone --recursive https://github.com/leejet/stable-diffusion.cpp
  1. Compila stable-diffusion.cpp:
cd stable-diffusion.cpp
mkdir -p build && cd build

Con CUDA:

cmake .. -DCMAKE_BUILD_TYPE=Release -DSD_CUDA=ON
make -j$(nproc)
cd ../..

Sin CUDA:

cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)
cd ../..
  1. Crea y activa un entorno virtual de Python:
python3 -m venv diffugen_env
source diffugen_env/bin/activate  # On Windows: diffugen_env\Scripts\activate
pip install -r requirements.txt
  1. Descarga los modelos requeridos (estructura mostrada abajo):
stable-diffusion.cpp/models/
├── ae.sft                           # VAE model
├── clip_l.safetensors               # CLIP model
├── flux/
│   ├── flux1-schnell-q8_0.gguf     # Flux Schnell model (default)
│   └── flux1-dev-q8_0.gguf          # Flux Dev model
├── sd3-medium.safetensors           # SD3 model
├── sdxl-1.0-base.safetensors        # SDXL model
├── sdxl_vae-fp16-fix.safetensors    # SDXL VAE
├── t5xxl_fp16.safetensors           # T5 model
└── v1-5-pruned-emaonly.safetensors  # SD1.5 model

Puedes descargar los modelos desde las siguientes fuentes:

# Create model directories
mkdir -p stable-diffusion.cpp/models/flux

# Flux models
# Flux Schnell - Fast generation model (Q8 Quantized,requires t5xxl, clip-l, vae)
curl -L https://huggingface.co/leejet/FLUX.1-schnell-gguf/resolve/main/flux1-schnell-q8_0.gguf -o stable-diffusion.cpp/models/flux/flux1-schnell-q8_0.gguf

# Flux Dev - Development model with better quality (Q8 QUantized, requires t5xxl, clip-l, vae)
curl -L https://huggingface.co/leejet/FLUX.1-dev-gguf/resolve/main/flux1-dev-q8_0.gguf -o stable-diffusion.cpp/models/flux/flux1-dev-q8_0.gguf

# Required models for Flux
# T5XXL Text Encoder
curl -L https://huggingface.co/Sanami/flux1-dev-gguf/resolve/main/t5xxl_fp16.safetensors -o stable-diffusion.cpp/models/t5xxl_fp16.safetensors

# CLIP-L Text Encoder
curl -L https://huggingface.co/Sanami/flux1-dev-gguf/resolve/main/clip_l.safetensors -o stable-diffusion.cpp/models/clip_l.safetensors

# VAE for image decoding
curl -L https://huggingface.co/pretentioushorsefly/flux-models/resolve/main/models/vae/ae.safetensors -o stable-diffusion.cpp/models/ae.sft

# Stable Diffusion models
# SDXL 1.0 Base Model (requires sdxl-vae)
curl -L https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors -o stable-diffusion.cpp/models/sd_xl_base_1.0.safetensors

# SDXL VAE (required for SDXL)
curl -L https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/resolve/main/sdxl_vae-fp16-fix.safetensors -o stable-diffusion.cpp/models/sdxl_vae-fp16-fix.safetensors

# Stable Diffusion 1.5 (standalone)
curl -L https://huggingface.co/runwayml/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors -o stable-diffusion.cpp/models/v1-5-pruned-emaonly.safetensors

# Stable Diffusion 3 Medium (standalone)
curl -L https://huggingface.co/leo009/stable-diffusion-3-medium/resolve/main/sd3_medium_incl_clips_t5xxlfp16.safetensors -o stable-diffusion.cpp/models/sd3_medium_incl_clips_t5xxlfp16.safetensors

Nota: La descarga de modelos puede tardar mucho tiempo dependiendo de tu conexión a internet. El modelo SDXL es de aproximadamente 6GB, SD3 es de unos 13GB, SD1.5 es de alrededor de 4GB, y los modelos Flux son de 8-13GB cada uno.

  1. Actualiza las rutas de archivo en la configuración:

Establece el script de shell como ejecutable

chmod +x diffugen.sh

Enfoque de Configuración: DiffuGen utiliza un único archivo de configuración (diffugen.json) como fuente de verdad para todos los ajustes. El flujo de trabajo es:

  1. Edita diffugen.json en el directorio raíz de DiffuGen con tus ajustes deseados
  2. Ejecuta la opción 5 en setup_diffugen.sh para actualizar automáticamente las rutas en este archivo
  3. Copia el contenido de diffugen.json al archivo de configuración MCP de tu IDE

El archivo contiene todos los ajustes necesarios:

  • Rutas de archivo (command, SD_CPP_PATH, models_dir, output_dir)
  • Parámetros de modelo por defecto (steps, cfg_scale, sampling_method)
  • Ajustes de uso de VRAM
  • Metadatos para la integración con el IDE
{
  "mcpServers": {
    "diffugen": {
      "command": "/home/cloudwerxlab/Desktop/Servers/MCP/Tools/DiffuGen/diffugen.sh",
      "args": [],
      "env": {
        "CUDA_VISIBLE_DEVICES": "0",
        "SD_CPP_PATH": "path/to/stable-diffusion.cpp",
        "default_model": "flux-schnell"
      },
      "resources": {
        "models_dir": "path/to/stable-diffusion.cpp/models",
        "output_dir": "path/to/outputs",
        "vram_usage": "adaptive"
      },
      "metadata": {
        "name": "DiffuGen",
        "version": "1.0",
        "description": "Your AI art studio embedded directly in code. Generate, iterate, and perfect visual concepts through this powerful MCP server for Cursor, Windsurf, and other compatible IDEs, utilizing cutting-edge Flux and Stable Diffusion models without disrupting your development process.",
        "author": "CLOUDWERX LAB",
        "homepage": "https://github.com/CLOUDWERX-DEV/diffugen",
        "usage": "Generate images using two primary methods:\n1. Standard generation: 'generate an image of [description]' with optional parameters:\n   - model: Choose from flux-schnell (default), flux-dev, sdxl, sd3, sd15\n   - dimensions: width and height (default: 512x512)\n   - steps: Number of diffusion steps (default: 20, lower for faster generation)\n   - cfg_scale: Guidance scale (default: 7.0, lower for more creative freedom)\n   - seed: For reproducible results (-1 for random)\n   - sampling_method: euler, euler_a (default), heun, dpm2, dpm++2s_a, dpm++2m, dpm++2mv2, lcm\n   - negative_prompt: Specify elements to avoid in the image\n2. Quick Flux generation: 'generate a flux image of [description]' for faster results with fewer steps (default: 4)"
      },
      "cursorOptions": {
        "autoApprove": true,
        "category": "Image Generation",
        "icon": "🖼️",
        "displayName": "DiffuGen"
      },
      "windsurfOptions": {
        "displayName": "DiffuGen",
        "icon": "🖼️",
        "category": "Creative Tools"
      },
      "default_params": {
        "steps": {
          "flux-schnell": 8,
          "flux-dev": 20,
          "sdxl": 20,
          "sd3": 20,
          "sd15": 20
        },
        "cfg_scale": {
          "flux-schnell": 1.0,
          "flux-dev": 1.0,
          "sdxl": 7.0,
          "sd3": 7.0, 
          "sd15": 7.0
        },
        "sampling_method": {
          "flux-schnell": "euler",
          "flux-dev": "euler",
          "sdxl": "euler",
          "sd3": "euler",
          "sd15": "euler"
        }
      }
    }
  }
}

🔧 Instrucciones de Configuración para IDE

Configuración con Cursor

  1. Descarga e instala Cursor
  2. Ve a Configuración de Cursor > MCP y haz clic en "Agregar nuevo servidor MCP global"
  3. Copia el contenido del archivo diffugen.json de tu DiffuGen y pégalo en ~/.cursor/mcp.json
  4. Actualiza los servidores MCP en Configuración > MCP
  5. Usa DiffuGen abriendo el panel de chat de IA (Ctrl+K o Cmd+K) y solicitando la generación de imágenes

Configuración con Windsurf

  1. Descarga e instala Windsurf
  2. Navega a Windsurf > Configuración > Configuración avanzada o Paleta de comandos > Abrir página de configuración de Windsurf
  3. Desplázate hasta la sección Cascade y haz clic en "Agregar servidor" > "Agregar servidor personalizado +"
  4. Copia el contenido del archivo diffugen.json de tu DiffuGen y pégalo en ~/.codeium/windsurf/mcp_config.json
  5. Usa DiffuGen a través de la interfaz de chat de Cascade

Configuración con Roo Code

  1. Descarga e instala Roo Code
  2. Localiza el archivo de configuración MCP para Roo Code
  3. Copia el contenido del archivo diffugen.json de tu DiffuGen en la configuración MCP de Roo Code
  4. Usa DiffuGen a través de la función de asistente de IA

Configuración con Cline

  1. Descarga e instala Cline
  2. Copia el contenido del archivo diffugen.json de tu DiffuGen en la configuración MCP de Cline
  3. Usa DiffuGen a través del chat de IA o la interfaz de comandos

Configuración con Claude en la Consola de Anthropic

Claude puede usar DiffuGen si lo has configurado como servidor MCP en tu sistema. Al pedirle a Claude que genere imágenes, sé específico sobre el uso de DiffuGen y proporciona los parámetros que deseas usar.

🎮 Uso

Para iniciar el servidor DiffuGen manualmente:

cd /path/to/diffugen
./diffugen.sh

O usando Python directamente:

cd /path/to/diffugen
python -m diffugen

Deberías ver: DiffuGen ready cuando el servidor se haya iniciado correctamente.

Uso del Servidor OpenAPI

El servidor OpenAPI proporciona una interfaz API REST para acceso HTTP directo a las capacidades de generación de imágenes de DiffuGen. Esto es adicional a la integración MCP y puede ser útil para:

  • Acceso directo a la API HTTP
  • Integración con otras herramientas que no soportan MCP
  • Aplicaciones personalizadas que necesitan acceso programático

Para instrucciones detalladas de configuración y opciones avanzadas, consulta la Guía de Integración OpenAPI.

Para iniciar el servidor OpenAPI:

python diffugen_openapi.py

El servidor puede configurarse para usar un host o puerto diferente si es necesario. Por defecto, se ejecuta en:

  • Host: 0.0.0.0
  • Puerto: 8080

El servidor estará disponible en http://0.0.0.0:8080 con documentación interactiva en http://0.0.0.0:8080/docs.

Las imágenes generadas se guardan en el directorio /output por defecto. Si este directorio no es accesible, el servidor creará automáticamente un directorio output en el directorio de trabajo actual. Las imágenes se sirven a través del endpoint /images.

Integración con OpenWebUI

  1. Abre la configuración de OpenWebUI (icono de engranaje)
  2. Navega a la sección "Tools"
  3. Haz clic en el botón "+" para añadir un nuevo servidor de herramientas
  4. Introduce los siguientes detalles:
  5. Haz clic en "Guardar"

Una vez añadido, DiffuGen aparecerá en la lista de herramientas disponibles al hacer clic en el icono de herramientas en la interfaz de chat. Los siguientes endpoints estarán disponibles:

  • generate_stable_image_generate_stable_post: Generar con Stable Diffusion
  • generate_flux_image_endpoint_generate_flux_post: Generar con modelos Flux
  • list_models_models_get: Listar modelos disponibles

Ejemplo usando curl:

curl -X POST "http://0.0.0.0:5199/generate/flux" \
     -H "Content-Type: application/json" \
     -d '{"prompt": "A beautiful sunset", "model": "flux-schnell"}'

Ejemplo usando requests de Python:

import requests

response = requests.post(
    "http://0.0.0.0:5199/generate/flux",
    json={
        "prompt": "A beautiful sunset",
        "model": "flux-schnell"
    }
)
result = response.json()

Parámetros predeterminados por modelo

Cada modelo tiene parámetros predeterminados específicos optimizados para obtener los mejores resultados:

ModeloPasos predeterminadosEscala CFG predeterminadaMejor para
flux-schnell81.0Borradores rápidos, imágenes conceptuales
flux-dev201.0Generaciones flux de mejor calidad
sdxl207.0Imágenes detalladas de alta calidad
sd3207.0Última generación con buena calidad
sd15207.0Modelo base clásico

Estos parámetros predeterminados se pueden personalizar añadiendo una sección default_params al archivo de configuración MCP de tu IDE:

"default_params": {
  "steps": {
    "flux-schnell": 12,  // Customize steps for better quality
    "sdxl": 30           // Increase steps for more detailed SDXL images
  },
  "cfg_scale": {
    "sd15": 9.0          // Higher cfg_scale for stronger prompt adherence
  }
}

Solo necesitas especificar los parámetros que quieras sobrescribir; cualquier valor no especificado usará los valores predeterminados integrados.

Nota: Para ejemplos de línea de comandos y recomendaciones específicos de cada modelo, consulta la sección Recomendaciones de parámetros específicos por modelo.

Pedir a un LLM que genere imágenes

Aquí tienes ejemplos de cómo pedir a un asistente de IA que genere imágenes con DiffuGen:

Solicitudes básicas:

Generate an image of a cat playing with yarn

Create a picture of a futuristic cityscape with flying cars

Con especificación de modelo:

Generate an image of a medieval castle using the sdxl model

Create a flux image of a sunset over mountains

Con parámetros avanzados:

Generate an image of a cyberpunk street scene, model=flux-dev, width=768, height=512, steps=25, cfg_scale=1.0, seed=42

Create an illustration of a fantasy character with model=sd15, width=512, height=768, steps=30, cfg_scale=7.5, sampling_method=dpm++2m, negative_prompt=blurry, low quality, distorted

Referencia de parámetros

DiffuGen se puede usar desde la línea de comandos con la siguiente sintaxis básica:

./diffugen.sh "Your prompt here" [options]

Ejemplo:

./diffugen.sh "A futuristic cityscape with flying cars"

Este comando genera una imagen usando los parámetros predeterminados (modelo flux-schnell, resolución 512x512, etc.) y la guarda en el directorio de salida configurado.

A continuación se muestran los parámetros que se pueden usar con DiffuGen (aplicables tanto a la interfaz MCP como a la línea de comandos):

ParámetroDescripciónPredeterminadoValores válidosIndicador de línea de comandos
modelEl modelo a usar para la generaciónflux-schnell/sd15flux-schnell, flux-dev, sdxl, sd3, sd15--model
widthAncho de la imagen en píxeles512256-2048--width
heightAlto de la imagen en píxeles512256-2048--height
stepsNúmero de pasos de difusiónespecífico del modelo1-100--steps
cfg_scaleEscala de guía sin clasificadorespecífico del modelo0.1-30.0--cfg-scale
seedSemilla aleatoria para reproducibilidad-1 (aleatorio)-1 o cualquier entero--seed
sampling_methodMétodo de muestreo de difusióneulereuler, euler_a, heun, dpm2, dpm++2s_a, dpm++2m, dpm++2mv2, lcm--sampling-method
negative_promptElementos a evitar en la imagen"" (vacío)Cualquier cadena de texto--negative-prompt
output_dirDirectorio para guardar imágenesDefinido en la configuraciónRuta válida--output-dir

Estos parámetros se pueden especificar al pedir a un asistente de IA que genere imágenes o al usar la interfaz de línea de comandos. Los parámetros se pasan en diferentes formatos según la interfaz:

  • En MCP/Asistente de IA: parameter=value (p. ej., model=sdxl, width=768, height=512)
  • En línea de comandos: --parameter value (p. ej., --model sdxl --width 768 --height 512)

Los valores predeterminados se eligen para proporcionar buenos resultados de forma inmediata con un tiempo de espera mínimo. Para imágenes de mayor calidad, considera aumentar los pasos o cambiar a modelos como sdxl.

Recomendaciones de parámetros específicos por modelo

Nota: Estas recomendaciones se basan en la sección Parámetros predeterminados por modelo y proporcionan ejemplos prácticos.

Para obtener los mejores resultados al usar modelos específicos mediante la línea de comandos:

Modelos Flux (flux-schnell, flux-dev)

# Flux-Schnell (fastest)
./diffugen.sh "Vibrant colorful abstract painting" \
  --model flux-schnell \
  --cfg-scale 1.0 \
  --sampling-method euler \
  --steps 8

# Flux-Dev (better quality)
./diffugen.sh "Detailed fantasy landscape with mountains and castles" \
  --model flux-dev \
  --cfg-scale 1.0 \
  --sampling-method euler \
  --steps 20

Modelos SD estándar (sdxl, sd3, sd15)

# SDXL (highest quality)
./diffugen.sh "Hyperrealistic portrait of a Celtic warrior" \
  --model sdxl \
  --cfg-scale 7.0 \
  --sampling-method dpm++2m \
  --steps 30

# SD15 (classic model)
./diffugen.sh "Photorealistic landscape at sunset" \
  --model sd15 \
  --cfg-scale 7.0 \
  --sampling-method euler_a \
  --steps 20

Cambios en los parámetros predeterminados

La interfaz de línea de comandos de DiffuGen usa los siguientes valores predeterminados si no se especifica lo contrario en la configuración:

  • Modelo predeterminado: si no se especifica, se usan modelos apropiados para la función (flux-schnell para funciones Flux, sd15 para funciones SD)
  • Método de muestreo predeterminado: euler (mejor para modelos Flux)
  • Escala CFG predeterminada: 1.0 para modelos Flux, 7.0 para modelos SD estándar
  • Pasos predeterminados: 8 para flux-schnell, 20 para otros modelos
  • Dimensiones predeterminadas: 512x512 píxeles

Al usar la línea de comandos, no necesitas especificar estos parámetros a menos que quieras sobrescribir los valores predeterminados. Si usas con frecuencia parámetros específicos, considera añadirlos a tu archivo de configuración en lugar de especificarlos en cada línea de comandos.

Notas de uso de la línea de comandos

  • Las imágenes generadas se guardan en el directorio de salida configurado con nombres de archivo basados en la marca de tiempo y los parámetros
  • Puedes generar varias imágenes en secuencia ejecutando el comando varias veces
  • Para procesamiento por lotes, considera crear un script de shell que llame a DiffuGen con diferentes parámetros
  • Para ver todas las opciones disponibles de línea de comandos, ejecuta ./diffugen.sh --help
  • El mismo motor impulsa tanto la interfaz MCP como la herramienta de línea de comandos, por lo que la calidad y las capacidades son idénticas

⚙️ Configuración

Enfoque de configuración

DiffuGen usa un único enfoque de configuración centrado en el archivo diffugen.json:

  1. Archivo de configuración principal: diffugen.json en el directorio raíz de DiffuGen es la única fuente de verdad para todos los ajustes
  2. Integración con IDE: Copia el contenido de diffugen.json al archivo de configuración MCP de tu IDE
  3. Variables de entorno: Para uso avanzado, puedes sobrescribir los ajustes con variables de entorno

Sobrescritura de variables de entorno

Para uso avanzado, puedes sobrescribir los ajustes usando variables de entorno:

  • SD_CPP_PATH: Sobrescribe la ruta a stable-diffusion.cpp
  • DIFFUGEN_OUTPUT_DIR: Sobrescribe el directorio de salida
  • DIFFUGEN_DEFAULT_MODEL: Sobrescribe el modelo predeterminado
  • DIFFUGEN_VRAM_USAGE: Sobrescribe los ajustes de uso de VRAM
  • CUDA_VISIBLE_DEVICES: Controla qué GPUs se usan para la generación

Configuraciones específicas por IDE

DiffuGen te permite tener diferentes configuraciones para diferentes IDEs usando variables de entorno en la configuración MCP de cada IDE. Esto te permite mantener una única base diffugen.json mientras personalizas los parámetros por IDE.

La prioridad de configuración funciona de la siguiente manera:

  1. Variables de entorno (prioridad más alta)
  2. Ajustes del archivo local diffugen.json (configuración base)

Ejemplo: Diferentes directorios de salida para diferentes IDEs

Para Cursor (en ~/.cursor/mcp.json):

"env": {
  "CUDA_VISIBLE_DEVICES": "0",
  "SD_CPP_PATH": "/path/to/stable-diffusion.cpp",
  "DIFFUGEN_OUTPUT_DIR": "/cursor/specific/output/directory",
  "default_model": "flux-schnell"
}

Para Windsurf (en ~/.codeium/windsurf/mcp_config.json):

"env": {
  "CUDA_VISIBLE_DEVICES": "0",
  "SD_CPP_PATH": "/path/to/stable-diffusion.cpp",
  "DIFFUGEN_OUTPUT_DIR": "/windsurf/specific/output/directory",
  "default_model": "sdxl"
}

Ejemplo: Diferentes modelos predeterminados y ajustes de VRAM

"env": {
  "CUDA_VISIBLE_DEVICES": "0",
  "SD_CPP_PATH": "/path/to/stable-diffusion.cpp",
  "default_model": "flux-dev", 
  "DIFFUGEN_VRAM_USAGE": "maximum"
}

Este enfoque te permite personalizar el comportamiento de DiffuGen por IDE mientras sigues usando la misma instalación subyacente.

Elementos clave de configuración

Comando y argumentos

  • command: Ruta completa al script diffugen.sh (debe ser una ruta absoluta)
  • args: Argumentos adicionales de línea de comandos para pasar al script (normalmente se deja vacío)

Variables de entorno

  • CUDA_VISIBLE_DEVICES: Controla qué GPUs se usan para la generación

    • "0": Usa solo la primera GPU
    • "1": Usa solo la segunda GPU
    • "0,1": Usa tanto la primera como la segunda GPU
    • "-1": Desactiva CUDA y usa solo la CPU

  • SD_CPP_PATH: Ruta al directorio de instalación de stable-diffusion.cpp

    • Se usa para localizar el binario y los modelos de stable-diffusion.cpp

  • default_model: El modelo predeterminado a usar cuando no se especifica ninguno

Configuración de recursos

  • models_dir: Directorio que contiene los archivos de modelo

    • Debe apuntar al directorio models dentro de tu instalación de stable-diffusion.cpp

  • output_dir: Directorio donde se guardarán las imágenes generadas

    • Debe ser escribible por el usuario que ejecuta DiffuGen

  • vram_usage: Controla la estrategia de uso de VRAM

    • "adaptive": Ajusta automáticamente el uso de memoria según la VRAM disponible
    • "minimal": Usa la mínima VRAM a costa de la velocidad
    • "balanced": Equilibra el uso de memoria y la velocidad (predeterminado)
    • "maximum": Usa la máxima VRAM disponible para el mejor rendimiento

Opciones específicas por IDE

Cada IDE tiene opciones específicas que puedes personalizar en el archivo diffugen.json:

Opciones de Cursor

"cursorOptions": {
  "autoApprove": true,
  "category": "Image Generation",
  "icon": "🖼️",
  "displayName": "DiffuGen"
}

Opciones de Windsurf

"windsurfOptions": {
  "displayName": "DiffuGen",
  "icon": "🖼️",
  "category": "Creative Tools"
}

Personalización de parámetros predeterminados

Puedes personalizar los parámetros predeterminados de cada modelo en la sección default_params:

"default_params": {
  "steps": {
    "flux-schnell": 12,
    "sdxl": 30
  },
  "cfg_scale": {
    "sd15": 9.0
  },
  "sampling_method": {
    "flux-schnell": "euler",
    "sdxl": "dpm++2m"
  }
}

Actualización de archivos de configuración

Al usar el script de configuración automática, se crea un archivo diffugen.json correctamente configurado con las rutas adecuadas para tu sistema cuando ejecutas la opción 5. Para integrar DiffuGen con tu IDE:

  1. Ejecuta la opción 5 en setup_diffugen.sh para actualizar las rutas en diffugen.json
  2. Copia todo el contenido del archivo diffugen.json generado
  3. Pégalo en el archivo de configuración MCP de tu IDE (p. ej., ~/.cursor/mcp.json)
  4. Reinicia tu IDE para aplicar los cambios

La principal ventaja de este enfoque es una única fuente de verdad para la configuración, lo que facilita el mantenimiento y la actualización de tu instalación de DiffuGen.

📃 Uso avanzado

El módulo Python de DiffuGen se puede importar y usar programáticamente en tus propios scripts de Python:

from diffugen import generate_image

# Generate an image programmatically
result = generate_image(
    prompt="A starry night over a quiet village",
    model="sdxl",
    width=1024,
    height=768,
    steps=30,
    cfg_scale=7.0,
    seed=42,
    sampling_method="dpm++2m",
    negative_prompt="blurry, low quality"
)

print(f"Image saved to: {result['file_path']}")

Uso del servidor OpenAPI

También puedes usar el servidor OpenAPI programáticamente en tus aplicaciones:

import requests

def generate_image_via_api(prompt, model="flux-schnell", width=512, height=512):
    response = requests.post(
        "http://0.0.0.0:5199/generate/flux",
        json={
            "prompt": prompt,
            "model": model,
            "width": width,
            "height": height
        }
    )
    return response.json()

# Example usage
result = generate_image_via_api(
    prompt="A magical forest at night",
    model="flux-schnell",
    width=768,
    height=512
)
print(f"Generated image: {result['file_path']}")

🔍 Solución de problemas

Problemas comunes y soluciones

  1. Modelos faltantes o rutas incorrectas

    • Asegúrate de que todos los archivos de modelo estén descargados y colocados en los directorios correctos
    • Comprueba que las rutas en el archivo de configuración estén correctamente establecidas
    • Verifica que los permisos de archivo permitan el acceso de lectura a los archivos de modelo

  2. Problemas de CUDA/GPU

    • Asegúrate de que tus controladores NVIDIA estén actualizados
    • Establece CUDA_VISIBLE_DEVICES para apuntar a una GPU específica
    • Si te quedas sin VRAM, intenta usar un modelo más pequeño o reducir las dimensiones

  3. Problemas de calidad de imagen

    • Aumenta los pasos para mejor calidad (a costa del tiempo de generación)
    • Ajusta la escala CFG: más alta para mayor adherencia al prompt, más baja para creatividad
    • Prueba diferentes métodos de muestreo (dpm++2m a menudo proporciona buenos resultados)
    • Usa prompts más detallados con descripciones de estilo específicas

  4. Errores de permisos de archivo

    • Asegúrate de que el directorio de salida sea escribible por el usuario que ejecuta DiffuGen
    • Comprueba que todos los scripts tengan permisos de ejecución (chmod +x diffugen.sh)

Obtener ayuda

Si encuentras problemas no cubiertos aquí, puedes:

  • Consultar el repositorio de GitHub para problemas y soluciones
  • Ejecutar con registro de depuración habilitado: DEBUG=1 ./diffugen.sh "your prompt"
  • Contactar a los desarrolladores a través de los issues de GitHub

🌟 Contribuciones

¡Las contribuciones a DiffuGen son bienvenidas! Para contribuir:

  1. Haz un fork del repositorio
  2. Crea una rama de características
  3. Realiza tus cambios
  4. Envía un pull request

Asegúrate de que tu código siga los estándares de codificación del proyecto e incluya las pruebas adecuadas.

📄 Licencia

Este proyecto está licenciado bajo la Licencia Apache; consulta el archivo LICENSE para más detalles.

  • Todos los modelos están licenciados bajo su respectiva distribución y no están de ninguna manera licenciados ni proporcionados por CLOUDWERX.DEV
  • HuggingFace.co se usa para descargar modelos y no está afiliado de ninguna manera con CLOUDWERX.DEV

🙏 Agradecimientos

📬 Contacto

                   ______   __   ___   ___         _______              
                  |   _  \ |__|.'  _|.'  _|.--.--.|   _   |.-----.-----.
                  |.  |   \|  ||   _||   _||  |  ||.  |___||  -__|     |
                  |.  |    \__||__|  |__|  |_____||.  |   ||_____|__|__|
                  |:  1    /                      |:  1   |             
                  |::.. . /                       |::.. . |             
                  `------'                        `-------'

Hecho con ❤️ por CLOUDWERX LAB