mirror of https://github.com/Memo-2023/mana-monorepo.git synced 2026-05-20 09:13:39 +02:00

Wuesteon d36b321d9d style: auto-format codebase with Prettier

Applied formatting to 1487+ files using pnpm format:write
  - TypeScript/JavaScript files
  - Svelte components
  - Astro pages
  - JSON configs
  - Markdown docs

  13 files still need manual review (Astro JSX comments)

2025-11-27 18:33:16 +01:00

35 KiB

Raw Blame History

Umfassende Dokumentation der Replicate Image Models für MärchenZauber

Inhaltsverzeichnis

Executive Summary
Detaillierte Modellanalyse
Kostenvergleich
Technische Spezifikationen
Implementierungsempfehlungen
API-Verwendungsbeispiele
Best Practices für Kinderbücher

Executive Summary

Diese Dokumentation analysiert 10 führende Bildgenerierungsmodelle auf Replicate für die Verwendung in der MärchenZauber-App zur Erstellung von Kindergeschichten. Die Analyse basiert auf praktischen Tests und Recherchen mit Fokus auf:

Kosteneffizienz: Von $0.003 bis $0.04 pro Bild
Geschwindigkeit: Von 1-2 Sekunden bis 10-15 Sekunden
Qualität: Von schnellen Prototypen bis zu publikationsreifen Illustrationen
Spezialfunktionen: Charakterkonsistenz, Textrendering, künstlerische Stile

Detaillierte Modellanalyse

1. 🚀 Google Imagen 4 Fast

URL: https://replicate.com/google/imagen-4-fast
Kategorie: High-Volume, kostengünstige Generierung

Technische Details

Model ID: google/imagen-4-fast:latest
Preis: $0.02/Bild (50 Bilder für $1) - Kostengünstigstes Modell
Hardware: CPU-basiert
Geschwindigkeit: Bis zu 10x schneller als Imagen 3
Auflösung: Bis zu 2K (2048x2048)
Seitenverhältnisse: 1:1, 9:16, 16:9, 3:4, 4:3

Input-Parameter

{
    "prompt": "A cute cartoon rabbit in a magical forest, children's book style",
    "aspect_ratio": "16:9",
    "safety_filter_level": "block_some",  # block_few, block_some, block_most
    "person_generation": "dont_allow",
    "output_format": "jpg"
}

Stärken für Kindergeschichten

✅ Extrem kosteneffizient - Ideal für hohe Volumen
✅ Schnelle Generierung - Echtzeit-Story-Erstellung möglich
✅ Mehrere Sicherheitsstufen - Kindgerechte Inhalte garantiert
✅ Konsistente Qualität bei einfachen Szenen

Einschränkungen

❌ Geringere Bildqualität im Vergleich zu Pro-Modellen
❌ Limitierte Details bei komplexen Charakteren
❌ Keine LoRA/Finetuning Unterstützung

Kostenberechnung

10-seitige Geschichte: $0.20
100 Geschichten/Tag: $20
Monatliche Kosten (3000 Geschichten): $600

2. 🎨 ByteDance Seedream-4

URL: https://replicate.com/bytedance/seedream-4
Kategorie: High-Resolution, sequenzielle Story-Generierung

Technische Details

Model ID: bytedance/seedream-4:latest
Preis: $0.03/Bild (33 Bilder für $1)
Hardware: CPU-basiert
Auflösung: 1K, 2K, 4K Optionen
Einzigartig: Sequenzielle Bildgenerierung

Input-Parameter

{
    "prompt": "A brave little fox exploring a mystical cave",
    "resolution": "4K",
    "num_images": 10,  # Bis zu 15 Bilder in einem Batch
    "sequential_mode": True,  # Für Story-Kontinuität
    "style": "children_illustration",
    "edit_prompt": "Add sparkles to the fox's eyes"  # Präzise Bearbeitung
}

Stärken für Kindergeschichten

✅ 4K Auflösung - Perfekt für gedruckte Bücher
✅ Sequenzielle Generierung - Erhält Charakterkonsistenz
✅ Batch-Processing - Bis zu 15 Bilder gleichzeitig
✅ Text-basierte Bearbeitung - Nachträgliche Anpassungen möglich
✅ Konsistente Farben und Stile über mehrere Bilder

Einschränkungen

⚠️ Mittlere Preisklasse
⚠️ CPU-basiert kann langsamer sein
❌ Weniger Community-Support als etablierte Modelle

Kostenberechnung

10-seitige Geschichte: $0.30
100 Geschichten/Tag: $30
Monatliche Kosten (3000 Geschichten): $900

3. 🎭 Ideogram V3 Turbo

URL: https://replicate.com/ideogram-ai/ideogram-v3-turbo
Kategorie: Künstlerische Vielfalt und Design-Flexibilität

Technische Details

Model ID: ideogram-ai/ideogram-v3-turbo:latest
Preis: $0.03/Bild (33 Bilder für $1)
Hardware: CPU-basiert
Besonderheit: 50+ vordefinierte Kunststile

Input-Parameter

{
    "prompt": "A magical unicorn in a candy land",
    "style_preset": "vintage_poster",  # Über 50 Stile verfügbar
    "magic_prompt": True,  # Automatische Prompt-Optimierung
    "color_palette": "pastel",
    "inpainting_mask": None,  # Für Charakterkonsistenz
    "commercial_use": True
}

Verfügbare Stile für Kinderbücher

cartoon_3d - Pixar-ähnlicher Stil
watercolor - Aquarell-Illustrationen
oil_painting - Klassische Märchenoptik
vintage_poster - Retro-Kinderbuch-Stil
anime - Manga-inspirierte Illustrationen
clay_animation - Stop-Motion-Look

Stärken für Kindergeschichten

✅ Vielfältige Kunststile - Verschiedene Geschichtsästhetiken
✅ Magic Prompt - Verbessert automatisch Beschreibungen
✅ Inpainting - Nachträgliche Charakteranpassungen
✅ Kommerzielle Nutzung explizit erlaubt
✅ Konsistente Stilanwendung

Einschränkungen

⚠️ CPU-basiert - Langsamere Generierung
⚠️ Stil-Konsistenz kann variieren
❌ Keine eigenen Stil-Uploads

Kostenberechnung

10-seitige Geschichte: $0.30
100 Geschichten/Tag: $30
Monatliche Kosten (3000 Geschichten): $900

4. 📝 Qwen Image

URL: https://replicate.com/qwen/qwen-image
Kategorie: Text-Integration und komplexe Szenen

Technische Details

Model ID: qwen/qwen-image:latest
Preis: $0.025/Bild (40 Bilder für $1)
Hardware: H100 GPU (schnelle Generierung)
Lizenz: Apache 2.0 (Open Source)

Input-Parameter

{
    "prompt": "A book page showing 'Chapter 1: The Magic Forest' with decorative borders",
    "text_rendering": True,
    "text_content": "Once upon a time...",
    "lora_weights": "custom_character.safetensors",  # Charakterkonsistenz
    "guidance_scale": 7.5,
    "num_inference_steps": 30,
    "scheduler": "DPMSolverMultistep"
}

Stärken für Kindergeschichten

✅ Exzellentes Text-Rendering - Perfekt für Titel und Kapitel
✅ H100 GPU - Sehr schnelle Generierung
✅ LoRA Support - Custom Charaktere möglich
✅ Open Source - Keine Lizenzgebühren
✅ Komplexe Szenen mit vielen Details

Einschränkungen

⚠️ Komplexere Konfiguration erforderlich
⚠️ Weniger intuitive Parameter
❌ Begrenzte Stiloptionen ohne LoRA

Kostenberechnung

10-seitige Geschichte: $0.25
100 Geschichten/Tag: $25
Monatliche Kosten (3000 Geschichten): $750

5. ⚡ FLUX.1 Schnell

URL: https://replicate.com/black-forest-labs/flux-schnell
Kategorie: Ultra-schnelle Entwicklung und Prototyping

Technische Details

Model ID: black-forest-labs/flux-schnell:5599ed30703defd1d160a25a63321b4dec97101d98b4674bcc56e41f62f35637
Preis: ~$0.003/Bild (333 Bilder für $1) - Zweitgünstigstes
Hardware: H100 GPU
Runs: 496.2M (meistgenutzt auf Replicate)

Input-Parameter

{
    "prompt": "A friendly dragon teaching ABC to forest animals",
    "num_inference_steps": 4,  # Limitiert auf 4 für Geschwindigkeit
    "go_fast": True,  # Turbo-Modus
    "megapixels": "1",
    "num_outputs": 4,  # Maximum 4 Bilder
    "output_format": "webp",
    "output_quality": 90
}

Stärken für Kindergeschichten

✅ Extrem günstig - Ideal für Tests und Entwicklung
✅ Blitzschnell - 1-2 Sekunden pro Bild
✅ GPU-basiert - Konsistente Performance
✅ "Go Fast" Modus - Noch schnellere Iteration
✅ 496M+ Generierungen - Bewährte Stabilität

Einschränkungen

❌ Nur 4 Inference Steps - Reduzierte Qualität
❌ Maximum 4 Bilder pro Anfrage
❌ Weniger Details als Pro-Version
❌ Nicht für Produktion empfohlen

Kostenberechnung

10-seitige Geschichte: ~$0.03
100 Geschichten/Tag: $3
Monatliche Kosten (3000 Geschichten): $90

6. 💎 FLUX.1.1 Pro

URL: https://replicate.com/black-forest-labs/flux-1.1-pro
Kategorie: Premium-Qualität für professionelle Publikationen

Technische Details

Model ID: black-forest-labs/flux-1.1-pro:8f06b9d3d1f0f2226f33b226bb4a0e47230895564befc417e7917337e282ad8c
Preis: $0.04/Bild (25 Bilder für $1)
Hardware: CPU-basiert
Max Auflösung: 1440x1440 Pixel

Input-Parameter

{
    "prompt": "A whimsical tea party with woodland creatures in Victorian style",
    "aspect_ratio": "1:1",
    "output_format": "png",
    "output_quality": 100,
    "safety_tolerance": 3,  # 1-6 Skala
    "prompt_upsampling": True,  # Verbessert automatisch Prompts
    "image_prompt": "reference_character.jpg",  # Referenzbild für Konsistenz
}

Stärken für Kindergeschichten

✅ Professionelle Qualität - Publikationsreif
✅ Exzellente Prompt-Befolgung - Präzise Umsetzung
✅ Image-to-Image - Charakterkonsistenz durch Referenzen
✅ Einstellbare Sicherheit - Kindgerechte Kontrolle
✅ Konsistente Ergebnisse - Zuverlässige Qualität

Einschränkungen

⚠️ Höhere Kosten als andere Modelle
⚠️ CPU-basiert - Langsamere Generierung
❌ Begrenzte Auflösung (1440x1440)

Kostenberechnung

10-seitige Geschichte: $0.40
100 Geschichten/Tag: $40
Monatliche Kosten (3000 Geschichten): $1200

7. 🏃 Stable Diffusion 3.5 Large Turbo

URL: https://replicate.com/stability-ai/stable-diffusion-3.5-large-turbo
Kategorie: Schnelle, kontrollierbare Generierung

Technische Details

Model ID: stability-ai/stable-diffusion-3.5-large-turbo:latest
Preis: $0.04/Bild (25 Bilder für $1)
Hardware: CPU-basiert
Parameter: 8B Parameter Modell

Input-Parameter

{
    "prompt": "A cozy treehouse library with reading animals",
    "negative_prompt": "scary, dark, violent",  # Ausschluss unerwünschter Elemente
    "num_inference_steps": 4,  # 1-10 für Geschwindigkeitsoptimierung
    "guidance_scale": 3.5,
    "seed": 42,  # Für Reproduzierbarkeit
    "output_format": "jpg",
    "disable_safety_checker": False
}

Stärken für Kindergeschichten

✅ Feine Details - Hochwertige Illustrationen
✅ Turbo-Optimierung - Schnell trotz CPU
✅ Negative Prompts - Präzise Kontrolle
✅ Vielfältige Stile - Flexible Anpassung
✅ Seed-Kontrolle - Reproduzierbare Ergebnisse

Einschränkungen

⚠️ CPU-basiert - Nicht die schnellste Option
⚠️ Höhere Kosten für Turbo-Version
❌ Weniger Community-Ressourcen als SD 1.5/XL

Kostenberechnung

10-seitige Geschichte: $0.40
100 Geschichten/Tag: $40
Monatliche Kosten (3000 Geschichten): $1200

8. 🌟 Google Imagen 4 (Standard)

URL: https://replicate.com/google/imagen-4
Kategorie: Premium Google-Qualität

Technische Details

Model ID: google/imagen-4:latest
Preis: $0.04/Bild (25 Bilder für $1)
Hardware: CPU-basiert
Varianten: Standard, Ultra, Fast

Input-Parameter

{
    "prompt": "A magical school bus flying through clouds made of cotton candy",
    "aspect_ratio": "16:9",
    "safety_filter_level": "block_most",
    "person_generation": "dont_allow",
    "output_format": "png",
    "quality": "standard",  # standard, ultra
    "style_preset": "photographic"  # oder "digital_art", "anime"
}

Stärken für Kindergeschichten

✅ Google-Qualität - Führende Bildqualität
✅ Verbesserte Typografie - Text in Bildern
✅ Multiple Sicherheitsstufen - Maximaler Schutz
✅ 2K Auflösung - Hochauflösende Ausgabe
✅ Konsistente Qualität - Google-Standard

Einschränkungen

⚠️ Höhere Kosten als Fast-Version
⚠️ CPU-basiert - Langsamere Generierung
❌ Weniger Anpassungsoptionen als Open-Source

Kostenberechnung

10-seitige Geschichte: $0.40
100 Geschichten/Tag: $40
Monatliche Kosten (3000 Geschichten): $1200

9. ⚖️ Stable Diffusion 3.5 Medium

URL: https://replicate.com/stability-ai/stable-diffusion-3.5-medium
Kategorie: Ausgewogenes Preis-Leistungs-Verhältnis

Technische Details

Model ID: stability-ai/stable-diffusion-3.5-medium:latest
Preis: $0.035/Bild (28 Bilder für $1)
Hardware: CPU-basiert
Parameter: 2.5B Parameter Modell

Input-Parameter

{
    "prompt": "A cheerful robot teaching math to curious kittens",
    "aspect_ratio": "1:1",
    "num_inference_steps": 28,
    "guidance_scale": 4.5,
    "seed": -1,  # Zufällig
    "output_format": "webp",
    "webhook": "https://your-webhook.com/sd35-complete"  # Optional
}

Stärken für Kindergeschichten

✅ Gute Balance - Preis vs. Qualität
✅ MMDiT-X Architektur - Moderne Technologie
✅ Vielseitig - Breites Anwendungsspektrum
✅ Webhook-Support - Asynchrone Verarbeitung
✅ Multiple Formate - WebP, PNG, JPG

Einschränkungen

⚠️ Mittlere Qualität - Nicht die beste, nicht die schlechteste
⚠️ CPU-basiert - Standardgeschwindigkeit
❌ Weniger Features als Large-Version

Kostenberechnung

10-seitige Geschichte: $0.35
100 Geschichten/Tag: $35
Monatliche Kosten (3000 Geschichten): $1050

10. 🍌 Google Nano Banana

URL: https://replicate.com/google/nano-banana
Kategorie: Konversationelle Bearbeitung und Charakterkonsistenz

Technische Details

Model ID: google/nano-banana:latest
Preis: $0.039/Bild (25 Bilder für $1)
Hardware: CPU-basiert
Besonderheit: Multi-Turn-Editing

Input-Parameter

{
    "prompt": "A banana superhero saving the fruit kingdom",
    "conversation_history": [
        "Make the cape more colorful",
        "Add a sidekick strawberry",
        "Put them in a castle made of chocolate"
    ],
    "character_reference": "previous_banana_hero.jpg",
    "multi_image_fusion": True,
    "synth_id_watermark": True,  # AI-Kennzeichnung
    "consistency_mode": "high"
}

Stärken für Kindergeschichten

✅ Charakterkonsistenz - Beste im Vergleich
✅ Multi-Image Fusion - Komplexe Szenen
✅ Konversationelles Editing - Iterative Verbesserung
✅ SynthID Watermarking - Transparente AI-Kennzeichnung
✅ Referenzbilder - Konsistente Charaktere

Einschränkungen

⚠️ Langsamer - 8-10 Sekunden pro Bild
⚠️ Höhere Kosten für Spezialfeatures
❌ Name verwirrt - Nicht nur für Bananen!

Kostenberechnung

10-seitige Geschichte: $0.39
100 Geschichten/Tag: $39
Monatliche Kosten (3000 Geschichten): $1170

Kostenvergleich

Übersichtstabelle

Modell	Preis/Bild	10-Seiten Story	100 Stories/Tag	3000 Stories/Monat
FLUX.1 Schnell	$0.003	$0.03	$3	$90
Google Imagen 4 Fast	$0.020	$0.20	$20	$600
Qwen Image	$0.025	$0.25	$25	$750
ByteDance Seedream-4	$0.030	$0.30	$30	$900
Ideogram V3 Turbo	$0.030	$0.30	$30	$900
SD 3.5 Medium	$0.035	$0.35	$35	$1050
Google Nano Banana	$0.039	$0.39	$39	$1170
FLUX.1.1 Pro	$0.040	$0.40	$40	$1200
SD 3.5 Large Turbo	$0.040	$0.40	$40	$1200
Google Imagen 4	$0.040	$0.40	$40	$1200

ROI-Analyse bei 10 Credits ($1) pro Geschichte

Modell	Kosten/Story	Gewinn/Story	Gewinnmarge
FLUX.1 Schnell	$0.03	$0.97	97%
Google Imagen 4 Fast	$0.20	$0.80	80%
Qwen Image	$0.25	$0.75	75%
ByteDance/Ideogram	$0.30	$0.70	70%
Premium Modelle	$0.40	$0.60	60%

Technische Spezifikationen

Hardware-Anforderungen

GPU-basierte Modelle (Schneller)

FLUX.1 Schnell: H100 GPU
Qwen Image: H100 GPU

CPU-basierte Modelle (Langsamer, aber skalierbar)

Alle anderen Modelle nutzen CPU-Infrastruktur
Vorteil: Bessere Verfügbarkeit bei hohem Volumen
Nachteil: 3-10x langsamere Generierung

Generierungsgeschwindigkeiten

Kategorie	Modelle	Zeit pro Bild	10-Seiten Story
Ultra-Schnell	FLUX Schnell	1-2 Sek	10-20 Sek
Schnell	Imagen 4 Fast, Qwen	2-5 Sek	20-50 Sek
Standard	Seedream, Ideogram, SD 3.5	5-10 Sek	50-100 Sek
Langsam	FLUX Pro, Nano Banana	8-15 Sek	80-150 Sek

Implementierungsempfehlungen

🎯 Empfohlene Strategie für MärchenZauber

Phase 1: Entwicklung & Testing

Modell: FLUX.1 Schnell

Kosten: $0.03/Story
Zweck: Schnelle Iterationen, Feature-Testing
Budget: $90/Monat für 3000 Test-Stories

// Entwicklungsumgebung
const DEV_MODEL = {
  id: 'flux-schnell',
  replicateId: 'black-forest-labs/flux-schnell:5599ed30...',
  costPerImage: 0.003,
  speed: 'ultra-fast',
};

Phase 2: Beta & Early Access

Modell: Google Imagen 4 Fast

Kosten: $0.20/Story
Zweck: Gute Qualität bei niedrigen Kosten
Budget: $600/Monat für 3000 Stories

// Beta-Umgebung
const BETA_MODEL = {
  id: 'imagen-4-fast',
  replicateId: 'google/imagen-4-fast:latest',
  costPerImage: 0.02,
  speed: 'fast',
  quality: 'good',
};

Phase 3: Produktion

Hauptmodell: ByteDance Seedream-4

Kosten: $0.30/Story
Zweck: 4K-Qualität mit Sequenz-Support
Features: Batch-Generierung, Konsistenz

Premium-Option: FLUX.1.1 Pro

Kosten: $0.40/Story
Zweck: Höchste Qualität für Premium-Nutzer
Features: Beste Prompt-Befolgung

// Produktionsumgebung
const PRODUCTION_MODELS = {
  standard: {
    id: 'seedream-4',
    replicateId: 'bytedance/seedream-4:latest',
    costPerImage: 0.03,
    features: ['4K', 'sequential', 'batch'],
  },
  premium: {
    id: 'flux-pro',
    replicateId: 'black-forest-labs/flux-1.1-pro:8f06b9d3...',
    costPerImage: 0.04,
    features: ['highest-quality', 'prompt-adherence'],
  },
};

🔄 Dynamisches Modell-Switching

class ImageModelSelector {
  selectModel(user, storyType) {
    // Entwickler/Tester
    if (user.role === 'developer') {
      return MODELS.FLUX_SCHNELL;
    }

    // Premium-Nutzer
    if (user.subscription === 'premium') {
      return MODELS.FLUX_PRO;
    }

    // Geschichten mit vielen Charakteren
    if (storyType.characterCount > 3) {
      return MODELS.NANO_BANANA; // Beste Konsistenz
    }

    // Geschichten mit Text-Integration
    if (storyType.includesText) {
      return MODELS.QWEN_IMAGE;
    }

    // Standard-Nutzer
    return MODELS.IMAGEN_4_FAST;
  }
}

API-Verwendungsbeispiele

Grundlegende Replicate-Integration

const Replicate = require('replicate');

class ReplicateImageService {
  constructor(apiKey) {
    this.client = new Replicate({
      auth: apiKey,
      useFileOutput: true,
    });
  }

  async generateStoryIllustration(prompt, modelConfig) {
    try {
      // Prompt-Optimierung für Kindergeschichten
      const enhancedPrompt = this.enhancePromptForChildren(prompt);

      // Modell-spezifische Parameter
      const input = this.prepareModelInput(enhancedPrompt, modelConfig);

      // Generierung
      const output = await this.client.run(modelConfig.replicateId, { input });

      // Nachbearbeitung
      return this.processOutput(output, modelConfig);
    } catch (error) {
      console.error('Generation failed:', error);
      return this.fallbackGeneration(prompt);
    }
  }

  enhancePromptForChildren(prompt) {
    const childrenKeywords = [
      'colorful',
      'friendly',
      'cartoon-style',
      'whimsical',
      'bright',
      'cheerful',
      'suitable for ages 3-8',
    ];

    return `${prompt}. Style: ${childrenKeywords.join(', ')}`;
  }

  prepareModelInput(prompt, modelConfig) {
    const baseInput = {
      prompt,
      output_format: 'jpg',
      output_quality: 95,
    };

    // Modell-spezifische Anpassungen
    switch (modelConfig.id) {
      case 'flux-schnell':
        return {
          ...baseInput,
          num_inference_steps: 4,
          go_fast: true,
        };

      case 'seedream-4':
        return {
          ...baseInput,
          resolution: '4K',
          sequential_mode: true,
          num_images: 10,
        };

      case 'imagen-4-fast':
        return {
          ...baseInput,
          aspect_ratio: '16:9',
          safety_filter_level: 'block_most',
          person_generation: 'dont_allow',
        };

      default:
        return baseInput;
    }
  }

  async fallbackGeneration(prompt) {
    // Fallback zu günstigstem Modell
    return this.client.run(MODELS.FLUX_SCHNELL.replicateId, {
      input: {
        prompt,
        go_fast: true,
        num_inference_steps: 4,
      },
    });
  }
}

Batch-Generierung für Geschichten

class StoryIllustrationService {
  async generateStoryIllustrations(story, modelId) {
    const model = this.getModelConfig(modelId);

    // Sequenzielle Modelle (Seedream-4)
    if (model.supportsSequential) {
      return this.generateSequential(story, model);
    }

    // Parallel-Generierung für andere Modelle
    return this.generateParallel(story, model);
  }

  async generateSequential(story, model) {
    // Seedream-4 kann alle 10 Seiten in einem Batch
    const prompts = story.pages.map((page) => this.createIllustrationPrompt(page, story.character));

    const output = await this.client.run(model.replicateId, {
      input: {
        prompt: prompts.join(' | '),
        num_images: prompts.length,
        sequential_mode: true,
        resolution: '4K',
      },
    });

    return this.processSequentialOutput(output, story);
  }

  async generateParallel(story, model) {
    // Parallele Generierung für maximale Geschwindigkeit
    const promises = story.pages.map((page) =>
      this.generateSingleIllustration(page, model, story.character)
    );

    // Limit concurrent requests
    const results = await this.batchProcess(promises, 3);
    return results;
  }

  async batchProcess(promises, batchSize) {
    const results = [];
    for (let i = 0; i < promises.length; i += batchSize) {
      const batch = promises.slice(i, i + batchSize);
      const batchResults = await Promise.all(batch);
      results.push(...batchResults);
    }
    return results;
  }
}

Charakterkonsistenz-Management

class CharacterConsistencyService {
  constructor() {
    this.characterCache = new Map();
  }

  async generateWithConsistency(prompt, character, modelId) {
    const model = this.getModelConfig(modelId);

    // Google Nano Banana - Beste Konsistenz
    if (model.id === 'nano-banana') {
      return this.generateWithNanoBanana(prompt, character);
    }

    // FLUX Pro mit Image-Prompt
    if (model.id === 'flux-pro') {
      return this.generateWithFluxPro(prompt, character);
    }

    // Qwen mit LoRA
    if (model.id === 'qwen-image') {
      return this.generateWithQwen(prompt, character);
    }

    // Standard-Ansatz
    return this.generateStandard(prompt, character, model);
  }

  async generateWithNanoBanana(prompt, character) {
    const characterRef = this.characterCache.get(character.id);

    return this.client.run('google/nano-banana:latest', {
      input: {
        prompt: `${character.description}. ${prompt}`,
        character_reference: characterRef?.imageUrl,
        consistency_mode: 'high',
        multi_image_fusion: true,
        conversation_history: characterRef?.history || [],
      },
    });
  }

  async generateWithFluxPro(prompt, character) {
    const characterRef = this.characterCache.get(character.id);

    return this.client.run(MODELS.FLUX_PRO.replicateId, {
      input: {
        prompt: `${character.description}. ${prompt}`,
        image_prompt: characterRef?.imageUrl,
        prompt_upsampling: true,
        safety_tolerance: 3,
      },
    });
  }

  cacheCharacterReference(characterId, imageUrl, metadata) {
    this.characterCache.set(characterId, {
      imageUrl,
      history: metadata.history || [],
      description: metadata.description,
      timestamp: Date.now(),
    });
  }
}

Best Practices für Kinderbücher

1. Prompt-Engineering für Kindergeschichten

class ChildrenPromptOptimizer {
  optimizePrompt(basePrompt, age_group = '3-8') {
    const styles = {
      '3-5': {
        keywords: ['simple', 'bright colors', 'large features', 'friendly faces'],
        avoid: ['complex backgrounds', 'small details', 'scary elements'],
      },
      '6-8': {
        keywords: ['detailed', 'adventure', 'magical', 'whimsical'],
        avoid: ['violent', 'dark', 'scary', 'inappropriate'],
      },
    };

    const style = styles[age_group] || styles['3-8'];

    // Basis-Optimierung
    let optimized = `${basePrompt}. `;
    optimized += `Style: ${style.keywords.join(', ')}. `;
    optimized += `Avoid: ${style.avoid.join(', ')}.`;

    // Modell-spezifische Anpassungen
    return this.addModelSpecificEnhancements(optimized);
  }

  addModelSpecificEnhancements(prompt) {
    // Für Imagen-Modelle
    if (this.currentModel.includes('imagen')) {
      prompt += ' Safety: maximum child-friendly content.';
    }

    // Für FLUX-Modelle
    if (this.currentModel.includes('flux')) {
      prompt += ' Render style: Pixar-like 3D cartoon.';
    }

    // Für Ideogram
    if (this.currentModel.includes('ideogram')) {
      prompt += ' Use style preset: cartoon_3d.';
    }

    return prompt;
  }
}

2. Sicherheitsfilter-Konfiguration

const SAFETY_CONFIGS = {
  'imagen-4': {
    safety_filter_level: 'block_most',
    person_generation: 'dont_allow',
  },
  'flux-pro': {
    safety_tolerance: 6, // Maximum (1-6 scale)
  },
  'stable-diffusion': {
    disable_safety_checker: false,
    negative_prompt: 'violence, scary, inappropriate, dark, horror',
  },
};

3. Qualitätsstufen-Management

class QualityTierManager {
  constructor() {
    this.tiers = {
      draft: {
        model: 'flux-schnell',
        cost: 0.003,
        quality: 'low',
        speed: 'ultra-fast',
        use_case: 'Prototyping, Testing',
      },
      standard: {
        model: 'imagen-4-fast',
        cost: 0.02,
        quality: 'good',
        speed: 'fast',
        use_case: 'Regular users, daily stories',
      },
      premium: {
        model: 'seedream-4',
        cost: 0.03,
        quality: 'excellent',
        speed: 'standard',
        use_case: 'Premium users, special stories',
      },
      professional: {
        model: 'flux-pro',
        cost: 0.04,
        quality: 'best',
        speed: 'slow',
        use_case: 'Print books, commercial use',
      },
    };
  }

  selectTier(user, story) {
    if (story.type === 'test') return this.tiers.draft;
    if (user.subscription === 'premium') return this.tiers.premium;
    if (story.forPrint) return this.tiers.professional;
    return this.tiers.standard;
  }
}

4. Fehlerbehandlung und Fallbacks

class RobustImageGeneration {
  async generateWithFallbacks(prompt, preferredModel) {
    const fallbackChain = [
      preferredModel,
      'imagen-4-fast', // Erster Fallback
      'flux-schnell', // Zweiter Fallback
      'qwen-image', // Letzter Fallback
    ];

    for (const modelId of fallbackChain) {
      try {
        const result = await this.tryGeneration(prompt, modelId);
        if (result.success) {
          return result;
        }
      } catch (error) {
        console.error(`Model ${modelId} failed:`, error);
        continue;
      }
    }

    // Wenn alles fehlschlägt
    throw new Error('All image generation models failed');
  }

  async tryGeneration(prompt, modelId) {
    const timeout = this.getTimeout(modelId);

    return Promise.race([this.generateImage(prompt, modelId), this.timeoutPromise(timeout)]);
  }

  getTimeout(modelId) {
    const timeouts = {
      'flux-schnell': 5000, // 5 Sekunden
      'imagen-4-fast': 10000, // 10 Sekunden
      'flux-pro': 20000, // 20 Sekunden
    };
    return timeouts[modelId] || 15000;
  }
}

Migration von aktuellen Modellen

Schritt-für-Schritt Migration

1. Aktuelle Situation

// Aktuell in MärchenZauber
const CURRENT_MODELS = {
  'flux-schnell': 'black-forest-labs/flux-schnell:5599ed30...',
  'flux-pro': 'black-forest-labs/flux-1.1-pro:8f06b9d3...',
  sdxl: 'stability-ai/sdxl:39ed52f2...',
};

2. Empfohlene Erweiterung

// Neue Modell-Konfiguration
const ENHANCED_MODELS = {
  // Bestehende Modelle behalten
  ...CURRENT_MODELS,

  // Neue Modelle hinzufügen
  'imagen-4-fast': {
    id: 'imagen-4-fast',
    name: 'Google Imagen 4 Fast',
    replicateId: 'google/imagen-4-fast:latest',
    costPerImage: 0.02,
    estimatedTime: '2-5 Sekunden',
    creditsPerImage: 2, // 20% der Story-Credits
    features: ['ultra-fast', 'cost-effective', 'safe'],
  },
  'seedream-4': {
    id: 'seedream-4',
    name: 'ByteDance Seedream 4K',
    replicateId: 'bytedance/seedream-4:latest',
    costPerImage: 0.03,
    estimatedTime: '5-10 Sekunden',
    creditsPerImage: 3,
    features: ['4K', 'sequential', 'batch-processing'],
  },
  'nano-banana': {
    id: 'nano-banana',
    name: 'Google Nano Banana Pro',
    replicateId: 'google/nano-banana:latest',
    costPerImage: 0.039,
    estimatedTime: '8-10 Sekunden',
    creditsPerImage: 4,
    features: ['character-consistency', 'multi-turn-editing'],
  },
};

3. Backend-Service Update

// image-supabase.service.ts Update
async generateImageWithReplicate(
  prompt: string,
  path: string,
  token?: string,
  userId?: string,
): Promise<Result<string>> {
  try {
    const modelConfig = this.settingsService.getModelConfig(userId);

    // Modell-spezifische Optimierungen
    const optimizedInput = this.optimizeForModel(
      prompt,
      modelConfig.id
    );

    // Erweiterte Fehlerbehandlung
    const result = await this.replicateClient.run(
      modelConfig.replicateId,
      { input: optimizedInput },
      {
        wait: {
          maxAttempts: 3,
          interval: 1000
        }
      }
    );

    return this.processResult(result, modelConfig);
  } catch (error) {
    // Automatischer Fallback
    return this.fallbackGeneration(prompt, path, token);
  }
}

optimizeForModel(prompt, modelId) {
  const optimizations = {
    'imagen-4-fast': {
      prompt: `${prompt}. Children's illustration style.`,
      aspect_ratio: '16:9',
      safety_filter_level: 'block_most'
    },
    'seedream-4': {
      prompt: `${prompt}. 4K quality children's book illustration.`,
      resolution: '4K',
      sequential_mode: true
    },
    'nano-banana': {
      prompt: `${prompt}. Consistent character design.`,
      consistency_mode: 'high',
      synth_id_watermark: true
    }
  };

  return optimizations[modelId] || { prompt };
}

Performance-Metriken und Monitoring

Tracking-System

class ModelPerformanceTracker {
  constructor() {
    this.metrics = new Map();
  }

  async trackGeneration(modelId, startTime, success, cost) {
    const duration = Date.now() - startTime;

    if (!this.metrics.has(modelId)) {
      this.metrics.set(modelId, {
        totalGenerations: 0,
        successCount: 0,
        failureCount: 0,
        totalDuration: 0,
        totalCost: 0,
        averageSpeed: 0,
        successRate: 0,
      });
    }

    const modelMetrics = this.metrics.get(modelId);
    modelMetrics.totalGenerations++;

    if (success) {
      modelMetrics.successCount++;
      modelMetrics.totalDuration += duration;
      modelMetrics.totalCost += cost;
    } else {
      modelMetrics.failureCount++;
    }

    // Berechne Durchschnittswerte
    modelMetrics.averageSpeed = modelMetrics.totalDuration / modelMetrics.successCount;
    modelMetrics.successRate = modelMetrics.successCount / modelMetrics.totalGenerations;

    // Log wichtige Ereignisse
    if (modelMetrics.successRate < 0.95) {
      console.warn(`Model ${modelId} success rate below 95%:`, modelMetrics.successRate);
    }

    return modelMetrics;
  }

  getBestPerformingModel() {
    let bestModel = null;
    let bestScore = 0;

    this.metrics.forEach((metrics, modelId) => {
      // Scoring: Balance zwischen Geschwindigkeit, Erfolgsrate und Kosten
      const score =
        metrics.successRate * 100 - metrics.averageSpeed / 1000 - metrics.totalCost * 10;

      if (score > bestScore) {
        bestScore = score;
        bestModel = modelId;
      }
    });

    return bestModel;
  }
}

Zusammenfassung und Nächste Schritte

Kernerkenntnisse

Kostenoptimierung: FLUX Schnell bietet mit $0.003/Bild die günstigste Option, während Google Imagen 4 Fast mit $0.02/Bild den besten Kompromiss zwischen Kosten und Qualität darstellt.
Qualitätsstufen: Für Produktionsqualität empfehlen sich ByteDance Seedream-4 (4K Support) oder FLUX.1.1 Pro (beste Prompt-Befolgung).
Spezialfeatures:
- Charakterkonsistenz: Google Nano Banana
- Text-Integration: Qwen Image
- Künstlerische Vielfalt: Ideogram V3 Turbo
- Sequenzielle Generierung: ByteDance Seedream-4

Empfohlene Implementierungsschritte

Kurzfristig (1-2 Wochen)

Integration von Google Imagen 4 Fast als kostengünstige Alternative
A/B-Testing zwischen aktuellen und neuen Modellen
Performance-Tracking implementieren

Mittelfristig (1 Monat)

Dynamisches Modell-Switching basierend auf User-Tier
Seedream-4 für Premium-Features integrieren
Fallback-Kette erweitern

Langfristig (3 Monate)

ML-basierte Modellauswahl
Custom LoRA Training für Charakterkonsistenz
Eigene Qualitätsbewertung entwickeln

Geschäftsmodell-Optimierung

Bei aktuellem Preis von 10 Credits ($1) pro Geschichte:

Strategie	Modell-Mix	Kosten/Story	Gewinn/Story	Marge
Budget	100% Imagen Fast	$0.20	$0.80	80%
Balanced	70% Imagen, 30% Seedream	$0.23	$0.77	77%
Premium	50% Seedream, 50% FLUX Pro	$0.35	$0.65	65%
Entwicklung	100% FLUX Schnell	$0.03	$0.97	97%

Technische Optimierungen

Caching: Häufige Charaktere/Szenen zwischenspeichern
Batch-Processing: Mehrere Seiten gleichzeitig generieren
Preemptive Generation: Nächste Seiten während des Lesens generieren
CDN-Integration: Generierte Bilder global verteilen

Diese umfassende Dokumentation bietet eine solide Grundlage für die strategische Entscheidung bezüglich der Bildgenerierungsmodelle in MärchenZauber. Die Empfehlungen berücksichtigen sowohl technische als auch geschäftliche Aspekte und ermöglichen eine skalierbare, kosteneffiziente Lösung.

35 KiB Raw Blame History

Umfassende Dokumentation der Replicate Image Models für MärchenZauber

Inhaltsverzeichnis

Executive Summary

Detaillierte Modellanalyse

1. 🚀 Google Imagen 4 Fast

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

2. 🎨 ByteDance Seedream-4

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

3. 🎭 Ideogram V3 Turbo

Technische Details

Input-Parameter

Verfügbare Stile für Kinderbücher

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

4. 📝 Qwen Image

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

5. ⚡ FLUX.1 Schnell

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

6. 💎 FLUX.1.1 Pro

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

7. 🏃 Stable Diffusion 3.5 Large Turbo

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

8. 🌟 Google Imagen 4 (Standard)

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

9. ⚖️ Stable Diffusion 3.5 Medium

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

10. 🍌 Google Nano Banana

Technische Details

Input-Parameter

Stärken für Kindergeschichten

Einschränkungen

Kostenberechnung

Kostenvergleich

Übersichtstabelle

ROI-Analyse bei 10 Credits ($1) pro Geschichte

Technische Spezifikationen

Hardware-Anforderungen

GPU-basierte Modelle (Schneller)

CPU-basierte Modelle (Langsamer, aber skalierbar)

Generierungsgeschwindigkeiten

Implementierungsempfehlungen

🎯 Empfohlene Strategie für MärchenZauber

Phase 1: Entwicklung & Testing

Phase 2: Beta & Early Access

Phase 3: Produktion

🔄 Dynamisches Modell-Switching

35 KiB

Raw Blame History