Upload 27 files

.env.example

@@ -0,0 +1,20 @@
+# OpenAI API Key
+OPENAI_API_KEY=sk-your-key-here
+
+# OpenAI Model (optional, defaults to gpt-4o-mini)
+# Options: gpt-4o-mini, gpt-3.5-turbo, gpt-4, gpt-4-turbo
+OPENAI_MODEL=gpt-4o-mini
+
+HUGGINGFACE_TOKEN=hf_your-token-here
+ELEVENLABS_API_KEY=your-key-here
+GEMINI_API_KEY=your-key-here
+MODAL_TOKEN=your-token-here
+SAMBANOVA_API_KEY=your-key-here
+NEBIUS_API_KEY=your-key-here
+BLAXEL_API_KEY=blx_your-key-here
+
+# Comic Mode Feature Flags (Step 1)
+ENABLE_COMIC_MODE=false
+ENABLE_BLAXEL=false
+ENABLE_MODAL=false
+ENABLE_SAMBANOVA=false

.gitignore

@@ -0,0 +1,23 @@
+.env
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+venv/
+env/
+.venv/
+gradio_cached_examples/
+flagged/
+*.log
+.DS_Store
+
+
+.venvCartoonProject/
+
+

README.md

@@ -1,14 +1,152 @@
 ---
-title: Mythforge Comic Generator
-emoji: 🦀
-colorFrom: purple
+title: MythForge AI Comic Generator
+emoji: 📚
+colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: 6.0.1
+sdk_version: 6.0.0
 app_file: app.py
 pinned: false
-license: apache-2.0
-short_description: Transform text into professional manga comics
+tags:
+  - mcp-in-action-track-creative
+  - mcp-in-action-track-consumer
+  - comic-generation
+  - manga
+  - ai-art
+  - storytelling
+  - multimodal
+  - gradio
+  - mcp
+  - agents
+  - openai
+  - gemini
+  - modal
+  - elevenlabs
+  - llamaindex
+  - blaxel
+  - anthropic
+  - sambanova
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 📚 MythForge AI Comic Generator
+
+**Create professional manga-style comics with AI-powered storytelling, image generation, and voice narration!**
+
+> 🎉 **Submission for MCP's 1st Birthday Hackathon - Track 2: MCP in Action (Creative)**
+
+## 🎥 Demo Video
+
+[Add your demo video link here - YouTube, Loom, or direct upload]
+
+## 📢 Social Media
+
+[Add your social media post link here - Twitter/X, LinkedIn, etc.]
+
+## ✨ What It Does
+
+MythForge AI transforms your story ideas into complete 6-panel manga comics with:
+- **AI Story Generation**: GPT-4o-mini crafts engaging narratives with character development
+- **Character Consistency**: Gemini Pro ensures characters look the same across all panels
+- **Professional Art**: SDXL generates high-quality 1024×1024 manga-style images
+- **Voice Narration**: ElevenLabs provides diverse character voices for each panel
+- **Character Memory**: **MCP-powered LlamaIndex** maintains character consistency across stories
+- **Multiple Export Formats**: PDF, ZIP package, or interactive web viewer
+
+## 🤖 MCP Integration
+
+This application demonstrates **MCP in Action** by using the Model Context Protocol for:
+- **Character Memory & RAG**: LlamaIndex MCP server maintains persistent character profiles and story context
+- **Autonomous Agent Behavior**: The system autonomously plans story arcs, maintains character consistency, and orchestrates multiple AI services
+- **Multi-Provider Orchestration**: Blaxel framework coordinates between OpenAI, Gemini, Modal, and ElevenLabs
+
+## 🏗️ Architecture
+
+```
+User Prompt → Story Generation (GPT-4o-mini + SambaNova fallback)
+           ↓
+Character Analysis (Gemini 2.5 Flash) → MCP Character Memory (LlamaIndex)
+           ↓
+Image Generation (Modal SDXL) → Character Consistency Check (Gemini Pro)
+           ↓
+Audio Generation (ElevenLabs TTS)
+           ↓
+Comic Assembly (2x3 Grid Layout)
+```
+
+## 🛠️ Built With
+
+- **OpenAI**: GPT-4o-mini (Primary Story Generation), GPT-4o (Dynamic Prompt Examples)
+- **Gemini**: 3 Pro Image (Character Consistency), 2.5 Flash (Vision), 2.0 Flash (Intelligence)
+- **Modal**: SDXL (Panel Image Generation)
+- **ElevenLabs**: TTS with 9 Diverse Voices
+- **LlamaIndex**: Character Memory & RAG via MCP
+- **Blaxel**: Multi-Provider Orchestration Framework
+- **Claude Code**: Autonomous Development & Debugging
+- **SambaNova**: Llama 3.3 70B (Story Fallback)
+- **Gradio**: v6 UI Framework
+
+## 🚀 Features
+
+### Story Creation
+- Dynamic prompt examples generated by GPT-4o
+- Multiple visual styles (anime, manga, comic, webcomic)
+- Optional speech bubbles and audio narration
+
+### Character Consistency
+- MCP-powered character memory across multiple stories
+- Gemini Pro vision analysis for visual consistency
+- Persistent character profiles using LlamaIndex RAG
+
+### Professional Output
+- 2148×3192 full manga page (2x3 grid)
+- Individual 1024×1024 panel images
+- Synchronized audio narration for each panel
+- Export as PDF, ZIP, or interactive HTML
+
+## 📦 Installation
+
+```bash
+# Clone the repository
+git clone https://huggingface.co/spaces/YOUR_USERNAME/mythforge-comic-generator
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Set up environment variables
+cp .env.example .env
+# Add your API keys to .env
+```
+
+## 🔑 Required API Keys
+
+- `OPENAI_API_KEY`: For GPT-4o story generation
+- `GEMINI_API_KEY`: For character consistency analysis
+- `ELEVENLABS_API_KEY`: For voice narration
+- `MODAL_TOKEN_ID` & `MODAL_TOKEN_SECRET`: For SDXL image generation
+
+## 💡 Usage
+
+1. Enter your story idea or use AI-generated examples
+2. Select your preferred visual style
+3. Choose whether to include audio and speech bubbles
+4. Click "Generate Comic"
+5. Download your comic in your preferred format
+
+## 🎯 MCP Use Case
+
+This project showcases MCP's power in creative applications by:
+- **Context Engineering**: Maintaining character profiles and story context across sessions
+- **Autonomous Planning**: Orchestrating multiple AI services without manual intervention
+- **Tool Integration**: Using MCP servers as intelligent tools for character memory
+
+## 👥 Team
+
+- [Your HuggingFace Username]
+
+## 📄 License
+
+[Specify your license - MIT, Apache 2.0, etc.]
+
+## 🙏 Acknowledgments
+
+Built for MCP's 1st Birthday Hackathon hosted by Anthropic and Gradio.

app.py

@@ -1,7 +1,19 @@
-import gradio as gr
+"""
+MythForge AI - Comic Generator
+Hugging Face Spaces Entry Point
 
-def greet(name):
-    return "Hello " + name + "!!"
+This file imports and launches the Gradio app from app_comic.py
+Required for Hugging Face Spaces deployment (must be named app.py)
+"""
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+from app_comic import demo
+
+if __name__ == "__main__":
+    print("📚 Starting MythForge Comic Generator (Hugging Face Spaces)...")
+    
+    # Launch with Hugging Face Spaces compatible settings
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,  # Default Hugging Face port
+        share=False
+    )

app_comic.py

@@ -0,0 +1,1192 @@
+"""MythForge AI - Comic Generator Application (Gradio 6)"""
+import gradio as gr
+import asyncio
+import tempfile
+import os
+import json
+from datetime import datetime
+from typing import Dict, List, Optional
+from PIL import Image
+
+from config import Config
+from sambanova_generator import SambanovaGenerator
+from audio_generator import AudioGenerator
+from comic_layout import ComicLayout
+from speech_bubble_overlay import SpeechBubbleOverlay
+from export_service import ExportService
+from modal_image_generator import ModalImageGenerator
+
+# New sponsor integrations
+try:
+    from story_memory import StoryMemory
+    LLAMAINDEX_AVAILABLE = True
+except ImportError:
+    LLAMAINDEX_AVAILABLE = False
+    print("⚠️  LlamaIndex not available - character memory disabled")
+
+try:
+    from multimodal_analyzer import MultimodalAnalyzer
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+    print("⚠️  Gemini analyzer not available - image verification disabled")
+
+try:
+    from blaxel_agent import BlaxelComicAgent
+    BLAXEL_AVAILABLE = True
+except ImportError:
+    BLAXEL_AVAILABLE = False
+    print("⚠️  Blaxel agent not available - orchestration disabled")
+
+# MCP Memory Client (optional, for memory operations via MCP)
+try:
+    from mythforge_mcp_memory_client import get_mcp_memory_client
+    MCP_MEMORY_AVAILABLE = True
+except ImportError:
+    MCP_MEMORY_AVAILABLE = False
+    print("⚠️  MCP Memory Client not available - using direct LlamaIndex")
+
+# Feature flags
+ENABLE_COMIC_MODE = Config.ENABLE_COMIC_MODE
+ENABLE_SAMBANOVA = Config.ENABLE_SAMBANOVA
+ENABLE_MODAL = Config.ENABLE_MODAL
+
+
+class ComicGeneratorApp:
+    """Comic Generator Gradio Application"""
+
+    def __init__(self):
+        """Initialize comic generator components"""
+        # Core generators
+        self.sambanova_gen = SambanovaGenerator() if ENABLE_SAMBANOVA else None
+        self.modal_gen = ModalImageGenerator() if ENABLE_MODAL else None
+        self.audio_gen = AudioGenerator()
+        self.layout = ComicLayout()
+        self.bubble_overlay = SpeechBubbleOverlay()
+        self.export_service = ExportService()
+
+        # New sponsor integrations
+        # Use MCP for memory if enabled, otherwise use direct LlamaIndex
+        self.mcp_memory_client = None
+        if Config.ENABLE_MCP and MCP_MEMORY_AVAILABLE:
+            self.mcp_memory_client = get_mcp_memory_client()
+            if self.mcp_memory_client:
+                print("📡 Using MCP for story memory operations")
+                self.story_memory = None  # Don't use direct LlamaIndex
+            else:
+                # Fallback to direct LlamaIndex
+                self.story_memory = StoryMemory() if LLAMAINDEX_AVAILABLE else None
+        else:
+            # Use direct LlamaIndex (existing behavior)
+            self.story_memory = StoryMemory() if LLAMAINDEX_AVAILABLE else None
+        
+        self.multimodal_analyzer = MultimodalAnalyzer() if GEMINI_AVAILABLE else None
+        self.blaxel_agent = BlaxelComicAgent() if BLAXEL_AVAILABLE else None
+
+        # OpenAI fallback (uses existing dependency)
+        try:
+            from openai import OpenAI
+            self.openai_client = OpenAI(api_key=Config.OPENAI_API_KEY)
+            self.openai_available = True
+        except Exception as e:
+            print(f"⚠️  OpenAI not available: {e}")
+            self.openai_client = None
+            self.openai_available = False
+
+    async def generate_comic_async(
+        self,
+        prompt: str,
+        style: str = "manga",
+        include_audio: bool = True,
+        include_bubbles: bool = True,
+        progress=None
+    ):
+        """Generate complete comic with all features"""
+
+        if not prompt or len(prompt.strip()) < 10:
+            raise ValueError("Please enter a story prompt (at least 10 characters)")
+
+        # Extract style name if it contains description (e.g., "manga - Japanese...")
+        if " - " in style:
+            style = style.split(" - ")[0].strip()
+
+        outputs = {
+            "story_data": None,
+            "panel_images": [],
+            "manga_page": None,
+            "audio_files": [],
+            "metadata": {}
+        }
+
+        try:
+            # Fork: Use Blaxel workflow orchestration or direct API calls
+            if Config.ENABLE_BLAXEL_WORKFLOW and self.blaxel_agent:
+                print("🔀 Using Blaxel workflow orchestration...")
+                try:
+                    return await self._generate_with_blaxel_workflow(
+                        prompt=prompt,
+                        style=style,
+                        include_audio=include_audio,
+                        include_bubbles=include_bubbles,
+                        progress=progress
+                    )
+                except Exception as e:
+                    print(f"⚠️  Blaxel workflow failed: {e}")
+                    print("🔄 Falling back to direct API calls...")
+                    # Continue with direct API calls below
+
+            # Step 1: Generate story with SambaNova (or fallback)
+            if progress:
+                progress(0.1, desc="✍️ Writing story with AI...")
+
+            # Retrieve context from LlamaIndex memory for character consistency
+            context_prompt = prompt
+            if self.mcp_memory_client:
+                # Use MCP for memory retrieval
+                try:
+                    context = self.mcp_memory_client.retrieve_context_sync(prompt, top_k=3)
+                    if context and context != "No stories in memory yet." and "Error" not in context:
+                        context_prompt = f"{prompt}\n\nPrevious story context:\n{context}"
+                        print(f"📚 Retrieved character context via MCP")
+                except Exception as e:
+                    print(f"⚠️  MCP memory retrieval failed: {e}")
+                    context_prompt = prompt
+            elif self.story_memory:
+                # Use direct LlamaIndex (existing behavior)
+                try:
+                    context = self.story_memory.retrieve_context(prompt, top_k=3)
+                    if context and context != "No stories in memory yet.":
+                        context_prompt = f"{prompt}\n\nPrevious story context:\n{context}"
+                        print(f"📚 Retrieved character context from LlamaIndex")
+                except Exception as e:
+                    print(f"⚠️  Memory retrieval failed: {e}")
+                    context_prompt = prompt
+
+
+            # Adaptive text generation: OpenAI first (for $1k prize) or SambaNova first
+            story_data = None
+
+            if Config.USE_OPENAI_PRIMARY:
+                # Primary: OpenAI GPT-4o-mini ($1,000 API credits prize)
+                if self.openai_available:
+                    try:
+                        print("🎯 Generating story with OpenAI GPT-4o-mini...")
+                        story_data = await self._generate_with_openai(context_prompt, style)
+                        print("✅ Story generated with OpenAI")
+                    except Exception as e:
+                        print(f"⚠️  OpenAI failed: {e}")
+                        story_data = None
+
+                # Fallback: SambaNova
+                if not story_data and self.sambanova_gen and ENABLE_SAMBANOVA:
+                    try:
+                        print("🔄 Falling back to SambaNova...")
+                        story_data = self.sambanova_gen.generate_comic_story(
+                            prompt=context_prompt,
+                            panel_count=6,
+                            style=style
+                        )
+                        print("✅ Story generated with SambaNova")
+                    except Exception as e:
+                        print(f"⚠️  SambaNova fallback failed: {e}")
+                        story_data = None
+            else:
+                # Primary: SambaNova Llama 3.3 70B
+                if self.sambanova_gen and ENABLE_SAMBANOVA:
+                    try:
+                        print("🎯 Generating story with SambaNova Llama 3.3 70B...")
+                        story_data = self.sambanova_gen.generate_comic_story(
+                            prompt=context_prompt,
+                            panel_count=6,
+                            style=style
+                        )
+                        print("✅ Story generated with SambaNova")
+                    except Exception as e:
+                        print(f"⚠️  SambaNova failed: {e}")
+                        story_data = None
+
+                # Fallback: OpenAI
+                if not story_data and self.openai_available:
+                    try:
+                        print("🔄 Falling back to OpenAI GPT-4o-mini...")
+                        story_data = await self._generate_with_openai(context_prompt, style)
+                        print("✅ Story generated with OpenAI")
+                    except Exception as e:
+                        print(f"⚠️  OpenAI fallback failed: {e}")
+                        story_data = None
+
+            # Final fallback: Simple placeholder
+            if not story_data:
+                print("⚠️  Using placeholder story")
+                story_data = self._create_fallback_story(prompt, style)
+
+            outputs["story_data"] = story_data
+            outputs["metadata"] = {
+                "title": story_data.get("title", "MythForge Comic"),
+                "prompt": prompt,
+                "style": style,
+                "timestamp": datetime.now().isoformat(),
+                "panel_count": len(story_data["panels"])
+            }
+
+            # Step 2: Generate panel images with Modal SDXL
+            if progress:
+                progress(0.3, desc="🎨 Generating panel artwork with SDXL...")
+
+            # Use Modal SDXL if enabled, otherwise use placeholders
+            if self.modal_gen and self.modal_gen.enabled:
+                panel_images = await self.modal_gen.generate_comic_panels(
+                    panels_data=story_data["panels"],
+                    style=style,
+                    num_inference_steps=25
+                )
+            else:
+                if progress:
+                    progress(0.3, desc="🎨 Creating placeholder panels...")
+                panel_images = self._create_placeholder_panels(story_data["panels"])
+
+            outputs["panel_images"] = panel_images
+
+            # Step 2.5: Verify image quality with Gemini (if enabled)
+            if self.multimodal_analyzer and self.multimodal_analyzer.enabled:
+                if progress:
+                    progress(0.4, desc="🔍 Verifying panel quality with Gemini...")
+                try:
+                    quality_scores = []
+                    for i, panel_img in enumerate(panel_images):
+                        score = await self.multimodal_analyzer.analyze_panel_quality(
+                            panel_img,
+                            story_data["panels"][i]
+                        )
+                        quality_scores.append(score)
+
+                    avg_quality = sum(quality_scores) / len(quality_scores) if quality_scores else 0
+                    print(f"✅ Gemini quality score: {avg_quality:.2f}/10")
+                    outputs["quality_score"] = avg_quality
+                except Exception as e:
+                    print(f"⚠️  Gemini verification failed: {e}")
+
+            # Step 3: Add speech bubbles
+            if include_bubbles and progress:
+                progress(0.5, desc="💬 Adding speech bubbles...")
+
+            if include_bubbles:
+                panel_images_with_bubbles = []
+                for i, (panel_img, panel_data) in enumerate(zip(panel_images, story_data["panels"])):
+                    dialogue = panel_data.get("dialogue", "")
+                    character = panel_data.get("character_name", "")
+
+                    if dialogue:
+                        # Determine position based on panel number
+                        position = "top" if i < 2 else ("middle" if i < 4 else "bottom")
+                        panel_with_bubble = self.bubble_overlay.add_dialogue_to_panel(
+                            panel_img.copy(),
+                            dialogue,
+                            character,
+                            position
+                        )
+                        panel_images_with_bubbles.append(panel_with_bubble)
+                    else:
+                        panel_images_with_bubbles.append(panel_img)
+
+                panel_images = panel_images_with_bubbles
+                outputs["panel_images"] = panel_images
+
+            # Step 4: Create manga layout
+            if progress:
+                progress(0.6, desc="📖 Creating manga page layout...")
+
+            manga_page = self.layout.create_manga_page(panel_images, layout="2x3")
+            outputs["manga_page"] = manga_page
+
+            # Step 5: Generate audio (intro + panels + conclusion)
+            if include_audio and progress:
+                progress(0.8, desc="🎤 Generating audio tracks...")
+
+            if include_audio:
+                # Create persistent temp directory for audio files (prefix to avoid cleanup)
+                temp_dir = tempfile.mkdtemp(prefix="mythforge_audio_")
+
+                # Generate introduction track (Track 0)
+                intro_path = f"{temp_dir}/intro_audio.mp3"
+                characters = list(set([p.get("character_name", "Character") for p in story_data["panels"] if p.get("character_name")]))
+                await self.audio_gen.generate_introduction(
+                    story_prompt=prompt,
+                    story_title=story_data.get("title", "Comic Story"),
+                    characters=characters,
+                    output_path=intro_path
+                )
+                print(f"✅ Generated introduction audio: {intro_path}")
+
+                # Generate panel audio (Tracks 1-6)
+                audio_files = await self.audio_gen.generate_comic_audio(
+                    panels=story_data["panels"],
+                    output_dir=temp_dir
+                )
+
+                # Generate conclusion track (Track 7)
+                conclusion_path = f"{temp_dir}/conclusion_audio.mp3"
+                await self.audio_gen.generate_conclusion(
+                    story_title=story_data.get("title", "Comic Story"),
+                    panels=story_data["panels"],
+                    output_path=conclusion_path
+                )
+                print(f"✅ Generated conclusion audio: {conclusion_path}")
+
+                # Combine all audio: intro + panels + conclusion
+                all_audio_files = [intro_path] + audio_files + [conclusion_path]
+
+                # Store the temp directory path so it persists
+                outputs["audio_temp_dir"] = temp_dir
+                outputs["audio_files"] = all_audio_files
+                outputs["intro_audio"] = intro_path
+                outputs["conclusion_audio"] = conclusion_path
+
+            # Step 6: Store story in LlamaIndex memory for future context
+            if self.mcp_memory_client:
+                # Use MCP for memory storage
+                try:
+                    # Convert story_data to text for storage
+                    story_text = f"Title: {story_data.get('title', 'Untitled')}\n\n"
+                    for panel in story_data.get("panels", []):
+                        story_text += f"Panel {panel.get('panel_number', '?')}: "
+                        story_text += f"{panel.get('scene_description', '')} "
+                        story_text += f"{panel.get('dialogue', '')}\n"
+
+                    self.mcp_memory_client.store_story_sync(
+                        story_text=story_text,
+                        metadata={"prompt": prompt, "style": style}
+                    )
+                    print("✅ Story stored via MCP for future context")
+                except Exception as e:
+                    print(f"⚠️  MCP memory storage failed: {e}")
+            elif self.story_memory:
+                # Use direct LlamaIndex (existing behavior)
+                try:
+                    # Convert story_data to text for storage
+                    story_text = f"Title: {story_data.get('title', 'Untitled')}\n\n"
+                    for panel in story_data.get("panels", []):
+                        story_text += f"Panel {panel.get('panel_number', '?')}: "
+                        story_text += f"{panel.get('scene_description', '')} "
+                        story_text += f"{panel.get('dialogue', '')}\n"
+
+                    self.story_memory.store_story(
+                        story_text=story_text,
+                        metadata={"prompt": prompt, "style": style}
+                    )
+                    print("✅ Story stored in LlamaIndex memory for future context")
+                except Exception as e:
+                    print(f"⚠️  Memory storage failed: {e}")
+
+            if progress:
+                progress(1.0, desc="✅ Comic complete!")
+
+            return outputs
+
+        except Exception as e:
+            print(f"Error generating comic: {e}")
+            raise
+
+    def _create_fallback_story(self, prompt: str, style: str):
+        """Create fallback story data when SambaNova unavailable"""
+        return {
+            "title": "Adventure Story",
+            "panels": [
+                {
+                    "panel_number": i + 1,
+                    "scene_description": f"Scene {i+1}: {prompt[:50]}...",
+                    "dialogue": f"Panel {i+1} dialogue about the adventure",
+                    "character_name": "Hero" if i % 2 == 0 else "Guide",
+                    "action": f"Action happening in panel {i+1}"
+                }
+                for i in range(6)
+            ]
+        }
+
+    async def _generate_with_openai(self, prompt: str, style: str) -> Dict:
+        """
+        Generate comic story using OpenAI GPT-4 as fallback
+
+        Args:
+            prompt: Story prompt with optional LlamaIndex context
+            style: Visual style (manga, shonen, etc.)
+
+        Returns:
+            Dict with same structure as SambaNova (title, panels)
+        """
+        if not self.openai_client:
+            raise RuntimeError("OpenAI client not initialized")
+
+        system_prompt = f"""You are a creative comic story writer specializing in {style} style.
+Generate a complete 6-panel comic story with:
+1. Engaging narrative suitable for visual storytelling
+2. Clear scene descriptions for each panel
+3. Character dialogue in speech bubble format
+4. Action and emotion cues for illustrations
+
+Format your response as JSON with this structure:
+{{
+  "title": "Story Title",
+  "panels": [
+    {{
+      "panel_number": 1,
+      "scene_description": "Detailed visual description",
+      "dialogue": "Character: What they say",
+      "action": "What's happening"
+    }},
+    ...
+  ]
+}}"""
+
+        user_prompt = f"""Create a 6-panel {style} comic story based on this prompt:
+
+"{prompt}"
+
+Make it visually dynamic with clear scenes for each panel. Include character dialogue."""
+
+        try:
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.8,
+                max_tokens=2000,
+                response_format={"type": "json_object"}
+            )
+
+            # Parse JSON response
+            content = response.choices[0].message.content
+            story_data = json.loads(content)
+
+            # Ensure all panels have required fields
+            for panel in story_data.get("panels", []):
+                if "character_name" not in panel:
+                    # Extract character name from dialogue
+                    dialogue = panel.get("dialogue", "")
+                    if ":" in dialogue:
+                        panel["character_name"] = dialogue.split(":")[0].strip()
+                    else:
+                        panel["character_name"] = "Narrator"
+
+            print(f"💰 OpenAI cost: ~${response.usage.total_tokens * 0.0000015:.4f}")
+            return story_data
+
+        except Exception as e:
+            raise RuntimeError(f"OpenAI generation failed: {e}")
+
+    async def _generate_with_blaxel_workflow(
+        self,
+        prompt: str,
+        style: str,
+        include_audio: bool,
+        include_bubbles: bool,
+        progress=None
+    ) -> Dict:
+        """
+        Generate comic using Blaxel workflow orchestration
+
+        This method uses Blaxel to orchestrate all AI services (SambaNova, Modal, ElevenLabs)
+        in a single workflow, providing unified cost tracking and error handling.
+
+        Args:
+            prompt: User's story prompt
+            style: Visual style
+            include_audio: Whether to generate audio
+            include_bubbles: Whether to add speech bubbles
+            progress: Gradio progress callback
+
+        Returns:
+            Complete outputs dict with story, images, audio, etc.
+        """
+        if not self.blaxel_agent:
+            raise RuntimeError("Blaxel agent not initialized")
+
+        if progress:
+            progress(0.1, desc="🔀 Orchestrating workflow with Blaxel...")
+
+        # Call Blaxel orchestration
+        result = await self.blaxel_agent.generate_comic_orchestrated(
+            prompt=prompt,
+            style=style,
+            include_audio=include_audio
+        )
+
+        # Extract results from Blaxel response
+        story_generation = result.get("story_generation", {})
+        image_generation = result.get("image_generation", {})
+        audio_generation = result.get("audio_generation", {})
+
+        # Convert Blaxel format to our app format
+        story_data = story_generation
+        panel_images = image_generation.get("images", [])
+        audio_files = audio_generation.get("files", []) if include_audio else []
+
+        if progress:
+            progress(0.6, desc="📖 Creating manga layout...")
+
+        # Create manga layout
+        manga_page = self.layout.create_manga_page(panel_images, layout="2x3")
+
+        # Add speech bubbles if requested
+        if include_bubbles:
+            if progress:
+                progress(0.7, desc="💬 Adding speech bubbles...")
+
+            panel_images_with_bubbles = []
+            for i, (panel_img, panel_data) in enumerate(zip(panel_images, story_data["panels"])):
+                dialogue = panel_data.get("dialogue", "")
+                character = panel_data.get("character_name", "")
+
+                if dialogue:
+                    position = "top" if i < 2 else ("middle" if i < 4 else "bottom")
+                    panel_with_bubble = self.bubble_overlay.add_dialogue_to_panel(
+                        panel_img.copy(),
+                        dialogue,
+                        character,
+                        position
+                    )
+                    panel_images_with_bubbles.append(panel_with_bubble)
+                else:
+                    panel_images_with_bubbles.append(panel_img)
+
+            panel_images = panel_images_with_bubbles
+
+        # Store in LlamaIndex memory
+        if self.mcp_memory_client:
+            try:
+                # Convert story_data to text for storage
+                story_text = f"Title: {story_data.get('title', 'Untitled')}\n\n"
+                for panel in story_data.get("panels", []):
+                    story_text += f"Panel {panel.get('panel_number', '?')}: "
+                    story_text += f"{panel.get('scene_description', '')} "
+                    story_text += f"{panel.get('dialogue', '')}\n"
+                
+                self.mcp_memory_client.store_story_sync(
+                    story_text=story_text,
+                    metadata={"prompt": prompt, "style": style}
+                )
+                print("✅ Story stored via MCP")
+            except Exception as e:
+                print(f"⚠️  MCP memory storage failed: {e}")
+        elif self.story_memory:
+            try:
+                await self.story_memory.store_story(
+                    story_data=story_data,
+                    prompt=prompt,
+                    style=style
+                )
+                print("✅ Story stored in LlamaIndex memory")
+            except Exception as e:
+                print(f"⚠️  Memory storage failed: {e}")
+
+        # Print Blaxel cost tracking
+        workflow_id = result.get("workflow_id")
+        if workflow_id:
+            try:
+                costs = self.blaxel_agent.get_cost_report(workflow_id)
+                print(f"💰 Blaxel total cost: ${costs.get('total_cost', 0):.4f}")
+            except:
+                pass
+
+        return {
+            "story_data": story_data,
+            "panel_images": panel_images,
+            "manga_page": manga_page,
+            "audio_files": audio_files,
+            "metadata": {
+                "title": story_data.get("title", "MythForge Comic"),
+                "prompt": prompt,
+                "style": style,
+                "timestamp": datetime.now().isoformat(),
+                "panel_count": len(story_data["panels"]),
+                "workflow": "blaxel_orchestrated"
+            }
+        }
+
+    def _create_placeholder_panels(self, panels_data):
+        """Create placeholder panel images (until Modal SDXL integrated)"""
+        from PIL import ImageDraw, ImageFont
+
+        panel_images = []
+        colors = [
+            (255, 200, 200),  # Light red
+            (200, 255, 200),  # Light green
+            (200, 200, 255),  # Light blue
+            (255, 255, 200),  # Light yellow
+            (255, 200, 255),  # Light magenta
+            (200, 255, 255)   # Light cyan
+        ]
+
+        for i, panel_data in enumerate(panels_data):
+            # Create colored panel with gradient border
+            panel = Image.new('RGB', (1024, 1024), color=colors[i])
+            draw = ImageDraw.Draw(panel)
+
+            # Add decorative border
+            border_width = 10
+            draw.rectangle(
+                [border_width, border_width, 1024-border_width, 1024-border_width],
+                outline=(0, 0, 0),
+                width=border_width
+            )
+
+            # Panel number (large and prominent)
+            panel_num_text = f"PANEL {i+1}"
+
+            # Try to load a larger font, fallback to default
+            try:
+                # Try to use a system font at larger size
+                font_large = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", 80)
+                font_medium = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", 40)
+                font_small = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", 24)
+            except:
+                # Fallback to default (will be smaller)
+                font_large = ImageFont.load_default()
+                font_medium = ImageFont.load_default()
+                font_small = ImageFont.load_default()
+
+            # Draw panel number at top
+            bbox = draw.textbbox((512, 150), panel_num_text, font=font_large, anchor='mm')
+            draw.rectangle(bbox, fill=(255, 255, 255, 180))
+            draw.text((512, 150), panel_num_text, fill=(0, 0, 0), anchor='mm', font=font_large)
+
+            # Draw scene description (wrapped)
+            scene = panel_data.get("scene_description", "Scene description")
+            # Wrap text to fit width
+            words = scene.split()
+            lines = []
+            current_line = []
+            for word in words:
+                current_line.append(word)
+                test_line = ' '.join(current_line)
+                if len(test_line) > 35:  # Roughly 35 chars per line
+                    if len(current_line) > 1:
+                        current_line.pop()
+                        lines.append(' '.join(current_line))
+                        current_line = [word]
+                    else:
+                        lines.append(test_line)
+                        current_line = []
+            if current_line:
+                lines.append(' '.join(current_line))
+
+            # Draw wrapped text
+            y_pos = 400
+            for line in lines[:4]:  # Max 4 lines
+                draw.text((512, y_pos), line, fill=(20, 20, 20), anchor='mm', font=font_medium)
+                y_pos += 50
+
+            # Draw dialogue if present
+            dialogue = panel_data.get("dialogue", "")
+            character = panel_data.get("character_name", "")
+            if dialogue:
+                # Draw character name
+                y_pos = 700
+                if character:
+                    draw.text((512, y_pos), f"💬 {character}:",
+                             fill=(0, 0, 128), anchor='mm', font=font_small)
+                    y_pos += 40
+
+                # Draw dialogue (wrapped)
+                dialogue_words = dialogue.split()
+                dialogue_lines = []
+                current_line = []
+                for word in dialogue_words:
+                    current_line.append(word)
+                    test_line = ' '.join(current_line)
+                    if len(test_line) > 40:
+                        if len(current_line) > 1:
+                            current_line.pop()
+                            dialogue_lines.append(' '.join(current_line))
+                            current_line = [word]
+                        else:
+                            dialogue_lines.append(test_line)
+                            current_line = []
+                if current_line:
+                    dialogue_lines.append(' '.join(current_line))
+
+                for line in dialogue_lines[:3]:  # Max 3 lines
+                    draw.text((512, y_pos), f'"{line}"',
+                             fill=(0, 0, 0), anchor='mm', font=font_small)
+                    y_pos += 35
+
+            # Add placeholder indicator at bottom
+            draw.text((512, 950), "🎨 Placeholder (SDXL pending)",
+                     fill=(128, 128, 128), anchor='mm', font=font_small)
+
+            panel_images.append(panel)
+
+        return panel_images
+
+    def export_comic(self, outputs, export_format: str):
+        """Export comic in requested format"""
+        if not outputs or not outputs.get("manga_page"):
+            raise ValueError("No comic to export. Generate a comic first.")
+
+        manga_page = outputs["manga_page"]
+        panel_images = outputs["panel_images"]
+        audio_files = outputs.get("audio_files", [])
+        metadata = outputs.get("metadata", {})
+        title = metadata.get("title", "MythForge_Comic").replace(" ", "_")
+
+        try:
+            if export_format == "pdf":
+                pdf_bytes = self.export_service.generate_comic_pdf(
+                    comic_page=manga_page,
+                    title=metadata.get("title", "MythForge Comic"),
+                    metadata=metadata
+                )
+
+                # Save to temp file
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as f:
+                    f.write(pdf_bytes)
+                    return f.name
+
+            elif export_format == "zip":
+                zip_bytes = self.export_service.generate_comic_zip(
+                    comic_page=manga_page,
+                    panel_images=panel_images,
+                    audio_files=audio_files,
+                    title=title,
+                    metadata=metadata
+                )
+
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as f:
+                    f.write(zip_bytes)
+                    return f.name
+
+            elif export_format == "web":
+                web_bytes = self.export_service.generate_web_package(
+                    comic_page=manga_page,
+                    audio_files=audio_files,
+                    title=title,
+                    metadata=metadata
+                )
+
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as f:
+                    f.write(web_bytes)
+                    return f.name
+
+        except Exception as e:
+            print(f"Export error: {e}")
+            raise
+
+
+# Global app instance
+app = ComicGeneratorApp()
+
+# Store current comic output for exports
+current_comic = {}
+
+
+def generate_comic_sync(prompt, style, include_audio, include_bubbles, progress=gr.Progress()):
+    """Synchronous wrapper for comic generation"""
+    global current_comic
+
+    try:
+        # Run async generation
+        outputs = asyncio.run(app.generate_comic_async(
+            prompt=prompt,
+            style=style,
+            include_audio=include_audio,
+            include_bubbles=include_bubbles,
+            progress=progress
+        ))
+
+        # Store for exports
+        current_comic = outputs
+
+        # Prepare UI outputs
+        story_data = outputs["story_data"]
+        manga_page = outputs["manga_page"]
+        panel_images = outputs["panel_images"]
+        audio_files = outputs.get("audio_files", [])
+
+        # Format story text
+        story_text = f"# {story_data.get('title', 'Comic Story')}\n\n"
+        for panel in story_data["panels"]:
+            story_text += f"**Panel {panel['panel_number']}:**\n"
+            story_text += f"*{panel['scene_description']}*\n\n"
+            if panel.get('dialogue'):
+                story_text += f'"{panel["dialogue"]}" - {panel.get("character_name", "")}\n\n'
+
+        # Save manga page to temp file for display
+        manga_temp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+        manga_page.save(manga_temp.name)
+
+        # Prepare audio outputs (6 audio players)
+        audio_outputs = []
+        for i in range(6):
+            if i < len(audio_files) and audio_files[i]:
+                # Verify file exists
+                audio_path = audio_files[i]
+                if os.path.exists(audio_path):
+                    audio_outputs.append(audio_path)
+                    print(f"  Audio {i+1}: {audio_path} ({os.path.getsize(audio_path):,} bytes)")
+                else:
+                    print(f"  Audio {i+1}: File not found at {audio_path}")
+                    audio_outputs.append(None)
+            else:
+                audio_outputs.append(None)
+
+        # Status message
+        status = f"""✅ **Comic Generated Successfully!**
+
+**Panels:** {len(panel_images)}
+**Format:** 2x3 Manga Grid (2148×3192)
+**Audio Tracks:** {len([a for a in audio_files if a])}
+**Style:** {style}
+
+Ready to download in PDF, ZIP, or Web Viewer format!"""
+
+        return (story_text, manga_temp.name, *panel_images, *audio_outputs, status)
+
+    except Exception as e:
+        error_msg = f"❌ **Error:** {str(e)}\n\nPlease check your configuration and try again."
+        # Return error + empty outputs
+        return (error_msg, None, *[None]*6, *[None]*6, error_msg)
+
+
+def export_comic_sync(export_format):
+    """Export current comic"""
+    global current_comic
+
+    if not current_comic:
+        return None, "⚠️ No comic to export. Generate a comic first."
+
+    try:
+        file_path = app.export_comic(current_comic, export_format)
+
+        format_info = {
+            "pdf": "PDF (comic page only)",
+            "zip": "ZIP (full package with audio)",
+            "web": "Web Viewer (interactive HTML)"
+        }
+
+        message = f"✅ Exported as {format_info.get(export_format, export_format)}!"
+        return file_path, message
+
+    except Exception as e:
+        return None, f"❌ Export failed: {str(e)}"
+
+
+# Generate example prompts using GPT-4o
+def generate_example_prompts():
+    """Generate 2 concise example prompts using GPT-4o"""
+    try:
+        from openai import OpenAI
+        client = OpenAI(api_key=Config.OPENAI_API_KEY)
+
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=[{
+                "role": "system",
+                "content": "You are a creative comic story writer. Generate concise, engaging comic prompts."
+            }, {
+                "role": "user",
+                "content": """Generate 2 diverse, creative comic story prompts. Each prompt should be:
+- Concise: 30-40 words (3-4 sentences)
+- Complete story idea with characters, setting, and conflict
+- Visually exciting and comic-worthy
+
+Make them diverse genres (e.g., sci-fi and fantasy, or modern and adventure).
+Return only the 2 prompts, one per paragraph. No titles, no extra formatting."""
+            }],
+            temperature=0.9,
+            max_tokens=300
+        )
+
+        examples_text = response.choices[0].message.content
+        # Split into 2 examples
+        examples = [ex.strip() for ex in examples_text.split("\n\n") if ex.strip()][:2]
+        return examples
+    except Exception as e:
+        print(f"⚠️  Could not generate examples: {e}")
+        # Fallback examples - concise 30-40 words each
+        return [
+            "A young monk discovers ancient scrolls that teach forbidden martial arts. When shadow warriors attack the temple, she must master the techniques before dawn to save her masters and protect the sacred texts.",
+
+            "In a neon-lit city where music controls technology, a street violinist accidentally awakens a dormant AI. Together they must perform the perfect symphony to prevent a corporate takeover of all sound."
+        ]
+
+
+# Custom CSS for artistic comic style
+comic_css = """
+@import url('https://fonts.googleapis.com/css2?family=Comic+Neue:wght@400;700&family=Poppins:wght@400;600&display=swap');
+
+body, .gradio-container {
+    font-family: 'Poppins', sans-serif !important;
+    background-color: #f9f9f9;
+}
+
+h1, h2, h3, h4, h5, h6 {
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+    color: #2c3e50;
+}
+
+.comic-panel {
+    border: 3px solid #2c3e50;
+    border-radius: 10px;
+    box-shadow: 5px 5px 15px rgba(0,0,0,0.1);
+    transition: transform 0.2s;
+    overflow: hidden;
+}
+
+.comic-panel:hover {
+    transform: scale(1.02);
+    box-shadow: 8px 8px 20px rgba(0,0,0,0.15);
+}
+
+/* Make the generate button pop */
+.comic-button {
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+    font-size: 1.2em !important;
+    background: linear-gradient(135deg, #ff9966 0%, #ff5e62 100%) !important;
+    border: 2px solid #2c3e50 !important;
+    box-shadow: 3px 3px 0px #2c3e50 !important;
+    color: white !important;
+    transition: all 0.2s !important;
+}
+
+.comic-button:active {
+    transform: translate(2px, 2px);
+    box-shadow: 1px 1px 0px #2c3e50 !important;
+}
+
+/* Improve text readability */
+.prose {
+    font-size: 1.1em !important;
+    line-height: 1.6 !important;
+    color: #333 !important;
+}
+
+/* Custom container styling */
+.group-container {
+    background: white;
+    padding: 20px;
+    border-radius: 15px;
+    border: 1px solid #e0e0e0;
+    box-shadow: 0 4px 6px rgba(0,0,0,0.05);
+}
+
+/* Make download file component prominent */
+.download-file-container {
+    background: linear-gradient(135deg, #e8f5e9 0%, #c8e6c9 100%) !important;
+    padding: 20px !important;
+    border-radius: 12px !important;
+    border: 3px solid #4caf50 !important;
+    box-shadow: 0 4px 12px rgba(76, 175, 80, 0.3) !important;
+    margin-top: 15px !important;
+}
+
+.download-file-container label {
+    font-family: 'Comic Neue', cursive !important;
+    font-weight: 700 !important;
+    font-size: 1.3em !important;
+    color: #2e7d32 !important;
+}
+
+.download-file-container a {
+    font-size: 1.2em !important;
+    font-weight: 600 !important;
+    color: #1976d2 !important;
+    text-decoration: underline !important;
+}
+"""
+
+# Create Gradio interface
+with gr.Blocks(title="MythForge AI - Comic Generator") as demo:
+    # Inject custom CSS (Gradio 6 compatibility)
+    gr.HTML(f"<style>{comic_css}</style>")
+
+    gr.Markdown("""
+    <div style="text-align: center;">
+
+    # 📚 MythForge AI - Comic Generator
+
+    ### Generate 6-panel manga comics with AI!
+
+    Powered by OpenAI, Gemini, Modal, ElevenLabs, LlamaIndex, Blaxel, Claude Code, and SambaNova
+
+    </div>
+    """)
+
+    with gr.Row():
+        with gr.Column(scale=1, elem_classes=["group-container"]):
+            gr.Markdown("### 📝 Story Input")
+
+            prompt_input = gr.Textbox(
+                label="Comic Story Prompt",
+                placeholder="Enter your story idea here (draw inspiration from examples below and Click on Generate Comic button)...",
+                lines=4,
+                max_lines=8,
+                max_length=800
+            )
+
+            # Generate example prompts
+            gr.Markdown("#### 💡 Example Story Prompts")
+            example_prompts = generate_example_prompts()
+
+            with gr.Row():
+                for i, example in enumerate(example_prompts):
+                    with gr.Column(scale=1):
+                        example_display = gr.Textbox(
+                            value=example,
+                            label=f"Example {i+1}",
+                            lines=4,
+                            max_lines=4,
+                            interactive=True,
+                            show_label=True
+                        )
+
+            style_input = gr.Dropdown(
+                label="Visual Style",
+                choices=[
+                    "anime - Modern Japanese animation with vibrant colors",
+                    "cartoon - Playful Western animation with bold outlines",
+                    "comic - Classic American comic book with action lines",
+                    "manga - Japanese black-and-white comic art style",
+                    "shonen - Action-packed manga for young males",
+                    "shoujo - Romantic manga for young females",
+                    "webcomic - Digital comic optimized for scrolling"
+                ],
+                value="anime - Modern Japanese animation with vibrant colors"
+            )
+
+            with gr.Row():
+                include_audio_checkbox = gr.Checkbox(
+                    label="Generate Audio",
+                    value=True
+                )
+                include_bubbles_checkbox = gr.Checkbox(
+                    label="Add Speech Bubbles",
+                    value=True
+                )
+
+            generate_btn = gr.Button("🎨 Generate Comic", variant="primary", size="lg", elem_classes=["comic-button"])
+
+            status_output = gr.Markdown("Ready to generate...")
+
+        with gr.Column(scale=2, elem_classes=["group-container"]):
+            gr.Markdown("### 📖 Full Manga Page")
+            manga_page_output = gr.Image(
+                label="2x3 Manga Layout (2148×3192)",
+                type="filepath",
+                height=900,
+                elem_classes=["comic-panel"]
+            )
+
+    with gr.Row():
+        gr.Markdown("## 📜 Story Script")
+
+    with gr.Row():
+        story_output = gr.Markdown(label="Comic Script")
+
+    with gr.Row():
+        gr.Markdown("## 🖼️ Individual Panels (1024×1024)")
+
+    # 6 individual panels in 2x3 grid with audio
+    panel_outputs = []
+    audio_outputs = []
+
+    with gr.Row():
+        gr.Markdown("## 🖼️ Comic Panels & Audio")
+
+    # Create 3 rows of 2 columns
+    for row in range(3):
+        with gr.Row():
+            for col in range(2):
+                idx = row * 2 + col + 1
+                with gr.Column():
+                    panel = gr.Image(label=f"Panel {idx}", type="pil", height=300, elem_classes=["comic-panel"])
+                    audio = gr.Audio(label=f"Panel {idx} Audio", type="filepath", interactive=False, autoplay=False)
+                    panel_outputs.append(panel)
+                    audio_outputs.append(audio)
+
+    with gr.Row():
+        gr.Markdown("## 💾 Download Comic")
+
+    with gr.Row():
+        with gr.Column():
+            export_format_input = gr.Radio(
+                label="Export Format",
+                choices=[
+                    ("PDF (Comic Only)", "pdf"),
+                    ("ZIP Package (All Assets + Audio)", "zip"),
+                    ("Web Viewer (Interactive HTML)", "web")
+                ],
+                value="web"
+            )
+
+            export_btn = gr.Button("📥 Generate Download Artifact", variant="primary", size="lg", elem_classes=["comic-button"])
+            export_status = gr.Markdown("")
+            download_output = gr.File(label="Download File", elem_classes=["download-file-container"])
+
+    # Wire up generate button
+    generate_btn.click(
+        fn=generate_comic_sync,
+        inputs=[prompt_input, style_input, include_audio_checkbox, include_bubbles_checkbox],
+        outputs=[story_output, manga_page_output, *panel_outputs, *audio_outputs, status_output]
+    )
+
+    # Wire up export button
+    export_btn.click(
+        fn=export_comic_sync,
+        inputs=[export_format_input],
+        outputs=[download_output, export_status]
+    )
+
+    gr.HTML("""
+    <div style="text-align: center; padding: 20px; background: #f0f2f5; border-radius: 10px; margin-top: 20px; border: 1px solid #e0e0e0;">
+        <h3 style="font-family: 'Comic Neue', cursive; color: #2c3e50; margin-bottom: 5px;">MythForge AI Comic Generator</h3>
+        <p style="color: #666; margin-bottom: 20px; font-style: italic;">Create manga-style comics with AI</p>
+        
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 15px; text-align: left;">
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>OpenAI:</strong> GPT-4o-mini (Primary Story Generation), GPT-4o (Dynamic Prompt Examples)
+            </div>
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>Gemini:</strong> 3 Pro Image (Character Consistency), 2.5 Flash (Vision), 2.0 Flash (Intelligence)
+            </div>
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>Modal:</strong> SDXL (Panel Image Generation)
+            </div>
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>ElevenLabs:</strong> TTS with 9 Diverse Voices
+            </div>
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>LlamaIndex:</strong> Character Memory & RAG
+            </div>
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>Blaxel:</strong> Multi-Provider Orchestration Framework
+            </div>
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>Claude Code:</strong> Autonomous Development & Debugging
+            </div>
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>SambaNova:</strong> Llama 3.3 70B (Story Fallback)
+            </div>
+            <div style="background: white; padding: 10px; border-radius: 8px; border: 1px solid #eee; box-shadow: 0 2px 4px rgba(0,0,0,0.02);">
+                <strong>Gradio:</strong> v6 UI Framework
+            </div>
+        </div>
+    </div>
+    """)
+
+
+if __name__ == "__main__":
+    print("📚 Starting MythForge Comic Generator...")
+    print(f"🎨 Comic Mode: {ENABLE_COMIC_MODE}")
+    print(f"⚡ SambaNova: {ENABLE_SAMBANOVA}")
+    print(f"🖼️ Modal SDXL: {ENABLE_MODAL}")
+    print("🌐 Opening Gradio interface...")
+
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7861,  # Different port from original app
+        share=False
+    )

audio_generator.py

@@ -0,0 +1,437 @@
+"""Audio Generation Service using ElevenLabs"""
+import re
+from typing import List, Optional
+from elevenlabs.client import ElevenLabs
+from elevenlabs import save
+from config import Config
+
+class AudioGenerator:
+    """Generate narrated audio with character voices using ElevenLabs"""
+    
+    def __init__(self):
+        """Initialize ElevenLabs client"""
+        self.client = None
+        # Diverse ElevenLabs voice IDs for better variety
+        self.voices = {
+            "narrator": "ErXwobaYiN019PkySvjV",  # Antoni - warm narrator
+            "character_1": "TxGEqnHWrfWFTfGW9XjX",  # Josh - young male
+            "character_2": "EXAVITQu4vr4xnSDxMaL",  # Bella - soft female
+            "character_3": "21m00Tcm4TlvDq8ikWAM",  # Rachel - clear female
+            "character_4": "VR6AewLTigWG4xSOukaG",  # Arnold - deep male
+            "character_5": "AZnzlk1XvdvUeBnXmlld",  # Domi - young female
+            "character_6": "pNInz6obpgDQGcFmaJgB",  # Adam - deep male 2
+            "character_7": "yoZ06aMxZJJ28mfd3POQ",  # Sam - raspy male
+            "character_8": "onwK4e9ZLuTAKqWW03F9"   # Daniel - authoritative male
+        }
+        
+    def _init_client(self):
+        """Lazy initialize ElevenLabs client"""
+        if self.client is None:
+            if not Config.ELEVENLABS_API_KEY:
+                raise ValueError("ELEVENLABS_API_KEY not set in environment")
+            self.client = ElevenLabs(api_key=Config.ELEVENLABS_API_KEY)
+            print(f"✅ ElevenLabs TTS with {len(self.voices)} diverse voices")
+    
+    def _parse_dialogue(self, text: str) -> List[tuple]:
+        """
+        Parse story text to identify dialogue and narration
+        Returns list of (text, voice_type) tuples
+        """
+        # Simple parsing: look for quoted dialogue
+        # Format: [(text, "narrator"), (dialogue, "character_1"), ...]
+        
+        segments = []
+        current_pos = 0
+        
+        # Find all quoted text
+        dialogue_pattern = r'"([^"]+)"'
+        matches = list(re.finditer(dialogue_pattern, text))
+        
+        if not matches:
+            # No dialogue found, return entire text as narration
+            return [(text, "narrator")]
+        
+        for i, match in enumerate(matches):
+            # Add narration before dialogue
+            if match.start() > current_pos:
+                narration = text[current_pos:match.start()].strip()
+                if narration:
+                    segments.append((narration, "narrator"))
+            
+            # Add dialogue
+            dialogue = match.group(1)
+            # Alternate between character voices
+            voice_type = f"character_{(i % 2) + 1}"
+            segments.append((dialogue, voice_type))
+            
+            current_pos = match.end()
+        
+        # Add remaining narration
+        if current_pos < len(text):
+            narration = text[current_pos:].strip()
+            if narration:
+                segments.append((narration, "narrator"))
+        
+        return segments
+    
+    async def generate_narration(
+        self,
+        story_text: str,
+        use_multiple_voices: bool = False
+    ) -> bytes:
+        """
+        Generate audio narration for the story
+        
+        Args:
+            story_text: The story text to narrate
+            use_multiple_voices: Whether to use multiple character voices
+            
+        Returns:
+            Audio data as bytes (MP3 format)
+        """
+        self._init_client()
+        
+        try:
+            if use_multiple_voices:
+                # Parse dialogue and generate with multiple voices
+                segments = self._parse_dialogue(story_text)
+                audio_segments = []
+                
+                for text, voice_type in segments:
+                    if not text.strip():
+                        continue
+                    
+                    voice_name = self.voices.get(voice_type, self.voices["narrator"])
+                    
+                    # Use the correct API method
+                    audio = self.client.text_to_speech.convert(
+                        text=text,
+                        voice_id=voice_name,
+                        model_id="eleven_monolingual_v1"
+                    )
+                    
+                    # Collect audio bytes
+                    audio_bytes = b""
+                    for chunk in audio:
+                        audio_bytes += chunk
+                    
+                    audio_segments.append(audio_bytes)
+                
+                # Combine audio segments
+                return b"".join(audio_segments)
+            
+            else:
+                # Single narrator voice
+                audio = self.client.text_to_speech.convert(
+                    text=story_text,
+                    voice_id=self.voices["narrator"],
+                    model_id="eleven_monolingual_v1"
+                )
+                
+                # Collect audio bytes
+                audio_bytes = b""
+                for chunk in audio:
+                    audio_bytes += chunk
+                
+                return audio_bytes
+        
+        except Exception as e:
+            print(f"Error generating audio: {e}")
+            raise
+    
+    async def generate_panel_audio(
+        self,
+        panel_data: dict,
+        output_path: Optional[str] = None
+    ) -> bytes:
+        """
+        Generate audio for a single comic panel
+
+        Args:
+            panel_data: Panel dictionary with 'dialogue' and optional 'character_name'
+            output_path: Optional path to save MP3 file
+
+        Returns:
+            Audio data as bytes (MP3 format)
+        """
+        self._init_client()
+
+        try:
+            dialogue = panel_data.get("dialogue", "")
+            character_name = panel_data.get("character_name", "").lower()
+
+            if not dialogue.strip():
+                # No dialogue, return empty audio or silence
+                return b""
+
+            # Remove "Character:" prefix if present (prevents voice from saying the name)
+            if ":" in dialogue:
+                parts = dialogue.split(":", 1)
+                # Check if this looks like a "Character: dialogue" format
+                potential_name = parts[0].strip()
+                if not potential_name.startswith("(") and len(potential_name.split()) <= 3:
+                    dialogue = parts[1].strip()
+
+            # Map character names to voices
+            voice_id = self._map_character_to_voice(character_name)
+
+            # Generate audio
+            audio = self.client.text_to_speech.convert(
+                text=dialogue,
+                voice_id=voice_id,
+                model_id="eleven_monolingual_v1"
+            )
+
+            # Collect audio bytes
+            audio_bytes = b""
+            for chunk in audio:
+                audio_bytes += chunk
+
+            # Save if output path provided
+            if output_path and audio_bytes:
+                with open(output_path, 'wb') as f:
+                    f.write(audio_bytes)
+
+            return audio_bytes
+
+        except Exception as e:
+            print(f"Error generating panel audio: {e}")
+            raise
+
+    async def generate_comic_audio(
+        self,
+        panels: List[dict],
+        output_dir: str = "."
+    ) -> List[str]:
+        """
+        Generate audio for all panels in a comic
+
+        Args:
+            panels: List of panel dictionaries from SambaNova output
+            output_dir: Directory to save MP3 files
+
+        Returns:
+            List of output file paths
+        """
+        self._init_client()
+
+        output_files = []
+
+        for i, panel in enumerate(panels):
+            panel_num = panel.get("panel_number", i + 1)
+            output_path = f"{output_dir}/panel_{panel_num}_audio.mp3"
+
+            try:
+                await self.generate_panel_audio(panel, output_path)
+                output_files.append(output_path)
+                print(f"✅ Generated audio for panel {panel_num}: {output_path}")
+            except Exception as e:
+                print(f"❌ Failed to generate audio for panel {panel_num}: {e}")
+                output_files.append(None)
+
+        return output_files
+
+    def _map_character_to_voice(self, character_name: str) -> str:
+        """
+        Map character name to ElevenLabs voice ID
+
+        Args:
+            character_name: Character name from dialogue
+
+        Returns:
+            ElevenLabs voice ID
+        """
+        # Mapping based on character traits for diverse voices
+        character_lower = character_name.lower()
+
+        # Female character indicators → Use diverse female voices
+        female_indicators = ["she", "her", "girl", "woman", "princess", "queen", "mother", "sister", "lady", "maiden"]
+        # Male character indicators → Use diverse male voices
+        male_indicators = ["he", "him", "boy", "man", "prince", "king", "father", "brother", "wizard", "knight", "sir"]
+        # Authoritative/older → Deep voices
+        authority_indicators = ["king", "wizard", "master", "elder", "lord", "sage", "mentor"]
+        # Young characters → Lighter voices
+        young_indicators = ["boy", "girl", "child", "youth", "apprentice", "student"]
+
+        # Narrator default
+        if character_lower in ["narrator", ""]:
+            return self.voices["narrator"]  # Antoni
+
+        # Check for specific character traits
+        is_female = any(indicator in character_lower for indicator in female_indicators)
+        is_male = any(indicator in character_lower for indicator in male_indicators)
+        is_authority = any(indicator in character_lower for indicator in authority_indicators)
+        is_young = any(indicator in character_lower for indicator in young_indicators)
+
+        # Smart voice mapping based on character traits
+        if is_female:
+            if is_young:
+                return self.voices["character_5"]  # Domi - young female
+            else:
+                # Alternate between Bella and Rachel
+                char_hash = sum(ord(c) for c in character_name)
+                return self.voices["character_2"] if char_hash % 2 == 0 else self.voices["character_3"]
+        elif is_male:
+            if is_authority:
+                # Deep authoritative male voices
+                char_hash = sum(ord(c) for c in character_name)
+                return self.voices["character_4"] if char_hash % 2 == 0 else self.voices["character_6"]  # Arnold or Adam
+            elif is_young:
+                return self.voices["character_1"]  # Josh - young male
+            else:
+                # Alternate between different male voices
+                char_hash = sum(ord(c) for c in character_name)
+                voice_options = ["character_1", "character_7", "character_8"]  # Josh, Sam, Daniel
+                return self.voices[voice_options[char_hash % len(voice_options)]]
+
+        # Default: distribute across all 8 character voices based on hash
+        # This ensures consistency for the same character name while using all voices
+        char_hash = sum(ord(c) for c in character_name)
+        voice_index = (char_hash % 8) + 1
+        return self.voices[f"character_{voice_index}"]
+
+    async def generate_introduction(
+        self,
+        story_prompt: str,
+        story_title: str,
+        characters: List[str],
+        output_path: Optional[str] = None
+    ) -> bytes:
+        """
+        Generate introductory narrator track
+
+        Args:
+            story_prompt: Original user story prompt
+            story_title: Generated story title
+            characters: List of character names
+            output_path: Optional path to save MP3 file
+
+        Returns:
+            Audio data as bytes (MP3 format)
+        """
+        self._init_client()
+
+        try:
+            # Create introduction script
+            char_list = ", ".join(characters) if characters else "our characters"
+            intro_text = f"""Welcome to {story_title}.
+
+{story_prompt}
+
+Today's story features {char_list}. Let's begin."""
+
+            # Generate audio using narrator voice
+            audio = self.client.text_to_speech.convert(
+                text=intro_text,
+                voice_id=self.voices["narrator"],
+                model_id="eleven_monolingual_v1"
+            )
+
+            # Collect audio bytes
+            audio_bytes = b""
+            for chunk in audio:
+                audio_bytes += chunk
+
+            # Save if output path provided
+            if output_path:
+                with open(output_path, "wb") as f:
+                    f.write(audio_bytes)
+
+            return audio_bytes
+
+        except Exception as e:
+            print(f"Error generating introduction: {e}")
+            raise
+
+    async def generate_conclusion(
+        self,
+        story_title: str,
+        panels: List[dict],
+        output_path: Optional[str] = None
+    ) -> bytes:
+        """
+        Generate concluding narrator track
+
+        Args:
+            story_title: Story title
+            panels: List of panel data to summarize
+            output_path: Optional path to save MP3 file
+
+        Returns:
+            Audio data as bytes (MP3 format)
+        """
+        self._init_client()
+
+        try:
+            # Create conclusion script based on final panel
+            final_panel = panels[-1] if panels else None
+            final_action = final_panel.get("action", "the story concludes") if final_panel else "the story concludes"
+
+            conclusion_text = f"""And so, {final_action}.
+
+This concludes {story_title}. Thank you for experiencing this story with us."""
+
+            # Generate audio using narrator voice
+            audio = self.client.text_to_speech.convert(
+                text=conclusion_text,
+                voice_id=self.voices["narrator"],
+                model_id="eleven_monolingual_v1"
+            )
+
+            # Collect audio bytes
+            audio_bytes = b""
+            for chunk in audio:
+                audio_bytes += chunk
+
+            # Save if output path provided
+            if output_path:
+                with open(output_path, "wb") as f:
+                    f.write(audio_bytes)
+
+            return audio_bytes
+
+        except Exception as e:
+            print(f"Error generating conclusion: {e}")
+            raise
+
+    def estimate_cost(self, text: str) -> float:
+        """
+        Estimate cost for audio generation
+        ElevenLabs charges per character
+        """
+        char_count = len(text)
+        # Approximate cost: $0.30 per 1000 characters
+        cost = (char_count / 1000) * 0.30
+        return cost
+
+    def estimate_comic_cost(self, panels: List[dict]) -> dict:
+        """
+        Estimate cost for generating audio for all panels
+
+        Args:
+            panels: List of panel dictionaries
+
+        Returns:
+            Dictionary with cost breakdown
+        """
+        total_chars = 0
+        panel_costs = []
+
+        for panel in panels:
+            dialogue = panel.get("dialogue", "")
+            char_count = len(dialogue)
+            total_chars += char_count
+            cost = self.estimate_cost(dialogue)
+            panel_costs.append({
+                "panel": panel.get("panel_number", 0),
+                "characters": char_count,
+                "cost": cost
+            })
+
+        total_cost = self.estimate_cost("".join([p.get("dialogue", "") for p in panels]))
+
+        return {
+            "total_characters": total_chars,
+            "total_cost": total_cost,
+            "panel_breakdown": panel_costs
+        }

auto_character_intelligence.py

@@ -0,0 +1,358 @@
+"""
+Automatic Character Intelligence System
+Extracts characters from user prompts, generates descriptions, and introduces surprise characters
+"""
+
+import json
+import re
+from typing import Dict, List, Tuple, Optional
+import google.generativeai as genai
+from config import Config
+
+
+class AutoCharacterIntelligence:
+    """Automatically extract and generate characters from story prompts"""
+
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        Initialize Auto Character Intelligence
+
+        Args:
+            api_key: Gemini API key (defaults to Config.GEMINI_API_KEY)
+        """
+        self.api_key = api_key or Config.GEMINI_API_KEY
+        if not self.api_key:
+            raise ValueError("Gemini API key is required")
+
+        genai.configure(api_key=self.api_key)
+
+        # Try Gemini 2.0 Flash for fast character analysis
+        try:
+            self.model = genai.GenerativeModel('gemini-2.0-flash')
+            self.model_name = 'gemini-2.0-flash'
+        except:
+            self.model = genai.GenerativeModel('gemini-1.5-flash')
+            self.model_name = 'gemini-1.5-flash'
+
+        print(f"✅ AutoCharacterIntelligence using {self.model_name.upper().replace('-', ' ')}")
+
+    def extract_characters_from_prompt(
+        self,
+        story_prompt: str,
+        art_style: str = "manga",
+        include_surprise_character: bool = True
+    ) -> Dict[str, str]:
+        """
+        Automatically extract characters from story prompt and generate detailed descriptions
+
+        Args:
+            story_prompt: User's story prompt
+            art_style: Art style for character design
+            include_surprise_character: Add a surprise character that fits the story
+
+        Returns:
+            Dictionary mapping character names to detailed descriptions
+        """
+        prompt = f"""Analyze this story prompt and extract ALL characters, then generate detailed visual descriptions for each.
+
+STORY PROMPT: "{story_prompt}"
+
+ART STYLE: {art_style}
+
+Your task:
+1. Identify ALL characters mentioned or implied in the story
+2. For each character, create a DETAILED visual description including:
+   - Age range and gender
+   - Physical appearance (face, hair, body type)
+   - Clothing and accessories
+   - Distinctive features
+   - Personality traits reflected in appearance
+   - Color palette
+
+3. {'IMPORTANT: Also introduce ONE surprise character that would add interest to this story. This character should fit naturally into the narrative but NOT be explicitly mentioned in the prompt. Make them intriguing and relevant.' if include_surprise_character else ''}
+
+Return a JSON object with this structure:
+{{
+    "main_characters": {{
+        "Character Name 1": "Detailed visual description...",
+        "Character Name 2": "Detailed visual description..."
+    }},
+    {'"surprise_character": {{"Character Name": "Detailed description with explanation of why they appear"}},' if include_surprise_character else ''}
+    "story_analysis": "Brief analysis of the story and character relationships"
+}}
+
+Make descriptions vivid, specific, and suitable for {art_style} art style.
+Return ONLY valid JSON."""
+
+        try:
+            response = self.model.generate_content(prompt)
+            response_text = response.text.strip()
+
+            # Remove markdown code blocks
+            if response_text.startswith("```"):
+                lines = response_text.split("\n")
+                if lines[0].startswith("```"):
+                    lines = lines[1:]
+                if lines and lines[-1].strip() == "```":
+                    lines = lines[:-1]
+                response_text = "\n".join(lines)
+
+            # Parse JSON
+            result = json.loads(response_text)
+
+            # Combine all characters
+            all_characters = {}
+            all_characters.update(result.get("main_characters", {}))
+
+            if include_surprise_character and "surprise_character" in result:
+                all_characters.update(result.get("surprise_character", {}))
+
+            print(f"\n✓ Extracted {len(all_characters)} characters from prompt:")
+            for char_name in all_characters.keys():
+                char_type = "🎁 SURPRISE" if char_name in result.get("surprise_character", {}) else "📖 Main"
+                print(f"  {char_type}: {char_name}")
+
+            if "story_analysis" in result:
+                print(f"\n📝 Story Analysis: {result['story_analysis']}")
+
+            return all_characters
+
+        except json.JSONDecodeError as e:
+            print(f"Error parsing JSON: {e}")
+            print(f"Raw response: {response_text}")
+            return self._fallback_character_extraction(story_prompt, art_style)
+
+        except Exception as e:
+            print(f"Error extracting characters: {e}")
+            return self._fallback_character_extraction(story_prompt, art_style)
+
+    def _fallback_character_extraction(self, story_prompt: str, art_style: str) -> Dict[str, str]:
+        """Fallback character extraction using simple pattern matching"""
+        characters = {}
+
+        # Common character archetypes based on keywords
+        archetypes = {
+            "yogi": "Elderly Indian yogi, white beard, saffron robes, meditation beads",
+            "wizard": "Elderly wizard, long grey beard, blue robes with stars, pointed hat",
+            "warrior": "Strong warrior, armor, sword, determined expression",
+            "princess": "Young princess, elegant gown, crown, graceful demeanor",
+            "dragon": "Large dragon, scales, wings, fierce eyes",
+            "knight": "Armored knight, shield, sword, noble bearing"
+        }
+
+        # Extract using simple matching
+        prompt_lower = story_prompt.lower()
+        for keyword, description in archetypes.items():
+            if keyword in prompt_lower:
+                char_name = keyword.capitalize()
+                characters[char_name] = f"{description}, {art_style} art style"
+
+        # If no characters found, create generic ones
+        if not characters:
+            characters["Protagonist"] = f"Main character, {art_style} art style, heroic appearance"
+
+        print(f"⚠️ Using fallback extraction: {len(characters)} characters")
+        return characters
+
+    def generate_panel_breakdown(
+        self,
+        story_prompt: str,
+        num_panels: int = 3
+    ) -> List[Dict]:
+        """
+        Generate panel-by-panel breakdown from story prompt
+
+        Args:
+            story_prompt: User's story prompt
+            num_panels: Number of panels to generate
+
+        Returns:
+            List of panel dictionaries with scene descriptions and characters
+        """
+        prompt = f"""Break down this story into {num_panels} comic panels.
+
+STORY: "{story_prompt}"
+
+For each panel, provide:
+1. Scene description (visual details)
+2. Characters appearing in that panel
+3. Action/event happening
+4. Mood/atmosphere
+
+Return JSON array:
+[
+    {{
+        "panel_number": 1,
+        "scene_description": "Detailed visual description of the scene...",
+        "characters": ["Character1", "Character2"],
+        "action": "What is happening",
+        "mood": "Peaceful/Tense/Exciting etc."
+    }},
+    ...
+]
+
+Make each panel visually distinct and progress the story naturally.
+Return ONLY valid JSON array."""
+
+        try:
+            response = self.model.generate_content(prompt)
+            response_text = response.text.strip()
+
+            # Remove markdown code blocks
+            if response_text.startswith("```"):
+                lines = response_text.split("\n")
+                if lines[0].startswith("```"):
+                    lines = lines[1:]
+                if lines and lines[-1].strip() == "```":
+                    lines = lines[:-1]
+                response_text = "\n".join(lines)
+
+            panels = json.loads(response_text)
+
+            print(f"\n✓ Generated {len(panels)} panel breakdown:")
+            for panel in panels:
+                print(f"  Panel {panel.get('panel_number')}: {panel.get('characters', [])}")
+
+            return panels
+
+        except Exception as e:
+            print(f"Error generating panel breakdown: {e}")
+            # Fallback: simple 3-panel structure
+            return [
+                {
+                    "panel_number": 1,
+                    "scene_description": f"Opening scene: {story_prompt[:100]}",
+                    "characters": [],
+                    "action": "Introduction",
+                    "mood": "Setting the scene"
+                },
+                {
+                    "panel_number": 2,
+                    "scene_description": f"Middle scene: {story_prompt[:100]}",
+                    "characters": [],
+                    "action": "Development",
+                    "mood": "Building tension"
+                },
+                {
+                    "panel_number": 3,
+                    "scene_description": f"Final scene: {story_prompt[:100]}",
+                    "characters": [],
+                    "action": "Conclusion",
+                    "mood": "Resolution"
+                }
+            ]
+
+    def analyze_story_for_surprise_character(
+        self,
+        story_prompt: str,
+        existing_characters: List[str]
+    ) -> Tuple[str, str]:
+        """
+        Suggest a surprise character that would enhance the story
+
+        Args:
+            story_prompt: User's story prompt
+            existing_characters: List of already identified characters
+
+        Returns:
+            Tuple of (character_name, character_description)
+        """
+        existing_str = ", ".join(existing_characters)
+
+        prompt = f"""Based on this story, suggest ONE surprise character that would add intrigue.
+
+STORY: "{story_prompt}"
+EXISTING CHARACTERS: {existing_str}
+
+The surprise character should:
+1. Fit naturally into the story world
+2. Add an interesting dynamic or plot twist
+3. Be visually distinctive
+4. NOT duplicate existing characters
+
+Return JSON:
+{{
+    "character_name": "Name",
+    "character_description": "Detailed visual description",
+    "story_reason": "Why this character appears and their role"
+}}
+
+Return ONLY valid JSON."""
+
+        try:
+            response = self.model.generate_content(prompt)
+            response_text = response.text.strip()
+
+            # Remove markdown code blocks
+            if response_text.startswith("```"):
+                lines = response_text.split("\n")
+                if lines[0].startswith("```"):
+                    lines = lines[1:]
+                if lines and lines[-1].strip() == "```":
+                    lines = lines[:-1]
+                response_text = "\n".join(lines)
+
+            result = json.loads(response_text)
+
+            character_name = result.get("character_name", "Mystery Character")
+            character_desc = result.get("character_description", "Unknown appearance")
+            reason = result.get("story_reason", "")
+
+            print(f"\n🎁 Surprise Character Suggested: {character_name}")
+            print(f"   Reason: {reason}")
+
+            return character_name, character_desc
+
+        except Exception as e:
+            print(f"Error suggesting surprise character: {e}")
+            return "Mystery Character", "Mysterious figure shrouded in shadows"
+
+
+# Example usage
+if __name__ == "__main__":
+    intelligence = AutoCharacterIntelligence()
+
+    # Example 1: Extract characters from yogi prompt
+    print("="*70)
+    print("Example 1: Yogi Story")
+    print("="*70)
+
+    yogi_prompt = "A yogi teaching a young aspirant the rules of meditation and mindfulness leading to levitation by his own example in a beautiful vibrant colorful jungle"
+
+    characters = intelligence.extract_characters_from_prompt(
+        story_prompt=yogi_prompt,
+        art_style="manga",
+        include_surprise_character=True
+    )
+
+    print("\n--- Extracted Characters ---")
+    for name, desc in characters.items():
+        print(f"\n{name}:")
+        print(f"  {desc[:150]}...")
+
+    # Example 2: Generate panel breakdown
+    print("\n" + "="*70)
+    print("Example 2: Panel Breakdown")
+    print("="*70)
+
+    panels = intelligence.generate_panel_breakdown(yogi_prompt, num_panels=3)
+
+    print("\n--- Panel Breakdown ---")
+    for panel in panels:
+        print(f"\nPanel {panel['panel_number']}:")
+        print(f"  Characters: {', '.join(panel.get('characters', []))}")
+        print(f"  Scene: {panel.get('scene_description', '')[:100]}...")
+        print(f"  Mood: {panel.get('mood', 'N/A')}")
+
+    # Example 3: Suggest surprise character
+    print("\n" + "="*70)
+    print("Example 3: Surprise Character")
+    print("="*70)
+
+    surprise_name, surprise_desc = intelligence.analyze_story_for_surprise_character(
+        story_prompt=yogi_prompt,
+        existing_characters=["Master Yogi", "Young Aspirant"]
+    )
+
+    print(f"\nSurprise Character: {surprise_name}")
+    print(f"Description: {surprise_desc}")

blaxel_agent.py

@@ -0,0 +1,182 @@
+"""Blaxel Agent Integration for MythForge Comic Generator
+
+Orchestrates multi-provider AI comic generation through Blaxel's agent platform.
+"""
+
+import requests
+import asyncio
+from typing import Dict, List, Optional
+from blaxel_config import BlaxelConfig
+
+
+class BlaxelComicAgent:
+    """Blaxel agent for orchestrating comic generation workflow"""
+
+    def __init__(self):
+        """Initialize Blaxel agent client"""
+        self.enabled = BlaxelConfig.is_enabled()
+        self.base_url = BlaxelConfig.BASE_URL
+        self.headers = BlaxelConfig.get_headers()
+
+        if self.enabled:
+            print(f"✅ Blaxel agent enabled: {BlaxelConfig.AGENT_NAME}")
+        else:
+            print("⚠️  Blaxel agent disabled (set ENABLE_BLAXEL=true in .env)")
+
+    async def generate_comic_orchestrated(
+        self,
+        prompt: str,
+        style: str = "manga",
+        include_audio: bool = True
+    ) -> Dict:
+        """
+        Orchestrate comic generation through Blaxel agent workflow
+
+        Args:
+            prompt: User's story prompt
+            style: Visual style (manga, shonen, etc.)
+            include_audio: Whether to generate audio
+
+        Returns:
+            Dict with generated assets and metadata
+        """
+        if not self.enabled:
+            raise RuntimeError("Blaxel agent not enabled")
+
+        # Define agent workflow
+        workflow = {
+            "agent_name": BlaxelConfig.AGENT_NAME,
+            "workflow_version": BlaxelConfig.AGENT_VERSION,
+            "steps": [
+                {
+                    "name": "story_generation",
+                    "provider": "sambanova",
+                    "model": "llama-3.3-70b",
+                    "input": {
+                        "prompt": prompt,
+                        "style": style,
+                        "panel_count": 6
+                    },
+                    "timeout": 10
+                },
+                {
+                    "name": "image_generation",
+                    "provider": "modal",
+                    "model": "sdxl",
+                    "input": {
+                        "scenes": "{{story_generation.panels}}",
+                        "style": style,
+                        "count": 6
+                    },
+                    "timeout": 120,
+                    "parallel": True  # Generate 6 panels in parallel
+                },
+                {
+                    "name": "audio_generation",
+                    "provider": "elevenlabs",
+                    "model": "eleven_multilingual_v2",
+                    "input": {
+                        "dialogues": "{{story_generation.panels}}",
+                        "count": 6
+                    },
+                    "timeout": 30,
+                    "enabled": include_audio
+                }
+            ],
+            "monitoring": {
+                "track_costs": True,
+                "track_latency": True,
+                "log_errors": True
+            }
+        }
+
+        # Execute workflow through Blaxel
+        try:
+            response = await self._execute_workflow(workflow)
+            return response
+        except Exception as e:
+            print(f"❌ Blaxel workflow failed: {e}")
+            raise
+
+    async def _execute_workflow(self, workflow: Dict) -> Dict:
+        """Execute workflow through Blaxel API"""
+        endpoint = f"{self.base_url}/v1/workflows/execute"
+
+        try:
+            response = requests.post(
+                endpoint,
+                json=workflow,
+                headers=self.headers,
+                timeout=BlaxelConfig.REQUEST_TIMEOUT
+            )
+
+            if response.status_code != 200:
+                raise RuntimeError(
+                    f"Blaxel API error {response.status_code}: {response.text}"
+                )
+
+            result = response.json()
+            return result
+
+        except requests.exceptions.Timeout:
+            raise RuntimeError("Blaxel workflow timeout")
+        except Exception as e:
+            raise RuntimeError(f"Blaxel execution failed: {e}")
+
+    def get_workflow_status(self, workflow_id: str) -> Dict:
+        """Get status of a running workflow"""
+        endpoint = f"{self.base_url}/v1/workflows/{workflow_id}/status"
+
+        response = requests.get(endpoint, headers=self.headers)
+        return response.json()
+
+    def get_cost_report(self, workflow_id: str) -> Dict:
+        """Get cost breakdown for a workflow"""
+        endpoint = f"{self.base_url}/v1/workflows/{workflow_id}/costs"
+
+        response = requests.get(endpoint, headers=self.headers)
+        return response.json()
+
+    @classmethod
+    def is_available(cls) -> bool:
+        """Check if Blaxel agent is available"""
+        return BlaxelConfig.is_enabled()
+
+
+# Example usage
+if __name__ == "__main__":
+    import asyncio
+
+    async def test_blaxel():
+        """Test Blaxel agent integration"""
+        agent = BlaxelComicAgent()
+
+        if not agent.enabled:
+            print("❌ Blaxel not enabled. Set ENABLE_BLAXEL=true in .env")
+            return
+
+        print("Testing Blaxel comic generation workflow...")
+
+        try:
+            result = await agent.generate_comic_orchestrated(
+                prompt="A wizard discovers a magical library",
+                style="manga",
+                include_audio=True
+            )
+
+            print("✅ Blaxel workflow completed!")
+            print(f"Story: {result.get('story_generation', {}).get('title')}")
+            print(f"Panels generated: {len(result.get('image_generation', {}).get('images', []))}")
+            print(f"Audio files: {len(result.get('audio_generation', {}).get('files', []))}")
+
+            # Get cost report
+            workflow_id = result.get('workflow_id')
+            if workflow_id:
+                costs = agent.get_cost_report(workflow_id)
+                print(f"Total cost: ${costs.get('total_cost', 0):.4f}")
+
+        except Exception as e:
+            print(f"❌ Test failed: {e}")
+
+    # Run test
+    asyncio.run(test_blaxel())

blaxel_config.py

@@ -0,0 +1,74 @@
+"""Blaxel Configuration for MythForge Comic Generator"""
+import os
+from config import Config
+
+class BlaxelConfig:
+    """Configuration for Blaxel agent orchestration"""
+
+    # Blaxel API Configuration
+    API_KEY = Config.BLAXEL_API_KEY
+    BASE_URL = os.getenv("BLAXEL_BASE_URL", "https://api.blaxel.ai")
+
+    # Agent Configuration
+    AGENT_NAME = "mythforge-comic-generator"
+    AGENT_DESCRIPTION = "Generates 6-panel manga-style comics with dialogue and audio"
+    AGENT_VERSION = "1.0.0"
+
+    # Timeout Settings (in seconds)
+    REQUEST_TIMEOUT = 300  # 5 minutes for comic generation
+    RETRY_ATTEMPTS = 3
+    RETRY_DELAY = 2  # seconds between retries
+
+    # Model Gateway Configuration
+    # Routes for different AI services through Blaxel
+    MODEL_GATEWAY_ENABLED = Config.ENABLE_BLAXEL
+
+    # Service Routes (through Blaxel Model Gateway)
+    ROUTES = {
+        "text_generation": {
+            "primary": "sambanova/llama-3.1-70b",
+            "fallback": "openai/gpt-4o-mini"
+        },
+        "image_generation": {
+            "primary": "modal/sdxl",
+            "fallback": "local/sd-1.5"
+        },
+        "audio_generation": {
+            "primary": "elevenlabs/eleven_multilingual_v2"
+        },
+        "vision_analysis": {
+            "primary": "gemini/flash"
+        }
+    }
+
+    # Batch Job Configuration
+    ENABLE_BATCH_MODE = False  # For bulk comic generation
+    MAX_BATCH_SIZE = 10
+
+    # Monitoring and Logging
+    ENABLE_LOGGING = True
+    LOG_LEVEL = os.getenv("BLAXEL_LOG_LEVEL", "INFO")
+
+    @classmethod
+    def validate(cls):
+        """Validate Blaxel configuration"""
+        if Config.ENABLE_BLAXEL and not cls.API_KEY:
+            raise ValueError(
+                "BLAXEL_API_KEY is required when ENABLE_BLAXEL=true. "
+                "Please set it in .env file or disable Blaxel."
+            )
+        return True
+
+    @classmethod
+    def is_enabled(cls):
+        """Check if Blaxel is enabled"""
+        return Config.ENABLE_BLAXEL and cls.API_KEY is not None
+
+    @classmethod
+    def get_headers(cls):
+        """Get properly formatted headers for Blaxel API requests"""
+        return {
+            "X-Blaxel-Authorization": f"Bearer {cls.API_KEY}",
+            "accept": "application/json, text/plain, */*",
+            "Content-Type": "application/json"
+        }

character_consistency_manager.py

@@ -0,0 +1,689 @@
+"""
+Character Consistency Manager
+Orchestrates Nano Banana + LlamaIndex hybrid workflow for character persistence
+"""
+
+import os
+import json
+from typing import Dict, List, Optional, Tuple, Union
+from PIL import Image
+from io import BytesIO
+import base64
+
+from nano_banana_client import NanoBananaClient
+from character_extractor import CharacterExtractor
+from story_memory import StoryMemory
+from auto_character_intelligence import AutoCharacterIntelligence
+from config import Config
+
+
+class CharacterConsistencyManager:
+    """Manages character consistency across comic panels using Nano Banana + LlamaIndex"""
+
+    def __init__(
+        self,
+        character_library_dir: str = "./character_library",
+        enable_nano_banana: bool = None,
+        enable_character_library: bool = None
+    ):
+        """
+        Initialize Character Consistency Manager
+
+        Args:
+            character_library_dir: Directory to store character library
+            enable_nano_banana: Enable Nano Banana image generation (defaults to Config)
+            enable_character_library: Enable character library persistence (defaults to Config)
+        """
+        self.character_library_dir = character_library_dir
+        self.enable_nano_banana = enable_nano_banana if enable_nano_banana is not None else Config.ENABLE_NANO_BANANA
+        self.enable_character_library = enable_character_library if enable_character_library is not None else Config.ENABLE_CHARACTER_LIBRARY
+
+        # Create character library directory
+        os.makedirs(character_library_dir, exist_ok=True)
+        os.makedirs(os.path.join(character_library_dir, "images"), exist_ok=True)
+        os.makedirs(os.path.join(character_library_dir, "profiles"), exist_ok=True)
+
+        # Initialize components
+        self.nano_banana = None
+        self.character_extractor = None
+        self.story_memory = None
+        self.auto_intelligence = None
+
+        if Config.GEMINI_API_KEY:
+            try:
+                if self.enable_nano_banana:
+                    self.nano_banana = NanoBananaClient(model=Config.NANO_BANANA_MODEL)
+                    print("✓ Nano Banana client initialized")
+            except Exception as e:
+                print(f"Warning: Could not initialize Nano Banana: {e}")
+
+            try:
+                self.character_extractor = CharacterExtractor()
+                print("✓ Character Extractor initialized")
+            except Exception as e:
+                print(f"Warning: Could not initialize Character Extractor: {e}")
+
+            try:
+                self.auto_intelligence = AutoCharacterIntelligence()
+                print("✓ Auto Character Intelligence initialized")
+            except Exception as e:
+                print(f"Warning: Could not initialize Auto Intelligence: {e}")
+
+        if self.enable_character_library and Config.ENABLE_LLAMAINDEX:
+            try:
+                self.story_memory = StoryMemory()
+                print("✓ Story Memory (LlamaIndex) initialized")
+            except Exception as e:
+                print(f"Warning: Could not initialize Story Memory: {e}")
+
+        # Character cache (in-memory for current session)
+        self.character_cache: Dict[str, Dict] = {}
+
+        print(f"Character Consistency Manager initialized")
+        print(f"  Nano Banana: {'✓ Enabled' if self.enable_nano_banana and self.nano_banana else '✗ Disabled'}")
+        print(f"  Character Library: {'✓ Enabled' if self.enable_character_library and self.story_memory else '✗ Disabled'}")
+
+    def create_character(
+        self,
+        character_description: str,
+        character_name: str,
+        style: str = "manga"
+    ) -> Dict:
+        """
+        Create a new character with reference images
+
+        Args:
+            character_description: Detailed character description
+            character_name: Name of the character
+            style: Art style
+
+        Returns:
+            Character profile dictionary with reference images
+        """
+        if not self.nano_banana:
+            raise ValueError("Nano Banana is not enabled. Set ENABLE_NANO_BANANA=true")
+
+        print(f"\n=== Creating Character: {character_name} ===")
+
+        # Generate character reference sheet
+        print("Generating character reference images...")
+        try:
+            reference_images = self.nano_banana.generate_character_sheet(
+                character_description=character_description,
+                style=style
+            )
+
+            if not reference_images:
+                raise ValueError("No reference images generated")
+
+            print(f"Generated {len(reference_images)} reference images")
+
+            # Extract character profile from first image
+            print("Extracting character profile...")
+            character_profile = self.character_extractor.extract_character_profile(
+                image=reference_images[0],
+                character_name=character_name
+            )
+
+            # Save reference images
+            image_paths = []
+            for i, img in enumerate(reference_images):
+                img_filename = f"{character_name.lower().replace(' ', '_')}_ref_{i}.png"
+                img_path = os.path.join(self.character_library_dir, "images", img_filename)
+                img.save(img_path)
+                image_paths.append(img_path)
+                print(f"Saved reference image: {img_filename}")
+
+            # Update profile with image paths
+            character_profile["reference_images"] = image_paths
+            character_profile["style"] = style
+            character_profile["original_description"] = character_description
+
+            # Save character profile
+            profile_filename = f"{character_name.lower().replace(' ', '_')}_profile.json"
+            profile_path = os.path.join(self.character_library_dir, "profiles", profile_filename)
+            with open(profile_path, 'w') as f:
+                json.dump(character_profile, f, indent=2)
+            print(f"Saved character profile: {profile_filename}")
+
+            # Cache character
+            self.character_cache[character_name] = character_profile
+
+            # Store in LlamaIndex if enabled
+            if self.story_memory and self.enable_character_library:
+                consistency_prompt = self.character_extractor.generate_consistency_prompt(character_profile)
+                self.story_memory.store_story(
+                    story_text=f"Character: {character_name}\n{consistency_prompt}",
+                    metadata={
+                        "type": "character_profile",
+                        "character_name": character_name,
+                        "style": style
+                    }
+                )
+                print(f"Stored {character_name} in character library")
+
+            print(f"✓ Character '{character_name}' created successfully")
+            return character_profile
+
+        except Exception as e:
+            print(f"Error creating character: {e}")
+            raise
+
+    def get_character(self, character_name: str) -> Optional[Dict]:
+        """
+        Retrieve character from library
+
+        Args:
+            character_name: Name of the character
+
+        Returns:
+            Character profile dictionary or None if not found
+        """
+        # Check cache first
+        if character_name in self.character_cache:
+            return self.character_cache[character_name]
+
+        # Check disk
+        profile_filename = f"{character_name.lower().replace(' ', '_')}_profile.json"
+        profile_path = os.path.join(self.character_library_dir, "profiles", profile_filename)
+
+        if os.path.exists(profile_path):
+            with open(profile_path, 'r') as f:
+                character_profile = json.load(f)
+                self.character_cache[character_name] = character_profile
+                print(f"Loaded character '{character_name}' from library")
+                return character_profile
+
+        # Check LlamaIndex
+        if self.story_memory and self.enable_character_library:
+            char_info = self.story_memory.get_character_info(character_name)
+            if char_info:
+                print(f"Found character '{character_name}' in story memory")
+                return char_info
+
+        print(f"Character '{character_name}' not found in library")
+        return None
+
+    def generate_panel_with_character(
+        self,
+        scene_description: str,
+        character_name: str,
+        panel_number: int = 1,
+        create_if_missing: bool = False,
+        character_description: Optional[str] = None
+    ) -> Image.Image:
+        """
+        Generate a comic panel with character consistency
+
+        Args:
+            scene_description: Description of the scene
+            character_name: Name of the character
+            panel_number: Panel number in sequence
+            create_if_missing: If True, create character if not in library
+            character_description: Character description (required if create_if_missing=True)
+
+        Returns:
+            Generated PIL Image
+        """
+        if not self.nano_banana:
+            raise ValueError("Nano Banana is not enabled")
+
+        # Get or create character
+        character_profile = self.get_character(character_name)
+
+        if not character_profile:
+            if create_if_missing and character_description:
+                print(f"Character '{character_name}' not found. Creating new character...")
+                character_profile = self.create_character(
+                    character_description=character_description,
+                    character_name=character_name
+                )
+            else:
+                raise ValueError(f"Character '{character_name}' not found in library. Set create_if_missing=True to create.")
+
+        # Load reference images
+        reference_images = []
+        for img_path in character_profile.get("reference_images", []):
+            if os.path.exists(img_path):
+                reference_images.append(Image.open(img_path))
+
+        if not reference_images:
+            print(f"Warning: No reference images found for {character_name}")
+
+        # Generate consistency prompt
+        consistency_prompt = self.character_extractor.generate_consistency_prompt(character_profile)
+
+        # Generate panel
+        print(f"\nGenerating Panel {panel_number} with character '{character_name}'...")
+        generated_image = self.nano_banana.generate_with_character_consistency(
+            prompt=scene_description,
+            character_references=reference_images,
+            character_description=consistency_prompt,
+            scene_number=panel_number
+        )
+
+        # Verify consistency
+        if panel_number > 1 and reference_images and self.character_extractor:
+            print("Verifying character consistency...")
+            consistency_result = self.character_extractor.compare_character_consistency(
+                image1=reference_images[0],
+                image2=generated_image,
+                character_name=character_name
+            )
+            print(f"Consistency score: {consistency_result.get('consistency_score', 0.0):.2%}")
+
+            if consistency_result.get('consistency_score', 0.0) < 0.7:
+                print(f"⚠ Low consistency score! Differences: {consistency_result.get('differences', [])}")
+
+        return generated_image
+
+    def generate_story_panels(
+        self,
+        story_panels: List[Dict],
+        main_character_name: str,
+        main_character_description: Optional[str] = None
+    ) -> List[Image.Image]:
+        """
+        Generate all panels for a story with character consistency
+
+        Args:
+            story_panels: List of panel dictionaries with 'description' field
+            main_character_name: Name of the main character
+            main_character_description: Character description (for first-time creation)
+
+        Returns:
+            List of generated PIL Images
+        """
+        generated_panels = []
+
+        # Get or create character
+        character_profile = self.get_character(main_character_name)
+
+        if not character_profile and main_character_description:
+            print(f"Creating new character '{main_character_name}'...")
+            character_profile = self.create_character(
+                character_description=main_character_description,
+                character_name=main_character_name
+            )
+
+        # Generate each panel
+        for i, panel in enumerate(story_panels, 1):
+            scene_description = panel.get("description", "")
+
+            try:
+                panel_image = self.generate_panel_with_character(
+                    scene_description=scene_description,
+                    character_name=main_character_name,
+                    panel_number=i,
+                    create_if_missing=False
+                )
+                generated_panels.append(panel_image)
+                print(f"✓ Panel {i}/{len(story_panels)} generated")
+
+            except Exception as e:
+                print(f"✗ Error generating panel {i}: {e}")
+                # Create placeholder
+                placeholder = Image.new('RGB', (1024, 1024), color='gray')
+                generated_panels.append(placeholder)
+
+        return generated_panels
+
+    def generate_panel_with_multiple_characters(
+        self,
+        scene_description: str,
+        character_names: List[str],
+        panel_number: int = 1,
+        create_missing: bool = False,
+        character_descriptions: Optional[Dict[str, str]] = None
+    ) -> Image.Image:
+        """
+        Generate a panel with MULTIPLE characters maintaining consistency
+
+        Args:
+            scene_description: Description of the scene
+            character_names: List of character names to include
+            panel_number: Panel number in sequence
+            create_missing: Create characters if not in library
+            character_descriptions: Dict mapping character names to descriptions (for creation)
+
+        Returns:
+            Generated PIL Image with all characters
+
+        Note:
+            Nano Banana Pro can maintain up to 5 people and 6 objects simultaneously.
+            For best results, limit to 2-3 main characters per panel.
+        """
+        if not self.nano_banana:
+            raise ValueError("Nano Banana is not enabled")
+
+        if len(character_names) > 5:
+            print(f"⚠️ Warning: {len(character_names)} characters requested. Nano Banana Pro supports up to 5 people.")
+            print(f"   Using first 5 characters only.")
+            character_names = character_names[:5]
+
+        # Get or create all characters
+        all_character_profiles = []
+        all_reference_images = []
+        combined_consistency_prompts = []
+
+        for char_name in character_names:
+            char_profile = self.get_character(char_name)
+
+            # Create if missing
+            if not char_profile:
+                if create_missing and character_descriptions and char_name in character_descriptions:
+                    print(f"Creating new character '{char_name}'...")
+                    char_profile = self.create_character(
+                        character_description=character_descriptions[char_name],
+                        character_name=char_name
+                    )
+                else:
+                    raise ValueError(f"Character '{char_name}' not found. Set create_missing=True and provide description.")
+
+            all_character_profiles.append(char_profile)
+
+            # Load reference images (limit per character to fit within 14 total)
+            refs_per_character = min(14 // len(character_names), 4)
+            char_refs = []
+            for img_path in char_profile.get("reference_images", [])[:refs_per_character]:
+                if os.path.exists(img_path):
+                    char_refs.append(Image.open(img_path))
+
+            all_reference_images.extend(char_refs)
+
+            # Build consistency prompt
+            consistency_prompt = self.character_extractor.generate_consistency_prompt(char_profile)
+            combined_consistency_prompts.append(f"CHARACTER {len(all_character_profiles)} ({char_name}):\n{consistency_prompt}")
+
+        # Build combined prompt
+        characters_description = "\n\n".join(combined_consistency_prompts)
+
+        full_prompt = f"""IMPORTANT: Maintain EXACT character appearances from reference images.
+
+{characters_description}
+
+SCENE (Panel {panel_number}):
+{scene_description}
+
+Generate this scene with ALL {len(character_names)} characters maintaining their EXACT appearance from the references.
+Ensure each character is visually distinct and identifiable.
+"""
+
+        print(f"\nGenerating Panel {panel_number} with {len(character_names)} characters:")
+        for name in character_names:
+            print(f"  - {name}")
+
+        # Generate with all reference images
+        try:
+            generated_image = self.nano_banana.generate_image(
+                prompt=full_prompt,
+                reference_images=all_reference_images,
+                aspect_ratio="1:1",
+                num_images=1
+            )[0]
+
+            print(f"✓ Panel {panel_number} generated with {len(character_names)} characters")
+            return generated_image
+
+        except Exception as e:
+            print(f"✗ Error generating multi-character panel: {e}")
+            raise
+
+    def list_characters(self) -> List[str]:
+        """List all characters in the library"""
+        characters = []
+
+        # Check profiles directory
+        profiles_dir = os.path.join(self.character_library_dir, "profiles")
+        if os.path.exists(profiles_dir):
+            for filename in os.listdir(profiles_dir):
+                if filename.endswith("_profile.json"):
+                    character_name = filename.replace("_profile.json", "").replace("_", " ").title()
+                    characters.append(character_name)
+
+        return sorted(characters)
+
+    def get_character_info_summary(self, character_name: str) -> str:
+        """Get a human-readable summary of character information"""
+        character_profile = self.get_character(character_name)
+
+        if not character_profile:
+            return f"Character '{character_name}' not found."
+
+        summary = f"=== Character: {character_name} ===\n"
+        summary += f"Physical Description: {character_profile.get('physical_description', 'N/A')}\n"
+        summary += f"Age Range: {character_profile.get('age_range', 'N/A')}\n"
+        summary += f"Hair: {character_profile.get('hair', 'N/A')}\n"
+        summary += f"Clothing: {character_profile.get('clothing', 'N/A')}\n"
+        summary += f"Body Type: {character_profile.get('body_type', 'N/A')}\n"
+        summary += f"Art Style: {character_profile.get('style', 'N/A')}\n"
+        summary += f"Reference Images: {len(character_profile.get('reference_images', []))}\n"
+
+        return summary
+
+    def generate_comic_from_prompt(
+        self,
+        story_prompt: str,
+        num_panels: int = 3,
+        art_style: str = "manga",
+        include_surprise_character: bool = True,
+        output_dir: str = "./auto_generated_comics"
+    ) -> Dict:
+        """
+        FULLY AUTOMATIC: Generate complete comic from just a text prompt
+
+        This method automatically:
+        1. Extracts ALL characters from the prompt
+        2. Adds a surprise character (optional)
+        3. Generates detailed descriptions for each character
+        4. Creates character reference sheets
+        5. Breaks story into panel-by-panel scenes
+        6. Generates all panels with consistent characters
+        7. Saves everything to disk
+
+        Args:
+            story_prompt: User's story idea (e.g., "A yogi teaching meditation...")
+            num_panels: Number of comic panels to generate
+            art_style: Art style (manga, anime, comic, etc.)
+            include_surprise_character: Add a surprise character for intrigue
+            output_dir: Directory to save generated comic
+
+        Returns:
+            Dictionary with:
+            - characters: Dict of created characters
+            - panels: List of generated panel images
+            - panel_info: List of panel descriptions
+            - surprise_character: Name of surprise character (if added)
+
+        Example:
+            ```python
+            manager = CharacterConsistencyManager()
+            result = manager.generate_comic_from_prompt(
+                "A yogi teaching a young aspirant meditation and levitation in a jungle"
+            )
+            # Automatically creates: Yogi, Aspirant, + Surprise character
+            # Generates 3 panels with all characters consistent
+            ```
+        """
+        if not self.auto_intelligence or not self.nano_banana:
+            raise ValueError("Auto Intelligence and Nano Banana must be enabled")
+
+        print("\n" + "="*70)
+        print("  🤖 AUTOMATIC COMIC GENERATION")
+        print("="*70)
+        print(f"Story: {story_prompt}")
+        print(f"Panels: {num_panels}")
+        print(f"Style: {art_style}")
+        print(f"Surprise Character: {'Yes' if include_surprise_character else 'No'}")
+        print("="*70)
+
+        # Create output directory
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Step 1: Extract characters automatically
+        print("\n📖 Step 1: Extracting characters from prompt...")
+        characters_dict = self.auto_intelligence.extract_characters_from_prompt(
+            story_prompt=story_prompt,
+            art_style=art_style,
+            include_surprise_character=include_surprise_character
+        )
+
+        surprise_char_name = None
+        if include_surprise_character:
+            # Identify surprise character (last one added)
+            all_names = list(characters_dict.keys())
+            surprise_char_name = all_names[-1] if len(all_names) > 2 else None
+
+        # Step 2: Create all characters with reference sheets
+        print(f"\n🎨 Step 2: Creating {len(characters_dict)} characters...")
+        created_characters = {}
+
+        for char_name, char_description in characters_dict.items():
+            # Check if character already exists
+            existing = self.get_character(char_name)
+            if existing:
+                print(f"  ✓ {char_name} already in library (reusing)")
+                created_characters[char_name] = existing
+            else:
+                char_type = "🎁 SURPRISE" if char_name == surprise_char_name else "📖"
+                print(f"  {char_type} Creating {char_name}...")
+                try:
+                    profile = self.create_character(
+                        character_description=char_description,
+                        character_name=char_name,
+                        style=art_style
+                    )
+                    created_characters[char_name] = profile
+                    print(f"  ✓ {char_name} created")
+                except Exception as e:
+                    print(f"  ✗ Error creating {char_name}: {e}")
+
+        # Step 3: Generate panel breakdown
+        print(f"\n📋 Step 3: Breaking story into {num_panels} panels...")
+        panel_breakdown = self.auto_intelligence.generate_panel_breakdown(
+            story_prompt=story_prompt,
+            num_panels=num_panels
+        )
+
+        # Step 4: Generate each panel
+        print(f"\n🖼️  Step 4: Generating {num_panels} panels...")
+        generated_panels = []
+        panel_info = []
+
+        for i, panel_desc in enumerate(panel_breakdown[:num_panels], 1):
+            scene_desc = panel_desc.get("scene_description", story_prompt)
+            panel_characters = panel_desc.get("characters", list(created_characters.keys()))
+
+            # Filter to only use created characters
+            valid_characters = [c for c in panel_characters if c in created_characters]
+
+            # If no characters specified, use all created characters
+            if not valid_characters:
+                valid_characters = list(created_characters.keys())[:3]  # Limit to 3 for best results
+
+            print(f"\n  Panel {i}/{num_panels}:")
+            print(f"    Scene: {scene_desc[:80]}...")
+            print(f"    Characters: {', '.join(valid_characters)}")
+
+            try:
+                # Generate panel with all characters
+                if len(valid_characters) == 1:
+                    panel_image = self.generate_panel_with_character(
+                        scene_description=scene_desc,
+                        character_name=valid_characters[0],
+                        panel_number=i
+                    )
+                else:
+                    panel_image = self.generate_panel_with_multiple_characters(
+                        scene_description=scene_desc,
+                        character_names=valid_characters,
+                        panel_number=i
+                    )
+
+                # Save panel
+                panel_filename = f"panel_{i:02d}.png"
+                panel_path = os.path.join(output_dir, panel_filename)
+                panel_image.save(panel_path)
+
+                generated_panels.append(panel_image)
+                panel_info.append({
+                    "panel_number": i,
+                    "characters": valid_characters,
+                    "scene": scene_desc,
+                    "filename": panel_filename,
+                    "path": panel_path
+                })
+
+                print(f"    ✓ Saved: {panel_filename}")
+
+            except Exception as e:
+                print(f"    ✗ Error generating panel {i}: {e}")
+
+        # Step 5: Summary
+        print("\n" + "="*70)
+        print("  ✅ COMIC GENERATION COMPLETE")
+        print("="*70)
+        print(f"\nCharacters Created: {len(created_characters)}")
+        for char_name in created_characters.keys():
+            char_type = "🎁 SURPRISE" if char_name == surprise_char_name else "📖"
+            print(f"  {char_type} {char_name}")
+
+        print(f"\nPanels Generated: {len(generated_panels)}/{num_panels}")
+        print(f"Output Directory: {output_dir}")
+
+        if surprise_char_name:
+            print(f"\n🎁 Surprise Character: {surprise_char_name}")
+            print(f"   Check the panels to see how they appear in the story!")
+
+        # Return results
+        return {
+            "characters": created_characters,
+            "panels": generated_panels,
+            "panel_info": panel_info,
+            "surprise_character": surprise_char_name,
+            "output_dir": output_dir,
+            "story_prompt": story_prompt
+        }
+
+
+# Example usage
+if __name__ == "__main__":
+    print("=== Character Consistency Manager Test ===\n")
+
+    # Initialize manager
+    manager = CharacterConsistencyManager()
+
+    # Example: Create a character
+    if manager.nano_banana:
+        print("Test 1: Creating a character")
+        try:
+            yogi_profile = manager.create_character(
+                character_description="Elderly Indian yogi with long white beard, saffron robes, peaceful expression, meditation beads",
+                character_name="Master Yogi",
+                style="manga"
+            )
+            print("✓ Character created successfully\n")
+        except Exception as e:
+            print(f"✗ Test 1 failed: {e}\n")
+
+        # Example: List characters
+        print("Test 2: Listing characters")
+        characters = manager.list_characters()
+        print(f"Characters in library: {characters}\n")
+
+        # Example: Generate panel with character
+        if characters:
+            print("Test 3: Generating panel with character")
+            try:
+                panel = manager.generate_panel_with_character(
+                    scene_description="The yogi meditating peacefully in a vibrant jungle",
+                    character_name=characters[0],
+                    panel_number=1
+                )
+                print("✓ Panel generated successfully\n")
+            except Exception as e:
+                print(f"✗ Test 3 failed: {e}\n")
+    else:
+        print("Nano Banana not enabled. Set ENABLE_NANO_BANANA=true in .env to test.")
+
+    print("=== Tests Complete ===")

character_extractor.py

@@ -0,0 +1,363 @@
+"""
+Character Extraction Module using Gemini Vision
+Analyzes comic panels to extract detailed character descriptions and visual attributes
+"""
+
+import os
+import base64
+from io import BytesIO
+from typing import Dict, List, Optional, Tuple, Union
+from PIL import Image
+import google.generativeai as genai
+import json
+import re
+from config import Config
+
+
+class CharacterExtractor:
+    """Extract character information from images using Gemini Vision"""
+
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        Initialize Character Extractor
+
+        Args:
+            api_key: Gemini API key (defaults to Config.GEMINI_API_KEY)
+        """
+        self.api_key = api_key or Config.GEMINI_API_KEY
+        if not self.api_key:
+            raise ValueError("Gemini API key is required")
+
+        genai.configure(api_key=self.api_key)
+
+        # Try Gemini 2.5 Flash, fallback to 2.0 Flash
+        try:
+            self.model = genai.GenerativeModel('gemini-2.5-flash')
+            self.model_name = 'gemini-2.5-flash'
+        except:
+            try:
+                self.model = genai.GenerativeModel('gemini-2.0-flash')
+                self.model_name = 'gemini-2.0-flash'
+            except:
+                self.model = genai.GenerativeModel('gemini-2.0-flash-exp')
+                self.model_name = 'gemini-2.0-flash-exp'
+
+        print(f"✅ CharacterExtractor using {self.model_name.upper().replace('-', ' ')}")
+
+    def extract_character_profile(
+        self,
+        image: Union[str, Image.Image, bytes],
+        character_name: Optional[str] = None
+    ) -> Dict:
+        """
+        Extract detailed character profile from image
+
+        Args:
+            image: Image file path, PIL Image, or bytes
+            character_name: Optional known character name
+
+        Returns:
+            Dictionary with character profile:
+            {
+                "name": str,
+                "physical_description": str,
+                "age_range": str,
+                "clothing": str,
+                "hair": str,
+                "facial_features": str,
+                "body_type": str,
+                "distinctive_features": List[str],
+                "color_palette": List[str],
+                "art_style": str,
+                "confidence_score": float
+            }
+        """
+        # Prepare image
+        if isinstance(image, str):
+            pil_image = Image.open(image)
+        elif isinstance(image, bytes):
+            pil_image = Image.open(BytesIO(image))
+        else:
+            pil_image = image
+
+        # Build extraction prompt
+        character_context = f"the character named {character_name}" if character_name else "the main character"
+
+        prompt = f"""Analyze this image and extract a detailed character profile for {character_context}.
+
+Provide a comprehensive analysis in JSON format with these fields:
+
+1. **name**: Character's apparent name or role (if visible in the image or provided)
+2. **physical_description**: Overall physical appearance (2-3 sentences)
+3. **age_range**: Estimated age range (e.g., "elderly", "young adult", "child")
+4. **clothing**: Detailed description of clothing, accessories, and attire
+5. **hair**: Hair color, style, length, and notable features
+6. **facial_features**: Detailed facial characteristics (eyes, nose, expression, wrinkles, etc.)
+7. **body_type**: Body build and posture (lean, muscular, stocky, etc.)
+8. **distinctive_features**: List of unique identifying features (scars, tattoos, jewelry, etc.)
+9. **color_palette**: Main colors associated with the character (clothing, hair, skin tone)
+10. **art_style**: The artistic style of the image (manga, anime, realistic, cartoon, etc.)
+11. **confidence_score**: Your confidence in this analysis (0.0 to 1.0)
+
+Be extremely detailed and precise. Focus on features that would ensure visual consistency across multiple images.
+
+Return ONLY valid JSON with no additional text."""
+
+        try:
+            # Generate analysis
+            response = self.model.generate_content([pil_image, prompt])
+
+            # Extract JSON from response
+            response_text = response.text.strip()
+
+            # Remove markdown code blocks if present
+            if response_text.startswith("```"):
+                lines = response_text.split("\n")
+                if lines[0].startswith("```"):
+                    lines = lines[1:]
+                if lines and lines[-1].strip() == "```":
+                    lines = lines[:-1]
+                response_text = "\n".join(lines)
+
+            # Parse JSON
+            character_profile = json.loads(response_text)
+
+            # Add character name if provided
+            if character_name:
+                character_profile["name"] = character_name
+
+            # Ensure all required fields exist
+            required_fields = [
+                "name", "physical_description", "age_range", "clothing",
+                "hair", "facial_features", "body_type", "distinctive_features",
+                "color_palette", "art_style", "confidence_score"
+            ]
+
+            for field in required_fields:
+                if field not in character_profile:
+                    character_profile[field] = "Unknown" if field != "distinctive_features" and field != "color_palette" else []
+
+            print(f"Extracted character profile for '{character_profile.get('name', 'Unknown')}'")
+            return character_profile
+
+        except json.JSONDecodeError as e:
+            print(f"Error parsing JSON response: {e}")
+            print(f"Raw response: {response_text}")
+
+            # Fallback: Create basic profile
+            return self._create_fallback_profile(character_name)
+
+        except Exception as e:
+            print(f"Error extracting character profile: {e}")
+            return self._create_fallback_profile(character_name)
+
+    def _create_fallback_profile(self, character_name: Optional[str] = None) -> Dict:
+        """Create a basic fallback profile when extraction fails"""
+        return {
+            "name": character_name or "Unknown",
+            "physical_description": "Unable to extract detailed description",
+            "age_range": "unknown",
+            "clothing": "unknown",
+            "hair": "unknown",
+            "facial_features": "unknown",
+            "body_type": "unknown",
+            "distinctive_features": [],
+            "color_palette": [],
+            "art_style": "unknown",
+            "confidence_score": 0.0
+        }
+
+    def generate_consistency_prompt(self, character_profile: Dict) -> str:
+        """
+        Generate a detailed consistency prompt from character profile
+
+        Args:
+            character_profile: Character profile dictionary
+
+        Returns:
+            Detailed prompt text for maintaining character consistency
+        """
+        prompt_parts = []
+
+        # Name
+        if character_profile.get("name") and character_profile["name"] != "Unknown":
+            prompt_parts.append(f"Character: {character_profile['name']}")
+
+        # Physical description
+        if character_profile.get("physical_description"):
+            prompt_parts.append(character_profile["physical_description"])
+
+        # Age
+        if character_profile.get("age_range") and character_profile["age_range"] != "unknown":
+            prompt_parts.append(f"Age: {character_profile['age_range']}")
+
+        # Hair
+        if character_profile.get("hair") and character_profile["hair"] != "unknown":
+            prompt_parts.append(f"Hair: {character_profile['hair']}")
+
+        # Clothing
+        if character_profile.get("clothing") and character_profile["clothing"] != "unknown":
+            prompt_parts.append(f"Clothing: {character_profile['clothing']}")
+
+        # Facial features
+        if character_profile.get("facial_features") and character_profile["facial_features"] != "unknown":
+            prompt_parts.append(f"Facial features: {character_profile['facial_features']}")
+
+        # Body type
+        if character_profile.get("body_type") and character_profile["body_type"] != "unknown":
+            prompt_parts.append(f"Body type: {character_profile['body_type']}")
+
+        # Distinctive features
+        if character_profile.get("distinctive_features") and character_profile["distinctive_features"]:
+            features_str = ", ".join(character_profile["distinctive_features"])
+            prompt_parts.append(f"Distinctive features: {features_str}")
+
+        # Art style
+        if character_profile.get("art_style") and character_profile["art_style"] != "unknown":
+            prompt_parts.append(f"Art style: {character_profile['art_style']}")
+
+        return ". ".join(prompt_parts)
+
+    def crop_character_from_image(
+        self,
+        image: Union[str, Image.Image, bytes],
+        character_name: Optional[str] = None
+    ) -> Optional[Image.Image]:
+        """
+        Attempt to crop the character from the image using Gemini Vision
+        (Note: Actual bounding box detection would require additional ML models like YOLO or SAM)
+
+        For now, this is a placeholder that returns the full image.
+        Future enhancement: Use object detection to crop character bounding box.
+
+        Args:
+            image: Image file path, PIL Image, or bytes
+            character_name: Optional character name for context
+
+        Returns:
+            Cropped PIL Image or None if failed
+        """
+        # Prepare image
+        if isinstance(image, str):
+            pil_image = Image.open(image)
+        elif isinstance(image, bytes):
+            pil_image = Image.open(BytesIO(image))
+        else:
+            pil_image = image
+
+        # TODO: Implement actual character cropping using object detection
+        # For now, return the full image as a placeholder
+        print(f"Character cropping not yet implemented. Returning full image.")
+        return pil_image
+
+    def compare_character_consistency(
+        self,
+        image1: Union[str, Image.Image, bytes],
+        image2: Union[str, Image.Image, bytes],
+        character_name: Optional[str] = None
+    ) -> Dict:
+        """
+        Compare two images to verify character consistency
+
+        Args:
+            image1: First image
+            image2: Second image
+            character_name: Optional character name
+
+        Returns:
+            Dictionary with consistency analysis:
+            {
+                "is_consistent": bool,
+                "consistency_score": float,
+                "differences": List[str],
+                "analysis": str
+            }
+        """
+        # Prepare images
+        if isinstance(image1, str):
+            pil_image1 = Image.open(image1)
+        elif isinstance(image1, bytes):
+            pil_image1 = Image.open(BytesIO(image1))
+        else:
+            pil_image1 = image1
+
+        if isinstance(image2, str):
+            pil_image2 = Image.open(image2)
+        elif isinstance(image2, bytes):
+            pil_image2 = Image.open(BytesIO(image2))
+        else:
+            pil_image2 = image2
+
+        character_context = f"the character {character_name}" if character_name else "the main character"
+
+        prompt = f"""Compare {character_context} in these two images and analyze visual consistency.
+
+Provide analysis in JSON format:
+
+1. **is_consistent**: true/false - Are the characters the same person?
+2. **consistency_score**: 0.0 to 1.0 - How consistent is the character appearance?
+3. **differences**: List of specific visual differences found
+4. **analysis**: Detailed explanation of your assessment
+
+Focus on:
+- Facial features (eyes, nose, face shape)
+- Hair (color, style, length)
+- Clothing and accessories
+- Body type and proportions
+- Art style consistency
+
+Return ONLY valid JSON."""
+
+        try:
+            response = self.model.generate_content([
+                "Image 1:", pil_image1,
+                "Image 2:", pil_image2,
+                prompt
+            ])
+
+            response_text = response.text.strip()
+
+            # Remove markdown code blocks
+            if response_text.startswith("```"):
+                lines = response_text.split("\n")
+                if lines[0].startswith("```"):
+                    lines = lines[1:]
+                if lines and lines[-1].strip() == "```":
+                    lines = lines[:-1]
+                response_text = "\n".join(lines)
+
+            consistency_result = json.loads(response_text)
+
+            print(f"Consistency score: {consistency_result.get('consistency_score', 0.0):.2f}")
+            return consistency_result
+
+        except Exception as e:
+            print(f"Error comparing character consistency: {e}")
+            return {
+                "is_consistent": False,
+                "consistency_score": 0.0,
+                "differences": ["Unable to analyze"],
+                "analysis": f"Error: {str(e)}"
+            }
+
+
+# Example usage
+if __name__ == "__main__":
+    extractor = CharacterExtractor()
+
+    print("=== Character Extractor Test ===")
+    print("Note: Requires actual image file to test")
+    print("Example usage:")
+    print("""
+    # Extract character profile
+    profile = extractor.extract_character_profile("panel1.png", character_name="Yogi")
+    print(json.dumps(profile, indent=2))
+
+    # Generate consistency prompt
+    consistency_prompt = extractor.generate_consistency_prompt(profile)
+    print(consistency_prompt)
+
+    # Compare consistency between two panels
+    consistency = extractor.compare_character_consistency("panel1.png", "panel3.png", "Yogi")
+    print(f"Consistency score: {consistency['consistency_score']}")
+    """)

comic_generator.py

@@ -0,0 +1,293 @@
+"""
+Comic Generator with Character Consistency Integration
+Safe wrapper that integrates character consistency system with automatic fallback to legacy system
+"""
+
+import asyncio
+import os
+from typing import Dict, List, Optional, Union
+from PIL import Image
+from config import Config
+
+# Try to import character consistency system (optional dependency)
+try:
+    from character_consistency_manager import CharacterConsistencyManager
+    CHARACTER_CONSISTENCY_AVAILABLE = True
+    print("✓ Character Consistency system available")
+except ImportError as e:
+    CHARACTER_CONSISTENCY_AVAILABLE = False
+    print(f"⚠️  Character Consistency not available - using legacy system")
+    print(f"   Import error: {e}")
+
+
+class ComicGeneratorWithConsistency:
+    """
+    Unified comic generator with character consistency support and legacy fallback
+
+    This class provides a safe integration layer between the new character consistency
+    system and the existing comic generation logic in app_comic.py
+
+    Behavior:
+    - If ENABLE_NANO_BANANA=true AND system available: Use character consistency
+    - If character consistency fails OR disabled: Automatic fallback to legacy system
+    - Legacy system always available as safety net
+    """
+
+    def __init__(self):
+        """Initialize comic generator with optional character consistency"""
+        self.consistency_enabled = (
+            CHARACTER_CONSISTENCY_AVAILABLE and
+            Config.ENABLE_NANO_BANANA
+        )
+
+        self.consistency_manager = None
+
+        if self.consistency_enabled:
+            try:
+                self.consistency_manager = CharacterConsistencyManager()
+                print("✓ Character Consistency Manager initialized")
+            except Exception as e:
+                print(f"⚠️  Failed to initialize Character Consistency: {e}")
+                print("🔄 Will use legacy system")
+                self.consistency_enabled = False
+
+        # Stats tracking
+        self.consistency_success_count = 0
+        self.consistency_failure_count = 0
+        self.fallback_count = 0
+
+    async def generate_comic_from_prompt(
+        self,
+        story_prompt: str,
+        num_panels: int = 3,
+        art_style: str = "manga",
+        include_surprise_character: bool = True,
+        force_legacy: bool = False,
+        output_dir: Optional[str] = None
+    ) -> Dict:
+        """
+        Generate comic with automatic character consistency or legacy fallback
+
+        Args:
+            story_prompt: User's story prompt
+            num_panels: Number of panels to generate
+            art_style: Art style for the comic
+            include_surprise_character: Add AI-generated surprise character
+            force_legacy: Force use of legacy system (for testing)
+            output_dir: Output directory for generated files
+
+        Returns:
+            Dictionary with generation results:
+            {
+                "success": bool,
+                "method": str,  # "character_consistency" or "legacy"
+                "panels": List[Image],
+                "characters": Dict[str, str],  # Only if character_consistency used
+                "output_dir": str,
+                "panel_info": List[Dict],  # Panel metadata
+                "error": Optional[str]
+            }
+        """
+
+        # Determine which system to use
+        use_consistency = (
+            self.consistency_enabled and
+            not force_legacy and
+            self.consistency_manager is not None
+        )
+
+        if use_consistency:
+            print(f"\n🎨 Generating comic with CHARACTER CONSISTENCY system...")
+            print(f"   Story: {story_prompt[:100]}...")
+            print(f"   Panels: {num_panels}, Style: {art_style}")
+
+            try:
+                result = await self._generate_with_consistency(
+                    story_prompt=story_prompt,
+                    num_panels=num_panels,
+                    art_style=art_style,
+                    include_surprise_character=include_surprise_character,
+                    output_dir=output_dir
+                )
+
+                if result["success"]:
+                    self.consistency_success_count += 1
+                    print(f"✓ Character consistency generation successful!")
+                    return result
+                else:
+                    print(f"⚠️  Character consistency failed: {result.get('error')}")
+                    print(f"🔄 Falling back to legacy system...")
+                    self.consistency_failure_count += 1
+
+            except Exception as e:
+                print(f"⚠️  Character consistency exception: {e}")
+                print(f"🔄 Falling back to legacy system...")
+                self.consistency_failure_count += 1
+
+        # Fallback to legacy system
+        self.fallback_count += 1
+        print(f"\n🎨 Generating comic with LEGACY system...")
+
+        return await self._generate_with_legacy(
+            story_prompt=story_prompt,
+            num_panels=num_panels,
+            art_style=art_style,
+            output_dir=output_dir
+        )
+
+    async def _generate_with_consistency(
+        self,
+        story_prompt: str,
+        num_panels: int,
+        art_style: str,
+        include_surprise_character: bool,
+        output_dir: Optional[str]
+    ) -> Dict:
+        """
+        Generate comic using character consistency system
+
+        This wraps the CharacterConsistencyManager.generate_comic_from_prompt method
+        in a safe async context with proper error handling
+        """
+
+        try:
+            # Call character consistency system (runs in executor for async compatibility)
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None,
+                self.consistency_manager.generate_comic_from_prompt,
+                story_prompt,
+                num_panels,
+                art_style,
+                include_surprise_character,
+                output_dir or "./auto_generated_comics"
+            )
+
+            # Add success flag and method
+            result["success"] = True
+            result["method"] = "character_consistency"
+
+            return result
+
+        except Exception as e:
+            return {
+                "success": False,
+                "method": "character_consistency",
+                "error": str(e),
+                "panels": [],
+                "characters": {},
+                "panel_info": []
+            }
+
+    async def _generate_with_legacy(
+        self,
+        story_prompt: str,
+        num_panels: int,
+        art_style: str,
+        output_dir: Optional[str]
+    ) -> Dict:
+        """
+        Generate comic using legacy system (placeholder for app_comic.py integration)
+
+        NOTE: This is a placeholder. In actual integration, this would call the
+        existing comic generation logic from app_comic.py
+
+        For now, returns a structure indicating legacy mode was used
+        """
+
+        return {
+            "success": True,
+            "method": "legacy",
+            "panels": [],
+            "characters": {},
+            "panel_info": [
+                {
+                    "panel_number": i + 1,
+                    "characters": [],
+                    "filename": f"legacy_panel_{i+1}.png"
+                }
+                for i in range(num_panels)
+            ],
+            "output_dir": output_dir or "./generated_comics",
+            "note": "Legacy system placeholder - integrate with app_comic.py logic"
+        }
+
+    def get_stats(self) -> Dict:
+        """Get generation statistics"""
+        total = self.consistency_success_count + self.consistency_failure_count + self.fallback_count
+
+        return {
+            "total_generations": total,
+            "consistency_enabled": self.consistency_enabled,
+            "consistency_available": CHARACTER_CONSISTENCY_AVAILABLE,
+            "consistency_successes": self.consistency_success_count,
+            "consistency_failures": self.consistency_failure_count,
+            "legacy_fallbacks": self.fallback_count,
+            "consistency_rate": (
+                f"{(self.consistency_success_count / total * 100):.1f}%"
+                if total > 0 else "N/A"
+            )
+        }
+
+    def print_stats(self):
+        """Print generation statistics"""
+        stats = self.get_stats()
+
+        print("\n" + "="*70)
+        print("  COMIC GENERATOR STATISTICS")
+        print("="*70)
+        print(f"Character Consistency Available: {stats['consistency_available']}")
+        print(f"Character Consistency Enabled:   {stats['consistency_enabled']}")
+        print(f"\nTotal Generations:               {stats['total_generations']}")
+        print(f"  ✓ Consistency Successes:       {stats['consistency_successes']}")
+        print(f"  ⚠ Consistency Failures:        {stats['consistency_failures']}")
+        print(f"  🔄 Legacy Fallbacks:            {stats['legacy_fallbacks']}")
+        print(f"\nConsistency Success Rate:        {stats['consistency_rate']}")
+        print("="*70)
+
+
+# Example usage and testing
+async def test_comic_generator():
+    """Test the comic generator with both systems"""
+
+    print("\n" + "="*70)
+    print("  COMIC GENERATOR TEST")
+    print("="*70)
+
+    generator = ComicGeneratorWithConsistency()
+
+    test_prompt = "A yogi teaching a young aspirant the rules of meditation and mindfulness leading to levitation by his own example in a beautiful vibrant colorful jungle"
+
+    # Test 1: Character consistency (if available)
+    print("\n--- Test 1: Character Consistency Mode ---")
+    result1 = await generator.generate_comic_from_prompt(
+        story_prompt=test_prompt,
+        num_panels=3,
+        art_style="manga",
+        include_surprise_character=True
+    )
+
+    print(f"\nResult: {result1['method']}")
+    print(f"Success: {result1['success']}")
+    if result1.get('characters'):
+        print(f"Characters: {list(result1['characters'].keys())}")
+
+    # Test 2: Force legacy mode
+    print("\n--- Test 2: Forced Legacy Mode ---")
+    result2 = await generator.generate_comic_from_prompt(
+        story_prompt=test_prompt,
+        num_panels=3,
+        art_style="manga",
+        force_legacy=True
+    )
+
+    print(f"\nResult: {result2['method']}")
+    print(f"Success: {result2['success']}")
+
+    # Print stats
+    generator.print_stats()
+
+
+if __name__ == "__main__":
+    # Run test
+    asyncio.run(test_comic_generator())

comic_layout.py

@@ -0,0 +1,403 @@
+"""Comic Panel Layout System for MythForge
+
+Creates professional manga page layouts by compositing individual panels
+into 2x3 grids with proper spacing, borders, and gutters.
+"""
+
+from typing import List, Tuple, Optional
+from PIL import Image, ImageDraw
+from config import Config
+
+
+class ComicLayout:
+    """Comic panel layout compositor for manga pages"""
+
+    def __init__(self):
+        """Initialize comic layout system"""
+        # Default manga page dimensions
+        self.panel_width = Config.COMIC_PANEL_WIDTH  # 1024
+        self.panel_height = Config.COMIC_PANEL_HEIGHT  # 1024
+
+        # Layout settings
+        self.gutter_width = 20  # Space between panels
+        self.page_margin = 40  # Margin around entire page
+        self.border_width = 3  # Panel border thickness
+        self.border_color = (0, 0, 0)  # Black borders
+
+    def create_manga_page(
+        self,
+        panels: List[Image.Image],
+        layout: str = "2x3"
+    ) -> Image.Image:
+        """
+        Create a manga page from 6 panels in 2x3 grid
+
+        Args:
+            panels: List of 6 PIL Images (should be 1024x1024)
+            layout: Layout type (default "2x3" for manga)
+
+        Returns:
+            Composite manga page as single PIL Image
+        """
+        if len(panels) != 6:
+            raise ValueError(f"Expected 6 panels for 2x3 layout, got {len(panels)}")
+
+        # Calculate page dimensions
+        cols, rows = self._parse_layout(layout)
+
+        page_width = (
+            2 * self.page_margin +
+            cols * self.panel_width +
+            (cols - 1) * self.gutter_width
+        )
+
+        page_height = (
+            2 * self.page_margin +
+            rows * self.panel_height +
+            (rows - 1) * self.gutter_width
+        )
+
+        # Create white background
+        page = Image.new('RGB', (page_width, page_height), color='white')
+
+        # Paste panels in 2x3 grid
+        for idx, panel in enumerate(panels):
+            row = idx // cols
+            col = idx % cols
+
+            # Calculate position
+            x = self.page_margin + col * (self.panel_width + self.gutter_width)
+            y = self.page_margin + row * (self.panel_height + self.gutter_width)
+
+            # Resize panel if needed
+            if panel.size != (self.panel_width, self.panel_height):
+                panel = panel.resize(
+                    (self.panel_width, self.panel_height),
+                    Image.Resampling.LANCZOS
+                )
+
+            # Paste panel
+            page.paste(panel, (x, y))
+
+            # Draw border
+            if self.border_width > 0:
+                self._draw_panel_border(page, x, y)
+
+        return page
+
+    def create_horizontal_strip(
+        self,
+        panels: List[Image.Image],
+        max_panels: int = 3
+    ) -> Image.Image:
+        """
+        Create horizontal webcomic strip (3 panels side-by-side)
+
+        Args:
+            panels: List of PIL Images
+            max_panels: Maximum panels per row (default 3)
+
+        Returns:
+            Horizontal comic strip
+        """
+        num_panels = min(len(panels), max_panels)
+
+        strip_width = (
+            2 * self.page_margin +
+            num_panels * self.panel_width +
+            (num_panels - 1) * self.gutter_width
+        )
+
+        strip_height = 2 * self.page_margin + self.panel_height
+
+        # Create white background
+        strip = Image.new('RGB', (strip_width, strip_height), color='white')
+
+        # Paste panels horizontally
+        for idx in range(num_panels):
+            panel = panels[idx]
+
+            x = self.page_margin + idx * (self.panel_width + self.gutter_width)
+            y = self.page_margin
+
+            # Resize if needed
+            if panel.size != (self.panel_width, self.panel_height):
+                panel = panel.resize(
+                    (self.panel_width, self.panel_height),
+                    Image.Resampling.LANCZOS
+                )
+
+            strip.paste(panel, (x, y))
+
+            # Draw border
+            if self.border_width > 0:
+                self._draw_panel_border(strip, x, y)
+
+        return strip
+
+    def create_vertical_scroll(
+        self,
+        panels: List[Image.Image]
+    ) -> Image.Image:
+        """
+        Create vertical webtoon-style scroll (all panels stacked)
+
+        Args:
+            panels: List of PIL Images
+
+        Returns:
+            Vertical comic scroll
+        """
+        num_panels = len(panels)
+
+        scroll_width = 2 * self.page_margin + self.panel_width
+
+        scroll_height = (
+            2 * self.page_margin +
+            num_panels * self.panel_height +
+            (num_panels - 1) * self.gutter_width
+        )
+
+        # Create white background
+        scroll = Image.new('RGB', (scroll_width, scroll_height), color='white')
+
+        # Paste panels vertically
+        for idx, panel in enumerate(panels):
+            x = self.page_margin
+            y = self.page_margin + idx * (self.panel_height + self.gutter_width)
+
+            # Resize if needed
+            if panel.size != (self.panel_width, self.panel_height):
+                panel = panel.resize(
+                    (self.panel_width, self.panel_height),
+                    Image.Resampling.LANCZOS
+                )
+
+            scroll.paste(panel, (x, y))
+
+            # Draw border
+            if self.border_width > 0:
+                self._draw_panel_border(scroll, x, y)
+
+        return scroll
+
+    def create_custom_layout(
+        self,
+        panels: List[Image.Image],
+        grid: Tuple[int, int]
+    ) -> Image.Image:
+        """
+        Create custom grid layout (e.g., 3x2, 4x2, etc.)
+
+        Args:
+            panels: List of PIL Images
+            grid: Tuple of (columns, rows)
+
+        Returns:
+            Custom layout comic page
+        """
+        cols, rows = grid
+        expected_panels = cols * rows
+
+        if len(panels) != expected_panels:
+            raise ValueError(
+                f"Expected {expected_panels} panels for {cols}x{rows} grid, "
+                f"got {len(panels)}"
+            )
+
+        page_width = (
+            2 * self.page_margin +
+            cols * self.panel_width +
+            (cols - 1) * self.gutter_width
+        )
+
+        page_height = (
+            2 * self.page_margin +
+            rows * self.panel_height +
+            (rows - 1) * self.gutter_width
+        )
+
+        # Create white background
+        page = Image.new('RGB', (page_width, page_height), color='white')
+
+        # Paste panels in grid
+        for idx, panel in enumerate(panels):
+            row = idx // cols
+            col = idx % cols
+
+            x = self.page_margin + col * (self.panel_width + self.gutter_width)
+            y = self.page_margin + row * (self.panel_height + self.gutter_width)
+
+            # Resize if needed
+            if panel.size != (self.panel_width, self.panel_height):
+                panel = panel.resize(
+                    (self.panel_width, self.panel_height),
+                    Image.Resampling.LANCZOS
+                )
+
+            page.paste(panel, (x, y))
+
+            # Draw border
+            if self.border_width > 0:
+                self._draw_panel_border(page, x, y)
+
+        return page
+
+    def _draw_panel_border(self, image: Image.Image, x: int, y: int):
+        """Draw border around a panel"""
+        draw = ImageDraw.Draw(image)
+
+        # Draw rectangle border
+        draw.rectangle(
+            [
+                (x, y),
+                (x + self.panel_width, y + self.panel_height)
+            ],
+            outline=self.border_color,
+            width=self.border_width
+        )
+
+    def _parse_layout(self, layout: str) -> Tuple[int, int]:
+        """Parse layout string into (columns, rows)"""
+        if layout == "2x3":
+            return (2, 3)
+        elif layout == "3x2":
+            return (3, 2)
+        elif layout == "1x6":
+            return (1, 6)
+        elif layout == "6x1":
+            return (6, 1)
+        elif "x" in layout:
+            parts = layout.split("x")
+            return (int(parts[0]), int(parts[1]))
+        else:
+            raise ValueError(f"Invalid layout format: {layout}")
+
+    def get_page_dimensions(self, layout: str = "2x3") -> Tuple[int, int]:
+        """
+        Get final page dimensions for a layout
+
+        Args:
+            layout: Layout string (e.g., "2x3")
+
+        Returns:
+            Tuple of (width, height) in pixels
+        """
+        cols, rows = self._parse_layout(layout)
+
+        width = (
+            2 * self.page_margin +
+            cols * self.panel_width +
+            (cols - 1) * self.gutter_width
+        )
+
+        height = (
+            2 * self.page_margin +
+            rows * self.panel_height +
+            (rows - 1) * self.gutter_width
+        )
+
+        return (width, height)
+
+    def set_style(
+        self,
+        gutter_width: Optional[int] = None,
+        border_width: Optional[int] = None,
+        border_color: Optional[Tuple[int, int, int]] = None,
+        page_margin: Optional[int] = None
+    ):
+        """
+        Customize layout style
+
+        Args:
+            gutter_width: Space between panels
+            border_width: Panel border thickness
+            border_color: RGB tuple for borders
+            page_margin: Margin around page
+        """
+        if gutter_width is not None:
+            self.gutter_width = gutter_width
+        if border_width is not None:
+            self.border_width = border_width
+        if border_color is not None:
+            self.border_color = border_color
+        if page_margin is not None:
+            self.page_margin = page_margin
+
+
+# Test/demo function
+if __name__ == "__main__":
+    print("=" * 60)
+    print("COMIC LAYOUT SYSTEM TEST")
+    print("=" * 60)
+    print()
+
+    layout = ComicLayout()
+
+    # Show default settings
+    print("Default Settings:")
+    print(f"  Panel size: {layout.panel_width}x{layout.panel_height}")
+    print(f"  Gutter width: {layout.gutter_width}px")
+    print(f"  Border width: {layout.border_width}px")
+    print(f"  Page margin: {layout.page_margin}px")
+    print()
+
+    # Calculate dimensions
+    print("Layout Dimensions:")
+    print("-" * 60)
+
+    layouts = ["2x3", "3x2", "1x6", "6x1"]
+    for layout_name in layouts:
+        width, height = layout.get_page_dimensions(layout_name)
+        print(f"{layout_name} layout: {width}x{height} pixels")
+
+    print()
+
+    # Create test panels
+    print("Creating test manga page...")
+    print()
+
+    # Create 6 colored test panels
+    test_panels = []
+    colors = [
+        (255, 200, 200),  # Light red
+        (200, 255, 200),  # Light green
+        (200, 200, 255),  # Light blue
+        (255, 255, 200),  # Light yellow
+        (255, 200, 255),  # Light magenta
+        (200, 255, 255)   # Light cyan
+    ]
+
+    for i, color in enumerate(colors):
+        panel = Image.new('RGB', (1024, 1024), color=color)
+        # Add panel number
+        from PIL import ImageDraw, ImageFont
+        draw = ImageDraw.Draw(panel)
+        text = f"Panel {i+1}"
+        # Use default font
+        draw.text((512, 512), text, fill=(0, 0, 0), anchor='mm')
+        test_panels.append(panel)
+
+    # Create manga page
+    manga_page = layout.create_manga_page(test_panels, layout="2x3")
+
+    # Save test output
+    output_path = "test_manga_page.png"
+    manga_page.save(output_path)
+
+    print(f"✅ Test manga page created: {output_path}")
+    print(f"   Dimensions: {manga_page.size}")
+    print()
+
+    # Create horizontal strip
+    strip = layout.create_horizontal_strip(test_panels[:3])
+    strip_path = "test_comic_strip.png"
+    strip.save(strip_path)
+
+    print(f"✅ Test comic strip created: {strip_path}")
+    print(f"   Dimensions: {strip.size}")
+    print()
+
+    print("=" * 60)
+    print("Test complete! Check output images.")
+    print("=" * 60)

config.py

@@ -0,0 +1,74 @@
+"""Configuration management for MythForge AI"""
+import os
+from dotenv import load_dotenv
+
+# Load .env file with override=True to ensure .env values take precedence
+load_dotenv(override=True)
+
+class Config:
+    """Application configuration"""
+    
+    # OpenAI Configuration
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+    OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")  # Default to gpt-4o-mini, can use gpt-3.5-turbo or gpt-4
+    
+    # HuggingFace Configuration (V2+)
+    HUGGINGFACE_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+    
+    # ElevenLabs Configuration (V4+)
+    ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
+    
+    # Gemini Configuration (V6+)
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+    
+    # Optional Services
+    MODAL_TOKEN = os.getenv("MODAL_TOKEN")
+    SAMBANOVA_API_KEY = os.getenv("SAMBANOVA_API_KEY")
+    NEBIUS_API_KEY = os.getenv("NEBIUS_API_KEY")
+    BLAXEL_API_KEY = os.getenv("BLAXEL_API_KEY")
+
+    # Feature Flags for Comic Mode (Step 1)
+    ENABLE_COMIC_MODE = os.getenv("ENABLE_COMIC_MODE", "false").lower() == "true"
+    ENABLE_BLAXEL = os.getenv("ENABLE_BLAXEL", "false").lower() == "true"
+    ENABLE_MODAL = os.getenv("ENABLE_MODAL", "false").lower() == "true"
+    ENABLE_SAMBANOVA = os.getenv("ENABLE_SAMBANOVA", "false").lower() == "true"
+
+    # MCP Server Feature Flag (for backward compatibility)
+    ENABLE_MCP = os.getenv("ENABLE_MCP", "false").lower() == "true"
+
+
+    # New Sponsor Feature Flags (Hackathon)
+    ENABLE_LLAMAINDEX = os.getenv("ENABLE_LLAMAINDEX", "true").lower() == "true"  # Default ON
+    ENABLE_GEMINI = os.getenv("ENABLE_GEMINI", "false").lower() == "true"
+    ENABLE_OPENAI_FALLBACK = os.getenv("ENABLE_OPENAI_FALLBACK", "true").lower() == "true"  # Default ON
+    ENABLE_BLAXEL_WORKFLOW = os.getenv("ENABLE_BLAXEL_WORKFLOW", "false").lower() == "true"  # Use Blaxel orchestration instead of direct calls
+
+    # Text Generation Priority (for prize optimization)
+    USE_OPENAI_PRIMARY = os.getenv("USE_OPENAI_PRIMARY", "true").lower() == "true"  # true = OpenAI first ($1k prize), false = SambaNova first
+
+    # Nano Banana (Gemini Image) Configuration
+    ENABLE_NANO_BANANA = os.getenv("ENABLE_NANO_BANANA", "false").lower() == "true"
+    NANO_BANANA_MODEL = os.getenv("NANO_BANANA_MODEL", "gemini-2.5-flash-image")  # Options: gemini-2.5-flash-image, gemini-3-pro-image-preview
+    NANO_BANANA_MAX_REFERENCES = int(os.getenv("NANO_BANANA_MAX_REFERENCES", "14"))  # Up to 14 reference images
+    ENABLE_CHARACTER_LIBRARY = os.getenv("ENABLE_CHARACTER_LIBRARY", "false").lower() == "true"  # Multimodal character persistence
+
+    # Character Consistency Fallback Configuration
+    NANO_BANANA_AUTO_FALLBACK = os.getenv("NANO_BANANA_AUTO_FALLBACK", "true").lower() == "true"  # Auto fallback to legacy on error
+    NANO_BANANA_FALLBACK_ON_QUOTA = os.getenv("NANO_BANANA_FALLBACK_ON_QUOTA", "true").lower() == "true"  # Fallback on quota exceeded
+    NANO_BANANA_MAX_RETRY = int(os.getenv("NANO_BANANA_MAX_RETRY", "2"))  # Max retries before fallback
+
+    # Application Settings
+    MAX_STORY_LENGTH = 2000
+    DEFAULT_TEMPERATURE = 0.7
+
+    # Comic Mode Settings (Step 1)
+    COMIC_PANEL_COUNT = 6  # Manga style: 2x3 grid
+    COMIC_PANEL_WIDTH = 1024  # For SDXL
+    COMIC_PANEL_HEIGHT = 1024
+    
+    @classmethod
+    def validate_v1(cls):
+        """Validate V1 configuration"""
+        if not cls.OPENAI_API_KEY:
+            raise ValueError("OPENAI_API_KEY is required. Please set it in .env file")
+        return True

demo_automatic_comic.py

@@ -0,0 +1,175 @@
+"""
+Demo: Fully Automatic Comic Generation
+User provides ONLY a text prompt - system does everything automatically
+"""
+
+from character_consistency_manager import CharacterConsistencyManager
+
+
+def demo_yogi_auto():
+    """Demo: Automatic yogi story with surprise character"""
+    print("="*70)
+    print("  DEMO: FULLY AUTOMATIC COMIC GENERATION")
+    print("  User provides ONE sentence - System does EVERYTHING")
+    print("="*70)
+
+    manager = CharacterConsistencyManager()
+
+    # User's simple prompt - that's ALL they provide!
+    user_prompt = "A yogi teaching a young aspirant the rules of meditation and mindfulness leading to levitation by his own example in a beautiful vibrant colorful jungle"
+
+    print(f"\n📝 User Input:")
+    print(f'   "{user_prompt}"')
+    print(f"\n🤖 System will automatically:")
+    print(f"   1. Extract all characters (Yogi, Aspirant)")
+    print(f"   2. Add a surprise character for intrigue")
+    print(f"   3. Generate detailed descriptions for each")
+    print(f"   4. Create reference sheets for each character")
+    print(f"   5. Break story into 3 panels")
+    print(f"   6. Generate all panels with consistent characters")
+    print(f"\nStarting automatic generation...\n")
+
+    # ONE LINE OF CODE!
+    result = manager.generate_comic_from_prompt(
+        story_prompt=user_prompt,
+        num_panels=3,
+        art_style="manga",
+        include_surprise_character=True
+    )
+
+    print("\n" + "="*70)
+    print("  RESULTS")
+    print("="*70)
+    print(f"\nCharacters automatically created:")
+    for char_name in result["characters"].keys():
+        if char_name == result["surprise_character"]:
+            print(f"  🎁 {char_name} (SURPRISE!)")
+        else:
+            print(f"  📖 {char_name}")
+
+    print(f"\nPanels generated: {len(result['panels'])}")
+    for panel_info in result["panel_info"]:
+        print(f"  Panel {panel_info['panel_number']}: {', '.join(panel_info['characters'])}")
+        print(f"    File: {panel_info['filename']}")
+
+    print(f"\n✅ Complete comic saved to: {result['output_dir']}")
+
+
+def demo_custom_story():
+    """Demo: User provides their own story"""
+    print("\n" + "="*70)
+    print("  CUSTOM STORY DEMO")
+    print("="*70)
+
+    manager = CharacterConsistencyManager()
+
+    print("\n📝 Enter your story idea (or press Enter for default):")
+    print("   Example: A wizard teaching magic to an apprentice in a castle")
+
+    user_story = input("\n> ").strip()
+
+    if not user_story:
+        user_story = "A wise old wizard teaching a young apprentice powerful magic spells in an ancient castle library, accidentally summoning something unexpected"
+
+    print(f"\n🤖 Generating comic from: '{user_story}'")
+
+    result = manager.generate_comic_from_prompt(
+        story_prompt=user_story,
+        num_panels=3,
+        art_style="fantasy",
+        include_surprise_character=True
+    )
+
+    print(f"\n✅ Comic saved to: {result['output_dir']}")
+
+
+def compare_before_after():
+    """Show the difference: Manual vs Automatic"""
+    print("\n" + "="*70)
+    print("  COMPARISON: MANUAL vs AUTOMATIC")
+    print("="*70)
+
+    print("\n❌ OLD WAY (Manual - Lots of code):")
+    print("""
+    manager = CharacterConsistencyManager()
+
+    # User has to manually specify EVERYTHING
+    yogi = manager.create_character(
+        "Elderly yogi, white beard, saffron robes...",
+        "Master Yogi",
+        "manga"
+    )
+
+    aspirant = manager.create_character(
+        "Young boy, short hair, white clothes...",
+        "Young Aspirant",
+        "manga"
+    )
+
+    # Manually generate each panel
+    panel1 = manager.generate_panel_with_character(...)
+    panel2 = manager.generate_panel_with_multiple_characters(...)
+    panel3 = manager.generate_panel_with_multiple_characters(...)
+
+    # ~20+ lines of code, character hardcoding
+    """)
+
+    print("\n✅ NEW WAY (Automatic - ONE line):")
+    print("""
+    manager = CharacterConsistencyManager()
+
+    # User just provides a story prompt!
+    result = manager.generate_comic_from_prompt(
+        "A yogi teaching a young aspirant meditation and levitation in a jungle"
+    )
+
+    # Done! System automatically:
+    # - Extracted: Yogi, Aspirant
+    # - Added: Surprise character (e.g., Forest Spirit)
+    # - Generated: All character sheets
+    # - Created: 3 consistent panels
+    # - Saved: Everything to disk
+
+    # Just 1 line of code!
+    """)
+
+    print("\n🚀 Benefit: 95% less code, 100% automatic!")
+
+
+def main():
+    print("\n" + "="*70)
+    print("  AUTOMATIC COMIC GENERATION DEMOS")
+    print("  No hardcoding - Just provide a story prompt!")
+    print("="*70)
+
+    print("\nSelect demo:")
+    print("  1. Yogi Story (automatic with surprise character)")
+    print("  2. Custom Story (enter your own idea)")
+    print("  3. Show Comparison (Manual vs Automatic)")
+    print("  4. Run all demos")
+    print("="*70)
+
+    choice = input("\nEnter choice (1-4): ").strip()
+
+    if choice == "1":
+        demo_yogi_auto()
+    elif choice == "2":
+        demo_custom_story()
+    elif choice == "3":
+        compare_before_after()
+    elif choice == "4":
+        compare_before_after()
+        input("\nPress Enter to run Yogi demo...")
+        demo_yogi_auto()
+        input("\nPress Enter to run Custom Story...")
+        demo_custom_story()
+    else:
+        print("Invalid choice!")
+
+    print("\n" + "="*70)
+    print("  ✅ DEMO COMPLETE")
+    print("="*70)
+
+
+if __name__ == "__main__":
+    main()

export_service.py

@@ -0,0 +1,870 @@
+"""Export Service for generating downloadable files"""
+import io
+import os
+import zipfile
+from typing import List, Dict, Optional
+from PIL import Image
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.platypus import Image as RLImage
+
+class ExportService:
+    """Generate downloadable files from stories"""
+    
+    def generate_pdf(self, story_text: str, images: List[Image.Image] = None, metadata: dict = None) -> bytes:
+        """
+        Generate PDF with story text and images
+        
+        Args:
+            story_text: The story text
+            images: List of PIL Images
+            metadata: Story metadata
+            
+        Returns:
+            PDF file as bytes
+        """
+        buffer = io.BytesIO()
+        doc = SimpleDocTemplate(buffer, pagesize=letter)
+        story = []
+        styles = getSampleStyleSheet()
+        
+        # Title
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Heading1'],
+            fontSize=24,
+            spaceAfter=30
+        )
+        story.append(Paragraph("MythForge AI Story", title_style))
+        story.append(Spacer(1, 0.2*inch))
+        
+        # Metadata
+        if metadata:
+            meta_text = f"Style: {metadata.get('style', 'N/A')} | Tone: {metadata.get('tone', 'N/A')}"
+            story.append(Paragraph(meta_text, styles['Normal']))
+            story.append(Spacer(1, 0.3*inch))
+        
+        # Story text
+        paragraphs = story_text.split('\n\n')
+        for para in paragraphs:
+            if para.strip():
+                story.append(Paragraph(para.strip(), styles['BodyText']))
+                story.append(Spacer(1, 0.2*inch))
+        
+        # Images
+        if images:
+            story.append(PageBreak())
+            story.append(Paragraph("Illustrations", styles['Heading2']))
+            story.append(Spacer(1, 0.2*inch))
+            
+            for img in images:
+                # Save image to buffer
+                img_buffer = io.BytesIO()
+                img.save(img_buffer, format='PNG')
+                img_buffer.seek(0)
+                
+                # Add to PDF
+                rl_img = RLImage(img_buffer, width=4*inch, height=4*inch)
+                story.append(rl_img)
+                story.append(Spacer(1, 0.3*inch))
+        
+        # Build PDF
+        doc.build(story)
+        buffer.seek(0)
+        return buffer.getvalue()
+
+    def generate_comic_pdf(
+        self,
+        comic_page: Image.Image,
+        title: str = "MythForge Comic",
+        metadata: Optional[Dict] = None
+    ) -> bytes:
+        """
+        Generate PDF with comic page
+
+        Args:
+            comic_page: Composite manga page (2148x3192)
+            title: Comic title
+            metadata: Comic metadata
+
+        Returns:
+            PDF file as bytes
+        """
+        buffer = io.BytesIO()
+
+        # Use letter size with custom margins for better fit
+        from reportlab.lib.pagesizes import letter
+        doc = SimpleDocTemplate(
+            buffer,
+            pagesize=letter,
+            leftMargin=0.5*inch,
+            rightMargin=0.5*inch,
+            topMargin=0.5*inch,
+            bottomMargin=0.5*inch
+        )
+        story = []
+        styles = getSampleStyleSheet()
+
+        # Title page
+        title_style = ParagraphStyle(
+            'ComicTitle',
+            parent=styles['Heading1'],
+            fontSize=24,
+            spaceAfter=15,
+            alignment=1  # Center
+        )
+        story.append(Spacer(1, 0.5*inch))
+        story.append(Paragraph(title, title_style))
+        story.append(Spacer(1, 0.2*inch))
+
+        # Metadata
+        if metadata:
+            meta_style = ParagraphStyle(
+                'Metadata',
+                parent=styles['Normal'],
+                fontSize=10,
+                alignment=1
+            )
+            if metadata.get('style'):
+                story.append(Paragraph(f"Style: {metadata['style']}", meta_style))
+            if metadata.get('prompt'):
+                prompt_text = metadata['prompt'][:80] + "..." if len(metadata['prompt']) > 80 else metadata['prompt']
+                story.append(Paragraph(f"{prompt_text}", meta_style))
+            story.append(Spacer(1, 0.15*inch))
+
+        story.append(Paragraph("Generated with MythForge AI", styles['Italic']))
+        story.append(PageBreak())
+
+        # Comic page - scale to fit page width while maintaining aspect ratio
+        img_buffer = io.BytesIO()
+        comic_page.save(img_buffer, format='PNG')
+        img_buffer.seek(0)
+
+        # Calculate scaled dimensions (manga page is 2148x3192)
+        # Letter page usable area: ~7.5" x 10" after margins
+        page_width = 7.5 * inch
+        page_height = 10 * inch
+
+        # Manga aspect ratio: 2148/3192 = 0.673
+        img_aspect = comic_page.width / comic_page.height
+
+        # Scale to fit width
+        scaled_width = page_width * 0.95  # 95% of page width for safety
+        scaled_height = scaled_width / img_aspect
+
+        # If height is too large, scale by height instead
+        if scaled_height > page_height:
+            scaled_height = page_height * 0.95
+            scaled_width = scaled_height * img_aspect
+
+        rl_img = RLImage(img_buffer, width=scaled_width, height=scaled_height)
+        story.append(rl_img)
+
+        # Build PDF
+        doc.build(story)
+        buffer.seek(0)
+        return buffer.getvalue()
+
+    def generate_comic_zip(
+        self,
+        comic_page: Image.Image,
+        panel_images: List[Image.Image],
+        audio_files: List[str],
+        title: str = "MythForge_Comic",
+        metadata: Optional[Dict] = None
+    ) -> bytes:
+        """
+        Generate ZIP archive with all comic assets
+
+        Args:
+            comic_page: Composite manga page
+            panel_images: List of 6 individual panel images
+            audio_files: List of 6 panel audio file paths
+            title: Comic title (used for filenames)
+            metadata: Comic metadata
+
+        Returns:
+            ZIP file as bytes
+        """
+        buffer = io.BytesIO()
+
+        with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            # Add comic page
+            img_buffer = io.BytesIO()
+            comic_page.save(img_buffer, format='PNG')
+            zip_file.writestr(f"{title}_full_page.png", img_buffer.getvalue())
+
+            # Add individual panels
+            for i, panel in enumerate(panel_images):
+                panel_buffer = io.BytesIO()
+                panel.save(panel_buffer, format='PNG')
+                zip_file.writestr(f"{title}_panel_{i+1}.png", panel_buffer.getvalue())
+
+            # Add audio files
+            for i, audio_path in enumerate(audio_files):
+                if audio_path and os.path.exists(audio_path):
+                    with open(audio_path, 'rb') as f:
+                        zip_file.writestr(f"{title}_panel_{i+1}_audio.mp3", f.read())
+
+            # Add metadata as JSON
+            if metadata:
+                import json
+                metadata_str = json.dumps(metadata, indent=2)
+                zip_file.writestr(f"{title}_metadata.json", metadata_str)
+
+            # Add README
+            readme = self._generate_readme(title, metadata)
+            zip_file.writestr("README.txt", readme)
+
+        buffer.seek(0)
+        return buffer.getvalue()
+
+    def generate_web_package(
+        self,
+        comic_page: Image.Image,
+        audio_files: List[str],
+        title: str = "MythForge_Comic",
+        metadata: Optional[Dict] = None
+    ) -> bytes:
+        """
+        Generate web-ready package with HTML viewer
+
+        Args:
+            comic_page: Composite manga page
+            audio_files: List of panel audio file paths
+            title: Comic title
+            metadata: Comic metadata
+
+        Returns:
+            ZIP file with HTML viewer as bytes
+        """
+        buffer = io.BytesIO()
+
+        with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            # Add comic page
+            img_buffer = io.BytesIO()
+            comic_page.save(img_buffer, format='PNG')
+            zip_file.writestr("comic.png", img_buffer.getvalue())
+
+            # Add audio files (intro + panels + conclusion)
+            if audio_files:
+                # First file is intro
+                if len(audio_files) > 0 and audio_files[0] and os.path.exists(audio_files[0]):
+                    with open(audio_files[0], 'rb') as f:
+                        zip_file.writestr("audio/intro.mp3", f.read())
+
+                # Middle files are panels
+                panel_count = len(audio_files) - 2 if len(audio_files) > 2 else 0
+                for i in range(panel_count):
+                    audio_path = audio_files[i + 1]
+                    if audio_path and os.path.exists(audio_path):
+                        with open(audio_path, 'rb') as f:
+                            zip_file.writestr(f"audio/panel_{i+1}.mp3", f.read())
+
+                # Last file is conclusion
+                if len(audio_files) > 1 and audio_files[-1] and os.path.exists(audio_files[-1]):
+                    with open(audio_files[-1], 'rb') as f:
+                        zip_file.writestr("audio/conclusion.mp3", f.read())
+
+            # Add HTML viewer (panel_count excludes intro/conclusion)
+            panel_count = max(0, len(audio_files) - 2) if audio_files else 6
+            html_content = self._generate_html_viewer(title, panel_count, metadata)
+            zip_file.writestr("index.html", html_content)
+
+            # Add CSS
+            css_content = self._generate_css()
+            zip_file.writestr("style.css", css_content)
+
+            # Add JavaScript
+            js_content = self._generate_javascript(len(audio_files))
+            zip_file.writestr("comic.js", js_content)
+
+        buffer.seek(0)
+        return buffer.getvalue()
+
+    def _generate_readme(self, title: str, metadata: Optional[Dict]) -> str:
+        """Generate README for ZIP package"""
+        readme = f"""
+{title}
+{'=' * len(title)}
+
+Generated with MythForge AI Comic Generator
+
+Contents:
+---------
+- {title}_full_page.png       : Complete 6-panel manga page (2148x3192)
+- {title}_panel_1.png to _6   : Individual panel images (1024x1024 each)
+- {title}_panel_1_audio.mp3 to _6 : Audio narration for each panel
+- {title}_metadata.json       : Comic metadata and generation info
+- README.txt                  : This file
+
+"""
+        if metadata:
+            readme += "\nMetadata:\n---------\n"
+            if metadata.get('prompt'):
+                readme += f"Story Prompt: {metadata['prompt']}\n"
+            if metadata.get('style'):
+                readme += f"Visual Style: {metadata['style']}\n"
+            if metadata.get('timestamp'):
+                readme += f"Generated: {metadata['timestamp']}\n"
+
+        readme += """
+Usage:
+------
+- View the full comic page in any image viewer
+- Play panel audio files sequentially while viewing
+- Use individual panels for editing or social media
+- metadata.json contains the story data in JSON format
+
+For best experience, open the web viewer (if included) in a browser.
+
+Powered by:
+-----------
+- SambaNova Llama 3.1 70B (Story Generation)
+- Stable Diffusion XL (Image Generation)
+- ElevenLabs (Voice Synthesis)
+"""
+        return readme
+
+    def _generate_html_viewer(self, title: str, panel_count: int, metadata: Optional[Dict]) -> str:
+        """Generate HTML viewer for web package"""
+        html = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{title} - MythForge Comic</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>{title}</h1>
+            <p class="tagline">Generated with MythForge AI</p>
+        </header>
+
+        <main>
+            <div class="comic-viewer">
+                <img src="comic.png" alt="{title}" id="comic-page" />
+
+                <div class="panel-overlay">
+"""
+        # Add clickable panel regions (2x3 grid)
+        # Panel positions based on comic_layout.py dimensions
+        panel_positions = [
+            (0, 0),      # Panel 1: top-left
+            (1, 0),      # Panel 2: top-right
+            (0, 1),      # Panel 3: middle-left
+            (1, 1),      # Panel 4: middle-right
+            (0, 2),      # Panel 5: bottom-left
+            (1, 2),      # Panel 6: bottom-right
+        ]
+
+        for i, (col, row) in enumerate(panel_positions):
+            panel_num = i + 1
+            html += f'                    <div class="panel-region" data-panel="{panel_num}" data-panel-label="Panel {panel_num}" data-col="{col}" data-row="{row}"></div>\n'
+
+        html += """                </div>
+            </div>
+
+            <div class="audio-controls">
+                <div id="current-panel-indicator">Now Playing: Introduction</div>
+                <h2>Comic Audio Tracks</h2>
+                <div class="audio-grid">
+                    <div class="audio-item">
+                        <span>📖 Introduction</span>
+                        <audio id="audio-intro" src="audio/intro.mp3" preload="auto"></audio>
+                        <button onclick="playTrack('intro')">▶ Play</button>
+                    </div>
+"""
+        for i in range(panel_count):
+            html += f"""                    <div class="audio-item">
+                        <span>Panel {i+1}</span>
+                        <audio id="audio-{i+1}" src="audio/panel_{i+1}.mp3" preload="auto"></audio>
+                        <button onclick="playPanel({i+1})">▶ Play</button>
+                    </div>
+"""
+
+        html += """                    <div class="audio-item">
+                        <span>🎬 Conclusion</span>
+                        <audio id="audio-conclusion" src="audio/conclusion.mp3" preload="auto"></audio>
+                        <button onclick="playTrack('conclusion')">▶ Play</button>
+                    </div>
+                </div>
+                <div class="playback-controls">
+                    <button onclick="playAll()" class="btn-primary">▶ Play All (8 Tracks)</button>
+                    <button onclick="stopAll()" class="btn-secondary">⏹ Stop</button>
+                </div>
+            </div>
+        </main>
+
+        <footer>
+"""
+        if metadata and metadata.get('prompt'):
+            html += f'            <p><strong>Story:</strong> {metadata["prompt"]}</p>\n'
+
+        html += """            <p><strong>Powered by:</strong> OpenAI • Gemini • Modal • ElevenLabs • LlamaIndex • Blaxel • Claude Code • SambaNova • Gradio</p>
+        </footer>
+    </div>
+
+    <script src="comic.js"></script>
+</body>
+</html>
+"""
+        return html
+
+    def _generate_css(self) -> str:
+        """Generate CSS for web viewer"""
+        return """
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: #333;
+    min-height: 100vh;
+    padding: 20px;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    background: white;
+    border-radius: 12px;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+    overflow: hidden;
+}
+
+header {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 30px;
+    text-align: center;
+}
+
+header h1 {
+    font-size: 2.5rem;
+    margin-bottom: 10px;
+}
+
+.tagline {
+    font-size: 1rem;
+    opacity: 0.9;
+}
+
+main {
+    padding: 30px;
+}
+
+.comic-viewer {
+    position: relative;
+    margin-bottom: 30px;
+    text-align: center;
+}
+
+#comic-page {
+    max-width: 100%;
+    height: auto;
+    border-radius: 8px;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+}
+
+.panel-overlay {
+    position: absolute;
+    top: 0;
+    left: 50%;
+    transform: translateX(-50%);
+    width: 100%;
+    max-width: 100%;
+    height: 100%;
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    grid-template-rows: repeat(3, 1fr);
+    gap: 2%;
+    padding: 2%;
+}
+
+.panel-region {
+    cursor: pointer;
+    border: 5px solid transparent;
+    border-radius: 8px;
+    transition: all 0.3s ease;
+    position: relative;
+    box-shadow: 0 0 0 rgba(102, 126, 234, 0);
+}
+
+.panel-region::before {
+    content: attr(data-panel-label);
+    position: absolute;
+    top: 8px;
+    left: 8px;
+    background: rgba(0, 0, 0, 0.7);
+    color: white;
+    padding: 4px 10px;
+    border-radius: 4px;
+    font-size: 14px;
+    font-weight: bold;
+    opacity: 0;
+    transition: opacity 0.3s ease;
+    z-index: 10;
+}
+
+.panel-region:hover::before {
+    opacity: 1;
+}
+
+.panel-region:hover {
+    border-color: rgba(102, 126, 234, 0.8);
+    background: rgba(102, 126, 234, 0.1);
+    box-shadow: 0 0 15px rgba(102, 126, 234, 0.4);
+}
+
+.panel-region.active {
+    border-color: #667eea;
+    background: rgba(102, 126, 234, 0.25);
+    animation: pulse-glow 1.5s infinite;
+    box-shadow: 0 0 30px rgba(102, 126, 234, 0.8), 0 0 50px rgba(102, 126, 234, 0.5);
+}
+
+.panel-region.active::before {
+    opacity: 1;
+    background: #667eea;
+}
+
+@keyframes pulse-glow {
+    0%, 100% {
+        transform: scale(1);
+        box-shadow: 0 0 30px rgba(102, 126, 234, 0.8), 0 0 50px rgba(102, 126, 234, 0.5);
+    }
+    50% {
+        transform: scale(1.03);
+        box-shadow: 0 0 40px rgba(102, 126, 234, 1), 0 0 70px rgba(102, 126, 234, 0.7);
+    }
+}
+
+.audio-controls {
+    background: #f7f7f7;
+    padding: 20px;
+    border-radius: 8px;
+}
+
+.audio-controls h2 {
+    margin-bottom: 15px;
+    color: #667eea;
+}
+
+#current-panel-indicator {
+    background: #667eea;
+    color: white;
+    padding: 12px 20px;
+    border-radius: 6px;
+    text-align: center;
+    font-weight: bold;
+    font-size: 16px;
+    margin-bottom: 15px;
+    display: none;
+    animation: fade-in 0.3s ease;
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.3);
+}
+
+@keyframes fade-in {
+    from { opacity: 0; transform: translateY(-10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.audio-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: 15px;
+    margin-bottom: 20px;
+}
+
+.audio-item {
+    background: white;
+    padding: 15px;
+    border-radius: 6px;
+    text-align: center;
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
+}
+
+.audio-item span {
+    display: block;
+    font-weight: 600;
+    margin-bottom: 10px;
+    color: #667eea;
+}
+
+.audio-item button {
+    width: 100%;
+    padding: 8px;
+    background: #667eea;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 14px;
+    transition: background 0.3s;
+}
+
+.audio-item button:hover {
+    background: #5568d3;
+}
+
+.playback-controls {
+    display: flex;
+    justify-content: center;
+    gap: 15px;
+}
+
+.btn-primary, .btn-secondary {
+    padding: 12px 30px;
+    font-size: 16px;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+    transition: all 0.3s;
+}
+
+.btn-primary {
+    background: #667eea;
+    color: white;
+}
+
+.btn-primary:hover {
+    background: #5568d3;
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+}
+
+.btn-secondary {
+    background: #e0e0e0;
+    color: #333;
+}
+
+.btn-secondary:hover {
+    background: #d0d0d0;
+}
+
+footer {
+    background: #f0f0f0;
+    padding: 20px;
+    text-align: center;
+    color: #666;
+}
+
+footer p {
+    margin: 5px 0;
+}
+"""
+
+    def _generate_javascript(self, panel_count: int) -> str:
+        """Generate JavaScript for web viewer"""
+        return f"""
+let currentPanel = 0;
+let isPlaying = false;
+
+// Play specific panel
+function playPanel(panelNum) {{
+    stopAll();
+
+    const audio = document.getElementById(`audio-${{panelNum}}`);
+    const panel = document.querySelector(`[data-panel="${{panelNum}}"]`);
+
+    if (audio) {{
+        audio.play();
+        highlightPanel(panelNum);
+
+        audio.onended = () => {{
+            unhighlightPanel(panelNum);
+        }};
+    }}
+}}
+
+// Play specific track (intro/conclusion)
+function playTrack(trackType) {{
+    stopAll();
+
+    const audio = document.getElementById(`audio-${{trackType}}`);
+
+    if (audio) {{
+        audio.play();
+        const indicator = document.getElementById('current-panel-indicator');
+        if (indicator) {{
+            indicator.textContent = `Now Playing: ${{trackType === 'intro' ? 'Introduction' : 'Conclusion'}}`;
+        }}
+
+        audio.onended = () => {{
+            if (indicator) {{
+                indicator.textContent = 'Playback Complete';
+            }}
+        }};
+    }}
+}}
+
+// Play all tracks sequentially (intro + panels + conclusion)
+async function playAll() {{
+    if (isPlaying) return;
+
+    isPlaying = true;
+    currentPanel = 0;
+
+    // Play intro
+    if (!isPlaying) return;
+    await playTrackAsync('intro');
+
+    // Play all panels
+    for (let i = 1; i <= {panel_count}; i++) {{
+        if (!isPlaying) break;
+
+        await playPanelAsync(i);
+    }}
+
+    // Play conclusion
+    if (isPlaying) {{
+        await playTrackAsync('conclusion');
+    }}
+
+    isPlaying = false;
+    currentPanel = 0;
+}}
+
+// Play intro/conclusion track async
+function playTrackAsync(trackType) {{
+    return new Promise((resolve) => {{
+        const audio = document.getElementById(`audio-${{trackType}}`);
+
+        if (!audio) {{
+            resolve();
+            return;
+        }}
+
+        const indicator = document.getElementById('current-panel-indicator');
+        if (indicator) {{
+            indicator.textContent = `Now Playing: ${{trackType === 'intro' ? 'Introduction' : 'Conclusion'}}`;
+        }}
+
+        audio.play();
+
+        audio.onended = () => {{
+            // Add 2-second pause after track ends
+            setTimeout(() => {{
+                if (indicator) {{
+                    indicator.textContent = 'Transitioning...';
+                }}
+                resolve();
+            }}, 2000);
+        }};
+    }});
+}}
+
+// Play panel and wait for completion
+function playPanelAsync(panelNum) {{
+    return new Promise((resolve) => {{
+        const audio = document.getElementById(`audio-${{panelNum}}`);
+        const panel = document.querySelector(`[data-panel="${{panelNum}}"]`);
+
+        if (!audio) {{
+            resolve();
+            return;
+        }}
+
+        highlightPanel(panelNum);
+        audio.play();
+
+        audio.onended = () => {{
+            // Add 2-second pause after audio ends before moving to next panel
+            setTimeout(() => {{
+                unhighlightPanel(panelNum);
+                resolve();
+            }}, 2000);  // 2 second pause for smoother transitions
+        }};
+    }});
+}}
+
+// Stop all audio
+function stopAll() {{
+    isPlaying = false;
+
+    // Stop intro
+    const introAudio = document.getElementById('audio-intro');
+    if (introAudio) {{
+        introAudio.pause();
+        introAudio.currentTime = 0;
+    }}
+
+    // Stop all panels
+    for (let i = 1; i <= {panel_count}; i++) {{
+        const audio = document.getElementById(`audio-${{i}}`);
+        if (audio) {{
+            audio.pause();
+            audio.currentTime = 0;
+        }}
+        unhighlightPanel(i);
+    }}
+
+    // Stop conclusion
+    const conclusionAudio = document.getElementById('audio-conclusion');
+    if (conclusionAudio) {{
+        conclusionAudio.pause();
+        conclusionAudio.currentTime = 0;
+    }}
+
+    // Hide current panel indicator
+    const indicator = document.getElementById('current-panel-indicator');
+    if (indicator) {{
+        indicator.style.display = 'none';
+    }}
+}}
+
+// Highlight panel
+function highlightPanel(panelNum) {{
+    const panel = document.querySelector(`[data-panel="${{panelNum}}"]`);
+    if (panel) {{
+        panel.classList.add('active');
+
+        // Scroll panel into view with smooth animation
+        panel.scrollIntoView({{
+            behavior: 'smooth',
+            block: 'center',
+            inline: 'center'
+        }});
+
+        // Update currently playing indicator
+        updateCurrentPanelIndicator(panelNum);
+    }}
+}}
+
+// Remove highlight
+function unhighlightPanel(panelNum) {{
+    const panel = document.querySelector(`[data-panel="${{panelNum}}"]`);
+    if (panel) {{
+        panel.classList.remove('active');
+    }}
+}}
+
+// Update current panel indicator
+function updateCurrentPanelIndicator(panelNum) {{
+    const indicator = document.getElementById('current-panel-indicator');
+    if (indicator) {{
+        indicator.textContent = `Now Playing: Panel ${{panelNum}}`;
+        indicator.style.display = 'block';
+    }}
+}}
+
+// Add click handlers to panel regions
+document.addEventListener('DOMContentLoaded', () => {{
+    const panels = document.querySelectorAll('.panel-region');
+    panels.forEach(panel => {{
+        panel.addEventListener('click', () => {{
+            const panelNum = parseInt(panel.dataset.panel);
+            playPanel(panelNum);
+        }});
+    }});
+}});
+"""

modal_image_generator.py

@@ -0,0 +1,209 @@
+"""Modal SDXL Image Generator Client for MythForge Comics
+
+Client interface to Modal SDXL deployment for comic panel generation.
+"""
+
+import modal
+from PIL import Image
+from io import BytesIO
+from typing import List, Optional
+from config import Config
+
+
+class ModalImageGenerator:
+    """Client for Modal SDXL image generation"""
+
+    def __init__(self):
+        """Initialize Modal client"""
+        self.enabled = Config.ENABLE_MODAL
+        self.app_name = "mythforge-sdxl"
+
+        if self.enabled:
+            try:
+                # Get reference to deployed Modal SDXLModel class
+                # In Modal 1.0+, we access deployed functions directly via modal.Function.lookup()
+                self.model = modal.Cls.from_name(self.app_name, "SDXLModel")
+                print(f"✅ Modal using SDXL (connected to {self.app_name})")
+            except Exception as e:
+                print(f"⚠️  Modal app not found: {e}")
+                print("   Run: modal deploy modal_sdxl.py")
+                self.enabled = False
+
+    def generate_panel(
+        self,
+        prompt: str,
+        style: str = "manga",
+        num_inference_steps: int = 25,
+        seed: Optional[int] = None
+    ) -> Image.Image:
+        """
+        Generate a single comic panel
+
+        Args:
+            prompt: Scene description
+            style: Visual style (manga, anime, comic, etc.)
+            num_inference_steps: Quality (25 = good, 50 = best)
+            seed: Random seed for reproducibility
+
+        Returns:
+            PIL Image (1024x1024)
+        """
+        if not self.enabled:
+            raise RuntimeError("Modal image generation not enabled")
+
+        # Style enhancements
+        style_prompts = {
+            "manga": "black and white manga style, ink drawing, dramatic shading",
+            "shonen": "shonen manga style, dynamic action poses, speed lines",
+            "shoujo": "shoujo manga style, sparkles, flowers, romantic",
+            "anime": "anime style, cel shaded, vibrant colors",
+            "comic": "western comic book style, bold lines, halftone",
+            "webcomic": "digital webcomic style, clean lines, modern",
+            "cartoon": "cartoon style, simplified, expressive",
+        }
+
+        style_enhancement = style_prompts.get(style, "")
+        enhanced_prompt = f"{prompt}, {style_enhancement}, high quality, detailed"
+
+        print(f"Generating image: {enhanced_prompt[:60]}...")
+
+        # Call Modal function
+        try:
+            # Call the generate method on the deployed class
+            image_bytes = self.model().generate.remote(
+                prompt=enhanced_prompt,
+                num_inference_steps=num_inference_steps,
+                seed=seed
+            )
+
+            # Convert bytes to PIL Image
+            image = Image.open(BytesIO(image_bytes))
+            return image
+
+        except Exception as e:
+            print(f"❌ Modal generation failed: {e}")
+            raise
+
+    async def generate_comic_panels(
+        self,
+        panels_data: List[dict],
+        style: str = "manga",
+        num_inference_steps: int = 25
+    ) -> List[Image.Image]:
+        """
+        Generate multiple comic panels (async for compatibility with app)
+
+        Args:
+            panels_data: List of panel dictionaries with scene_description
+            style: Visual style
+            num_inference_steps: Quality setting
+
+        Returns:
+            List of PIL Images
+        """
+        if not self.enabled:
+            raise RuntimeError("Modal image generation not enabled")
+
+        images = []
+
+        for i, panel in enumerate(panels_data):
+            scene = panel.get("scene_description", "")
+            if not scene:
+                scene = f"Comic panel {i+1}"
+
+            print(f"🎨 Generating panel {i+1}/{len(panels_data)}: {scene[:50]}...")
+
+            try:
+                image = self.generate_panel(
+                    prompt=scene,
+                    style=style,
+                    num_inference_steps=num_inference_steps,
+                    seed=i  # Different seed per panel
+                )
+                images.append(image)
+                print(f"   ✅ Panel {i+1} generated")
+
+            except Exception as e:
+                print(f"   ❌ Panel {i+1} failed: {e}")
+                # Create fallback placeholder
+                placeholder = Image.new('RGB', (1024, 1024), color=(200, 200, 200))
+                images.append(placeholder)
+
+        return images
+
+    def generate_batch(
+        self,
+        prompts: List[str],
+        style: str = "manga",
+        num_inference_steps: int = 25
+    ) -> List[Image.Image]:
+        """
+        Generate multiple panels using batch function (faster)
+
+        Args:
+            prompts: List of scene descriptions
+            style: Visual style
+            num_inference_steps: Quality setting
+
+        Returns:
+            List of PIL Images
+        """
+        if not self.enabled:
+            raise RuntimeError("Modal image generation not enabled")
+
+        print(f"Generating {len(prompts)} panels in batch...")
+
+        try:
+            # Call batch generation function
+            generate_fn = modal.Function.lookup(self.app_name, "generate_comic_panels")
+            images_bytes = generate_fn.remote(
+                prompts=prompts,
+                style=style,
+                num_inference_steps=num_inference_steps
+            )
+
+            # Convert all to PIL Images
+            images = [Image.open(BytesIO(img_bytes)) for img_bytes in images_bytes]
+
+            print(f"✅ Generated {len(images)} panels")
+            return images
+
+        except Exception as e:
+            print(f"❌ Batch generation failed: {e}")
+            raise
+
+    @classmethod
+    def is_available(cls) -> bool:
+        """Check if Modal SDXL is available"""
+        try:
+            modal.App.lookup("mythforge-sdxl", create_if_missing=False)
+            return True
+        except:
+            return False
+
+
+# Test function
+if __name__ == "__main__":
+    print("Testing Modal Image Generator...")
+    print("=" * 60)
+
+    generator = ModalImageGenerator()
+
+    if not generator.enabled:
+        print("❌ Modal not enabled")
+        print("   1. Deploy: modal deploy modal_sdxl.py")
+        print("   2. Enable: Set ENABLE_MODAL=true in .env")
+    else:
+        print("✅ Modal enabled")
+
+        # Test single generation
+        test_prompt = "A wizard discovering a glowing magical spellbook in an ancient library"
+        print(f"\nTest prompt: {test_prompt}")
+
+        try:
+            image = generator.generate_panel(test_prompt, style="manga")
+            image.save("test_modal_panel.png")
+            print(f"✅ Test image saved to test_modal_panel.png")
+            print(f"   Size: {image.size}")
+        except Exception as e:
+            print(f"❌ Test failed: {e}")

modal_sdxl.py

@@ -0,0 +1,214 @@
+"""Modal SDXL Deployment for MythForge Comic Generator
+
+Deploys Stable Diffusion XL on Modal's serverless GPU infrastructure
+for high-quality 1024x1024 comic panel generation.
+
+Compatible with Modal 1.0+ API
+"""
+
+import modal
+from pathlib import Path
+
+# Create Modal app
+app = modal.App("mythforge-sdxl")
+
+
+# Function to download model weights during image build
+def download_sdxl_model():
+    """Download SDXL model weights"""
+    from diffusers import StableDiffusionXLPipeline
+    import torch
+
+    print("Downloading SDXL model weights...")
+    StableDiffusionXLPipeline.from_pretrained(
+        "stabilityai/stable-diffusion-xl-base-1.0",
+        torch_dtype=torch.float16,
+        variant="fp16",
+        use_safetensors=True,
+    )
+    print("✅ SDXL model downloaded")
+
+
+# Define the image with SDXL dependencies (downloads models at build time)
+sdxl_image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .pip_install(
+        "numpy==1.26.3",  # Required by diffusers schedulers
+        "diffusers==0.25.0",
+        "transformers==4.36.2",
+        "accelerate==0.25.0",
+        "safetensors==0.4.1",
+        "torch==2.1.2",
+        "pillow==10.1.0",
+        "huggingface-hub==0.20.0",  # Pin compatible version
+    )
+    # Download model weights during image build
+    .run_function(
+        download_sdxl_model,
+        gpu="A10G",  # Need GPU to download FP16 weights
+    )
+)
+
+
+@app.cls(
+    image=sdxl_image,
+    gpu="A10G",  # A10G GPU - good balance of cost/performance
+    timeout=300,  # 5 minute timeout
+    scaledown_window=60,  # Keep warm for 1 minute
+)
+class SDXLModel:
+    """SDXL model for comic panel generation"""
+
+    @modal.enter()
+    def load_models(self):
+        """Load models when container starts"""
+        from diffusers import StableDiffusionXLPipeline
+        import torch
+
+        print("Loading SDXL pipeline...")
+        self.pipe = StableDiffusionXLPipeline.from_pretrained(
+            "stabilityai/stable-diffusion-xl-base-1.0",
+            torch_dtype=torch.float16,
+            variant="fp16",
+            use_safetensors=True,
+        ).to("cuda")
+
+        # Enable memory optimizations
+        self.pipe.enable_attention_slicing()
+        print("✅ SDXL pipeline loaded")
+
+    @modal.method()
+    def generate(
+        self,
+        prompt: str,
+        negative_prompt: str = "",
+        num_inference_steps: int = 25,
+        guidance_scale: float = 7.5,
+        seed: int = None,
+    ) -> bytes:
+        """
+        Generate a comic panel image
+
+        Args:
+            prompt: Scene description for the panel
+            negative_prompt: What to avoid in the image
+            num_inference_steps: Quality vs speed (25 is good balance)
+            guidance_scale: How closely to follow prompt (7.5 is default)
+            seed: Random seed for reproducibility
+
+        Returns:
+            PNG image as bytes
+        """
+        import torch
+        from io import BytesIO
+
+        # Set seed if provided
+        if seed is not None:
+            generator = torch.Generator("cuda").manual_seed(seed)
+        else:
+            generator = None
+
+        # Default negative prompt for comic art
+        if not negative_prompt:
+            negative_prompt = (
+                "blurry, low quality, distorted, deformed, ugly, "
+                "duplicate, watermark, signature, text, words, "
+                "bad anatomy, extra limbs, poorly drawn"
+            )
+
+        # Enhance prompt for comic style
+        enhanced_prompt = f"{prompt}, comic book style, manga art, high quality, detailed, vibrant colors, professional illustration"
+
+        print(f"Generating image with prompt: {enhanced_prompt[:100]}...")
+
+        # Generate image
+        result = self.pipe(
+            prompt=enhanced_prompt,
+            negative_prompt=negative_prompt,
+            num_inference_steps=num_inference_steps,
+            guidance_scale=guidance_scale,
+            generator=generator,
+            height=1024,
+            width=1024,
+        )
+
+        image = result.images[0]
+
+        # Convert to bytes
+        buffer = BytesIO()
+        image.save(buffer, format="PNG")
+        return buffer.getvalue()
+
+
+# Function to generate comic panels (called from client)
+@app.function(
+    image=sdxl_image,
+    gpu="A10G",
+    timeout=600,  # 10 minute timeout for batch generation
+)
+def generate_comic_panels(
+    prompts: list[str],
+    style: str = "manga",
+    num_inference_steps: int = 25,
+) -> list[bytes]:
+    """
+    Generate multiple comic panels in batch
+
+    Args:
+        prompts: List of scene descriptions (one per panel)
+        style: Visual style (manga, anime, comic, etc.)
+        num_inference_steps: Quality setting
+
+    Returns:
+        List of PNG images as bytes
+    """
+    model = SDXLModel()
+
+    images = []
+    for i, prompt in enumerate(prompts):
+        print(f"Generating panel {i+1}/{len(prompts)}...")
+
+        # Style-specific enhancements
+        style_prompts = {
+            "manga": "black and white manga style, ink drawing, dramatic shading",
+            "shonen": "shonen manga style, dynamic action poses, speed lines",
+            "shoujo": "shoujo manga style, sparkles, flowers, romantic",
+            "anime": "anime style, cel shaded, vibrant colors",
+            "comic": "western comic book style, bold lines, halftone",
+            "webcomic": "digital webcomic style, clean lines, modern",
+            "cartoon": "cartoon style, simplified, expressive",
+        }
+
+        style_enhancement = style_prompts.get(style, "")
+        full_prompt = f"{prompt}, {style_enhancement}"
+
+        image_bytes = model.generate(
+            prompt=full_prompt,
+            num_inference_steps=num_inference_steps,
+        )
+        images.append(image_bytes)
+
+    return images
+
+
+# CLI for testing
+@app.local_entrypoint()
+def main(prompt: str = "A wizard in an ancient library"):
+    """Test the SDXL deployment"""
+    print(f"Testing SDXL with prompt: {prompt}")
+
+    model = SDXLModel()
+    image_bytes = model.generate.remote(prompt)
+
+    # Save test image
+    output_path = Path("test_sdxl_output.png")
+    output_path.write_bytes(image_bytes)
+
+    print(f"✅ Image saved to {output_path}")
+    print(f"   Size: {len(image_bytes):,} bytes ({len(image_bytes)/1024:.1f} KB)")
+
+
+if __name__ == "__main__":
+    # Can test locally with:
+    # modal run modal_sdxl.py
+    pass

multimodal_analyzer.py

@@ -0,0 +1,121 @@
+"""Multimodal Analyzer using Google Gemini"""
+from typing import Optional
+from PIL import Image
+import google.generativeai as genai
+from config import Config
+
+class MultimodalAnalyzer:
+    """Analyze images and provide style descriptions using Gemini"""
+
+    def __init__(self):
+        """Initialize Gemini client"""
+        self.model = None
+        self.enabled = Config.ENABLE_GEMINI and Config.GEMINI_API_KEY is not None
+
+        if self.enabled:
+            print("✅ Gemini analyzer enabled")
+        else:
+            print("⚠️  Gemini analyzer disabled (set ENABLE_GEMINI=true in .env)")
+
+    def _init_client(self):
+        """Lazy initialize Gemini"""
+        if self.model is None:
+            if not Config.GEMINI_API_KEY:
+                raise ValueError("GEMINI_API_KEY not set in environment")
+            genai.configure(api_key=Config.GEMINI_API_KEY)
+            # Use Gemini 2.5 Flash - production-ready with balanced performance
+            # Falls back to 2.0 Flash if 2.5 not available
+            try:
+                self.model = genai.GenerativeModel('gemini-2.5-flash')
+                print("✅ Using Gemini 2.5 Flash")
+            except Exception:
+                try:
+                    self.model = genai.GenerativeModel('gemini-2.0-flash')
+                    print("⚠️  Using Gemini 2.0 Flash (2.5 not available)")
+                except Exception:
+                    self.model = genai.GenerativeModel('gemini-2.0-flash-exp')
+                    print("⚠️  Using Gemini 2.0 Flash Experimental (fallback)")
+    
+    async def analyze_reference_image(self, image: Image.Image) -> str:
+        """
+        Analyze visual style from reference image
+        
+        Args:
+            image: PIL Image to analyze
+            
+        Returns:
+            Style description string
+        """
+        self._init_client()
+        
+        try:
+            prompt = """Analyze this image and describe its visual style in detail.
+Focus on:
+- Art style (realistic, cartoon, anime, etc.)
+- Color palette and mood
+- Lighting and atmosphere
+- Artistic technique
+- Overall aesthetic
+
+Provide a concise description (2-3 sentences) suitable for guiding image generation."""
+            
+            response = self.model.generate_content([prompt, image])
+            return response.text
+            
+        except Exception as e:
+            print(f"Error analyzing image: {e}")
+            return "fantasy illustration style with vibrant colors"
+    
+    async def analyze_panel_quality(self, image: Image.Image, panel_data: dict) -> float:
+        """
+        Analyze quality of a comic panel image
+
+        Args:
+            image: Generated panel image
+            panel_data: Panel metadata with scene_description
+
+        Returns:
+            Quality score from 0-10
+        """
+        if not self.enabled:
+            return 8.0  # Default score when disabled
+
+        self._init_client()
+
+        try:
+            scene = panel_data.get("scene_description", "")
+            prompt = f"""Analyze this comic panel image and rate its quality from 0-10.
+
+Expected scene: {scene}
+
+Rate based on:
+- Visual clarity and composition
+- Adherence to scene description
+- Artistic quality
+- Suitability for comic storytelling
+
+Respond with ONLY a number from 0-10."""
+
+            response = self.model.generate_content([prompt, image])
+            score_text = response.text.strip()
+
+            # Extract numeric score
+            try:
+                score = float(score_text)
+                return min(max(score, 0), 10)  # Clamp to 0-10
+            except ValueError:
+                # Try to extract first number
+                import re
+                match = re.search(r'(\d+\.?\d*)', score_text)
+                if match:
+                    return min(max(float(match.group(1)), 0), 10)
+                return 7.0  # Default if parsing fails
+
+        except Exception as e:
+            print(f"⚠️  Gemini quality analysis failed: {e}")
+            return 7.0  # Default score on error
+
+    def estimate_cost(self) -> float:
+        """Estimate cost for Gemini API call"""
+        # Gemini has generous free tier
+        return 0.0

mythforge_mcp_memory_client.py

@@ -0,0 +1,197 @@
+"""
+MythForge MCP Memory Client - Minimal client for LlamaIndex memory operations only
+
+This client only handles story memory operations via MCP protocol.
+Used by app_comic.py to access memory through MCP instead of direct calls.
+"""
+import asyncio
+import json
+from typing import Optional, Dict, Any
+from pathlib import Path
+
+try:
+    from mcp import ClientSession, StdioServerParameters
+    from mcp.client.stdio import stdio_client
+    MCP_AVAILABLE = True
+except ImportError:
+    MCP_AVAILABLE = False
+
+
+class MythForgeMCPMemoryClient:
+    """
+    Minimal MCP client wrapper for LlamaIndex memory operations only.
+    
+    Provides the same interface as StoryMemory for retrieve_context and store_story,
+    but routes calls through MCP server instead of direct LlamaIndex access.
+    """
+    
+    def __init__(self, server_script: str = "mythforge_mcp_server.py", cwd: Optional[str] = None):
+        """
+        Initialize MCP memory client.
+        
+        Args:
+            server_script: Path to the MCP server script
+            cwd: Working directory for the server
+        """
+        if not MCP_AVAILABLE:
+            raise ImportError("MCP client not available. Install: pip install mcp")
+        
+        self.server_script = Path(server_script).resolve()
+        self.cwd = Path(cwd).resolve() if cwd else self.server_script.parent
+        
+        self.server_params = StdioServerParameters(
+            command="python",
+            args=[str(self.server_script)],
+            cwd=str(self.cwd)
+        )
+    
+    async def _call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """Internal method to call MCP tool with proper context management"""
+        async with stdio_client(self.server_params) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                result = await session.call_tool(tool_name, arguments=arguments)
+                return result
+    
+    async def retrieve_context(self, query: str, top_k: int = 3) -> str:
+        """
+        Retrieve relevant story context based on query (MCP version).
+        
+        Args:
+            query: Search query
+            top_k: Number of results to return
+        
+        Returns:
+            Retrieved context as string
+        """
+        try:
+            result = await self._call_tool(
+                "search_story_memory",
+                arguments={"query": query, "top_k": top_k}
+            )
+            
+            # Extract result from MCP response
+            if hasattr(result, 'content') and result.content:
+                content_item = result.content[0]
+                if hasattr(content_item, 'text'):
+                    try:
+                        result_dict = json.loads(content_item.text)
+                        return result_dict.get("context", "")
+                    except json.JSONDecodeError:
+                        return content_item.text
+            
+            return ""
+            
+        except Exception as e:
+            print(f"⚠️  MCP memory retrieval failed: {e}")
+            return "Error retrieving context."
+    
+    async def store_story(self, story_text: str, metadata: Dict) -> None:
+        """
+        Store story in knowledge graph (MCP version).
+        
+        Args:
+            story_text: The story text
+            metadata: Story metadata (style, tone, etc.)
+        """
+        try:
+            result = await self._call_tool(
+                "store_story_in_memory",
+                arguments={
+                    "story_text": story_text,
+                    "title": metadata.get("title"),
+                    "style": metadata.get("style"),
+                    "metadata": metadata
+                }
+            )
+            
+            # Check if successful
+            if hasattr(result, 'content') and result.content:
+                content_item = result.content[0]
+                if hasattr(content_item, 'text'):
+                    try:
+                        result_dict = json.loads(content_item.text)
+                        if result_dict.get("success"):
+                            print(f"✅ Story stored via MCP. Total stories: {result_dict.get('total_stories', 0)}")
+                        else:
+                            print(f"⚠️  MCP storage failed: {result_dict.get('error', 'Unknown error')}")
+                    except json.JSONDecodeError:
+                        pass
+            
+        except Exception as e:
+            print(f"⚠️  MCP memory storage failed: {e}")
+    
+    def retrieve_context_sync(self, query: str, top_k: int = 3) -> str:
+        """
+        Synchronous wrapper for retrieve_context.
+        Creates a fresh connection for each call.
+        """
+        try:
+            # Use get_event_loop() if one exists, otherwise create new
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    # If loop is running, we need to use a different approach
+                    # For now, create a new loop in a thread
+                    import concurrent.futures
+                    with concurrent.futures.ThreadPoolExecutor() as executor:
+                        future = executor.submit(asyncio.run, self.retrieve_context(query, top_k))
+                        return future.result()
+                else:
+                    return loop.run_until_complete(self.retrieve_context(query, top_k))
+            except RuntimeError:
+                # No event loop, create one
+                return asyncio.run(self.retrieve_context(query, top_k))
+        except Exception as e:
+            print(f"⚠️  MCP memory retrieval (sync) failed: {e}")
+            return ""
+    
+    def store_story_sync(self, story_text: str, metadata: Dict) -> None:
+        """
+        Synchronous wrapper for store_story.
+        Creates a fresh connection for each call.
+        """
+        try:
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    import concurrent.futures
+                    with concurrent.futures.ThreadPoolExecutor() as executor:
+                        future = executor.submit(asyncio.run, self.store_story(story_text, metadata))
+                        future.result()
+                else:
+                    loop.run_until_complete(self.store_story(story_text, metadata))
+            except RuntimeError:
+                asyncio.run(self.store_story(story_text, metadata))
+        except Exception as e:
+            print(f"⚠️  MCP memory storage (sync) failed: {e}")
+
+
+# Global client instance (lazy initialized)
+_mcp_memory_client = None
+
+
+def get_mcp_memory_client() -> Optional[MythForgeMCPMemoryClient]:
+    """
+    Get or create global MCP memory client instance.
+    
+    Returns:
+        MythForgeMCPMemoryClient instance or None if MCP not available
+    """
+    global _mcp_memory_client
+    
+    from config import Config
+    
+    # Only create if MCP is enabled
+    if not Config.ENABLE_MCP:
+        return None
+    
+    if _mcp_memory_client is None:
+        try:
+            _mcp_memory_client = MythForgeMCPMemoryClient()
+            print("✅ MCP Memory Client initialized")
+        except Exception as e:
+            print(f"⚠️  Failed to initialize MCP Memory Client: {e}")
+            return None
+    
+    return _mcp_memory_client

mythforge_mcp_server.py

@@ -0,0 +1,1020 @@
+"""
+MythForge MCP Server - Exposes comic generation capabilities via Model Context Protocol
+
+This server is opt-in via ENABLE_MCP=true in .env for backward compatibility.
+Run separately: python mythforge_mcp_server.py
+"""
+import os
+import sys
+import asyncio
+import json
+import base64
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+from datetime import datetime
+
+from mcp.server.fastmcp import FastMCP, Context
+from config import Config
+
+# Only proceed if MCP is enabled
+if not Config.ENABLE_MCP:
+    print("⚠️  MCP server disabled. Set ENABLE_MCP=true in .env to enable.")
+    sys.exit(0)
+
+# Initialize MCP server
+mcp = FastMCP("MythForge", json_response=True)
+
+# Lazy-loaded app instance (only created when needed)
+_comic_app = None
+_character_manager = None
+_export_service = None
+
+
+# def get_comic_app():
+#     """Lazy load ComicGeneratorApp (only if MCP is enabled)"""
+#     global _comic_app
+#     if _comic_app is None:
+#         try:
+#             from app_comic import ComicGeneratorApp
+#             _comic_app = ComicGeneratorApp()
+#             print("✅ ComicGeneratorApp initialized for MCP")
+#         except Exception as e:
+#             print(f"❌ Failed to initialize ComicGeneratorApp: {e}")
+#             raise
+#     return _comic_app
+
+def get_story_memory():
+    """Get StoryMemory instance directly (for MCP server use)"""
+    try:
+        from story_memory import StoryMemory
+        from config import Config
+        
+        if Config.ENABLE_LLAMAINDEX:
+            return StoryMemory()
+        return None
+    except Exception as e:
+        print(f"⚠️  StoryMemory not available: {e}")
+        return None
+
+
+def get_character_manager():
+    """Lazy load CharacterConsistencyManager (optional)"""
+    global _character_manager
+    if _character_manager is None:
+        try:
+            from character_consistency_manager import CharacterConsistencyManager
+            if Config.ENABLE_NANO_BANANA:
+                _character_manager = CharacterConsistencyManager()
+                print("✅ CharacterConsistencyManager initialized for MCP")
+            else:
+                print("⚠️  Character consistency disabled (ENABLE_NANO_BANANA=false)")
+        except Exception as e:
+            print(f"⚠️  Character consistency not available: {e}")
+    return _character_manager
+
+
+def get_export_service():
+    """Lazy load ExportService"""
+    global _export_service
+    if _export_service is None:
+        try:
+            from export_service import ExportService
+            _export_service = ExportService()
+        except Exception as e:
+            print(f"❌ Failed to initialize ExportService: {e}")
+            raise
+    return _export_service
+
+
+# ============================================================================
+# CORE COMIC GENERATION TOOLS
+# ============================================================================
+
+@mcp.tool()
+async def generate_comic(
+    prompt: str,
+    style: str = "manga",
+    num_panels: int = 6,
+    include_audio: bool = True,
+    include_bubbles: bool = True,
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Generate a complete comic from a text prompt.
+    
+    Args:
+        prompt: Story prompt (e.g., "A wizard discovers a magical spellbook")
+        style: Art style (manga, cartoon, anime, comic)
+        num_panels: Number of panels (default 6)
+        include_audio: Generate voice narration
+        include_bubbles: Add speech bubbles with dialogue
+    
+    Returns:
+        Dictionary with:
+        - success: bool
+        - comic_id: str (directory name)
+        - output_dir: str (full path)
+        - metadata: Dict (title, timestamp, etc.)
+        - panels: List[str] (panel image paths)
+        - audio_files: List[str] (audio file paths)
+        - manga_page: str (full page image path)
+    """
+    if ctx:
+        await ctx.info(f"🎨 Generating comic: {prompt[:50]}...")
+    
+    try:
+        app = get_comic_app()
+        
+        # Create progress callback if context available
+        progress_callback = None
+        if ctx:
+            async def progress(step: float, desc: str = ""):
+                await ctx.report_progress(int(step * 100), 100, desc)
+            progress_callback = progress
+        
+        # Generate comic
+        result = await app.generate_comic_async(
+            prompt=prompt,
+            style=style,
+            include_audio=include_audio,
+            include_bubbles=include_bubbles,
+            progress=progress_callback
+        )
+        
+        # Extract output directory
+        metadata = result.get("metadata", {})
+        title = metadata.get("title", "MythForge_Comic").replace(" ", "_")
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        comic_id = f"{title}_{timestamp}"
+        
+        # Save outputs to directory
+        output_dir = Path("./auto_generated_comics") / comic_id
+        output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Save manga page
+        manga_page_path = None
+        if result.get("manga_page"):
+            manga_page_path = output_dir / "manga_page.png"
+            result["manga_page"].save(str(manga_page_path))
+        
+        # Save panel images
+        panel_paths = []
+        for i, panel_img in enumerate(result.get("panel_images", []), 1):
+            panel_path = output_dir / f"panel_{i:02d}.png"
+            panel_img.save(str(panel_path))
+            panel_paths.append(str(panel_path))
+        
+        # Copy audio files
+        audio_paths = []
+        for i, audio_path in enumerate(result.get("audio_files", []), 1):
+            if audio_path and os.path.exists(audio_path):
+                import shutil
+                dest_path = output_dir / f"panel_{i:02d}_audio.mp3"
+                shutil.copy(audio_path, dest_path)
+                audio_paths.append(str(dest_path))
+        
+        # Save metadata
+        metadata_path = output_dir / "metadata.json"
+        with open(metadata_path, 'w') as f:
+            json.dump({
+                **metadata,
+                "comic_id": comic_id,
+                "output_dir": str(output_dir),
+                "panel_count": len(panel_paths),
+                "audio_count": len(audio_paths)
+            }, f, indent=2)
+        
+        if ctx:
+            await ctx.info(f"✅ Comic generated: {comic_id}")
+        
+        return {
+            "success": True,
+            "comic_id": comic_id,
+            "output_dir": str(output_dir),
+            "metadata": metadata,
+            "panels": panel_paths,
+            "audio_files": audio_paths,
+            "manga_page": str(manga_page_path) if manga_page_path else None
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to generate comic: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg
+        }
+
+
+@mcp.tool()
+async def generate_comic_with_characters(
+    prompt: str,
+    character_names: List[str],
+    num_panels: int = 6,
+    art_style: str = "manga",
+    include_surprise_character: bool = True,
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Generate comic with specific characters (uses character consistency system).
+    
+    Args:
+        prompt: Story prompt
+        character_names: List of character names to include
+        num_panels: Number of panels
+        art_style: Visual style (manga, anime, comic, etc.)
+        include_surprise_character: Add AI-generated surprise character
+    
+    Returns:
+        Dictionary with generation results
+    """
+    if ctx:
+        await ctx.info(f"🎨 Generating comic with characters: {', '.join(character_names)}")
+    
+    try:
+        manager = get_character_manager()
+        if not manager:
+            return {
+                "success": False,
+                "error": "Character consistency not available. Set ENABLE_NANO_BANANA=true"
+            }
+        
+        result = manager.generate_comic_from_prompt(
+            story_prompt=prompt,
+            num_panels=num_panels,
+            art_style=art_style,
+            include_surprise_character=include_surprise_character
+        )
+        
+        if ctx:
+            await ctx.info("✅ Comic with character consistency generated")
+        
+        return {
+            "success": True,
+            "characters": result.get("characters", {}),
+            "panels": [str(p) for p in result.get("panels", [])],
+            "panel_info": result.get("panel_info", []),
+            "surprise_character": result.get("surprise_character"),
+            "output_dir": result.get("output_dir")
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to generate comic with characters: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg
+        }
+
+
+# ============================================================================
+# CHARACTER MANAGEMENT TOOLS
+# ============================================================================
+
+@mcp.tool()
+async def create_character(
+    name: str,
+    description: str,
+    reference_image_path: Optional[str] = None,
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Create a new character profile for consistency.
+    
+    Args:
+        name: Character name
+        description: Physical description
+        reference_image_path: Optional path to reference image
+    
+    Returns:
+        Character profile information
+    """
+    if ctx:
+        await ctx.info(f"👤 Creating character: {name}")
+    
+    try:
+        manager = get_character_manager()
+        if not manager:
+            return {
+                "success": False,
+                "error": "Character consistency not available. Set ENABLE_NANO_BANANA=true"
+            }
+        
+        # Create character
+        character = manager.create_character(
+            name=name,
+            description=description,
+            reference_image_path=reference_image_path
+        )
+        
+        if ctx:
+            await ctx.info(f"✅ Character created: {name}")
+        
+        return {
+            "success": True,
+            "character": character
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to create character: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg
+        }
+
+
+@mcp.tool()
+async def list_characters(ctx: Context = None) -> List[Dict[str, Any]]:
+    """List all available characters in the library."""
+    try:
+        manager = get_character_manager()
+        if not manager:
+            return []
+        
+        characters = manager.list_all_characters()
+        return [{"name": name, "profile": profile} for name, profile in characters.items()]
+        
+    except Exception as e:
+        if ctx:
+            await ctx.error(f"Failed to list characters: {str(e)}")
+        return []
+
+
+@mcp.tool()
+async def get_character_info(character_name: str, ctx: Context = None) -> Dict[str, Any]:
+    """Get detailed information about a character."""
+    try:
+        manager = get_character_manager()
+        if not manager:
+            return {
+                "success": False,
+                "error": "Character consistency not available"
+            }
+        
+        info = manager.get_character_info_summary(character_name)
+        return {
+            "success": True,
+            "character_name": character_name,
+            "info": info
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+
+# ============================================================================
+# EXPORT & FILE MANAGEMENT TOOLS
+# ============================================================================
+
+@mcp.tool()
+async def export_comic(
+    comic_id: str,
+    format: str = "zip",  # zip, pdf, web
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Export comic in specified format.
+    
+    Args:
+        comic_id: Comic directory name or ID
+        format: Export format (zip, pdf, web)
+    
+    Returns:
+        Path to exported file
+    """
+    if ctx:
+        await ctx.info(f"📦 Exporting comic {comic_id} as {format}")
+    
+    try:
+        # Find comic directory
+        comics_dir = Path("./auto_generated_comics")
+        comic_dir = comics_dir / comic_id
+        
+        if not comic_dir.exists():
+            return {
+                "success": False,
+                "error": f"Comic {comic_id} not found"
+            }
+        
+        # Load metadata
+        metadata_path = comic_dir / "metadata.json"
+        if metadata_path.exists():
+            with open(metadata_path, 'r') as f:
+                metadata = json.load(f)
+        else:
+            metadata = {}
+        
+        # Load manga page
+        manga_page_path = comic_dir / "manga_page.png"
+        if not manga_page_path.exists():
+            return {
+                "success": False,
+                "error": "Manga page not found"
+            }
+        
+        from PIL import Image
+        manga_page = Image.open(manga_page_path)
+        
+        # Load panel images
+        panel_images = []
+        for i in range(1, 7):
+            panel_path = comic_dir / f"panel_{i:02d}.png"
+            if panel_path.exists():
+                panel_images.append(Image.open(panel_path))
+        
+        # Load audio files
+        audio_files = []
+        for i in range(1, 7):
+            audio_path = comic_dir / f"panel_{i:02d}_audio.mp3"
+            if audio_path.exists():
+                audio_files.append(str(audio_path))
+        
+        export_service = get_export_service()
+        title = metadata.get("title", comic_id).replace(" ", "_")
+        
+        if format == "pdf":
+            pdf_bytes = export_service.generate_comic_pdf(
+                comic_page=manga_page,
+                title=metadata.get("title", "MythForge Comic"),
+                metadata=metadata
+            )
+            output_path = comic_dir / f"{title}.pdf"
+            with open(output_path, 'wb') as f:
+                f.write(pdf_bytes)
+            
+        elif format == "zip":
+            zip_bytes = export_service.generate_comic_zip(
+                comic_page=manga_page,
+                panel_images=panel_images,
+                audio_files=audio_files,
+                title=title,
+                metadata=metadata
+            )
+            output_path = comic_dir / f"{title}.zip"
+            with open(output_path, 'wb') as f:
+                f.write(zip_bytes)
+            
+        elif format == "web":
+            web_bytes = export_service.generate_web_package(
+                comic_page=manga_page,
+                audio_files=audio_files,
+                title=title,
+                metadata=metadata
+            )
+            output_path = comic_dir / f"{title}_web.zip"
+            with open(output_path, 'wb') as f:
+                f.write(web_bytes)
+        else:
+            return {
+                "success": False,
+                "error": f"Unknown format: {format}"
+            }
+        
+        if ctx:
+            await ctx.info(f"✅ Exported to {output_path}")
+        
+        return {
+            "success": True,
+            "format": format,
+            "output_path": str(output_path)
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to export comic: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg
+        }
+
+
+@mcp.tool()
+async def list_generated_comics(ctx: Context = None) -> List[Dict[str, Any]]:
+    """List all generated comics with metadata."""
+    try:
+        comics_dir = Path("./auto_generated_comics")
+        if not comics_dir.exists():
+            return []
+        
+        comics = []
+        for comic_dir in comics_dir.iterdir():
+            if comic_dir.is_dir():
+                metadata_path = comic_dir / "metadata.json"
+                if metadata_path.exists():
+                    with open(metadata_path, 'r') as f:
+                        metadata = json.load(f)
+                    comics.append({
+                        "comic_id": comic_dir.name,
+                        "title": metadata.get("title", comic_dir.name),
+                        "timestamp": metadata.get("timestamp"),
+                        "style": metadata.get("style"),
+                        "panel_count": metadata.get("panel_count", 0)
+                    })
+        
+        return sorted(comics, key=lambda x: x.get("timestamp", ""), reverse=True)
+        
+    except Exception as e:
+        if ctx:
+            await ctx.error(f"Failed to list comics: {str(e)}")
+        return []
+
+
+# ============================================================================
+# STORY MEMORY & CONTEXT TOOLS (Enhanced LlamaIndex Integration)
+# ============================================================================
+
+@mcp.tool()
+async def search_story_memory(
+    query: str,
+    top_k: int = 3,
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Search previous stories for context using LlamaIndex vector search.
+    
+    Args:
+        query: Search query (e.g., "wizard discovers spellbook")
+        top_k: Number of results to return
+    
+    Returns:
+        Dictionary with:
+        - success: bool
+        - query: Original query
+        - context: Retrieved context string
+        - top_k: Number of results
+        - has_results: Whether results were found
+    """
+    if ctx:
+        await ctx.info(f"🔍 Searching story memory: {query[:50]}...")
+    
+    try:
+        # Use StoryMemory directly, not through app
+        story_memory = get_story_memory()
+        if not story_memory:
+            return {
+                "success": False,
+                "error": "Story memory not available. Set ENABLE_LLAMAINDEX=true",
+                "query": query,
+                "context": "",
+                "has_results": False
+            }
+        
+        context = app.story_memory.retrieve_context(query, top_k=top_k)
+        has_results = context and context != "No stories in memory yet." and "Error" not in context
+        
+        if ctx:
+            await ctx.info(f"✅ Found {top_k} relevant stories" if has_results else "⚠️  No stories found")
+        
+        return {
+            "success": True,
+            "query": query,
+            "context": context,
+            "top_k": top_k,
+            "has_results": has_results
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to search story memory: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg,
+            "query": query,
+            "context": "",
+            "has_results": False
+        }
+
+
+@mcp.tool()
+async def store_story_in_memory(
+    story_text: str,
+    title: Optional[str] = None,
+    style: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Store a story in LlamaIndex memory for future retrieval.
+    
+    Args:
+        story_text: The story text to store
+        title: Optional story title
+        style: Optional art style (manga, cartoon, etc.)
+        metadata: Optional additional metadata
+    
+    Returns:
+        Dictionary with storage result
+    """
+    if ctx:
+        await ctx.info("💾 Storing story in memory...")
+    
+    try:
+        story_memory = get_story_memory()
+        if not story_memory:
+            return {
+                "success": False,
+                "error": "Story memory not available. Set ENABLE_LLAMAINDEX=true"
+            }
+        
+        # Prepare metadata FIRST (before using it)
+        story_metadata = {
+            "title": title or "Untitled Story",
+            "style": style or "manga",
+            **(metadata or {})
+        }
+        
+        # Store story
+        story_memory.store_story(story_text, story_metadata)
+        
+        # Get updated stats
+        stats = story_memory.get_memory_stats()
+        
+        if ctx:
+            await ctx.info(f"✅ Story stored. Total stories: {stats['total_stories']}")
+        
+        return {
+            "success": True,
+            "title": story_metadata["title"],
+            "characters_extracted": len(story_memory.character_db),
+            "total_stories": stats["total_stories"],
+            "total_characters": stats["total_characters"]
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to store story: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg
+        }
+
+
+@mcp.tool()
+async def get_character_from_memory(
+    character_name: str,
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Get stored information about a character from memory.
+    
+    Args:
+        character_name: Name of the character
+    
+    Returns:
+        Character information dictionary
+    """
+    if ctx:
+        await ctx.info(f"👤 Retrieving character: {character_name}")
+    
+    try:
+        app = get_comic_app()
+        if not app.story_memory:
+            return {
+                "success": False,
+                "error": "Story memory not available",
+                "character_name": character_name
+            }
+        
+        char_info = app.story_memory.get_character_info(character_name)
+        
+        if not char_info:
+            return {
+                "success": False,
+                "error": f"Character '{character_name}' not found in memory",
+                "character_name": character_name
+            }
+        
+        # Get consistency prompt
+        consistency_prompt = app.story_memory.get_character_consistency_prompt(character_name)
+        
+        if ctx:
+            await ctx.info(f"✅ Found character: {character_name}")
+        
+        return {
+            "success": True,
+            "character_name": character_name,
+            "appearances": char_info.get("appearances", 0),
+            "descriptions": char_info.get("descriptions", []),
+            "visual_attributes": char_info.get("visual_attributes", {}),
+            "consistency_prompt": consistency_prompt
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to get character: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg,
+            "character_name": character_name
+        }
+
+
+@mcp.tool()
+async def list_characters_in_memory(ctx: Context = None) -> Dict[str, Any]:
+    """
+    List all characters stored in story memory.
+    
+    Returns:
+        Dictionary with list of characters and statistics
+    """
+    try:
+        app = get_comic_app()
+        if not app.story_memory:
+            return {
+                "success": False,
+                "error": "Story memory not available",
+                "characters": []
+            }
+        
+        all_characters = app.story_memory.get_all_characters()
+        stats = app.story_memory.get_memory_stats()
+        
+        # Format character list
+        character_list = []
+        for name, info in all_characters.items():
+            character_list.append({
+                "name": name,
+                "appearances": info.get("appearances", 0),
+                "has_descriptions": len(info.get("descriptions", [])) > 0,
+                "has_visual_attributes": bool(info.get("visual_attributes", {}))
+            })
+        
+        return {
+            "success": True,
+            "total_characters": len(character_list),
+            "total_stories": stats.get("total_stories", 0),
+            "characters": character_list
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to list characters: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg,
+            "characters": []
+        }
+
+
+@mcp.tool()
+async def get_memory_statistics(ctx: Context = None) -> Dict[str, Any]:
+    """
+    Get statistics about the story memory system.
+    
+    Returns:
+        Dictionary with memory statistics
+    """
+    try:
+        app = get_comic_app()
+        if not app.story_memory:
+            return {
+                "success": False,
+                "error": "Story memory not available",
+                "enabled": False
+            }
+        
+        stats = app.story_memory.get_memory_stats()
+        
+        return {
+            "success": True,
+            "enabled": True,
+            "total_characters": stats.get("total_characters", 0),
+            "total_stories": stats.get("total_stories", 0),
+            "multimodal_enabled": stats.get("multimodal_enabled", False),
+            "character_names": stats.get("characters", []),
+            "multimodal_docs": stats.get("multimodal_docs", 0)
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "enabled": False
+        }
+
+
+@mcp.tool()
+async def get_character_consistency_context(
+    character_name: str,
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Get character consistency prompt for maintaining character appearance across stories.
+    
+    Args:
+        character_name: Name of the character
+    
+    Returns:
+        Consistency prompt and character information
+    """
+    if ctx:
+        await ctx.info(f"🎭 Getting consistency context for: {character_name}")
+    
+    try:
+        app = get_comic_app()
+        if not app.story_memory:
+            return {
+                "success": False,
+                "error": "Story memory not available",
+                "character_name": character_name
+            }
+        
+        char_info = app.story_memory.get_character_info(character_name)
+        if not char_info:
+            return {
+                "success": False,
+                "error": f"Character '{character_name}' not found",
+                "character_name": character_name,
+                "consistency_prompt": ""
+            }
+        
+        consistency_prompt = app.story_memory.get_character_consistency_prompt(character_name)
+        
+        return {
+            "success": True,
+            "character_name": character_name,
+            "consistency_prompt": consistency_prompt,
+            "appearances": char_info.get("appearances", 0),
+            "descriptions": char_info.get("descriptions", []),
+            "visual_attributes": char_info.get("visual_attributes", {})
+        }
+        
+    except Exception as e:
+        error_msg = f"Failed to get consistency context: {str(e)}"
+        if ctx:
+            await ctx.error(error_msg)
+        return {
+            "success": False,
+            "error": error_msg,
+            "character_name": character_name,
+            "consistency_prompt": ""
+        }
+
+
+# ============================================================================
+# UTILITY TOOLS
+# ============================================================================
+
+@mcp.tool()
+async def check_api_status(ctx: Context = None) -> Dict[str, Any]:
+    """Check status of all integrated APIs (Modal, SambaNova, ElevenLabs, etc.)."""
+    status = {
+        "openai": Config.OPENAI_API_KEY is not None,
+        "modal": Config.MODAL_TOKEN is not None and Config.ENABLE_MODAL,
+        "sambanova": Config.SAMBANOVA_API_KEY is not None and Config.ENABLE_SAMBANOVA,
+        "elevenlabs": Config.ELEVENLABS_API_KEY is not None,
+        "gemini": Config.GEMINI_API_KEY is not None and Config.ENABLE_GEMINI,
+        "blaxel": Config.BLAXEL_API_KEY is not None and Config.ENABLE_BLAXEL,
+        "nano_banana": Config.ENABLE_NANO_BANANA,
+        "character_library": Config.ENABLE_CHARACTER_LIBRARY
+    }
+    
+    return {
+        "apis": status,
+        "enabled_features": {
+            "comic_mode": Config.ENABLE_COMIC_MODE,
+            "mcp": Config.ENABLE_MCP
+        }
+    }
+
+
+@mcp.tool()
+async def estimate_generation_cost(
+    num_panels: int = 6,
+    include_audio: bool = True,
+    ctx: Context = None
+) -> Dict[str, Any]:
+    """
+    Estimate cost for generating a comic.
+    
+    Returns:
+        Dictionary with cost breakdown by service
+    """
+    costs = {
+        "story_generation": {
+            "provider": "OpenAI GPT-4o-mini" if Config.USE_OPENAI_PRIMARY else "SambaNova",
+            "estimated_cost": 0.001  # Rough estimate
+        },
+        "image_generation": {
+            "provider": "Modal SDXL" if Config.ENABLE_MODAL else "Local",
+            "estimated_cost": num_panels * 0.00082 if Config.ENABLE_MODAL else 0.0
+        },
+        "audio_generation": {
+            "provider": "ElevenLabs",
+            "estimated_cost": num_panels * 0.005 if include_audio else 0.0
+        }
+    }
+    
+    total = sum(c["estimated_cost"] for c in costs.values())
+    
+    return {
+        "breakdown": costs,
+        "total_estimated_cost": total,
+        "num_panels": num_panels,
+        "include_audio": include_audio
+    }
+
+
+# ============================================================================
+# RESOURCES (for accessing generated content)
+# ============================================================================
+
+@mcp.resource("comic://{comic_id}/page")
+def get_comic_page(comic_id: str) -> bytes:
+    """Get the full manga page image for a comic."""
+    comics_dir = Path("./auto_generated_comics")
+    page_path = comics_dir / comic_id / "manga_page.png"
+    
+    if page_path.exists():
+        with open(page_path, 'rb') as f:
+            return f.read()
+    raise FileNotFoundError(f"Comic page not found: {comic_id}")
+
+
+@mcp.resource("comic://{comic_id}/panel/{panel_num}")
+def get_comic_panel(comic_id: str, panel_num: int) -> bytes:
+    """Get individual panel image."""
+    comics_dir = Path("./auto_generated_comics")
+    panel_path = comics_dir / comic_id / f"panel_{panel_num:02d}.png"
+    
+    if panel_path.exists():
+        with open(panel_path, 'rb') as f:
+            return f.read()
+    raise FileNotFoundError(f"Panel {panel_num} not found for comic {comic_id}")
+
+
+@mcp.resource("comic://{comic_id}/metadata")
+def get_comic_metadata(comic_id: str) -> str:
+    """Get comic metadata JSON."""
+    comics_dir = Path("./auto_generated_comics")
+    metadata_path = comics_dir / comic_id / "metadata.json"
+    
+    if metadata_path.exists():
+        with open(metadata_path, 'r') as f:
+            return f.read()
+    raise FileNotFoundError(f"Metadata not found for comic {comic_id}")
+
+
+@mcp.resource("memory://characters/{character_name}")
+def get_character_resource(character_name: str) -> str:
+    """Get character information as a resource."""
+    try:
+        app = get_comic_app()
+        if not app.story_memory:
+            return json.dumps({"error": "Story memory not available"})
+        
+        char_info = app.story_memory.get_character_info(character_name)
+        if not char_info:
+            return json.dumps({"error": f"Character '{character_name}' not found"})
+        
+        return json.dumps({
+            "character_name": character_name,
+            **char_info
+        }, indent=2)
+        
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+@mcp.resource("memory://statistics")
+def get_memory_statistics_resource() -> str:
+    """Get memory statistics as a resource."""
+    try:
+        app = get_comic_app()
+        if not app.story_memory:
+            return json.dumps({"enabled": False})
+        
+        stats = app.story_memory.get_memory_stats()
+        return json.dumps(stats, indent=2)
+        
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+# ============================================================================
+# MAIN ENTRY POINT
+# ============================================================================
+
+if __name__ == "__main__":
+    if not Config.ENABLE_MCP:
+        print("⚠️  MCP server is disabled. Set ENABLE_MCP=true in .env to enable.")
+        sys.exit(0)
+    
+    print("🚀 Starting MythForge MCP Server...")
+    print(f"✅ MCP enabled: {Config.ENABLE_MCP}")
+    print("📡 Server ready. Connect via stdio transport.")
+    
+    # Run with stdio transport (for Claude Code, MCP Inspector, etc.)
+    mcp.run(transport="stdio")

nano_banana_client.py

@@ -0,0 +1,293 @@
+"""
+Nano Banana (Gemini 2.5/3 Pro Image) API Client
+Handles image generation with character consistency using Google's Gemini Image models
+"""
+
+import os
+import base64
+from io import BytesIO
+from typing import List, Optional, Dict, Union
+from PIL import Image
+import google.generativeai as genai
+from config import Config
+
+
+class NanoBananaClient:
+    """Client for Gemini Image Generation (Nano Banana / Nano Banana Pro)"""
+
+    def __init__(self, api_key: Optional[str] = None, model: str = "gemini-2.5-flash-image"):
+        """
+        Initialize Nano Banana client
+
+        Args:
+            api_key: Gemini API key (defaults to Config.GEMINI_API_KEY)
+            model: Model name - Options:
+                   - "gemini-2.5-flash-image" (Nano Banana)
+                   - "gemini-3-pro-image-preview" (Nano Banana Pro)
+        """
+        self.api_key = api_key or Config.GEMINI_API_KEY
+        if not self.api_key:
+            raise ValueError("Gemini API key is required for Nano Banana")
+
+        genai.configure(api_key=self.api_key)
+        self.model_name = model
+        self.model = genai.GenerativeModel(model)
+
+        # Conversation history for iterative generation
+        self.conversation_history: List[Dict] = []
+
+        # Display model being used
+        model_display = "Gemini 3 Pro Image (Nano Banana Pro)" if "3-pro" in model else "Gemini 2.5 Flash Image (Nano Banana)"
+        print(f"✅ Using {model_display}")
+
+    def _prepare_image_parts(self, images: List[Union[str, Image.Image, bytes]]) -> List:
+        """
+        Prepare image parts for Gemini API
+
+        Args:
+            images: List of images (file paths, PIL Images, or bytes)
+
+        Returns:
+            List of image parts for API
+        """
+        image_parts = []
+
+        for img in images:
+            if isinstance(img, str):
+                # File path
+                with Image.open(img) as pil_img:
+                    image_parts.append(pil_img)
+            elif isinstance(img, Image.Image):
+                # PIL Image
+                image_parts.append(img)
+            elif isinstance(img, bytes):
+                # Bytes
+                pil_img = Image.open(BytesIO(img))
+                image_parts.append(pil_img)
+            else:
+                raise ValueError(f"Unsupported image type: {type(img)}")
+
+        return image_parts
+
+    def generate_image(
+        self,
+        prompt: str,
+        reference_images: Optional[List[Union[str, Image.Image, bytes]]] = None,
+        aspect_ratio: str = "1:1",
+        num_images: int = 1,
+        safety_filter: str = "default"
+    ) -> List[Image.Image]:
+        """
+        Generate images using Nano Banana
+
+        Args:
+            prompt: Text description of desired image
+            reference_images: Optional list of reference images for consistency (up to 14)
+            aspect_ratio: One of "1:1", "16:9", "9:16", "21:9"
+            num_images: Number of images to generate (1-4)
+            safety_filter: Safety filter level
+
+        Returns:
+            List of generated PIL Images
+        """
+        # Validate reference images count
+        if reference_images and len(reference_images) > Config.NANO_BANANA_MAX_REFERENCES:
+            print(f"Warning: Too many reference images ({len(reference_images)}). Using first {Config.NANO_BANANA_MAX_REFERENCES}.")
+            reference_images = reference_images[:Config.NANO_BANANA_MAX_REFERENCES]
+
+        # Build prompt parts
+        parts = []
+
+        # Add reference images if provided
+        if reference_images:
+            image_parts = self._prepare_image_parts(reference_images)
+            parts.extend(image_parts)
+
+            # Add reference instruction
+            parts.append(f"Using the reference image(s) above, generate: {prompt}")
+        else:
+            parts.append(prompt)
+
+        # Add aspect ratio instruction
+        parts.append(f"\nAspect ratio: {aspect_ratio}")
+
+        try:
+            # Generate image
+            response = self.model.generate_content(
+                parts,
+                generation_config={
+                    "temperature": 0.8,
+                    "candidate_count": num_images
+                }
+            )
+
+            # Store in conversation history
+            self.conversation_history.append({
+                "prompt": prompt,
+                "reference_count": len(reference_images) if reference_images else 0,
+                "response": response
+            })
+
+            # Extract images from response
+            generated_images = []
+
+            # Note: Actual image extraction depends on Gemini API response format
+            # This is a placeholder - adjust based on actual API response structure
+            if hasattr(response, 'images'):
+                for img_data in response.images:
+                    if isinstance(img_data, bytes):
+                        generated_images.append(Image.open(BytesIO(img_data)))
+                    elif hasattr(img_data, 'data'):
+                        generated_images.append(Image.open(BytesIO(img_data.data)))
+
+            # Fallback: Check response parts
+            if not generated_images and hasattr(response, 'parts'):
+                for part in response.parts:
+                    if hasattr(part, 'inline_data'):
+                        img_bytes = part.inline_data.data
+                        generated_images.append(Image.open(BytesIO(img_bytes)))
+
+            if not generated_images:
+                raise ValueError("No images returned from Gemini API")
+
+            print(f"Generated {len(generated_images)} image(s)")
+            return generated_images
+
+        except Exception as e:
+            print(f"Error generating image with Nano Banana: {e}")
+            raise
+
+    def generate_with_character_consistency(
+        self,
+        prompt: str,
+        character_references: List[Union[str, Image.Image, bytes]],
+        character_description: str,
+        scene_number: int = 1
+    ) -> Image.Image:
+        """
+        Generate image maintaining character consistency
+
+        Args:
+            prompt: Scene description
+            character_references: Reference images of the character
+            character_description: Detailed text description of character
+            scene_number: Scene/panel number for context
+
+        Returns:
+            Generated PIL Image with consistent character
+        """
+        # Build consistency-focused prompt
+        consistency_prompt = f"""CHARACTER CONSISTENCY REQUIREMENTS:
+{character_description}
+
+IMPORTANT: Maintain the EXACT same character appearance from the reference images.
+- Same facial features, hair, clothing, body type
+- Same artistic style and color palette
+- Consistent character identity across all details
+
+SCENE {scene_number}:
+{prompt}
+
+Generate this scene while keeping the character IDENTICAL to the reference images."""
+
+        return self.generate_image(
+            prompt=consistency_prompt,
+            reference_images=character_references,
+            aspect_ratio="1:1",
+            num_images=1
+        )[0]
+
+    def generate_character_sheet(
+        self,
+        character_description: str,
+        style: str = "manga"
+    ) -> List[Image.Image]:
+        """
+        Generate character reference sheet with multiple views
+
+        Args:
+            character_description: Detailed character description
+            style: Art style (manga, anime, comic, etc.)
+
+        Returns:
+            List of character views (front, side, expressions, etc.)
+        """
+        views = [
+            "front view, standing pose, full body",
+            "side profile view, standing pose",
+            "facial close-up, neutral expression",
+            "facial close-up, happy expression"
+        ]
+
+        character_sheets = []
+
+        for i, view in enumerate(views):
+            prompt = f"{character_description}, {view}, {style} art style, character reference sheet, clean white background, professional character design"
+
+            # Use previous views as references for consistency
+            reference_images = character_sheets if i > 0 else None
+
+            try:
+                img = self.generate_image(
+                    prompt=prompt,
+                    reference_images=reference_images,
+                    aspect_ratio="1:1",
+                    num_images=1
+                )[0]
+
+                character_sheets.append(img)
+                print(f"Generated character sheet view {i+1}/{len(views)}")
+
+            except Exception as e:
+                print(f"Error generating character sheet view {i+1}: {e}")
+                continue
+
+        return character_sheets
+
+    def reset_conversation(self):
+        """Reset conversation history for new session"""
+        self.conversation_history = []
+        print("Conversation history reset")
+
+    def get_conversation_context(self) -> str:
+        """Get summary of conversation history"""
+        if not self.conversation_history:
+            return "No conversation history"
+
+        summary = f"Conversation with {len(self.conversation_history)} interactions:\n"
+        for i, interaction in enumerate(self.conversation_history, 1):
+            summary += f"{i}. Prompt: {interaction['prompt'][:50]}... (Refs: {interaction['reference_count']})\n"
+
+        return summary
+
+
+# Example usage
+if __name__ == "__main__":
+    # Test Nano Banana client
+    client = NanoBananaClient(model="gemini-2.5-flash-image")
+
+    # Test 1: Simple generation
+    print("\n=== Test 1: Simple Image Generation ===")
+    try:
+        images = client.generate_image(
+            prompt="An elderly yogi with long white beard, wearing saffron robes, meditating in a vibrant jungle",
+            aspect_ratio="1:1",
+            num_images=1
+        )
+        print(f"Success! Generated {len(images)} image(s)")
+    except Exception as e:
+        print(f"Test 1 failed: {e}")
+
+    # Test 2: Character sheet generation
+    print("\n=== Test 2: Character Sheet Generation ===")
+    try:
+        character_desc = "Elderly Indian yogi, long flowing white beard, wrinkled wise face, orange saffron robes, meditation beads, peaceful expression, lean muscular build"
+        sheets = client.generate_character_sheet(
+            character_description=character_desc,
+            style="manga"
+        )
+        print(f"Success! Generated {len(sheets)} character views")
+    except Exception as e:
+        print(f"Test 2 failed: {e}")
+
+    print("\n=== Tests Complete ===")

requirements.txt

@@ -0,0 +1,28 @@
+gradio>=6.0.0
+openai>=1.54.0
+python-dotenv>=1.0.0
+google-adk>=0.1.0
+numpy>=1.24.0,<2.0
+transformers>=4.46.0
+diffusers>=0.31.0
+torch>=2.0.0
+accelerate>=0.20.0
+pillow==10.4.0
+elevenlabs>=1.0.0
+llama-index>=0.11.0
+llama-index-core>=0.11.0
+llama-index-embeddings-openai>=0.2.0
+google-generativeai>=0.8.0
+reportlab>=4.0.0
+markdown>=3.5.0
+requests>=2.31.0
+modal>=0.63.0
+
+# Nano Banana + LlamaIndex Multimodal Character Consistency
+llama-index-multi-modal-llms-gemini>=0.2.0
+llama-index-vector-stores-chroma>=0.2.0
+chromadb>=0.4.0
+pillow>=10.0.0
+
+mcp>=1.22.0
+fastmcp>=2.13.1

sambanova_generator.py

@@ -0,0 +1,372 @@
+"""SambaNova Cloud Integration for MythForge Comic Generator
+
+Uses Llama 3.3 70B for ultra-fast comic story and dialogue generation.
+461 tokens/sec - 50x cheaper than OpenAI GPT-4o-mini.
+128k context window for complex comic narratives.
+"""
+
+import os
+import json
+import requests
+from typing import List, Dict, Optional
+from config import Config
+
+
+class SambanovaGenerator:
+    """SambaNova Cloud text generation using Llama 3.3 70B"""
+
+    def __init__(self):
+        """Initialize SambaNova client"""
+        self.api_key = Config.SAMBANOVA_API_KEY
+        self.base_url = os.getenv("SAMBANOVA_BASE_URL", "https://api.sambanova.ai/v1")
+        # Updated to use currently available production model (Llama 3.3 70B - 128k context)
+        self.model = os.getenv("SAMBANOVA_MODEL", "Meta-Llama-3.3-70B-Instruct")
+        self.enabled = Config.ENABLE_SAMBANOVA and self.api_key is not None
+
+        # Cost tracking
+        self.total_cost = 0.0
+        self.input_cost_per_million = 0.60  # $0.60 per 1M input tokens
+        self.output_cost_per_million = 1.20  # $1.20 per 1M output tokens
+
+        if self.enabled:
+            print(f"✅ SambaNova using {self.model}")
+
+    def generate_comic_story(
+        self,
+        prompt: str,
+        panel_count: int = 6,
+        style: str = "manga",
+        temperature: float = 0.7
+    ) -> Dict:
+        """
+        Generate comic story with scene descriptions for each panel
+
+        Args:
+            prompt: User's story prompt
+            panel_count: Number of panels (default 6 for manga)
+            style: Visual style (manga, cartoon, etc.)
+            temperature: Creativity level (0.0-1.0)
+
+        Returns:
+            Dict with story text, panel scenes, and dialogue
+        """
+        if not self.enabled:
+            raise ValueError("SambaNova is not enabled or API key not set")
+
+        # Create system prompt for comic generation
+        system_prompt = f"""You are a creative comic story writer specializing in {style} style.
+Generate a complete {panel_count}-panel comic story with:
+1. Engaging narrative suitable for visual storytelling
+2. Clear scene descriptions for each panel
+3. Character dialogue in speech bubble format (MINIMUM 2 sentences per panel for story progression)
+4. Action and emotion cues for illustrations
+
+Format your response as JSON with this structure:
+{{
+  "title": "Story Title",
+  "panels": [
+    {{
+      "panel_number": 1,
+      "scene_description": "Detailed visual description",
+      "dialogue": "Character: First sentence. Second sentence. Optional third sentence.",
+      "action": "What's happening"
+    }},
+    ...
+  ]
+}}"""
+
+        # Create user prompt
+        user_prompt = f"""Create a {panel_count}-panel {style} comic story based on this prompt:
+
+"{prompt}"
+
+Make it visually dynamic with clear scenes for each panel. Include rich character dialogue with AT LEAST 2 sentences per panel to deliver the storyline effectively."""
+
+        # Make API request
+        try:
+            response = self._call_api(
+                system_prompt=system_prompt,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                max_tokens=2000
+            )
+
+            # Parse response
+            story_data = self._parse_response(response, panel_count)
+
+            # Track cost
+            if "usage" in response:
+                self._update_cost(response["usage"])
+
+            return story_data
+
+        except Exception as e:
+            raise RuntimeError(f"SambaNova generation failed: {e}")
+
+    def generate_panel_dialogue(
+        self,
+        scene_description: str,
+        characters: List[str],
+        panel_number: int,
+        style: str = "manga"
+    ) -> Dict:
+        """
+        Generate dialogue for a specific comic panel
+
+        Args:
+            scene_description: What's happening in the panel
+            characters: List of character names in this panel
+            panel_number: Panel number (1-6)
+            style: Visual style
+
+        Returns:
+            Dict with dialogue and character assignments
+        """
+        if not self.enabled:
+            raise ValueError("SambaNova is not enabled")
+
+        system_prompt = f"""You are a dialogue writer for {style} comics.
+Write natural, engaging dialogue for comic speech bubbles."""
+
+        user_prompt = f"""Panel {panel_number} scene: {scene_description}
+
+Characters present: {', '.join(characters)}
+
+Write dialogue for this panel. Format as:
+Character Name: "Dialogue text"
+
+Keep it concise for speech bubbles (max 20 words per bubble)."""
+
+        try:
+            response = self._call_api(
+                system_prompt=system_prompt,
+                user_prompt=user_prompt,
+                temperature=0.8,
+                max_tokens=200
+            )
+
+            dialogue_text = response["choices"][0]["message"]["content"]
+
+            # Parse dialogue into character: text pairs
+            dialogue_data = self._parse_dialogue(dialogue_text, characters)
+
+            # Track cost
+            if "usage" in response:
+                self._update_cost(response["usage"])
+
+            return dialogue_data
+
+        except Exception as e:
+            raise RuntimeError(f"Dialogue generation failed: {e}")
+
+    def _call_api(
+        self,
+        system_prompt: str,
+        user_prompt: str,
+        temperature: float = 0.7,
+        max_tokens: int = 2000
+    ) -> Dict:
+        """
+        Make API call to SambaNova Cloud
+
+        Args:
+            system_prompt: System instructions
+            user_prompt: User's request
+            temperature: Creativity level
+            max_tokens: Max response length
+
+        Returns:
+            API response dict
+        """
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        payload = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": False
+        }
+
+        response = requests.post(
+            f"{self.base_url}/chat/completions",
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+
+        if response.status_code != 200:
+            raise RuntimeError(
+                f"SambaNova API error {response.status_code}: {response.text}"
+            )
+
+        return response.json()
+
+    def _parse_response(self, response: Dict, panel_count: int) -> Dict:
+        """Parse SambaNova response into structured comic data"""
+        content = response["choices"][0]["message"]["content"]
+
+        # Strip markdown code blocks if present (```json ... ``` or ``` ... ```)
+        content = content.strip()
+        if content.startswith("```"):
+            # Remove first ``` line
+            lines = content.split("\n")
+            if lines[0].startswith("```"):
+                lines = lines[1:]
+            # Remove last ``` line
+            if lines and lines[-1].strip() == "```":
+                lines = lines[:-1]
+            content = "\n".join(lines)
+
+        try:
+            # Try to parse as JSON
+            story_data = json.loads(content)
+
+            # Extract character names from dialogue if not provided
+            if "panels" in story_data:
+                for panel in story_data["panels"]:
+                    if panel.get("dialogue") and not panel.get("character_name"):
+                        # Try to extract character name from "Character: dialogue" format
+                        dialogue = panel["dialogue"]
+                        if ":" in dialogue:
+                            parts = dialogue.split(":", 1)
+                            character_name = parts[0].strip()
+                            # Check if it looks like a character name (not a description)
+                            if not character_name.startswith("(") and len(character_name.split()) <= 3:
+                                panel["character_name"] = character_name
+                                # Remove character name from dialogue to avoid duplication
+                                panel["dialogue"] = parts[1].strip()
+
+            # Ensure we have the right number of panels
+            if "panels" in story_data and len(story_data["panels"]) != panel_count:
+                # Adjust panels if needed
+                panels = story_data["panels"][:panel_count]
+                if len(panels) < panel_count:
+                    # Duplicate last panel to fill
+                    while len(panels) < panel_count:
+                        panels.append(panels[-1].copy())
+                        panels[-1]["panel_number"] = len(panels)
+                story_data["panels"] = panels
+
+            return story_data
+
+        except json.JSONDecodeError:
+            # Fallback: Parse as plain text
+            return self._fallback_parse(content, panel_count)
+
+    def _fallback_parse(self, content: str, panel_count: int) -> Dict:
+        """Fallback parser if JSON fails"""
+        # Split content into panels (simple heuristic)
+        lines = content.strip().split("\n")
+        panels = []
+
+        for i in range(panel_count):
+            panels.append({
+                "panel_number": i + 1,
+                "scene_description": f"Panel {i+1} from story",
+                "dialogue": "",
+                "action": lines[i] if i < len(lines) else "Continuation"
+            })
+
+        return {
+            "title": "Comic Story",
+            "panels": panels
+        }
+
+    def _parse_dialogue(self, dialogue_text: str, characters: List[str]) -> Dict:
+        """Parse dialogue text into structured format"""
+        dialogues = []
+        lines = dialogue_text.strip().split("\n")
+
+        for line in lines:
+            if ":" in line:
+                parts = line.split(":", 1)
+                character = parts[0].strip()
+                text = parts[1].strip().strip('"').strip("'")
+
+                # Only include if character is in the scene
+                if any(char.lower() in character.lower() for char in characters):
+                    dialogues.append({
+                        "character": character,
+                        "text": text
+                    })
+
+        return {"dialogues": dialogues}
+
+    def _update_cost(self, usage: Dict):
+        """Update cost tracking based on token usage"""
+        input_tokens = usage.get("prompt_tokens", 0)
+        output_tokens = usage.get("completion_tokens", 0)
+
+        input_cost = (input_tokens / 1_000_000) * self.input_cost_per_million
+        output_cost = (output_tokens / 1_000_000) * self.output_cost_per_million
+
+        cost = input_cost + output_cost
+        self.total_cost += cost
+
+        return cost
+
+    def get_cost(self) -> float:
+        """Get total cost of all SambaNova calls"""
+        return self.total_cost
+
+    def estimate_cost(self, prompt: str, panel_count: int = 6) -> float:
+        """
+        Estimate cost for generating a comic
+
+        Args:
+            prompt: User's story prompt
+            panel_count: Number of panels
+
+        Returns:
+            Estimated cost in USD
+        """
+        # Rough estimation based on typical usage
+        avg_input_tokens = len(prompt.split()) * 1.3  # Words to tokens ratio
+        avg_output_tokens = panel_count * 150  # ~150 tokens per panel
+
+        input_cost = (avg_input_tokens / 1_000_000) * self.input_cost_per_million
+        output_cost = (avg_output_tokens / 1_000_000) * self.output_cost_per_million
+
+        return input_cost + output_cost
+
+    @classmethod
+    def is_available(cls) -> bool:
+        """Check if SambaNova is configured and available"""
+        return Config.ENABLE_SAMBANOVA and Config.SAMBANOVA_API_KEY is not None
+
+
+# Test function
+if __name__ == "__main__":
+    print("Testing SambaNova Generator...")
+    print("=" * 60)
+
+    generator = SambanovaGenerator()
+
+    if not generator.enabled:
+        print("❌ SambaNova is not enabled")
+        print(f"   ENABLE_SAMBANOVA = {Config.ENABLE_SAMBANOVA}")
+        print(f"   API Key set = {Config.SAMBANOVA_API_KEY is not None}")
+        print()
+        print("To enable:")
+        print("1. Set SAMBANOVA_API_KEY in .env file")
+        print("2. Set ENABLE_SAMBANOVA=true in .env file")
+    else:
+        print("✅ SambaNova enabled")
+        print(f"   Model: {generator.model}")
+        print(f"   Base URL: {generator.base_url}")
+        print()
+
+        # Estimate cost
+        test_prompt = "A wizard discovers a magical library"
+        estimated_cost = generator.estimate_cost(test_prompt, panel_count=6)
+        print(f"Estimated cost for 6-panel comic: ${estimated_cost:.6f}")
+        print()
+
+        print("Ready for comic generation!")

speech_bubble_overlay.py

@@ -0,0 +1,353 @@
+"""Speech Bubble Overlay System for MythForge Comic Generator
+
+Adds comic-style speech bubbles with dialogue to manga panels.
+"""
+
+from typing import List, Dict, Tuple, Optional
+from PIL import Image, ImageDraw, ImageFont
+import textwrap
+
+
+class SpeechBubbleOverlay:
+    """Add speech bubbles with dialogue to comic panels"""
+
+    def __init__(self):
+        """Initialize speech bubble system"""
+        # Bubble styling
+        self.bubble_color = (255, 255, 255)  # White
+        self.bubble_border = (0, 0, 0)  # Black
+        self.border_width = 3
+        self.text_color = (0, 0, 0)  # Black text
+
+        # Padding and sizing
+        self.padding = 15  # Inside bubble
+        self.margin = 30  # From panel edges
+        self.max_width_ratio = 0.7  # Max 70% of panel width
+
+        # Font settings (using default PIL font for now)
+        self.font_size = 24
+        self.line_spacing = 8
+
+        # Try to load a better font if available
+        try:
+            self.font = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", self.font_size)
+            self.name_font = ImageFont.truetype("/System/Library/Fonts/Helvetica.ttc", self.font_size - 4)
+        except:
+            # Fallback to default
+            self.font = ImageFont.load_default()
+            self.name_font = ImageFont.load_default()
+
+    def add_dialogue_to_panel(
+        self,
+        panel: Image.Image,
+        dialogue: str,
+        character_name: Optional[str] = None,
+        position: str = "top"
+    ) -> Image.Image:
+        """
+        Add speech bubble with dialogue to a panel
+
+        Args:
+            panel: PIL Image of the comic panel
+            dialogue: Text to display in bubble
+            character_name: Optional character name to show
+            position: "top", "middle", or "bottom"
+
+        Returns:
+            Panel with speech bubble overlay
+        """
+        # Create a copy to avoid modifying original
+        panel_copy = panel.copy()
+        draw = ImageDraw.Draw(panel_copy)
+
+        # Wrap text to fit in bubble
+        max_width = int(panel.width * self.max_width_ratio)
+        wrapped_text = self._wrap_text(dialogue, max_width)
+
+        # Calculate bubble dimensions
+        bubble_width, bubble_height = self._calculate_bubble_size(
+            wrapped_text,
+            character_name
+        )
+
+        # Calculate bubble position
+        x, y = self._calculate_position(
+            panel.width,
+            panel.height,
+            bubble_width,
+            bubble_height,
+            position
+        )
+
+        # Draw bubble
+        self._draw_bubble(draw, x, y, bubble_width, bubble_height)
+
+        # Draw character name if provided
+        text_y = y + self.padding
+        if character_name:
+            text_y = self._draw_character_name(
+                draw, x, text_y, bubble_width, character_name
+            )
+            text_y += self.line_spacing
+
+        # Draw dialogue text
+        self._draw_text(draw, x, text_y, bubble_width, wrapped_text)
+
+        return panel_copy
+
+    def add_multiple_bubbles(
+        self,
+        panel: Image.Image,
+        dialogues: List[Dict]
+    ) -> Image.Image:
+        """
+        Add multiple speech bubbles to a panel
+
+        Args:
+            panel: PIL Image of the comic panel
+            dialogues: List of dialogue dicts with keys:
+                - text: Dialogue text
+                - character: Character name (optional)
+                - position: "top", "middle", "bottom" (optional)
+
+        Returns:
+            Panel with multiple speech bubbles
+        """
+        panel_copy = panel.copy()
+
+        for dialogue_data in dialogues:
+            text = dialogue_data.get("text", "")
+            character = dialogue_data.get("character")
+            position = dialogue_data.get("position", "top")
+
+            if text:
+                panel_copy = self.add_dialogue_to_panel(
+                    panel_copy,
+                    text,
+                    character,
+                    position
+                )
+
+        return panel_copy
+
+    def _wrap_text(self, text: str, max_width: int) -> List[str]:
+        """Wrap text to fit within max width"""
+        # Estimate characters per line (rough approximation)
+        avg_char_width = self.font_size * 0.6
+        chars_per_line = int(max_width / avg_char_width)
+
+        # Wrap text
+        wrapper = textwrap.TextWrapper(
+            width=chars_per_line,
+            break_long_words=False,
+            break_on_hyphens=False
+        )
+
+        return wrapper.wrap(text)
+
+    def _calculate_bubble_size(
+        self,
+        wrapped_lines: List[str],
+        character_name: Optional[str]
+    ) -> Tuple[int, int]:
+        """Calculate required bubble dimensions"""
+        # Calculate text dimensions
+        max_line_width = 0
+        for line in wrapped_lines:
+            bbox = self.font.getbbox(line)
+            line_width = bbox[2] - bbox[0]
+            max_line_width = max(max_line_width, line_width)
+
+        # Check character name width
+        if character_name:
+            name_bbox = self.name_font.getbbox(character_name.upper())
+            name_width = name_bbox[2] - name_bbox[0]
+            max_line_width = max(max_line_width, name_width)
+
+        # Calculate bubble size with padding
+        bubble_width = max_line_width + (2 * self.padding)
+
+        # Calculate height
+        line_height = self.font_size + self.line_spacing
+        text_height = len(wrapped_lines) * line_height
+
+        if character_name:
+            text_height += self.font_size + self.line_spacing  # Name height
+
+        bubble_height = text_height + (2 * self.padding)
+
+        return (int(bubble_width), int(bubble_height))
+
+    def _calculate_position(
+        self,
+        panel_width: int,
+        panel_height: int,
+        bubble_width: int,
+        bubble_height: int,
+        position: str
+    ) -> Tuple[int, int]:
+        """Calculate bubble position on panel"""
+        # Center horizontally
+        x = (panel_width - bubble_width) // 2
+
+        # Position vertically
+        if position == "top":
+            y = self.margin
+        elif position == "bottom":
+            y = panel_height - bubble_height - self.margin
+        else:  # middle
+            y = (panel_height - bubble_height) // 2
+
+        return (x, y)
+
+    def _draw_bubble(
+        self,
+        draw: ImageDraw.Draw,
+        x: int,
+        y: int,
+        width: int,
+        height: int
+    ):
+        """Draw speech bubble shape"""
+        # Draw white rectangle with black border
+        draw.rectangle(
+            [x, y, x + width, y + height],
+            fill=self.bubble_color,
+            outline=self.bubble_border,
+            width=self.border_width
+        )
+
+        # Optional: Add rounded corners in future
+        # For now, simple rectangle
+
+    def _draw_character_name(
+        self,
+        draw: ImageDraw.Draw,
+        x: int,
+        y: int,
+        bubble_width: int,
+        character_name: str
+    ) -> int:
+        """Draw character name at top of bubble"""
+        name_text = character_name.upper()
+
+        # Get text dimensions
+        bbox = self.name_font.getbbox(name_text)
+        text_width = bbox[2] - bbox[0]
+        text_height = bbox[3] - bbox[1]
+
+        # Center name in bubble
+        text_x = x + (bubble_width - text_width) // 2
+
+        # Draw name in bold (simulate by drawing multiple times)
+        for offset in [(0, 0), (1, 0), (0, 1), (1, 1)]:
+            draw.text(
+                (text_x + offset[0], y + offset[1]),
+                name_text,
+                fill=self.text_color,
+                font=self.name_font
+            )
+
+        return y + text_height
+
+    def _draw_text(
+        self,
+        draw: ImageDraw.Draw,
+        x: int,
+        y: int,
+        bubble_width: int,
+        wrapped_lines: List[str]
+    ):
+        """Draw wrapped dialogue text"""
+        line_height = self.font_size + self.line_spacing
+
+        for i, line in enumerate(wrapped_lines):
+            # Get line dimensions for centering
+            bbox = self.font.getbbox(line)
+            text_width = bbox[2] - bbox[0]
+
+            # Center line in bubble
+            text_x = x + (bubble_width - text_width) // 2
+            text_y = y + (i * line_height)
+
+            # Draw text
+            draw.text(
+                (text_x, text_y),
+                line,
+                fill=self.text_color,
+                font=self.font
+            )
+
+
+# Test/demo function
+if __name__ == "__main__":
+    print("=" * 60)
+    print("SPEECH BUBBLE OVERLAY TEST")
+    print("=" * 60)
+    print()
+
+    # Create test panel
+    panel = Image.new('RGB', (1024, 1024), color=(200, 220, 255))
+
+    # Add title to panel
+    draw = ImageDraw.Draw(panel)
+    draw.text((512, 50), "Test Comic Panel", fill=(0, 0, 0), anchor='mt')
+
+    # Initialize bubble system
+    bubble_overlay = SpeechBubbleOverlay()
+
+    # Test 1: Single bubble with character name
+    print("Test 1: Single bubble with character name")
+    panel_with_bubble = bubble_overlay.add_dialogue_to_panel(
+        panel,
+        dialogue="Welcome to MythForge! This is a test of the speech bubble system.",
+        character_name="Narrator",
+        position="top"
+    )
+
+    panel_with_bubble.save("test_bubble_single.png")
+    print("✅ Saved: test_bubble_single.png")
+    print()
+
+    # Test 2: Multiple bubbles
+    print("Test 2: Multiple bubbles")
+    dialogues = [
+        {
+            "text": "Hello! I'm testing the speech bubble system!",
+            "character": "Character 1",
+            "position": "top"
+        },
+        {
+            "text": "This looks amazing! The bubbles work great!",
+            "character": "Character 2",
+            "position": "bottom"
+        }
+    ]
+
+    panel_multi = bubble_overlay.add_multiple_bubbles(panel.copy(), dialogues)
+    panel_multi.save("test_bubble_multiple.png")
+    print("✅ Saved: test_bubble_multiple.png")
+    print()
+
+    # Test 3: Long text wrapping
+    print("Test 3: Long text wrapping")
+    long_text = (
+        "This is a much longer piece of dialogue that will need to wrap "
+        "across multiple lines to fit properly in the speech bubble without "
+        "going outside the panel boundaries."
+    )
+
+    panel_long = bubble_overlay.add_dialogue_to_panel(
+        panel.copy(),
+        dialogue=long_text,
+        character_name="Wizard",
+        position="middle"
+    )
+
+    panel_long.save("test_bubble_long.png")
+    print("✅ Saved: test_bubble_long.png")
+    print()
+
+    print("=" * 60)
+    print("Test complete! Check output images.")
+    print("=" * 60)

story_memory.py

@@ -0,0 +1,393 @@
+"""Story Memory Service using LlamaIndex with Multimodal Support"""
+import json
+import os
+import re
+from typing import Dict, List, Optional
+from llama_index.core import Document, VectorStoreIndex, StorageContext, load_index_from_storage
+from llama_index.core.node_parser import SimpleNodeParser
+from llama_index.embeddings.openai import OpenAIEmbedding
+from config import Config
+
+# Multimodal support (optional, requires additional packages)
+try:
+    from llama_index.multi_modal_llms.gemini import GeminiMultiModal
+    from llama_index.core.indices.multi_modal import MultiModalVectorStoreIndex
+    MULTIMODAL_AVAILABLE = True
+except ImportError:
+    MULTIMODAL_AVAILABLE = False
+    print("Note: Multimodal support not available. Install llama-index-multi-modal-llms-gemini for image support.")
+
+class StoryMemory:
+    """Maintain character consistency and story memory using LlamaIndex"""
+    
+    def __init__(self, persist_dir: str = "./story_memory", enable_multimodal: bool = False):
+        """Initialize Story Memory with LlamaIndex
+
+        Args:
+            persist_dir: Directory to persist vector index and character database
+            enable_multimodal: Enable multimodal (text + image) indexing
+        """
+        self.persist_dir = persist_dir
+        self.character_db_path = os.path.join(persist_dir, "characters.json")
+        self.character_db: Dict[str, Dict] = {}
+        self.index: Optional[VectorStoreIndex] = None
+        self.multimodal_index: Optional[MultiModalVectorStoreIndex] = None
+        self.enable_multimodal = enable_multimodal and MULTIMODAL_AVAILABLE and Config.ENABLE_CHARACTER_LIBRARY
+
+        # Create persist directory if it doesn't exist
+        os.makedirs(persist_dir, exist_ok=True)
+        os.makedirs(os.path.join(persist_dir, "multimodal"), exist_ok=True)
+
+        # Load existing character database
+        self._load_character_db()
+
+        # Load or create index
+        self._load_or_create_index()
+
+        # Initialize multimodal index if enabled
+        if self.enable_multimodal:
+            self._load_or_create_multimodal_index()
+    
+    def _load_character_db(self):
+        """Load character database from disk"""
+        if os.path.exists(self.character_db_path):
+            try:
+                with open(self.character_db_path, 'r') as f:
+                    self.character_db = json.load(f)
+                print(f"Loaded {len(self.character_db)} characters from memory")
+            except Exception as e:
+                print(f"Error loading character database: {e}")
+                self.character_db = {}
+    
+    def _save_character_db(self):
+        """Save character database to disk"""
+        try:
+            with open(self.character_db_path, 'w') as f:
+                json.dump(self.character_db, f, indent=2)
+        except Exception as e:
+            print(f"Error saving character database: {e}")
+    
+    def _load_or_create_index(self):
+        """Load existing index or create new one"""
+        try:
+            if os.path.exists(os.path.join(self.persist_dir, "docstore.json")):
+                # Load existing index
+                storage_context = StorageContext.from_defaults(persist_dir=self.persist_dir)
+                self.index = load_index_from_storage(storage_context)
+                print("Loaded existing story index")
+            else:
+                # Create new index
+                self.index = VectorStoreIndex([])
+                self.index.storage_context.persist(persist_dir=self.persist_dir)
+                print("Created new story index")
+        except Exception as e:
+            print(f"Error with index: {e}")
+            # Create fresh index on error
+            self.index = VectorStoreIndex([])
+
+    def _load_or_create_multimodal_index(self):
+        """Load or create multimodal index for images + text"""
+        if not MULTIMODAL_AVAILABLE:
+            print("Multimodal support not available")
+            return
+
+        try:
+            multimodal_dir = os.path.join(self.persist_dir, "multimodal")
+            if os.path.exists(os.path.join(multimodal_dir, "docstore.json")):
+                # Load existing multimodal index
+                storage_context = StorageContext.from_defaults(persist_dir=multimodal_dir)
+                self.multimodal_index = load_index_from_storage(storage_context)
+                print("Loaded existing multimodal index")
+            else:
+                # Create new multimodal index
+                self.multimodal_index = MultiModalVectorStoreIndex([])
+                self.multimodal_index.storage_context.persist(persist_dir=multimodal_dir)
+                print("Created new multimodal index")
+        except Exception as e:
+            print(f"Error with multimodal index: {e}")
+            self.multimodal_index = None
+    
+    def _extract_characters(self, story_text: str) -> List[Dict]:
+        """
+        Extract character names and descriptions from story text
+        Simple extraction based on capitalized names and context
+        """
+        characters = []
+        
+        # Look for patterns like "Name was/is/had..."
+        pattern = r'([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)\s+(was|is|had|wore|carried|felt|thought|said)'
+        matches = re.findall(pattern, story_text)
+        
+        # Get unique character names
+        char_names = list(set([match[0] for match in matches]))
+        
+        for name in char_names:
+            # Extract sentences mentioning this character
+            sentences = [s.strip() for s in story_text.split('.') if name in s]
+            description = '. '.join(sentences[:2])  # First 2 mentions
+            
+            characters.append({
+                "name": name,
+                "description": description,
+                "mentions": len(sentences)
+            })
+        
+        return characters
+    
+    def store_story(self, story_text: str, metadata: Dict):
+        """
+        Store story in knowledge graph
+        
+        Args:
+            story_text: The story text
+            metadata: Story metadata (style, tone, etc.)
+        """
+        try:
+            # Extract and store characters
+            characters = self._extract_characters(story_text)
+            
+            for char in characters:
+                char_name = char["name"]
+                if char_name not in self.character_db:
+                    self.character_db[char_name] = {
+                        "name": char_name,
+                        "descriptions": [],
+                        "appearances": 0,
+                        "visual_attributes": {}
+                    }
+                
+                # Update character info
+                self.character_db[char_name]["descriptions"].append(char["description"])
+                self.character_db[char_name]["appearances"] += 1
+                
+                # Extract visual attributes from metadata
+                if "style" in metadata:
+                    self.character_db[char_name]["visual_attributes"]["style"] = metadata["style"]
+            
+            # Save character database
+            self._save_character_db()
+            
+            # Index the story
+            doc = Document(
+                text=story_text,
+                metadata={
+                    **metadata,
+                    "characters": [c["name"] for c in characters]
+                }
+            )
+            
+            self.index.insert(doc)
+            self.index.storage_context.persist(persist_dir=self.persist_dir)
+            
+            print(f"Stored story with {len(characters)} characters")
+            
+        except Exception as e:
+            print(f"Error storing story: {e}")
+    
+    def get_character_info(self, character_name: str) -> Optional[Dict]:
+        """
+        Get stored information about a character
+        
+        Args:
+            character_name: Name of the character
+            
+        Returns:
+            Character information dictionary or None
+        """
+        return self.character_db.get(character_name)
+    
+    def get_all_characters(self) -> Dict[str, Dict]:
+        """Get all stored characters"""
+        return self.character_db
+    
+    def retrieve_context(self, query: str, top_k: int = 3) -> str:
+        """
+        Retrieve relevant story context based on query
+        
+        Args:
+            query: Search query
+            top_k: Number of results to return
+            
+        Returns:
+            Retrieved context as string
+        """
+        try:
+            if self.index is None:
+                return "No stories in memory yet."
+            
+            query_engine = self.index.as_query_engine(similarity_top_k=top_k)
+            response = query_engine.query(query)
+            
+            return str(response)
+            
+        except Exception as e:
+            print(f"Error retrieving context: {e}")
+            return "Error retrieving context."
+    
+    def get_character_consistency_prompt(self, character_name: str) -> str:
+        """
+        Generate a prompt to maintain character consistency
+        
+        Args:
+            character_name: Name of the character
+            
+        Returns:
+            Consistency prompt for story generation
+        """
+        char_info = self.get_character_info(character_name)
+        
+        if not char_info:
+            return ""
+        
+        prompt = f"\nCharacter Consistency Note:\n"
+        prompt += f"- {character_name} has appeared in {char_info['appearances']} previous stories\n"
+        
+        if char_info['descriptions']:
+            prompt += f"- Previous description: {char_info['descriptions'][0]}\n"
+        
+        if char_info['visual_attributes']:
+            prompt += f"- Visual style: {char_info['visual_attributes'].get('style', 'N/A')}\n"
+        
+        return prompt
+    
+    def get_memory_stats(self) -> Dict:
+        """Get statistics about stored memories"""
+        stats = {
+            "total_characters": len(self.character_db),
+            "characters": list(self.character_db.keys()),
+            "total_stories": len(self.index.docstore.docs) if self.index else 0,
+            "multimodal_enabled": self.enable_multimodal
+        }
+
+        if self.multimodal_index:
+            stats["multimodal_docs"] = len(self.multimodal_index.docstore.docs) if hasattr(self.multimodal_index, 'docstore') else 0
+
+        return stats
+
+    def store_character_with_images(
+        self,
+        character_name: str,
+        character_description: str,
+        image_paths: List[str],
+        metadata: Optional[Dict] = None
+    ):
+        """
+        Store character with associated images in multimodal index
+
+        Args:
+            character_name: Name of the character
+            character_description: Text description
+            image_paths: List of paths to character images
+            metadata: Optional metadata
+        """
+        if not self.enable_multimodal or not self.multimodal_index:
+            print("Multimodal indexing not enabled. Storing text only.")
+            # Fallback to text-only storage
+            self.store_story(
+                story_text=f"Character: {character_name}\n{character_description}",
+                metadata={
+                    "type": "character",
+                    "character_name": character_name,
+                    **(metadata or {})
+                }
+            )
+            return
+
+        try:
+            from llama_index.core.schema import ImageDocument
+
+            # Create text document
+            text_doc = Document(
+                text=f"Character: {character_name}\n{character_description}",
+                metadata={
+                    "type": "character",
+                    "character_name": character_name,
+                    **(metadata or {})
+                }
+            )
+
+            # Create image documents
+            image_docs = []
+            for img_path in image_paths:
+                if os.path.exists(img_path):
+                    img_doc = ImageDocument(
+                        image_path=img_path,
+                        metadata={
+                            "character_name": character_name,
+                            "type": "character_image",
+                            **(metadata or {})
+                        }
+                    )
+                    image_docs.append(img_doc)
+
+            # Index documents
+            if image_docs:
+                all_docs = [text_doc] + image_docs
+                self.multimodal_index.insert_nodes(all_docs)
+
+                # Persist
+                multimodal_dir = os.path.join(self.persist_dir, "multimodal")
+                self.multimodal_index.storage_context.persist(persist_dir=multimodal_dir)
+
+                print(f"Stored character '{character_name}' with {len(image_docs)} images in multimodal index")
+            else:
+                print(f"No valid images found for {character_name}. Storing text only.")
+                self.multimodal_index.insert(text_doc)
+
+        except Exception as e:
+            print(f"Error storing character with images: {e}")
+            # Fallback to text-only
+            self.store_story(
+                story_text=f"Character: {character_name}\n{character_description}",
+                metadata={"type": "character", "character_name": character_name}
+            )
+
+    def retrieve_character_with_images(
+        self,
+        character_name: str,
+        top_k: int = 3
+    ) -> Dict:
+        """
+        Retrieve character information including images
+
+        Args:
+            character_name: Name of the character
+            top_k: Number of results to return
+
+        Returns:
+            Dictionary with character info and image paths
+        """
+        if not self.enable_multimodal or not self.multimodal_index:
+            # Fallback to text-only retrieval
+            return {
+                "character_name": character_name,
+                "description": self.retrieve_context(character_name, top_k=top_k),
+                "images": []
+            }
+
+        try:
+            query_engine = self.multimodal_index.as_query_engine(similarity_top_k=top_k)
+            response = query_engine.query(f"Character: {character_name}")
+
+            # Extract image paths from retrieved nodes
+            image_paths = []
+            if hasattr(response, 'source_nodes'):
+                for node in response.source_nodes:
+                    if hasattr(node, 'metadata') and node.metadata.get('type') == 'character_image':
+                        img_path = node.metadata.get('image_path')
+                        if img_path and os.path.exists(img_path):
+                            image_paths.append(img_path)
+
+            return {
+                "character_name": character_name,
+                "description": str(response),
+                "images": image_paths
+            }
+
+        except Exception as e:
+            print(f"Error retrieving character with images: {e}")
+            return {
+                "character_name": character_name,
+                "description": "Error retrieving character",
+                "images": []
+            }

test_mcp_memory.py

@@ -0,0 +1,16 @@
+from mythforge_mcp_memory_client import get_mcp_memory_client
+
+client = get_mcp_memory_client()
+if client:
+    # Test retrieve
+    context = client.retrieve_context_sync("wizard", top_k=3)
+    print(f"Retrieved: {context[:100]}")
+    
+    # Test store
+    client.store_story_sync(
+        "A wizard discovers a spellbook",
+        {"title": "Test Story", "style": "manga"}
+    )
+    print("✅ Stored via MCP")
+else:
+    print("❌ MCP client not available")