Update app.py

app.py

@@ -10,7 +10,7 @@ import zipfile
 import re
 import json
 
-# 로깅 설정
+# 로깅 설정 - 클라이언트 정보 숨김
 logging.basicConfig(level=logging.WARNING, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
@@ -30,8 +30,8 @@ def get_api_client():
         api_endpoint = os.getenv('API_ENDPOINT')
         
         if not api_endpoint:
-            logger.error("API_ENDPOINT 환경변수가 설정되지 않았습니다.")
-            raise ValueError("API_ENDPOINT 환경변수가 설정되지 않았습니다.")
+            logger.error("API 엔드포인트가 설정되지 않았습니다.")
+            raise ValueError("API 엔드포인트가 설정되지 않았습니다.")
         
         client = Client(api_endpoint)
         logger.info("원격 API 클라이언트 초기화 성공")
@@ -44,8 +44,11 @@ def get_api_client():
 # ===== 한국시간 관련 함수 =====
 def get_korean_time():
     """한국시간 반환"""
-    korea_tz = pytz.timezone('Asia/Seoul')
-    return datetime.now(korea_tz)
+    try:
+        korea_tz = pytz.timezone('Asia/Seoul')
+        return datetime.now(korea_tz)
+    except:
+        return datetime.now()
 
 def format_korean_datetime(dt=None, format_type="filename"):
     """한국시간 포맷팅"""
@@ -61,108 +64,51 @@ def format_korean_datetime(dt=None, format_type="filename"):
     else:
         return dt.strftime("%y%m%d_%H%M")
 
-# ===== 데이터 처리 및 검증 함수들 =====
-def create_export_data_from_html(analysis_keyword, main_keyword, analysis_html, step1_data=None):
-    """분석 HTML과 1단계 데이터를 기반으로 export용 데이터 구조 생성 (더미 데이터 제거)"""
-    logger.info("=== 📊 Export 데이터 구조 생성 시작 (더미 데이터 제거 버전) ===")
+# ===== 로딩 애니메이션 =====
+def create_loading_animation():
+    """로딩 애니메이션 HTML"""
+    return """
+    <div style="display: flex; flex-direction: column; align-items: center; padding: 40px; background: white; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);">
+        <div style="width: 60px; height: 60px; border: 4px solid #f3f3f3; border-top: 4px solid #FB7F0D; border-radius: 50%; animation: spin 1s linear infinite; margin-bottom: 20px;"></div>
+        <h3 style="color: #FB7F0D; margin: 10px 0; font-size: 18px;">분석 중입니다...</h3>
+        <p style="color: #666; margin: 5px 0; text-align: center;">원격 서버에서 데이터를 수집하고 AI가 분석하고 있습니다.<br>잠시만 기다려주세요.</p>
+        <div style="width: 200px; height: 4px; background: #f0f0f0; border-radius: 2px; margin-top: 15px; overflow: hidden;">
+            <div style="width: 100%; height: 100%; background: linear-gradient(90deg, #FB7F0D, #ff9a8b); border-radius: 2px; animation: progress 2s ease-in-out infinite;"></div>
+        </div>
+    </div>
     
-    # 기본 export 데이터 구조
-    export_data = {
-        "main_keyword": main_keyword or analysis_keyword,
-        "analysis_keyword": analysis_keyword,
-        "analysis_html": analysis_html,
-        "main_keywords_df": None,
-        "related_keywords_df": None,
-        "analysis_completed": True,
-        "created_at": get_korean_time().isoformat()
+    <style>
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
     }
     
-    # 1단계 데이터에서 main_keywords_df 추출 (실제 데이터만)
-    if step1_data and isinstance(step1_data, dict):
-        if "keywords_df" in step1_data:
-            keywords_df = step1_data["keywords_df"]
-            if isinstance(keywords_df, dict):
-                try:
-                    export_data["main_keywords_df"] = pd.DataFrame(keywords_df)
-                    logger.info(f"✅ 1단계 키워드 데이터를 DataFrame으로 변환: {export_data['main_keywords_df'].shape}")
-                except Exception as e:
-                    logger.warning(f"⚠️ 1단계 데이터 변환 실패: {e}")
-                    export_data["main_keywords_df"] = None
-            elif hasattr(keywords_df, 'shape'):
-                export_data["main_keywords_df"] = keywords_df
-                logger.info(f"✅ 1단계 키워드 DataFrame 사용: {keywords_df.shape}")
-            else:
-                logger.info("📋 1단계 키워드 데이터가 유효하지 않음 - None으로 유지")
-                export_data["main_keywords_df"] = None
-    
-    # 분석 HTML에서 연관검색어 정보 추출 시도 (실제 데이터만)
-    if analysis_html and "연관검색어 분석" in analysis_html:
-        logger.info("🔍 분석 HTML에서 연관검색어 정보 발견 - 실제 파싱 필요")
-        # 실제 HTML 파싱 로직이 필요한 부분
-        # 현재는 더미 데이터 대신 None으로 유지
-        export_data["related_keywords_df"] = None
-        logger.info("💡 실제 HTML 파싱 로직 구현 필요 - 연관검색어 데이터는 None으로 유지")
-    
-    logger.info(f"📊 Export 데이터 구조 생성 완료 (더미 데이터 없음):")
-    logger.info(f"   - analysis_keyword: {export_data['analysis_keyword']}")
-    logger.info(f"   - main_keywords_df: {export_data['main_keywords_df'].shape if export_data['main_keywords_df'] is not None else 'None'}")
-    logger.info(f"   - related_keywords_df: {export_data['related_keywords_df'].shape if export_data['related_keywords_df'] is not None else 'None'}")
-    logger.info(f"   - analysis_html: {len(str(export_data['analysis_html']))} 문자")
-    
-    return export_data
-
-def validate_and_repair_export_data(export_data):
-    """Export 데이터 유효성 검사 및 복구 (더미 데이터 제거)"""
-    logger.info("🔧 Export 데이터 유효성 검사 및 복구 시작 (더미 데이터 제거 버전)")
-    
-    if not export_data or not isinstance(export_data, dict):
-        logger.warning("⚠️ Export 데이터가 없거나 딕셔너리가 아님 - 기본 구조 생성")
-        return {
-            "main_keyword": "기본키워드",
-            "analysis_keyword": "기본분석키워드",
-            "analysis_html": "<div>기본 분석 결과</div>",
-            "main_keywords_df": None,  # 더미 데이터 대신 None
-            "related_keywords_df": None,  # 더미 데이터 대신 None
-            "analysis_completed": True
-        }
-    
-    # 필수 키들 확인 및 복구
-    required_keys = {
-        "analysis_keyword": "분석키워드",
-        "main_keyword": "메인키워드", 
-        "analysis_html": "<div>분석 완료</div>",
-        "analysis_completed": True
+    @keyframes progress {
+        0% { transform: translateX(-100%); }
+        100% { transform: translateX(100%); }
     }
-    
-    for key, default_value in required_keys.items():
-        if key not in export_data or not export_data[key]:
-            export_data[key] = default_value
-            logger.info(f"🔧 {key} 키 복구: {default_value}")
-    
-    # DataFrame 데이터 검증 및 변환 (더미 데이터 생성 안함)
-    for df_key in ["main_keywords_df", "related_keywords_df"]:
-        if df_key in export_data and export_data[df_key] is not None:
-            df_data = export_data[df_key]
-            
-            # 딕셔너리를 DataFrame으로 변환
-            if isinstance(df_data, dict):
-                try:
-                    # 빈 딕셔너리는 None으로 처리
-                    if not df_data:
-                        export_data[df_key] = None
-                        logger.info(f"📋 {df_key} 빈 딕셔너리 - None으로 설정")
-                    else:
-                        export_data[df_key] = pd.DataFrame(df_data)
-                        logger.info(f"✅ {df_key} 딕셔너리를 DataFrame으로 변환 성공")
-                except Exception as e:
-                    logger.warning(f"⚠️ {df_key} 변환 실패: {e}")
-                    export_data[df_key] = None
-            elif not hasattr(df_data, 'shape'):
-                logger.warning(f"⚠️ {df_key}가 DataFrame이 아님 - None으로 설정")
-                export_data[df_key] = None
-    
-    logger.info("✅ Export 데이터 유효성 검사 및 복구 완료 (더미 데이터 없음)")
-    return export_data
+    </style>
+    """
+
+# ===== 에러 처리 함수 =====
+def generate_error_response(error_message):
+    """에러 응답 생성"""
+    return f'''
+    <div style="color: red; padding: 30px; text-align: center; width: 100%; 
+                background-color: #f8d7da; border-radius: 12px; border: 1px solid #f5c6cb;">
+        <h3 style="margin-bottom: 15px;">❌ 연결 오류</h3>
+        <p style="margin-bottom: 20px;">{error_message}</p>
+        <div style="background: white; padding: 15px; border-radius: 8px; color: #333;">
+            <h4>해결 방법:</h4>
+            <ul style="text-align: left; padding-left: 20px;">
+                <li>네트워크 연결을 확인해주세요</li>
+                <li>원격 서버 상태를 확인해주세요</li>
+                <li>잠시 후 다시 시도해주세요</li>
+                <li>문제가 지속되면 관리자에게 문의하세요</li>
+            </ul>
+        </div>
+    </div>
+    '''
 
 # ===== 파일 출력 함수들 =====
 def create_timestamp_filename(analysis_keyword):
@@ -172,109 +118,6 @@ def create_timestamp_filename(analysis_keyword):
     safe_keyword = re.sub(r'[-\s]+', '_', safe_keyword)
     return f"{safe_keyword}_{timestamp}_분석결과"
 
-def export_to_excel(main_keyword, main_keywords_df, analysis_keyword, related_keywords_df, filename_base):
-    """엑셀 파일로 출력 (실제 데이터만)"""
-    try:
-        # 실제 데이터가 있는지 확인
-        has_main_data = main_keywords_df is not None and not main_keywords_df.empty
-        has_related_data = related_keywords_df is not None and not related_keywords_df.empty
-        
-        if not has_main_data and not has_related_data:
-            logger.info("📋 생성할 데이터가 없어 엑셀 파일 생성 건너뜀")
-            return None
-        
-        excel_filename = f"{filename_base}.xlsx"
-        excel_path = os.path.join(tempfile.gettempdir(), excel_filename)
-        
-        with pd.ExcelWriter(excel_path, engine='xlsxwriter') as writer:
-            # 워크북과 워크시트 스타일 설정
-            workbook = writer.book
-            
-            # 헤더 스타일
-            header_format = workbook.add_format({
-                'bold': True,
-                'text_wrap': True,
-                'valign': 'top',
-                'fg_color': '#D7E4BC',
-                'border': 1
-            })
-            
-            # 데이터 스타일
-            data_format = workbook.add_format({
-                'text_wrap': True,
-                'valign': 'top',
-                'border': 1
-            })
-            
-            # 숫자 포맷
-            number_format = workbook.add_format({
-                'num_format': '#,##0',
-                'text_wrap': True,
-                'valign': 'top',
-                'border': 1
-            })
-            
-            # 첫 번째 시트: 메인키워드 조합키워드 (실제 데이터만)
-            if has_main_data:
-                main_keywords_df.to_excel(writer, sheet_name=f'{main_keyword}_조합키워드', index=False)
-                worksheet1 = writer.sheets[f'{main_keyword}_조합키워드']
-                
-                # 헤더 스타일 적용
-                for col_num, value in enumerate(main_keywords_df.columns.values):
-                    worksheet1.write(0, col_num, value, header_format)
-                
-                # 데이터 스타일 적용
-                for row_num in range(1, len(main_keywords_df) + 1):
-                    for col_num, value in enumerate(main_keywords_df.iloc[row_num-1]):
-                        if isinstance(value, (int, float)) and col_num in [1, 2, 3]:  # 검색량 컬럼
-                            worksheet1.write(row_num, col_num, value, number_format)
-                        else:
-                            worksheet1.write(row_num, col_num, value, data_format)
-                
-                # 열 너비 자동 조정
-                for i, col in enumerate(main_keywords_df.columns):
-                    max_len = max(
-                        main_keywords_df[col].astype(str).map(len).max(),
-                        len(str(col))
-                    )
-                    worksheet1.set_column(i, i, min(max_len + 2, 50))
-                
-                logger.info(f"✅ 메인키워드 시트 생성: {main_keywords_df.shape}")
-            
-            # 두 번째 시트: 분석키워드 연관검색어 (실제 데이터만)
-            if has_related_data:
-                related_keywords_df.to_excel(writer, sheet_name=f'{analysis_keyword}_연관검색어', index=False)
-                worksheet2 = writer.sheets[f'{analysis_keyword}_연관검색어']
-                
-                # 헤더 스타일 적용
-                for col_num, value in enumerate(related_keywords_df.columns.values):
-                    worksheet2.write(0, col_num, value, header_format)
-                
-                # 데이터 스타일 적용
-                for row_num in range(1, len(related_keywords_df) + 1):
-                    for col_num, value in enumerate(related_keywords_df.iloc[row_num-1]):
-                        if isinstance(value, (int, float)) and col_num in [1, 2, 3]:  # 검색량 컬럼
-                            worksheet2.write(row_num, col_num, value, number_format)
-                        else:
-                            worksheet2.write(row_num, col_num, value, data_format)
-                
-                # 열 너비 자동 조정
-                for i, col in enumerate(related_keywords_df.columns):
-                    max_len = max(
-                        related_keywords_df[col].astype(str).map(len).max(),
-                        len(str(col))
-                    )
-                    worksheet2.set_column(i, i, min(max_len + 2, 50))
-                
-                logger.info(f"✅ 연관검색어 시트 생성: {related_keywords_df.shape}")
-        
-        logger.info(f"엑셀 파일 생성 완료: {excel_path}")
-        return excel_path
-        
-    except Exception as e:
-        logger.error(f"엑셀 파일 생성 오류: {e}")
-        return None
-
 def export_to_html(analysis_html, filename_base):
     """HTML 파일로 출력 - 한국시간 적용"""
     try:
@@ -291,7 +134,7 @@ def export_to_html(analysis_html, filename_base):
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>키워드 심충분석 결과</title>
+    <title>키워드 심층분석 결과</title>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css">
     <style>
@@ -395,8 +238,8 @@ def export_to_html(analysis_html, filename_base):
 <body>
     <div class="container">
         <div class="header">
-            <h1><i class="fas fa-chart-line"></i> 키워드 심충분석 결과</h1>
-            <p>AI 상품 소싱 분석 시스템 v3.2 (더미 데이터 제거 버전)</p>
+            <h1><i class="fas fa-chart-line"></i> 키워드 심층분석 결과</h1>
+            <p>AI 상품 소싱 분석 시스템 v2.10</p>
         </div>
         <div class="content">
             {analysis_html}
@@ -419,418 +262,170 @@ def export_to_html(analysis_html, filename_base):
         logger.error(f"HTML 파일 생성 오류: {e}")
         return None
 
-def create_zip_file(excel_path, html_path, filename_base):
-    """압축 파일 생성"""
+def create_zip_file(html_path, filename_base):
+    """압축 파일 생성 (HTML만)"""
     try:
         zip_filename = f"{filename_base}.zip"
         zip_path = os.path.join(tempfile.gettempdir(), zip_filename)
         
-        files_added = 0
         with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
-            if excel_path and os.path.exists(excel_path):
-                zipf.write(excel_path, f"{filename_base}.xlsx")
-                logger.info(f"엑셀 파일 압축 추가: {filename_base}.xlsx")
-                files_added += 1
-            
             if html_path and os.path.exists(html_path):
                 zipf.write(html_path, f"{filename_base}.html")
                 logger.info(f"HTML 파일 압축 추가: {filename_base}.html")
-                files_added += 1
-        
-        if files_added == 0:
-            logger.warning("압축할 파일이 없음")
-            return None
         
-        logger.info(f"압축 파일 생성 완료: {zip_path} ({files_added}개 파일)")
+        logger.info(f"압축 파일 생성 완료: {zip_path}")
         return zip_path
         
     except Exception as e:
         logger.error(f"압축 파일 생성 오류: {e}")
         return None
 
-def export_analysis_results_enhanced(export_data):
-    """강화된 분석 결과 출력 메인 함수 (더미 데이터 제거)"""
+def export_analysis_results(export_data):
+    """분석 결과 출력 메인 함수 - 세션별 데이터 처리"""
     try:
-        logger.info("=== 📊 강화된 출력 함수 시작 (더미 데이터 제거 버전) ===")
+        # 출력할 데이터 확인
+        if not export_data or not isinstance(export_data, dict):
+            return None, "분석 데이터가 없습니다. 먼저 키워드 심층분석을 실행해주세요."
         
-        # 데이터 유효성 검사 및 복구
-        export_data = validate_and_repair_export_data(export_data)
+        analysis_keyword = export_data.get("analysis_keyword", "")
+        analysis_html = export_data.get("analysis_html", "")
         
-        analysis_keyword = export_data.get("analysis_keyword", "기본키워드")
-        analysis_html = export_data.get("analysis_html", "<div>분석 완료</div>")
-        main_keyword = export_data.get("main_keyword", analysis_keyword)
-        main_keywords_df = export_data.get("main_keywords_df")
-        related_keywords_df = export_data.get("related_keywords_df")
+        if not analysis_keyword:
+            return None, "분석할 키워드가 설정되지 않았습니다. 먼저 키워드 분석을 실행해주세요."
         
-        logger.info(f"🔍 처리할 데이터:")
-        logger.info(f"   - analysis_keyword: '{analysis_keyword}'")
-        logger.info(f"   - main_keyword: '{main_keyword}'")
-        logger.info(f"   - analysis_html: {len(str(analysis_html))} 문자")
-        logger.info(f"   - main_keywords_df: {main_keywords_df.shape if main_keywords_df is not None else 'None'}")
-        logger.info(f"   - related_keywords_df: {related_keywords_df.shape if related_keywords_df is not None else 'None'}")
+        if not analysis_html:
+            return None, "분석 결과가 없습니다. 먼저 키워드 심층분석을 실행해주세요."
         
         # 파일명 생성 (한국시간 적용)
         filename_base = create_timestamp_filename(analysis_keyword)
-        logger.info(f"📁 출력 파일명: {filename_base}")
-        
-        # HTML 파일은 분석 결과가 있으면 생성
-        html_path = None
-        if analysis_html and len(str(analysis_html).strip()) > 20:  # 의미있는 HTML인지 확인
-            logger.info("🌐 HTML 파일 생성 시작...")
-            html_path = export_to_html(analysis_html, filename_base)
-            if html_path:
-                logger.info(f"✅ HTML 파일 생성 성공: {html_path}")
-            else:
-                logger.error("❌ HTML 파일 생성 실패")
-        else:
-            logger.info("📄 분석 HTML이 없어 HTML 파일 생성 건너뜀")
-        
-        # 엑셀 파일 생성 (실제 DataFrame이 있는 경우만)
-        excel_path = None
-        if (main_keywords_df is not None and not main_keywords_df.empty) or \
-           (related_keywords_df is not None and not related_keywords_df.empty):
-            logger.info("📊 엑셀 파일 생성 시작...")
-            excel_path = export_to_excel(
-                main_keyword,
-                main_keywords_df,
-                analysis_keyword,
-                related_keywords_df,
-                filename_base
-            )
-            if excel_path:
-                logger.info(f"✅ 엑셀 파일 생성 성공: {excel_path}")
-            else:
-                logger.warning("⚠️ 엑셀 파일 생성 실패")
-        else:
-            logger.info("📊 실제 DataFrame 데이터가 없어 엑셀 파일 생성 생략")
+        logger.info(f"출력 파일명: {filename_base}")
         
-        # 생성된 파일이 있는지 확인
-        if not html_path and not excel_path:
-            logger.warning("⚠️ 생성된 파일이 없음")
-            return None, "⚠️ 생성할 수 있는 데이터가 없습니다. 분석을 먼저 완료해주세요."
+        # HTML 파일 생성
+        html_path = export_to_html(analysis_html, filename_base)
         
         # 압축 파일 생성
-        logger.info("📦 압축 파일 생성 시작...")
-        zip_path = create_zip_file(excel_path, html_path, filename_base)
-        if zip_path:
-            file_types = []
-            if html_path:
-                file_types.append("HTML")
-            if excel_path:
-                file_types.append("엑셀")
-            
-            file_list = " + ".join(file_types)
-            logger.info(f"✅ 압축 파일 생성 성공: {zip_path} ({file_list})")
-            return zip_path, f"✅ 분석 결과가 성공적으로 출력되었습니다!\n파일명: {filename_base}.zip\n포함 파일: {file_list}\n\n💡 더미 데이터 제거 버전 - 실제 분석 데이터만 포함됩니다."
+        if html_path:
+            zip_path = create_zip_file(html_path, filename_base)
+            if zip_path:
+                return zip_path, f"✅ 분석 결과가 성공적으로 출력되었습니다!\n파일명: {filename_base}.zip"
+            else:
+                return None, "압축 파일 생성에 실패했습니다."
         else:
-            logger.error("❌ 압축 파일 생성 실패")
-            return None, "압축 파일 생성에 실패했습니다."
+            return None, "출력할 파일이 없습니다."
     
     except Exception as e:
-        logger.error(f"❌ 강화된 출력 함수 전체 오류: {e}")
-        import traceback
-        logger.error(f"스택 트레이스:\n{traceback.format_exc()}")
+        logger.error(f"분석 결과 출력 오류: {e}")
         return None, f"출력 중 오류가 발생했습니다: {str(e)}"
 
-# ===== 로딩 애니메이션 =====
-def create_loading_animation():
-    """로딩 애니메이션 HTML"""
-    return """
-    <div style="display: flex; flex-direction: column; align-items: center; padding: 40px; background: white; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);">
-        <div style="width: 60px; height: 60px; border: 4px solid #f3f3f3; border-top: 4px solid #FB7F0D; border-radius: 50%; animation: spin 1s linear infinite; margin-bottom: 20px;"></div>
-        <h3 style="color: #FB7F0D; margin: 10px 0; font-size: 18px;">분석 중입니다...</h3>
-        <p style="color: #666; margin: 5px 0; text-align: center;">원격 서버에서 데이터를 수집하고 AI가 분석하고 있습니다.<br>잠시만 기다려주세요.</p>
-        <div style="width: 200px; height: 4px; background: #f0f0f0; border-radius: 2px; margin-top: 15px; overflow: hidden;">
-            <div style="width: 100%; height: 100%; background: linear-gradient(90deg, #FB7F0D, #ff9a8b); border-radius: 2px; animation: progress 2s ease-in-out infinite;"></div>
-        </div>
-    </div>
-    
-    <style>
-    @keyframes spin {
-        0% { transform: rotate(0deg); }
-        100% { transform: rotate(360deg); }
-    }
-    
-    @keyframes progress {
-        0% { transform: translateX(-100%); }
-        100% { transform: translateX(100%); }
-    }
-    </style>
-    """
-
-# ===== 에러 처리 함수 =====
-def generate_error_response(error_message):
-    """에러 응답 생성"""
-    return f'''
-    <div style="color: red; padding: 30px; text-align: center; width: 100%; 
-                background-color: #f8d7da; border-radius: 12px; border: 1px solid #f5c6cb;">
-        <h3 style="margin-bottom: 15px;">❌ 연결 오류</h3>
-        <p style="margin-bottom: 20px;">{error_message}</p>
-        <div style="background: white; padding: 15px; border-radius: 8px; color: #333;">
-            <h4>해결 방법:</h4>
-            <ul style="text-align: left; padding-left: 20px;">
-                <li>네트워크 연결을 확인해주세요</li>
-                <li>원격 서버 상태를 확인해주세요</li>
-                <li>잠시 후 다시 시도해주세요</li>
-                <li>문제가 지속되면 관리자에게 문의하세요</li>
-            </ul>
-        </div>
-    </div>
-    '''
-
 # ===== 원격 API 호출 함수들 =====
-def call_collect_data_api(keyword):
-    """1단계: 상품 데이터 수집 API 호출"""
+def call_analyze_keyword_api(analysis_keyword):
+    """키워드 심층분석 API 호출"""
     try:
         client = get_api_client()
         if not client:
             return generate_error_response("API 클라이언트를 초기화할 수 없습니다."), {}
         
-        logger.info("원격 API 호출: 상품 데이터 수집")
+        logger.info("원격 API 호출: 키워드 심층분석")
         result = client.predict(
-            keyword=keyword,
-            api_name="/on_collect_data"
+            analysis_keyword=analysis_keyword,
+            api_name="/on_analyze_keyword"
         )
         
-        logger.info(f"데이터 수집 API 결과 타입: {type(result)}")
-        
-        # 결과가 튜플인 경우 첫 번째 요소는 HTML, 두 번째는 세션 데이터
-        if isinstance(result, tuple) and len(result) == 2:
-            html_result, session_data = result
-            
-            # 세션 데이터가 제대로 있는지 확인
-            if isinstance(session_data, dict):
-                logger.info(f"데이터 수집 세션 데이터 수신: {list(session_data.keys()) if session_data else '빈 딕셔너리'}")
-                return html_result, session_data
-            else:
-                logger.warning("세션 데이터가 딕셔너리가 아닙니다.")
-                return html_result, {}
+        logger.info(f"키워드 분석 API 결과 타입: {type(result)}")
+        
+        # 분석 결과로 export 데이터 생성
+        if isinstance(result, str) and len(result) > 100:
+            export_data = {
+                "analysis_keyword": analysis_keyword,
+                "analysis_html": result,
+                "analysis_completed": True,
+                "created_at": get_korean_time().isoformat()
+            }
+            return result, export_data
         else:
-            logger.warning("예상과 다른 데이터 수집 결과 형태")
-            return str(result), {"keywords_collected": True}
+            return str(result), {}
             
     except Exception as e:
-        logger.error(f"상품 데이터 수집 API 호출 오류: {e}")
+        logger.error(f"키워드 심층분석 API 호출 오류: {e}")
         return generate_error_response(f"원격 서버 연결 실패: {str(e)}"), {}
 
-def call_analyze_keyword_api_enhanced(analysis_keyword, base_keyword, keywords_data):
-    """3단계: 강화된 키워드 심충분석 API 호출 (더미 데이터 제거)"""
+def call_export_results_api(export_data):
+    """분석 결과 출력 API 호출"""
     try:
         client = get_api_client()
         if not client:
-            return generate_error_response("API 클라이언트를 초기화할 수 없습니다."), {}
-        
-        logger.info("=== 🚀 강화된 키워드 심충분석 API 호출 (더미 데이터 제거) ===")
-        logger.info(f"파라미터 - analysis_keyword: '{analysis_keyword}'")
-        logger.info(f"파라미터 - base_keyword: '{base_keyword}'")
-        logger.info(f"파라미터 - keywords_data 타입: {type(keywords_data)}")
+            return None, "API 클라이언트를 초기화할 수 없습니다."
         
-        # 원격 API 호출
+        logger.info("원격 API 호출: 분석 결과 출력")
         result = client.predict(
-            analysis_keyword,
-            base_keyword, 
-            keywords_data,
-            api_name="/on_analyze_keyword"
+            api_name="/on_export_results"
         )
         
-        logger.info(f"📡 원격 API 응답 수신:")
-        logger.info(f"   - 응답 타입: {type(result)}")
-        logger.info(f"   - 응답 길이: {len(result) if hasattr(result, '__len__') else 'N/A'}")
+        logger.info(f"출력 API 결과 타입: {type(result)}")
         
-        # 응답 처리 및 Export 데이터 구조 생성
+        # 결과가 튜플인 경우 첫 번째 요소는 메시지, 두 번째는 파일
         if isinstance(result, tuple) and len(result) == 2:
-            html_result, remote_export_data = result
-            
-            logger.info(f"📊 원격 export 데이터:")
-            logger.info(f"   - 타입: {type(remote_export_data)}")
-            logger.info(f"   - 키들: {list(remote_export_data.keys()) if isinstance(remote_export_data, dict) else 'None'}")
-            
-            # HTML 결과가 있으면 Export 데이터 구조 생성 (더미 데이터 없이)
-            if html_result:
-                logger.info("🔧 Export 데이터 구조 생성 시작 (더미 데이터 제거)")
-                enhanced_export_data = create_export_data_from_html(
-                    analysis_keyword=analysis_keyword,
-                    main_keyword=base_keyword,
-                    analysis_html=html_result,
-                    step1_data=keywords_data
-                )
-                
-                # 원격에서 온 실제 데이터가 있으면 병합
-                if isinstance(remote_export_data, dict) and remote_export_data:
-                    logger.info("🔗 원격 실제 데이터와 로컬 데이터 병합")
-                    for key, value in remote_export_data.items():
-                        if value is not None and key in ["main_keywords_df", "related_keywords_df"]:
-                            # DataFrame 데이터만 검증하여 병합
-                            if isinstance(value, dict) and value:  # 빈 딕셔너리가 아닌 경우만
-                                enhanced_export_data[key] = value
-                                logger.info(f"   - {key} 원격 실제 데이터로 업데이트")
-                            elif hasattr(value, 'shape') and not value.empty:  # DataFrame이고 비어있지 않은 경우
-                                enhanced_export_data[key] = value
-                                logger.info(f"   - {key} 원격 DataFrame 데이터로 업데이트")
-                        elif value is not None and key not in ["main_keywords_df", "related_keywords_df"]:
-                            enhanced_export_data[key] = value
-                            logger.info(f"   - {key} 원격 데이터로 업데이트")
-                
-                logger.info(f"✅ 최종 Export 데이터 구조 (더미 데이터 없음):")
-                logger.info(f"   - 키 개수: {len(enhanced_export_data)}")
-                logger.info(f"   - 키 목록: {list(enhanced_export_data.keys())}")
-                
-                return html_result, enhanced_export_data
+            message, file_path = result
+            if file_path:
+                return file_path, message
             else:
-                logger.warning("⚠️ HTML 결과가 비어있음")
-                return str(result), {}
+                return None, message
         else:
-            logger.warning("⚠️ 예상과 다른 API 응답 형태")
-            # HTML만 반환된 경우도 처리
-            if isinstance(result, str) and len(result) > 100:  # HTML일 가능성이 높음
-                logger.info("📄 HTML 문자열로 추정되는 응답 - Export 데이터 생성 (더미 데이터 없이)")
-                enhanced_export_data = create_export_data_from_html(
-                    analysis_keyword=analysis_keyword,
-                    main_keyword=base_keyword,
-                    analysis_html=result,
-                    step1_data=keywords_data
-                )
-                return result, enhanced_export_data
-            else:
-                return str(result), {}
+            return None, str(result)
             
     except Exception as e:
-        logger.error(f"❌ 키워드 심충분석 API 호출 오류: {e}")
-        import traceback
-        logger.error(f"스택 트레이스:\n{traceback.format_exc()}")
-        return generate_error_response(f"원격 서버 연결 실패: {str(e)}"), {}
+        logger.error(f"분석 결과 출력 API 호출 오류: {e}")
+        return None, f"원격 서버 연결 실패: {str(e)}"
 
 # ===== 그라디오 인터페이스 =====
 def create_interface():
-    # CSS 스타일링 (기존과 동일)
-    custom_css = """
-    /* 기존 다크모드 자동 변경 AI 상품 소싱 분석 시스템 CSS */
-    :root {
-        --primary-color: #FB7F0D;
-        --secondary-color: #ff9a8b;
-        --accent-color: #FF6B6B;
-        --background-color: #FFFFFF;
-        --card-bg: #ffffff;
-        --input-bg: #ffffff;
-        --text-color: #334155;
-        --text-secondary: #64748b;
-        --border-color: #dddddd;
-        --border-light: #e5e5e5;
-        --table-even-bg: #f3f3f3;
-        --table-hover-bg: #f0f0f0;
-        --shadow: 0 8px 30px rgba(251, 127, 13, 0.08);
-        --shadow-light: 0 2px 4px rgba(0, 0, 0, 0.1);
-        --border-radius: 18px;
-    }
-    @media (prefers-color-scheme: dark) {
-        :root {
-            --background-color: #1a1a1a;
-            --card-bg: #2d2d2d;
-            --input-bg: #2d2d2d;
-            --text-color: #e5e5e5;
-            --text-secondary: #a1a1aa;
-            --border-color: #404040;
-            --border-light: #525252;
-            --table-even-bg: #333333;
-            --table-hover-bg: #404040;
-            --shadow: 0 8px 30px rgba(0, 0, 0, 0.3);
-            --shadow-light: 0 2px 4px rgba(0, 0, 0, 0.2);
+    # CSS 파일 로드
+    try:
+        with open('style.css', 'r', encoding='utf-8') as f:
+            custom_css = f.read()
+    except:
+        custom_css = """
+        :root { --primary-color: #FB7F0D; --secondary-color: #ff9a8b; }
+        .custom-button { 
+            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)) !important;
+            color: white !important; border-radius: 30px !important; height: 45px !important;
+            font-size: 16px !important; font-weight: bold !important; width: 100% !important;
         }
-    }
-    body {
-        font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif;
-        background-color: var(--background-color) !important;
-        color: var(--text-color) !important;
-        line-height: 1.6;
-        margin: 0;
-        padding: 0;
-        transition: background-color 0.3s ease, color 0.3s ease;
-    }
-    .gradio-container {
-        width: 100%;
-        margin: 0 auto;
-        padding: 20px;
-        background-color: var(--background-color) !important;
-    }
-    .custom-frame {
-        background-color: var(--card-bg) !important;
-        border: 1px solid var(--border-light) !important;
-        border-radius: var(--border-radius);
-        padding: 20px;
-        margin: 10px 0;
-        box-shadow: var(--shadow) !important;
-        color: var(--text-color) !important;
-    }
-    .custom-button {
-        border-radius: 30px !important;
-        background: var(--primary-color) !important;
-        color: white !important;
-        font-size: 18px !important;
-        padding: 10px 20px !important;
-        border: none;
-        box-shadow: 0 4px 8px rgba(251, 127, 13, 0.25);
-        transition: transform 0.3s ease;
-        height: 45px !important;
-        width: 100% !important;
-    }
-    .custom-button:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 6px 12px rgba(251, 127, 13, 0.3);
-    }
-    .export-button {
-        background: linear-gradient(135deg, #28a745, #20c997) !important;
-        color: white !important; 
-        border-radius: 25px !important; 
-        height: 50px !important;
-        font-size: 17px !important; 
-        font-weight: bold !important; 
-        width: 100% !important;
-        margin-top: 20px !important;
-    }
-    .section-title {
-        display: flex;
-        align-items: center;
-        font-size: 20px;
-        font-weight: 700;
-        color: var(--text-color) !important;
-        margin-bottom: 10px;
-        padding-bottom: 5px;
-        border-bottom: 2px solid var(--primary-color);
-        font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif;
-    }
-    .section-title img, .section-title i {
-        margin-right: 10px;
-        font-size: 20px;
-        color: var(--primary-color);
-    }
-    .gr-input, .gr-text-input, .gr-sample-inputs,
-    input[type="text"], input[type="number"], textarea, select {
-        border-radius: var(--border-radius) !important;
-        border: 1px solid var(--border-color) !important;
-        padding: 12px !important;
-        box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.05) !important;
-        transition: all 0.3s ease !important;
-        background-color: var(--input-bg) !important;
-        color: var(--text-color) !important;
-    }
-    .gr-input:focus, .gr-text-input:focus,
-    input[type="text"]:focus, textarea:focus, select:focus {
-        border-color: var(--primary-color) !important;
-        outline: none !important;
-        box-shadow: 0 0 0 2px rgba(251, 127, 13, 0.2) !important;
-    }
-    .fade-in {
-        animation: fadeIn 0.5s ease-out;
-    }
-    @keyframes fadeIn {
-        from { opacity: 0; transform: translateY(10px); }
-        to { opacity: 1; transform: translateY(0); }
-    }
-    """
+        .export-button {
+            background: linear-gradient(135deg, #28a745, #20c997) !important;
+            color: white !important; border-radius: 25px !important; height: 50px !important;
+            font-size: 17px !important; font-weight: bold !important; width: 100% !important;
+            margin-top: 20px !important;
+        }
+        .custom-frame {
+            background-color: white !important;
+            border: 1px solid #e5e5e5 !important;
+            border-radius: 18px;
+            padding: 20px;
+            margin: 10px 0;
+            box-shadow: 0 8px 30px rgba(251, 127, 13, 0.08) !important;
+        }
+        .section-title {
+            display: flex;
+            align-items: center;
+            font-size: 20px;
+            font-weight: 700;
+            color: #334155 !important;
+            margin-bottom: 10px;
+            padding-bottom: 5px;
+            border-bottom: 2px solid var(--primary-color);
+            font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif;
+        }
+        .section-title img, .section-title i {
+            margin-right: 10px;
+            font-size: 20px;
+            color: var(--primary-color);
+        }
+        """
     
     with gr.Blocks(
         css=custom_css, 
-        title="🛒 AI 상품 소싱 분석기 v3.2 (더미 데이터 제거)",
+        title="🛒 AI 상품 소싱 분석기 v2.10",
         theme=gr.themes.Default(primary_hue="orange", secondary_hue="orange")
     ) as interface:
         
@@ -840,103 +435,64 @@ def create_interface():
         <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css">
         """)
         
-        # 세션별 상태 변수
-        keywords_data_state = gr.State()
+        # 세션별 상태 관리 (멀티 사용자 안전)
         export_data_state = gr.State({})
         
-        # === UI 컴포넌트들 ===
-        with gr.Column(elem_classes="custom-frame fade-in"):
-            gr.HTML('<div class="section-title"><i class="fas fa-search"></i> 1단계: 메인 키워드 입력</div>')
-            
-            keyword_input = gr.Textbox(
-                label="상품 메인키워드", 
-                placeholder="예: 슬리퍼, 무선이어폰, 핸드크림",
-                value="",
-                elem_id="keyword_input"
-            )
-            
-            collect_data_btn = gr.Button("1단계: 상품 데이터 수집하기", elem_classes="custom-button", size="lg")
-        
+        # === 키워드 심층분석 입력 ===
         with gr.Column(elem_classes="custom-frame fade-in"):
-            gr.HTML('<div class="section-title"><i class="fas fa-database"></i> 2단계: 수집된 키워드 목록</div>')
-            keywords_result = gr.HTML()
-        
-        with gr.Column(elem_classes="custom-frame fade-in"):
-            gr.HTML('<div class="section-title"><i class="fas fa-bullseye"></i> 3단계: 분석할 키워드 선택</div>')
+            gr.HTML('<div class="section-title"><i class="fas fa-bullseye"></i> 키워드 심층분석 입력</div>')
             
             analysis_keyword_input = gr.Textbox(
                 label="분석할 키워드", 
-                placeholder="위 목록에서 원하는 키워드를 입력하세요 (예: 통굽 슬리퍼)",
+                placeholder="심층 분석할 키워드를 입력하세요 (예: 통굽 슬리퍼)",
                 value="",
                 elem_id="analysis_keyword_input"
             )
             
-            analyze_keyword_btn = gr.Button("키워드 심충분석 하기", elem_classes="custom-button", size="lg")
+            analyze_keyword_btn = gr.Button("키워드 심층분석 하기", elem_classes="custom-button", size="lg")
         
+        # === 키워드 심층분석 ===
         with gr.Column(elem_classes="custom-frame fade-in"):
-            gr.HTML('<div class="section-title"><i class="fas fa-chart-line"></i> 키워드 심충분석</div>')
-            analysis_result = gr.HTML(label="키워드 심충분석")
+            gr.HTML('<div class="section-title"><i class="fas fa-chart-line"></i> 키워드 심층분석</div>')
+            analysis_result = gr.HTML(label="키워드 심층분석")
         
+        # === 결과 출력 섹션 ===
         with gr.Column(elem_classes="custom-frame fade-in"):
             gr.HTML('<div class="section-title"><i class="fas fa-download"></i> 분석 결과 출력</div>')
-            
-            gr.HTML("""
-            <div style="background: #e3f2fd; border-left: 4px solid #2196f3; padding: 15px; margin: 10px 0; border-radius: 5px;">
-                <h4 style="margin: 0 0 10px 0; color: #1976d2;"><i class="fas fa-info-circle"></i> 실제 데이터 출력 버전</h4>
-                <p style="margin: 0; color: #1976d2; font-size: 14px;">
-                    • 분석된 데이터를 파일로 출력됩니다<br>
-                </p>
-            </div>
-            """)
         
             export_btn = gr.Button("📊 분석결과 출력하기", elem_classes="export-button", size="lg")
             export_result = gr.HTML()
             download_file = gr.File(label="다운로드", visible=False)
         
         # ===== 이벤트 핸들러 =====
-        def on_collect_data(keyword):
-            if not keyword.strip():
-                return ("<div style='color: red; padding: 20px; text-align: center; width: 100%;'>키워드를 입력해주세요.</div>", None)
-            
-            # 로딩 상태 표시
-            yield (create_loading_animation(), None)
-            
-            # 원격 API 호출
-            result_html, result_data = call_collect_data_api(keyword)
-            
-            yield (result_html, result_data)
-        
-        def on_analyze_keyword(analysis_keyword, base_keyword, keywords_data):
+        def on_analyze_keyword(analysis_keyword):
             if not analysis_keyword.strip():
-                return "<div style='color: red; padding: 20px; text-align: center; width: 100%;'>분석할 키워드를 입력해주세요.</div>", {}
+                return "분석할 키워드를 입력해주세요.", {}
             
             # 로딩 상태 표시
             yield create_loading_animation(), {}
             
-            # 강화된 API 호출 (더미 데이터 제거)
-            html_result, enhanced_export_data = call_analyze_keyword_api_enhanced(
-                analysis_keyword, base_keyword, keywords_data
-            )
+            # 실제 키워드 분석 실행
+            keyword_result, session_export_data = call_analyze_keyword_api(analysis_keyword)
             
-            yield html_result, enhanced_export_data
-                
+            # 📈 검색량 트렌드 분석과 🎯 키워드 분석 표시
+            yield keyword_result, session_export_data
+        
         def on_export_results(export_data):
-            """강화된 분석 결과 출력 핸들러 (더미 데이터 제거)"""
+            """분석 결과 출력 핸들러 - 세션별 데이터 처리"""
             try:
-                logger.info(f"📊 입력 export_data: {type(export_data)}")
-                if isinstance(export_data, dict):
-                    logger.info(f"📋 export_data 키들: {list(export_data.keys())}")
-                
-                # 강화된 출력 함수 호출 (더미 데이터 제거)
-                zip_path, message = export_analysis_results_enhanced(export_data)
+                # 로컬 출력 시도
+                zip_path, message = export_analysis_results(export_data)
                 
                 if zip_path:
+                    # 성공 메시지와 함께 다운로드 파일 제공
                     success_html = f"""
                     <div style="background: #d4edda; border: 1px solid #c3e6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
                         <h4 style="color: #155724; margin: 0 0 15px 0;"><i class="fas fa-check-circle"></i> 출력 완료!</h4>
                         <p style="color: #155724; margin: 0; line-height: 1.6;">
                             {message}<br>
-                            <strong>데이터출력:</strong><br>
+                            <strong>포함 파일:</strong><br>
+                            • 🌐 HTML 파일: 키워드 심층분석 결과 (그래프 포함)<br>
                             <br>
                             <i class="fas fa-download"></i> 아래 다운로드 버튼을 클릭하여 파일을 저장하세요.<br>
                             <small style="color: #666;">⏰ 한국시간 기준으로 파일명이 생성됩니다.</small>
@@ -945,64 +501,60 @@ def create_interface():
                     """
                     return success_html, gr.update(value=zip_path, visible=True)
                 else:
-                    error_html = f"""
-                    <div style="background: #f8d7da; border: 1px solid #f5c6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
-                        <h4 style="color: #721c24; margin: 0 0 10px 0;"><i class="fas fa-exclamation-triangle"></i> 출력 실패</h4>
-                        <p style="color: #721c24; margin: 0;">{message}</p>
-                        <div style="margin-top: 15px; padding: 15px; background: white; border-radius: 5px;">
-                            <h5 style="color: #721c24; margin: 0 0 10px 0;">🔍 디버깅 정보:</h5>
-                            <ul style="color: #721c24; margin: 0; padding-left: 20px;">
-                                <li>Export 데이터 타입: {type(export_data)}</li>
-                                <li>Export 데이터 유효성: {'유효' if export_data else '무효'}</li>
-                                <li>키워드 심충분석 상태: {'완료' if export_data.get('analysis_completed') else '미완료'}</li>
-                            </ul>
+                    # 로컬 출력 실패시 원격 API 시도
+                    try:
+                        remote_file, remote_message = call_export_results_api(export_data)
+                        if remote_file:
+                            success_html = f"""
+                            <div style="background: #d4edda; border: 1px solid #c3e6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
+                                <h4 style="color: #155724; margin: 0 0 15px 0;"><i class="fas fa-check-circle"></i> 원격 출력 완료!</h4>
+                                <p style="color: #155724; margin: 0; line-height: 1.6;">
+                                    {remote_message}<br>
+                                    <i class="fas fa-download"></i> 아래 다운로드 버튼을 클릭하여 파일을 저장하세요.
+                                </p>
+                            </div>
+                            """
+                            return success_html, gr.update(value=remote_file, visible=True)
+                        else:
+                            # 실패 메시지
+                            error_html = f"""
+                            <div style="background: #f8d7da; border: 1px solid #f5c6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
+                                <h4 style="color: #721c24; margin: 0 0 10px 0;"><i class="fas fa-exclamation-triangle"></i> 출력 실패</h4>
+                                <p style="color: #721c24; margin: 0;">{message}<br>원격 출력도 실패: {remote_message}</p>
+                            </div>
+                            """
+                            return error_html, gr.update(visible=False)
+                    except:
+                        # 원격 API도 실패
+                        error_html = f"""
+                        <div style="background: #f8d7da; border: 1px solid #f5c6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
+                            <h4 style="color: #721c24; margin: 0 0 10px 0;"><i class="fas fa-exclamation-triangle"></i> 출력 실패</h4>
+                            <p style="color: #721c24; margin: 0;">{message}</p>
                         </div>
-                    </div>
-                    """
-                    logger.error("❌ 강화된 출력 실패")
-                    return error_html, gr.update(visible=False)
+                        """
+                        return error_html, gr.update(visible=False)
                     
             except Exception as e:
-                logger.error(f"❌ 강화된 출력 핸들러 오류: {e}")
-                import traceback
-                logger.error(f"스택 트레이스:\n{traceback.format_exc()}")
-                
+                logger.error(f"출력 핸들러 오류: {e}")
                 error_html = f"""
                 <div style="background: #f8d7da; border: 1px solid #f5c6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
                     <h4 style="color: #721c24; margin: 0 0 10px 0;"><i class="fas fa-exclamation-triangle"></i> 시스템 오류</h4>
-                    <p style="color: #721c24; margin: 0;">강화된 출력 중 시스템 오류가 발생했습니다:</p>
-                    <code style="display: block; margin: 10px 0; padding: 10px; background: #f8f9fa; border-radius: 3px; color: #721c24;">
-                        {type(e).__name__}: {str(e)}
-                    </code>
-                    <div style="margin-top: 15px; padding: 10px; background: #fff3cd; border-radius: 5px;">
-                        <p style="margin: 0; color: #856404; font-size: 14px;">
-                            💡 실제 분석 결과가 있어야만 파일이 생성됩니다.
-                        </p>
-                    </div>
+                    <p style="color: #721c24; margin: 0;">출력 중 시스템 오류가 발생했습니다: {str(e)}</p>
                 </div>
                 """
                 return error_html, gr.update(visible=False)
         
         # ===== 이벤트 연결 =====
-        collect_data_btn.click(
-            fn=on_collect_data,
-            inputs=[keyword_input],
-            outputs=[keywords_result, keywords_data_state],
-            api_name="on_collect_data"
-        )
-        
         analyze_keyword_btn.click(
             fn=on_analyze_keyword,
-            inputs=[analysis_keyword_input, keyword_input, keywords_data_state],  
-            outputs=[analysis_result, export_data_state],
-            api_name="on_analyze_keyword"
+            inputs=[analysis_keyword_input],
+            outputs=[analysis_result, export_data_state]
         )
         
         export_btn.click(
             fn=on_export_results,
             inputs=[export_data_state],
-            outputs=[export_result, download_file],
-            api_name="on_export_results"
+            outputs=[export_result, download_file]
         )
     
     return interface
@@ -1014,8 +566,37 @@ if __name__ == "__main__":
         import pytz
         logger.info("✅ pytz 모듈 로드 성공 - 한국시간 지원")
     except ImportError:
+        logger.warning("⚠️ pytz 모듈이 설치되지 않음 - pip install pytz 실행 필요")
         logger.info("시스템 시간을 사용합니다.")
     
+    logger.info("===== 상품 소싱 분석 시스템 v2.10 (컨트롤 타워 버전) 시작 =====")
+    
+    # 필요한 패키지 안내
+    print("📦 필요한 패키지:")
+    print("   pip install gradio gradio_client pandas pytz")
+    print()
+    
+    # API 엔드포인트 설정 안내
+    api_endpoint = os.getenv('API_ENDPOINT')
+    if not api_endpoint:
+        print("⚠️  API_ENDPOINT 환경변수를 설정하세요.")
+        print("   export API_ENDPOINT='your-endpoint-url'")
+        print()
+    else:
+        print("✅ API 엔드포인트 설정 완료!")
+        print()
+    
+    print("🚀 v2.10 컨트롤 타워 버전 특징:")
+    print("   • 허깅페이스 그라디오 엔드포인트 활용")
+    print("   • 완전히 동일한 UI와 기능 구현")
+    print("   • 📈 검색량 트렌드 분석과 🎯 키워드 분석 표시")
+    print("   • ✅ 출력 기능: HTML 파일 생성 및 ZIP 다운로드")
+    print("   • ✅ 한국시간 기준 파일명 생성")
+    print("   • ✅ 멀티 사용자 안전: gr.State로 세션별 데이터 관리")
+    print("   • 🔒 클라이언트 정보 환경변수로 완전 숨김")
+    print("   • 원격 서버와 로컬 처리 하이브리드 방식")
+    print()
+    
     # 앱 실행
     app = create_interface()
     app.launch(server_name="0.0.0.0", server_port=7860, share=True)