DiffuGen

Gere imagens a partir de texto usando os modelos Flux e Stable Diffusion.

GitHub
20
Experimente este MCPPatrocinado

Documentação

DiffuGen - Gerador de Imagens Local Avançado com Integração MCP

DiffuGen Logo

Seu estúdio de arte com IA embutido diretamente no código. Gere, itere e aperfeiçoe conceitos visuais através deste poderoso servidor MCP para Cursor, Windsurf e outros IDEs compatíveis, utilizando modelos de ponta Flux e Stable Diffusion sem interromper seu processo de desenvolvimento.

Stars Badge Forks Badge Issues Badge License Badge

⭐ Novo: Agora inclui suporte ao servidor OpenAPI e integração com OpenWebUI OpenAPI Tools (OWUI Versão 0.60.0 Necessária) para geração e exibição de imagens sem interrupções em interfaces de chat! O OpenAPI é separado do servidor MCP e permite integrações em seus próprios projetos!

📃 Sumário

🚀 Introdução

DiffuGen é um poderoso sistema de geração de imagens baseado em MCP que traz modelos de IA de ponta diretamente para o seu fluxo de trabalho de desenvolvimento. Ele integra perfeitamente tanto os modelos Flux (Flux Schnell, Flux Dev) quanto as variantes do Stable Diffusion (SDXL, SD3, SD1.5) em uma interface unificada, permitindo que você aproveite os pontos fortes exclusivos de cada família de modelos sem trocar de ferramenta. Com controle abrangente de parâmetros e suporte a múltiplas GPUs, o DiffuGen escala desde esboços rápidos de conceitos em hardware modesto até visuais de qualidade de produção em sistemas de alto desempenho.

Construído sobre a implementação altamente otimizada do stable-diffusion.cpp, o DiffuGen oferece desempenho excepcional mesmo em hardware modesto, mantendo saídas de alta qualidade.

🧠 Entendendo MCP e DiffuGen

O que é MCP?

MCP (Model Context Protocol) é um protocolo que permite que LLMs (Modelos de Linguagem de Grande Escala) acessem ferramentas e serviços personalizados. Em termos simples, um cliente MCP (como Cursor, Windsurf, Roo Code ou Cline) pode fazer solicitações a servidores MCP para acessar as ferramentas que eles fornecem.

DiffuGen como um Servidor MCP

O DiffuGen funciona como um servidor MCP que fornece capacidades de geração de texto para imagem. Ele implementa o protocolo MCP para permitir que IDEs compatíveis enviem solicitações de geração e recebam as imagens geradas.

O servidor expõe duas ferramentas principais:

  1. generate_stable_diffusion_image: Gerar com modelos Stable Diffusion
  2. generate_flux_image: Gerar com modelos Flux

Arquitetura Técnica

O DiffuGen consiste em vários componentes principais:

  • setup-diffugen.sh: O utilitário completo de instalação, downloader e gerenciador de modelos
  • diffugen.py: O script Python principal que implementa a funcionalidade do servidor MCP e define as ferramentas de geração
  • diffugen.sh: Um script de lançamento em shell que configura o ambiente e inicia o servidor Python
  • diffugen.json: Arquivo de configuração modelo para integração MCP com vários IDEs (a ser copiado para a configuração MCP do IDE)
  • stable-diffusion.cpp: A implementação otimizada em C++ do Stable Diffusion usada para a geração real de imagens

O sistema funciona da seguinte forma:

  1. Recebe dados de prompt e parâmetros de um cliente MCP
  2. Processa a solicitação através do servidor Python
  3. Chama o binário stable-diffusion.cpp com os parâmetros apropriados
  4. Salva a imagem gerada em um diretório de saída configurado
  5. Retorna o caminho e os metadados da imagem gerada ao cliente

Sobre o stable-diffusion.cpp

stable-diffusion.cpp é uma implementação altamente otimizada em C++ do algoritmo Stable Diffusion. Comparado à implementação de referência em Python, ele oferece:

  • Velocidade de inferência significativamente maior (até 3-4x mais rápida)
  • Menor uso de memória (funciona em GPUs com apenas 4GB de VRAM)
  • Kernels CUDA otimizados para GPUs NVIDIA
  • Suporte a vários métodos de amostragem e formatos de modelo
  • Suporte à quantização de modelos para melhor desempenho
  • Sem dependências Python para o processo de geração principal

Isso permite que o DiffuGen forneça geração de imagens de alta qualidade com desempenho excepcional, mesmo em configurações de hardware modestas.

✨ Recursos

  • Suporte a Múltiplos Modelos: Gere imagens usando vários modelos, incluindo Flux Schnell, Flux Dev, SDXL, SD3 e SD1.5
  • Integração MCP: Integra-se perfeitamente com IDEs que suportam MCP (Cursor, Windsurf, Roo Code, Cline, etc.)
  • Servidor OpenAPI: Interface de API REST adicional para acesso HTTP direto às capacidades de geração de imagens
  • Multiplataforma: Funciona em Linux, macOS e Windows (via nativo ou WSL)
  • Controle de Parâmetros: Ajuste fino das suas gerações com controles para:
    • Dimensões da imagem (largura/altura)
    • Etapas de amostragem
    • Escala CFG
    • Valores de semente
    • Prompts negativos (apenas para modelos SD; Flux não suporta prompts negativos.)
    • Métodos de amostragem
  • Aceleração CUDA: Utiliza aceleração de GPU para geração de imagens mais rápida
  • Interface em Linguagem Natural: Gere imagens usando comandos simples em linguagem natural
  • Recuperação Inteligente de Erros: Tratamento robusto de erros com procedimentos de recuperação cientes da operação
  • Configuração Amigável: Script de configuração interativo com melhor tratamento de interrupções
  • Rastreamento de Recursos: Gerenciamento de recursos ciente da sessão para limpeza eficiente
  • Interface Personalizável: Suporte a logotipos de arte ANSI personalizados e melhorias visuais

💻 Requisitos do Sistema

Requisitos Mínimos:

  • CPU: Processador de 4 núcleos (Intel i5/AMD Ryzen 5 ou equivalente)
  • RAM: 8GB de memória do sistema
  • Armazenamento: 5GB de espaço livre em disco (SSD preferido para carregamento mais rápido de modelos)
  • Python: 3.8 ou mais recente
  • GPU: Gráficos integrados ou GPU dedicada de entrada (opcional)
  • Rede: Conexão de banda larga para downloads de modelos (5+ Mbps)

Requisitos Recomendados:

  • CPU: Processador de 8+ núcleos (Intel i7/i9 ou AMD Ryzen 7/9)
  • RAM: 16GB+ de memória do sistema
  • GPU: GPU NVIDIA com 6GB+ de VRAM (RTX 2060 ou melhor para desempenho ideal)
  • Armazenamento: 20GB+ de espaço livre em SSD
  • Python: 3.10 ou mais recente (3.11 oferece o melhor desempenho)
  • Rede: Conexão de alta velocidade (20+ Mbps) para downloads eficientes de modelos

📥 Instalação

Instalação Automática (Recomendada)

A maneira mais fácil de instalar o DiffuGen é usando o script de configuração fornecido:

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

Siga os prompts interativos para concluir a instalação.

O script de configuração irá:

  • Instalar dependências necessárias
  • Clonar e compilar o stable-diffusion.cpp
  • Configurar um ambiente virtual Python
  • Baixar os modelos selecionados (Nota: Alguns modelos também requerem modelos Clip\VAE)
  • Configurar caminhos de arquivo para o seu sistema

Instalação Manual

Se você preferir instalar manualmente, siga estes passos:

  1. Clone os repositórios:
git clone https://github.com/CLOUDWERX-DEV/diffugen.git
cd DiffuGen
git clone --recursive https://github.com/leejet/stable-diffusion.cpp
  1. Compile o stable-diffusion.cpp:
cd stable-diffusion.cpp
mkdir -p build && cd build

Com CUDA:

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

Sem CUDA:

cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)
cd ../..
  1. Crie e ative um ambiente virtual Python:
python3 -m venv diffugen_env
source diffugen_env/bin/activate  # On Windows: diffugen_env\Scripts\activate
pip install -r requirements.txt
  1. Baixe os modelos necessários (estrutura mostrada abaixo):
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

Você pode baixar os modelos das seguintes fontes:

# 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: O download dos modelos pode levar muito tempo dependendo da sua conexão com a internet. O modelo SDXL tem aproximadamente 6GB, o SD3 cerca de 13GB, o SD1.5 cerca de 4GB, e os modelos Flux têm 8-13GB cada.

  1. Atualize os caminhos de arquivo na configuração:

Defina o script shell como Executável

chmod +x diffugen.sh

Abordagem de Configuração: O DiffuGen usa um único arquivo de configuração (diffugen.json) como fonte de verdade para todas as configurações. O fluxo de trabalho é:

  1. Edite o diffugen.json no diretório raiz do DiffuGen com as configurações desejadas
  2. Execute a opção 5 no setup_diffugen.sh para atualizar automaticamente os caminhos neste arquivo
  3. Copie o conteúdo do diffugen.json para o arquivo de configuração MCP do seu IDE

O arquivo contém todas as configurações necessárias:

  • Caminhos de arquivo (command, SD_CPP_PATH, models_dir, output_dir)
  • Parâmetros padrão do modelo (steps, cfg_scale, sampling_method)
  • Configurações de uso de VRAM
  • Metadados para integração com 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"
        }
      }
    }
  }
}

🔧 Instruções de Configuração para IDEs

Configurando com Cursor

  1. Baixe e instale o Cursor
  2. Vá para Configurações do Cursor > MCP e clique em "Adicionar novo servidor MCP global"
  3. Copie o conteúdo do arquivo diffugen.json do seu DiffuGen e cole-o em ~/.cursor/mcp.json
  4. Atualize os Servidores MCP em Configurações > MCP
  5. Use o DiffuGen abrindo o painel de chat de IA (Ctrl+K ou Cmd+K) e solicitando a geração de imagens

Configurando com Windsurf

  1. Baixe e instale o Windsurf
  2. Navegue até Windsurf > Configurações > Configurações Avançadas ou Paleta de Comandos > Abrir Página de Configurações do Windsurf
  3. Role até a seção Cascade e clique em "Adicionar Servidor" > "Adicionar servidor personalizado +"
  4. Copie o conteúdo do arquivo diffugen.json do seu DiffuGen e cole em ~/.codeium/windsurf/mcp_config.json
  5. Use o DiffuGen através da interface de chat Cascade

Configurando com Roo Code

  1. Baixe e instale o Roo Code
  2. Localize o arquivo de configuração MCP para o Roo Code
  3. Copie o conteúdo do arquivo diffugen.json do seu DiffuGen para a configuração MCP do Roo Code
  4. Use o DiffuGen através do recurso de assistente de IA

Configurando com Cline

  1. Baixe e instale o Cline
  2. Copie o conteúdo do arquivo diffugen.json do seu DiffuGen para as configurações MCP do Cline
  3. Use o DiffuGen através do chat de IA ou interface de comando

Configurando com Claude no Console Anthropic

O Claude pode usar o DiffuGen se você o configurou como um servidor MCP no seu sistema. Ao pedir ao Claude para gerar imagens, seja específico sobre o uso do DiffuGen e forneça os parâmetros que deseja usar.

🎮 Uso

Para iniciar o servidor DiffuGen manualmente:

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

Ou usando Python diretamente:

cd /path/to/diffugen
python -m diffugen

Você deve ver: DiffuGen ready quando o servidor for iniciado com sucesso.

Uso do Servidor OpenAPI

O servidor OpenAPI fornece uma interface de API REST para acesso HTTP direto às capacidades de geração de imagens do DiffuGen. Isso é adicional à integração MCP e pode ser útil para:

  • Acesso direto à API HTTP
  • Integração com outras ferramentas que não suportam MCP
  • Aplicações personalizadas que precisam de acesso programático

Para instruções detalhadas de configuração e opções avançadas, consulte o Guia de Integração OpenAPI.

Para iniciar o servidor OpenAPI:

python diffugen_openapi.py

O servidor pode ser configurado para usar um host ou porta diferente, se necessário. Por padrão, ele roda em:

  • Host: 0.0.0.0
  • Porta: 8080

O servidor estará disponível em http://0.0.0.0:8080 com documentação interativa em http://0.0.0.0:8080/docs.

As imagens geradas são salvas no diretório /output por padrão. Se este diretório não estiver acessível, o servidor criará automaticamente um diretório output no diretório de trabalho atual. As imagens são servidas através do endpoint /images.

Integração OpenWebUI

  1. Abra as Configurações do OpenWebUI (ícone de engrenagem)
  2. Navegue até a seção "Ferramentas"
  3. Clique no botão "+" para adicionar um novo servidor de ferramentas
  4. Insira os seguintes detalhes:
  5. Clique em "Salvar"

Depois de adicionado, o DiffuGen aparecerá na lista de ferramentas disponíveis ao clicar no ícone de ferramentas na interface de chat. Os seguintes endpoints estarão disponíveis:

  • generate_stable_image_generate_stable_post: Gerar com Stable Diffusion
  • generate_flux_image_endpoint_generate_flux_post: Gerar com Modelos Flux
  • list_models_models_get: Listar Modelos Disponíveis

Exemplo 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"}'

Exemplo usando Python requests:

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 Padrão por Modelo

Cada modelo tem parâmetros padrão específicos otimizados para melhores resultados:

ModelPassos PadrãoEscala CFG PadrãoMelhor Para
flux-schnell81.0Rascunhos rápidos, imagens conceituais
flux-dev201.0Gerações flux de melhor qualidade
sdxl207.0Imagens detalhadas de alta qualidade
sd3207.0Geração mais recente com boa qualidade
sd15207.0Modelo base clássico

Esses parâmetros padrão podem ser personalizados adicionando uma seção default_params ao arquivo de configuração MCP do seu 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
  }
}

Você só precisa especificar os parâmetros que deseja substituir - quaisquer valores não especificados usarão os padrões integrados.

Nota: Para exemplos de linha de comando e recomendações específicas de modelo, consulte a seção Recomendações de Parâmetros Específicos de Modelo.

Pedindo a um LLM para Gerar Imagens

Aqui estão exemplos de como pedir a um assistente de IA para gerar imagens com o DiffuGen:

Solicitações Básicas:

Generate an image of a cat playing with yarn

Create a picture of a futuristic cityscape with flying cars

Com Especificação de Modelo:

Generate an image of a medieval castle using the sdxl model

Create a flux image of a sunset over mountains

Com Parâmetros Avançados:

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

Referência de Parâmetros

O DiffuGen pode ser usado a partir da linha de comando com a seguinte sintaxe básica:

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

Exemplo:

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

Este comando gera uma imagem usando parâmetros padrão (modelo flux-schnell, resolução 512x512, etc.) e a salva no diretório de saída configurado.

Abaixo estão os parâmetros que podem ser usados com o DiffuGen (aplicáveis tanto à interface MCP quanto à linha de comando):

ParâmetroDescriçãoPadrãoValores VálidosFlag de Linha de Comando
modelO modelo a ser usado para geraçãoflux-schnell/sd15flux-schnell, flux-dev, sdxl, sd3, sd15--model
widthLargura da imagem em pixels512256-2048--width
heightAltura da imagem em pixels512256-2048--height
stepsNúmero de etapas de difusãoespecífico do modelo1-100--steps
cfg_scaleEscala de orientação sem classificadorespecífico do modelo0.1-30.0--cfg-scale
seedSemente aleatória para reprodutibilidade-1 (aleatório)-1 ou qualquer inteiro--seed
sampling_methodMétodo de amostragem de difusãoeulereuler, euler_a, heun, dpm2, dpm++2s_a, dpm++2m, dpm++2mv2, lcm--sampling-method
negative_promptElementos a evitar na imagem"" (vazio)Qualquer texto--negative-prompt
output_dirDiretório para salvar imagensDefinido na configuraçãoCaminho válido--output-dir

Esses parâmetros podem ser especificados ao pedir a um assistente de IA para gerar imagens ou ao usar a interface de linha de comando. Os parâmetros são passados em formatos diferentes dependendo da interface:

  • No MCP/Assistente de IA: parameter=value (por exemplo, model=sdxl, width=768, height=512)
  • Na Linha de Comando: --parameter value (por exemplo, --model sdxl --width 768 --height 512)

Os valores padrão são escolhidos para fornecer bons resultados prontos para uso com tempo de espera mínimo. Para imagens de maior qualidade, considere aumentar as etapas ou mudar para modelos como sdxl.

Recomendações de Parâmetros Específicos de Modelo

Nota: Estas recomendações baseiam-se na seção Parâmetros Padrão por Modelo e fornecem exemplos práticos.

Para melhores resultados ao usar modelos específicos via linha de comando:

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 Padrão (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

Alterações de Parâmetros Padrão

A interface de linha de comando do DiffuGen usa os seguintes padrões se não forem especificados de outra forma na configuração:

  • Modelo Padrão: Se não especificado, modelos apropriados para a função são usados (flux-schnell para funções Flux, sd15 para funções SD)
  • Método de Amostragem Padrão: euler (melhor para modelos Flux)
  • Escala CFG Padrão: 1.0 para modelos Flux, 7.0 para modelos SD padrão
  • Passos Padrão: 8 para flux-schnell, 20 para outros modelos
  • Dimensões Padrão: 512x512 pixels

Ao usar a linha de comando, você não precisa especificar esses parâmetros, a menos que queira substituir os padrões. Se você usa frequentemente parâmetros específicos, considere adicioná-los ao seu arquivo de configuração em vez de especificá-los em cada linha de comando.

Notas de Uso da Linha de Comando

  • As imagens geradas são salvas no diretório de saída configurado com nomes de arquivo baseados em timestamp e parâmetros
  • Você pode gerar várias imagens em sequência executando o comando várias vezes
  • Para processamento em lote, considere criar um script de shell que chame o DiffuGen com diferentes parâmetros
  • Para ver todas as opções de linha de comando disponíveis, execute ./diffugen.sh --help
  • O mesmo mecanismo alimenta tanto a interface MCP quanto a ferramenta de linha de comando, então a qualidade e as capacidades são idênticas

⚙️ Configuração

Abordagem de Configuração

O DiffuGen usa uma abordagem de configuração única centrada no arquivo diffugen.json:

  1. Arquivo de Configuração Principal: diffugen.json no diretório raiz do DiffuGen é a fonte única de verdade para todas as configurações
  2. Integração com IDE: Copie o conteúdo de diffugen.json para o arquivo de configuração MCP do seu IDE
  3. Variáveis de Ambiente: Para uso avançado, você pode substituir configurações com variáveis de ambiente

Substituições de Variáveis de Ambiente

Para uso avançado, você pode substituir configurações usando variáveis de ambiente:

  • SD_CPP_PATH: Substitua o caminho para stable-diffusion.cpp
  • DIFFUGEN_OUTPUT_DIR: Substitua o diretório de saída
  • DIFFUGEN_DEFAULT_MODEL: Substitua o modelo padrão
  • DIFFUGEN_VRAM_USAGE: Substitua as configurações de uso de VRAM
  • CUDA_VISIBLE_DEVICES: Controle quais GPUs são usadas para geração

Definindo Configurações Específicas de IDE

O DiffuGen permite que você tenha configurações diferentes para diferentes IDEs usando variáveis de ambiente na configuração MCP de cada IDE. Isso permite manter uma única base diffugen.json enquanto personaliza parâmetros por IDE.

A prioridade de configuração funciona da seguinte forma:

  1. Variáveis de ambiente (prioridade mais alta)
  2. Configurações do arquivo local diffugen.json (configuração base)

Exemplo: Diretórios de Saída Diferentes para Diferentes IDEs

Para Cursor (em ~/.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 (em ~/.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"
}

Exemplo: Modelos Padrão e Configurações de VRAM Diferentes

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

Essa abordagem permite personalizar o comportamento do DiffuGen por IDE enquanto ainda usa a mesma instalação subjacente.

Elementos Chave de Configuração

Comando e Argumentos

  • command: Caminho completo para o script diffugen.sh (deve ser um caminho absoluto)
  • args: Argumentos adicionais de linha de comando para passar ao script (geralmente deixados vazios)

Variáveis de Ambiente

  • CUDA_VISIBLE_DEVICES: Controla quais GPUs são usadas para geração

    • "0": Use apenas a primeira GPU
    • "1": Use apenas a segunda GPU
    • "0,1": Use a primeira e a segunda GPUs
    • "-1": Desative CUDA e use apenas CPU

  • SD_CPP_PATH: Caminho para o diretório de instalação do stable-diffusion.cpp

    • Isso é usado para localizar o binário e os modelos do stable-diffusion.cpp

  • default_model: O modelo padrão a ser usado quando nenhum é especificado

Configuração de Recursos

  • models_dir: Diretório contendo os arquivos de modelo

    • Deve apontar para o diretório models dentro da sua instalação do stable-diffusion.cpp

  • output_dir: Diretório onde as imagens geradas serão salvas

    • Deve ser gravável pelo usuário que executa o DiffuGen

  • vram_usage: Controla a estratégia de uso de VRAM

    • "adaptive": Ajustar automaticamente o uso de memória com base na VRAM disponível
    • "minimal": Usar VRAM mínima ao custo de velocidade
    • "balanced": Equilibrar uso de memória e velocidade (padrão)
    • "maximum": Usar a VRAM máxima disponível para melhor desempenho

Opções Específicas de IDE

Cada IDE tem opções específicas que você pode personalizar no arquivo diffugen.json:

Opções do Cursor

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

Opções do Windsurf

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

Personalizando Parâmetros Padrão

Você pode personalizar parâmetros padrão para cada modelo na seção default_params:

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

Atualizando Arquivos de Configuração

Ao usar o script de configuração automática, um arquivo diffugen.json configurado corretamente é criado com os caminhos corretos para o seu sistema quando você executa a opção 5. Para integrar o DiffuGen ao seu IDE:

  1. Execute a opção 5 em setup_diffugen.sh para atualizar os caminhos em diffugen.json
  2. Copie todo o conteúdo do arquivo diffugen.json gerado
  3. Cole-o no arquivo de configuração MCP do seu IDE (por exemplo, ~/.cursor/mcp.json)
  4. Reinicie seu IDE para aplicar as alterações

A principal vantagem dessa abordagem é uma fonte única de verdade para configuração, facilitando a manutenção e atualização da sua configuração do DiffuGen.

📃 Uso Avançado

O módulo Python do DiffuGen pode ser importado e usado programaticamente em seus próprios scripts 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']}")

Usando o Servidor OpenAPI

Você também pode usar o servidor OpenAPI programaticamente em suas aplicações:

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']}")

🔍 Solução de Problemas

Problemas Comuns e Soluções

  1. Modelos ausentes ou caminhos incorretos

    • Garanta que todos os arquivos de modelo sejam baixados e colocados nos diretórios corretos
    • Verifique se os caminhos no arquivo de configuração estão definidos corretamente
    • Verifique se as permissões de arquivo permitem acesso de leitura aos arquivos de modelo

  2. Problemas de CUDA/GPU

    • Certifique-se de que seus drivers NVIDIA estejam atualizados
    • Defina CUDA_VISIBLE_DEVICES para direcionar uma GPU específica
    • Se estiver ficando sem VRAM, tente usar um modelo menor ou reduzir as dimensões

  3. Problemas de qualidade de imagem

    • Aumente as etapas para melhor qualidade (ao custo do tempo de geração)
    • Ajuste a escala CFG: maior para mais aderência ao prompt, menor para criatividade
    • Experimente diferentes métodos de amostragem (dpm++2m geralmente fornece bons resultados)
    • Use prompts mais detalhados com descrições de estilo específicas

  4. Erros de permissão de arquivo

    • Garanta que o diretório de saída seja gravável pelo usuário que executa o DiffuGen
    • Verifique se todos os scripts têm permissões de execução (chmod +x diffugen.sh)

Obtendo Ajuda

Se você encontrar problemas não abordados aqui, você pode:

  • Verifique o repositório GitHub para problemas e soluções
  • Execute com registro de depuração habilitado: DEBUG=1 ./diffugen.sh "your prompt"
  • Contate os desenvolvedores via issues do GitHub

🌟 Contribuindo

Contribuições para o DiffuGen são bem-vindas! Para contribuir:

  1. Faça um fork do repositório
  2. Crie um branch de recurso
  3. Faça suas alterações
  4. Envie um pull request

Por favor, garanta que seu código siga os padrões de codificação do projeto e inclua testes apropriados.

📄 Licença

Este projeto é licenciado sob a Licença Apache - consulte o arquivo LICENSE para detalhes.

  • Todos os modelos são licenciados sob sua respectiva distribuição e não são de forma alguma licenciados ou fornecidos pela CLOUDWERX.DEV
  • HuggingFace.co é usado para baixar modelos e não é afiliado de forma alguma à CLOUDWERX.DEV

🙏 Agradecimentos

📬 Contato

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

Feito com ❤️ por CLOUDWERX LAB