Update app.py

app.py

@@ -49,25 +49,47 @@ if not SERPHOUSE_API_KEY:
     logger.warning("SERPHOUSE_API_KEY not set. Web search functionality will be limited.")
 
 ##############################################################################
-# AI Image Generation API Configuration
+# AI Image Generation API Configuration - FLUX API
 ##############################################################################
-AI_IMAGE_API_URL = "http://211.233.58.201:7971/"
-AI_IMAGE_ENABLED = False
-ai_image_client = None
+FLUX_API_URL = "http://211.233.58.201:7896"
+FLUX_API_ENABLED = False
+flux_api_client = None
 
-def initialize_ai_image_api():
-    """AI 이미지 생성 API 초기화"""
-    global AI_IMAGE_ENABLED, ai_image_client
+def initialize_flux_api():
+    """FLUX API 초기화"""
+    global FLUX_API_ENABLED, flux_api_client
     
     try:
-        logger.info("Connecting to AI image generation API...")
-        ai_image_client = Client(AI_IMAGE_API_URL)
-        AI_IMAGE_ENABLED = True
-        logger.info("AI image generation API connected successfully")
+        logger.info("Connecting to FLUX API...")
+        flux_api_client = Client(FLUX_API_URL)
+        FLUX_API_ENABLED = True
+        logger.info("FLUX API connected successfully")
         return True
     except Exception as e:
-        logger.error(f"Failed to connect to AI image API: {e}")
-        AI_IMAGE_ENABLED = False
+        logger.error(f"Failed to connect to FLUX API: {e}")
+        FLUX_API_ENABLED = False
+        return False
+
+##############################################################################
+# Diagram Generation API Configuration
+##############################################################################
+DIAGRAM_API_URL = "http://211.233.58.201:7860"  # ChartGPT API URL
+DIAGRAM_API_ENABLED = False
+diagram_api_client = None
+
+def initialize_diagram_api():
+    """다이어그램 생성 API 초기화"""
+    global DIAGRAM_API_ENABLED, diagram_api_client
+    
+    try:
+        logger.info("Connecting to Diagram Generation API...")
+        diagram_api_client = Client(DIAGRAM_API_URL)
+        DIAGRAM_API_ENABLED = True
+        logger.info("Diagram API connected successfully")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to connect to Diagram API: {e}")
+        DIAGRAM_API_ENABLED = False
         return False
 
 ##############################################################################
@@ -308,6 +330,288 @@ def get_emoji_for_content(text: str) -> str:
     else:
         return '▶️'
 
+##############################################################################
+# Diagram Type Detection
+##############################################################################
+def detect_diagram_type(title: str, content: str) -> Optional[str]:
+    """슬라이드 내용을 분석하여 적절한 다이어그램 타입 결정"""
+    combined_text = f"{title} {content}".lower()
+    
+    # Process Flow keywords
+    if any(word in combined_text for word in ['프로세스', 'process', '절차', 'procedure', '단계', 'step', 'flow', '흐름', '워크플로우', 'workflow']):
+        return "Process Flow"
+    
+    # WBS keywords
+    elif any(word in combined_text for word in ['wbs', '작업분해', '프로젝트', 'project', '업무분해', 'breakdown', '구조도']):
+        return "WBS Diagram"
+    
+    # Concept Map keywords
+    elif any(word in combined_text for word in ['개념', 'concept', '관계', 'relationship', '연관', 'connection', '마인드맵', 'mindmap']):
+        return "Concept Map"
+    
+    # Radial Diagram keywords
+    elif any(word in combined_text for word in ['중심', 'central', '방사형', 'radial', '핵심', 'core', '주요', 'main']):
+        return "Radial Diagram"
+    
+    # Synoptic Chart keywords
+    elif any(word in combined_text for word in ['개요', 'overview', '전체', 'overall', '요약', 'summary', '시놉틱', 'synoptic']):
+        return "Synoptic Chart"
+    
+    return None
+
+##############################################################################
+# Generate Diagram JSON using LLM
+##############################################################################
+def generate_diagram_json(title: str, content: str, diagram_type: str) -> Optional[str]:
+    """LLM을 사용하여 다이어그램용 JSON 생성"""
+    if not FRIENDLI_TOKEN:
+        return None
+    
+    # 다이어그램 타입별 JSON 구조 가이드
+    json_guides = {
+        "Concept Map": """Generate a JSON for a concept map with the EXACT following structure:
+{
+  "central_node": "Main Topic",
+  "nodes": [
+    {
+      "id": "node1",
+      "label": "First Concept",
+      "relationship": "is part of",
+      "subnodes": [
+        {
+          "id": "node1_1",
+          "label": "Sub Concept 1",
+          "relationship": "includes",
+          "subnodes": []
+        }
+      ]
+    }
+  ]
+}""",
+        "Process Flow": """Generate a JSON for a process flow diagram with the EXACT following structure:
+{
+  "start_node": "Start Process",
+  "nodes": [
+    {"id": "step1", "label": "First Step", "type": "process"},
+    {"id": "step2", "label": "Decision Point", "type": "decision"},
+    {"id": "end", "label": "End Process", "type": "end"}
+  ],
+  "connections": [
+    {"from": "start_node", "to": "step1", "label": "Begin"},
+    {"from": "step1", "to": "step2", "label": "Next"},
+    {"from": "step2", "to": "end", "label": "Complete"}
+  ]
+}""",
+        "WBS Diagram": """Generate a JSON for a WBS diagram with the EXACT following structure:
+{
+  "project_title": "Project Name",
+  "phases": [
+    {
+      "id": "phase1",
+      "label": "Phase 1",
+      "tasks": [
+        {
+          "id": "task1_1",
+          "label": "Task 1.1",
+          "subtasks": []
+        }
+      ]
+    }
+  ]
+}""",
+        "Radial Diagram": """Generate a JSON for a radial diagram with the EXACT following structure:
+{
+  "central_node": "Central Concept",
+  "nodes": [
+    {
+      "id": "branch1",
+      "label": "Branch 1",
+      "relationship": "connected to",
+      "subnodes": []
+    }
+  ]
+}""",
+        "Synoptic Chart": """Generate a JSON for a synoptic chart with the EXACT following structure:
+{
+  "central_node": "Chart Title",
+  "nodes": [
+    {
+      "id": "phase1",
+      "label": "Phase 1 Name",
+      "relationship": "starts with",
+      "subnodes": []
+    }
+  ]
+}"""
+    }
+    
+    system_prompt = f"""You are a helpful assistant that generates JSON structures for diagrams.
+{json_guides.get(diagram_type, '')}
+
+Important rules:
+1. Generate ONLY valid JSON without any explanation or markdown formatting
+2. The JSON must follow the EXACT structure shown above
+3. Create content based on the provided title and content
+4. Use the user's language (Korean or English) for the content values
+5. Keep it simple with 3-5 main nodes/steps"""
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": f"Create a {diagram_type} JSON for:\nTitle: {title}\nContent: {content}"}
+    ]
+    
+    headers = {
+        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": FRIENDLI_MODEL_ID,
+        "messages": messages,
+        "max_tokens": 1000,
+        "temperature": 0.7,
+        "stream": False
+    }
+    
+    try:
+        response = requests.post(FRIENDLI_API_URL, headers=headers, json=payload, timeout=30)
+        if response.status_code == 200:
+            response_data = response.json()
+            if 'choices' in response_data and len(response_data['choices']) > 0:
+                content = response_data['choices'][0]['message']['content']
+                # Extract JSON from response
+                content = content.strip()
+                if content.startswith("```json"):
+                    content = content[7:]
+                if content.startswith("```"):
+                    content = content[3:]
+                if content.endswith("```"):
+                    content = content[:-3]
+                
+                # Validate JSON
+                json.loads(content)  # This will raise exception if invalid
+                return content
+    except Exception as e:
+        logger.error(f"Error generating diagram JSON: {e}")
+    
+    return None
+
+##############################################################################
+# Generate Diagram using API
+##############################################################################
+def generate_diagram_via_api(json_data: str, diagram_type: str) -> Optional[str]:
+    """다이어그램 API를 통해 다이어그램 생성"""
+    if not DIAGRAM_API_ENABLED or not diagram_api_client:
+        return None
+    
+    try:
+        # API 호출
+        result = diagram_api_client.predict(
+            prompt_input=f"Generate {diagram_type}",  # 프롬프트
+            diagram_type_select=diagram_type,  # 다이어그램 타입
+            design_type_select="None",  # 디자인 타입은 None
+            output_format_radio="png",  # PNG 형식
+            use_search_checkbox=False,  # 검색 사용 안함
+            api_name="/generate_with_llm"
+        )
+        
+        # 결과에서 이미지 경로 추출
+        if isinstance(result, tuple) and len(result) > 0:
+            image_path = result[0]
+            if image_path and os.path.exists(image_path):
+                # 임시 파일로 복사
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
+                    shutil.copy2(image_path, tmp.name)
+                    return tmp.name
+        
+        return None
+        
+    except Exception as e:
+        logger.error(f"Failed to generate diagram via API: {e}")
+        return None
+
+##############################################################################
+# FLUX Image Generation Functions
+##############################################################################
+def generate_flux_prompt(title: str, content: str) -> str:
+    """슬라이드 내용을 기반으로 FLUX 이미지 프롬프�� 생성"""
+    
+    # LLM을 사용하여 프롬프트 생성
+    system_prompt = """You are an expert at creating visual prompts for AI image generation.
+Create a concise, visually descriptive prompt in English based on the slide content.
+The prompt should describe a professional, modern illustration that represents the key concepts.
+Keep it under 100 words and focus on visual elements, style, and mood.
+Output ONLY the prompt without any explanation."""
+    
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": f"Create an image prompt for:\nTitle: {title}\nContent: {content[:500]}"}
+    ]
+    
+    headers = {
+        "Authorization": f"Bearer {FRIENDLI_TOKEN}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": FRIENDLI_MODEL_ID,
+        "messages": messages,
+        "max_tokens": 200,
+        "temperature": 0.8,
+        "stream": False
+    }
+    
+    try:
+        response = requests.post(FRIENDLI_API_URL, headers=headers, json=payload, timeout=30)
+        if response.status_code == 200:
+            response_data = response.json()
+            if 'choices' in response_data and len(response_data['choices']) > 0:
+                prompt = response_data['choices'][0]['message']['content'].strip()
+                return f"Professional business presentation slide illustration: {prompt}, modern clean style, corporate colors, white background"
+    except Exception as e:
+        logger.error(f"Error generating FLUX prompt: {e}")
+    
+    # Fallback prompt
+    return f"Professional business presentation illustration about {title}, modern minimalist style, clean design, corporate colors"
+
+def generate_flux_image_via_api(prompt: str) -> Optional[str]:
+    """FLUX API를 통해 이미지 생성"""
+    if not FLUX_API_ENABLED or not flux_api_client:
+        return None
+    
+    try:
+        logger.info(f"Generating FLUX image with prompt: {prompt[:100]}...")
+        
+        result = flux_api_client.predict(
+            prompt=prompt,
+            width=768,
+            height=768,
+            guidance=3.5,
+            inference_steps=8,
+            seed=random.randint(1, 1000000),
+            do_img2img=False,
+            init_image=None,
+            image2image_strength=0.8,
+            resize_img=True,
+            api_name="/generate_image"
+        )
+        
+        if isinstance(result, tuple) and len(result) > 0:
+            image_path = result[0]
+            if image_path and os.path.exists(image_path):
+                # PNG로 변환
+                with Image.open(image_path) as img:
+                    png_tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+                    img.save(png_tmp.name, format="PNG")
+                    logger.info(f"FLUX image generated and saved to {png_tmp.name}")
+                    return png_tmp.name
+        
+        return None
+        
+    except Exception as e:
+        logger.error(f"Failed to generate FLUX image: {e}")
+        return None
+
 ##############################################################################
 # Icon and Shape Mappings
 ##############################################################################
@@ -559,114 +863,127 @@ def pdf_to_markdown(pdf_path: str) -> str:
     return f"**[PDF File: {os.path.basename(pdf_path)}]**\n\n{full_text}"
 
 ##############################################################################
-# AI Image Generation Functions using API
+# AI Image Generation Functions using FLUX API
 ##############################################################################
 def generate_cover_image_prompt(topic: str, slides_data: list) -> str:
-    """PPT 주제와 내용을 기반으로 표지 이미지 프롬프트 생성 - 한글 지원"""
+    """PPT 주제와 내용을 기반으로 표지 이미지 프롬프트 생성"""
     
     # 주요 키워드 추출
-    keywords = []
-    topic_keywords = extract_keywords(topic, top_k=3)
-    keywords.extend(topic_keywords.split())
-    
-    # 각 슬라이드 제목에서 키워드 추출
-    for slide in slides_data[:5]:
-        title = slide.get('title', '')
-        if title:
-            slide_keywords = extract_keywords(title, top_k=2)
-            keywords.extend(slide_keywords.split())
-    
-    unique_keywords = list(dict.fromkeys(keywords))[:5]
+    keywords = extract_keywords(topic, top_k=3).split()
     
     # 주제 분석을 통한 스타일 결정
-    style = "현대적이고 전문적인"
+    style = "modern professional"
     topic_lower = topic.lower()
     
     if any(word in topic_lower for word in ['기술', 'tech', 'ai', '인공지능', 'digital', '디지털']):
-        style = "미래지향적이고 하이테크한 디지털 아트"
+        style = "futuristic technology"
     elif any(word in topic_lower for word in ['비즈니스', 'business', '경영', 'management']):
-        style = "전문적이고 기업적인 현대적"
+        style = "corporate business"
     elif any(word in topic_lower for word in ['교육', 'education', '학습', 'learning']):
-        style = "교육적이고 영감을 주는 밝은"
+        style = "educational inspiring"
     elif any(word in topic_lower for word in ['환경', 'environment', '자연', 'nature']):
-        style = "자연적이고 친환경적인 녹색"
+        style = "nature eco-friendly"
     elif any(word in topic_lower for word in ['의료', 'medical', '건강', 'health']):
-        style = "의료적이고 건강한 깨끗한"
+        style = "medical healthcare"
     elif any(word in topic_lower for word in ['금융', 'finance', '투자', 'investment']):
-        style = "금융적이고 전문적인 신뢰감 있는"
+        style = "financial professional"
     
-    # wbgmsst 스타일을 위한 한글 프롬프트 구성
-    prompt = f"wbgmsst, 3D, {' '.join(unique_keywords)}를 상징하는 아이소메트릭 스타일의 {style} 일러스트레이션, 흰색 배경, 깔끔한 미니멀리스틱 구성, 전문적인 프레젠테이션 표지, 고품질, 스튜디오 조명"
+    # FLUX를 위한 영어 프롬프트 구성
+    prompt = f"Professional presentation cover design, {style} theme, abstract geometric shapes representing {' '.join(keywords)}, modern minimalist style, gradient background, clean composition, high quality, corporate design"
     
     return prompt
 
+def generate_conclusion_image_prompt(title: str, content: str) -> str:
+    """결론 슬라이드용 이미지 프롬프트 생성"""
+    
+    # 주요 키워드 추출
+    keywords = extract_keywords(f"{title} {content}", top_k=5).split()
+    
+    # 결론/하이라이트 관련 키워드 감지
+    conclusion_keywords = ['결론', 'conclusion', '요약', 'summary', '핵심', 'key', 
+                          '중요', 'important', '미래', 'future', '전망', 'outlook']
+    
+    # 프롬프트 스타일 결정
+    if any(word in title.lower() + content.lower() for word in conclusion_keywords):
+        style = "inspirational conclusion with bright future vision"
+    else:
+        style = "professional summary visualization"
+    
+    # FLUX 프롬프트 구성
+    prompt = f"Professional presentation conclusion slide, {style}, highlighting {' '.join(keywords[:3])}, modern abstract visualization, uplifting mood, corporate design, high quality"
+    
+    return prompt
 
+def generate_flux_prompt(title: str, content: str) -> str:
+    """슬라이드 내용을 기반으로 FLUX 이미지 프롬프트 생성"""
+    
+    # 주요 키워드 추출
+    keywords = extract_keywords(f"{title} {content}", top_k=4).split()
+    
+    # 내용 분석을 통한 스타일 결정
+    content_lower = (title + " " + content).lower()
+    
+    style = "professional business"
+    if any(word in content_lower for word in ['data', '데이터', 'analysis', '분석', 'chart', '차트']):
+        style = "data visualization analytics"
+    elif any(word in content_lower for word in ['process', '프로세스', 'workflow', '워크플로우']):
+        style = "workflow process diagram"
+    elif any(word in content_lower for word in ['team', '팀', 'collaboration', '협업']):
+        style = "teamwork collaboration"
+    elif any(word in content_lower for word in ['growth', '성장', 'increase', '증가']):
+        style = "growth success metrics"
+    
+    # FLUX 프롬프트 구성
+    prompt = f"Professional presentation slide illustration, {style} theme, featuring {' '.join(keywords[:3])}, modern business graphics, clean corporate design, white background, high quality"
+    
+    return prompt
 
-def generate_ai_cover_image_via_api(topic: str, slides_data: list) -> Optional[str]:
-    """API를 통해 AI 표지 이미지 생성(PNG 변환 포함)"""
-    if not AI_IMAGE_ENABLED or not ai_image_client:
-        logger.warning("AI image generation API is not available")
+def generate_flux_image_via_api(prompt: str) -> Optional[str]:
+    """FLUX API를 통해 이미지 생성"""
+    if not FLUX_API_ENABLED or not flux_api_client:
+        logger.warning("FLUX API is not available")
         return None
-
+    
     try:
-        # ── 1. 프롬프트 및 파라미터 ─────────────────────────────
-        prompt = generate_cover_image_prompt(topic, slides_data)
-        logger.info(f"Generated image prompt: {prompt}")
-
-        height, width = 1024.0, 1024.0
-        steps, scales = 8.0, 3.5
-        seed = float(random.randint(0, 1_000_000))
-        logger.info(f"Calling AI image API… (h={height}, w={width}, steps={steps}, scales={scales}, seed={seed})")
-
-        result = ai_image_client.predict(
-            height=height,
-            width=width,
-            steps=steps,
-            scales=scales,
+        logger.info(f"Generating FLUX image with prompt: {prompt[:100]}...")
+        
+        result = flux_api_client.predict(
             prompt=prompt,
-            seed=seed,
-            api_name="/process_and_save_image"
+            width=768,
+            height=768,
+            guidance=3.5,
+            inference_steps=8,
+            seed=random.randint(1, 1000000),
+            do_img2img=False,
+            init_image=None,
+            image2image_strength=0.8,
+            resize_img=True,
+            api_name="/generate_image"
         )
-        logger.info(f"API call successful. Result type: {type(result)}")
-
-        # ── 2. 내부 헬퍼: WEBP → PNG 변환 ────────────────────────
-        def _to_png(src_path: str) -> Optional[str]:
-            try:
-                with Image.open(src_path) as im:
+        
+        if isinstance(result, tuple) and len(result) > 0:
+            image_path = result[0]
+            if image_path and os.path.exists(image_path):
+                # PNG로 변환
+                with Image.open(image_path) as img:
                     png_tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-                    im.save(png_tmp.name, format="PNG")
-                    logger.info(f"Converted {src_path} → {png_tmp.name}")
+                    img.save(png_tmp.name, format="PNG")
+                    logger.info(f"FLUX image generated and saved to {png_tmp.name}")
                     return png_tmp.name
-            except Exception as e:
-                logger.error(f"PNG 변환 실패: {e}")
-                return None
-
-        # ── 3. 결과 처리 ────────────────────────────────────────
-        image_path = None
-        if isinstance(result, dict):
-            image_path = result.get("path")
-        elif isinstance(result, str):
-            image_path = result
-
-        if image_path and os.path.exists(image_path):
-            ext = os.path.splitext(image_path)[1].lower()
-            if ext == ".png":
-                # 이미 PNG라면 그대로 복사
-                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp:
-                    shutil.copy2(image_path, tmp.name)
-                    logger.info(f"PNG copied from {image_path} → {tmp.name}")
-                    return tmp.name
-            else:
-                # WEBP·JPEG 등은 PNG로 변환
-                return _to_png(image_path)
-
-        logger.error(f"Image path not found or invalid: {result}")
+        
         return None
-
+        
     except Exception as e:
-        logger.error(f"Failed to generate AI image via API: {e}", exc_info=True)
+        logger.error(f"Failed to generate FLUX image: {e}")
         return None
 
+def generate_ai_cover_image_via_flux(topic: str, slides_data: list) -> Optional[str]:
+    """FLUX API를 통해 AI 표지 이미지 생성"""
+    if not FLUX_API_ENABLED:
+        return None
+
+    prompt = generate_cover_image_prompt(topic, slides_data)
+    return generate_flux_image_via_api(prompt)
 
 ##############################################################################
 # PPT Generation Functions - FIXED VERSION
@@ -1039,9 +1356,11 @@ def create_advanced_ppt_from_content(
     topic: str,
     theme_name: str,
     include_charts: bool = False,
-    include_ai_image: bool = False
+    include_ai_image: bool = False,
+    include_diagrams: bool = False,
+    include_flux_images: bool = False
 ) -> str:
-    """Create advanced PPT file with consistent visual design and AI image option"""
+    """Create advanced PPT file with consistent visual design and AI-generated visuals"""
     if not PPTX_AVAILABLE:
         raise ImportError("python-pptx library is required")
 
@@ -1053,7 +1372,7 @@ def create_advanced_ppt_from_content(
     prs.slide_height = Inches(5.625)
 
     # ─────────────────────────────────────────────────────────
-    # 1) 제목 슬라이드(표지) 생성
+    # 1) 제목 슬라이드(표지) 생성 - 수정된 레이아웃
     # ─────────────────────────────────────────────────────────
     title_slide_layout = prs.slide_layouts[0]
     slide = prs.slides.add_slide(title_slide_layout)
@@ -1061,50 +1380,14 @@ def create_advanced_ppt_from_content(
     # 배경 그라디언트
     add_gradient_background(slide, theme['colors']['primary'], theme['colors']['secondary'])
 
-    # AI 이미지(표지 그림)
-    title_top_position = Inches(2.0)
-    if include_ai_image and AI_IMAGE_ENABLED:
-        logger.info("Generating AI cover image via API...")
-        ai_image_path = generate_ai_cover_image_via_api(topic, slides_data)
-        if ai_image_path and os.path.exists(ai_image_path):
-            img = Image.open(ai_image_path)
-            img_width, img_height = img.size
-
-            # 이미지 더 크게 (60% 폭, 최대 높이 4")
-            max_width = Inches(6)
-            ratio = img_height / img_width
-            img_w = max_width
-            img_h = max_width * ratio
-            max_height = Inches(4)
-            if img_h > max_height:
-                img_h = max_height
-                img_w = max_height / ratio
-
-            left = (prs.slide_width - img_w) / 2
-            top = Inches(0.6)
-
-            pic = slide.shapes.add_picture(ai_image_path, left, top, width=img_w, height=img_h)
-            pic.shadow.inherit = False
-            pic.shadow.visible = True
-            pic.shadow.blur_radius = Pt(15)
-            pic.shadow.distance = Pt(8)
-            pic.shadow.angle = 45
-
-            title_top_position = top + img_h + Inches(0.35)
-
-            try:
-                os.unlink(ai_image_path)
-            except Exception as e:
-                logger.warning(f"Temp image delete failed: {e}")
-
-    # 제목 / 부제목 텍스트
+    # 제목과 부제목을 먼저 중앙 상단에 배치
     title_shape = slide.shapes.title
     subtitle_shape = slide.placeholders[1] if len(slide.placeholders) > 1 else None
 
     if title_shape:
         title_shape.left = Inches(0.5)
         title_shape.width = prs.slide_width - Inches(1)
-        title_shape.top = int(title_top_position)
+        title_shape.top = Inches(0.8)  # 상단에 배치
         title_shape.height = Inches(1.2)
 
         tf = title_shape.text_frame
@@ -1112,23 +1395,15 @@ def create_advanced_ppt_from_content(
         tf.text = topic
         p = tf.paragraphs[0]
         p.font.name = theme['fonts']['title']
-        p.font.size = Pt(32)
+        p.font.size = Pt(36)
         p.font.bold = True
         p.font.color.rgb = RGBColor(255, 255, 255)
         p.alignment = PP_ALIGN.CENTER
 
-        # 가로 방향 고정
-        bodyPr = tf._txBody.bodyPr
-        bodyPr.set('vert', 'horz')
-
-        # 최상위 레이어로 이동
-        slide.shapes._spTree.remove(title_shape._element)
-        slide.shapes._spTree.append(title_shape._element)
-
     if subtitle_shape:
         subtitle_shape.left = Inches(0.5)
         subtitle_shape.width = prs.slide_width - Inches(1)
-        subtitle_shape.top = int(title_top_position + Inches(1.0))
+        subtitle_shape.top = Inches(2.0)  # 제목 아래에 배치
         subtitle_shape.height = Inches(0.9)
 
         tf2 = subtitle_shape.text_frame
@@ -1136,15 +1411,60 @@ def create_advanced_ppt_from_content(
         tf2.text = f"자동 생성된 프레젠테이션  •  총 {len(slides_data)}장"
         p2 = tf2.paragraphs[0]
         p2.font.name = theme['fonts']['subtitle']
-        p2.font.size = Pt(18)
+        p2.font.size = Pt(20)
         p2.font.color.rgb = RGBColor(255, 255, 255)
         p2.alignment = PP_ALIGN.CENTER
 
-        bodyPr2 = tf2._txBody.bodyPr
-        bodyPr2.set('vert', 'horz')
-
-        slide.shapes._spTree.remove(subtitle_shape._element)
-        slide.shapes._spTree.append(subtitle_shape._element)
+    # AI 이미지를 우측에 배치
+    if include_ai_image and FLUX_API_ENABLED:
+        logger.info("Generating AI cover image via FLUX API...")
+        ai_image_path = generate_ai_cover_image_via_flux(topic, slides_data)
+        if ai_image_path and os.path.exists(ai_image_path):
+            try:
+                img = Image.open(ai_image_path)
+                img_width, img_height = img.size
+                
+                # 이미지를 우측에 배치
+                max_width = Inches(4)
+                max_height = Inches(3.5)
+                
+                ratio = img_height / img_width
+                img_w = max_width
+                img_h = max_width * ratio
+                
+                if img_h > max_height:
+                    img_h = max_height
+                    img_w = max_height / ratio
+                
+                # 우측 배치
+                left = prs.slide_width - img_w - Inches(0.5)
+                top = (prs.slide_height - img_h) / 2
+                
+                pic = slide.shapes.add_picture(ai_image_path, left, top, width=img_w, height=img_h)
+                pic.shadow.inherit = False
+                pic.shadow.visible = True
+                pic.shadow.blur_radius = Pt(15)
+                pic.shadow.distance = Pt(8)
+                pic.shadow.angle = 45
+                
+                # 이미지 아래에 작은 캡션 추가
+                caption_box = slide.shapes.add_textbox(
+                    left, top + img_h + Inches(0.1), 
+                    img_w, Inches(0.3)
+                )
+                caption_tf = caption_box.text_frame
+                caption_tf.text = "AI Generated"
+                caption_p = caption_tf.paragraphs[0]
+                caption_p.font.size = Pt(10)
+                caption_p.font.color.rgb = RGBColor(255, 255, 255)
+                caption_p.alignment = PP_ALIGN.CENTER
+                
+                try:
+                    os.unlink(ai_image_path)
+                except Exception as e:
+                    logger.warning(f"Temp image delete failed: {e}")
+            except Exception as e:
+                logger.error(f"Failed to add cover image: {e}")
 
     # 장식 요소
     add_decorative_shapes(slide, theme)
@@ -1192,149 +1512,275 @@ def create_advanced_ppt_from_content(
             except Exception as e:
                 logger.warning(f"Title font sizing failed: {e}")
         
-        # Add content based on layout - COMPLETELY FIXED VERSION
-        if layout_type == 'section_header':
-            # Section header content handling
-            content = slide_data.get('content', '')
-            if content:
-                logger.info(f"Adding content to section header slide {i+1}: {content[:50]}...")
-                textbox = slide.shapes.add_textbox(
-                    Inches(1), Inches(3.5), Inches(8), Inches(1.5)
-                )
-                tf = textbox.text_frame
-                tf.clear()
-                tf.text = content
-                tf.word_wrap = True
+        # Detect if this slide should have a diagram or image
+        slide_title = slide_data.get('title', '')
+        slide_content = slide_data.get('content', '')
+        
+        # 결론/하이라이트 슬라이드 감지
+        is_conclusion_slide = any(word in slide_title.lower() for word in 
+                                 ['결론', 'conclusion', '요약', 'summary', '핵심', 'key', 
+                                  '마무리', 'closing', '정리', 'takeaway', '시사점', 'implication'])
+        
+        # 다이어그램 또는 이미지 생성 여부 결정
+        should_add_visual = False
+        visual_type = None
+        
+        # 결론 슬라이드는 항상 FLUX 이미지 추가
+        if is_conclusion_slide and include_flux_images and FLUX_API_ENABLED:
+            should_add_visual = True
+            visual_type = ('flux_conclusion', None)
+        elif include_diagrams:
+            diagram_type = detect_diagram_type(slide_title, slide_content)
+            if diagram_type:
+                should_add_visual = True
+                visual_type = ('diagram', diagram_type)
+        elif not should_add_visual and include_flux_images and i % 3 == 0:  # 매 3번째 슬라이드에 FLUX 이미지
+            should_add_visual = True
+            visual_type = ('flux', None)
+        
+        # 시각적 요소가 있는 경우 좌-우 레이아웃 적용
+        if should_add_visual and layout_type not in ['section_header']:
+            # 좌측에 텍스트 배치
+            left_box = slide.shapes.add_textbox(
+                Inches(0.5), Inches(1.5), Inches(4.5), Inches(3.5)
+            )
+            left_tf = left_box.text_frame
+            left_tf.clear()
+            left_tf.text = slide_content
+            left_tf.word_wrap = True
+            force_font_size(left_tf, 14, theme)
+            
+            # Apply emoji bullets
+            for paragraph in left_tf.paragraphs:
+                text = paragraph.text.strip()
+                if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
+                    clean_text = text.lstrip('-•● ')
+                    emoji = get_emoji_for_content(clean_text)
+                    paragraph.text = f"{emoji} {clean_text}"
+                    force_font_size(left_tf, 14, theme)
+            
+            # 우측에 시각적 요소 추가
+            visual_added = False
+            
+            if visual_type[0] == 'diagram':
+                # 다이어그램 생성
+                logger.info(f"Generating {visual_type[1]} for slide {i+1}")
+                diagram_json = generate_diagram_json(slide_title, slide_content, visual_type[1])
                 
-                for paragraph in tf.paragraphs:
-                    paragraph.font.name = theme['fonts']['body']
-                    paragraph.font.size = Pt(16)
-                    paragraph.font.color.rgb = RGBColor(255, 255, 255)
-                    paragraph.alignment = PP_ALIGN.CENTER
+                if diagram_json:
+                    diagram_path = generate_diagram_via_api(diagram_json, visual_type[1])
+                    if diagram_path and os.path.exists(diagram_path):
+                        try:
+                            # 다이어그램 이미지 추가
+                            pic = slide.shapes.add_picture(
+                                diagram_path,
+                                Inches(5.2), Inches(1.5),
+                                width=Inches(4.3), height=Inches(3.0)
+                            )
+                            visual_added = True
+                            
+                            # 임시 파일 삭제
+                            os.unlink(diagram_path)
+                        except Exception as e:
+                            logger.error(f"Failed to add diagram: {e}")
             
-            # Add decorative line
-            line = slide.shapes.add_shape(
-                MSO_SHAPE.RECTANGLE, Inches(3), Inches(3.2), Inches(4), Pt(4)
-            )
-            line.fill.solid()
-            line.fill.fore_color.rgb = RGBColor(255, 255, 255)
-            line.line.fill.background()
-        
-        elif layout_type == 'two_content':
-            content = slide_data.get('content', '')
-            if content:
-                logger.info(f"Creating two-column layout for slide {i+1}")
-                content_lines = content.split('\n')
-                mid_point = len(content_lines) // 2
+            elif visual_type[0] == 'flux_conclusion':
+                # 결론 슬라이드용 FLUX 이미지 생성
+                logger.info(f"Generating conclusion FLUX image for slide {i+1}")
+                conclusion_prompt = generate_conclusion_image_prompt(slide_title, slide_content)
+                flux_image_path = generate_flux_image_via_api(conclusion_prompt)
                 
-                # Left column
-                left_box = slide.shapes.add_textbox(
-                    Inches(0.5), Inches(1.5), Inches(4.5), Inches(3.5)
-                )
-                left_tf = left_box.text_frame
-                left_tf.clear()
-                left_content = '\n'.join(content_lines[:mid_point])
-                if left_content:
-                    left_tf.text = left_content
-                    left_tf.word_wrap = True
-                    force_font_size(left_tf, 14, theme)
-                    
-                    # Apply emoji bullets
-                    for paragraph in left_tf.paragraphs:
-                        text = paragraph.text.strip()
-                        if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
-                            clean_text = text.lstrip('-•● ')
-                            emoji = get_emoji_for_content(clean_text)
-                            paragraph.text = f"{emoji} {clean_text}"
-                            force_font_size(left_tf, 14, theme)
+                if flux_image_path and os.path.exists(flux_image_path):
+                    try:
+                        # FLUX 이미지 추가
+                        pic = slide.shapes.add_picture(
+                            flux_image_path,
+                            Inches(5.2), Inches(1.5),
+                            width=Inches(4.3), height=Inches(3.0)
+                        )
+                        visual_added = True
+                        
+                        # 이미지 캡션 추가
+                        caption_box = slide.shapes.add_textbox(
+                            Inches(5.2), Inches(4.6), Inches(4.3), Inches(0.3)
+                        )
+                        caption_tf = caption_box.text_frame
+                        caption_tf.text = "Key Takeaway Visualization"
+                        caption_p = caption_tf.paragraphs[0]
+                        caption_p.font.size = Pt(10)
+                        caption_p.font.color.rgb = theme['colors']['secondary']
+                        caption_p.alignment = PP_ALIGN.CENTER
+                        
+                        # 임시 파일 삭제
+                        os.unlink(flux_image_path)
+                    except Exception as e:
+                        logger.error(f"Failed to add conclusion FLUX image: {e}")
+            
+            elif visual_type[0] == 'flux':
+                # FLUX 이미지 생성
+                logger.info(f"Generating FLUX image for slide {i+1}")
+                flux_prompt = generate_flux_prompt(slide_title, slide_content)
+                flux_image_path = generate_flux_image_via_api(flux_prompt)
                 
-                # Right column
-                right_box = slide.shapes.add_textbox(
-                    Inches(5), Inches(1.5), Inches(4.5), Inches(3.5)
+                if flux_image_path and os.path.exists(flux_image_path):
+                    try:
+                        # FLUX 이미지 추가
+                        pic = slide.shapes.add_picture(
+                            flux_image_path,
+                            Inches(5.2), Inches(1.5),
+                            width=Inches(4.3), height=Inches(3.0)
+                        )
+                        visual_added = True
+                        
+                        # 임시 파일 삭제
+                        os.unlink(flux_image_path)
+                    except Exception as e:
+                        logger.error(f"Failed to add FLUX image: {e}")
+            
+            # 시각적 요소가 추가되지 않은 경우 플레이스홀더 추가
+            if not visual_added:
+                placeholder_box = slide.shapes.add_textbox(
+                    Inches(5.2), Inches(2.5), Inches(4.3), Inches(1.0)
                 )
-                right_tf = right_box.text_frame
-                right_tf.clear()
-                right_content = '\n'.join(content_lines[mid_point:])
-                if right_content:
-                    right_tf.text = right_content
-                    right_tf.word_wrap = True
-                    force_font_size(right_tf, 14, theme)
-                    
-                    # Apply emoji bullets
-                    for paragraph in right_tf.paragraphs:
-                        text = paragraph.text.strip()
-                        if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
-                            clean_text = text.lstrip('-•● ')
-                            emoji = get_emoji_for_content(clean_text)
-                            paragraph.text = f"{emoji} {clean_text}"
-                            force_font_size(right_tf, 14, theme)
+                placeholder_tf = placeholder_box.text_frame
+                placeholder_tf.text = f"{visual_type[1] if visual_type[0] == 'diagram' else 'Visual'} Placeholder"
+                placeholder_tf.paragraphs[0].font.size = Pt(14)
+                placeholder_tf.paragraphs[0].font.color.rgb = theme['colors']['secondary']
+                placeholder_tf.paragraphs[0].alignment = PP_ALIGN.CENTER
         
         else:
-            # Regular content - MOST IMPORTANT PART - COMPLETELY FIXED
-            content = slide_data.get('content', '')
-            
-            # 디버깅 로그
-            logger.info(f"Slide {i+1} - Content to add: '{content[:100]}...' (length: {len(content)})")
+            # 기본 레이아웃 (시각적 요소 없음)
+            if layout_type == 'section_header':
+                # Section header content handling
+                content = slide_data.get('content', '')
+                if content:
+                    logger.info(f"Adding content to section header slide {i+1}: {content[:50]}...")
+                    textbox = slide.shapes.add_textbox(
+                        Inches(1), Inches(3.5), Inches(8), Inches(1.5)
+                    )
+                    tf = textbox.text_frame
+                    tf.clear()
+                    tf.text = content
+                    tf.word_wrap = True
+                    
+                    for paragraph in tf.paragraphs:
+                        paragraph.font.name = theme['fonts']['body']
+                        paragraph.font.size = Pt(16)
+                        paragraph.font.color.rgb = RGBColor(255, 255, 255)
+                        paragraph.alignment = PP_ALIGN.CENTER
+                
+                # Add decorative line
+                line = slide.shapes.add_shape(
+                    MSO_SHAPE.RECTANGLE, Inches(3), Inches(3.2), Inches(4), Pt(4)
+                )
+                line.fill.solid()
+                line.fill.fore_color.rgb = RGBColor(255, 255, 255)
+                line.line.fill.background()
             
-            if include_charts and slide_data.get('chart_data'):
-                create_chart_slide(slide, slide_data['chart_data'], theme)
+            elif layout_type == 'two_content':
+                content = slide_data.get('content', '')
+                if content:
+                    logger.info(f"Creating two-column layout for slide {i+1}")
+                    content_lines = content.split('\n')
+                    mid_point = len(content_lines) // 2
+                    
+                    # Left column
+                    left_box = slide.shapes.add_textbox(
+                        Inches(0.5), Inches(1.5), Inches(4.5), Inches(3.5)
+                    )
+                    left_tf = left_box.text_frame
+                    left_tf.clear()
+                    left_content = '\n'.join(content_lines[:mid_point])
+                    if left_content:
+                        left_tf.text = left_content
+                        left_tf.word_wrap = True
+                        force_font_size(left_tf, 14, theme)
+                        
+                        # Apply emoji bullets
+                        for paragraph in left_tf.paragraphs:
+                            text = paragraph.text.strip()
+                            if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
+                                clean_text = text.lstrip('-•● ')
+                                emoji = get_emoji_for_content(clean_text)
+                                paragraph.text = f"{emoji} {clean_text}"
+                                force_font_size(left_tf, 14, theme)
+                    
+                    # Right column
+                    right_box = slide.shapes.add_textbox(
+                        Inches(5), Inches(1.5), Inches(4.5), Inches(3.5)
+                    )
+                    right_tf = right_box.text_frame
+                    right_tf.clear()
+                    right_content = '\n'.join(content_lines[mid_point:])
+                    if right_content:
+                        right_tf.text = right_content
+                        right_tf.word_wrap = True
+                        force_font_size(right_tf, 14, theme)
+                        
+                        # Apply emoji bullets
+                        for paragraph in right_tf.paragraphs:
+                            text = paragraph.text.strip()
+                            if text and text.startswith(('-', '•', '●')) and not has_emoji(text):
+                                clean_text = text.lstrip('-•● ')
+                                emoji = get_emoji_for_content(clean_text)
+                                paragraph.text = f"{emoji} {clean_text}"
+                                force_font_size(right_tf, 14, theme)
             
-            # content가 있으면 무조건 텍스트박스 추가
-            if content and content.strip():
-                # 명확한 위치와 크기로 텍스트박스 생성
-                textbox = slide.shapes.add_textbox(
-                    Inches(0.5),   # left
-                    Inches(1.5),   # top  
-                    Inches(9),     # width
-                    Inches(3.5)    # height
-                )
-                
-                tf = textbox.text_frame
-                tf.clear()
-                
-                # 텍스트 설정
-                tf.text = content.strip()
-                tf.word_wrap = True
-                
-                # 텍스트 프레임 여백 설정
-                tf.margin_left = Inches(0.1)
-                tf.margin_right = Inches(0.1)
-                tf.margin_top = Inches(0.05)
-                tf.margin_bottom = Inches(0.05)
+            else:
+                # Regular content
+                content = slide_data.get('content', '')
                 
-                # 폰트 강제 적용
-                force_font_size(tf, 16, theme)
+                logger.info(f"Slide {i+1} - Content to add: '{content[:100]}...' (length: {len(content)})")
                 
-                # 각 단락에 대해 처리
-                for p_idx, paragraph in enumerate(tf.paragraphs):
-                    if paragraph.text.strip():
-                        # 이모지 추가
-                        text = paragraph.text.strip()
-                        if text.startswith(('-', '•', '●')) and not has_emoji(text):
-                            clean_text = text.lstrip('-•● ')
-                            emoji = get_emoji_for_content(clean_text)
-                            paragraph.text = f"{emoji} {clean_text}"
-                        
-                        # 폰트 재적용 - 각 run에 대해 명시적으로 설정
-                        if paragraph.runs:
-                            for run in paragraph.runs:
-                                run.font.size = Pt(16)
-                                run.font.name = theme['fonts']['body']
-                                run.font.color.rgb = theme['colors']['text']
-                        else:
-                            # runs가 없으면 생성
-                            paragraph.font.size = Pt(16)
-                            paragraph.font.name = theme['fonts']['body']
-                            paragraph.font.color.rgb = theme['colors']['text']
-                        
-                        # 단락 간격
-                        paragraph.space_before = Pt(6)
-                        paragraph.space_after = Pt(6)
-                        paragraph.line_spacing = 1.3
+                if include_charts and slide_data.get('chart_data'):
+                    create_chart_slide(slide, slide_data['chart_data'], theme)
                 
-                logger.info(f"Successfully added content to slide {i+1}")
-            else:
-                logger.warning(f"Slide {i+1} has no content or empty content")
+                if content and content.strip():
+                    textbox = slide.shapes.add_textbox(
+                        Inches(0.5),   # left
+                        Inches(1.5),   # top  
+                        Inches(9),     # width
+                        Inches(3.5)    # height
+                    )
+                    
+                    tf = textbox.text_frame
+                    tf.clear()
+                    
+                    tf.text = content.strip()
+                    tf.word_wrap = True
+                    
+                    tf.margin_left = Inches(0.1)
+                    tf.margin_right = Inches(0.1)
+                    tf.margin_top = Inches(0.05)
+                    tf.margin_bottom = Inches(0.05)
+                    
+                    force_font_size(tf, 16, theme)
+                    
+                    for p_idx, paragraph in enumerate(tf.paragraphs):
+                        if paragraph.text.strip():
+                            text = paragraph.text.strip()
+                            if text.startswith(('-', '•', '●')) and not has_emoji(text):
+                                clean_text = text.lstrip('-•● ')
+                                emoji = get_emoji_for_content(clean_text)
+                                paragraph.text = f"{emoji} {clean_text}"
+                            
+                            if paragraph.runs:
+                                for run in paragraph.runs:
+                                    run.font.size = Pt(16)
+                                    run.font.name = theme['fonts']['body']
+                                    run.font.color.rgb = theme['colors']['text']
+                            else:
+                                paragraph.font.size = Pt(16)
+                                paragraph.font.name = theme['fonts']['body']
+                                paragraph.font.color.rgb = theme['colors']['text']
+                            
+                            paragraph.space_before = Pt(6)
+                            paragraph.space_after = Pt(6)
+                            paragraph.line_spacing = 1.3
+                    
+                    logger.info(f"Successfully added content to slide {i+1}")
+                else:
+                    logger.warning(f"Slide {i+1} has no content or empty content")
         
         # Add slide notes if available
         if slide_data.get('notes'):
@@ -1578,7 +2024,7 @@ Notes: [Speaker script]
         yield f"⚠️ Error generating content: {str(e)}"
 
 ##############################################################################
-# Main PPT Generation Function - IMPROVED VERSION with API Image
+# Main PPT Generation Function - IMPROVED VERSION with Enhanced Features
 ##############################################################################
 def generate_ppt(
     topic: str,
@@ -1590,9 +2036,11 @@ def generate_ppt(
     font_style: str = "modern",
     layout_style: str = "consistent",
     include_charts: bool = False,
-    include_ai_image: bool = False
+    include_ai_image: bool = False,
+    include_diagrams: bool = False,
+    include_flux_images: bool = False
 ) -> tuple:
-    """Main function to generate PPT with advanced design and API-based AI image"""
+    """Main function to generate PPT with advanced design and enhanced visuals"""
     
     if not PPTX_AVAILABLE:
         return None, "❌ python-pptx 라이브러리가 설치되지 않았습니다.\n\n설치 명령: pip install python-pptx", ""
@@ -1604,14 +2052,32 @@ def generate_ppt(
         return None, "❌ 슬라이드 수는 3장 이상 20장 이하로 설정해주세요.", ""
     
     try:
-        # AI 이미지 생성이 요청되었지만 초기화되지 않은 경우
-        if include_ai_image and not AI_IMAGE_ENABLED:
-            yield None, "🔄 AI 이미지 생성 API에 연결하는 중...", ""
-            if initialize_ai_image_api():
-                yield None, "✅ AI 이미지 API 연결 성공!", ""
+        # FLUX API 초기화 (표지 이미지용)
+        if include_ai_image and not FLUX_API_ENABLED:
+            yield None, "🔄 FLUX 이미지 생성 API에 연결하는 중...", ""
+            if initialize_flux_api():
+                yield None, "✅ FLUX API 연결 성공!", ""
             else:
                 include_ai_image = False
-                yield None, "⚠️ AI 이미지 API 연결 실패. AI 이미지 없이 진행합니다.", ""
+                yield None, "⚠️ FLUX API 연결 실패. AI 이미지 없이 진행합니다.", ""
+        
+        # 다이어그램 API 초기화
+        if include_diagrams and not DIAGRAM_API_ENABLED:
+            yield None, "🔄 다이어그램 생성 API에 연결하는 중...", ""
+            if initialize_diagram_api():
+                yield None, "✅ 다이어그램 API 연결 성공!", ""
+            else:
+                include_diagrams = False
+                yield None, "⚠️ 다이어그램 API 연결 실패. 다이어그램 없이 진행합니다.", ""
+        
+        # FLUX API 초기화 (슬라이드 이미지용)
+        if include_flux_images and not FLUX_API_ENABLED:
+            yield None, "🔄 FLUX 이미지 생성 API에 연결하는 중...", ""
+            if initialize_flux_api():
+                yield None, "✅ FLUX API 연결 성공!", ""
+            else:
+                include_flux_images = False
+                yield None, "⚠️ FLUX API 연결 실패. 슬라이드 이미지 없이 진행합니다.", ""
         
         # Process reference files if provided
         additional_context = ""
@@ -1672,6 +2138,7 @@ def generate_ppt(
         # Debug logging
         logger.info(f"Parsed {len(slides_data)} slides from LLM response")
         logger.info(f"Design theme: {design_theme}, Layout style: {layout_style}")
+        logger.info(f"Include diagrams: {include_diagrams}, Include FLUX images: {include_flux_images}")
         
         if not slides_data:
             # Show the raw response for debugging
@@ -1682,20 +2149,42 @@ def generate_ppt(
             yield None, error_msg, llm_response
             return
         
-        # AI 이미지 생성 알림
-        if include_ai_image and AI_IMAGE_ENABLED:
-            yield None, f"📝 슬라이드 생성 완료!\n\n🎨 AI 3D 표지 이미지 생성 중... (30초 정도 소요)", llm_response
+        # AI 이미지 및 다이어그램 생성 알림
+        visual_features = []
+        if include_ai_image and FLUX_API_ENABLED:
+            visual_features.append("AI 3D 표지 이미지")
+        if include_diagrams and DIAGRAM_API_ENABLED:
+            visual_features.append("다이어그램")
+        if include_flux_images and FLUX_API_ENABLED:
+            visual_features.append("AI 생성 이미지")
+        
+        if visual_features:
+            yield None, f"📝 슬라이드 생성 완료!\n\n🎨 생성 중: {', '.join(visual_features)}... (시간이 소요될 수 있습니다)", llm_response
         
         # Create PPT file with advanced design
-        ppt_path = create_advanced_ppt_from_content(slides_data, topic, design_theme, include_charts, include_ai_image)
+        ppt_path = create_advanced_ppt_from_content(
+            slides_data, 
+            topic, 
+            design_theme, 
+            include_charts, 
+            include_ai_image,
+            include_diagrams,
+            include_flux_images
+        )
         
         success_msg = f"✅ PPT 파일이 성공적으로 생성되었습니다!\n\n"
         success_msg += f"📊 주제: {topic}\n"
         success_msg += f"📄 슬라이드 수: {len(slides_data)}장\n"
         success_msg += f"🎨 디자인 테마: {DESIGN_THEMES[design_theme]['name']}\n"
         success_msg += f"📐 레이아웃 스타일: {layout_style}\n"
-        if include_ai_image and AI_IMAGE_ENABLED:
-            success_msg += f"🖼️ AI 생성 3D 스타일 표지 이미지 포함\n"
+        
+        if include_ai_image and FLUX_API_ENABLED:
+            success_msg += f"🖼️ AI 생성 표지 이미지 포함\n"
+        if include_diagrams and DIAGRAM_API_ENABLED:
+            success_msg += f"📊 AI 생성 다이어그램 포함\n"
+        if include_flux_images and FLUX_API_ENABLED:
+            success_msg += f"🎨 AI 생성 슬라이드 이미지 포함\n"
+            
         success_msg += f"📝 생성된 슬라이드:\n"
         
         for i, slide in enumerate(slides_data[:5]):  # Show first 5 slides
@@ -1899,7 +2388,7 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
         # 🎯 AI 기반 PPT 자동 생성 시스템 Pro
         
         고급 디자인 테마와 레이아웃을 활용한 전문적인 프레젠테이션을 자동으로 생성합니다.
-        각 슬라이드마다 5개의 핵심 포인트와 발표자 노트를 포함합니다.
+        FLUX AI로 생성한 고품질 이미지와 다이어그램을 포함하여 시각적으로 풍부한 PPT를 만듭니다.
         """
     )
     
@@ -1982,11 +2471,27 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
                     info="CSV 데이터가 있을 경우 차트 생성"
                 )
             
-            include_ai_image = gr.Checkbox(
-                label="🖼️ AI 3D 표지 이미지",
-                value=False,
-                info="AI로 생성한 3D 스타일 이미지를 표지에 추가 (생성 시간 30초 추가)"
-            )
+            # Visual Enhancement Options
+            gr.Markdown("<div class='section-header'>🖼️ 시각적 향상 옵션</div>")
+            
+            with gr.Row():
+                include_ai_image = gr.Checkbox(
+                    label="🖼️ AI 표지 이미지",
+                    value=False,
+                    info="FLUX로 생성한 표지 이미지 추가"
+                )
+                
+                include_diagrams = gr.Checkbox(
+                    label="📊 AI 다이어그램",
+                    value=False,
+                    info="내용에 맞는 다이어그램 자동 생성"
+                )
+                
+                include_flux_images = gr.Checkbox(
+                    label="🎨 슬라이드 이미지",
+                    value=False,
+                    info="일부 슬라이드에 FLUX 이미지 추가"
+                )
             
             reference_files = gr.File(
                 label="📎 참고 자료 (선택사항)",
@@ -2030,42 +2535,35 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
         1. **PPT 주제 입력**: 구체적인 주제일수록 더 좋은 결과
         2. **슬라이드 수 선택**: 3-20장 범위에서 선택
         3. **디자인 테마 선택**: 5가지 전문적인 테마 중 선택
-        4. **추가 옵션 설정**: 웹 검색, 차트 포함 등
-        5. **AI 3D 이미지**: 주제를 상징하는 3D 스타일 표지 이미지 생성
-        6. **참고 자료 업로드**: PDF, CSV, TXT 파일 지원
-        7. **생성 버튼 클릭**: AI가 자동으로 PPT 생성
-        
-        ### 🎨 디자인 테마 특징
-        - **프로페셔널**: 비즈니스 프레젠테이션에 적합한 깔끔한 디자인
-        - **모던**: 트렌디하고 세련된 색상 조합
-        - **자연**: 편안하고 친근한 느낌의 자연 색상
-        - **크리에이티브**: 대담하고 활기찬 색상으로 주목도 높음
-        - **미니멀**: 깔끔하고 단순한 흑백 디자인
-        
-        ### ✨ 새로운 기능
-        - **5개 핵심 포인트**: 각 슬라이드마다 5개의 핵심 내용
-        - **발표자 노트**: 각 슬라이드마다 발표자를 위한 노트 자동 생성
-        - **향상된 폰트 크기**: 더 큰 폰트로 가독성 향상
-        - **AI 3D 이미지**: API를 통한 고품질 3D 스타일 표지 이미지 (한글 프롬프트 지원)
+        4. **시각적 옵션 설정**: AI 이미지, 다이어그램, FLUX 이미지 추가
+        5. **참고 자료 업로드**: PDF, CSV, TXT 파일 지원
+        6. **생성 버튼 클릭**: AI가 자동으로 PPT 생성
+        
+        ### 🎨 새로운 기능
+        - **FLUX AI 표지 이미지**: FLUX API를 통한 고품질 표지 이미지 (우측 배치)
+        - **AI 다이어그램**: 내용 분석 후 적절한 다이어그램 자동 생성
+        - **FLUX 슬라이드 이미지**: 주요 슬라이드에 AI 생성 이미지 추가
+        - **결론 슬라이드 강조**: 결론/요약 슬라이드에 특별한 FLUX 이미지 추가
+        - **좌-우 레이아웃**: 텍스트는 좌측, 시각적 요소는 우측 배치
         
         ### 💡 고급 팁
-        - CSV 파일 업로드 시 '차트 포함' 옵션으로 데이터 시각화 가능
-        - 웹 검색 활성화로 최신 정보 반영
-        - AI 이미지는 주제의 핵심 키워드를 분석하여 자동 생성
-        - 다양한 레이아웃으로 시각적 흥미 유발
+        - 표지의 제목/부제는 중앙 상단, AI 이미지는 우측에 배치됩니다
+        - 결론/요약 슬라이드는 자동으로 감지되어 특별한 이미지가 추가됩니다
+        - FLUX 이미지는 슬라이드 내용을 분석하여 관련 이미지를 생성합니다
         """
     )
     
     # Examples
     gr.Examples(
         examples=[
-            ["인공지능의 미래와 산업 적용 사례", 10, False, True, [], "professional", "modern", "consistent", False, False],
-            ["2024년 디지털 마케팅 트렌드", 12, True, True, [], "modern", "modern", "consistent", False, True],
-            ["기후변화와 지속가능한 발전", 15, True, True, [], "nature", "classic", "consistent", False, True],
-            ["스타트업 사업계획서", 8, False, True, [], "creative", "modern", "varied", False, True],
+            ["인공지능의 미래와 산업 적용 사례", 10, False, True, [], "professional", "modern", "consistent", False, True, True, False],
+            ["2024년 디지털 마케팅 트렌드", 12, True, True, [], "modern", "modern", "consistent", False, True, True, True],
+            ["기후변화와 지속가능한 발전", 15, True, True, [], "nature", "classic", "consistent", False, True, True, True],
+            ["스타트업 사업계획서", 8, False, True, [], "creative", "modern", "varied", False, True, True, True],
         ],
         inputs=[topic_input, num_slides, use_web_search, use_korean, reference_files, 
-                design_theme, font_style, layout_style, include_charts, include_ai_image],
+                design_theme, font_style, layout_style, include_charts, include_ai_image,
+                include_diagrams, include_flux_images],
     )
     
     # Event handler
@@ -2081,10 +2579,19 @@ with gr.Blocks(css=css, title="AI PPT Generator Pro") as demo:
             font_style,
             layout_style,
             include_charts,
-            include_ai_image
+            include_ai_image,
+            include_diagrams,
+            include_flux_images
         ],
         outputs=[download_file, status_text, content_preview]
     )
 
+# Initialize APIs on startup
 if __name__ == "__main__":
+    # Try to initialize APIs
+    if FLUX_API_URL:
+        initialize_flux_api()
+    if DIAGRAM_API_URL:
+        initialize_diagram_api()
+    
     demo.launch()