Update app.py

app.py

@@ -17,9 +17,19 @@ from bs4 import BeautifulSoup
 from urllib.parse import urlparse
 import urllib.request
 
+# Gemini API 임포트
+try:
+    from google import genai
+    from google.genai import types
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+    logger.warning("Google Gemini API가 설치되지 않았습니다. pip install google-genai로 설치하세요.")
+
 # 환경 변수에서 토큰 가져오기
 FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN", "YOUR_FRIENDLI_TOKEN")
 BAPI_TOKEN = os.getenv("BAPI_TOKEN", "YOUR_BRAVE_API_TOKEN")
+GAPI_TOKEN = os.getenv("GAPI_TOKEN", "YOUR_GEMINI_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"
@@ -32,15 +42,31 @@ class LLMCollaborativeSystem:
     def __init__(self):
         self.token = FRIENDLI_TOKEN
         self.bapi_token = BAPI_TOKEN
+        self.gapi_token = GAPI_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")
+        self.use_gemini = False
+        self.gemini_client = None
         
         if self.test_mode:
             logger.warning("테스트 모드로 실행됩니다.")
         if self.bapi_token == "YOUR_BRAVE_API_TOKEN":
             logger.warning("Brave API 토큰이 설정되지 않았습니다.")
+        if self.gapi_token == "YOUR_GEMINI_API_TOKEN":
+            logger.warning("Gemini API 토큰이 설정되지 않았습니다.")
+        
+    def set_llm_mode(self, mode: str):
+        """LLM 모드 설정 (default 또는 commercial)"""
+        if mode == "commercial" and GEMINI_AVAILABLE and self.gapi_token != "YOUR_GEMINI_API_TOKEN":
+            self.use_gemini = True
+            if not self.gemini_client:
+                self.gemini_client = genai.Client(api_key=self.gapi_token)
+            logger.info("Gemini 2.5 Pro 모드로 전환되었습니다.")
+        else:
+            self.use_gemini = False
+            logger.info("기본 LLM 모드로 전환되었습니다.")
         
     def create_headers(self):
         """API 헤더 생성"""
@@ -169,6 +195,33 @@ class LLMCollaborativeSystem:
 4. 명확한 결론과 다음 단계를 제시하세요
 5. 전문적이고 완성도 높은 최종 보고서 형식으로 작성하세요"""
     
+    def create_evaluator_prompt(self, user_query: str, supervisor_responses: List[str], researcher_response: str, executor_responses: List[str]) -> str:
+        """평가자 AI 프롬프트 생성"""
+        return f"""당신은 전체 협력 과정과 결과를 평가하는 평가자 AI입니다.
+
+사용자 질문: {user_query}
+
+감독자 AI의 분석 및 지시:
+- 초기 분석: {supervisor_responses[0]}
+- 실행 지시: {supervisor_responses[1]}
+- 검토 피드백: {supervisor_responses[2]}
+
+조사자 AI의 조사 결과:
+{researcher_response}
+
+실행자 AI의 구현:
+- 초기 구현: {executor_responses[0]}
+- 최종 보고서: {executor_responses[1]}
+
+위 전체 과정을 평가하여:
+1. **품질 평가**: 각 AI의 답변 품질과 역할 수행도를 평가하세요 (10점 만점)
+2. **협력 효과성**: AI 간 협력이 얼마나 효과적이었는지 평가하세요
+3. **정보 활용도**: 웹 검색 정보가 얼마나 잘 활용되었는지 평가하세요
+4. **개선점**: 향후 개선이 필요한 부분을 구체적으로 제시하세요
+5. **최종 평점**: 전체 프로세스에 대한 종합 평가를 제시하세요
+
+평가는 구체적이고 건설적으로 작성하세요."""
+    
     def extract_keywords(self, supervisor_response: str) -> List[str]:
         """감독자 응답에서 키워드 추출"""
         keywords = []
@@ -392,9 +445,71 @@ class LLMCollaborativeSystem:
             yield chunk + " "
             time.sleep(0.05)
     
+    def call_gemini_streaming(self, messages: List[Dict[str, str]], role: str) -> Generator[str, None, None]:
+        """Gemini API 스트리밍 호출"""
+        if not self.gemini_client:
+            yield "❌ Gemini API 클라이언트가 초기화되지 않았습니다."
+            return
+        
+        try:
+            # 시스템 프롬프트 설정
+            system_prompts = {
+                "supervisor": "당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.",
+                "researcher": "당신은 정보를 조사하고 체계적으로 정리하는 조사자 AI입니다.",
+                "executor": "당신은 세부적인 내용을 구현하는 실행자 AI입니다.",
+                "evaluator": "당신은 전체 협력 과정과 결과를 평가하는 평가자 AI입니다."
+            }
+            
+            # Gemini 메시지 포맷으로 변환
+            contents = []
+            
+            # 시스템 메시지 추가
+            contents.append(types.Content(
+                role="user",
+                parts=[types.Part.from_text(text=system_prompts.get(role, ""))]
+            ))
+            contents.append(types.Content(
+                role="model",
+                parts=[types.Part.from_text(text="네, 이해했습니다. 제 역할을 수행하겠습니다.")]
+            ))
+            
+            # 사용자 메시지 추가
+            for msg in messages:
+                if msg["role"] == "user":
+                    contents.append(types.Content(
+                        role="user",
+                        parts=[types.Part.from_text(text=msg["content"])]
+                    ))
+            
+            # Gemini 설정
+            generate_content_config = types.GenerateContentConfig(
+                response_mime_type="text/plain",
+                temperature=0.7,
+                top_p=0.8,
+                max_output_tokens=2048
+            )
+            
+            # 스트리밍 생성
+            for chunk in self.gemini_client.models.generate_content_stream(
+                model="gemini-2.5-pro",
+                contents=contents,
+                config=generate_content_config,
+            ):
+                if chunk.text:
+                    yield chunk.text
+                    
+        except Exception as e:
+            logger.error(f"Gemini API 오류: {str(e)}")
+            yield f"❌ Gemini API 오류: {str(e)}"
+    
     def call_llm_streaming(self, messages: List[Dict[str, str]], role: str) -> Generator[str, None, None]:
         """스트리밍 LLM API 호출"""
         
+        # Gemini 모드인 경우
+        if self.use_gemini:
+            yield from self.call_gemini_streaming(messages, role)
+            return
+        
         # 테스트 모드
         if self.test_mode:
             logger.info(f"테스트 모드 스트리밍 - Role: {role}")
@@ -424,30 +539,21 @@ class LLMCollaborativeSystem:
 - 최신 연구에 따르면 모델 최적화의 핵심은 아키텍처 설계와 훈련 전략의 균형입니다 (신뢰도: 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배)를 기준으로 계획 수립 권장
 
 **핵심 인사이트:**
 - 최신 트렌드는 효율성과 성능의 균형에 초점
@@ -497,27 +603,7 @@ class LLMCollaborativeSystem:
 - 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배 향상)
-- 상세 성능 벤치마크 보고서
-- 프로덕션 배포 가이드 및 모니터링 대시보드
-- 재현 가능한 최적화 파이프라인 코드""",
+  * 구현 프레임워크: PyTorch/TensorFlow""",
                 
                 "supervisor_review": """실행자 AI의 계획을 검토한 결과, 조사 내용이 잘 반영되었습니다. 다음과 같은 개선사항을 제안합니다.
 
@@ -534,16 +620,10 @@ class LLMCollaborativeSystem:
 2. **비용 분석 구체화**
    - OpenAI 사례의 70% 절감을 위한 구체적인 비용 계산
    - ROI 분석 및 투자 대비 효과 측정 방법
-   
-3. **팀 협업 체계화**
-   - 데이터 과학자, ML 엔지니어, DevOps 간 역할 분담 명확화
-   - 주간 진행 상황 공유 및 이슈 트래킹 프로세스
 
 **추가 권장사항**
 - 최신 연구 동향 모니터링 체계 구축
-- 경쟁사 벤치마킹을 위한 정기적인 조사 프로세스
-- 내부 지식 공유를 위한 문서화 및 세미나 계획
-- 실패 사례에서 배운 교훈을 축적하는 시스템 구축""",
+- 경쟁사 벤치마킹을 위한 정기적인 조사 프로세스""",
                 
                 "executor_final": """감독자 AI의 피드백을 완전히 반영하여 최종 실행 보고서를 작성합니다.
 
@@ -558,158 +638,98 @@ class LLMCollaborativeSystem:
 **월-화요일: 성능 메트릭 수집**
 - 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% 이상 성능 향상 검증 보고서
+- 데이터 정제 파이프라인 구축
+- 고급 데이터 증강 기법 적용
+- A/B 테스트로 효과 검증
 
 ## 📊 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 이슈 트래킹
-
-### 예상 산출물
-- 최적화된 모델 체크포인트
-- 성능 벤치마크 상세 보고서
-- 모델 변환 자동화 스크립트
+- Knowledge Distillation으로 모델 경량화
+- Pruning & Quantization 적용
+- TensorRT 최적화 (Tesla 사례 적용)
 
 ## 📊 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
+- 종합 성능 검증 및 지표 달성도 확인
+- Canary 배포 전략 실행
+- 실시간 모니터링 체계 구축
 
-### 예상 산출물
-- 프로덕션 배포 완료
-- 실시간 모니터링 대시보드
-- ROI 분석 보고서
-- 운영 가이드 문서
+## 📝 결론
+본 프로젝트는 최신 연구 결과와 업계 베스트 프랙티스를 적용하여, 8주 만에 모델 성능을 획기적으로 개선하고 운영 비용을 70% 절감하는 성과를 달성할 것으로 예상됩니다.""",
+                
+                "evaluator": """## 📊 전체 협력 과정 평가 보고서
 
-## 📈 지속적 개선 계획
+### 1️⃣ 품질 평가 (10점 만점)
 
-### 모니터링 및 유지보수
-- 월간 성능 리뷰 미팅
-- 분기별 재훈련 계획
-- 신기술 도입 검토 (Sparse Models, MoE)
+**감독자 AI: 9.5/10**
+- 거시적 관점에서 체계적인 분석과 방향 제시
+- 단계별 구체적인 지시사항 제공
+- 피드백이 건설적이고 실행 가능함
 
-### 지식 공유
-- 내부 기술 세미나 (월 1회)
-- 외부 컨퍼런스 발표 준비
-- 오픈소스 기여 계획
+**조사자 AI: 9.0/10**
+- 웹 검색을 통한 최신 정보 수집 우수
+- 신뢰도 평가와 모순 감지 기능 효과적
+- 출처 표기와 정보 정리가 체계적
 
-### 차기 프로젝트
-- 엣지 디바이스 배포 최적화
-- 연합 학습(Federated Learning) 도입
-- AutoML 플랫폼 구축
+**실행자 AI: 8.5/10**
+- 조사 내용을 잘 활용한 구체적 계획 수립
+- 실행 가능한 단계별 접근법 제시
+- 일부 세부사항에서 더 구체화 필요
 
-## 📝 결론
-본 프로젝트는 최신 연구 결과와 업계 베스트 프랙티스를 적용하여, 8주 만에 모델 성능을 획기적으로 개선하고 운영 비용을 70% 절감하는 성과를 달성할 것으로 예상됩니다. 체계적인 접근과 리스크 관리, 그리고 지속적인 개선 계획을 통해 장기적인 경쟁력을 확보할 수 있습니다.
+### 2️⃣ 협력 효과성 평가
 
----
-*작성일: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
-*작성자: 협력적 AI 시스템 (감독자, 조사자, 실행자 AI)*"""
+**강점:**
+- AI 간 역할 분담이 명확하고 상호보완적
+- 정보 흐름이 체계적이고 일관성 있음
+- 피드백 반영이 효과적으로 이루어짐
+
+**개선점:**
+- 실시간 상호작용 메커니즘 추가 고려
+- 중간 점검 단계 도입 필요
+
+### 3️⃣ 정보 활용도 평가
+
+**우수한 점:**
+- 20개 이상의 웹 소스에서 정보 수집
+- 신뢰도 기반 정보 선별 효과적
+- 실제 기업 사례 적절히 활용
+
+**보완 필요:**
+- 학술 논문 등 더 깊이 있는 자료 활용
+- 지역별/산업별 특성 고려 필요
+
+### 4️⃣ 향후 개선 방향
+
+1. **실시간 협업 강화**
+   - AI 간 중간 체크포인트 추가
+   - 동적 역할 조정 메커니즘 도입
+
+2. **정보 검증 강화**
+   - 교차 검증 프로세스 추가
+   - 전문가 검토 단계 고려
+
+3. **맞춤화 강화**
+   - 사용자 컨텍스트 더 깊이 반영
+   - 산업별/규모별 맞춤 전략 제공
+
+### 5️⃣ 최종 평점: ⭐⭐⭐⭐⭐ 9.0/10
+
+**종합 평가:**
+본 협력 시스템은 각 AI의 전문성을 효과적으로 활용하여 사용자 질문에 대한 종합적이고 실행 가능한 답변을 제공했습니다. 특히 웹 검색을 통한 최신 정보 활용과 단계적 피드백 반영이 우수했습니다. 향후 실시간 협업과 맞춤화를 더욱 강화한다면 더욱 뛰어난 성과를 달성할 수 있을 것입니다."""
             }
             
             # 프롬프트 내용에 따라 적절한 응답 선택
@@ -723,6 +743,8 @@ class DataQualityPipeline:
                 response = test_responses["researcher"]
             elif role == "executor" and "최종 보고서" in messages[0]["content"]:
                 response = test_responses["executor_final"]
+            elif role == "evaluator":
+                response = test_responses["evaluator"]
             else:
                 response = test_responses["executor"]
             
@@ -734,7 +756,8 @@ class DataQualityPipeline:
             system_prompts = {
                 "supervisor": "당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.",
                 "researcher": "당신은 정보를 조사하고 체계적으로 정리하는 조사자 AI입니다.",
-                "executor": "당신은 세부적인 내용을 구현하는 실행자 AI입니다."
+                "executor": "���신은 세부적인 내용을 구현하는 실행자 AI입니다.",
+                "evaluator": "당신은 전체 협력 과정과 결과를 평가하는 평가자 AI입니다."
             }
             
             full_messages = [
@@ -797,15 +820,18 @@ llm_system = LLMCollaborativeSystem()
 # 내부 히스토리 관리 (UI에는 표시하지 않음)
 internal_history = []
 
-def process_query_streaming(user_query: str):
+def process_query_streaming(user_query: str, llm_mode: str):
     """스트리밍을 지원하는 쿼리 처리"""
     global internal_history
     
     if not user_query:
         return "", "", "", "", "❌ 질문을 입력해주세요."
     
+    # LLM 모드 설정
+    llm_system.set_llm_mode(llm_mode)
+    
     conversation_log = []
-    all_responses = {"supervisor": [], "researcher": [], "executor": []}
+    all_responses = {"supervisor": [], "researcher": [], "executor": [], "evaluator": []}
     
     try:
         # 1단계: 감독자 AI 초기 분석 및 키워드 추출
@@ -965,6 +991,26 @@ def process_query_streaming(user_query: str):
         
         all_responses["executor"].append(final_executor_response)
         
+        # 8단계: 평가자 AI가 전체 과정 평가
+        evaluator_prompt = llm_system.create_evaluator_prompt(
+            user_query,
+            all_responses["supervisor"],
+            all_responses["researcher"][0],
+            all_responses["executor"]
+        )
+        evaluator_response = ""
+        
+        evaluator_text = "[전체 평가] 🔄 평가 중...\n"
+        for chunk in llm_system.call_llm_streaming(
+            [{"role": "user", "content": evaluator_prompt}], 
+            "evaluator"
+        ):
+            evaluator_response += chunk
+            evaluator_text = f"[전체 평가] - {datetime.now().strftime('%H:%M:%S')}\n{evaluator_response}"
+            yield supervisor_text, researcher_text, executor_text, evaluator_text, "📊 평가자 AI가 평가 중..."
+        
+        all_responses["evaluator"].append(evaluator_response)
+        
         # 최종 결과 생성 (최종 보고서를 메인으로)
         final_summary = f"""## 🎯 최종 종합 보고서
 
@@ -976,6 +1022,11 @@ def process_query_streaming(user_query: str):
 
 ---
 
+### 📊 전체 프로세스 평가 (평가자 AI)
+{evaluator_response}
+
+---
+
 <details>
 <summary>📋 전체 협력 과정 보기</summary>
 
@@ -997,16 +1048,28 @@ def process_query_streaming(user_query: str):
 </details>
 
 ---
-*이 보고서는 웹 검색을 통한 최신 정보와 AI들의 협력, 그리고 피드백 반영을 통해 작성되었습니다.*"""
+*이 보고서는 {'Gemini 2.5 Pro' if llm_system.use_gemini else '기본 LLM'}를 사용하여 웹 검색과 AI 협력을 통해 작성되었습니다.*"""
         
         # 내부 히스토리 업데이트 (UI에는 표시하지 않음)
         internal_history.append((user_query, final_summary))
         
-        yield supervisor_text, researcher_text, executor_text, final_summary, "✅ 최종 보고서 완성!"
+        # 최종 요약만 표시
+        display_summary = f"""## 🎯 최종 결과
+
+### 📄 실행 보고서
+{final_executor_response}
+
+### 📊 평가 요약
+{evaluator_response.split('### 5️⃣')[1] if '### 5️⃣' in evaluator_response else evaluator_response[-500:]}
+
+---
+*{'Gemini 2.5 Pro' if llm_system.use_gemini else '기본 LLM'} 사용 | 4개 AI 협력 완료*"""
+        
+        yield supervisor_text, researcher_text, executor_text, evaluator_text, "✅ 최종 보고서 완성!"
         
     except Exception as e:
         error_msg = f"❌ 처리 중 오류: {str(e)}"
-        yield "", "", "", error_msg, error_msg
+        yield "", "", "", "", error_msg
 
 def clear_all():
     """모든 내용 초기화"""
@@ -1022,21 +1085,29 @@ css = """
 .supervisor-box textarea {
     border-left: 4px solid #667eea !important;
     padding-left: 10px !important;
+    background-color: #f8f9ff !important;
 }
 .researcher-box textarea {
     border-left: 4px solid #10b981 !important;
     padding-left: 10px !important;
+    background-color: #f0fdf4 !important;
 }
 .executor-box textarea {
     border-left: 4px solid #764ba2 !important;
     padding-left: 10px !important;
+    background-color: #faf5ff !important;
+}
+.evaluator-box textarea {
+    border-left: 4px solid #f59e0b !important;
+    padding-left: 10px !important;
+    background-color: #fffbeb !important;
 }
 """
 
 with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css) as app:
     gr.Markdown(
         f"""
-        # 🤝 협력적 LLM 시스템 (조사자 포함 + 피드백 반영)
+        # 🤝 협력적 LLM 시스템 (4-AI 협업 + 평가자)
         """
     )
     
@@ -1044,14 +1115,27 @@ with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css)
     with gr.Row():
         with gr.Column():
             gr.Markdown("""
-            ## 🚀 강화된 조사 기능
-            - **20개 검색 결과**: 더 많은 정보 수집
-            - **동의�� 검색**: 관련 정보 확장 탐색
-            - **신뢰도 점수**: 0-1 점수로 출처 평가
-            - **웹페이지 분석**: 주요 URL 콘텐츠 직접 확인
-            - **모순 감지**: 상충하는 정보 자동 식별
+            ## 🚀 4개 AI의 협력 시스템
+            - **감독자 AI**: 거시적 분석과 전략 수립
+            - **조사자 AI**: 웹 검색과 정보 수집/정리
+            - **실행자 AI**: 구체적 계획 수립과 실행
+            - **평가자 AI**: 전체 과정 평가와 개선점 제시
+            
+            ### 🌟 주요 기능
+            - 20개 검색 결과와 동의어 검색
+            - 신뢰도 기반 정보 평가
+            - 실시간 협업과 피드백 반영
+            - 종합적인 품질 평가
             """)
             
+            # LLM 선택 옵션
+            llm_mode = gr.Radio(
+                choices=["default", "commercial"],
+                value="default",
+                label="LLM 모드 선택",
+                info="commercial을 선택하면 Gemini 2.5 Pro를 사용합니다"
+            )
+            
             user_input = gr.Textbox(
                 label="질문 입력",
                 placeholder="예: 기계학습 모델의 성능을 향상시키는 방법은?",
@@ -1069,48 +1153,50 @@ with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css)
                 max_lines=1
             )
     
-    # 최종 결과
+    # AI 출력들 - 2x2 그리드
     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,
+                lines=15,
+                max_lines=20,
                 interactive=False,
                 elem_classes=["supervisor-box"]
             )
         
-        # 조사자 AI 출력
         with gr.Column():
             gr.Markdown("### 🔍 조사자 AI (웹 검색 & 정리)")
             researcher_output = gr.Textbox(
                 label="",
-                lines=20,
-                max_lines=25,
+                lines=15,
+                max_lines=20,
                 interactive=False,
                 elem_classes=["researcher-box"]
             )
-        
-        # 실행자 AI 출력
+    
+    with gr.Row():
+        # 하단 행
         with gr.Column():
             gr.Markdown("### 👁️ 실행자 AI (미시적 구현)")
             executor_output = gr.Textbox(
                 label="",
-                lines=20,
-                max_lines=25,
+                lines=15,
+                max_lines=20,
                 interactive=False,
                 elem_classes=["executor-box"]
             )
+        
+        with gr.Column():
+            gr.Markdown("### 📊 평가자 AI (전체 평가)")
+            evaluator_output = gr.Textbox(
+                label="",
+                lines=15,
+                max_lines=20,
+                interactive=False,
+                elem_classes=["evaluator-box"]
+            )
     
     # 예제
     gr.Examples(
@@ -1128,8 +1214,8 @@ with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css)
     # 이벤트 핸들러
     submit_btn.click(
         fn=process_query_streaming,
-        inputs=[user_input],
-        outputs=[supervisor_output, researcher_output, executor_output, final_output, status_text]
+        inputs=[user_input, llm_mode],
+        outputs=[supervisor_output, researcher_output, executor_output, evaluator_output, status_text]
     ).then(
         fn=lambda: "",
         outputs=[user_input]
@@ -1137,8 +1223,8 @@ with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css)
     
     user_input.submit(
         fn=process_query_streaming,
-        inputs=[user_input],
-        outputs=[supervisor_output, researcher_output, executor_output, final_output, status_text]
+        inputs=[user_input, llm_mode],
+        outputs=[supervisor_output, researcher_output, executor_output, evaluator_output, status_text]
     ).then(
         fn=lambda: "",
         outputs=[user_input]
@@ -1146,7 +1232,7 @@ with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css)
     
     clear_btn.click(
         fn=clear_all,
-        outputs=[supervisor_output, researcher_output, executor_output, final_output, status_text]
+        outputs=[supervisor_output, researcher_output, executor_output, evaluator_output, status_text]
     )