Update app.py

app.py

@@ -1,1754 +1,35 @@
-import gradio as gr
 import os
-import json
-import requests
-from datetime import datetime
-import time
-from typing import List, Dict, Any, Generator, Tuple
-import logging
-import re
+import sys
+import streamlit as st
+from tempfile import NamedTemporaryFile
 
-# 로깅 설정
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# 추가 임포트
-from bs4 import BeautifulSoup
-from urllib.parse import urlparse
-import urllib.request
-
-# 환경 변수에서 토큰 가져오기
-FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN", "YOUR_FRIENDLI_TOKEN")
-BAPI_TOKEN = os.getenv("BAPI_TOKEN", "YOUR_BRAVE_API_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"
-
-# 전역 변수
-conversation_history = []
-
-class LLMCollaborativeSystem:
-    def __init__(self):
-        self.token = FRIENDLI_TOKEN
-        self.bapi_token = BAPI_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, user_query: str) -> str:
-        """감독자 AI 초기 프롬프트 생성"""
-        return f"""당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.
-
-사용자 질문: {user_query}
-
-이 질문에 대해:
-1. 문제의 본질과 핵심 요구사항을 파악하세요
-2. 해결을 위한 전략적 프레임워크를 수립하세요
-3. 창조자 AI가 혁신적인 아이디어를 낼 수 있도록 문제의 맥락과 제약사항을 명확히 정의하세요
-4. 성공 기준과 목표를 구체적으로 제시하세요"""
-    
-    def create_creator_prompt(self, user_query: str, supervisor_guidance: str) -> str:
-        """창조자 AI 프롬프트 생성"""
-        return f"""당신은 혁신적이고 창의적인 아이디어를 생성하는 창조자 AI입니다.
-
-사용자 질문: {user_query}
-
-감독자 AI의 분석:
-{supervisor_guidance}
-
-위 분석을 바탕으로:
-1. 기존 방식을 뛰어넘는 혁신적인 해결 방안 5-7개를 제시하세요
-2. 각 아이디어의 독창성과 잠재적 영향력을 설명하세요
-3. 실현 가능성과 함께 필요한 리소스를 개략적으로 제시하세요
-4. 아이디어 간의 시너지 효과나 결합 가능성을 탐색하세요
-5. 미래 지향적이고 파괴적인 혁신 요소를 포함하세요"""
-    
-    def create_supervisor_ideation_review_prompt(self, user_query: str, creator_ideas: str) -> str:
-        """감독자 AI의 아이디어 검토 및 조사 지시 프롬프트"""
-        return f"""당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.
-
-사용자 질문: {user_query}
-
-창조자 AI가 제시한 혁신적 아이디어들:
-{creator_ideas}
-
-이 아이디어들을 검토하고:
-1. 각 아이디어의 전략적 가치와 실현 가능성을 평가하세요
-2. 가장 유망한 3-4개 아이디어를 선별하고 그 이유를 설명하세요
-3. 선별된 아이디어에 대해 조사가 필요한 구체적인 키워드나 검색어를 제시하세요
-4. 조사 시 중점적으로 확인해야 할 사항들을 명시하세요
-
-키워드는 다음 형식으로 제시하세요:
-[검색 키워드]: 키워드1, 키워드2, 키워드3, 키워드4, 키워드5"""
-    
-    def create_researcher_prompt(self, user_query: str, supervisor_guidance: str, search_results: Dict[str, List[Dict]]) -> str:
-        """조사자 AI 프롬프트 생성 (기존 코드 재사용)"""
-        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):
-                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]:
-                contradiction_text += f"- {cont['type']}: {cont['source1']} vs {cont['source2']}\n"
-        
-        return f"""당신은 정보를 조사하고 정리하는 조사자 AI입니다.
-
-사용자 질문: {user_query}
-
-감독자 AI의 지침:
-{supervisor_guidance}
-
-브레이브 검색 결과 (신뢰도 점수 포함):
-{search_summary}
-{contradiction_text}
-
-위 검색 결과를 바탕으로:
-1. 각 키워드별로 중요한 정보를 정리하세요
-2. 신뢰할 수 있는 출처(신뢰도 0.7 이상)를 우선적으로 참고하세요
-3. 실제 구현 사례나 성공 사례를 중점적으로 찾아 정리하세요
-4. 기술적 실현 가능성과 필요한 리소스 정보를 포함하세요
-5. 최신 트렌드와 미래 전망을 강조하세요"""
-    
-    def create_evaluator_research_prompt(self, user_query: str, creator_ideas: str, research_summary: str) -> str:
-        """평가자 AI의 조사 결과 평가 프롬프트"""
-        return f"""당신은 객관적이고 비판적인 시각으로 평가하는 평가자 AI입니다.
-
-사용자 질문: {user_query}
-
-창조자 AI의 아이디어:
-{creator_ideas}
-
-조사자 AI의 조사 결과:
-{research_summary}
-
-위 내용을 종합적으로 평가하여:
-1. 각 아이디어의 실현 가능성을 1-10점으로 평가하고 근거를 제시하세요
-2. 예상되는 리스크와 장애물을 구체적으로 분석하세요
-3. ROI(투자 대비 효과)를 예측하고 우선순위를 제안하세요
-4. 조사 결과의 신뢰성과 충분성을 평가하세요
-5. 추가로 필요한 정보나 검증 사항을 제시하세요
-6. 최종적으로 가장 실행 가능한 2-3개 방안을 추천하세요"""
-    
-    def create_supervisor_execution_prompt(self, user_query: str, evaluator_assessment: str) -> str:
-        """감독자 AI의 실행 지시 프롬프트"""
-        return f"""당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.
-
-사용자 질문: {user_query}
-
-평가자 AI의 종합 평가:
-{evaluator_assessment}
-
-평가 결과를 바탕으로 실행자 AI에게 구체적인 지시를 내려주세요:
-1. 평가자가 추천한 방안들을 어떻게 구현할지 단계별로 명시하세요
-2. 각 단계의 구체적인 작업 내용과 예상 소요 시간을 제시하세요
-3. 리스크 대응 방안을 각 단계별로 준비하세요
-4. 성과 측정 지표와 마일스톤을 명확히 정의하세요
-5. 필요한 리소스와 협력 체계를 구체화하세요"""
-    
-    def create_executor_prompt(self, user_query: str, supervisor_guidance: str, full_context: str) -> str:
-        """실행자 AI 프롬프트 생성"""
-        return f"""당신은 세부적인 내용을 구현하는 실행자 AI입니다.
-
-사용자 질문: {user_query}
-
-전체 맥락 (아이디어, 조사, 평가):
-{full_context}
-
-감독자 AI의 구체적인 지시:
-{supervisor_guidance}
-
-위 모든 정보를 바탕으로:
-1. 즉시 실행 가능한 구체적인 행동 계획을 작성하세요
-2. 각 작업의 상세한 실행 방법과 필요 도구를 명시하세요
-3. 예상되는 결과물과 산출물을 구체적으로 설명하세요
-4. 단계별 체크리스트와 검증 방법을 포함하세요
-5. 실제 코드, 템플릿, 프로세스 등 즉시 사용 가능한 자료를 제공하세요"""
-    
-    def create_evaluator_execution_prompt(self, user_query: str, executor_plan: str) -> str:
-        """평가자 AI의 실행 계획 평가 프롬프트"""
-        return f"""당신은 객관적이고 비판적인 시각으로 평가하는 평가자 AI입니다.
-
-사용자 질문: {user_query}
-
-실행자 AI의 실행 계획:
-{executor_plan}
-
-이 실행 계획을 평가하여:
-1. 계획의 완성도와 실행 가능성을 평가하세요 (1-10점)
-2. 누락된 요소나 개선이 필요한 부분을 구체적으로 지적하세요
-3. 예상되는 실행 상의 문제점과 해결 방안을 제시하세요
-4. 성공 가능성을 높이기 위한 추가 제안을 하세요
-5. 최종 점검 사항과 품질 기준을 제시하세요"""
-    
-    def create_supervisor_final_prompt(self, user_query: str, evaluator_feedback: str) -> str:
-        """감독자 AI의 최종 지시 프롬프트"""
-        return f"""당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.
-
-사용자 질문: {user_query}
-
-평가자 AI의 실행 계획 평가:
-{evaluator_feedback}
-
-평가 내용을 바탕으로:
-1. 실행자 AI가 반드시 보완해야 할 핵심 사항을 명확히 지시하세요
-2. 최종 품질 기준과 완성도 요구사항을 제시하세요
-3. 즉시 실행 가능한 형���로 만들기 위한 구체적인 개선 방향을 제시하세요
-4. 성공적인 실행을 위한 핵심 성공 요인을 강조하세요"""
-    
-    def create_executor_final_prompt(self, user_query: str, initial_plan: str, supervisor_final_guidance: str, full_context: str) -> str:
-        """실행자 AI 최종 보고서 프롬프트"""
-        return f"""당신은 세부적인 내용을 구현하는 실행자 AI입니다.
-
-사용자 질문: {user_query}
-
-전체 협업 맥락:
-{full_context}
-
-당신의 초기 실행 계획:
-{initial_plan}
-
-감독자 AI의 최종 지시사항:
-{supervisor_final_guidance}
-
-모든 피드백을 완전히 반영하여 즉시 실행 가능한 최종 솔루션을 작성하세요:
-1. 모든 개선사항을 반영한 완성된 실행 계획
-2. 구체적인 실행 도구, 코드, 템플릿 제공
-3. 단계별 실행 가이드와 체크리스트
-4. 예상 결과와 성과 측정 방법
-5. 리스크 대응 계획과 문제 해결 가이드
-6. 지속적 개선을 위한 모니터링 체계
-
-**반드시 실용적이고 즉시 적용 가능한 형태로 작성하세요.**"""
-    
-    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 = ["best practices", "implementation guide", "case studies", "latest trends", "success factors"]
-        
-        return keywords[:7]
-    
-    def generate_synonyms(self, keyword: str) -> List[str]:
-        """키워드의 동의어/유사어 생성 (기존 코드 재사용)"""
-        synonyms = {
-            "optimization": ["improvement", "enhancement", "efficiency", "tuning"],
-            "performance": ["speed", "efficiency", "throughput", "latency"],
-            "strategy": ["approach", "method", "technique", "plan"],
-            "implementation": ["deployment", "execution", "development", "integration"],
-            "analysis": ["evaluation", "assessment", "study", "research"],
-            "management": ["administration", "governance", "control", "supervision"],
-            "best practices": ["proven methods", "industry standards", "guidelines", "recommendations"],
-            "trends": ["developments", "innovations", "emerging", "future"],
-            "machine learning": ["ML", "AI", "deep learning", "neural networks"],
-            "프로젝트": ["project", "사업", "업무", "작업"],
-            "innovation": ["disruption", "breakthrough", "transformation", "revolution"],
-            "solution": ["approach", "method", "system", "framework"]
-        }
-        
-        keyword_lower = keyword.lower()
-        
-        if keyword_lower in synonyms:
-            return synonyms[keyword_lower][: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:
-        """검색 결과의 신뢰도 점수 계산 (기존 코드 재사용)"""
-        score = 0.5
-        
-        url = result.get('url', '')
-        title = result.get('title', '')
-        description = result.get('description', '')
-        
-        trusted_domains = [
-            '.edu', '.gov', '.org', 'wikipedia.org', 'nature.com', 
-            'sciencedirect.com', 'ieee.org', 'acm.org', 'springer.com',
-            'harvard.edu', 'mit.edu', 'stanford.edu', 'github.com'
-        ]
-        
-        for domain in trusted_domains:
-            if domain in url:
-                score += 0.2
-                break
-        
-        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))
-    
-    def fetch_url_content(self, url: str, max_length: int = 2000) -> str:
-        """URL에서 콘텐츠 추출 (기존 코드 재사용)"""
-        try:
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-            }
-            
-            req = urllib.request.Request(url, headers=headers)
-            
-            with urllib.request.urlopen(req, timeout=5) as response:
-                html = response.read().decode('utf-8', errors='ignore')
-                
-            soup = BeautifulSoup(html, 'html.parser')
-            
-            for script in soup(["script", "style"]):
-                script.decompose()
-            
-            text = soup.get_text()
-            
-            lines = (line.strip() for line in text.splitlines())
-            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
-            text = ' '.join(chunk for chunk in chunks if chunk)
-            
-            if len(text) > max_length:
-                text = text[:max_length] + "..."
-            
-            return text
-            
-        except Exception as e:
-            logger.error(f"URL 콘텐츠 가져오기 실패 {url}: {str(e)}")
-            return ""
-    
-    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:
-                            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"Best Practices for {query} - Source {i+1}",
-                    "description": f"Comprehensive guide on implementing {query} with proven methodologies and real-world examples from industry leaders.",
-                    "url": f"https://example{i+1}.com/{query.replace(' ', '-')}",
-                    "credibility_score": 0.7 + (i * 0.05)
-                })
-            return test_results
-        
-        try:
-            params = {
-                "q": query,
-                "count": 20,
-                "safesearch": "moderate",
-                "freshness": "pw"
-            }
-            
-            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 딕셔너리를 메서드 내부에 정의
-            test_responses = {
-                "supervisor_initial": """이 질문에 대한 거시적 분석을 제시하겠습니다.
-
-**1. 문제의 본질 파악**
-사용자는 실용적이고 즉시 적용 가능한 해결책을 원하고 있습니다. 단순한 이론이나 개념이 아닌, 실제로 구현 가능한 구체적인 방안이 필요합니다.
-
-**2. 전략적 프레임워크**
-- 단기 목표: 즉시 실행 가능한 quick win 솔루션 도출
-- 중기 목표: 지속 가능한 개선 체계 구축
-- 장기 목표: 혁신적 변화를 통한 경쟁 우위 확보
-
-**3. 제약사항 및 맥락**
-- 기존 리소스와 인프라 활용 극대화
-- 최소한의 투자로 최대 효과 달성
-- 실무진이 바로 이해하고 실행할 수 있는 수준
-
-**4. 성공 기준**
-- 측정 가능한 개선 지표 (30% 이상 향상)
-- 3개월 내 가시적 성과 달성
-- ROI 200% 이상 달성""",
-                
-                "creator": """혁신적인 아이디어를 제시하겠습니다.
-
-**🚀 아이디어 1: AI 기반 자동 최적화 시스템**
-- 독창성: 머신러닝이 스스로 시스템을 개선하는 자가 진화 시스템
-- 영향력: 인간 개입 없이 24/7 성능 향상, 90% 효율성 증가 가능
-- 필요 리소스: 클라우드 컴퓨팅, ML 엔지니어 1명
-- 실현 가능성: 8/10
-
-**💡 아이디어 2: 크라우드소싱 혁신 플랫폼**
-- 독창성: 전 직원이 참여하는 실시간 개선 아이디어 시장
-- 영향력: 집단 지성 활용으로 혁신 속도 10배 가속
-- 필요 리소스: 웹 플랫폼, 인센티브 예산
-- 실현 가능성: 9/10
-
-**🔄 아이디어 3: 디지털 트윈 시뮬레이션**
-- 독창성: 가상 환경에서 모든 시나리오를 사전 테스트
-- 영향력: 리스크 80% 감소, 실패 비용 제로화
-- 필요 리소스: 시뮬레이션 소프트웨어, 데이터 분석가
-- 실현 가능성: 7/10
-
-**🌐 아이디어 4: 블록체인 기반 프로세스 자동화**
-- 독창성: 신뢰 기반 자동 실행 스마트 컨트랙트
-- 영향력: 중개 비용 제거, 처리 시간 95% 단축
-- 필요 리소스: 블록체인 개발자, 네트워크 인프라
-- 실현 가능성: 6/10
-
-**🧬 아이디어 5: 생체모방 알고리즘 적용**
-- 독창성: 자연의 최적화 원리를 비즈니스에 적용
-- 영향력: 예측 불가능한 환경에서도 적응력 극대화
-- 필요 리소스: R&D 팀, 실험 환경
-- 실현 가능성: 5/10
-
-**시너지 효과**
-아이디어 1+2 결합: AI가 크라우드소싱 아이디어를 자동 평가하고 구현
-아이디어 3+4 결합: 블록체인으로 검증된 디지털 트윈 결과 자동 실행""",
-                
-                "supervisor_ideation_review": """창조자 AI의 아이디어를 검토한 결과입니다.
-
-**전략적 평가**
-1. AI 기반 자동 최적화 시스템 - ⭐⭐⭐⭐⭐
-   - 즉시 실행 가능하고 ROI가 명확함
-   - 기존 인프라 활용 가능
-
-2. 크라우드소싱 혁신 플랫폼 - ⭐⭐⭐⭐⭐
-   - 조직 문화 개선과 혁신 동시 달성
-   - 빠른 구현과 낮은 리스크
-
-3. 디지털 트윈 시뮬레이션 - ⭐⭐⭐⭐
-   - 중장기적 가치가 높음
-   - 초기 투자 대비 효과 검증 필요
-
-**선별된 아이디어**
-1, 2, 3번 아이디어를 중심으로 진행 권장
-
-**조사 필요 사항**
-- 성공 사례와 구현 방법론
-- 필요 기술 스택과 도구
-- 예상 비용과 ROI 데이터
-- 산업별 적용 사례
-
-[검색 키워드]: AI automation implementation case studies, crowdsourcing innovation platform examples, digital twin ROI analysis, machine learning optimization tools, employee innovation engagement systems""",
-                
-                "researcher": """조사 결과를 종합하여 보고합니다.
-
-**1. AI 자동 최적화 시스템 구현 사례 (신뢰도 0.92)**
-- Google: AutoML로 모델 성능 40% 개선, 개발 시간 90% 단축
-- Netflix: 실시간 최적화로 스트리밍 품질 35% 향상
-- 구현 도구: TensorFlow Extended, AutoKeras, H2O.ai
-- 평균 ROI: 6개월 내 250%
-- 출처: Google AI Blog, Netflix Tech Blog
-
-**2. 크라우드소싱 혁신 플랫폼 성공 사례 (신뢰도 0.88)**
-- P&G Connect+Develop: 외부 혁신으로 R&D 생산성 60% 향상
-- Lego Ideas: 고객 아이디어로 신제품 출시 주기 50% 단축
-- 플랫폼: IdeaScale, Brightidea, Spigit
-- 평균 참여율: 직원의 75%
-- 출처: Harvard Business Review, MIT Sloan Review
-
-**3. 디지털 트윈 ROI 분석 (신뢰도 0.85)**
-- GE: 예측 정비로 다운타임 20% 감소, 연간 $1.6B 절감
-- Siemens: 제품 개발 주기 50% 단축
-- 필요 기술: Azure Digital Twins, AWS IoT TwinMaker
-- 초기 투자 회수: 평균 18개월
-- 출처: Gartner Report 2024, IDC Research
-
-**4. 실제 구현 가이드 (신뢰도 0.90)**
-- 단계별 구현 로드맵 확보
-- 오픈소스 도구 목록 및 비용 분석
-- 필요 인력: 프로젝트당 3-5명
-- 구현 기간: 3-6개월
-
-**5. 최신 트렌드 (신뢰도 0.87)**
-- 2024년 AI 자동화가 주류�� 부상
-- Low-code/No-code 플랫폼으로 진입 장벽 낮아짐
-- Edge AI로 실시간 최적화 가능
-- 출처: McKinsey Digital Report 2024
-
-**핵심 인사이트**
-- 세 가지 아이디어 모두 검증된 성공 사례 존재
-- 투자 대비 효과가 명확히 입증됨
-- 기술적 구현 장벽이 낮아지고 있음
-- 빠른 실행이 경쟁 우위의 핵심""",
-                
-                "evaluator_research": """조사 결과를 객관적으로 평가합니다.
-
-**실현 가능성 평가**
-1. AI 자동 최적화 시스템: 9/10
-   - 근거: 다수의 성공 사례, 명확한 ROI, 기술 성숙도 높음
-   - 리스크: 초기 데이터 품질, 내부 저항
-   - ROI 예측: 6개월 내 250% (조사 결과 검증됨)
-
-2. 크라우드소싱 혁신 플랫폼: 9/10
-   - 근거: 즉시 구현 가능, 낮은 기술 장벽
-   - 리스크: 참여도 저하, 아이디어 품질 관리
-   - ROI 예측: 1년 내 180%
-
-3. 디지털 트윈: 7/10
-   - 근거: 높은 잠재력, 장기적 가치
-   - 리스크: 초기 투자 규모, 기술 복잡도
-   - ROI 예측: 18개월 내 200%
-
-**조사 신뢰성 평가**
-- 출처 신뢰도: 평균 0.88 (매우 높음)
-- 정보 충분성: 85% (실행에 충분)
-- 추가 필요 정보: 산업별 세부 사례, 실패 요인 분석
-
-**최종 추천**
-1순위: AI 자동 최적화 + 크라우드소싱 통합 접근
-- 두 방안을 결합하여 시너지 극대화
-- 단계적 구현으로 리스크 최소화
-- 3개월 내 가시적 성과 가능
-
-2순위: 디지털 트윈 (중장기 프로젝트로 병행)""",
-                
-                "supervisor_execution": """평가 결과를 바탕으로 구체적인 실행 지시를 내립니다.
-
-**통합 실행 전략**
-AI 자동 최적화와 크라우드소싱을 결합한 "지능형 혁신 시스템" 구축
-
-**1단계: 기반 구축 (1-2주차)**
-- AI 자동 최적화 파일럿 프로젝트 선정
-- 크라우드소싱 플랫폼 도구 선정 (IdeaScale 추천)
-- 프로젝트팀 구성: PM 1명, ML 엔지니어 2명, 플랫폼 관리자 1명
-- 초기 예산: $50,000
-
-**2단계: 파일럿 실행 (3-6주차)**
-- 선정 부서에서 AI 최적화 테스트
-- 전사 아이디어 공모 시작
-- 주간 성과 측정 및 조정
-- 리스크: 데이터 품질 → 대응: 데이터 정제 자동화
-
-**3단계: 통합 및 확장 (7-12주차)**
-- AI가 크라우드소싱 아이디어 자동 평가
-- 최우수 아이디어 자동 시뮬레이션
-- 단계적 전사 확대
-- 성과 지표: 효율성 30% 향상, 혁신 아이디어 100개/월
-
-**리스크 대응 계획**
-- 기술적 문제: 24/7 모니터링, 롤백 계획
-- 참여 저조: 게임화, 인센티브 강화
-- 품질 이슈: AI 기반 품질 검증
-
-**성과 측정**
-- 주간: 시스템 성능, 참여율
-- 월간: ROI, 혁신 지표
-- 분기: 전략적 영향 평가""",
-                
-                "executor": """즉시 실행 가능한 구체적 계획을 제시합니다.
-
-**🚀 1주차: 킥오프 및 환경 구축**
-
-월요일-화요일: 프로젝트팀 구성 및 환경 설정
-```python
-# AI 최적화 환경 설정 스크립트
-import tensorflow as tf
-from tensorflow import keras
-import autokeras as ak
-
-# 자동 최적화 파이프라인 설정
-class AutoOptimizer:
-    def __init__(self):
-        self.model = ak.AutoModel(
-            project_name='auto_optimization',
-            max_trials=100
-        )
-    
-    def optimize(self, data):
-        # 자동 하이퍼파라미터 튜닝
-        self.model.fit(data['X'], data['y'])
-        return self.model.evaluate(data['X_test'], data['y_test'])
-```
-
-수요일-금요일: 크라우드소싱 플랫폼 구축
-- IdeaScale 계정 설정 및 커스터마이징
-- 직원 온보딩 자료 작성
-- 평가 기준 및 보상 체계 수립
-
-**📊 2-3주차: 파일럿 프로그램 실행**
-
-데이터 수집 및 AI 모델 훈련:
-```python
-# 실시간 성능 모니터링 대시보드
-import dash
-import plotly.graph_objs as go
-
-app = dash.Dash(__name__)
-app.layout = html.Div([
-    dcc.Graph(id='live-performance'),
-    dcc.Interval(id='graph-update', interval=1000)
-])
-
-@app.callback(Output('live-performance', 'figure'),
-              [Input('graph-update', 'n_intervals')])
-def update_metrics(n):
-    # 실시간 성능 지표 업데이트
-    return create_performance_dashboard()
-```
-
-크라우드소싱 캠페인 런칭:
-- 첫 주 챌린지: "효율성 10% 개선 아이디어"
-- 일일 리더보드 및 포인트 시스템
-- AI 자동 아이디어 분류 및 초기 평가
-
-**🔧 4-6주차: 통합 시스템 구현**
-
-AI-크라우드소싱 통합 모듈:
-```python
-class InnovationEngine:
-    def __init__(self):
-        self.ai_evaluator = AIIdeaEvaluator()
-        self.crowd_platform = CrowdsourcingPlatform()
-    
-    def process_idea(self, idea):
-        # 1. AI 초기 평가
-        score = self.ai_evaluator.evaluate(idea)
-        
-        # 2. 유망 아이디어 자동 시뮬레이션
-        if score > 0.7:
-            simulation_result = self.run_simulation(idea)
-            
-        # 3. 실행 우선순위 자동 배정
-        return self.prioritize_execution(idea, score, simulation_result)
-```
-
-**📈 예상 산출물**
-1. 구동 가능한 AI 최적화 시스템
-2. 활성화된 크라우드소싱 플랫폼  
-3. 통합 대시보드 및 분석 도구
-4. 첫 달 목표: 50개 아이디어, 5개 구현, 15% 효율성 개선""",
-                
-                "evaluator_execution": """실행 계획을 평가합니다.
-
-**계획 완성도: 8.5/10**
-
-**강점**
-- 즉시 실행 가능한 코드와 구체적 일정 제공
-- 단계별 명확한 목표와 산출물 정의
-- 기술 스택이 검증되고 실용적임
-
-**개선 필요사항**
-1. 데이터 보안 및 프라이버시 대책 미흡
-   - 추가 필요: GDPR 준수 체크리스트, 데이터 암호화 방안
-
-2. 변화 관리 계획 부족
-   - 추가 필요: 직원 교육 프로그램, 저항 관리 전략
-
-3. 백업 및 복구 계획 누락
-   - 추가 필요: 시스템 장애 시 BCP, 데이터 백업 주기
-
-**실행 상 예상 문제점**
-1. 초기 데이터 부족 → 해결: 합성 데이터 생성 또는 전이학습
-2. 직원 참여 저조 → 해결: 챔피언 그룹 육성, 조기 성공 사례 홍보
-3. 기술 통합 복잡도 → 해결: 마이크로서비스 아키텍처 채택
-
-**추가 제안**
-- A/B 테스트 프레임워크 구축
-- 실패 시 빠른 피벗을 위한 의사결정 체계
-- 외부 전문가 자문단 구성
-- 경쟁사 벤치마킹 정기 실시
-
-**품질 기준**
-- 코드 커버리지 80% 이상
-- 응답 시간 200ms 이하
-- 시스템 가용성 99.9%
-- 사용자 만족도 4.5/5 이상""",
-                
-                "supervisor_final": """평가를 바탕으로 최종 개선 지시를 내립니다.
-
-**필수 보완 사항**
-
-1. **보안 및 컴플라이언스 강화**
-   - GDPR/CCPA 준수 체크리스트 즉시 작성
-   - 전체 데이터 플로우 암호화 구현
-   - 접근 권한 관리 시스템 구축
-
-2. **변화 관리 프로그램 추가**
-   - 1주차에 전직원 타운홀 미팅 실시
-   - 부서별 챔피언 선정 및 인센티브 제공
-   - 주간 성공 사례 공유 세션 운영
-
-3. **리스크 관리 체계 구축**
-   - 24/7 모니터링 대시보드 구현
-   - 자동 롤백 시스템 구축
-   - 핫라인 및 긴급 대응팀 구성
-
-**품질 보증 요구사항**
-- 모든 코드는 peer review 필수
-- 자동화된 테스트 커버리지 85% 이상
-- 일일 스탠드업으로 진행상황 체크
-
-**성공을 위한 핵심 요소**
-1. 경영진의 visible한 지원과 참여
-2. Quick win 사례를 통한 모멘텀 구축
-3. 지속적인 개선과 빠른 피드백 루프
-4. 투명한 성과 공유와 보상
-
-**최종 목표**
-- 3개월 내 ROI 150% 달성
-- 직원 참여율 80% 이상
-- 시스템 안정성 99.9% 유지""",
-                
-                "executor_final": """모든 피드백을 완전히 반영하여 최종 실행 가능 솔루션입니다.
-
-# 🎯 지능형 혁신 시스템 구축 - 최종 실행 가이드
-
-## 📋 Executive Summary
-AI 자동 최적화와 크라우드소싱을 통합한 혁신 시스템으로 3개월 내 효율성 30% 향상, ROI 150% 달성을 목표로 합니다.
-
-## 🚀 1주차: 보안 강화된 프로젝트 시작
-
-### Day 1-2: 킥오프 및 보안 체계 구축
-```python
-# 보안 강화된 데이터 처리 파이프라인
-from cryptography.fernet import Fernet
-import hashlib
-from datetime import datetime
-
-class SecureDataPipeline:
-    def __init__(self):
-        self.key = Fernet.generate_key()
-        self.cipher = Fernet(self.key)
-        self.audit_log = []
-    
-    def process_data(self, data, user_id):
-        # GDPR 준수 암호화
-        encrypted = self.cipher.encrypt(data.encode())
-        
-        # 감사 로그
-        self.audit_log.append({
-            'user': user_id,
-            'action': 'data_process',
-            'timestamp': datetime.now(),
-            'data_hash': hashlib.sha256(data.encode()).hexdigest()
-        })
-        
-        return self.run_optimization(encrypted)
-    
-    def run_optimization(self, encrypted_data):
-        # 암호화된 상태에서 처리
-        decrypted = self.cipher.decrypt(encrypted_data)
-        # AI 최적화 로직
-        return optimized_result
-```
-
-### Day 3: 전직원 타운홀 미팅
-**어젠다 (1시간)**
-1. 비전 공유: CEO 발표 (10분)
-2. 시스템 소개: 프로젝트 리더 (20분)
-3. 혜택 설명: 직원 관점에서 (15분)
-4. Q&A 및 피드백 (15분)
-
-**변화 관리 자료**
-```markdown
-# 직원을 위한 혁신 시스템 가이드
-
-## 당신에게 주는 혜택
-✅ 아이디어가 즉시 실행됩니다
-✅ 기여도에 따른 명확한 보상
-✅ 반복 업무 자동화로 창의적 업무 집중
-✅ 실시간 성과 확인 가능
-
-## 참여 방법 (3단계)
-1. 플랫폼 로그인 → 아이디어 제출
-2. AI가 자동 평가 → 24시간 �� 피드백
-3. 실행 및 보상 → 포인트/보너스 지급
-```
-
-### Day 4-5: 기술 인프라 구축
-```python
-# 통합 모니터링 대시보드
-import dash
-import plotly.graph_objs as go
-from dash import dcc, html, Input, Output
-import pandas as pd
-
-class MonitoringDashboard:
-    def __init__(self):
-        self.app = dash.Dash(__name__)
-        self.setup_layout()
-        self.setup_callbacks()
-    
-    def setup_layout(self):
-        self.app.layout = html.Div([
-            html.H1("지능형 혁신 시스템 대시보드"),
-            
-            # 실시간 KPI
-            html.Div([
-                dcc.Graph(id='efficiency-gauge'),
-                dcc.Graph(id='participation-rate'),
-                dcc.Graph(id='roi-tracker'),
-                dcc.Graph(id='system-health')
-            ], style={'display': 'flex'}),
-            
-            # 알림 시스템
-            html.Div(id='alerts', className='alert-box'),
-            
-            # 자동 업데이트
-            dcc.Interval(id='interval', interval=5000)
-        ])
-    
-    def setup_callbacks(self):
-        @self.app.callback(
-            [Output('efficiency-gauge', 'figure'),
-             Output('alerts', 'children')],
-            [Input('interval', 'n_intervals')]
-        )
-        def update_dashboard(n):
-            # 실시간 메트릭 수집
-            metrics = self.collect_metrics()
-            
-            # 임계값 체크 및 알림
-            alerts = self.check_thresholds(metrics)
-            
-            return self.create_gauge(metrics['efficiency']), alerts
-```
-
-## 📊 2-3주차: 스마트 파일럿 프로그램
-
-### 크라우드소싱 게임화 시스템
-```python
-class GamificationEngine:
-    def __init__(self):
-        self.levels = {
-            'Novice': 0,
-            'Contributor': 100,
-            'Innovator': 500,
-            'Champion': 1000,
-            'Legend': 5000
-        }
-        self.badges = {
-            'first_idea': '첫 아이디어',
-            'week_streak': '주간 연속 참여',
-            'top_rated': '최고 평점',
-            'implemented': '아이디어 실행됨'
-        }
-    
-    def process_contribution(self, user_id, idea):
-        points = self.calculate_points(idea)
-        badges = self.check_badges(user_id, idea)
-        level_up = self.check_level_up(user_id, points)
-        
-        # 실시간 알림
-        if level_up:
-            self.notify_achievement(user_id, level_up)
-        
-        return {
-            'points': points,
-            'badges': badges,
-            'level': self.get_user_level(user_id),
-            'ranking': self.get_ranking(user_id)
-        }
-```
-
-### AI 평가 및 시뮬레이션 엔진
-```python
-class AIInnovationEvaluator:
-    def __init__(self):
-        self.models = {
-            'feasibility': self.load_model('feasibility_model.h5'),
-            'impact': self.load_model('impact_model.h5'),
-            'cost': self.load_model('cost_model.h5')
-        }
-    
-    def evaluate_idea(self, idea_text, metadata):
-        # NLP 처리
-        features = self.extract_features(idea_text)
-        
-        # 다차원 평가
-        scores = {
-            'feasibility': self.models['feasibility'].predict(features),
-            'impact': self.models['impact'].predict(features),
-            'cost_efficiency': self.models['cost'].predict(features),
-            'innovation_index': self.calculate_innovation(features)
-        }
-        
-        # 자동 시뮬레이션 트리거
-        if scores['feasibility'] > 0.7 and scores['impact'] > 0.8:
-            simulation_result = self.run_simulation(idea_text, metadata)
-            scores['simulation'] = simulation_result
-        
-        return self.generate_report(scores, idea_text)
-```
-
-## 🔧 4-6주차: 고급 통합 및 최적화
-
-### 자동 실행 파이프라인
-```python
-class AutoExecutionPipeline:
-    def __init__(self):
-        self.executor = TaskExecutor()
-        self.validator = ResultValidator()
-        self.rollback = RollbackManager()
-    
-    def execute_approved_idea(self, idea_id):
-        try:
-            # 실행 계획 생성
-            plan = self.create_execution_plan(idea_id)
-            
-            # 단계별 실행 with 체크포인트
-            for step in plan.steps:
-                result = self.executor.execute(step)
-                
-                if not self.validator.validate(result):
-                    self.rollback.restore_checkpoint(step.checkpoint)
-                    return self.handle_failure(step, result)
-                
-                # 실시간 진행상황 업데이트
-                self.update_progress(idea_id, step.completion_rate)
-            
-            return self.finalize_execution(idea_id)
-            
-        except Exception as e:
-            self.emergency_rollback(idea_id)
-            self.alert_team(e)
-```
-
-### 지속적 개선 시스템
-```python
-class ContinuousImprovement:
-    def __init__(self):
-        self.ml_pipeline = MLPipeline()
-        self.feedback_loop = FeedbackLoop()
-        
-    def daily_optimization(self):
-        # 매일 자정 실행
-        performance_data = self.collect_daily_metrics()
-        
-        # 모델 재훈련
-        self.ml_pipeline.retrain(performance_data)
-        
-        # A/B 테스트 자동 설정
-        experiments = self.design_experiments(performance_data)
-        
-        for exp in experiments:
-            self.run_ab_test(exp)
-        
-        # 인사이트 생성
-        insights = self.generate_insights(performance_data)
-        self.distribute_report(insights)
-```
-
-## 📈 성과 측정 및 보고 체계
-
-### 실시간 KPI 대시보드
-```python
-kpi_metrics = {
-    'efficiency_gain': {
-        'current': 0,
-        'target': 30,
-        'unit': '%'
-    },
-    'participation_rate': {
-        'current': 0,
-        'target': 80,
-        'unit': '%'
-    },
-    'ideas_per_month': {
-        'current': 0,
-        'target': 100,
-        'unit': 'count'
-    },
-    'roi': {
-        'current': 0,
-        'target': 150,
-        'unit': '%'
-    },
-    'system_uptime': {
-        'current': 0,
-        'target': 99.9,
-        'unit': '%'
-    }
-}
-
-# 자동 보고서 생성
-def generate_weekly_report():
-    report = f\"\"\"
-    # 주간 성과 보고서 - {datetime.now().strftime('%Y-%m-%d')}
-    
-    ## 핵심 성과
-    - 효율성 향상: {kpi_metrics['efficiency_gain']['current']}%
-    - 직원 참여율: {kpi_metrics['participation_rate']['current']}%
-    - 제출된 아이디어: {kpi_metrics['ideas_per_month']['current']}개
-    - ROI: {kpi_metrics['roi']['current']}%
-    
-    ## 주요 성공 사례
-    {get_success_stories()}
-    
-    ## 다음 주 계획
-    {get_next_week_plan()}
-    \"\"\"
-    return report
-```
-
-## 🛡️ 리스크 관리 및 비상 계획
-
-### 자동 백업 및 복구
-```bash
-#!/bin/bash
-# 시간별 자동 백업 스크립트
-BACKUP_DIR="/secure/backups/$(date +%Y%m%d)"
-mkdir -p $BACKUP_DIR
-
-# 데이터베이스 백업
-pg_dump -U postgres innovation_db > $BACKUP_DIR/db_backup_$(date +%H%M).sql
-
-# 애플리케이션 상태 백업
-kubectl get all --all-namespaces -o yaml > $BACKUP_DIR/k8s_state_$(date +%H%M).yaml
-
-# S3 업로드 (암호화)
-aws s3 cp $BACKUP_DIR s3://innovation-backups/ --recursive --sse
-```
-
-### 24/7 모니터링 및 알림
-```python
-class AlertingSystem:
-    def __init__(self):
-        self.thresholds = {
-            'response_time': 200,  # ms
-            'error_rate': 0.01,    # 1%
-            'cpu_usage': 80,       # %
-            'participation_drop': 20  # %
-        }
-        
-    def monitor(self):
-        while True:
-            metrics = self.collect_metrics()
-            
-            for metric, value in metrics.items():
-                if self.is_threshold_breached(metric, value):
-                    self.trigger_alert(metric, value)
-                    self.auto_remediate(metric)
-            
-            time.sleep(60)  # 1분마다 체크
-```
-
-## 🎯 최종 체크리스트
-
-### Week 1 완료 사항
-- [ ] 보안 인프라 구축 완료
-- [ ] 전직원 타운홀 미팅 실시
-- [ ] 챔피언 그룹 선정
-- [ ] 기본 시스템 배포
-
-### Week 2-3 완료 사항
-- [ ] 파일럿 부서 선정 및 시작
-- [ ] 첫 아이디어 캠페인 런칭
-- [ ] AI 평가 시스템 가동
-- [ ] 첫 quick win 달성
-
-### Week 4-6 완료 사항
-- [ ] 전사 확대 시작
-- [ ] 자동화 파이프라인 완성
-- [ ] KPI 목표 50% 달성
-- [ ] 첫 ROI 리포트 작성
-
-## 💡 성공을 위한 팁
-1. 매일 아침 5분 스탠드업 미팅
-2. 주간 성공 사례 전사 공유
-3. 월간 혁신 어워드 시상
-4. 분기별 해커톤 개최
-
----
-*이 시스템은 지속적으로 진화합니다. 피드백은 [email protected]으로!*"""
-            }
-            
-            # 역할과 프롬프트에 따라 적절한 응답 선택
-            if role == "supervisor" and "창조자 AI가 제시한" in messages[0]["content"]:
-                response = test_responses["supervisor_ideation_review"]
-            elif role == "supervisor" and "평가자 AI의 종합 평가" in messages[0]["content"]:
-                response = test_responses["supervisor_execution"]
-            elif role == "supervisor" and "평가자 AI의 실행 계획 평가" in messages[0]["content"]:
-                response = test_responses["supervisor_final"]
-            elif role == "supervisor":
-                response = test_responses["supervisor_initial"]
-            elif role == "creator":
-                response = test_responses["creator"]
-            elif role == "researcher":
-                response = test_responses["researcher"]
-            elif role == "evaluator" and "조사자 AI의 조사 결과" in messages[0]["content"]:
-                response = test_responses["evaluator_research"]
-            elif role == "evaluator":
-                response = test_responses["evaluator_execution"]
-            elif role == "executor" and "최종 솔루션" 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": "당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.",
-                "creator": "당신은 혁신적이고 창의적인 아이디어를 생성하는 창조자 AI입니다.",
-                "researcher": "당신은 정보를 조사하고 체계적으로 정리하는 조사자 AI입니다.",
-                "evaluator": "당신은 객관적이고 비판적인 시각으로 평가하는 평가자 AI입니다.",
-                "executor": "당신은 세부적인 내용을 구현하는 실행자 AI입니다."
-            }
-            
-            full_messages = [
-                {"role": "system", "content": system_prompts.get(role, "")},
-                *messages
-            ]
-            
-            payload = {
-                "model": self.model_id,
-                "messages": full_messages,
-                "max_tokens": 2048,
-                "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)}"
-
-# 시스템 인스턴스 생성
-llm_system = LLMCollaborativeSystem()
-
-# 내부 히스토리 관리
-internal_history = []
-
-def process_query_streaming(user_query: str):
-    """향상된 협업 프로세스를 통한 쿼리 처리"""
-    global internal_history
-    
-    if not user_query:
-        return "", "", "", "", "", "❌ 질문을 입력해주세요."
-    
-    all_responses = {
-        "supervisor": [],
-        "creator": [],
-        "researcher": [],
-        "evaluator": [],
-        "executor": []
-    }
-    
+def main():
     try:
-        # 1단계: 감독자 AI 초기 분석
-        supervisor_prompt = llm_system.create_supervisor_initial_prompt(user_query)
-        supervisor_initial_response = ""
-        
-        supervisor_text = "[초기 분석] 🔄 생성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": supervisor_prompt}], 
-            "supervisor"
-        ):
-            supervisor_initial_response += chunk
-            supervisor_text = f"[초기 분석] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_initial_response}"
-            yield supervisor_text, "", "", "", "", "🔄 감독자 AI가 분석 중..."
-        
-        all_responses["supervisor"].append(supervisor_initial_response)
-        
-        # 2단계: 창조자 AI 혁신적 아이디어 생성
-        creator_prompt = llm_system.create_creator_prompt(user_query, supervisor_initial_response)
-        creator_response = ""
-        
-        creator_text = "[혁신 아이디어] 🔄 생성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": creator_prompt}], 
-            "creator"
-        ):
-            creator_response += chunk
-            creator_text = f"[혁신 아이디어] - {datetime.now().strftime('%H:%M:%S')}\n{creator_response}"
-            yield supervisor_text, creator_text, "", "", "", "💡 창조자 AI가 아이디어 생성 중..."
+        # Get the code from secrets
+        code = os.environ.get("MAIN_CODE")
         
-        all_responses["creator"].append(creator_response)
-        
-        # 3단계: 감독자 AI 아이디어 검토 및 조사 지시
-        supervisor_review_prompt = llm_system.create_supervisor_ideation_review_prompt(user_query, creator_response)
-        supervisor_review_response = ""
-        
-        supervisor_text += "\n\n---\n\n[아이디어 검토] 🔄 생성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": supervisor_review_prompt}], 
-            "supervisor"
-        ):
-            supervisor_review_response += chunk
-            temp_text = f"{all_responses['supervisor'][0]}\n\n---\n\n[아이디어 검토] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_review_response}"
-            supervisor_text = f"[초기 분석] - {datetime.now().strftime('%H:%M:%S')}\n{temp_text}"
-            yield supervisor_text, creator_text, "", "", "", "🎯 감독자 AI가 검토 중..."
-        
-        all_responses["supervisor"].append(supervisor_review_response)
-        
-        # 키워드 추출
-        keywords = llm_system.extract_keywords(supervisor_review_response)
-        logger.info(f"추출된 키워드: {keywords}")
+        if not code:
+            st.error("⚠️ The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+            return
         
-        # 4단계: 브레이브 검색 수행
-        researcher_text = "[웹 검색] 🔍 검색 중...\n"
-        yield supervisor_text, creator_text, researcher_text, "", "", "🔍 웹 검색 수행 중..."
+        # Create a temporary Python file
+        with NamedTemporaryFile(suffix='.py', delete=False, mode='w') as tmp:
+            tmp.write(code)
+            tmp_path = tmp.name
         
-        search_results = {}
-        total_search_count = 0
+        # Execute the code
+        exec(compile(code, tmp_path, 'exec'), globals())
         
-        for keyword in keywords:
-            results = llm_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, creator_text, researcher_text, "", "", f"🔍 '{keyword}' 검색 중..."
+        # Clean up the temporary file
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
             
-            synonyms = llm_system.generate_synonyms(keyword)
-            for synonym in synonyms:
-                syn_results = llm_system.brave_search(f"{keyword} {synonym}")
-                if syn_results:
-                    search_results[f"{keyword} ({synonym})"] = syn_results
-                    total_search_count += len(syn_results)
-                    researcher_text += f"✓ 동의어 '{synonym}' 검색 완료 ({len(syn_results)}개 결과)\n"
-                    yield supervisor_text, creator_text, researcher_text, "", "", f"🔍 동의어 '{synonym}' 검색 중..."
-        
-        researcher_text += f"\n📊 총 {total_search_count}개의 검색 결과 수집 완료\n"
-        
-        # 5단계: 조사자 AI가 검색 결과 정리
-        researcher_prompt = llm_system.create_researcher_prompt(user_query, supervisor_review_response, search_results)
-        researcher_response = ""
-        
-        researcher_text = "[조사 결과 정리] 🔄 생성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": researcher_prompt}], 
-            "researcher"
-        ):
-            researcher_response += chunk
-            researcher_text = f"[조사 결과 정리] - {datetime.now().strftime('%H:%M:%S')}\n{researcher_response}"
-            yield supervisor_text, creator_text, researcher_text, "", "", "📝 조사자 AI가 정리 중..."
-        
-        all_responses["researcher"].append(researcher_response)
-        
-        # 6단계: 평가자 AI가 조사 결과 평가
-        evaluator_research_prompt = llm_system.create_evaluator_research_prompt(
-            user_query, creator_response, researcher_response
-        )
-        evaluator_research_response = ""
-        
-        evaluator_text = "[조사 결과 평가] 🔄 생성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": evaluator_research_prompt}], 
-            "evaluator"
-        ):
-            evaluator_research_response += chunk
-            evaluator_text = f"[조사 결과 평가] - {datetime.now().strftime('%H:%M:%S')}\n{evaluator_research_response}"
-            yield supervisor_text, creator_text, researcher_text, evaluator_text, "", "⚖️ 평가자 AI가 평�� 중..."
-        
-        all_responses["evaluator"].append(evaluator_research_response)
-        
-        # 7단계: 감독자 AI가 실행 지시
-        supervisor_execution_prompt = llm_system.create_supervisor_execution_prompt(
-            user_query, evaluator_research_response
-        )
-        supervisor_execution_response = ""
-        
-        supervisor_text = f"{all_responses['supervisor'][0]}\n\n---\n\n[아이디어 검토] - {datetime.now().strftime('%H:%M:%S')}\n{all_responses['supervisor'][1]}\n\n---\n\n[실행 지시] 🔄 생성 중...\n"
-        for chunk in llm_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[아이디어 검토] - {datetime.now().strftime('%H:%M:%S')}\n{all_responses['supervisor'][1]}\n\n---\n\n[실행 지시] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_execution_response}"
-            supervisor_text = f"[초기 분석] - {datetime.now().strftime('%H:%M:%S')}\n{temp_text}"
-            yield supervisor_text, creator_text, researcher_text, evaluator_text, "", "🎯 감독자 AI가 지시 중..."
-        
-        all_responses["supervisor"].append(supervisor_execution_response)
-        
-        # 8단계: 실행자 AI가 초기 실행 계획 수립
-        full_context = f"""
-창조자 AI의 아이디어:
-{creator_response}
-
-조사자 AI의 조사 결과:
-{researcher_response}
-
-평가자 AI의 평가:
-{evaluator_research_response}
-"""
-        
-        executor_prompt = llm_system.create_executor_prompt(
-            user_query, supervisor_execution_response, full_context
-        )
-        executor_response = ""
-        
-        executor_text = "[초기 실행 계획] 🔄 생성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": executor_prompt}], 
-            "executor"
-        ):
-            executor_response += chunk
-            executor_text = f"[초기 실행 계획] - {datetime.now().strftime('%H:%M:%S')}\n{executor_response}"
-            yield supervisor_text, creator_text, researcher_text, evaluator_text, executor_text, "🔧 실행자 AI가 계획 중..."
-        
-        all_responses["executor"].append(executor_response)
-        
-        # 9단계: 평가자 AI가 실행 계획 평가
-        evaluator_execution_prompt = llm_system.create_evaluator_execution_prompt(
-            user_query, executor_response
-        )
-        evaluator_execution_response = ""
-        
-        evaluator_text += "\n\n---\n\n[실행 계획 평가] 🔄 생성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": evaluator_execution_prompt}], 
-            "evaluator"
-        ):
-            evaluator_execution_response += chunk
-            temp_text = f"{all_responses['evaluator'][0]}\n\n---\n\n[실행 계획 평가] - {datetime.now().strftime('%H:%M:%S')}\n{evaluator_execution_response}"
-            evaluator_text = f"[조사 결과 평가] - {datetime.now().strftime('%H:%M:%S')}\n{temp_text}"
-            yield supervisor_text, creator_text, researcher_text, evaluator_text, executor_text, "⚖️ 평가자 AI가 검증 중..."
-        
-        all_responses["evaluator"].append(evaluator_execution_response)
-        
-        # 10단계: 감독자 AI 최종 지시
-        supervisor_final_prompt = llm_system.create_supervisor_final_prompt(
-            user_query, evaluator_execution_response
-        )
-        supervisor_final_response = ""
-        
-        supervisor_text = f"{all_responses['supervisor'][0]}\n\n---\n\n[아이디어 검토] - {datetime.now().strftime('%H:%M:%S')}\n{all_responses['supervisor'][1]}\n\n---\n\n[실행 지시] - {datetime.now().strftime('%H:%M:%S')}\n{all_responses['supervisor'][2]}\n\n---\n\n[최종 지시] 🔄 생성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": supervisor_final_prompt}], 
-            "supervisor"
-        ):
-            supervisor_final_response += chunk
-            temp_text = f"{all_responses['supervisor'][0]}\n\n---\n\n[아이디어 검토] - {datetime.now().strftime('%H:%M:%S')}\n{all_responses['supervisor'][1]}\n\n---\n\n[실행 지시] - {datetime.now().strftime('%H:%M:%S')}\n{all_responses['supervisor'][2]}\n\n---\n\n[최종 지시] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_final_response}"
-            supervisor_text = f"[초기 분석] - {datetime.now().strftime('%H:%M:%S')}\n{temp_text}"
-            yield supervisor_text, creator_text, researcher_text, evaluator_text, executor_text, "🎯 감독자 AI가 최종 검토 중..."
-        
-        all_responses["supervisor"].append(supervisor_final_response)
-        
-        # 11단계: 실행자 AI 최종 솔루션
-        executor_final_prompt = llm_system.create_executor_final_prompt(
-            user_query, executor_response, supervisor_final_response, full_context
-        )
-        final_executor_response = ""
-        
-        executor_text += "\n\n---\n\n[최종 실행 솔루션] 🔄 작성 중...\n"
-        for chunk in llm_system.call_llm_streaming(
-            [{"role": "user", "content": executor_final_prompt}], 
-            "executor"
-        ):
-            final_executor_response += chunk
-            temp_text = f"[초기 실행 계획] - {datetime.now().strftime('%H:%M:%S')}\n{all_responses['executor'][0]}\n\n---\n\n[최종 실행 솔루션] - {datetime.now().strftime('%H:%M:%S')}\n{final_executor_response}"
-            executor_text = temp_text
-            yield supervisor_text, creator_text, researcher_text, evaluator_text, executor_text, "📄 최종 솔루션 작성 중..."
-        
-        all_responses["executor"].append(final_executor_response)
-        
-        # 최종 결과 생성
-        final_summary = f"""## 🎯 최적화된 실용적 문제 해결 보고서
-
-### 📌 사용자 질문
-{user_query}
-
-### 🚀 최종 실행 솔루션
-{final_executor_response}
-
----
-
-<details>
-<summary>📋 전체 협력 프로세스 보기</summary>
-
-#### 1️⃣ 거시적 분석 (감독자 AI)
-{all_responses['supervisor'][0]}
-
-#### 2️⃣ 혁신적 아이디어 (창조자 AI)
-{all_responses['creator'][0]}
-
-#### 3️⃣ 아이디어 검토 및 조사 지시 (감독자 AI)
-{all_responses['supervisor'][1]}
-
-#### 4️⃣ 조사 결과 (조사자 AI)
-{all_responses['researcher'][0]}
-
-#### 5️⃣ 조사 결과 평가 (평가자 AI)
-{all_responses['evaluator'][0]}
-
-#### 6️⃣ 실행 지시 (감독자 AI)
-{all_responses['supervisor'][2]}
-
-#### 7️⃣ 초기 실행 계획 (실행자 AI)
-{all_responses['executor'][0]}
-
-#### 8️⃣ 실행 계획 평가 (평가자 AI)
-{all_responses['evaluator'][1]}
-
-#### 9️⃣ 최종 지시 (감독자 AI)
-{all_responses['supervisor'][3]}
-
-</details>
-
----
-*이 보고서는 5개 AI의 협력적 프로세스를 통해 최적화된 실용적 해결책을 제공합니다.*
-*프로세스: 감독 → 창조 → 감독 → 조사 → 평가 → 감독 → 실행 → 평가 → 감독 → 실행*"""
-        
-        internal_history.append((user_query, final_summary))
-        
-        # 최종 마크다운 반환
-        yield supervisor_text, creator_text, researcher_text, evaluator_text, executor_text, final_summary
-        
     except Exception as e:
-        error_msg = f"❌ 처리 중 오류: {str(e)}"
-        yield "", "", "", "", "", error_msg
-
-def clear_all():
-    """모든 내용 초기화"""
-    global internal_history
-    internal_history = []
-    return "", "", "", "", "", "🔄 초기화되었습니다."
-
-# Gradio 인터페이스
-css = """
-.gradio-container {
-    font-family: 'Arial', sans-serif;
-}
-.supervisor-box textarea {
-    border-left: 4px solid #667eea !important;
-    background-color: #f3f4f6 !important;
-}
-.creator-box textarea {
-    border-left: 4px solid #f59e0b !important;
-    background-color: #fffbeb !important;
-}
-.researcher-box textarea {
-    border-left: 4px solid #10b981 !important;
-    background-color: #ecfdf5 !important;
-}
-.evaluator-box textarea {
-    border-left: 4px solid #ef4444 !important;
-    background-color: #fef2f2 !important;
-}
-.executor-box textarea {
-    border-left: 4px solid #764ba2 !important;
-    background-color: #faf5ff !important;
-}
-"""
-
-with gr.Blocks(title="최적화된 협력적 LLM 시스템", theme=gr.themes.Soft(), css=css) as app:
-    gr.Markdown(
-        """
-        # 🚀 최적화된 최고의 실용적 문제 해결자
-        ### 5개 AI의 협력적 프로세스: 감독 → 창조 → 감독 → 조사 → 평가 → 감독 → 실행 → 평가 → 감독 → 실행
-        """
-    )
-    
-    # 입력 섹션
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("""
-            ## 🎯 향상된 기능
-            - **창조자 AI**: 혁신적이고 파괴적인 아이디어 생성
-            - **평가자 AI**: 객관적이고 비판적인 검증 및 평가
-            - **강화된 프로세스**: 11단계 협력적 문제 해결
-            - **실용성 극대화**: 즉시 실행 가능한 솔루션 제공
-            """)
-            
-            user_input = gr.Textbox(
-                label="질문 입력",
-                placeholder="예: 우리 회사의 고객 만족도를 획기적으로 향상시킬 수 있는 혁신적인 방법은?",
-                lines=3
-            )
-            
-            with gr.Row():
-                submit_btn = gr.Button("🚀 분석 시작", variant="primary", scale=2)
-                clear_btn = gr.Button("🗑️ 초기화", scale=1)
-            
-            status_text = gr.Textbox(
-                label="상태",
-                interactive=False,
-                value="대기 중...",
-                max_lines=1
-            )
-    
-    # 최종 결과 (상단에 크게 표시)
-    with gr.Row():
-        with gr.Column():
-            with gr.Accordion("📊 최��� 실행 솔루션", open=True):
-                final_output = gr.Markdown(
-                    value="*질문을 입력하면 최종 솔루션이 여기에 표시됩니다.*"
-                )
-    
-    # AI 출력들 - 2줄로 배치
-    # 첫 번째 줄: 감독자, 창조자, 조사자
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 🧠 감독자 AI (전략적 지휘)")
-            supervisor_output = gr.Textbox(
-                label="",
-                lines=15,
-                max_lines=20,
-                interactive=False,
-                elem_classes=["supervisor-box"]
-            )
-        
-        with gr.Column():
-            gr.Markdown("### 💡 창조자 AI (혁신적 아이디어)")
-            creator_output = gr.Textbox(
-                label="",
-                lines=15,
-                max_lines=20,
-                interactive=False,
-                elem_classes=["creator-box"]
-            )
-        
-        with gr.Column():
-            gr.Markdown("### 🔍 조사자 AI (정보 수집)")
-            researcher_output = gr.Textbox(
-                label="",
-                lines=15,
-                max_lines=20,
-                interactive=False,
-                elem_classes=["researcher-box"]
-            )
-    
-    # 두 번째 줄: 평가자, 실행자
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### ⚖️ 평가자 AI (객관적 평가)")
-            evaluator_output = gr.Textbox(
-                label="",
-                lines=15,
-                max_lines=20,
-                interactive=False,
-                elem_classes=["evaluator-box"]
-            )
-        
-        with gr.Column():
-            gr.Markdown("### 🔧 실행자 AI (실용적 구현)")
-            executor_output = gr.Textbox(
-                label="",
-                lines=15,
-                max_lines=20,
-                interactive=False,
-                elem_classes=["executor-box"]
-            )
-    
-    # 프로세스 다이어그램
-    gr.Markdown("""
-    ---
-    ### 🔄 협업 프로세스 흐름도
-    ```
-    사용자 질문
-         ↓
-    [1] 감독자 AI (초기 분석)
-         ↓
-    [2] 창조자 AI (혁신 아이디어)
-         ↓
-    [3] 감독자 AI (아이디어 검토)
-         ↓
-    [4] 조사자 AI (웹 검색 & 정리)
-         ↓
-    [5] 평가자 AI (조사 결과 평가)
-         ↓
-    [6] 감독자 AI (실행 지시)
-         ↓
-    [7] 실행자 AI (초기 계획)
-         ↓
-    [8] 평가자 AI (계획 평가)
-         ↓
-    [9] 감독자 AI (최종 지시)
-         ↓
-    [10] 실행자 AI (최종 솔루션)
-         ↓
-    최적화된 실용적 해결책
-    ```
-    """)
-    
-    # 예제
-    gr.Examples(
-        examples=[
-            "우리 회사의 고객 만족도를 획기적으로 향상시킬 수 있는 혁신적인 방법은?",
-            "원격 근무 환경에서 팀 생산성을 2배로 높이는 구체적인 전략은?",
-            "스타트업이 6개월 내에 수익을 3배 늘릴 수 있는 실행 가능한 방법은?",
-            "기존 제품을 완전히 혁신하여 시장을 선도할 수 있는 아이디어는?",
-            "AI를 활용해 운영 비용을 50% 절감하는 실질적인 방안은?"
-        ],
-        inputs=user_input,
-        label="💡 예제 질문"
-    )
-    
-    # 이벤트 핸들러
-    submit_btn.click(
-        fn=process_query_streaming,
-        inputs=[user_input],
-        outputs=[supervisor_output, creator_output, researcher_output, evaluator_output, executor_output, final_output]
-    ).then(
-        fn=lambda: "",
-        outputs=[user_input]
-    )
-    
-    user_input.submit(
-        fn=process_query_streaming,
-        inputs=[user_input],
-        outputs=[supervisor_output, creator_output, researcher_output, evaluator_output, executor_output, final_output]
-    ).then(
-        fn=lambda: "",
-        outputs=[user_input]
-    )
-    
-    clear_btn.click(
-        fn=clear_all,
-        outputs=[supervisor_output, creator_output, researcher_output, evaluator_output, executor_output, status_text]
-    )
+        st.error(f"⚠️ Error loading or executing the application: {str(e)}")
+        import traceback
+        st.code(traceback.format_exc())
 
 if __name__ == "__main__":
-    app.queue()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        show_error=True
-    )
+    main()