Update app.py

app.py

@@ -1,1895 +1,36 @@
-# app.py
-"""Main PPT Generator with 3-AI collaboration system"""
-
 import os
-import re
-import json
-import time
-import logging
-import gradio as gr
-import requests
-from typing import List, Dict, Generator
-from datetime import datetime
-
-# 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'
-        ]
-        
-        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 우선 접근
-발표자 노트: 각 기술의 비즈니스 가치 연결
-시각 자료: 계층적 기술 스택 다이어그램
+import sys
+import streamlit as st
+from tempfile import NamedTemporaryFile
 
-[슬라이드 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
-        
-        # 실제 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": []}
-    
+def main():
     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, "⚠️ 슬라이드 파싱 중 문제 발견, 대체 방법 사용..."
+        # Get the code from secrets
+        code = os.environ.get("MAIN_CODE")
         
-        # 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} 처리 중...")
-        
-                # 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', '')]
-        
-                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:
-            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 not code:
+            st.error("⚠️ The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+            return
         
-        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)**"
+        # Create a temporary Python file
+        with NamedTemporaryFile(suffix='.py', delete=False, mode='w') as tmp:
+            tmp.write(code)
+            tmp_path = tmp.name
         
-        yield supervisor_text, researcher_text, executor_text, pptx_path, final_status
+        # Execute the code
+        exec(compile(code, tmp_path, 'exec'), globals())
         
-    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:
+        # Clean up the temporary file
         try:
-            # Convert custom_inputs to list to avoid tuple slicing issues
-            custom_inputs_list = list(custom_inputs)
+            os.unlink(tmp_path)
+        except:
+            pass
             
-            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:
-        print(f"[PPT Generation] Error: {str(e)}")
+        st.error(f"⚠️ Error loading or executing the application: {str(e)}")
         import traceback
-        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]
-    )
+        st.code(traceback.format_exc())
 
-# Run app
 if __name__ == "__main__":
-    demo.queue()  # Enable queue for streaming
-    demo.launch(ssr_mode=False)        
+    main()
+