app.py

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

# 로깅 설정
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. 이 주제에 대해 조사가 필요한 5-7개의 구체적인 키워드나 검색어를 제시하세요

키워드는 다음 형식으로 제시하세요:
[검색 키워드]: 키워드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):  # 상위 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"""당신은 정보를 조사하고 정리하는 조사자 AI입니다.

사용자 질문: {user_query}

감독자 AI의 지침:
{supervisor_guidance}

브레이브 검색 결과 (신뢰도 점수 포함):
{search_summary}
{contradiction_text}

위 검색 결과를 바탕으로:
1. 각 키워드별로 중요한 정보를 정리하세요
2. 신뢰할 수 있는 출처(신뢰도 0.7 이상)를 우선적으로 참고하세요
3. 출처를 명확히 표기하여 실행자 AI가 검증할 수 있도록 하세요
4. 정보의 모순이 있다면 양쪽 관점을 모두 제시하세요
5. 최신 트렌드나 중요한 통계가 있다면 강조하세요
6. 신뢰도가 낮은 정보는 주의 표시와 함께 포함하세요"""
    
    def create_supervisor_execution_prompt(self, user_query: str, research_summary: str) -> str:
        """감독자 AI의 실행 지시 프롬프트"""
        return f"""당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.

사용자 질문: {user_query}

조사자 AI가 정리한 조사 내용:
{research_summary}

위 조사 내용을 기반으로 실행자 AI에게 아주 구체적인 지시를 내려주세요:
1. 조사된 정보를 어떻게 활용할지 명확히 지시하세요
2. 실행 가능한 단계별 작업을 구체적으로 제시하세요
3. 각 단계에서 참고해야 할 조사 내용을 명시하세요
4. 예상되는 결과물의 형태를 구체적으로 설명하세요"""
    
    def create_executor_prompt(self, user_query: str, supervisor_guidance: str, research_summary: str) -> str:
        """실행자 AI 프롬프트 생성"""
        return f"""당신은 세부적인 내용을 구현하는 실행자 AI입니다.

사용자 질문: {user_query}

조사자 AI가 정리한 조사 내용:
{research_summary}

감독자 AI의 구체적인 지시:
{supervisor_guidance}

위 조사 내용과 지시사항을 바탕으로:
1. 조사된 정보를 적극 활용하여 구체적인 실행 계획을 작성하세요
2. 각 단계별로 참고한 조사 내용을 명시하세요
3. 실제로 적용 가능한 구체적인 방법론을 제시하세요
4. 예상되는 성과와 측정 방법을 포함하세요"""
    
    def create_executor_final_prompt(self, user_query: str, initial_response: str, supervisor_feedback: str, research_summary: str) -> str:
        """실행자 AI 최종 보고서 프롬프트"""
        return f"""당신은 세부적인 내용을 구현하는 실행자 AI입니다.

사용자 질문: {user_query}

조사자 AI의 조사 내용:
{research_summary}

당신의 초기 답변:
{initial_response}

감독자 AI의 피드백 및 개선사항:
{supervisor_feedback}

위 피드백을 완전히 반영하여 최종 보고서를 작성하세요:
1. 감독자의 모든 개선사항을 반영하세요
2. 조사 내용을 더욱 구체적으로 활용하세요
3. 실행 가능성을 높이는 세부 계획을 포함하세요
4. 명확한 결론과 다음 단계를 제시하세요
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 = ["best practices", "implementation guide", "case studies", "latest trends", "success factors"]
        
        return keywords[:7]  # 최대 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", "사업", "업무", "작업"]
        }
        
        # 키워드 정규화
        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', '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
        
        # 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 fetch_url_content(self, url: str, max_length: int = 2000) -> str:
        """URL에서 콘텐츠 추출"""
        try:
            # User-Agent 설정
            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:  # 공통 단어가 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,  # 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": """이 질문에 대한 거시적 분석을 제시하겠습니다.

1. **핵심 개념 파악**
   - 질문의 본질적 요소를 심층 분석합니다
   - 관련된 주요 이론과 원칙을 검토합니다
   - 다양한 관점에서의 접근 방법을 고려합니다

2. **전략적 접근 방향**
   - 체계적이고 단계별 해결 방안을 수립합니다
   - 장단기 목표를 명확히 설정합니다
   - 리스크 요인과 대응 방안을 마련합니다

3. **기대 효과와 과제**
   - 예상되는 긍정적 성과를 분석합니다
   - 잠재적 도전 과제를 식별합니다
   - 지속가능한 발전 방향을 제시합니다

[검색 키워드]: machine learning optimization, performance improvement strategies, model efficiency techniques, hyperparameter tuning best practices, latest ML trends 2024""",
                
                "researcher": """조사 결과를 종합하여 다음과 같이 정리했습니다.

**1. Machine Learning Optimization (신뢰도 높음)**
- 최신 연구에 따르면 모델 최적화의 핵심은 아키텍처 설계와 훈련 전략의 균형입니다 (신뢰도: 0.85)
- AutoML 도구들이 하이퍼파라미터 튜닝을 자동화하여 효율성을 크게 향상시킵니다 (신뢰도: 0.82)
- 출처: ML Conference 2024 (https://mlconf2024.org), Google Research (https://research.google)
- 동의어 검색 결과: "ML improvement", "AI optimization"에서 추가 정보 확인

**2. Performance Improvement Strategies (신뢰도 높음)**
- 데이터 품질 개선이 모델 성능 향상의 80%를 차지한다는 연구 결과 (신뢰도: 0.90)
- 앙상블 기법과 전이학습이 주요 성능 개선 방법으로 입증됨 (신뢰도: 0.78)
- 출처: Stanford AI Lab (https://ai.stanford.edu), MIT CSAIL (https://csail.mit.edu)
- 벤치마크: ImageNet에서 95% 이상의 정확도 달성 사례

**3. Model Efficiency Techniques (신뢰도 중간)**
- 모델 경량화(Pruning, Quantization)로 추론 속도 10배 향상 가능 (신뢰도: 0.75)
- Knowledge Distillation으로 모델 크기 90% 감소, 성능 유지 (신뢰도: 0.72)
- 출처: ArXiv 논문 (https://arxiv.org/abs/2023.xxxxx)
- ⚠️ 주의: 일부 소스는 5-7배 향상만을 보고하여 정보 상충 존재

**4. 실제 적용 사례 (신뢰도 높음)**
- Netflix: 추천 시스템 개선으로 사용자 만족도 35% 향상 (신뢰도: 0.88)
- Tesla: 실시간 객체 인식 속도 50% 개선 (신뢰도: 0.80)
- OpenAI: GPT 모델 효율성 개선으로 비용 70% 절감 (신뢰도: 0.85)
- 출처: 각 기업 공식 블로그 및 기술 발표 자료

**발견된 정보 모순:**
1. 모델 압축률: 일부는 90% 압축 가능하다고 주장하나, 다른 소스는 70%가 한계라고 명시
2. 성능 향상 폭: 10배 vs 5-7배 향상에 대한 의견 차이 존재
3. 권장사항: 실제 적용 시 보수적인 수치(5-7배)를 기준으로 계획 수립 권장

**핵심 인사이트:**
- 최신 트렌드는 효율성과 성능의 균형에 초점
- 2024년 들어 Sparse Models와 MoE(Mixture of Experts) 기법이 부상
- 실무 적용 시 단계별 검증이 성공의 핵심""",
                
                "supervisor_execution": """조사 내용을 바탕으로 실행자 AI에게 다음과 같이 구체적으로 지시합니다.

**1단계: 현재 모델 진단 (1주차)**
- 조사된 벤치마크 기준으로 현재 모델 성능 평가
- Netflix 사례를 참고하여 주요 병목 지점 식별
- AutoML 도구를 활용한 초기 최적화 가능성 탐색

**2단계: 데이터 품질 개선 (2-3주차)**
- 조사 결과의 "80% 규칙"에 따라 데이터 정제 우선 실행
- 데이터 증강 기법 적용 (조사된 최신 기법 활용)
- A/B 테스트로 개선 효과 측정

**3단계: 모델 최적화 구현 (4-6주차)**
- Knowledge Distillation 적용하여 모델 경량화
- 조사된 Pruning 기법으로 추론 속도 개선
- Tesla 사례의 실시간 처리 최적화 기법 벤치마킹

**4단계: 성과 검증 및 배포 (7-8주차)**
- OpenAI 사례의 비용 절감 지표 적용
- 조사된 성능 지표로 개선율 측정
- 단계적 배포 전략 수립""",
                
                "executor": """감독자의 지시와 조사 내용을 기반으로 구체적인 실행 계획을 수립합니다.

**1단계: 현재 모델 진단 (1주차)**
- 월요일-화요일: MLflow를 사용한 현재 모델 메트릭 수집
  * 조사 결과 참고: Netflix가 사용한 핵심 지표 (정확도, 지연시간, 처리량)
- 수요일-목요일: AutoML 도구 (Optuna, Ray Tune) 설정 및 초기 실행
  * 조사된 best practice에 따라 search space 정의
- 금요일: 진단 보고서 작성 및 개선 우선순위 결정

**2단계: 데이터 품질 개선 (2-3주차)**
- 데이터 정제 파이프라인 구축
  * 조사 결과의 "80% 규칙" 적용: 누락값, 이상치, 레이블 오류 처리
  * 코드 예시: `data_quality_pipeline.py` 구현
- 데이터 증강 구현
  * 최신 기법 적용: MixUp, CutMix, AutoAugment
  * 검증 데이터셋으로 효과 측정 (목표: 15% 성능 향상)

**3단계: 모델 최적화 구현 (4-6주차)**
- Knowledge Distillation 구현
  * Teacher 모델: 현재 대규모 모델
  * Student 모델: 90% 작은 크기 목표 (조사 결과 기반)
  * 구현 프레임워크: PyTorch/TensorFlow
- Pruning 및 Quantization 적용
  * 구조적 pruning으로 50% 파라미터 제거
  * INT8 quantization으로 추가 4배 속도 향상
  * Tesla 사례 참고: TensorRT 최적화 적용

**4단계: 성과 검증 및 배포 (7-8주차)**
- 성과 지표 측정
  * 추론 속도: 목표 10배 향상 (조사 결과 기반)
  * 정확도 손실: 최대 2% 이내 유지
  * 비용 절감: 70% 목표 (OpenAI 사례 참고)
- 배포 전략
  * A/B 테스트: 10% 트래픽으로 시작
  * 모니터링: Prometheus + Grafana 대시보드
  * 롤백 계획: 성능 저하 시 자동 롤백

**예상 결과물**
- 최적화된 모델 (크기 90% 감소, 속도 10배 향상)
- 상세 성능 벤치마크 보고서
- 프로덕션 배포 가이드 및 모니터링 대시보드
- 재현 가능한 최적화 파이프라인 코드""",
                
                "supervisor_review": """실행자 AI의 계획을 검토한 결과, 조사 내용이 잘 반영되었습니다. 다음과 같은 개선사항을 제안합니다.

**강점**
- 조사된 사례들(Netflix, Tesla, OpenAI)이 각 단계에 적절히 활용됨
- 구체적인 도구와 기법이 명시되어 실행 가능성이 높음
- 측정 가능한 목표가 조사 결과를 기반으로 설정됨

**개선 필요사항**
1. **리스크 관리 강화**
   - 각 단계별 실패 시나리오와 대응 방안 추가 필요
   - 기술적 문제 발생 시 백업 계획 수립
   
2. **비용 분석 구체화**
   - OpenAI 사례의 70% 절감을 위한 구체적인 비용 계산
   - ROI 분석 및 투자 대비 효과 측정 방법
   
3. **팀 협업 체계화**
   - 데이터 과학자, ML 엔지니어, DevOps 간 역할 분담 명확화
   - 주간 진행 상황 공유 및 이슈 트래킹 프로세스

**추가 권장사항**
- 최신 연구 동향 모니터링 체계 구축
- 경쟁사 벤치마킹을 위한 정기적인 조사 프로세스
- 내부 지식 공유를 위한 문서화 및 세미나 계획
- 실패 사례에서 배운 교훈을 축적하는 시스템 구축""",
                
                "executor_final": """감독자 AI의 피드백을 완전히 반영하여 최종 실행 보고서를 작성합니다.

# 🎯 기계학습 모델 성능 향상 최종 실행 보고서

## 📋 Executive Summary
본 보고서는 웹 검색을 통해 수집된 최신 사례와 감독자 AI의 전략적 지침을 바탕으로, 8주간의 체계적인 모델 최적화 프로젝트를 제시합니다. 목표는 모델 크기 90% 감소, 추론 속도 10배 향상, 운영 비용 70% 절감입니다.

## 📊 1단계: 현재 모델 진단 및 베이스라인 설정 (1주차)

### 실행 계획
**월-화요일: 성능 메트릭 수집**
- MLflow를 통한 현재 모델 전체 분석
- Netflix 사례 기반 핵심 지표: 정확도(92%), 지연시간(45ms), 처리량(1,000 req/s)
- 리소스 사용량: GPU 메모리 8GB, 추론 시 CPU 사용률 85%

**수-목요일: AutoML 초기 탐색**
- Optuna로 하이퍼파라미터 최적화 (200회 시도)
- Ray Tune으로 분산 학습 환경 구축
- 초기 개선 가능성: 15-20% 성능 향상 예상

**금요일: 진단 보고서 및 리스크 분석**
- 주요 병목: 모델 크기(2.5GB), 배치 처리 비효율성
- 리스크: 데이터 드리프트, 하드웨어 제약
- 백업 계획: 클라우드 GPU 인스턴스 확보

### 예상 산출물
- 상세 성능 베이스라인 문서
- 개선 기회 우선순위 매트릭스
- 리스크 레지스터 및 대응 계획

## 📊 2단계: 데이터 품질 개선 (2-3주차)

### 실행 계획
**2주차: 데이터 정제 파이프라인**
```python
# data_quality_pipeline.py 주요 구성
class DataQualityPipeline:
    def __init__(self):
        self.validators = [
            MissingValueHandler(threshold=0.05),
            OutlierDetector(method='isolation_forest'),
            LabelConsistencyChecker(),
            DataDriftMonitor()
        ]
    
    def process(self, data):
        # 80% 규칙 적용: 데이터 품질이 성능의 80% 결정
        for validator in self.validators:
            data = validator.transform(data)
            self.log_metrics(validator.get_stats())
        return data
```

**3주차: 고급 데이터 증강**
- MixUp: 15% 정확도 향상 예상
- CutMix: 경계 검출 성능 20% 개선
- AutoAugment: 자동 최적 증강 정책 탐색
- A/B 테스트: 각 기법별 효과 측정

### 리스크 대응
- 데이터 품질 저하 시: 롤백 메커니즘 구현
- 증강 과적합 방지: 검증셋 분리 및 교차 검증

### 예상 산출물
- 자동화된 데이터 품질 파이프라인
- 데이터 품질 대시보드 (Grafana)
- 15% 이상 성능 향상 검증 보고서

## 📊 3단계: 모델 최적화 구현 (4-6주차)

### 실행 계획
**4-5주차: Knowledge Distillation**
- Teacher 모델: 현재 2.5GB 모델
- Student 모델 아키텍처:
  * 파라미터 수: 250M → 25M (90% 감소)
  * 레이어 수: 24 → 6
  * Hidden dimension: 1024 → 256
- 훈련 전략:
  * Temperature: 5.0
  * Alpha (KD loss weight): 0.7
  * 훈련 에폭: 50

**6주차: Pruning & Quantization**
- 구조적 Pruning:
  * Magnitude 기반 50% 채널 제거
  * Fine-tuning: 10 에폭
- INT8 Quantization:
  * Post-training quantization
  * Calibration dataset: 1,000 샘플
- TensorRT 최적화 (Tesla 사례 적용):
  * FP16 추론 활성화
  * 동적 배치 최적화

### 팀 협업 체계
- ML 엔지니어: 모델 아키텍처 및 훈련
- DevOps: 인프라 및 배포 파이프라인
- 데이터 과학자: 성능 분석 및 검증
- 주간 스탠드업 미팅 및 Jira 이슈 트래킹

### 예상 산출물
- 최적화된 모델 체크포인트
- 성능 벤치마크 상세 보고서
- 모델 변환 자동화 스크립트

## 📊 4단계: 성과 검증 및 프로덕션 배포 (7-8주차)

### 실행 계획
**7주차: 종합 성능 검증**
- 성능 지표 달성도:
  * 추론 속도: 45ms → 4.5ms (10배 향상) ✓
  * 모델 크기: 2.5GB → 250MB (90% 감소) ✓
  * 정확도 손실: 92% → 90.5% (1.5% 손실) ✓
- 비용 분석:
  * GPU 인스턴스: $2,000/월 → $600/월
  * 처리량 증가로 인한 서버 수 감소: 10대 → 3대
  * 총 비용 절감: 70% 달성 ✓

**8주차: 단계적 배포**
- Canary 배포:
  * 1일차: 1% 트래픽
  * 3일차: 10% 트래픽
  * 7일차: 50% 트래픽
  * 14일차: 100% 전환
- 모니터링 설정:
  * Prometheus + Grafana 대시보드
  * 알림 임계값: 지연시간 >10ms, 오류율 >0.1%
- 롤백 계획:
  * 자동 롤백 트리거 설정
  * Blue-Green 배포로 즉시 전환 가능

### ROI 분석
- 초기 투자: $50,000 (인건비 + 인프라)
- 월간 절감액: $14,000
- 투자 회수 기간: 3.6개월
- 1년 순이익: $118,000

### 예상 산출물
- 프로덕션 배포 완료
- 실시간 모니터링 대시보드
- ROI 분석 보고서
- 운영 가이드 문서

## 📈 지속적 개선 계획

### 모니터링 및 유지보수
- 월간 성능 리뷰 미팅
- 분기별 재훈련 계획
- 신기술 도입 검토 (Sparse Models, MoE)

### 지식 공유
- 내부 기술 세미나 (월 1회)
- 외부 컨퍼런스 발표 준비
- 오픈소스 기여 계획

### 차기 프로젝트
- 엣지 디바이스 배포 최적화
- 연합 학습(Federated Learning) 도입
- AutoML 플랫폼 구축

## 📝 결론
본 프로젝트는 최신 연구 결과와 업계 베스트 프랙티스를 적용하여, 8주 만에 모델 성능을 획기적으로 개선하고 운영 비용을 70% 절감하는 성과를 달성할 것으로 예상됩니다. 체계적인 접근과 리스크 관리, 그리고 지속적인 개선 계획을 통해 장기적인 경쟁력을 확보할 수 있습니다.

---
*작성일: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
*작성자: 협력적 AI 시스템 (감독자, 조사자, 실행자 AI)*"""
            }
            
            # 프롬프트 내용에 따라 적절한 응답 선택
            if role == "supervisor" and "조사자 AI가 정리한" in messages[0]["content"]:
                response = test_responses["supervisor_execution"]
            elif role == "supervisor" and messages[0]["content"].find("실행자 AI의 답변") > -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 "최종 보고서" 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입니다.",
                "researcher": "당신은 정보를 조사하고 체계적으로 정리하는 조사자 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()

# 내부 히스토리 관리 (UI에는 표시하지 않음)
internal_history = []

def process_query_streaming(user_query: str):
    """스트리밍을 지원하는 쿼리 처리"""
    global internal_history
    
    if not user_query:
        return "", "", "", "", "❌ 질문을 입력해주세요."
    
    conversation_log = []
    all_responses = {"supervisor": [], "researcher": [], "executor": []}
    
    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)
        
        # 키워드 추출
        keywords = llm_system.extract_keywords(supervisor_initial_response)
        logger.info(f"추출된 키워드: {keywords}")
        
        # 2단계: 브레이브 검색 수행
        researcher_text = "[웹 검색] 🔍 검색 중...\n"
        yield supervisor_text, researcher_text, "", "", "🔍 웹 검색 수행 중..."
        
        search_results = {}
        total_search_count = 0
        
        # 원래 키워드로 검색
        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, researcher_text, "", "", f"🔍 '{keyword}' 검색 중..."
            
            # 동의어로 추가 검색
            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, researcher_text, "", "", f"🔍 동의어 '{synonym}' 검색 중..."
        
        researcher_text += f"\n📊 총 {total_search_count}개의 검색 결과 수집 완료\n"
        
        # URL 콘텐츠 가져오기 (상위 3개)
        researcher_text += "\n[콘텐츠 분석] 📖 주요 웹페이지 내용 분석 중...\n"
        yield supervisor_text, researcher_text, "", "", "📖 웹페이지 내용 분석 중..."
        
        content_analyzed = 0
        for keyword, results in search_results.items():
            for result in results[:2]:  # 각 키워드당 상위 2개만
                if content_analyzed >= 5:  # 총 5개까지만
                    break
                    
                url = result.get('url', '')
                if url and result.get('credibility_score', 0) >= 0.7:
                    content = llm_system.fetch_url_content(url)
                    if content:
                        result['content_preview'] = content[:500]  # 미리보기 저장
                        content_analyzed += 1
                        researcher_text += f"✓ 콘텐츠 분석 완료: {url[:50]}...\n"
                        yield supervisor_text, researcher_text, "", "", f"📖 분석 중: {url[:30]}..."
        
        # 3단계: 조사자 AI가 검색 결과 정리
        researcher_prompt = llm_system.create_researcher_prompt(user_query, supervisor_initial_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, researcher_text, "", "", "📝 조사자 AI가 정리 중..."
        
        all_responses["researcher"].append(researcher_response)
        
        # 4단계: 감독자 AI가 조사 내용 기반으로 실행 지시
        supervisor_execution_prompt = llm_system.create_supervisor_execution_prompt(user_query, researcher_response)
        supervisor_execution_response = ""
        
        supervisor_text += "\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{supervisor_execution_response}"
            supervisor_text = f"[초기 분석] - {datetime.now().strftime('%H:%M:%S')}\n{temp_text}"
            yield supervisor_text, researcher_text, "", "", "🎯 감독자 AI가 지시 중..."
        
        all_responses["supervisor"].append(supervisor_execution_response)
        
        # 5단계: 실행자 AI가 조사 내용과 지시를 기반으로 초기 구현
        executor_prompt = llm_system.create_executor_prompt(user_query, supervisor_execution_response, researcher_response)
        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, researcher_text, executor_text, "", "🔧 실행자 AI가 구현 중..."
        
        all_responses["executor"].append(executor_response)
        
        # 6단계: 감독자 AI 검토 및 피드백
        review_prompt = f"""당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.

사용자 질문: {user_query}

실행자 AI의 답변:
{executor_response}

이 답변을 검토하고 개선점과 추가 고려사항을 제시해주세요. 구체적이고 실행 가능한 개선 방안을 제시하세요."""
        
        review_response = ""
        supervisor_text = f"[초기 분석] - {datetime.now().strftime('%H:%M:%S')}\n{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": review_prompt}], 
            "supervisor"
        ):
            review_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{review_response}"
            supervisor_text = f"[초기 분석] - {datetime.now().strftime('%H:%M:%S')}\n{temp_text}"
            yield supervisor_text, researcher_text, executor_text, "", "🔄 감독자 AI가 검토 중..."
        
        all_responses["supervisor"].append(review_response)
        
        # 7단계: 실행자 AI 최종 보고서 (피드백 반영)
        final_executor_prompt = llm_system.create_executor_final_prompt(
            user_query, 
            executor_response, 
            review_response, 
            researcher_response
        )
        final_executor_response = ""
        
        executor_text += "\n\n---\n\n[최종 보고서] 🔄 작성 중...\n"
        for chunk in llm_system.call_llm_streaming(
            [{"role": "user", "content": final_executor_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, researcher_text, executor_text, "", "📄 최종 보고서 작성 중..."
        
        all_responses["executor"].append(final_executor_response)
        
        # 최종 결과 생성 (최종 보고서를 메인으로)
        final_summary = f"""## 🎯 최종 종합 보고서

### 📌 사용자 질문
{user_query}

### 📄 최종 보고서 (실행자 AI - 피드백 반영)
{final_executor_response}

---

<details>
<summary>📋 전체 협력 과정 보기</summary>

#### 🔍 거시적 분석 (감독자 AI)
{all_responses['supervisor'][0]}

#### 📚 조사 결과 (조사자 AI)
{researcher_response}

#### 🎯 실행 지시 (감독자 AI)
{all_responses['supervisor'][1]}

#### 💡 초기 구현 (실행자 AI)
{executor_response}

#### ✨ 검토 및 개선사항 (감독자 AI)
{review_response}

</details>

---
*이 보고서는 웹 검색을 통한 최신 정보와 AI들의 협력, 그리고 피드백 반영을 통해 작성되었습니다.*"""
        
        # 내부 히스토리 업데이트 (UI에는 표시하지 않음)
        internal_history.append((user_query, final_summary))
        
        yield supervisor_text, researcher_text, executor_text, final_summary, "✅ 최종 보고서 완성!"
        
    except Exception as e:
        error_msg = f"❌ 처리 중 오류: {str(e)}"
        yield "", "", "", error_msg, 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;
    padding-left: 10px !important;
}
.researcher-box textarea {
    border-left: 4px solid #10b981 !important;
    padding-left: 10px !important;
}
.executor-box textarea {
    border-left: 4px solid #764ba2 !important;
    padding-left: 10px !important;
}
"""

with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css) as app:
    gr.Markdown(
        f"""
        # 🤝 협력적 LLM 시스템 (조사자 포함 + 피드백 반영)
        
        > 감독자, 조사자, 실행자 AI가 협력하여 피드백을 반영한 완전한 보고서를 작성합니다.
        
        **상태**: 
        - LLM: {'🟢 실제 모드' if not llm_system.test_mode else '🟡 테스트 모드'}
        - Brave Search: {'🟢 활성화' if llm_system.bapi_token != "YOUR_BRAVE_API_TOKEN" else '🟡 테스트 모드'}
        
        **7단계 협력 프로세스:**
        1. 🧠 **감독자**: 거시적 분석 및 검색 키워드 추출
        2. 🔍 **조사자**: 브레이브 검색으로 최신 정보 수집
        3. 🧠 **감독자**: 조사 내용 기반 구체적 실행 지시
        4. 👁️ **실행자**: 초기 실행 계획 작성
        5. 🧠 **감독자**: 검토 및 개선사항 피드백
        6. 👁️ **실행자**: 피드백 반영한 최종 보고서 작성
        7. 📄 **최종 산출물**: 완전한 실행 보고서
        """
    )
    
    # 입력 섹션
    with gr.Row():
        with gr.Column():
            gr.Markdown("""
            ## 🚀 강화된 조사 기능
            - **20개 검색 결과**: 더 많은 정보 수집
            - **동의어 검색**: 관련 정보 확장 탐색
            - **신뢰도 점수**: 0-1 점수로 출처 평가
            - **웹페이지 분석**: 주요 URL 콘텐츠 직접 확인
            - **모순 감지**: 상충하는 정보 자동 식별
            """)
            
            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 출력들 - 한 줄에 나란히 배치
    with gr.Row():
        # 감독자 AI 출력
        with gr.Column():
            gr.Markdown("### 🧠 감독자 AI (거시적 분석)")
            supervisor_output = gr.Textbox(
                label="",
                lines=20,
                max_lines=25,
                interactive=False,
                elem_classes=["supervisor-box"]
            )
        
        # 조사자 AI 출력
        with gr.Column():
            gr.Markdown("### 🔍 조사자 AI (웹 검색 & 정리)")
            researcher_output = gr.Textbox(
                label="",
                lines=20,
                max_lines=25,
                interactive=False,
                elem_classes=["researcher-box"]
            )
        
        # 실행자 AI 출력
        with gr.Column():
            gr.Markdown("### 👁️ 실행자 AI (미시적 구현)")
            executor_output = gr.Textbox(
                label="",
                lines=20,
                max_lines=25,
                interactive=False,
                elem_classes=["executor-box"]
            )
    
    # 예제
    gr.Examples(
        examples=[
            "기계학습 모델의 성능을 향상시키는 최신 방법은?",
            "2024년 효과적인 프로젝트 관리 도구와 전략은?",
            "지속 가능한 비즈니스 모델의 최신 트렌드는?",
            "최신 데이터 시각화 도구와 기법은?",
            "원격 팀의 생산성을 높이는 검증된 방법은?"
        ],
        inputs=user_input,
        label="💡 예제 질문"
    )
    
    # 이벤트 핸들러
    submit_btn.click(
        fn=process_query_streaming,
        inputs=[user_input],
        outputs=[supervisor_output, researcher_output, executor_output, final_output, status_text]
    ).then(
        fn=lambda: "",
        outputs=[user_input]
    )
    
    user_input.submit(
        fn=process_query_streaming,
        inputs=[user_input],
        outputs=[supervisor_output, researcher_output, executor_output, final_output, status_text]
    ).then(
        fn=lambda: "",
        outputs=[user_input]
    )
    
    clear_btn.click(
        fn=clear_all,
        outputs=[supervisor_output, researcher_output, executor_output, final_output, status_text]
    )
    
    gr.Markdown(
        """
        ---
        ### 📝 사용 방법
        1. 질문을 입력하고 Enter 또는 '분석 시작' 버튼을 클릭하세요.
        2. 7단계 협력 프로세스가 진행됩니다:
           - 감독자 초기 분석 → 웹 검색 → 조사 정리 → 실행 지시 → 초기 구현 → 피드백 → 최종 보고서
        3. 각 AI의 작업 과정을 실시간으로 확인할 수 있습니다.
        4. 최종 보고서가 상단에 표시되며, 전체 협력 과정은 접을 수 있는 형태로 제공됩니다.
        
        ### ⚙️ 환경 설정
        - **필수 패키지 설치**: `pip install gradio requests beautifulsoup4`
        - **LLM API**: `export FRIENDLI_TOKEN="your_token"`
        - **Brave Search API**: `export BAPI_TOKEN="your_brave_api_token"`
        - **테스트 모드**: `export TEST_MODE=true` (API 없이 작동)
        
        ### 🔗 API 키 획득
        - Friendli API: [https://friendli.ai](https://friendli.ai)
        - Brave Search API: [https://brave.com/search/api/](https://brave.com/search/api/)
        
        ### 💡 특징
        - 완전한 피드백 루프: 감독자의 피드백이 실행자에게 전달되어 최종 개선
        - 웹 검색 기반: 최신 정보와 사례를 활용한 실용적 답변
        - 전문 보고서 형식: 실무에서 바로 활용 가능한 구조화된 결과물
        """
    )

if __name__ == "__main__":
    app.queue()  # 스트리밍을 위한 큐 활성화
    app.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=True,
        show_error=True
    )