Diffugen

DiffuGen is an advanced local image generation tool that integrates the MCP protocol, supports multiple AI models, and can seamlessly generate high - quality images in the development environment.

Developer tools Image and video processing #Image Generation #AI Tool #Development Integration #MCP Service .Python

rating : 2.5 points

downloads : 26

update time : 2025-04-28

What is DiffuGen?

DiffuGen is an image generation system based on the MCP protocol that allows you to generate images using powerful AI models directly in your development environment. It supports multiple models (such as Flux Schnell, Flux Dev, SDXL, SD3, and SD1.5) and provides high - quality image generation capabilities.

How to use DiffuGen?

Connect to the DiffuGen server by setting up an MCP client (such as Cursor, Windsurf) and input natural language prompts to generate images. You can also operate through the command line.

Use Cases

Suitable for developers and designers who need rapid prototyping, creative concept validation, and high - quality image generation.

Main Features

Multi - Model SupportSupports multiple image generation models to meet different needs.

MCP IntegrationSeamlessly integrates into IDEs that support MCP, such as Cursor and Windsurf.

OpenAPI ServerProvides a REST API interface for easy integration with other tools.

Parameter ControlFine - tune generation parameters, such as size, steps, CFG scale value, etc.

Advantages and Limitations

Advantages

Generate high - quality images without switching tools.

Supports a variety of hardware configurations, from small devices to high - performance workstations.

The natural language interface is simple and easy to use.

OpenAPI supports third - party integration.

Limitations

You may need to download large model files for the initial installation.

Some advanced features may require a certain technical background.

The generation speed is greatly affected by hardware performance.

How to Use

Install DiffuGen

Clone the project repository and run the automatic installation script.

Configure the IDE

Copy the generated configuration file to the MCP configuration of the IDE.

Start Using

Open the AI chat panel in the IDE and input prompts to generate images.

Usage Examples

Generate an Image of a Cat PlayingInput the prompt 'Generate an image of a cat playing' to generate the corresponding image.

Create a Night View of a Future CityInput the prompt 'Create a night view of a future city' to generate the corresponding image.

Frequently Asked Questions

How to install DiffuGen?

Why is my generation speed slow?

Does it support custom parameters?

Related Resources

GitHub Repository

Project source code and documentation.

OpenAPI Integration Guide

Detailed configuration instructions for the OpenAPI server.

StableDiffusion Model

Optimized C++ implementation.

Installation

Copy the following command to your Client for configuration

{
  "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"
        }
      }
    }
  }
}

Note: Your key is sensitive information, do not share it with anyone.

🚀 DiffuDiffusion Usage Documentation

DiffuDiffusion is a powerful tool for generating images. It provides a simple and efficient way to generate high - quality images based on user prompts.

🚀 Quick Start

Basic Usage

Run the script directly Use the following command to generate an image:
```
./diffugen.sh "Your prompt"
```
- Example: ./diffugen.sh "A cat standing on a rock with a beautiful view"

Use via OpenAPI interface You can generate images by accessing the local OpenAPI service:

curl -X POST http://0.0.0.0:5199/generate/flux \
    -H "Content-Type: application/json" \
    -d '{"prompt":"Your prompt","width":512,"height":512}'

Configuration File

Edit the config.json file to adjust the following parameters:

Model path: Specify the storage location of the model file.
Output directory: Set the save path for the generated images.
GPU configuration: Configure CUDA or other GPU acceleration options.

📦 Installation

Installation Steps

Download the project Clone the repository to your local machine using the following command:
```
git clone https://github.com/CLOUDWERX-DEV/diffu.git
cd diffu
```
Install dependencies Make sure you have installed the following tools:
- Git: For version control.
- C++ compiler: Such as g++, for compiling code.
- Python 3: For running scripts and managing configurations.
Download the model After entering the project directory, execute the following command to download the necessary model files:
```
./download_models.sh
```
Configure environment variables Set the relevant environment variables according to the instructions in the documentation to ensure that the program can find the models and dependencies.
Run tests Verify the installation by running the provided test script:
```
./test.sh
```

📚 Documentation

Model Management

Download new models Use the download_models.sh script to get the latest model version:
```
./download_models.sh --model-name new-model-version
```
Delete old models Manually remove the no - longer needed model files to ensure sufficient disk space.
Update models If a new version is available, you can automatically update it through the script:
```
./update_models.sh
```

Logging and Debugging

Enable logging Enable debug mode when running the script to get detailed log information:
```
DEBUG=1 ./diffugen.sh "Your prompt"
```
View log files Check the log files in the logs/ directory to diagnose potential problems.

📚 Educational Resources

Learning Materials

Official documentation: Detailed technical specifications and usage guides.
Tutorial videos: Step - by - step tutorials are provided on YouTube.
Community forum: Participate in discussions and get technical support.

Frequently Asked Questions

Model loading fails
- Check if the model file is correctly downloaded and the path is correct.
- Ensure that all dependencies are installed and configured correctly.
GPU is unavailable
- Update the NVIDIA driver to the latest version.
- Specify the correct CUDA_VISIBLE_DEVICES setting in the environment variables to locate the specific GPU.
Poor image quality
- Increase the number of generation steps (improves quality but consumes more time).
- Adjust the CFG scale: A higher value makes the output closer to the prompt, while a lower value is more creative.
- Choose a different sampling method, such as dpm++2m, which usually works well.
Permission issues
- Ensure that the output directory has write permissions for the user running the script.
- Check if all scripts have execution permissions (use chmod +x diffugen.sh).

🛠️ Development and Contribution

Contribution Guidelines

Fork the repository Fork the project on GitHub to get your own copy.
Create a feature branch Create an independent branch for new features or fixes:
```
git checkout -b feature/new-feature
```
Commit changes After making modifications, commit them to the local repository and push them to the remote:
```
git add .  
git commit -m "Add new feature"
git push origin feature/new-feature
```
Submit a pull request Create a Pull Request on GitHub for review and merging.

Coding Standards

Follow the existing coding style in the project.
Ensure that the commit messages are clear and describe the changes.
Conduct sufficient unit tests to ensure that new features work properly and there are no regression errors.