Update app.py

app.py

@@ -3,9 +3,8 @@ import os
 import json
 import requests
 from datetime import datetime
-import asyncio
-import aiohttp
-from typing import List, Dict, Any
+import time
+from typing import List, Dict, Any, Generator
 import logging
 
 # 로깅 설정
@@ -16,6 +15,7 @@ logger = logging.getLogger(__name__)
 FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN", "YOUR_FRIENDLI_TOKEN")
 API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
 MODEL_ID = "dep89a2fld32mcm"
+TEST_MODE = os.getenv("TEST_MODE", "false").lower() == "true"
 
 # 전역 변수
 conversation_history = []
@@ -25,6 +25,10 @@ class LLMCollaborativeSystem:
         self.token = FRIENDLI_TOKEN
         self.api_url = API_URL
         self.model_id = MODEL_ID
+        self.test_mode = TEST_MODE or (self.token == "YOUR_FRIENDLI_TOKEN")
+        
+        if self.test_mode:
+            logger.warning("테스트 모드로 실행됩니다.")
         
     def create_headers(self):
         """API 헤더 생성"""
@@ -62,16 +66,95 @@ class LLMCollaborativeSystem:
 
 위 지침을 바탕으로 구체적이고 실행 가능한 세부 내용을 작성해주세요. 실용적이고 구현 가능한 해결책에 집중하세요."""
     
-    def call_llm_sync(self, messages: List[Dict[str, str]], role: str) -> str:
-        """동기식 LLM API 호출"""
+    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.1)
+    
+    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. **기대 효과와 과제**
+   - 예상되는 긍정적 성과를 분석합니다
+   - 잠재적 도전 과제를 식별합니다
+   - 지속가능한 발전 방향을 제시합니다""",
+                
+                "executor": """감독자 AI의 지침에 따라 구체적인 실행 계획을 수립하겠습니다.
+
+**단계 1: 현황 분석 및 준비** (1-2주)
+- 현재 상황에 대한 정밀 진단 실시
+- 필요한 자원과 인력 확보
+- 이해관계자들과의 소통 채널 구축
+
+**단계 2: 파일럿 프로젝트 실행** (3-4주)
+- 소규모 테스트 프로젝트 진행
+- 초기 결과 데이터 수집 및 분석
+- 피드백을 통한 개선점 도출
+
+**단계 3: 본격 구현** (2-3개월)
+- 검증된 방법론을 전체에 적용
+- 주기적인 모니터링과 조정
+- 성과 지표 측정 및 보고
+
+**단계 4: 평가 및 확산** (지속)
+- 종합적인 성과 평가
+- 베스트 프랙티스 문서화
+- 다른 영역으로의 확대 적용""",
+                
+                "supervisor_review": """실행자 AI의 계획을 검토한 결과, 다음과 같은 개선사항을 제안합니다.
+
+**강점**
+- 단계별 접근이 체계적이고 현실적입니다
+- 파일럿 프로젝트를 통한 위험 최소화 전략이 우수합니다
+- 지속적인 모니터링 체계가 잘 구축되어 있습니다
+
+**개선 필요사항**
+1. 각 단계별 구체적인 성과 지표(KPI) 설정이 필요합니다
+2. 예상치 못한 상황에 대한 대안(Plan B) 준비가 보완되어야 합니다
+3. 이해관계자별 맞춤형 커뮤니케이션 전략이 추가되면 좋겠습니다
+
+**추가 권장사항**
+- 변화 관리(Change Management) 측면 강화
+- 디지털 도구 활용 방안 구체화
+- 장기적 지속가능성 확보 방안 마련"""
+            }
+            
+            if role == "supervisor" and not messages[0]["content"].find("실행자 AI의 답변") > -1:
+                response = test_responses["supervisor_initial"]
+            elif role == "executor":
+                response = test_responses["executor"]
+            else:
+                response = test_responses["supervisor_review"]
+            
+            yield from self.simulate_streaming(response, role)
+            return
+        
+        # 실제 API 호출
         try:
-            # 역할에 따른 시스템 프롬프트
             system_prompts = {
                 "supervisor": "당신은 거시적 관점에서 분석하고 지도하는 감독자 AI입니다.",
                 "executor": "당신은 세부적인 내용을 구현하는 실행자 AI입니다."
             }
             
-            # 메시지 구성
             full_messages = [
                 {"role": "system", "content": system_prompts.get(role, "")},
                 *messages
@@ -83,82 +166,126 @@ class LLMCollaborativeSystem:
                 "max_tokens": 2048,
                 "temperature": 0.7,
                 "top_p": 0.8,
-                "stream": False
+                "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,
-                timeout=60
+                stream=True,
+                timeout=10
             )
             
-            if response.status_code == 200:
-                data = response.json()
-                return data["choices"][0]["message"]["content"]
-            else:
+            if response.status_code != 200:
                 logger.error(f"API 오류: {response.status_code}")
-                return 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"LLM 호출 중 오류: {str(e)}")
-            return f"오류 발생: {str(e)}"
+            logger.error(f"스트리밍 중 오류: {str(e)}")
+            yield f"❌ 오류 발생: {str(e)}"
+
+# 시스템 인스턴스 생성
+llm_system = LLMCollaborativeSystem()
+
+def process_query_streaming(user_query: str, history: List):
+    """스트리밍을 지원하는 쿼리 처리"""
+    if not user_query:
+        return history, "", "", "", "❌ 질문을 입력해주세요."
     
-    def process_collaborative(self, user_query: str) -> Dict[str, Any]:
-        """협력적 처리 프로세스"""
-        conversation_log = []
+    conversation_log = []
+    all_responses = {"supervisor": [], "executor": []}
+    
+    try:
+        # 1단계: 감독자 AI 초기 분석 (스트리밍)
+        supervisor_prompt = llm_system.create_supervisor_prompt(user_query)
+        supervisor_response = ""
         
-        try:
-            # 1단계: 감독자 AI의 초기 분석
-            supervisor_prompt = self.create_supervisor_prompt(user_query)
-            supervisor_response = self.call_llm_sync(
-                [{"role": "user", "content": supervisor_prompt}],
-                "supervisor"
-            )
-            
-            conversation_log.append({
-                "role": "supervisor",
-                "stage": "초기 분석",
-                "content": supervisor_response,
-                "timestamp": datetime.now().strftime("%H:%M:%S")
-            })
-            
-            # 2단계: 실행자 AI의 세부 구현
-            executor_prompt = self.create_executor_prompt(user_query, supervisor_response)
-            executor_response = self.call_llm_sync(
-                [{"role": "user", "content": executor_prompt}],
-                "executor"
-            )
-            
-            conversation_log.append({
-                "role": "executor",
-                "stage": "세부 구현",
-                "content": executor_response,
-                "timestamp": datetime.now().strftime("%H:%M:%S")
-            })
-            
-            # 3단계: 감독자 AI의 검토 및 피드백
-            review_prompt = self.create_supervisor_prompt(user_query, executor_response)
-            review_response = self.call_llm_sync(
-                [{"role": "user", "content": review_prompt}],
-                "supervisor"
-            )
-            
-            conversation_log.append({
-                "role": "supervisor",
-                "stage": "검토 및 피드백",
-                "content": review_response,
-                "timestamp": datetime.now().strftime("%H:%M:%S")
-            })
-            
-            # 4단계: 최종 종합
-            final_summary = f"""## 🤝 협력적 AI 시스템 종합 답변
+        supervisor_text = "[초기 분석] 🔄 생성 중...\n"
+        for chunk in llm_system.call_llm_streaming(
+            [{"role": "user", "content": supervisor_prompt}], 
+            "supervisor"
+        ):
+            supervisor_response += chunk
+            supervisor_text = f"[초기 분석] - {datetime.now().strftime('%H:%M:%S')}\n{supervisor_response}"
+            yield history, supervisor_text, "", "", "🔄 감독자 AI가 분석 중..."
+        
+        all_responses["supervisor"].append(supervisor_response)
+        conversation_log.append({
+            "role": "supervisor",
+            "stage": "초기 분석",
+            "content": supervisor_response,
+            "timestamp": datetime.now().strftime("%H:%M:%S")
+        })
+        
+        # 2단계: 실행자 AI 세부 구현 (스트리밍)
+        executor_prompt = llm_system.create_executor_prompt(user_query, supervisor_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 history, supervisor_text, executor_text, "", "🔄 실행자 AI가 구현 중..."
+        
+        all_responses["executor"].append(executor_response)
+        conversation_log.append({
+            "role": "executor",
+            "stage": "세부 구현",
+            "content": executor_response,
+            "timestamp": datetime.now().strftime("%H:%M:%S")
+        })
+        
+        # 3단계: 감독자 AI 검토 (스트리밍)
+        review_prompt = llm_system.create_supervisor_prompt(user_query, executor_response)
+        review_response = ""
+        
+        supervisor_text += "\n\n---\n\n[검토 및 피드백] 🔄 생성 중...\n"
+        for chunk in llm_system.call_llm_streaming(
+            [{"role": "user", "content": review_prompt}], 
+            "supervisor"
+        ):
+            review_response += chunk
+            supervisor_text = f"[초기 분석] - {conversation_log[0]['timestamp']}\n{all_responses['supervisor'][0]}\n\n---\n\n[검토 및 피드백] - {datetime.now().strftime('%H:%M:%S')}\n{review_response}"
+            yield history, supervisor_text, executor_text, "", "🔄 감독자 AI가 검토 중..."
+        
+        all_responses["supervisor"].append(review_response)
+        
+        # 최종 결과 생성
+        final_summary = f"""## 🤝 협력적 AI 시스템 종합 답변
 
 ### 📌 사용자 질문
 {user_query}
 
 ### 🔍 거시적 분석 (감독자 AI)
-{supervisor_response}
+{all_responses['supervisor'][0]}
 
 ### 💡 세부 구현 (실행자 AI)
 {executor_response}
@@ -168,63 +295,15 @@ class LLMCollaborativeSystem:
 
 ---
 *이 답변은 거시적 관점과 미시적 세부사항을 종합하여 작성되었습니다.*"""
-            
-            return {
-                "final_result": final_summary,
-                "conversation_log": conversation_log,
-                "supervisor_texts": [log["content"] for log in conversation_log if log["role"] == "supervisor"],
-                "executor_texts": [log["content"] for log in conversation_log if log["role"] == "executor"]
-            }
-            
-        except Exception as e:
-            logger.error(f"협력 처리 오류: {str(e)}")
-            return {
-                "final_result": f"처리 중 오류가 발생했습니다: {str(e)}",
-                "conversation_log": [],
-                "supervisor_texts": [],
-                "executor_texts": []
-            }
-
-# 시스템 인스턴스 생성
-llm_system = LLMCollaborativeSystem()
-
-def process_query(user_query, history):
-    """Gradio 인터페이스를 위한 쿼리 처리 함수"""
-    if not user_query:
-        return history, "", "", "", "❌ 질문을 입력해주세요."
-    
-    # 처리 시작
-    status = "🔄 AI들이 협력하여 답변을 생성하고 있습니다..."
-    
-    try:
-        # 협력적 처리
-        result = llm_system.process_collaborative(user_query)
-        
-        # 감독자와 실행자 텍스트 포맷팅
-        supervisor_text = "\n\n---\n\n".join([
-            f"[{log['stage']}] - {log['timestamp']}\n{log['content']}"
-            for log in result["conversation_log"] if log["role"] == "supervisor"
-        ])
-        
-        executor_text = "\n\n---\n\n".join([
-            f"[{log['stage']}] - {log['timestamp']}\n{log['content']}"
-            for log in result["conversation_log"] if log["role"] == "executor"
-        ])
         
         # 히스토리 업데이트
-        new_history = history + [(user_query, result["final_result"])]
+        new_history = history + [(user_query, final_summary)]
         
-        return (
-            new_history,
-            supervisor_text,
-            executor_text,
-            result["final_result"],
-            "✅ 분석 완료!"
-        )
+        yield new_history, supervisor_text, executor_text, final_summary, "✅ 분석 완료!"
         
     except Exception as e:
         error_msg = f"❌ 처리 중 오류: {str(e)}"
-        return history, "", "", error_msg, error_msg
+        yield history, "", "", error_msg, error_msg
 
 def clear_all():
     """모든 내용 초기화"""
@@ -235,23 +314,25 @@ css = """
 .gradio-container {
     font-family: 'Arial', sans-serif;
 }
-.supervisor-box {
-    border-left: 4px solid #667eea;
-    padding-left: 10px;
+.supervisor-box textarea {
+    border-left: 4px solid #667eea !important;
+    padding-left: 10px !important;
 }
-.executor-box {
-    border-left: 4px solid #764ba2;
-    padding-left: 10px;
+.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와 미시적 실행자 AI가 협력하여 최상의 답변을 만들어냅니다.
         
+        **상태**: {'🟢 실제 모드' if not llm_system.test_mode else '🟡 테스트 모드'}
+        
         **시스템 구조:**
         - 🧠 **감독자 AI**: 전체적인 방향과 프레임워크를 제시
         - 👁️ **실행자 AI**: 구체적이고 실행 가능한 세부사항을 작성
@@ -332,7 +413,7 @@ with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css)
     
     # 이벤트 핸들러
     submit_btn.click(
-        fn=process_query,
+        fn=process_query_streaming,
         inputs=[user_input, chatbot],
         outputs=[chatbot, supervisor_output, executor_output, final_output, status_text]
     ).then(
@@ -341,7 +422,7 @@ with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css)
     )
     
     user_input.submit(
-        fn=process_query,
+        fn=process_query_streaming,
         inputs=[user_input, chatbot],
         outputs=[chatbot, supervisor_output, executor_output, final_output, status_text]
     ).then(
@@ -363,12 +444,14 @@ with gr.Blocks(title="협력적 LLM 시스템", theme=gr.themes.Soft(), css=css)
         3. 최종 종합 결과는 상단에 표시됩니다.
         
         ### ⚙️ 환경 설정
-        - `FRIENDLI_TOKEN` 환경 변수를 설정하세요: `export FRIENDLI_TOKEN="your_token"`
-        - 또는 코드의 `FRIENDLI_TOKEN` 변수를 직접 수정하세요.
+        - **실제 모드**: `export FRIENDLI_TOKEN="your_token"`
+        - **테스트 모드**: `export TEST_MODE=true` (API 없이 작동)
+        - 현재 토큰이 설정되지 않으면 자동으로 테스트 모드로 실행됩니다.
         """
     )
 
 if __name__ == "__main__":
+    app.queue()  # 스트리밍을 위한 큐 활성화
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,