feat: update imagegen docs

Author: Piotr Stachaczynski

docs-content/image-generation.md

@@ -12,7 +12,7 @@ MaIN.NET supports AI image generation through the same `ChatContext` API used fo
 | Gemini | Imagen 4.0 Fast, Gemini 2.5 Flash Image | `GeminiKey` |
 | xAI (Grok) | Grok Image, Grok Imagine, Grok Imagine Pro | `XaiKey` |
 | Vertex AI | Imagen 4.0, Veo 2.0 | `GoogleServiceAccountAuth` |
-| Local (FLUX) | FLUX.1 Schnell | `ImageGenUrl` pointing to local service |
+| Local (Self) | Stable Diffusion 1.5, FLUX.1 Schnell, Qwen Image | None — runs in-process via GGUF |
 
 **Not supported:** Anthropic, DeepSeek, GroqCloud, Ollama.
 
@@ -55,8 +55,10 @@ Models.Xai.GrokImagineImagePro // "grok-imagine-image-pro"
 Models.Vertex.Imagen4_0_Generate   // "google/imagen-4.0-generate-001"
 Models.Vertex.Veo2_0_Generate      // "google/veo-2.0-generate-001"
 
-// Local
-Models.Local.Flux1Shnell       // "FLUX.1_Shnell" (runs via local ImageGen service)
+// Local (in-process, no external service required)
+Models.Local.StableDiffusion1_5   // "stable-diffusion-1.5" — 512×512, SD1, CPU-friendly
+Models.Local.Flux1Shnell          // "FLUX.1_Shnell"        — 768×768, FLUX, good quality
+Models.Local.QwenImage            // "qwen-image"           — 1024×1024, highest quality
 ```
 
 ---
@@ -192,71 +194,108 @@ public class ChatWithImageGenVertexExample : IExample
 }
 ```
 
-### Local FLUX.1 Schnell
+### Local — in-process diffusion (no external service)
 
-FLUX.1 runs via a separate local image generation service. Start that service first, then point `ImageGenUrl` at it.
+Local image generation runs entirely in-process via `StableDiffusion.NET` (stable-diffusion.cpp). No separate service, no `ImageGenUrl` — just register the model, download it once, and generate.
+
+**Stable Diffusion 1.5** — fastest, single-file GGUF, great for CPU or low-VRAM machines:
 
 ```csharp
-using MaIN.Core;
 using MaIN.Core.Hub;
-using MaIN.Domain.Configuration;
 using MaIN.Domain.Models;
 using MaIN.Domain.Models.Concrete;
 using MaIN.Services.Registry;
 
-namespace Examples.Chat;
+ModelRegistry.RegisterOrReplace(new StableDiffusion1_5());
+await AIHub.Model().EnsureDownloadedAsync(Models.Local.StableDiffusion1_5);
 
-public class ChatWithImageGenExample : IExample
-{
-    public async Task Start()
-    {
-        // Only needed if not already set in appsettings.json:
-        MaINBootstrapper.Initialize(options =>
-        {
-            options.ImageGenUrl = "http://localhost:5003";
-        });
+var result = await AIHub.Chat()
+    .WithModel(Models.Local.StableDiffusion1_5)
+    .WithMessage("Fluffy cat with a book - anime style")
+    .CompleteAsync();
 
-        // Register the local model (required once at startup)
-        ModelRegistry.RegisterOrReplace(new GenericLocalModel(Models.Local.Flux1Shnell));
+await File.WriteAllBytesAsync("output.png", result.Message.Image!);
+```
 
-        var result = await AIHub.Chat()
-            .WithModel(Models.Local.Flux1Shnell)
-            .WithMessage("Cyberpunk godzilla cat warrior")
-            .CompleteAsync();
+**FLUX.1 Schnell** — better quality, downloads additional VAE + text-encoder assets automatically:
 
-        await File.WriteAllBytesAsync("output.png", result.Message.Image!);
-    }
-}
+```csharp
+ModelRegistry.RegisterOrReplace(new Flux1Shnell());
+await AIHub.Model().EnsureDownloadedAsync(Models.Local.Flux1Shnell);
+
+var result = await AIHub.Chat()
+    .WithModel(Models.Local.Flux1Shnell)
+    .WithMessage("Cyberpunk godzilla cat warrior")
+    .CompleteAsync();
+
+await File.WriteAllBytesAsync("output.png", result.Message.Image!);
 ```
 
-`ImageGenUrl` can also be set in `appsettings.json`:
-```json
-{
-  "MaIN": {
-    "ImageGenUrl": "http://localhost:5003"
-  }
-}
+**Qwen Image** — highest quality (1024×1024), requires significant RAM/VRAM, downloads a large Qwen2.5-VL text encoder:
+
+```csharp
+ModelRegistry.RegisterOrReplace(new QwenImage());
+await AIHub.Model().EnsureDownloadedAsync(Models.Local.QwenImage);
+
+var result = await AIHub.Chat()
+    .WithModel(Models.Local.QwenImage)
+    .WithMessage("A photorealistic mountain lake at dawn")
+    .CompleteAsync();
+
+await File.WriteAllBytesAsync("output.png", result.Message.Image!);
 ```
 
+**Key facts about local diffusion:**
+- `EnsureDownloadedAsync` downloads all required assets (VAE, CLIP, T5-XXL, etc.) automatically — you don't manage them separately
+- Models are loaded once and cached in memory for the lifetime of the process
+- `ModelsPath` config (or `MaIN_ModelsPath` env var) controls where GGUF files are stored
+- No `ImageGenUrl` or external service needed
+
 ---
 
 ## Custom Model Registration
 
 If you need to use a model ID not in the `Models.*` constants, register it at runtime:
 
 ```csharp
+using MaIN.Domain.Models.Abstract;
 using MaIN.Domain.Models.Concrete;
 using MaIN.Services.Registry;
 
 // Cloud image generation model (picks up the current backend's service):
 var model = new GenericImageGenerationCloudModel("my-model-id", BackendType.Gemini);
 ModelRegistry.RegisterOrReplace(model);
 
-// Local image generation model:
-var localModel = new GenericLocalModel("my-local-flux-variant");
+// Local in-process diffusion model (GGUF via stable-diffusion.cpp):
+var localModel = new GenericLocalImageGenerationModel(
+    FileName: "my-sd-model-Q8_0.gguf",
+    Architecture: DiffusionArchitecture.SD1,
+    Name: "My Custom SD Model",
+    Width: 512,
+    Height: 512,
+    Steps: 25,
+    CfgScale: 7.0f
+);
 ModelRegistry.RegisterOrReplace(localModel);
 ```
 
+For FLUX-based custom models that need separate encoder assets:
+```csharp
+var fluxModel = new GenericLocalImageGenerationModel(
+    FileName: "my-flux-model-Q4_0.gguf",
+    Architecture: DiffusionArchitecture.Flux,
+    Name: "My FLUX Model",
+    Width: 768,
+    Height: 768,
+    Steps: 4,
+    CfgScale: 1.0f,
+    Vae:   new ModelAsset("ae.safetensors",            new Uri("https://...")),
+    ClipL: new ModelAsset("clip_l.safetensors",        new Uri("https://...")),
+    T5Xxl: new ModelAsset("t5xxl_fp8_e4m3fn.safetensors", new Uri("https://..."))
+);
+ModelRegistry.RegisterOrReplace(fluxModel);
+```
+
 ---
 
 ## Result Structure

docs-content/models.md

@@ -15,7 +15,9 @@ All supported models are available as compile-time constants in the `Models` nam
 | `Models.Local.DeepSeekR1_1_5b` | DeepSeek-R1 1.5B — reasoning/CoT model |
 | `Models.Local.Qwen2_5_0_5b` | Qwen 2.5 0.5B — ultra-small, edge deployment |
 | `Models.Local.Llava16Mistral_7b` | LLaVA 1.6 Mistral 7B — vision model (image input) |
-| `Models.Local.Flux1Shnell` | FLUX.1 Schnell — local image generation |
+| `Models.Local.StableDiffusion1_5` | Stable Diffusion 1.5 — local image generation (512×512, CPU-friendly) |
+| `Models.Local.Flux1Shnell` | FLUX.1 Schnell — local image generation (768×768, balanced quality) |
+| `Models.Local.QwenImage` | Qwen Image — local image generation (1024×1024, highest quality) |
 | `Models.Local.Kokoro82m` | Kokoro 82M — local text-to-speech |
 
 **Adding a custom GGUF model** (not in the built-in catalogue):
@@ -39,9 +41,15 @@ await AIHub.Chat()
 - LLamaSharp is already a dependency of `MaIN.NET` — do NOT add it separately
 - Models are downloaded to `ModelsPath` (config key) or the `MaIN_ModelsPath` env variable
 - `EnsureModelDownloaded()` auto-downloads before first use; `EnsureDownloadedAsync` supports progress reporting
-- `LocalInferenceParams` controls temperature, grammar, top-p, max tokens for local models
+- `LocalInferenceParams` controls temperature, grammar, top-p, max tokens for local text models
 - Context size is set via `WithMemoryParams(new MemoryParams { ContextSize = 4096 })`
 
+**Local image generation (diffusion models):**
+- `StableDiffusion1_5`, `Flux1Shnell`, and `QwenImage` run in-process via `StableDiffusion.NET` — no external service or `ImageGenUrl` needed
+- Register the model class first: `ModelRegistry.RegisterOrReplace(new Flux1Shnell())`
+- `EnsureDownloadedAsync` handles all required assets (VAE, CLIP, T5-XXL) automatically
+- See [image-generation.md](image-generation.md) for full examples
+
 ---
 
 ## OpenAI