Update app.py

app.py

@@ -1,37 +1,1895 @@
-#백업 코드: openfree/Chart-GPT-BACKUP
+# app.py
+"""Main PPT Generator with 3-AI collaboration system"""
 
 import os
-import sys
-import streamlit as st
-from tempfile import NamedTemporaryFile
+import re
+import json
+import time
+import logging
+import gradio as gr
+import requests
+from typing import List, Dict, Generator
+from datetime import datetime
 
-def main():
-    try:
-        # Get the code from secrets
-        code = os.environ.get("MAIN_CODE")
+# Import separated modules
+from constants import (
+    EXAMPLE_TOPICS, AUDIENCE_TYPES, DESIGN_THEMES, 
+    STYLE_TEMPLATES, PPT_TEMPLATES, SLIDE_TITLE_TRANSLATIONS
+)
+from content_utils import (
+    parse_executor_response, extract_relevant_content_from_executor,
+    extract_slide_section_from_executor, parse_slide_section,
+    extract_speaker_notes_from_section, read_uploaded_file,
+    generate_dynamic_slides, brave_search, generate_slide_content,
+    generate_presentation_notes, generate_closing_notes,
+    generate_conclusion_phrase, generate_prompt_with_llm,
+    generate_image, create_slide_preview_html, create_pptx_file,
+    PROCESS_FLOW_AVAILABLE
+)
+from ui_components import (
+    create_custom_slides_ui, load_example, update_audience_info,
+    update_theme_preview, update_template_info, update_custom_slides_visibility,
+    clear_all, get_css, get_usage_instructions
+)
+
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Environment variables
+REPLICATE_API_TOKEN = os.getenv("RAPI_TOKEN")
+FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN")
+BRAVE_API_TOKEN = os.getenv("BAPI_TOKEN")
+API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
+BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search"
+MODEL_ID = "dep89a2fld32mcm"
+TEST_MODE = os.getenv("TEST_MODE", "false").lower() == "true"
+
+# Global variables
+current_slides_data = []
+current_topic = ""
+current_template = ""
+current_theme = ""
+uploaded_content = ""
+current_language = "English"
+conversation_history = []
+
+# ===== 핵심: 3자 협의 시스템 클래스 =====
+class PPTCreationSystem:
+    def __init__(self):
+        self.token = FRIENDLI_TOKEN
+        self.bapi_token = BRAVE_API_TOKEN
+        self.api_url = API_URL
+        self.brave_url = BRAVE_SEARCH_URL
+        self.model_id = MODEL_ID
+        self.test_mode = TEST_MODE or (self.token == "YOUR_FRIENDLI_TOKEN")
+        
+        if self.test_mode:
+            logger.warning("테스트 모드로 실행됩니다.")
+        if self.bapi_token == "YOUR_BRAVE_API_TOKEN":
+            logger.warning("Brave API 토큰이 설정되지 않았습니다.")
+        
+    def create_headers(self):
+        """API 헤더 생성"""
+        return {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json"
+        }
+    
+    def create_brave_headers(self):
+        """Brave API 헤더 생성"""
+        return {
+            "Accept": "application/json",
+            "Accept-Encoding": "gzip",
+            "X-Subscription-Token": self.bapi_token
+        }
+    
+    def create_supervisor_initial_prompt(self, ppt_topic: str) -> str:
+        """감독자 AI 초기 프롬프트 생성 - PPT 구조 설계"""
+        return f"""당신은 전문적인 PPT 구조를 설계하는 감독자 AI입니다.
+
+PPT 주제: {ppt_topic}
+
+이 주제에 대한 전문적인 PPT를 만들기 위해:
+
+1. **PPT 전체 구조 설계**
+   - 목적과 핵심 메시지 정의
+   - 타겟 청중 분석 및 톤 설정
+   - 전체 슬라이드 개수 및 흐름 설계 (10-15장 권장)
+
+2. **섹션별 구성 제안**
+   - 도입부 (표지, 목차, 배경)
+   - 본론 (핵심 내용 3-4개 섹션)
+   - 결론부 (요약, 시사점, Q&A)
+
+3. **조사가 필요한 핵심 키워드**
+   이 주제의 PPT를 위해 조사가 필요한 5-7개의 구체적인 키워드나 검색어를 제시하세요.
+
+키워드는 다음 형식으로 제시하세요:
+[검색 키워드]: 키워드1, 키워드2, 키워드3, 키워드4, 키워드5"""
+    
+    def create_researcher_prompt(self, ppt_topic: str, supervisor_guidance: str, search_results: Dict[str, List[Dict]]) -> str:
+        """조사자 AI 프롬프트 생성 - PPT 콘텐츠 조사"""
+        search_summary = ""
+        all_results = []
+        
+        for keyword, results in search_results.items():
+            search_summary += f"\n\n**{keyword}에 대한 검색 결과:**\n"
+            for i, result in enumerate(results[:10], 1):  # 상위 10개만 표시
+                search_summary += f"{i}. {result.get('title', 'N/A')} (신뢰도: {result.get('credibility_score', 0):.2f})\n"
+                search_summary += f"   - {result.get('description', 'N/A')}\n"
+                search_summary += f"   - 출처: {result.get('url', 'N/A')}\n"
+                if result.get('published'):
+                    search_summary += f"   - 게시일: {result.get('published')}\n"
+                
+                all_results.extend(results)
+        
+        # ��순 감지
+        contradictions = self.detect_contradictions(all_results)
+        contradiction_text = ""
+        if contradictions:
+            contradiction_text = "\n\n**발견된 정보 모순:**\n"
+            for cont in contradictions[:3]:  # 최대 3개만 표시
+                contradiction_text += f"- {cont['type']}: {cont['source1']} vs {cont['source2']}\n"
+        
+        return f"""당신은 PPT 콘텐츠를 위한 정보를 조사하고 정리하는 조사자 AI입니다.
+
+PPT 주제: {ppt_topic}
+
+감독자 AI의 구조 설계:
+{supervisor_guidance}
+
+브레이브 검색 결과 (신뢰도 점수 포함):
+{search_summary}
+{contradiction_text}
+
+위 검색 결과를 바탕으로 PPT에 포함할 핵심 콘텐츠를 정리하세요:
+
+1. **시각적 자료 가능한 통계/수치**
+   - 그래프나 차트로 표현 가능한 데이터
+   - 인포그래픽으로 변환 가능한 정보
+
+2. **핵심 인사이트와 트렌드**
+   - 청중의 관심을 끌 수 있는 최신 정보
+   - 업계 동향과 미래 전망
+
+3. **사례 연구 및 성공 스토리**
+   - 실제 적용 사례
+   - 벤치마크할 수 있는 모범 사례
+
+4. **전문가 의견 및 인용구**
+   - 권위 있는 출처의 의견
+   - PPT에 인용할 수 있는 명언
+
+5. **시각 자료 추천**
+   - 각 슬라이드에 적합한 이미지/아이콘 제안
+   - 도표나 다이어그램 아이디어"""
+    
+    def create_supervisor_execution_prompt(self, ppt_topic: str, research_summary: str) -> str:
+        """감독자 AI의 실행 지시 프롬프트 - PPT 제작 지시"""
+        return f"""당신은 PPT 제작을 총괄하는 감독자 AI입니다.
+
+PPT 주제: {ppt_topic}
+
+조사자 AI가 정리한 콘텐츠:
+{research_summary}
+
+위 조사 내용을 기반으로 실행자 AI에게 구체적인 PPT 제작 지시를 내려주세요:
+
+1. **슬라이드별 상세 구성**
+   - 각 슬라이드의 제목과 핵심 메시지
+   - 포함할 구체적인 콘텐츠 지정
+   - 시각 자료 배치 방안
+
+2. **디자인 가이드라인**
+   - 전체적인 톤과 스타일 (전문적/창의적/미니멀 등)
+   - 색상 팔레트 제안
+   - 폰트 및 레이아웃 원칙
+
+3. **스토리텔링 전략**
+   - 도입부에서 청중의 관심을 끄는 방법
+   - 핵심 메시지 전달 순서
+   - 결론부의 임팩트 있는 마무리
+
+4. **시각화 지침**
+   - 각 데이터의 최적 시각화 방법
+   - 복잡한 개념의 단순화 방안
+   - 애니메이션 효과 제안"""
+
+    def create_executor_prompt(self, ppt_topic: str, supervisor_guidance: str, research_summary: str) -> str:
+        """실행자 AI 프롬프트 생성 - PPT 슬라이드 작성"""
+        return f"""당신은 실제 PPT 슬라이드 내용을 작성하는 실행자 AI입니다.
+    
+    PPT 주제: {ppt_topic}
+    
+    조사자 AI가 정리한 콘텐츠:
+    {research_summary}
+    
+    감독자 AI의 제작 지시:
+    {supervisor_guidance}
+    
+    위 정보를 바탕으로 실제 PPT 슬라이드를 작성하세요:
+    
+    1. **각 슬라이드를 다음 형식으로 작성**:
+       [슬라이드 X]
+       제목: 
+       부제목: (선택사항)
+       • 🎯 첫 번째 핵심 포인트
+       • 💡 두 번째 핵심 포인트
+       • 🚀 세 번째 핵심 포인트
+       • ✅ 네 번째 핵심 포인트
+       • 📊 다섯 번째 핵심 포인트
+       발표자 노트: (실제 발표할 때 사용할 구어체 스크립트 - 최소 3-4문장)
+    
+    2. **작성 원칙**
+       - 한 슬라이드에 하나의 핵심 메시지
+       - 텍스트는 최소화, 시각적 요소 극대화
+       - 6x6 규칙 준수 (6줄 이하, 줄당 6단어 이하)
+       - 전문적이면서도 이해하기 쉬운 언어 사용
+       - 각 불릿 포인트는 반드시 이모지로 시작
+    
+    3. **발표자 노트 작성 지침**
+       - 슬라이드 내용을 자연스럽게 설명하는 구어체 사용
+       - 각 포인트를 풀어서 설명하고 연결
+       - 청중과 소통하는 느낌의 대화체 ("여러분", "우리가", "함께")
+       - 최소 3-4문장으로 풍부하게 작성
+       - 예시: "자, 이제 우리가 주목해야 할 핵심 포인트들을 살펴보겠습니다. 첫 번째로 시장 규모를 보시면..."
+    
+    4. **필수 포함 슬라이드**
+       - 표지 (제목, 부제목, 발표자/날짜)
+       - 목차
+       - 핵심 내용 슬라이드들
+       - 요약/결론
+       - Q&A/감사 슬라이드"""
+    
+    def create_supervisor_review_prompt(self, ppt_topic: str, executor_response: str, research_summary: str) -> str:
+        """감독자 AI의 검토 프롬프트 - PPT 검토 및 피드백"""
+        return f"""당신은 PPT 품질을 검토하고 개선점을 제시하는 감독자 AI입니다.
+
+PPT 주제: {ppt_topic}
+
+조사자 AI가 제공한 콘텐츠:
+{research_summary}
+
+실행자 AI의 PPT 초안:
+{executor_response}
+
+위 PPT 초안을 검토하고 다음 관점에서 구체적인 피드백을 제공하세요:
+
+1. **콘텐츠 품질**
+   - 조사 내용이 충분히 반영되었는지
+   - 각 슬라이드의 메시지가 명확한지
+   - 논리적 흐름이 자연스러운지
+
+2. **시각적 효과**
+   - 텍스트와 시각 요소의 균형
+   - 슬라이드별 일관성
+   - 청중의 이해를 돕는 구성인지
+
+3. **발표 준비도**
+   - 발표자 노트의 충실성
+   - 예상 질문에 대한 대비
+   - 시간 배분의 적절성
+
+4. **개선 필요사항**
+   - 구체적인 수정 지시사항
+   - 추가해야 할 내용
+   - 삭제하거나 간소화할 부분
+
+5. **최종 점검사항**
+   - 오타나 문법 오류
+   - 데이터의 정확성
+   - 전문성과 신뢰성"""
+
+    def create_executor_final_prompt(self, ppt_topic: str, initial_response: str, supervisor_feedback: str, research_summary: str) -> str:
+        """실행자 AI 최종 PPT 프롬프트"""
+        return f"""당신은 최종 PPT를 완성하는 실행자 AI입니다.
+
+PPT 주제: {ppt_topic}
+
+조사자 AI의 콘텐츠:
+{research_summary}
+
+당신의 초기 PPT 초안:
+{initial_response}
+
+감독자 AI의 피드백:
+{supervisor_feedback}
+
+위 피드백을 완전히 반영하여 최종 PPT를 작성하세요:
+
+1. **개선사항 반영**
+   - 감독자의 모든 피드백 적용
+   - 스토리라인 강화
+   - 시각적 일관성 확보
+
+2. **발표자 노트 강화**
+   - 각 슬라이드마다 풍부한 구어체 발표 스크립트 작성
+   - 최소 4-5문장으로 자세하게
+   - 실제 발표 상황을 가정한 자연스러운 대화체
+   - 예시: "자, 이제 시장 현황을 살펴보겠습니다. 여러분도 아시다시피 최근 디지털 전환이 가속화되면서..."
+
+3. **최종 품질 체크**
+   - 전문성과 완성도 향상
+   - 오타 및 문법 검토
+   - 논리적 흐름 재확인
+
+4. **프레젠테이션 준비**
+   - 각 슬라이드별 발표 스크립트 추가
+   - 예상 질문과 답변 준비
+   - 시간 배분 제안 (20분 발표 기준)
+
+5. **추가 자료**
+   - 백업 슬라이드 제안
+   - 참고 자료 목록
+   - 인쇄용 핸드아웃 버전 제안"""
+    
+    def extract_keywords(self, supervisor_response: str) -> List[str]:
+        """감독자 응답에서 키워드 추출"""
+        keywords = []
+        
+        # [검색 키워드]: 형식으로 키워드 찾기
+        keyword_match = re.search(r'\[검색 키워드\]:\s*(.+)', supervisor_response, re.IGNORECASE)
+        if keyword_match:
+            keyword_str = keyword_match.group(1)
+            keywords = [k.strip() for k in keyword_str.split(',') if k.strip()]
+        
+        # 키워드가 없으면 기본 키워드 생성
+        if not keywords:
+            keywords = ["industry trends", "market analysis", "case studies", "best practices", "future outlook"]
+        
+        return keywords[:7]  # 최대 7개로 제한
+    
+    def generate_synonyms(self, keyword: str) -> List[str]:
+        """키워드의 동의어/유사어 생성"""
+        synonyms = {
+            "trend": ["tendency", "direction", "movement", "pattern"],
+            "analysis": ["evaluation", "assessment", "study", "research"],
+            "strategy": ["approach", "plan", "tactics", "methodology"],
+            "market": ["industry", "sector", "business", "commerce"],
+            "innovation": ["breakthrough", "advancement", "revolution", "disruption"],
+            "growth": ["expansion", "development", "progress", "advancement"],
+            "presentation": ["pitch", "proposal", "demonstration", "showcase"],
+            "data": ["statistics", "metrics", "analytics", "insights"],
+            "technology": ["tech", "digital", "IT", "innovation"],
+            "business": ["enterprise", "corporate", "commercial", "company"]
+        }
+        
+        # 키워드 정규화
+        keyword_lower = keyword.lower()
+        
+        # 직접 매칭되는 동의어가 있으면 반환
+        if keyword_lower in synonyms:
+            return synonyms[keyword_lower][:2]  # 최대 2개
+        
+        # 부분 매칭 확인
+        for key, values in synonyms.items():
+            if key in keyword_lower or keyword_lower in key:
+                return values[:2]
+        
+        # 동의어가 없으면 빈 리스트
+        return []
+    
+    def calculate_credibility_score(self, result: Dict) -> float:
+        """검색 결과의 신뢰도 점수 계산 (0-1)"""
+        score = 0.5  # 기본 점수
+        
+        url = result.get('url', '')
+        title = result.get('title', '')
+        description = result.get('description', '')
+        
+        # URL 기반 점수
+        trusted_domains = [
+            '.edu', '.gov', '.org', 'wikipedia.org', 'harvard.edu', 
+            'mckinsey.com', 'deloitte.com', 'pwc.com', 'gartner.com',
+            'forrester.com', 'statista.com', 'bloomberg.com', 'reuters.com'
+        ]
         
-        if not code:
-            st.error("⚠️ The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+        for domain in trusted_domains:
+            if domain in url:
+                score += 0.2
+                break
+        
+        # HTTPS 사용 여부
+        if url.startswith('https://'):
+            score += 0.1
+        
+        # 제목과 설명의 길이 (너무 짧으면 신뢰도 감소)
+        if len(title) > 20:
+            score += 0.05
+        if len(description) > 50:
+            score += 0.05
+        
+        # 광고/스팸 키워드 체크
+        spam_keywords = ['buy now', 'sale', 'discount', 'click here', '100% free']
+        if any(spam in (title + description).lower() for spam in spam_keywords):
+            score -= 0.3
+        
+        # 날짜 정보가 있으면 가산점
+        if any(year in description for year in ['2024', '2023', '2022']):
+            score += 0.1
+        
+        return max(0, min(1, score))  # 0-1 범위로 제한
+    
+    def detect_contradictions(self, results: List[Dict]) -> List[Dict]:
+        """검색 결과 간 모순 감지"""
+        contradictions = []
+        
+        # 간단한 모순 감지 패턴
+        opposite_pairs = [
+            ("increase", "decrease"),
+            ("improve", "worsen"),
+            ("effective", "ineffective"),
+            ("success", "failure"),
+            ("benefit", "harm"),
+            ("positive", "negative"),
+            ("growth", "decline")
+        ]
+        
+        # 결과들을 비교
+        for i in range(len(results)):
+            for j in range(i + 1, len(results)):
+                desc1 = results[i].get('description', '').lower()
+                desc2 = results[j].get('description', '').lower()
+                
+                # 반대 개념이 포함되어 있는지 확인
+                for word1, word2 in opposite_pairs:
+                    if (word1 in desc1 and word2 in desc2) or (word2 in desc1 and word1 in desc2):
+                        # 같은 주제에 대해 반대 의견인지 확인
+                        common_words = set(desc1.split()) & set(desc2.split())
+                        if len(common_words) > 5:  # 공통 단어가 5개 이상이면 같은 주제로 간주
+                            contradictions.append({
+                                'source1': results[i]['url'],
+                                'source2': results[j]['url'],
+                                'type': f"{word1} vs {word2}",
+                                'desc1': results[i]['description'][:100],
+                                'desc2': results[j]['description'][:100]
+                            })
+        
+        return contradictions
+    
+    def brave_search(self, query: str) -> List[Dict]:
+        """Brave Search API 호출"""
+        if self.test_mode or self.bapi_token == "YOUR_BRAVE_API_TOKEN":
+            # 테스트 모드에서는 시뮬레이션된 결과 반환
+            test_results = []
+            for i in range(5):
+                test_results.append({
+                    "title": f"{query} - Industry Report {i+1}",
+                    "description": f"Comprehensive analysis of {query} including market trends, key statistics, and future projections for strategic planning.",
+                    "url": f"https://report{i+1}.com/{query.replace(' ', '-')}",
+                    "credibility_score": 0.7 + (i * 0.05)
+                })
+            return test_results
+        
+        try:
+            params = {
+                "q": query,
+                "count": 20,  # 20개로 증가
+                "safesearch": "moderate",
+                "freshness": "pw"  # Past week for recent results
+            }
+            
+            response = requests.get(
+                self.brave_url,
+                headers=self.create_brave_headers(),
+                params=params,
+                timeout=10
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                results = []
+                for item in data.get("web", {}).get("results", [])[:20]:
+                    result = {
+                        "title": item.get("title", ""),
+                        "description": item.get("description", ""),
+                        "url": item.get("url", ""),
+                        "published": item.get("published", "")
+                    }
+                    # 신뢰도 점수 계산
+                    result["credibility_score"] = self.calculate_credibility_score(result)
+                    results.append(result)
+                
+                # 신뢰도 점수 기준으로 정렬
+                results.sort(key=lambda x: x['credibility_score'], reverse=True)
+                return results
+            else:
+                logger.error(f"Brave API 오류: {response.status_code}")
+                return []
+                
+        except Exception as e:
+            logger.error(f"Brave 검색 중 오류: {str(e)}")
+            return []
+    
+    def simulate_streaming(self, text: str, role: str) -> Generator[str, None, None]:
+        """테스트 모드에서 스트리밍 시뮬레이션"""
+        words = text.split()
+        for i in range(0, len(words), 3):
+            chunk = " ".join(words[i:i+3])
+            yield chunk + " "
+            time.sleep(0.05)
+    
+    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str) -> Generator[str, None, None]:
+        """스트리밍 LLM API 호출"""
+        
+        # 테스트 모드
+        if self.test_mode:
+            logger.info(f"테스트 모드 스트리밍 - Role: {role}")
+            test_responses = {
+                "supervisor_initial": """전문적인 PPT 구조를 설계하겠습니다.
+
+## 1. PPT 전체 구조 설계
+
+**목적**: 디지털 트랜스포메이션의 핵심 요소와 성공 전략을 명확하게 전달
+**타겟 청중**: 경영진 및 의사결정자
+**톤**: 전문적이고 설득력 있는 비즈니스 스타일
+**전체 슬라이드**: 12장
+
+## 2. 섹션별 구성
+
+### 도입부 (3장)
+- 슬라이드 1: 표지 - 임팩트 있는 제목과 비주얼
+- 슬라이드 2: 목차 - 전체 흐름 제시
+- 슬라이드 3: 디지털 트랜스포메이션의 필요성
+
+### 본론 (7장)
+**섹션 1: 현황 분석 (2장)**
+- 슬라이드 4: 산업별 디지털화 현황
+- 슬라이드 5: 주요 도전과제
+
+**섹션 2: 핵심 전략 (3장)**
+- 슬라이드 6: 디지털 트랜스포메이션 프레임워크
+- 슬라이드 7: 기술 스택 및 인프라
+- 슬라이드 8: 변화 관리 전략
+
+**섹션 3: 성공 사례 (2장)**
+- 슬라이드 9: 글로벌 성공 사례
+- 슬라이드 10: ROI 및 성과 지표
+
+### 결론부 (2장)
+- 슬라이드 11: 핵심 시사점 및 권고사항
+- 슬라이드 12: Q&A
+
+## 3. 비주얼 전략
+- 색상: 기업 블루(#003366) + 악센트 오렌지(#FF6B35)
+- 아이콘: 모던하고 플랫한 디자인
+- 차트: 데이터 시각화 중심
+
+[검색 키워드]: digital transformation trends 2024, DX success cases, digital transformation ROI, change management digital, industry 4.0 statistics""",
+                
+                "researcher": """PPT 콘텐츠를 위한 핵심 정보를 정리했습니다.
+
+## 1. 시각적 자료 가능한 통계/수치 (신뢰도 높음)
+
+**디지털 트랜스포메이션 투자 현황**
+- 2024년 글로벌 DX 투자 규모: $3.4조 (신뢰도: 0.92)
+- 연평균 성장률(CAGR): 16.5% (2023-2027)
+- 출처: IDC Digital Transformation Spending Guide
+
+**산업별 디지털화 수준**
+- 금융: 78% 디지털화 완료 (신뢰도: 0.88)
+- 제조: 52% 진행 중 (신뢰도: 0.85)
+- 헬스케어: 61% 가속화 단계
+- 출처: McKinsey Global Institute
+
+## 2. 핵심 인사이트와 트렌드 (신뢰도 높음)
+
+**2024년 주요 트렌드**
+1. AI/ML 통합: 87%의 기업이 AI를 DX 핵심 요소로 채택 (신뢰도: 0.90)
+2. 클라우드 우선: 94%가 하이브리드 클라우드 전략 추진
+3. 데이터 중심: 실시간 분석이 경쟁력의 핵심
+- 출처: Gartner Technology Trends 2024
+
+## 3. 사례 연구 및 성공 스토리 (신뢰도 높음)
+
+**Amazon 사례**
+- 물류 자동화로 배송 시간 40% 단축 (신뢰도: 0.87)
+- AI 기반 추천으로 매출 35% 증가
+- 출처: Amazon Annual Report 2023
+
+**Starbucks 디지털 혁신**
+- 모바일 주문 비중: 전체 매출의 26% (신뢰도: 0.85)
+- 개인화 마케팅으로 고객 충성도 23% 향상
+- 출처: Starbucks Investor Relations
+
+## 4. 전문가 의견 및 인용구
+
+> "디지털 트랜스포메이션은 기술이 아닌 사람과 문화의 변화다"
+- Satya Nadella, Microsoft CEO
+
+> "2025년까지 디지털 리더와 후발주자의 격차는 2배 이상 벌어질 것"
+- Michael Porter, Harvard Business School
+
+## 5. 시각 자료 추천
+
+**슬라이드별 비주얼 제안**
+- 표지: 네트워크 연결 이미지 + 동적인 데이터 흐름
+- 통계: 인터랙티브한 대시보드 스타일 차트
+- 프레임워크: 계층적 다이어그램 + 아이콘
+- 사례: 기업 로고 + 핵심 지표 인포그래픽
+- 타임라인: 로드맵 형태의 단계별 진행도
+
+**아이콘 세트**
+- 기술: 클라우드, AI, 데이터, 보안
+- 비즈니스: 성장, 혁신, 협업, 효율성
+- 사람: 리더십, 팀워크, 스킬, 문화""",
+                
+                "supervisor_execution": """조사 내용을 바탕으로 PPT 제작을 위한 구체적인 지시사항입니다.
+
+## 1. 슬라이드별 상세 구성
+
+**슬라이드 1: 표지**
+- 제목: "디지털 트랜스포메이션: 미래를 향한 도약"
+- 부제목: "성공적인 DX 전략과 실행 방안"
+- 비주얼: 연결된 디지털 네트워크 배경
+- 조사 자료 활용: $3.4조 시장 규모 강조
+
+**슬라이드 4: 산업별 현황**
+- 조사된 통계 활용: 금융(78%), 제조(52%), 헬스케어(61%)
+- 원형 차트 + 진행 바 조합
+- 각 산업별 대표 아이콘 배치
+
+**슬라이드 7: 기술 스택**
+- AI/ML(87% 채택률) 중심으로 구성
+- 클라우��(94%) 하이브리드 전략 시각화
+- 계층적 다이어그램 사용
+
+**슬라이드 9: 성공 사례**
+- Amazon과 Starbucks 사례 대비
+- 핵심 성과 지표 인포그래픽
+- Before/After 비교 형식
+
+## 2. 디자인 가이드라인
+
+**색상 팔레트**
+- 주색상: 네이비 블루 (#1E3A8A)
+- 보조색상: 스카이 블루 (#3B82F6)
+- 강조색상: 오렌지 (#F59E0B)
+- 배경: 화이트/라이트 그레이
+
+**타이포그래피**
+- 제목: Montserrat Bold (32-40pt)
+- 본문: Open Sans Regular (18-24pt)
+- 강조: Open Sans Semi-Bold
+
+**레이아웃 원칙**
+- 여백 충분히 활용 (40% 이상)
+- 좌우 대칭 또는 황금비율
+- 한 슬라이드 한 메시지 원칙
+
+## 3. 스토리텔링 전략
+
+**도입부 전략**
+- 충격적인 통계로 시작 ($3.4조 시장)
+- "왜 지금인가?" 질문 제기
+- 청중의 pain point 공감
+
+**전개 방식**
+- 문제 → 해결책 → 증거 → 행동
+- 각 섹션 간 자연스러운 전환
+- 사례를 통한 구체화
+
+**클라이맥스**
+- ROI 데이터로 설득력 극대화
+- 성공 기업과의 격차 시각화
+- 행동 촉구 메시지
+
+## 4. 시각화 지침
+
+**데이터 시각화**
+- 산업별 현황: 방사형 차트
+- 성장률: 상승 곡선 그래프
+- ROI: 계산기 스타일 인포그래픽
+- 프로세스: 순환형 다이어그램
+
+**애니메이션 효과**
+- 슬라이드 전환: Morph 효과
+- 차트 등장: 순차적 빌드업
+- 강조 포인트: 줌인/하이라이트
+- 과도한 효과 지양""",
+                
+                "executor": """PPT 슬라이드를 작성합니다.
+
+[슬라이드 1] 표지
+제목: 디지털 트랜스포메이션: 미래를 향한 도약
+부제목: 성공적인 DX 전략과 실행 방안
+핵심 내용: 
+- 발표자: [이름]
+- 날짜: 2024년 3월
+- 기업명/로고
+발표자 노트: 청중의 주목을 끌 수 있도록 자신감 있게 시작. $3.4조 규모의 거대한 변화의 물결임을 강조
+시각 자료: 디지털 네트워크가 연결된 지구본 이미지, 동적인 데이터 흐름 효과
+
+[슬라이드 2] 목차
+제목: Agenda
+핵심 내용:
+- 디지털 트랜스포메이션의 현재
+- 산업별 디지털화 현황과 과제
+- 성공을 위한 핵심 전략
+- 글로벌 성공 사례와 교훈
+- 결론 및 다음 단계
+발표자 노트: 전체 20분 발표 중 각 섹션별 시간 배분 설명
+시각 자료: 번호가 매겨진 아이콘과 진행 표시 바
+
+[슬라이드 3] 도입
+제목: 왜 지금 디지털 트랜스포메이션인가?
+핵심 내용:
+- 2024년 글로벌 DX 투자: $3.4조
+- 디지털 리더 기업의 수익성: 평균 대비 2.5배
+- 팬데믹 이후 디지털 채택 가속화: 10년→2년
+- "변화하거나 도태되거나" - 생존의 문제
+발표자 노트: 시장 규모와 긴급성을 강조하여 청중의 관심 유도
+시각 자료: 급상승하는 그래프와 시계 아이콘으로 시급함 표현
+
+[슬라이드 4] 산업별 현황
+제목: 산업별 디지털 트랜스포메이션 현황
+핵심 내용:
+- 금융: 78% (선도 그룹)
+- 헬스케어: 61% (빠른 추격)
+- 제조: 52% (꾸준한 진행)
+- 소매: 45% (가속화 필요)
+발표자 노트: 각 산업의 특성과 도전과제 간단히 언급
+시각 자료: 도넛 차트와 산업별 아이콘, 진행률 바
+
+[슬라이드 5] 주요 도전과제
+제목: 디지털 트랜스포메이션의 5대 장벽
+핵심 내용:
+- 레거시 시스템의 복잡성 (67%)
+- 변화 저항과 문화적 관성 (54%)
+- 디지털 인재 부족 (48%)
+- 불명확한 ROI (41%)
+- 사이버 보안 우려 (38%)
+발표자 노트: 각 장벽에 대한 극복 방안 미리 준비
+시각 자료: 장벽을 나타내는 벽돌 아이콘과 백분율 표시
+
+[슬라이드 6] DX 프레임워크
+제목: 디지털 트랜스포메이션 성공 프레임워크
+핵심 내용:
+- 전략: 비즈니스 목표 정렬
+- 기술: AI/클라우드/데이터
+- 프로세스: 애자일 방법론
+- 문화: 혁신과 실험 장려
+- 거버넌스: 지속적 개선
+발표자 노트: 각 요소가 상호 연결되어 있음을 강조
+시각 자료: 5각형 다이어그램, 각 꼭지점에 아이콘 배치
+
+[슬라이드 7] 기술 스택
+제목: 2024 핵심 기술 스택
+핵심 내용:
+- AI/ML 채택률: 87%
+- 클라우드 전략: 94% 하이브리드
+- 데이터 분석: 실시간 처리
+- 보안: Zero Trust 아키텍처
+- 통합: API 우선 접근
+발표자 노트: 각 기술의 비즈니스 가치 연결
+시각 자료: 계층적 기술 스택 다이어그램
+
+[슬라이드 8] 변화 관리
+제목: 사람 중심의 변화 관리
+핵심 내용:
+- 리더십의 명확한 비전 공유
+- 단계별 교육 프로그램
+- 빠른 성과로 모멘텀 구축  
+- 지속적 커뮤니케이션
+- 보상 체계 연계
+발표자 노트: Satya Nadella 인용구 활용
+시각 자료: 변화 곡선과 사람 아이콘
+
+[슬라이드 9] 성공 사례
+제목: 글로벌 DX 성공 스토리
+핵심 내용:
+- Amazon: 물류 자동화 → 배송 40% 단축
+- Starbucks: 모바일 주문 → 매출 26%
+- Netflix: AI 추천 → 시청 시간 80% 증가
+- Tesla: OTA 업데이트 → 서비스 비용 70% 절감
+발표자 노트: 각 사례의 핵심 성공 요인 강조
+시각 자료: 기업 로고와 핵심 지표 인포그래픽
+
+[슬라이드 10] ROI 분석
+제목: 디지털 트랜스포메이션의 명확한 ROI
+핵심 내용:
+- 운영 효율성: 30-40% 개선
+- 고객 만족도: NPS 25% 상승
+- 신규 수익원: 전체 매출의 15%
+- 투자 회수 기간: 평균 2.5년
+발표자 노트: 구체적인 수치로 투자 정당성 입증
+시각 자료: ROI 계산기 스타일의 인포그래픽
+
+[슬라이드 11] 핵심 시사점
+제목: 성공적인 DX를 위한 5가지 제언
+핵심 내용:
+- 작게 시작하되 크게 생각하라
+- 기술보다 문화 변화에 투자하라
+- 데이터 기반 의사결정을 일상화하라
+- 실패를 두려워하지 말고 빠르게 배워라
+- 고객 중심으로 모든 것을 재설계하라
+발표자 노트: 각 제언에 대한 실천 방안 준비
+시각 자료: 체크리스트 스타일의 아이콘
+
+[슬라이드 12] Q&A
+제목: Questions & Discussion
+핵심 내용:
+- 감사합니다
+- 질문과 토론 환영
+- 연락처: [이메일/전화]
+- 추가 자료: [웹사이트/QR코드]
+발표자 노트: 예상 질문 3-5개 미리 준비
+시각 자료: 물음표 아이콘과 연락처 정보""",
+                
+                "supervisor_review": """실행자 AI의 PPT 초안을 검토했습니다. 전반적으로 잘 구성되었으나 다음 개선사항을 제안합니다.
+
+## 강점
+- 조사된 통계와 수치가 효과적으로 활용됨
+- 스토리라인이 논리적이고 설득력 있음
+- 각 슬라이드의 핵심 메시지가 명확함
+- 시각 자료 제안이 구체적임
+
+## 개선 필요사항
+
+### 1. 임팩트 강화
+**슬라이드 3 개선**
+- 현재: 통계 나열
+- 개선: "귀사는 디지털 리더입니까, 후발주자입니까?"라는 도발적 질문 추가
+- 청중 참여를 위한 인터랙티브 요소 고려
+
+**슬라이드 5 개선**  
+- 현재: 장벽만 제시
+- 개선: 각 장벽별 "Quick Win" 솔루션 한 줄 추가
+- 희망적 메시지로 균형 맞추기
+
+### 2. 스토리텔링 강화
+**전환 문구 추가**
+- 슬라이드 간 연결 문구 필요
+- 예: "이제 이러한 현황을 어떻게 개선할 수 있을까요?"
+
+**감정적 연결**
+- 숫자와 통계 외에 인간적 스토리 추가
+- 변화를 겪은 직원/고객의 실제 경험담
+
+### 3. 비주얼 일관성
+**색상 사용 정제**
+- 강조색(오렌지) 과도 사용 자제
+- 각 섹션별 색상 톤 구분
+- 데이터 시각화 색상 팔레트 통일
+
+**아이콘 스타일**
+- 모든 아이콘 동일 스타일로 통일
+- 라인 두께, 모서리 처리 일관성
+
+### 4. 발표 준비 강화
+**시간 배분 명시**
+- 각 슬라이드별 예상 소요 시간 추가
+- 전체 20분 기준 상세 배분
+
+**전환 스크립트**
+- 슬라이드 간 자연스러운 전환 멘트 준비
+- 청중 반응 체크 포인트 설정
+
+### 5. 추가 권장사항
+**백업 슬라이드 준비**
+- 상세 기술 스펙
+- 추가 사례 연구
+- 업종별 맞춤 전략
+- 상세 ROI 계산 방법
+
+**인쇄 자료**
+- 3슬라이드/페이지 형식
+- 메모 공간 포함
+- 핵심 수치 요약 페이지
+
+이러한 개선사항을 반영하면 더욱 완성도 높고 설득력 있는 PPT가 될 것입니다.""",
+                
+                "executor_final": """감독자 AI의 피드백을 완전히 반영한 최종 PPT를 작성합니다.
+
+# 🎯 디지털 트랜스포메이션: 미래를 향한 도약
+## 최종 완성 PPT (발표 시간: 20분)
+
+---
+
+[슬라이드 1] 표지 (30초)
+**제목**: 디지털 트랜스포메이션: 미래를 향한 도약
+**부제목**: 성공적인 DX 전략과 실행 방안
+**비주얼**: 
+- 배경: 연결된 디지털 네트워크와 데이터 흐름
+- 중앙: 회사 로고
+- 하단: 발표자 정보 및 날짜
+**발표자 노트**: 
+"안녕하십니까. 오늘 여러분과 함께 $3.4조 규모의 디지털 혁명, 그 중심에서 우리가 어떻게 성공할 수 있을지 논의하고자 합니다."
+
+---
+
+[슬라이드 2] 목차 (30초)
+**제목**: 오늘의 여정
+**핵심 내용**:
+1. 📊 디지털 트랜스포메이션의 현재 (3분)
+2. 🏭 산업별 현황과 도전과제 (3분)
+3. 🎯 성공 전략과 프레임워크 (5분)
+4. 🌟 글로벌 성공 사례 (4분)
+5. 💡 핵심 시사점과 실행 방안 (4분)
+6. 🤝 Q&A (1분)
+**발표자 노트**: 
+"20분간의 여정을 통해 디지털 트랜스포메이션의 현재와 미래, 그리고 실행 방안을 함께 탐색하겠습니다."
+**시각 자료**: 진행 단계를 보여주는 로드맵 스타일 디자인
+
+---
+
+[슬라이드 3] 도전적 질문 (1분 30초)
+**제목**: 귀사는 디지털 리더입니까, 후발주자입니까?
+**핵심 내용**:
+- 🌍 2024년 글로벌 DX 시장: **$3.4조**
+- 📈 디지털 리더의 수익성: 평균 대비 **2.5배**
+- ⏰ 변화의 속도: 10년 → **2년** (팬데믹 가속화)
+- ⚡ 핵심 질문: "우리는 변화를 주도하고 있는가?"
+**발표자 노트**: 
+"잠시 생각해보십시오. 귀사는 이 거대한 변화의 물결을 타고 있습니까, 아니면 뒤처져 있습니까?"
+**시각 자료**: 
+- 상단: 도발적 질문 크게 표시
+- 중앙: 리더 vs 후발주자 대비 인포그래픽
+- 전환: 청중 참여를 위한 3초 pause
+
+---
+
+[슬라이드 4] 산업별 디지털화 현황 (1분 30초)
+**제목**: 당신의 산업은 어디에 위치합니까?
+**핵심 내용**:
+- 🏦 금융: 78% - "디지털이 새로운 표준"
+- 🏥 헬스케어: 61% - "원격의료가 일상으로"
+- 🏭 제조: 52% - "스마트 팩토리로 진화"
+- 🛍️ 소매: 45% - "옴니채널이 생존 조건"
+**발표자 노트**: 
+"금융업은 이미 78%가 디지털화되었습니다. 귀사의 산업은 어떻습니까? 이제 각 산업의 성공 비결을 살펴보겠습니다."
+**시각 자료**: 
+- 레이스 트랙 형태의 진행도 표시
+- 각 산업별 대표 아이콘과 진행률
+- 업종별 대표 기업 로고 작게 표시
+
+---
+
+[슬라이드 5] 5대 장벽과 해결책 (2분)
+**제목**: 장벽을 기회로: 5대 도전과제와 Quick Win
+**핵심 내용**:
+- 🔧 레거시 시스템 (67%) → "단계적 현대화 전략"
+- 🚫 변화 저항 (54%) → "작은 성공 스토리 확산"
+- 👥 인재 부족 (48%) → "업스킬링 + 외부 파트너십"
+- 💰 불명확한 ROI (41%) → "파일럿 프로젝트로 증명"
+- 🔒 보안 우려 (38%) → "Security by Design 원칙"
+**발표자 노트**: 
+"모든 장벽에는 해결책이 있습니다. 중요한 것은 어디서부터 시작할 것인가입니다."
+**전환 멘트**: "그렇다면 이러한 장벽을 넘어 성공하기 위한 검증된 프레임워크를 소개하겠습니다."
+**시각 자료**: 
+- 장벽→해결책 화살표 애니메이션
+- 각 항목별 순차적 등장 효과
+
+---
+
+[슬라이드 6] DX 성공 프레임워크 (2분)
+**제목**: 검증된 디지털 트랜스포메이션 프레임워크
+**핵심 내용**:
+🎯 **전략**: 비즈니스 목표와 100% 정렬
+🔧 **기술**: AI(87%) + 클라우드(94%) + 데이터
+👥 **문화**: 혁신 DNA 주입
+⚙️ **프로세스**: 애자일 + DevOps
+📊 **거버넌스**: 측정 가능한 KPI
+**발표자 노트**: 
+"이 5가지 요소는 톱니바퀴처럼 맞물려 있습니다. 하나라도 빠지면 전체가 작동하지 않습니다."
+**시각 자료**: 
+- 중앙: 5각형 다이어그램
+- 각 요소 간 연결선으로 상호의존성 표현
+- 호버 효과로 각 요소 상세 설명
+
+---
+
+[슬라이드 7] 2024 기술 스택 (1분 30초)
+**제목**: 미래를 만드는 기술 스택
+**핵심 내용**:
+**Layer 1 - 인프라**
+- ☁️ 하이브리드 클라우드 (94% 채택)
+**Layer 2 - 데이터**
+- 📊 실시간 분석 플랫폼
+**Layer 3 - 인텔리전스**
+- 🤖 AI/ML (87% 통합)
+**Layer 4 - 경험**
+- 📱 옴니채널 인터페이스
+**Layer 5 - 보안**
+- 🔐 Zero Trust 아키텍처
+**발표자 노트**: 
+"각 레이어는 그 위의 레이어를 지원합니다. 탄탄한 기초 없이는 혁신도 없습니다."
+**시각 자료**: 
+- 피라미드 형태의 기술 스택
+- 각 레이어별 대표 기술 로고
+
+---
+
+[슬라이드 8] 인간 중심 변화 관리 (1분 30초)
+**제목**: 기술이 아닌 사람이 만드는 변화
+**핵심 내용**:
+> "디지털 트랜스포메이션은 기술이 아닌 사람과 문화의 변화다"
+> - Satya Nadella, Microsoft CEO
+
+- 🎯 **비전**: 명확하고 고무적인 미래상
+- 📚 **교육**: 지속적 학습 문화
+- 🏆 **성과**: 작은 승리의 축적
+- 💬 **소통**: 양방향 피드백 루프
+- 🎁 **보상**: 혁신에 대한 인센티브
+**발표자 노트**: 
+"가장 앞선 기술도 사람이 받아들이지 않으면 무용지물입니다."
+**전환 멘트**: "이제 이러한 원칙들이 실제로 어떤 성과를 만들어냈는지 보시겠습니다."
+**시각 자료**: 사람 중심의 원형 다이어그램
+
+---
+
+[슬라이드 9] 글로벌 성공 스토리 (2분)
+**제목**: 숫자로 증명된 DX 성공 사례
+**핵심 내용**:
+📦 **Amazon**: 물류 자동화 → 배송 시간 **40% 단축**
+☕ **Starbucks**: 모바일 주문 → 매출의 **26% 차지**
+🎬 **Netflix**: AI 추천 → 시청 시간 **80% 증가**
+🚗 **Tesla**: OTA 업데이트 → 서비스 비용 **70% 절감**
+
+**공통 성공 요인**:
+- 고객 경험 최우선
+- 데이터 기반 의사결정
+- 지속적 혁신 문화
+**발표자 노트**: 
+"이들의 공통점은 무엇일까요? 기술을 목적이 아닌 수단으로 활용했다는 점입니다."
+**시각 자료**: 
+- 각 기업별 Before/After 대비
+- 핵심 지표 크게 강조
+
+---
+
+[슬라이드 10] ROI의 진실 (2분)
+**제목**: 투자 대비 수익, 숨겨진 가치까지
+**정량적 효과**:
+- 💰 운영 효율성: **30-40% 개선**
+- 😊 고객 만족도: NPS **25포인트 상승**
+- 🚀 신규 수익: 전체 매출의 **15% 창출**
+- ⏱️ 투자 회수: 평균 **2.5년**
+
+**정성적 효과**:
+- 직원 만족도 향상
+- 브랜드 이미지 제고
+- 미래 대응력 확보
+**발표자 노트**: 
+"ROI는 단순히 숫자로만 측정되지 않습니다. 조직의 미래 경쟁력이 진정한 가치입니다."
+**시각 자료**: 
+- ROI 계산기 인터페이스
+- 정량/정성 효과 균형 표시
+
+---
+
+[슬라이드 11] 실행을 위한 5가지 제언 (2분)
+**제목**: 내일부터 시작할 수 있는 5가지 행동
+**핵심 제언**:
+1. 🌱 **Start Small, Think Big**
+   - "파일럿 프로젝트로 시작하되 전사 확산 계획 수립"
+2. 👥 **Culture First, Technology Second**
+   - "최고의 기술도 문화가 뒷받침되지 않으면 실패"
+3. 📊 **Data-Driven Everything**
+   - "추측이 아닌 데이터로 의사결정"
+4. 🔄 **Fail Fast, Learn Faster**
+   - "실패를 두려워하지 말고 빠르게 피벗"
+5. 🎯 **Customer at the Center**
+   - "모든 변화의 중심에 고객 가치"
+**발표자 노트**: 
+"이 중 단 하나만이라도 내일부터 실천한다면, 1년 후 조직은 완전히 달라져 있을 것입니다."
+**시각 자료**: 체크박스 스타일, 하나씩 체크되는 애니메이션
+
+---
+
+[슬라이드 12] 마무리 및 Q&A (1분)
+**제목**: 함께 만드는 디지털 미래
+**핵심 내용**:
+🙏 **감사합니다**
+
+💭 **생각해볼 질문들**:
+- 우리 조직의 디지털 성숙도는?
+- 가장 먼저 해결해야 할 과제는?
+- 첫 번째 파일럿 프로젝트는?
+
+📧 연락처: [이메일]
+📱 LinkedIn: [프로필]
+🔗 추가 자료: [QR 코드]
+**발표자 노트**: 
+"디지털 트랜스포메이션은 목적지가 아닌 여정입니다. 그 여정을 함께하게 되어 영광입니다."
+**시각 자료**: QR 코드와 연락처 정보
+
+---
+
+## 📎 백업 슬라이드 (필요시 활용)
+
+[백업 1] 산업별 상세 전략
+[백업 2] 기술 스택 상세 스펙
+[백업 3] 추가 성공 사례 (국내 기업)
+[백업 4] ROI 계산 방법론
+[백업 5] 단계별 실행 로드맵
+
+## 🎤 예상 Q&A 및 답변 준비
+
+**Q1: 우리 같은 중견기업도 가능한가요?**
+A: 오히려 중견기업이 더 빠르게 변화할 수 있습니다. 작은 파일럿부터 시작하세요.
+
+**Q2: 예산이 제한적인데 어떻게 시작하나요?**
+A: 클라우드 기반 SaaS를 활용하면 초기 투자를 최소화할 수 있습니다.
+
+**Q3: 직원들의 저항이 심한데 어떻게 극복하나요?**
+A: 변화의 수혜자를 먼저 만들고, 그들이 전도사가 되게 하세요.
+
+---
+*이 PPT는 20분 발표를 기준으로 작성되었으며, 청중과의 상호작용을 극대화하도록 설계되었습니다.*"""
+            }
+            
+            # 프롬프트 내용에 따라 적절한 응답 선택
+            if role == "supervisor" and "조사자 AI가 정리한" in messages[0]["content"]:
+                response = test_responses["supervisor_execution"]
+            elif role == "supervisor" and messages[0]["content"].find("실행자 AI의 PPT 초안") > -1:
+                response = test_responses["supervisor_review"]  
+            elif role == "supervisor":
+                response = test_responses["supervisor_initial"]
+            elif role == "researcher":
+                response = test_responses["researcher"]
+            elif role == "executor" and "최종 PPT" in messages[0]["content"]:
+                response = test_responses["executor_final"]
+            else:
+                response = test_responses["executor"]
+            
+            yield from self.simulate_streaming(response, role)
             return
         
-        # Create a temporary Python file
-        with NamedTemporaryFile(suffix='.py', delete=False, mode='w') as tmp:
-            tmp.write(code)
-            tmp_path = tmp.name
+        # 실제 API 호출
+        try:
+            system_prompts = {
+                "supervisor": "당신은 전문적인 PPT 구조를 설계하고 지도하는 감독자 AI입니다.",
+                "researcher": "당신은 PPT 콘텐츠를 위한 정보를 조사하고 정리하는 조사자 AI입니다.",
+                "executor": "당신은 실제 PPT 슬라이드 내용을 작성하는 실행자 AI입니다."
+            }
+            
+            full_messages = [
+                {"role": "system", "content": system_prompts.get(role, "")},
+                *messages
+            ]
+            
+            payload = {
+                "model": self.model_id,
+                "messages": full_messages,
+                "max_tokens": 4096,
+                "temperature": 0.7,
+                "top_p": 0.8,
+                "stream": True,
+                "stream_options": {"include_usage": True}
+            }
+            
+            logger.info(f"API 스트리밍 호출 시작 - Role: {role}")
+            
+            response = requests.post(
+                self.api_url,
+                headers=self.create_headers(),
+                json=payload,
+                stream=True,
+                timeout=10
+            )
+            
+            if response.status_code != 200:
+                logger.error(f"API 오류: {response.status_code}")
+                yield f"❌ API 오류 ({response.status_code}): {response.text[:200]}"
+                return
+            
+            for line in response.iter_lines():
+                if line:
+                    line = line.decode('utf-8')
+                    if line.startswith("data: "):
+                        data = line[6:]
+                        if data == "[DONE]":
+                            break
+                        try:
+                            chunk = json.loads(data)
+                            if "choices" in chunk and chunk["choices"]:
+                                content = chunk["choices"][0].get("delta", {}).get("content", "")
+                                if content:
+                                    yield content
+                        except json.JSONDecodeError:
+                            continue
+                            
+        except requests.exceptions.Timeout:
+            yield "⏱️ API 호출 시간이 초과되었습니다. 다시 시도해주세요."
+        except requests.exceptions.ConnectionError:
+            yield "🔌 API 서버에 연결할 수 없습니다. 인터넷 연결을 확인해주세요."
+        except Exception as e:
+            logger.error(f"스트리밍 중 오류: {str(e)}")
+            yield f"❌ 오류 발생: {str(e)}"
+
+# 시스템 인스턴스 생성
+ppt_system = PPTCreationSystem()
+
+# ===== 메인 처리 함수 =====
+def process_ppt_streaming(ppt_topic: str, template_name: str, audience_type: str, language: str,
+                         custom_slides: List[Dict], slide_count: int, seed: int, uploaded_file, 
+                         use_web_search: bool, theme_name: str = "Minimal Light", 
+                         progress=gr.Progress()):
+    """통합된 PPT 생성 처리 - 3자 협의 시스템 사용"""
+    # Update global variables
+    global current_topic, uploaded_content, current_language
+    current_topic = ppt_topic
+    current_language = language
+    
+    # Read uploaded file content
+    uploaded_content = ""
+    if uploaded_file is not None:
+        try:
+            uploaded_content = read_uploaded_file(uploaded_file.name)
+            print(f"[File Upload] Content length: {len(uploaded_content)} characters")
+        except Exception as e:
+            print(f"[File Upload] Error: {str(e)}")
+            uploaded_content = ""
+    
+    # Template selection and slide configuration
+    try:
+        if template_name == "Custom" and custom_slides:
+            slides = [{"title": "Cover", "style": "Title Slide (Hero)", "prompt_hint": "Presentation cover"}]
+            slides.extend(custom_slides)
+            slides.append({"title": "Thank You", "style": "Thank You Slide", "prompt_hint": "Presentation closing and key message"})
+        else:
+            template = PPT_TEMPLATES.get(template_name)
+            if not template:
+                yield "", "", "", None, f"❌ Template '{template_name}' not found."
+                return
+            slides = generate_dynamic_slides(ppt_topic, template, slide_count)
+    except Exception as e:
+        print(f"[Slide Configuration] Error: {str(e)}")
+        yield "", "", "", None, f"❌ Error configuring slides: {str(e)}"
+        return
+    
+    if not slides:
+        yield "", "", "", None, "No slides defined."
+        return
+    
+    total_slides = len(slides)
+    print(f"\n[PPT Generation] Starting - Total {total_slides} slides (Cover + {slide_count} content + Thank You)")
+    print(f"[PPT Generation] Topic: {ppt_topic}")
+    print(f"[PPT Generation] Template: {template_name}")
+    print(f"[PPT Generation] Audience: {audience_type}")
+    print(f"[PPT Generation] Language: {language}")
+    print(f"[PPT Generation] Design Theme: {theme_name}")
+    print(f"[PPT Generation] Web Search: {'Enabled' if use_web_search else 'Disabled'}")
+    
+    conversation_log = []
+    all_responses = {"supervisor": [], "researcher": [], "executor": []}
+    
+    try:
+        # 1단계: 감독자 AI 초기 분석 및 키워드 추출
+        progress(0.1, "🧠 감독자 AI가 PPT 구조를 설계 중...")
+        supervisor_prompt = ppt_system.create_supervisor_initial_prompt(ppt_topic)
+        supervisor_initial_response = ""
+        
+        supervisor_text = "[PPT 구조 설계] 🔄 생성 중...\n"
+        for chunk in ppt_system.call_llm_streaming(
+            [{"role": "user", "content": supervisor_prompt}], 
+            "supervisor"
+        ):
+            supervisor_initial_response += chunk
+            supervisor_text = f"[PPT 구조 설계] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_initial_response}"
+            yield supervisor_text, "", "", None, "🔄 감독자 AI가 PPT 구조를 설계 중..."
+        
+        all_responses["supervisor"].append(supervisor_initial_response)
+        
+        # 2단계: 웹 검색 수행 (선택된 경우)
+        search_results = {}
+        if use_web_search and BRAVE_API_TOKEN:
+            progress(0.2, "🔍 PPT 콘텐츠 검색 중...")
+            keywords = ppt_system.extract_keywords(supervisor_initial_response)
+            logger.info(f"추출된 키워드: {keywords}")
+            
+            researcher_text = "[콘텐츠 검색] 🔍 검색 중...\n"
+            yield supervisor_text, researcher_text, "", None, "🔍 PPT 콘텐츠 검색 중..."
+            
+            total_search_count = 0
+            
+            # 원래 키워드로 검색
+            for keyword in keywords:
+                try:
+                    results = ppt_system.brave_search(keyword)
+                    if results:
+                        search_results[keyword] = results
+                        total_search_count += len(results)
+                        researcher_text += f"✓ '{keyword}' 검색 완료 ({len(results)}개 결과)\n"
+                        yield supervisor_text, researcher_text, "", None, f"🔍 '{keyword}' 검색 중..."
+                except Exception as e:
+                    print(f"[Search] Error searching for '{keyword}': {str(e)}")
+            
+            researcher_text += f"\n📊 총 {total_search_count}개의 검색 결과 수집 완료\n"
+        
+        # 3단계: 조사자 AI가 검색 결과 정리
+        progress(0.3, "📝 조사자 AI가 콘텐츠 정리 중...")
+        researcher_prompt = ppt_system.create_researcher_prompt(ppt_topic, supervisor_initial_response, search_results)
+        researcher_response = ""
+        
+        researcher_text = "[PPT 콘텐츠 정리] 🔄 생성 중...\n"
+        for chunk in ppt_system.call_llm_streaming(
+            [{"role": "user", "content": researcher_prompt}], 
+            "researcher"
+        ):
+            researcher_response += chunk
+            researcher_text = f"[PPT 콘텐츠 정리] - {datetime.now().strftime('%H:%M:%S')}\n{researcher_response}"
+            yield supervisor_text, researcher_text, "", None, "📝 조사자 AI가 콘텐츠 정리 중..."
+        
+        all_responses["researcher"].append(researcher_response)
+        
+        # 4단계: 감독자 AI가 조사 내용 기반으로 실행 지시
+        progress(0.4, "🎯 감독자 AI가 제작 지시 중...")
+        supervisor_execution_prompt = ppt_system.create_supervisor_execution_prompt(ppt_topic, researcher_response)
+        supervisor_execution_response = ""
+        
+        supervisor_text += "\n\n---\n\n[PPT 제작 지시] 🔄 생성 중...\n"
+        for chunk in ppt_system.call_llm_streaming(
+            [{"role": "user", "content": supervisor_execution_prompt}], 
+            "supervisor"
+        ):
+            supervisor_execution_response += chunk
+            temp_text = f"{all_responses['supervisor'][0]}\n\n---\n\n[PPT 제작 지시] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_execution_response}"
+            supervisor_text = f"[PPT 구조 설계] - {datetime.now().strftime('%H:%M:%S')}\n{temp_text}"
+            yield supervisor_text, researcher_text, "", None, "🎯 감독자 AI가 제작 지시 중..."
+        
+        all_responses["supervisor"].append(supervisor_execution_response)
+        
+        # 5단계: 실행자 AI가 조사 내용과 지시를 기반으로 초기 PPT 작성
+        progress(0.5, "📊 실행자 AI가 PPT 작성 중...")
+        executor_prompt = ppt_system.create_executor_prompt(ppt_topic, supervisor_execution_response, researcher_response)
+        executor_response = ""
+        
+        executor_text = "[초기 PPT 작성] 🔄 생성 중...\n"
+        for chunk in ppt_system.call_llm_streaming(
+            [{"role": "user", "content": executor_prompt}], 
+            "executor"
+        ):
+            executor_response += chunk
+            executor_text = f"[초기 PPT 작성] - {datetime.now().strftime('%H:%M:%S')}\n{executor_response}"
+            yield supervisor_text, researcher_text, executor_text, None, "📊 실행자 AI가 PPT 작성 중..."
+        
+        all_responses["executor"].append(executor_response)
+        
+        # 5.5단계: 실행자 AI 응답 파싱 (개선된 파서 사용)
+        progress(0.55, "📝 실행자 AI 응답을 슬라이드로 변환 중...")
+        
+        # 개선된 파서 사용
+        parsed_slides = parse_executor_response(executor_response, slides, language)
+        logger.info(f"파싱된 슬라이드 수: {len(parsed_slides)}")
+        
+        # 파싱 성공 여부 확인
+        parsing_success = len(parsed_slides) > 0
+        
+        # 파싱 결과 로그
+        for slide_idx, slide_data in parsed_slides.items():
+            logger.info(f"[파싱 결과] 슬라이드 {slide_idx + 1}:")
+            logger.info(f"  - 제목: {slide_data.get('title', 'N/A')}")
+            logger.info(f"  - 부제목: {slide_data.get('subtitle', 'N/A')}")
+            logger.info(f"  - 불릿 포인트 수: {len(slide_data.get('bullet_points', []))}")
+            if slide_data.get('bullet_points'):
+                logger.info(f"  - 첫 번째 불릿: {slide_data['bullet_points'][0]}")
+        
+        # 파싱 실패 시 경고 및 대체 방안
+        if not parsing_success:
+            logger.warning("[파싱] 실행자 응답 파싱 실패 - 실행자 응답 원문을 직접 사용 시도")
+            
+            # 실행자 응답을 직접 보여주기 (디버깅용)
+            yield supervisor_text, researcher_text, executor_text + "\n\n⚠️ 파싱 실패 - 대체 방법 사용 중...", None, "⚠️ 슬라이드 파싱 중 문제 발견, 대체 방법 사용..."
+        
+        # 6단계: 실제 슬라이드 생성 (개선된 로직)
+        progress(0.6, "🎨 슬라이드 이미지 생성 중...")
+        results = []
+        preview_html = """
+        <style>
+            .slides-container {
+                width: 100%;
+                max-width: 1400px;
+                margin: 0 auto;
+            }
+        </style>
+        <div class="slides-container">
+        """
+        
+        # Process each slide with improved logic
+        for i, slide in enumerate(slides):
+            try:
+                progress((0.6 + (0.3 * i / total_slides)), f"슬라이드 {i+1}/{total_slides} 처리 중...")
         
-        # Execute the code
-        exec(compile(code, tmp_path, 'exec'), globals())
+                # Translate slide title if Korean
+                display_title = slide.get('title', '')
+                if language == "Korean" and slide.get('title', '') in SLIDE_TITLE_TRANSLATIONS:
+                    display_title = SLIDE_TITLE_TRANSLATIONS[slide.get('title', '')]
         
-        # Clean up the temporary file
+                slide_info = f"Slide {i+1}: {display_title}"
+                slide_context = f"{slide.get('title', '')} - {slide.get('prompt_hint', '')}"
+                
+                # 파싱된 데이터 확인 및 사용
+                content = None
+                speaker_notes = ""
+                
+                if i in parsed_slides and parsing_success:
+                    # 파싱된 데이터 사용
+                    parsed_data = parsed_slides[i]
+                    logger.info(f"[슬라이드 {i+1}] 실행자 AI의 파싱된 콘텐츠 사용")
+                    
+                    # 불릿 포인트 검증
+                    valid_bullets = []
+                    for bp in parsed_data.get("bullet_points", []):
+                        # 의미없는 placeholder 제거
+                        if bp and not any(skip in bp for skip in ["Point 1", "Point 2", "Point 3", "Point 4", "Point 5", "📌 Point"]):
+                            valid_bullets.append(bp)
+                    
+                    # 유효한 불릿 포인트가 있으면 사용
+                    if len(valid_bullets) >= 3:  # 최소 3개 이상일 때만 사용
+                        content = {
+                            "subtitle": parsed_data.get("subtitle") or display_title,
+                            "bullet_points": valid_bullets[:5]  # 최대 5개
+                        }
+                        speaker_notes = parsed_data.get("speaker_notes", "")
+                        logger.info(f"[슬라이드 {i+1}] 파싱된 콘텐츠 사용 완료 - 불릿 {len(valid_bullets)}개")
+                    else:
+                        logger.warning(f"[슬라이드 {i+1}] 불릿 포인트 부족 ({len(valid_bullets)}개) - 실행자 응답에서 재추출 시도")
+                        
+                        # 실행자 응답에서 해당 슬라이드 관련 내용 재추출
+                        slide_keywords = [display_title, slide.get('title', ''), slide.get('prompt_hint', '')]
+                        extracted_content = extract_relevant_content_from_executor(
+                            executor_response, slide_keywords, i+1, slide.get('title', '')
+                        )
+                        
+                        if extracted_content and len(extracted_content.get("bullet_points", [])) >= 3:
+                            content = extracted_content
+                            speaker_notes = extracted_content.get("speaker_notes", "")
+                            logger.info(f"[슬라이드 {i+1}] 실행자 응답에서 재추출 성공")
+                
+                # 파싱 실패하거나 콘텐츠가 없으면 실행자 응답에서 직접 추출
+                if not content:
+                    logger.warning(f"[슬라이드 {i+1}] 파싱 실패 - 실행자 응답에서 직접 추출 시도")
+                    
+                    # 슬라이드 번호로 실행자 응답에서 해당 부분 찾기
+                    slide_section = extract_slide_section_from_executor(executor_response, i+1)
+                    
+                    if slide_section:
+                        content = parse_slide_section(slide_section, display_title)
+                        speaker_notes = extract_speaker_notes_from_section(slide_section)
+                        logger.info(f"[슬라이드 {i+1}] 실행자 응답에서 직접 추출 성공")
+                
+                # 그래도 콘텐츠가 없으면 최종 폴백
+                if not content or len(content.get("bullet_points", [])) < 3:
+                    logger.warning(f"[슬라이드 {i+1}] 모든 방법 실패 - generate_slide_content 폴백 사용")
+                    
+                    # Thank You slide 특별 처리
+                    if slide.get('title') == 'Thank You':
+                        conclusion_phrase = generate_conclusion_phrase(
+                            ppt_topic, audience_type, language, 
+                            FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
+                        )
+                        content = {
+                            "subtitle": conclusion_phrase,
+                            "bullet_points": []
+                        }
+                        speaker_notes = generate_closing_notes(
+                            ppt_topic, conclusion_phrase, audience_type, language,
+                            FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
+                        )
+                    else:
+                        # 일반 슬라이드 폴백 생성
+                        content = generate_slide_content(
+                            ppt_topic, slide.get('title', ''), slide_context, audience_type, language,
+                            uploaded_content, list(search_results.values()) if use_web_search else [],
+                            FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
+                        )
+                        speaker_notes = generate_presentation_notes(
+                            ppt_topic, slide.get('title', ''), content, audience_type, language,
+                            FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
+                        )
+                
+                # 발표자 노트가 없으면 생성
+                if not speaker_notes:
+                    speaker_notes = generate_presentation_notes(
+                        ppt_topic, slide.get('title', ''), content, audience_type, language,
+                        FRIENDLI_TOKEN, API_URL, MODEL_ID, AUDIENCE_TYPES
+                    )
+                
+                # Generate prompt and image
+                style_key = slide.get("style", "Colorful Mind Map")
+                if style_key in STYLE_TEMPLATES:
+                    style_info = STYLE_TEMPLATES[style_key]
+                    prompt = generate_prompt_with_llm(
+                        ppt_topic, style_info["example"], 
+                        slide_context, uploaded_content,
+                        FRIENDLI_TOKEN, API_URL, MODEL_ID
+                    )
+                    
+                    # Generate image
+                    slide_seed = seed + i
+                    img, used_prompt = generate_image(
+                        prompt, slide_seed, slide_info, 
+                        REPLICATE_API_TOKEN, current_topic, current_language,
+                        FRIENDLI_TOKEN, API_URL, MODEL_ID
+                    )
+                    
+                    # Prepare slide data
+                    slide_data = {
+                        "slide_number": i + 1,
+                        "title": display_title,
+                        "subtitle": content["subtitle"],
+                        "bullet_points": content["bullet_points"][:5],
+                        "image": img,
+                        "style": style_info["name"],
+                        "speaker_notes": speaker_notes,
+                        "topic": ppt_topic
+                    }
+                    
+                    # 디버깅: 실제 사용된 콘텐츠 로그
+                    logger.info(f"[슬라이드 {i+1}] 최종 콘텐츠:")
+                    logger.info(f"  - 부제목: {slide_data['subtitle']}")
+                    logger.info(f"  - 불릿 포인트: {len(slide_data['bullet_points'])}개")
+                    if slide_data['bullet_points']:
+                        logger.info(f"  - 첫 번째 불릿: {slide_data['bullet_points'][0]}")
+                    
+                    # Generate preview HTML
+                    preview_html += create_slide_preview_html(slide_data)
+                    
+                    # Update current state
+                    yield supervisor_text, researcher_text, executor_text, None, f"### 🔄 {slide_info} 생성 중..."
+                    
+                    results.append({
+                        "slide_data": slide_data,
+                        "success": img is not None
+                    })
+                else:
+                    logger.error(f"[슬라이드 {i+1}] 알 수 없는 스타일: {style_key}")
+                    
+            except Exception as e:
+                logger.error(f"[슬라이드 {i+1}] 처리 중 오류: {str(e)}")
+                import traceback
+                traceback.print_exc()
+                
+                # 오류 시 기본값
+                results.append({
+                    "slide_data": {
+                        "slide_number": i + 1,
+                        "title": display_title,
+                        "subtitle": "콘텐츠 생성 중 오류 발생",
+                        "bullet_points": ["• 오류로 인해 콘텐츠를 생성할 수 없습니다"],
+                        "image": None,
+                        "style": "Error",
+                        "speaker_notes": "오류로 인해 발표자 노트를 생성할 수 없습니다.",
+                        "topic": ppt_topic
+                    },
+                    "success": False
+                })
+        
+        # Create PPTX file
+        progress(0.95, "Creating PPTX file...")
+        pptx_path = None
         try:
-            os.unlink(tmp_path)
-        except:
-            pass
+            pptx_path = create_pptx_file(results, ppt_topic, template_name, theme_name, DESIGN_THEMES)
+        except Exception as e:
+            print(f"[PPTX] File creation error: {str(e)}")
+            import traceback
+            traceback.print_exc()
+        
+        preview_html += "</div>"
+        progress(1.0, "Complete!")
+        successful = sum(1 for r in results if r["success"])
+        final_status = f"### 🎉 Generation complete! {successful} out of {total_slides} slides succeeded"
+        
+        # Save global variables
+        global current_slides_data, current_template, current_theme
+        current_slides_data = results
+        current_template = template_name
+        current_theme = theme_name
+        
+        if pptx_path:
+            final_status += f"\n\n### 📥 PPTX file is ready!"
+            final_status += f"\n\n🎤 **Speaker notes for {audience_type} included in each slide!**"
+            if PROCESS_FLOW_AVAILABLE:
+                final_status += f"\n\n🔧 **Process flow diagrams are automatically generated ({language} support)**"
+        
+        yield supervisor_text, researcher_text, executor_text, pptx_path, final_status
+        
+    except Exception as e:
+        error_msg = f"❌ 처리 중 오류: {str(e)}"
+        print(f"[PPT Generation] Critical error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        yield "", "", "", None, error_msg
+
+def generate_ppt_handler(topic, template_name, audience_type, language, theme_name, slide_count, 
+                       seed, file_upload, use_web_search, custom_slide_count, 
+                       progress=gr.Progress(), *custom_inputs):
+    if not topic.strip():
+        yield "", "", "", None, "❌ Please enter a topic."
+        return
+    
+    # Process custom slides
+    custom_slides = []
+    if template_name == "Custom" and custom_inputs:
+        try:
+            # Convert custom_inputs to list to avoid tuple slicing issues
+            custom_inputs_list = list(custom_inputs)
             
+            for i in range(0, min(custom_slide_count * 3, len(custom_inputs_list)), 3):
+                title = custom_inputs_list[i] if i < len(custom_inputs_list) else ""
+                style = custom_inputs_list[i+1] if i+1 < len(custom_inputs_list) else "Colorful Mind Map"
+                hint = custom_inputs_list[i+2] if i+2 < len(custom_inputs_list) else ""
+                
+                if title and style:
+                    custom_slides.append({
+                        "title": title,
+                        "style": style,
+                        "prompt_hint": hint
+                    })
+        except Exception as e:
+            print(f"[Custom Slides] Error processing custom inputs: {str(e)}")
+            yield "", "", "", None, f"❌ Error processing custom slides: {str(e)}"
+            return
+    
+    # Generate PPT
+    try:
+        for supervisor, researcher, executor, pptx_file, status in process_ppt_streaming(
+            topic, template_name, audience_type, language, custom_slides, slide_count, 
+            seed, file_upload, use_web_search, theme_name, progress
+        ):
+            yield supervisor, researcher, executor, pptx_file, status
     except Exception as e:
-        st.error(f"⚠️ Error loading or executing the application: {str(e)}")
+        print(f"[PPT Generation] Error: {str(e)}")
         import traceback
-        st.code(traceback.format_exc())
+        traceback.print_exc()
+        yield "", "", "", None, f"❌ Error during PPT generation: {str(e)}"
+
+# ===== Gradio UI =====
+with gr.Blocks(title="PPT Generator", theme=gr.themes.Soft(), css=get_css()) as demo:
+    gr.Markdown("""
+    # 🎯 Open GAMMA 'GAMJA' - AI Presentation Generator with 3-AI Collaboration
+    
+    ### Create professional presentations with AI-powered collaboration system!
+    
+    ** Community: https://discord.gg/openfreeai
+    """)
+    
+    # API token status check
+    token_status = []
+    if not REPLICATE_API_TOKEN:
+        token_status.append("⚠️ RAPI_TOKEN environment variable not set.")
+    if not FRIENDLI_TOKEN:
+        token_status.append("⚠️ FRIENDLI_TOKEN environment variable not set.")
+    if not BRAVE_API_TOKEN:
+        token_status.append("ℹ️ BAPI_TOKEN not available. Web search disabled.")
+    if not PROCESS_FLOW_AVAILABLE:
+        token_status.append("ℹ️ process_flow_generator not available. Process flow diagrams disabled.")
+    
+    if token_status:
+        gr.Markdown("\n".join(token_status))
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Language selection (at the top)
+            language_select = gr.Radio(
+                choices=["English", "Korean"],
+                label="🌐 Content Language",
+                value="English",
+                info="Select the language for your presentation content"
+            )
+            
+            # Example selection
+            with gr.Row():
+                example_btn = gr.Button("📋 Load Example", size="sm", variant="secondary")
+                
+            # Basic inputs
+            topic_input = gr.Textbox(
+                label="Presentation Topic",
+                placeholder="e.g., AI Startup Investment Pitch, New Product Launch, Digital Transformation Strategy",
+                lines=2
+            )
+            
+            # Audience selection
+            audience_select = gr.Dropdown(
+                choices=list(AUDIENCE_TYPES.keys()),
+                label="🎭 Target Audience",
+                value="General Staff",
+                info="Content and tone will be automatically optimized for your audience"
+            )
+            
+            # Audience description display
+            audience_info = gr.Markdown()
+            
+            # PPT template selection
+            template_select = gr.Dropdown(
+                choices=list(PPT_TEMPLATES.keys()),
+                label="PPT Template",
+                value="Business Proposal",
+                info="Select a template that matches your purpose"
+            )
+            
+            # Design theme selection
+            theme_select = gr.Dropdown(
+                choices=list(DESIGN_THEMES.keys()),
+                label="Design Theme",
+                value="Minimal Light",
+                info="Overall design style for your presentation"
+            )
+            
+            # Theme preview
+            theme_preview = gr.HTML()
+            
+            # Slide count selection
+            slide_count = gr.Slider(
+                minimum=6,
+                maximum=20,
+                value=8,
+                step=1,
+                label="Number of Content Slides (excluding Cover and Thank You)",
+                info="Select the number of content slides to generate (not used in Custom template)"
+            )
+            
+            # File upload
+            file_upload = gr.File(
+                label="Reference Material Upload (Optional)",
+                file_types=[".pdf", ".csv", ".txt"],
+                type="filepath",
+                value=None
+            )
+            
+            # Web search option
+            use_web_search = gr.Checkbox(
+                label="Use Web Search",
+                value=True,
+                info="Use Brave Search to include latest information"
+            )
+            
+            # Template description
+            template_info = gr.Markdown()
+            
+            # Seed value
+            seed_input = gr.Slider(
+                minimum=1,
+                maximum=100,
+                value=10,
+                step=1,
+                label="Seed Value"
+            )
+            
+            generate_btn = gr.Button("🚀 Generate PPT (AI creates all content automatically)", variant="primary", size="lg")
+            
+            # Usage instructions
+            with gr.Accordion("📖 How to Use", open=False):
+                gr.Markdown(get_usage_instructions())
+    
+    # Status display
+    with gr.Row():
+        with gr.Column():
+            status_output = gr.Markdown(
+                value="### 👆 Select a template and click the generate button!"
+            )
+            
+            # PPTX download area
+            download_file = gr.File(
+                label="📥 Download Generated PPTX File",
+                visible=True,
+                elem_id="download-file"
+            )
+    
+    # AI outputs in tabs
+    with gr.Tabs():
+        with gr.TabItem("🤖 3-AI Collaboration Process"):
+            with gr.Row():
+                # 감독자 AI 출력
+                with gr.Column():
+                    gr.Markdown("### 🧠 Supervisor AI (Structure Design)")
+                    supervisor_output = gr.Textbox(
+                        label="",
+                        lines=20,
+                        max_lines=25,
+                        interactive=False,
+                        elem_classes=["supervisor-box"]
+                    )
+                
+                # 조사자 AI 출력
+                with gr.Column():
+                    gr.Markdown("### 🔍 Researcher AI (Content Collection)")
+                    researcher_output = gr.Textbox(
+                        label="",
+                        lines=20,
+                        max_lines=25,
+                        interactive=False,
+                        elem_classes=["researcher-box"]
+                    )
+                
+                # 실행자 AI 출력
+                with gr.Column():
+                    gr.Markdown("### 📝 Executor AI (Slide Creation)")
+                    executor_output = gr.Textbox(
+                        label="",
+                        lines=20,
+                        max_lines=25,
+                        interactive=False,
+                        elem_classes=["executor-box"]
+                    )
+        
+        with gr.TabItem("📊 PPT Preview"):
+            # Preview area
+            preview_output = gr.HTML(
+                label="PPT Preview (16:9)",
+                elem_classes="preview-container"
+            )
+    
+    # Custom slides section
+    with gr.Accordion("📝 Custom Slide Configuration", open=False, elem_id="custom_accordion") as custom_accordion:
+        gr.Markdown("Build your presentation without using templates. (3-20 slides)")
+        
+        # Custom slide count selection
+        custom_slide_count = gr.Slider(
+            minimum=3,
+            maximum=20,
+            value=5,
+            step=1,
+            label="Number of Custom Slides",
+            info="Select the number of custom slides to create"
+        )
+        
+        custom_slides_components = create_custom_slides_ui(initial_count=5)
+    
+    # Connect events
+    example_btn.click(
+        fn=load_example,
+        inputs=[template_select, language_select],
+        outputs=[topic_input]
+    )
+    
+    audience_select.change(
+        fn=update_audience_info,
+        inputs=[audience_select],
+        outputs=[audience_info]
+    )
+    
+    theme_select.change(
+        fn=update_theme_preview,
+        inputs=[theme_select],
+        outputs=[theme_preview]
+    )
+    
+    template_select.change(
+        fn=update_template_info,
+        inputs=[template_select, slide_count],
+        outputs=[template_info, slide_count, custom_accordion]
+    )
+    
+    slide_count.change(
+        fn=lambda t, s: update_template_info(t, s)[0],
+        inputs=[template_select, slide_count],
+        outputs=[template_info]
+    )
+    
+    custom_slide_count.change(
+        fn=update_custom_slides_visibility,
+        inputs=[custom_slide_count],
+        outputs=[slide["row"] for slide in custom_slides_components]
+    )
+    
+    # Flatten custom slide input components
+    all_custom_inputs = []
+    for slide in custom_slides_components:
+        all_custom_inputs.extend([slide["title"], slide["style"], slide["hint"]])
+    
+    generate_btn.click(
+        fn=generate_ppt_handler,
+        inputs=[
+            topic_input, template_select, audience_select, language_select, theme_select, 
+            slide_count, seed_input, file_upload, use_web_search, custom_slide_count
+        ] + all_custom_inputs,
+        outputs=[supervisor_output, researcher_output, executor_output, download_file, status_output]
+    )
+    
+    # Load initial info on startup
+    demo.load(
+        fn=lambda: (update_template_info(template_select.value, slide_count.value)[0],
+                   update_theme_preview(theme_select.value),
+                   update_audience_info(audience_select.value)),
+        inputs=[],
+        outputs=[template_info, theme_preview, audience_info]
+    )
 
+# Run app
 if __name__ == "__main__":
-    main()
+    demo.queue()  # Enable queue for streaming
+    demo.launch(ssr_mode=False)