Upload 11 files

api_utils.py

@@ -0,0 +1,253 @@
+"""
+API 관련 유틸리티 함수 모음 (환경변수 버전)
+- API 키 관리 (환경변수에서 로드)
+- 시그니처 생성
+- API 헤더 생성
+- Gemini API 키 랜덤 로테이션 추가
+"""
+
+import os
+import time
+import hmac
+import hashlib
+import base64
+import requests
+import threading
+import random
+import google.generativeai as genai
+import logging
+
+logger = logging.getLogger(__name__)
+
+# 환경변수에서 API 설정 로드
+def get_api_configs():
+    # 환경변수 'API_CONFIGS'에서 전체 설정을 가져옴
+    api_configs_str = os.getenv('API_CONFIGS', '')
+    
+    if not api_configs_str:
+        logger.error("API_CONFIGS 환경변수가 설정되지 않았습니다.")
+        return [], [], [], []
+    
+    try:
+        # 환경변수 값을 exec로 실행하여 설정 로드
+        local_vars = {}
+        exec(api_configs_str, {}, local_vars)
+        
+        return (
+            local_vars.get('NAVER_API_CONFIGS', []),
+            local_vars.get('NAVER_SHOPPING_CONFIGS', []),
+            local_vars.get('NAVER_DATALAB_CONFIGS', []),
+            local_vars.get('GEMINI_API_CONFIGS', [])
+        )
+    except Exception as e:
+        logger.error(f"환경변수 파싱 오류: {e}")
+        return [], [], [], []
+
+# API 설정 로드
+NAVER_API_CONFIGS, NAVER_SHOPPING_CONFIGS, NAVER_DATALAB_CONFIGS, GEMINI_API_CONFIGS = get_api_configs()
+
+# 순차 사용을 위한 인덱스와 락
+current_api_index = 0
+current_shopping_api_index = 0
+current_datalab_api_index = 0
+current_gemini_api_index = 0
+api_lock = threading.Lock()
+shopping_lock = threading.Lock()
+datalab_lock = threading.Lock()
+gemini_lock = threading.Lock()
+
+# Gemini 모델 캐시
+_gemini_models = {}
+
+# API 설정 초기화 함수 추가
+def initialize_api_configs():
+    """API 설정을 초기화하고 랜덤하게 정렬"""
+    global NAVER_API_CONFIGS, NAVER_SHOPPING_CONFIGS, NAVER_DATALAB_CONFIGS, GEMINI_API_CONFIGS
+    
+    # API 설정을 다시 로드
+    NAVER_API_CONFIGS, NAVER_SHOPPING_CONFIGS, NAVER_DATALAB_CONFIGS, GEMINI_API_CONFIGS = get_api_configs()
+    
+    # API 설정을 랜덤하게 섞기
+    if NAVER_API_CONFIGS:
+        random.shuffle(NAVER_API_CONFIGS)
+    if NAVER_SHOPPING_CONFIGS:
+        random.shuffle(NAVER_SHOPPING_CONFIGS)
+    if NAVER_DATALAB_CONFIGS:
+        random.shuffle(NAVER_DATALAB_CONFIGS)
+    if GEMINI_API_CONFIGS:
+        random.shuffle(GEMINI_API_CONFIGS)
+    
+    print(f"API 설정 초기화 완료:")
+    print(f"  - 검색광고 API: {len(NAVER_API_CONFIGS)}개")
+    print(f"  - 쇼핑 API: {len(NAVER_SHOPPING_CONFIGS)}개")
+    print(f"  - 데이터랩 API: {len(NAVER_DATALAB_CONFIGS)}개")
+    print(f"  - Gemini API: {len(GEMINI_API_CONFIGS)}개")
+
+
+def generate_signature(timestamp, method, uri, secret_key):
+    """시그니처 생성 함수"""
+    message = f"{timestamp}.{method}.{uri}"
+    digest = hmac.new(secret_key.encode("utf-8"), message.encode("utf-8"), hashlib.sha256).digest()
+    return base64.b64encode(digest).decode()
+
+def get_header(method, uri, api_key, secret_key, customer_id):
+    """API 헤더 생성 함수"""
+    timestamp = str(round(time.time() * 1000))
+    signature = generate_signature(timestamp, method, uri, secret_key)
+    return {
+        "Content-Type": "application/json; charset=UTF-8",
+        "X-Timestamp": timestamp,
+        "X-API-KEY": api_key,
+        "X-Customer": str(customer_id),
+        "X-Signature": signature
+    }
+
+def get_next_api_config():
+    """순차적으로 다음 API 설정을 반환 (스레드 안전)"""
+    global current_api_index
+    
+    if not NAVER_API_CONFIGS:
+        logger.error("네이버 검색광고 API 설정이 없습니다.")
+        return None
+        
+    with api_lock:
+        config = NAVER_API_CONFIGS[current_api_index]
+        current_api_index = (current_api_index + 1) % len(NAVER_API_CONFIGS)
+    return config
+
+def get_next_shopping_api_config():
+    """순차적으로 다음 쇼핑 API 설정을 반환 (오류 키 건너뛰기 추가)"""
+    global current_shopping_api_index
+    
+    if not NAVER_SHOPPING_CONFIGS:
+        logger.error("네이버 쇼핑 API 설정이 없습니다.")
+        return None
+        
+    with shopping_lock:
+        # 최대 전체 키 수만큼 시도 (무한 루프 방지)
+        for _ in range(len(NAVER_SHOPPING_CONFIGS)):
+            config = NAVER_SHOPPING_CONFIGS[current_shopping_api_index]
+            current_shopping_api_index = (current_shopping_api_index + 1) % len(NAVER_SHOPPING_CONFIGS)
+            
+            # 기본값 체크
+            if config["CLIENT_ID"] and not config["CLIENT_ID"].startswith("YOUR_"):
+                return config
+        
+        # 모든 키가 기본값인 경우 첫 번째 키 반환
+        return NAVER_SHOPPING_CONFIGS[0] if NAVER_SHOPPING_CONFIGS else None
+
+def get_next_datalab_api_config():
+    """순차적으로 다음 데이터랩 API 설정을 반환 (스레드 안전)"""
+    global current_datalab_api_index
+    
+    if not NAVER_DATALAB_CONFIGS:
+        logger.error("네이버 데이터랩 API 설정이 없습니다.")
+        return None
+        
+    with datalab_lock:
+        # API 키가 설정되지 않았으면 None 반환
+        if not NAVER_DATALAB_CONFIGS[0]["CLIENT_ID"] or NAVER_DATALAB_CONFIGS[0]["CLIENT_ID"].startswith("YOUR_"):
+            return None
+            
+        config = NAVER_DATALAB_CONFIGS[current_datalab_api_index]
+        current_datalab_api_index = (current_datalab_api_index + 1) % len(NAVER_DATALAB_CONFIGS)
+        return config
+
+def get_next_gemini_api_key():
+    """순차적으로 다음 Gemini API 키를 반환 (스레드 안전)"""
+    global current_gemini_api_index
+    
+    if not GEMINI_API_CONFIGS:
+        logger.warning("사용 가능한 Gemini API 키가 없습니다.")
+        return None
+        
+    with gemini_lock:
+        # 최대 전체 키 수만큼 시도 (무한 루프 방지)
+        for _ in range(len(GEMINI_API_CONFIGS)):
+            api_key = GEMINI_API_CONFIGS[current_gemini_api_index]
+            current_gemini_api_index = (current_gemini_api_index + 1) % len(GEMINI_API_CONFIGS)
+            
+            # 기본값이 아닌 키만 반환
+            if api_key and not api_key.startswith("YOUR_") and api_key.strip():
+                return api_key
+        
+        # 모든 키가 기본값인 경우 None 반환
+        logger.warning("사용 가능한 Gemini API 키가 없습니다.")
+        return None
+
+def get_gemini_model():
+    """캐시된 Gemini 모델을 반환하거나 새로 생성"""
+    api_key = get_next_gemini_api_key()
+    
+    if not api_key:
+        logger.error("Gemini API 키를 가져올 수 없습니다.")
+        return None
+    
+    # 캐시에서 모델 확인
+    if api_key in _gemini_models:
+        return _gemini_models[api_key]
+    
+    try:
+        # 새 모델 생성
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel("gemini-2.0-flash-exp")
+        
+        # 캐시에 저장
+        _gemini_models[api_key] = model
+        
+        logger.info(f"Gemini 모델 생성 성공: {api_key[:8]}***{api_key[-4:]}")
+        return model
+        
+    except Exception as e:
+        logger.error(f"Gemini 모델 생성 실패 ({api_key[:8]}***): {e}")
+        return None
+
+def validate_api_config(api_config):
+    """API 설정 유효성 검사"""
+    if not api_config:
+        return False, "API 설정이 없습니다."
+        
+    API_KEY = api_config.get("API_KEY", "")
+    SECRET_KEY = api_config.get("SECRET_KEY", "")
+    CUSTOMER_ID_STR = api_config.get("CUSTOMER_ID", "")
+    
+    if not all([API_KEY, SECRET_KEY, CUSTOMER_ID_STR]):
+        return False, "API 키가 설정되지 않았습니다."
+    
+    if CUSTOMER_ID_STR.startswith("YOUR_") or API_KEY.startswith("YOUR_"):
+        return False, "API 키가 플레이스홀더입니다."
+    
+    try:
+        CUSTOMER_ID = int(CUSTOMER_ID_STR)
+    except ValueError:
+        return False, f"CUSTOMER_ID 변환 오류: '{CUSTOMER_ID_STR}'는 유효한 숫자가 아닙니다."
+    
+    return True, "유효한 API 설정입니다."
+
+def validate_datalab_config(datalab_config):
+    """데이터랩 API 설정 유효성 검사"""
+    if not datalab_config:
+        return False, "데이터랩 API 설정이 없습니다."
+    
+    CLIENT_ID = datalab_config.get("CLIENT_ID", "")
+    CLIENT_SECRET = datalab_config.get("CLIENT_SECRET", "")
+    
+    if not all([CLIENT_ID, CLIENT_SECRET]):
+        return False, "데이터랩 API 키가 설정되지 않았습니다."
+    
+    if CLIENT_ID.startswith("YOUR_") or CLIENT_SECRET.startswith("YOUR_"):
+        return False, "데이터랩 API 키가 플레이스홀더입니다."
+    
+    return True, "유효한 데이터랩 API 설정입니다."
+
+def validate_gemini_config():
+    """Gemini API 설정 유효성 검사"""
+    valid_keys = 0
+    for api_key in GEMINI_API_CONFIGS:
+        if api_key and not api_key.startswith("YOUR_") and api_key.strip():
+            valid_keys += 1
+    
+    if valid_keys == 0:
+        return False, "사용 가능한 Gemini API 키가 없습니다."
+    
+    return True, f"{valid_keys}개의 유효한 Gemini API 키가 설정되어 있습니다."

app.py

@@ -1,54 +1,75 @@
+"""
+AI 상품 소싱 분석 시스템 v2.10 - 간략버전 + 출력기능 + 멀티사용자 안전
+- 2단계: 수집된 키워드 목록 기능을 제거한다.
+- 3단계: 분석할 키워드 선택에서 🔗 연관검색어 분석의 상품추출 및 분석기능을제거한다.
+- 3단계: 분석할 키워드 선택의 명칭을 "키워드 심층분석 입력"이라고 바꾼다.
+- 📈 검색량 트렌드 분석, 🎯 키워드 분석이 나와야한다.
+- 출력 기능 추가: HTML 파일 생성 및 ZIP 다운로드
+- Gemini API 키 랜덤 적용 (api_utils 통합 관리)
+- 한국시간 적용
+- 멀티 사용자 안전: gr.State 사용으로 세션별 데이터 관리
+"""
+
 import gradio as gr
 import pandas as pd
 import os
 import logging
-from datetime import datetime
-import pytz
+import google.generativeai as genai
+from datetime import datetime, timedelta
 import time
-import tempfile
-import zipfile
 import re
-import json
+import zipfile
+import tempfile
+
+# 한국시간 적용을 위한 모듈 (선택적)
+try:
+    import pytz
+    PYTZ_AVAILABLE = True
+except ImportError:
+    PYTZ_AVAILABLE = False
 
-# 로깅 설정 - 클라이언트 정보 숨김
-logging.basicConfig(level=logging.WARNING, format='%(asctime)s - %(levelname)s - %(message)s')
+# 로깅 설정
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# 외부 라이브러리 로그 비활성화
-logging.getLogger('gradio').setLevel(logging.WARNING)
-logging.getLogger('gradio_client').setLevel(logging.WARNING)
-logging.getLogger('httpx').setLevel(logging.WARNING)
-logging.getLogger('urllib3').setLevel(logging.WARNING)
+# 모듈 임포트 (간략 버전에서 필요한 것만)
+import api_utils
+import keyword_search
+import keyword_analysis
+import trend_analysis_v2
 
-# ===== API 클라이언트 설정 =====
-def get_api_client():
-    """환경변수에서 API 엔드포인트를 가져와 클라이언트 생성"""
+# ===== Gemini API 설정 =====
+def setup_gemini_model():
+    """Gemini 모델 초기화 - api_utils에서 관리 (랜덤 키 적용)"""
     try:
-        from gradio_client import Client
-        
-        # 환경변수에서 API 엔드포인트 가져오기
-        api_endpoint = os.getenv('API_ENDPOINT')
-        
-        if not api_endpoint:
-            logger.error("API 엔드포인트가 설정되지 않았습니다.")
-            raise ValueError("API 엔드포인트가 설정되지 않았습니다.")
-        
-        client = Client(api_endpoint)
-        logger.info("원격 API 클라이언트 초기화 성공")
-        return client
+        # api_utils에서 Gemini 모델 가져오기 (랜덤 키 적용)
+        model = api_utils.get_gemini_model()
         
+        if model:
+            logger.info("Gemini 모델 초기화 성공 (api_utils 통합 관리 - 랜덤 키)")
+            return model
+        else:
+            logger.warning("Gemini API 키가 설정되지 않았습니다.")
+            return None
+            
     except Exception as e:
-        logger.error(f"API 클라이언트 초기화 실패: {e}")
+        logger.error(f"Gemini 모델 초기화 실패: {e}")
         return None
 
+# Gemini 모델 초기화
+gemini_model = setup_gemini_model()
+
 # ===== 한국시간 관련 함수 =====
 def get_korean_time():
     """한국시간 반환"""
-    try:
-        korea_tz = pytz.timezone('Asia/Seoul')
-        return datetime.now(korea_tz)
-    except:
-        return datetime.now()
+    if PYTZ_AVAILABLE:
+        try:
+            korea_tz = pytz.timezone('Asia/Seoul')
+            return datetime.now(korea_tz)
+        except:
+            pass
+    # pytz가 없거나 오류 시 시스템 시간 사용
+    return datetime.now()
 
 def format_korean_datetime(dt=None, format_type="filename"):
     """한국시간 포맷팅"""
@@ -71,7 +92,7 @@ def create_loading_animation():
     <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>
+        <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>
@@ -96,20 +117,203 @@ 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>
+        <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>
                 <li>잠시 후 다시 시도해주세요</li>
-                <li>문제가 지속되면 관리자에게 문의하세요</li>
             </ul>
         </div>
     </div>
     '''
 
+# ===== 메인 키워드 분석 함수 =====
+def safe_keyword_analysis(analysis_keyword):
+    """에러 방지를 위한 안전한 키워드 분석 - 멀티사용자 안전"""
+    
+    # 입력값 검증
+    if not analysis_keyword or not analysis_keyword.strip():
+        return generate_error_response("분석할 키워드를 입력해주세요."), {}
+    
+    analysis_keyword = analysis_keyword.strip()
+    
+    try:
+        # 검색량 조회 - 에러 방지
+        api_keyword = keyword_analysis.normalize_keyword_for_api(analysis_keyword)
+        search_volumes = keyword_search.fetch_all_search_volumes([api_keyword])
+        volume_data = search_volumes.get(api_keyword, {"PC검색량": 0, "모바일검색량": 0, "총검색량": 0})
+        
+        # 검색량이 0이거나 키워드가 존재하지 않는 경우 처리
+        if volume_data['총검색량'] == 0:
+            logger.warning(f"'{analysis_keyword}' 키워드의 검색량이 0이거나 존재하지 않습니다.")
+            error_result = f"""
+            <div style="padding: 30px; text-align: center; background: #fff3cd; border-radius: 12px; border: 1px solid #ffeaa7;">
+                <h3 style="color: #856404; margin-bottom: 15px;">⚠️ 키워드 분석 불가</h3>
+                <p style="color: #856404; margin-bottom: 10px;"><strong>'{analysis_keyword}'</strong> 키워드는 검색량이 없거나 올바르지 않은 키워드입니다.</p>
+                <div style="background: white; padding: 15px; border-radius: 8px; margin-top: 15px;">
+                    <h4 style="color: #333; margin-bottom: 10px;">💡 권장사항</h4>
+                    <ul style="text-align: left; color: #666; padding-left: 20px;">
+                        <li>키워드 철자를 확인해주세요</li>
+                        <li>더 일반적인 키워드를 사용해보세요</li>
+                        <li>키워드를 띄어쓰기로 구분해보세요 (예: '여성 슬리퍼')</li>
+                    </ul>
+                </div>
+            </div>
+            """
+            return error_result, {}
+        
+        logger.info(f"'{analysis_keyword}' 현재 검색량: {volume_data['총검색량']:,}")
+        
+        # 트렌드 분석 시도
+        monthly_data_1year = {}
+        monthly_data_3year = {}
+        trend_available = False
+        
+        try:
+            # 데이터랩 API 키 확인 (랜덤 적용)
+            datalab_config = api_utils.get_next_datalab_api_config()
+            if datalab_config and not datalab_config["CLIENT_ID"].startswith("YOUR_"):
+                logger.info("데이터랩 API 키가 설정되어 있어 1년, 3년 트렌드 분석을 시도합니다.")
+                
+                # 최적화된 API 함수 사용
+                # 1년 트렌드 데이터
+                trend_data_1year = trend_analysis_v2.get_naver_trend_data_v5([analysis_keyword], "1year", max_retries=3)
+                if trend_data_1year:
+                    current_volumes = {api_keyword: volume_data}
+                    monthly_data_1year = trend_analysis_v2.calculate_monthly_volumes_v7([analysis_keyword], current_volumes, trend_data_1year, "1year")
+                
+                # 3년 트렌드 데이터
+                trend_data_3year = trend_analysis_v2.get_naver_trend_data_v5([analysis_keyword], "3year", max_retries=3)
+                if trend_data_3year:
+                    current_volumes = {api_keyword: volume_data}
+                    monthly_data_3year = trend_analysis_v2.calculate_monthly_volumes_v7([analysis_keyword], current_volumes, trend_data_3year, "3year")
+                    
+                # 3년 데이터가 없는 경우 1년 데이터로 확장
+                if not monthly_data_3year and monthly_data_1year:
+                    logger.info("3년 데이터가 없어 1년 데이터를 기반으로 3년 차트 생성")
+                    keyword = analysis_keyword
+                    if keyword in monthly_data_1year:
+                        data_1y = monthly_data_1year[keyword]
+                        
+                        # 3년 분량의 날짜 생성 (24개월 추가)
+                        extended_dates = []
+                        extended_volumes = []
+                        
+                        # 기존 1년 데이터 이전에 24개월 추가 (모두 0으로)
+                        start_date = datetime.strptime(data_1y["dates"][0], "%Y-%m-%d")
+                        for i in range(24, 0, -1):
+                            prev_date = start_date - timedelta(days=30 * i)
+                            extended_dates.append(prev_date.strftime("%Y-%m-%d"))
+                            extended_volumes.append(0)
+                        
+                        # 기존 1년 데이터 추가 (예상 데이터 제외)
+                        actual_count = data_1y.get("actual_count", len(data_1y["dates"]))
+                        extended_dates.extend(data_1y["dates"][:actual_count])
+                        extended_volumes.extend(data_1y["monthly_volumes"][:actual_count])
+                        
+                        monthly_data_3year = {
+                            keyword: {
+                                "monthly_volumes": extended_volumes,
+                                "dates": extended_dates,
+                                "current_volume": data_1y["current_volume"],
+                                "growth_rate": trend_analysis_v2.calculate_3year_growth_rate_improved(extended_volumes),
+                                "volume_per_percent": data_1y["volume_per_percent"],
+                                "current_ratio": data_1y["current_ratio"],
+                                "actual_count": len(extended_volumes),
+                                "predicted_count": 0
+                            }
+                        }
+                
+                if monthly_data_1year or monthly_data_3year:
+                    trend_available = True
+                    logger.info("트렌드 분석 성공")
+                else:
+                    logger.info("트렌드 데이터 처리 실패")
+            else:
+                logger.info("데이터랩 API 키가 설정되지 않음")
+        except Exception as e:
+            logger.info(f"트렌드 분석 건너뜀: {str(e)[:100]}")
+        
+        # === 📈 검색량 트렌드 분석 섹션 ===
+        if trend_available and (monthly_data_1year or monthly_data_3year):
+            try:
+                trend_chart = trend_analysis_v2.create_trend_chart_v7(monthly_data_1year, monthly_data_3year)
+            except Exception as e:
+                logger.warning(f"트렌드 차트 생성 실패, 기본 차트 사용: {e}")
+                trend_chart = trend_analysis_v2.create_enhanced_current_chart(volume_data, analysis_keyword)
+        else:
+            trend_chart = trend_analysis_v2.create_enhanced_current_chart(volume_data, analysis_keyword)
+        
+        # 트렌드 섹션
+        trend_section = f"""
+        <div style="width: 100%; margin: 30px auto; font-family: 'Pretendard', sans-serif;">
+            <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 15px; border-radius: 10px 10px 0 0; color: white; text-align: center;">
+                <h3 style="margin: 0; font-size: 18px; color: white;">📈 검색량 트렌드 분석</h3>
+            </div>
+            <div style="background: white; padding: 20px; border-radius: 0 0 10px 10px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);">
+                {trend_chart}
+            </div>
+        </div>
+        """
+        
+        # === 🎯 키워드 분석 섹션 (AI 분석) ===
+        # api_utils에서 Gemini 모델 가져오기 (랜덤 키 적용)
+        current_gemini_model = api_utils.get_gemini_model()
+        
+        keyword_analysis_html = keyword_analysis.analyze_keyword_for_sourcing(
+            analysis_keyword, volume_data, monthly_data_1year, monthly_data_3year,
+            None, [], current_gemini_model  # 간략 버전에서는 추가 키워드 데이터 없음
+        )
+        
+        keyword_analysis_section = f"""
+        <div style="width: 100%; margin: 30px auto; font-family: 'Pretendard', sans-serif;">
+            <div style="background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%); padding: 15px; border-radius: 10px 10px 0 0; color: white; text-align: center;">
+                <h3 style="margin: 0; font-size: 18px; color: white;">🎯 키워드 분석</h3>
+            </div>
+            <div style="background: white; padding: 20px; border-radius: 0 0 10px 10px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); overflow: hidden;">
+                {keyword_analysis_html}
+            </div>
+        </div>
+        """
+        
+        # 경고 섹션 (필요한 경우)
+        warning_section = ""
+        if not trend_available:
+            warning_section = f"""
+            <div style="width: 100%; margin: 20px auto; padding: 15px; background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 8px; font-family: 'Pretendard', sans-serif;">
+                <div style="display: flex; align-items: center;">
+                    <span style="font-size: 20px; margin-right: 10px;">⚠️</span>
+                    <div>
+                        <strong style="color: #856404;">일부 기능 제한</strong>
+                        <div style="font-size: 14px; color: #856404; margin-top: 5px;">
+                            트렌드 분석에 제한이 있습니다. 현재 검색량 분석과 AI 추천은 정상 제공됩니다.<br>
+                            <small>완전한 월 데이터 기준으로 분석하기 위해 최신 완료된 월까지만 표시됩니다.</small>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            """
+        
+        # 최종 결과 조합
+        final_result = warning_section + trend_section + keyword_analysis_section
+        
+        # 세션별 출력 데이터 반환 (멀티 사용자 안전)
+        session_export_data = {
+            "analysis_keyword": analysis_keyword,
+            "analysis_html": final_result
+        }
+        
+        return final_result, session_export_data
+        
+    except Exception as e:
+        logger.error(f"키워드 분석 중 전체 오류: {e}")
+        error_result = generate_error_response(f"키워드 분석 중 오류가 발생했습니다: {str(e)}")
+        return error_result, {}
+
 # ===== 파일 출력 함수들 =====
 def create_timestamp_filename(analysis_keyword):
     """타임스탬프가 포함된 파일명 생성 - 한국시간 적용"""
@@ -317,72 +521,16 @@ def export_analysis_results(export_data):
         logger.error(f"분석 결과 출력 오류: {e}")
         return None, f"출력 중 오류가 발생했습니다: {str(e)}"
 
-# ===== 원격 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 호출: 키워드 심층분석")
-        result = client.predict(
-            analysis_keyword=analysis_keyword,
-            api_name="/on_analyze_keyword"
-        )
-        
-        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:
-            return str(result), {}
-            
-    except Exception as e:
-        logger.error(f"키워드 심층분석 API 호출 오류: {e}")
-        return generate_error_response(f"원격 서버 연결 실패: {str(e)}"), {}
-
-def call_export_results_api(export_data):
-    """분석 결과 출력 API 호출"""
-    try:
-        client = get_api_client()
-        if not client:
-            return None, "API 클라이언트를 초기화할 수 없습니다."
-        
-        logger.info("원격 API 호출: 분석 결과 출력")
-        result = client.predict(
-            api_name="/on_export_results"
-        )
-        
-        logger.info(f"출력 API 결과 타입: {type(result)}")
-        
-        # 결과가 튜플인 경우 첫 번째 요소는 메시지, 두 번째는 파일
-        if isinstance(result, tuple) and len(result) == 2:
-            message, file_path = result
-            if file_path:
-                return file_path, message
-            else:
-                return None, message
-        else:
-            return None, str(result)
-            
-    except Exception as e:
-        logger.error(f"분석 결과 출력 API 호출 오류: {e}")
-        return None, f"원격 서버 연결 실패: {str(e)}"
-
 # ===== 그라디오 인터페이스 =====
 def create_interface():
     # CSS 파일 로드
     try:
         with open('style.css', 'r', encoding='utf-8') as f:
             custom_css = f.read()
+        
+        with open('keyword_analysis_report.css', 'r', encoding='utf-8') as f:
+            keyword_css = f.read()
+            custom_css += "\n" + keyword_css
     except:
         custom_css = """
         :root { --primary-color: #FB7F0D; --secondary-color: #ff9a8b; }
@@ -397,30 +545,6 @@ def create_interface():
             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(
@@ -473,7 +597,7 @@ def create_interface():
             yield create_loading_animation(), {}
             
             # 실제 키워드 분석 실행
-            keyword_result, session_export_data = call_analyze_keyword_api(analysis_keyword)
+            keyword_result, session_export_data = safe_keyword_analysis(analysis_keyword)
             
             # 📈 검색량 트렌드 분석과 🎯 키워드 분석 표시
             yield keyword_result, session_export_data
@@ -481,7 +605,6 @@ def create_interface():
         def on_export_results(export_data):
             """분석 결과 출력 핸들러 - 세션별 데이터 처리"""
             try:
-                # 로컬 출력 시도
                 zip_path, message = export_analysis_results(export_data)
                 
                 if zip_path:
@@ -501,38 +624,14 @@ def create_interface():
                     """
                     return success_html, gr.update(value=zip_path, visible=True)
                 else:
-                    # 로컬 출력 실패시 원격 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>
-                        """
-                        return error_html, gr.update(visible=False)
+                    # 실패 메시지
+                    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>
+                    """
+                    return error_html, gr.update(visible=False)
                     
             except Exception as e:
                 logger.error(f"출력 핸들러 오류: {e}")
@@ -559,42 +658,121 @@ def create_interface():
     
     return interface
 
+# ===== API 설정 확인 함수 =====
+def check_datalab_api_config():
+    """네이버 데이터랩 API 설정 확인"""
+    logger.info("=== 네이버 데이터랩 API 설정 확인 ===")
+    
+    datalab_config = api_utils.get_next_datalab_api_config()
+    
+    if not datalab_config:
+        logger.warning("�� 데이터랩 API 키가 설정되지 않았습니다.")
+        logger.info("트렌드 분석 기능이 비활성화됩니다.")
+        return False
+    
+    client_id = datalab_config["CLIENT_ID"]
+    client_secret = datalab_config["CLIENT_SECRET"]
+    
+    logger.info(f"총 {len(api_utils.NAVER_DATALAB_CONFIGS)}개의 데이터랩 API 설정 사용 중")
+    logger.info(f"현재 선택된 API:")
+    logger.info(f"  CLIENT_ID: {client_id[:8]}***{client_id[-4:] if len(client_id) > 12 else '***'}")
+    logger.info(f"  CLIENT_SECRET: {client_secret[:4]}***{client_secret[-2:] if len(client_secret) > 6 else '***'}")
+    
+    # 기본값 체크
+    if client_id.startswith("YOUR_"):
+        logger.error("❌ CLIENT_ID가 기본값으로 설정되어 있습니다!")
+        return False
+    
+    if client_secret.startswith("YOUR_"):
+        logger.error("❌ CLIENT_SECRET이 기본값으로 설정되어 있습니다!")
+        return False
+    
+    # 길이 체크
+    if len(client_id) < 10:
+        logger.warning("⚠️ CLIENT_ID가 짧습니다. 올바른 키인지 확인해주세요.")
+    
+    if len(client_secret) < 5:
+        logger.warning("⚠️ CLIENT_SECRET이 짧습니다. 올바른 키인지 확인해주세요.")
+    
+    logger.info("✅ 데이터랩 API 키 형식 검증 완료")
+    return True
+
+def check_gemini_api_config():
+    """Gemini API 설정 확인 - 랜덤 키 적용"""
+    logger.info("=== Gemini API 설정 확인 ===")
+    
+    is_valid, message = api_utils.validate_gemini_config()
+    
+    if is_valid:
+        logger.info(f"✅ {message}")
+        # 첫 번째 사용 가능한 키 테스트 (랜덤)
+        test_key = api_utils.get_next_gemini_api_key()
+        if test_key:
+            logger.info(f"현재 사용 중인 Gemini API 키: {test_key[:8]}***{test_key[-4:]}")
+        return True
+    else:
+        logger.warning(f"❌ {message}")
+        logger.info("AI 분석 기능이 제한될 수 있습니다.")
+        return False
+
 # ===== 메인 실행 =====
 if __name__ == "__main__":
     # pytz 모듈 설치 확인
-    try:
-        import pytz
+    if PYTZ_AVAILABLE:
         logger.info("✅ pytz 모듈 로드 성공 - 한국시간 지원")
-    except ImportError:
+    else:
         logger.warning("⚠️ pytz 모듈이 설치되지 않음 - pip install pytz 실행 필요")
         logger.info("시스템 시간을 사용합니다.")
     
-    logger.info("===== 상품 소싱 분석 시스템 v2.10 (컨트롤 타워 버전) 시작 =====")
+    # API 설정 초기화
+    api_utils.initialize_api_configs()
+    logger.info("===== 상품 소싱 분석 시스템 v2.10 (간략버전 + 출력기능 + 랜덤키 + 멀티사용자 안전) 시작 =====")
+    
+    # 네이버 데이터랩 API 설정 확인
+    datalab_available = check_datalab_api_config()
+    
+    # Gemini API 설정 확인 (랜덤 키)
+    gemini_available = check_gemini_api_config()
     
     # 필요한 패키지 안내
     print("📦 필요한 패키지:")
-    print("   pip install gradio gradio_client pandas pytz")
+    print("   pip install gradio google-generativeai pandas requests xlsxwriter markdown plotly pytz")
     print()
     
-    # API 엔드포인트 설정 안내
-    api_endpoint = os.getenv('API_ENDPOINT')
-    if not api_endpoint:
-        print("⚠️  API_ENDPOINT 환경변수를 설정하세요.")
-        print("   export API_ENDPOINT='your-endpoint-url'")
+    # API 키 설정 안내
+    if not gemini_available:
+        print("⚠️  GEMINI_API_KEY 또는 GOOGLE_API_KEY 환경변수를 설정하세요.")
+        print("   export GEMINI_API_KEY='your-api-key'")
+        print("   또는")
+        print("   export GOOGLE_API_KEY='your-api-key'")
+        print()
+    
+    if not datalab_available:
+        print("⚠️  네이버 데이터랩 API 트렌드 분석을 위해서는:")
+        print("   1. 네이버 개발자센터(https://developers.naver.com)에서 애플리케이션 등록")
+        print("   2. '데이터랩(검색어 트렌드)' API 추가")
+        print("   3. 발급받은 CLIENT_ID와 CLIENT_SECRET을 api_utils.py의 NAVER_DATALAB_CONFIGS에 설정")
+        print("   4. 현재는 현재 검색량 정보만 표시됩니다.")
         print()
     else:
-        print("✅ API 엔드포인트 설정 완료!")
+        print("✅ 데이터랩 API 설정 완료 - 1년, 3년 트렌드 분석이 가능합니다!")
+        print()
+    
+    if gemini_available:
+        print("✅ Gemini API 설정 완료 - 랜덤 키 로테이션 적용됩니다!")
         print()
     
-    print("🚀 v2.10 컨트롤 타워 버전 특징:")
-    print("   • 허깅페이스 그라디오 엔드포인트 활용")
-    print("   • 완전히 동일한 UI와 기능 구현")
-    print("   • 📈 검색량 트렌드 분석과 🎯 키워드 분석 표시")
-    print("   • ✅ 출력 기능: HTML 파일 생성 및 ZIP 다운로드")
+    print("🚀 v2.10 개선사항:")
+    print("   • 2단계: 수집된 키워드 목록 기능 ���거")
+    print("   • 3단계: 연관검색어 분석의 상품추출 및 분석 기능 제거")
+    print("   • 3단계: '분석할 키워드 선택' → '키워드 심층분석 입력'으로 명칭 변경")
+    print("   • 📈 검색량 트렌드 분석과 🎯 키워드 분석만 표시")
+    print("   • ✅ 출력 기능 추가: HTML 파일 생성 및 ZIP 다운로드")
+    print("   • ✅ Gemini API 키 랜덤 로테이션 적용")
+    print("   • ✅ 네이버 데이터랩 API 키 랜덤 로테이션 적용")
     print("   • ✅ 한국시간 기준 파일명 생성")
     print("   • ✅ 멀티 사용자 안전: gr.State로 세션별 데이터 관리")
-    print("   • 🔒 클라이언트 정보 환경변수로 완전 숨김")
-    print("   • 원격 서버와 로컬 처리 하이브리드 방식")
+    print("   • 불필요한 모듈 임포트 제거로 안정성 향상")
     print()
     
     # 앱 실행

export_utils.py

@@ -0,0 +1,478 @@
+"""
+결과 출력 관련 유틸리티 함수 모음 - 카테고리 항목 제거
+- HTML 테이블 생성
+- 엑셀 파일 생성
+"""
+
+import pandas as pd
+import tempfile
+import os
+import threading
+import time
+import logging
+
+# 로깅 설정
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+# 임시 파일 추적 리스트
+_temp_files = []
+
+def create_table_without_checkboxes(df):
+    """DataFrame을 HTML 테이블로 변환 - 키워드 클릭 시 네이버 쇼핑 이동 기능 추가"""
+    if df.empty:
+        return "<p>검색 결과가 없습니다.</p>"
+    
+    # === 수정된 부분: 카테고리 관련 열 제거 ===
+    df_display = df.copy()
+    
+    # "상품 등록 카테고리(상위100위)" 또는 "관련 카테고리", "카테고리 항목" 열이 있으면 제거
+    columns_to_remove = ["상품 등록 카테고리(상위100위)", "관련 카테고리", "카테고리 항목"]
+    for col in columns_to_remove:
+        if col in df_display.columns:
+            df_display = df_display.drop(columns=[col])
+            logger.info(f"테이블에서 '{col}' 열 제거됨")
+    
+    # HTML 테이블 스타일 정의 - Z-INDEX 수정
+    html = '''
+    <style>
+    .table-container {
+        position: relative;
+        width: 100%;
+        margin: 0;
+        border-radius: 8px;
+        overflow: hidden;
+        box-shadow: 0 0 20px rgba(0, 0, 0, 0.1);
+    }
+    
+    .header-wrap {
+        position: sticky;
+        top: 0;
+        z-index: 100;  /* z-index 증가 */
+        background-color: #009879;
+    }
+    
+    .styled-table {
+        width: 100%;
+        border-collapse: collapse;
+        table-layout: fixed;
+        margin: 0;
+        padding: 0;
+        font-size: 14px;
+    }
+    
+    .styled-table th,
+    .styled-table td {
+        padding: 12px 15px;
+        text-align: left;
+        border-bottom: 1px solid #dddddd;
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+    
+    /* 긴 텍스트가 셀에서 줄바꿈되도록 수정 */
+    .styled-table td.col-rank {
+        white-space: normal;
+        word-break: break-word;
+        line-height: 1.3;
+    }
+    
+    /* 그 외 열은 한 줄로 표시 */
+    .styled-table td.col-seq,
+    .styled-table td.col-keyword,
+    .styled-table td.col-pc,
+    .styled-table td.col-mobile,
+    .styled-table td.col-total,
+    .styled-table td.col-range,
+    .styled-table td.col-count {
+        white-space: nowrap;
+    }
+    
+    .styled-table th {
+        background-color: #009879;
+        color: white;
+        font-weight: bold;
+        position: sticky;
+        top: 0;
+        white-space: nowrap;
+        z-index: 50;  /* 헤더 z-index 증가 */
+    }
+    
+    .styled-table tbody tr:nth-of-type(even) {
+        background-color: #f3f3f3;
+    }
+    
+    .styled-table tbody tr:hover {
+        background-color: #f0f0f0;
+    }
+    
+    .styled-table tbody tr:last-of-type {
+        border-bottom: 2px solid #009879;
+    }
+    
+    /* 데이터 셀 z-index 설정 */
+    .styled-table tbody td {
+        position: relative;
+        z-index: 1;  /* 데이터 셀은 낮은 z-index */
+    }
+    
+    .data-container {
+        max-height: 600px;
+        overflow-y: auto;
+        position: relative;  /* position 추가 */
+    }
+    
+    /* 스크롤바 스타일 */
+    .data-container::-webkit-scrollbar {
+        width: 10px;
+    }
+    
+    .data-container::-webkit-scrollbar-track {
+        background: #f1f1f1;
+        border-radius: 5px;
+    }
+    
+    .data-container::-webkit-scrollbar-thumb {
+        background: #888;
+        border-radius: 5px;
+    }
+    
+    .data-container::-webkit-scrollbar-thumb:hover {
+        background: #555;
+    }
+    
+    /* 키워드 링크 스타일 - 새로 추가 */
+    .keyword-link {
+        color: #2c5aa0;
+        text-decoration: none;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.3s ease;
+        display: inline-block;
+        padding: 2px 4px;
+        border-radius: 3px;
+        position: relative;
+        z-index: 5;  /* 링크 z-index 설정 */
+    }
+    
+    .keyword-link:hover {
+        color: #ffffff;
+        background-color: #2c5aa0;
+        text-decoration: none;
+        transform: translateY(-1px);
+        box-shadow: 0 2px 4px rgba(44, 90, 160, 0.3);
+    }
+    
+    .keyword-link:active {
+        transform: translateY(0px);
+    }
+    
+    /* 키워드 셀 특별 스타일 */
+    .col-keyword {
+        position: relative;
+    }
+    
+    .keyword-tooltip {
+        position: absolute;
+        bottom: 100%;
+        left: 50%;
+        transform: translateX(-50%);
+        background-color: #333;
+        color: white;
+        padding: 6px 10px;
+        border-radius: 4px;
+        font-size: 11px;
+        white-space: nowrap;
+        opacity: 0;
+        visibility: hidden;
+        transition: all 0.3s ease;
+        z-index: 1000;  /* 툴팁은 가장 높은 z-index */
+        pointer-events: none;
+        margin-bottom: 5px;
+    }
+    
+    .keyword-tooltip::after {
+        content: '';
+        position: absolute;
+        top: 100%;
+        left: 50%;
+        transform: translateX(-50%);
+        border: 4px solid transparent;
+        border-top-color: #333;
+    }
+    
+    .keyword-link:hover .keyword-tooltip {
+        opacity: 1;
+        visibility: visible;
+    }
+    
+    /* === 수정된 부분: 열 너비 정의 - 카테고리 열 제거 후 조정 === */
+    .col-seq { width: 8%; }
+    .col-keyword { width: 25%; }
+    .col-pc { width: 12%; }
+    .col-mobile { width: 12%; }
+    .col-total { width: 12%; }
+    .col-range { width: 12%; }
+    .col-rank { width: 15%; }
+    .col-count { width: 10%; }
+    
+    .truncated-text {
+        position: relative;
+        cursor: pointer;
+        z-index: 2;  /* 텍스트 z-index 설정 */
+    }
+    
+    .truncated-text:hover::after {
+        content: attr(data-full-text);
+        position: absolute;
+        left: 0;
+        top: 100%;
+        z-index: 99;
+        min-width: 200px;
+        max-width: 400px;
+        padding: 8px;
+        background-color: #fff;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.2);
+        white-space: normal;
+    }
+    
+    /* 키워드 태그 스타일 */
+    .keyword-tag-container {
+        margin-top: 20px;
+        padding: 10px;
+        border: 1px solid #ddd;
+        border-radius: 5px;
+        background-color: #f9f9f9;
+    }
+    
+    .keyword-tag {
+        display: inline-block;
+        background-color: #009879;
+        color: white;
+        padding: 5px 10px;
+        margin: 5px;
+        border-radius: 15px;
+        font-size: 12px;
+    }
+    
+    .category-tag {
+        display: inline-block;
+        background-color: #2c7fb8;
+        color: white;
+        padding: 5px 10px;
+        margin: 5px;
+        border-radius: 15px;
+        font-size: 12px;
+    }
+    
+    /* 분석 결과 테이블 스타일 */
+    .analysis-result {
+        margin-top: 30px;
+        border: 1px solid #ddd;
+        border-radius: 5px;
+        padding: 15px;
+        background-color: #f9f9f9;
+    }
+    
+    .result-header {
+        font-weight: bold;
+        margin-bottom: 10px;
+        color: #009879;
+    }
+    
+    .match-item {
+        margin: 5px 0;
+        padding: 5px;
+        border-bottom: 1px solid #eee;
+    }
+    
+    .match-keyword {
+        font-weight: bold;
+        color: #2c7fb8;
+    }
+    
+    .match-count {
+        display: inline-block;
+        background-color: #009879;
+        color: white;
+        padding: 2px 8px;
+        border-radius: 10px;
+        font-size: 12px;
+        margin-left: 10px;
+    }
+    </style>
+    '''
+    
+    # === 수정된 부분: 열 이름과 클래스 매핑 - 카테고리 관련 제거 ===
+    col_mapping = {
+        "순번": "col-seq",
+        "조합 키워드": "col-keyword",
+        "PC검색량": "col-pc",
+        "모바일검색량": "col-mobile",
+        "총검색량": "col-total",
+        "검색량구간": "col-range",
+        "키워드 사용자순위": "col-rank",
+        "키워드 사용횟수": "col-count"
+        # 카테고리 관련 매핑 제거됨
+    }
+    
+    # 테이블 컨테이너 시작
+    html += '<div class="table-container">'
+    
+    # 단일 테이블 구조로 변경 (헤더는 position: sticky로 고정)
+    html += '<div class="data-container">'
+    html += '<table class="styled-table">'
+    
+    # colgroup으로 열 너비 정의
+    html += '<colgroup>'
+    html += f'<col class="{col_mapping["순번"]}">'
+    for col in df_display.columns:
+        col_class = col_mapping.get(col, "")
+        html += f'<col class="{col_class}">'
+    html += '</colgroup>'
+    
+    # 테이블 헤더
+    html += '<thead>'
+    html += '<tr>'
+    html += f'<th class="{col_mapping["순번"]}">순번</th>'
+    for col in df_display.columns:
+        col_class = col_mapping.get(col, "")
+        html += f'<th class="{col_class}">{col}</th>'
+    html += '</tr>'
+    html += '</thead>'
+    
+    # 테이블 본문
+    html += '<tbody>'
+    for idx, row in df_display.iterrows():
+        html += '<tr>'
+        # 순번 표시 - 1부터 시작하는 순차적 번호
+        html += f'<td class="{col_mapping["순번"]}">{idx + 1}</td>'
+        
+        # 데이터 셀 추가
+        for col in df_display.columns:
+            col_class = col_mapping.get(col, "")
+            value = str(row[col])
+            
+            if col == "키워드 사용자순위":
+                # 긴 텍스트의 셀은 그대로 표시 (줄바꿈 허용)
+                html += f'<td class="{col_class}">{value}</td>'
+            elif len(value) > 30:  
+                # 다른 긴 텍스트는 hover로 전체 표시
+                html += f'<td class="{col_class}"><div class="truncated-text" data-full-text="{value}">{value[:30]}...</div></td>'
+            else:
+                # 일반 텍스트
+                html += f'<td class="{col_class}">{value}</td>'
+        html += '</tr>'
+    
+    html += '</tbody>'
+    html += '</table>'
+    html += '</div>'  # data-container 닫기
+    html += '</div>'  # table-container 닫기
+    
+    return html
+
+def cleanup_temp_files(delay=300):
+    """임시 파일 정리 함수"""
+    global _temp_files
+    
+    def cleanup():
+        time.sleep(delay)  # 지정된 시간 대기
+        temp_files_to_remove = _temp_files.copy()
+        _temp_files = []
+        
+        for file_path in temp_files_to_remove:
+            try:
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+                    logger.info(f"임시 파일 삭제: {file_path}")
+            except Exception as e:
+                logger.error(f"파일 삭제 오류: {e}")
+    
+    # 새 스레드 시작
+    threading.Thread(target=cleanup, daemon=True).start()
+
+def download_keywords(df, auto_cleanup=True, cleanup_delay=300):
+    """키워드 데이터를 엑셀 파일로 다운로드 - 카테고리 항목 제거"""
+    global _temp_files
+    
+    if df is None or df.empty:
+        return None
+    
+    # 임시 파일로 저장
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx')
+    temp_file.close()
+    filename = temp_file.name
+    
+    # 임시 파일 추적 목록에 추가
+    _temp_files.append(filename)
+    
+    # === 수정된 부분: 카테고리 관련 열 제거 ===
+    df_export = df.copy()
+    
+    # 카테고리 관련 열들 제거
+    columns_to_remove = ["상품 등록 카테고리(상위100위)", "관련 카테고리", "카테고리 항목"]
+    for col in columns_to_remove:
+        if col in df_export.columns:
+            df_export = df_export.drop(columns=[col])
+            logger.info(f"엑셀 내보내기에서 '{col}' 열 제거됨")
+    
+    # 키워드 데이터를 엑셀 파일로 저장
+    with pd.ExcelWriter(filename, engine='xlsxwriter') as writer:
+        # 키워드 목록 시트
+        df_export.to_excel(writer, sheet_name='키워드 목록', index=False)
+            
+        # 열 너비 조정 - 카테고리 열 제거 후 조정
+        worksheet = writer.sheets['키워드 목록']
+        worksheet.set_column('A:A', 20)  # 조합 키워드 열
+        worksheet.set_column('B:B', 12)  # PC검색량 열
+        worksheet.set_column('C:C', 12)  # 모바일검색량 열
+        worksheet.set_column('D:D', 12)  # 총검색량 열
+        worksheet.set_column('E:E', 12)  # 검색량구간 열
+        worksheet.set_column('F:F', 20)  # 키워드 사용자순위 열
+        worksheet.set_column('G:G', 12)  # 키워드 사용횟수 열
+        # 카테고리 열들 제거로 H, I 열 설정 제거됨
+        
+        # 헤더 형식 설정
+        header_format = writer.book.add_format({
+            'bold': True,
+            'bg_color': '#009879',
+            'color': 'white',
+            'border': 1
+        })
+        
+        # 헤더에 형식 적용
+        for col_num, value in enumerate(df_export.columns.values):
+            worksheet.write(0, col_num, value, header_format)
+    
+    logger.info(f"엑셀 파일 생성: {filename}")
+    
+    # 파일 자동 정리 옵션
+    if auto_cleanup:
+        # 별도 정리 작업 요청 없이 추적 목록에 추가만 하여 일괄 처리
+        pass
+        
+    return filename
+
+def register_cleanup_handlers():
+    """앱 종료 시 정리를 위한 핸들러 등록"""
+    import atexit
+    
+    def cleanup_all_temp_files():
+        global _temp_files
+        for file_path in _temp_files:
+            try:
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+                    logger.info(f"종료 시 임시 파일 삭제: {file_path}")
+            except Exception as e:
+                logger.error(f"파일 삭제 오류: {e}")
+        _temp_files = []
+    
+    # 앱 종료 시 실행될 함수 등록
+    atexit.register(cleanup_all_temp_files)

keyword_analysis.py

@@ -0,0 +1,1773 @@
+"""
+키워드 매칭 및 상승폭 계산 개선 - 전체 코드
+v4.0 - 스페이스바 처리 개선 + 올바른 트렌드 분석 로직 적용
+- 기존 모든 기능 유지하면서 최적화
+- 스페이스바 제거 후 검색/비교 로직 적용
+- 올바른 증감율 계산: 올해 완료월 vs 작년 동월
+- 🔖 가장 검색량이 많은 월: 실제+예상 데이터 중 최대값
+- 🔖 가장 상승폭이 높은 월: 연속된 월간 상승률 중 최대값
+"""
+
+import logging
+import pandas as pd
+from datetime import datetime
+import re
+import time
+import random
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+def normalize_keyword(keyword):
+   """키워드 정규화 - 스페이스바 처리 개선"""
+   if not keyword:
+       return ""
+   
+   # 1. 앞뒤 공백 제거
+   keyword = keyword.strip()
+   
+   # 2. 연속된 공백을 하나로 변경
+   keyword = re.sub(r'\s+', ' ', keyword)
+   
+   # 3. 특수문자 제거 (한글, 영문, 숫자, 공백만 남김)
+   keyword = re.sub(r'[^\w\s가-힣]', '', keyword)
+   
+   return keyword
+
+def normalize_keyword_for_api(keyword):
+   """API 호출용 키워드 정규화 (스페이스 제거)"""
+   normalized = normalize_keyword(keyword)
+   return normalized.replace(" ", "")
+
+def normalize_keyword_for_comparison(keyword):
+   """비교용 키워드 정규화 (스페이스 유지)"""
+   return normalize_keyword(keyword).lower()
+
+def normalize_keyword_advanced(keyword):
+    """고급 키워드 정규화 - 매칭 문제 해결"""
+    if not keyword:
+        return ""
+    
+    # 1. 기본 정리
+    keyword = str(keyword).strip()
+    
+    # 2. 연속된 공백을 하나로 변경
+    keyword = re.sub(r'\s+', ' ', keyword)
+    
+    # 3. 특수문자 제거 (한글, 영문, 숫자, 공백만 남김)
+    keyword = re.sub(r'[^\w\s가-힣]', '', keyword)
+    
+    # 4. 소문자 변환
+    keyword = keyword.lower()
+    
+    return keyword
+
+def create_keyword_variations(keyword):
+    """키워드 변형 버전들 생성 - 스페이스바 처리 강화"""
+    base = normalize_keyword_advanced(keyword)
+    variations = [base]
+    
+    # 스페이스 제거 버전
+    no_space = base.replace(" ", "")
+    if no_space != base:
+        variations.append(no_space)
+    
+    # 스페이스를 다른 구분자로 바꾼 버전들
+    variations.append(base.replace(" ", "-"))
+    variations.append(base.replace(" ", "_"))
+    
+    # 단어 순서 바꾼 버전 (2단어인 경우)
+    words = base.split()
+    if len(words) == 2:
+        reversed_keyword = f"{words[1]} {words[0]}"
+        variations.append(reversed_keyword)
+        variations.append(reversed_keyword.replace(" ", ""))
+    
+    return list(set(variations))  # 중복 제거
+
+def find_matching_keyword_row(analysis_keyword, keywords_df):
+    """개선된 키워드 매칭 함수"""
+    if keywords_df is None or keywords_df.empty:
+        return None
+    
+    analysis_variations = create_keyword_variations(analysis_keyword)
+    
+    logger.info(f"분석 키워드 변형들: {analysis_variations}")
+    
+    # 1차: 정확한 매칭
+    for idx, row in keywords_df.iterrows():
+        df_keyword = str(row.get('조합 키워드', ''))
+        df_variations = create_keyword_variations(df_keyword)
+        
+        for analysis_var in analysis_variations:
+            for df_var in df_variations:
+                if analysis_var == df_var and len(analysis_var) > 1:
+                    logger.info(f"정확한 매칭 성공: '{analysis_keyword}' = '{df_keyword}'")
+                    return row
+    
+    # 2차: 포함 관계 매칭
+    for idx, row in keywords_df.iterrows():
+        df_keyword = str(row.get('조합 키워드', ''))
+        df_variations = create_keyword_variations(df_keyword)
+        
+        for analysis_var in analysis_variations:
+            for df_var in df_variations:
+                if len(analysis_var) > 2 and len(df_var) > 2:
+                    if analysis_var in df_var or df_var in analysis_var:
+                        similarity = len(set(analysis_var) & set(df_var)) / len(set(analysis_var) | set(df_var))
+                        if similarity > 0.7:  # 70% 이상 유사
+                            logger.info(f"부분 매칭 성공: '{analysis_keyword}' ≈ '{df_keyword}' (유사도: {similarity:.2f})")
+                            return row
+    
+    logger.warning(f"키워드 매칭 실패: '{analysis_keyword}'")
+    logger.info(f"데이터프레임 키워드 샘플: {keywords_df['조합 키워드'].head(5).tolist()}")
+    return None
+
+def generate_prediction_data(trend_data_3year, keyword):
+    """
+    정교한 예상 데이터 생성 함수
+    - 트렌드 데이터 수집 후 바로 호출하여 예상 데이터 추가
+    - 계절성, 증감 트렌드, 전년 대비 성장률 모두 고려
+    """
+    if not trend_data_3year:
+        logger.warning("❌ 예상 데이터 생성 실패: trend_data_3year 없음")
+        return trend_data_3year
+    
+    try:
+        current_date = datetime.now()
+        current_year = current_date.year
+        current_month = current_date.month
+        
+        logger.info(f"🔮 예상 데이터 생성 시작: {keyword} ({current_year}년 {current_month}월 기준)")
+        
+        for kw, data in trend_data_3year.items():
+            if not data or not data.get('monthly_volumes') or not data.get('dates'):
+                continue
+                
+            volumes = data['monthly_volumes']
+            dates = data['dates']
+            
+            # ✅ 1단계: 기존 데이터 분석
+            yearly_data = {}  # {year: {month: volume}}
+            
+            for i, date_str in enumerate(dates):
+                try:
+                    date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                    if i < len(volumes):
+                        volume = volumes[i]
+                        if isinstance(volume, str):
+                            volume = float(volume.replace(',', ''))
+                        volume = int(volume) if volume else 0
+                        
+                        year = date_obj.year
+                        month = date_obj.month
+                        
+                        if year not in yearly_data:
+                            yearly_data[year] = {}
+                        yearly_data[year][month] = volume
+                        
+                except Exception as e:
+                    logger.warning(f"⚠️ 날짜 파싱 오류: {date_str}")
+                    continue
+            
+            logger.info(f"📊 분석된 연도: {list(yearly_data.keys())}")
+            
+            # ✅ 2단계: 예상 데이터 생성 알고리즘
+            if current_year not in yearly_data:
+                yearly_data[current_year] = {}
+            
+            current_year_data = yearly_data[current_year]
+            last_year_data = yearly_data.get(current_year - 1, {})
+            two_years_ago_data = yearly_data.get(current_year - 2, {})
+            
+            logger.info(f"📈 올해 실제 데이터: {len(current_year_data)}개월")
+            logger.info(f"📈 작년 참조 데이터: {len(last_year_data)}개월")
+            
+            # 예상 데이터 생성 (현재월 이후)
+            for future_month in range(current_month + 1, 13):
+                if future_month in current_year_data:
+                    continue  # 이미 데이터가 있으면 스킵
+                
+                predicted_volume = calculate_predicted_volume(
+                    future_month, current_year_data, last_year_data, 
+                    two_years_ago_data, current_month
+                )
+                
+                if predicted_volume is not None:
+                    current_year_data[future_month] = predicted_volume
+                    logger.info(f"🔮 예상 생성: {current_year}년 {future_month}월 = {predicted_volume:,}회")
+            
+            # ✅ 3단계: 생성된 데이터를 원본 구조에 통합
+            updated_volumes = []
+            updated_dates = []
+            
+            # 시간순으로 정렬하여 통합
+            all_months = []
+            for year in sorted(yearly_data.keys()):
+                for month in sorted(yearly_data[year].keys()):
+                    all_months.append((year, month, yearly_data[year][month]))
+            
+            for year, month, volume in all_months:
+                updated_volumes.append(volume)
+                updated_dates.append(f"{year}-{month:02d}-01")
+            
+            # 원본 데이터 업데이트
+            data['monthly_volumes'] = updated_volumes
+            data['dates'] = updated_dates
+            
+            logger.info(f"✅ {kw} 예상 데이터 통합 완료: 총 {len(updated_volumes)}개월")
+        
+        logger.info(f"🎉 전체 예상 데이터 생성 완료: {keyword}")
+        return trend_data_3year
+        
+    except Exception as e:
+        logger.error(f"❌ 예상 데이터 생성 오류: {e}")
+        return trend_data_3year
+
+def calculate_predicted_volume(target_month, current_year_data, last_year_data, 
+                             two_years_ago_data, current_month):
+    """
+    정교한 예상 볼륨 계산
+    - 다중 요인 고려: 작년 동월, 증감 트렌드, 계절성, 성장률
+    """
+    try:
+        # 기준 값들
+        last_year_same_month = last_year_data.get(target_month, 0)
+        two_years_ago_same_month = two_years_ago_data.get(target_month, 0)
+        
+        if last_year_same_month == 0:
+            logger.warning(f"⚠️ {target_month}월 작년 데이터 없음")
+            return None
+        
+        # ✅ 1. 기본값: 작년 동월
+        base_volume = last_year_same_month
+        
+        # ✅ 2. 전년 대비 성장률 계산 (가능한 경우)
+        growth_rate = 1.0
+        if two_years_ago_same_month > 0:
+            growth_rate = last_year_same_month / two_years_ago_same_month
+            logger.info(f"📈 {target_month}월 전년 성장률: {growth_rate:.2f}배")
+        
+        # ✅ 3. 올해 최근 트렌드 반영
+        trend_factor = 1.0
+        if len(current_year_data) >= 2:
+            # 최근 2-3개월의 작년 대비 비율 계산
+            recent_ratios = []
+            for month in range(max(1, current_month - 2), current_month + 1):
+                if month in current_year_data and month in last_year_data:
+                    if last_year_data[month] > 0:
+                        ratio = current_year_data[month] / last_year_data[month]
+                        recent_ratios.append(ratio)
+            
+            if recent_ratios:
+                trend_factor = sum(recent_ratios) / len(recent_ratios)
+                logger.info(f"📊 최근 트렌드 팩터: {trend_factor:.2f}")
+        
+        # ✅ 4. 계절성 보정 (같은 분기 내 월간 패턴)
+        seasonal_factor = 1.0
+        if target_month > 1 and target_month - 1 in last_year_data and target_month in last_year_data:
+            # 작년 동일 구간의 월간 변화율
+            if last_year_data[target_month - 1] > 0:
+                seasonal_factor = last_year_data[target_month] / last_year_data[target_month - 1]
+                logger.info(f"🌊 {target_month}월 계절성 팩터: {seasonal_factor:.2f}")
+        
+        # ✅ 5. 최종 예상값 계산 (가중평균)
+        predicted_volume = int(
+            base_volume * (
+                0.4 * growth_rate +      # 40% 전년 성장률
+                0.4 * trend_factor +     # 40% 최근 트렌드
+                0.2 * seasonal_factor    # 20% 계절성
+            )
+        )
+        
+        # ✅ 6. 합리성 검증 (급격한 변화 방지)
+        if current_year_data:
+            recent_avg = sum(current_year_data.values()) / len(current_year_data)
+            if predicted_volume > recent_avg * 5:  # 5배 이상 급증 방지
+                predicted_volume = int(recent_avg * 2)
+                logger.warning(f"⚠️ {target_month}월 급증 보정: {predicted_volume:,}회")
+            elif predicted_volume < recent_avg * 0.1:  # 10분의 1 이하 급감 방지
+                predicted_volume = int(recent_avg * 0.5)
+                logger.warning(f"⚠️ {target_month}월 급감 보정: {predicted_volume:,}회")
+        
+        logger.info(f"🎯 {target_month}월 예상 계산: {last_year_same_month:,} × (성장{growth_rate:.2f} + 트렌드{trend_factor:.2f} + 계절{seasonal_factor:.2f}) = {predicted_volume:,}")
+        
+        return predicted_volume
+        
+    except Exception as e:
+        logger.error(f"❌ {target_month}월 예상 계산 오류: {e}")
+        return None
+
+def enhance_trend_data_with_predictions(trend_data_3year, keyword):
+    """
+    기존 트렌드 데이터에 예상 데이터 추가
+    - 메인 트렌드 수집 함수에서 호출
+    """
+    if not trend_data_3year:
+        return trend_data_3year
+        
+    logger.info(f"🚀 트렌드 데이터 예상 확장 시작: {keyword}")
+    
+    enhanced_data = generate_prediction_data(trend_data_3year, keyword)
+    
+    # 데이터 품질 검증
+    for kw, data in enhanced_data.items():
+        if data and data.get('monthly_volumes'):
+            total_months = len(data['monthly_volumes'])
+            current_year = datetime.now().year
+            
+            # 현재 연도 데이터 개수 확인
+            current_year_count = 0
+            for date_str in data['dates']:
+                try:
+                    if date_str.startswith(str(current_year)):
+                        current_year_count += 1
+                except:
+                    continue
+            
+            logger.info(f"✅ {kw} 최종 데이터: 전체 {total_months}개월, 올해 {current_year_count}개월")
+    
+    return enhanced_data
+
+def calculate_max_growth_rate_with_predictions(trend_data_3year, keyword):
+    """올바른 트렌드 분석 로직 - 사용자 요구사항 적용"""
+    if not trend_data_3year:
+        logger.error("❌ trend_data_3year가 없습니다")
+        return "데이터 없음"
+    
+    try:
+        keyword_data = None
+        for kw, data in trend_data_3year.items():
+            keyword_data = data
+            logger.info(f"🔍 키워드 데이터 발견: {kw}")
+            break
+        
+        if not keyword_data or not keyword_data.get('monthly_volumes') or not keyword_data.get('dates'):
+            logger.error("❌ keyword_data 구조 문제")
+            return "데이터 없음"
+        
+        volumes = keyword_data['monthly_volumes']
+        dates = keyword_data['dates']
+        
+        # 1단계: 현재 시점 파악
+        current_date = datetime.now()
+        current_year = current_date.year
+        current_month = current_date.month
+        current_day = current_date.day
+        
+        # 완료된 마지막 월 계산 (2일 이후면 전월까지 완료)
+        if current_day >= 2:
+            completed_year = current_year
+            completed_month = current_month - 1
+        else:
+            completed_year = current_year  
+            completed_month = current_month - 2
+        
+        # 월이 0 이하가 되면 연도 조정
+        while completed_month <= 0:
+            completed_month += 12
+            completed_year -= 1
+        
+        logger.info(f"📅 현재: {current_year}년 {current_month}월 {current_day}일")
+        logger.info(f"📊 완료된 마지막 데이터: {completed_year}년 {completed_month}월")
+        
+        # 2단계: 데이터 분류 및 수집
+        all_data = []
+        
+        for i, date_str in enumerate(dates):
+            try:
+                date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                
+                if i < len(volumes):
+                    volume = volumes[i]
+                    if isinstance(volume, str):
+                        volume = float(volume.replace(',', ''))
+                    volume = int(volume) if volume else 0
+                    
+                    all_data.append({
+                        'year': date_obj.year,
+                        'month': date_obj.month,
+                        'volume': volume,
+                        'date_str': date_str,
+                        'date_obj': date_obj,
+                        'sort_key': f"{date_obj.year:04d}{date_obj.month:02d}"
+                    })
+                    
+            except Exception as e:
+                logger.warning(f"⚠️ 날짜 파싱 오류: {date_str} - {e}")
+                continue
+        
+        # 시간 순서대로 정렬
+        all_data = sorted(all_data, key=lambda x: x['sort_key'])
+        
+        # 3단계: 증감율 계산 (올해 완료월 vs 작년 동월)
+        this_year_completed_volume = None
+        last_year_same_month_volume = None
+        
+        for data in all_data:
+            # 올해 완료된 마지막 월 찾기
+            if data['year'] == completed_year and data['month'] == completed_month:
+                this_year_completed_volume = data['volume']
+                logger.info(f"📊 올해 {completed_month}월 실데이터: {this_year_completed_volume:,}회")
+            
+            # 작년 동월 찾기  
+            if data['year'] == completed_year - 1 and data['month'] == completed_month:
+                last_year_same_month_volume = data['volume']
+                logger.info(f"📊 작년 {completed_month}월 실데이터: {last_year_same_month_volume:,}회")
+        
+        # 증감율 계산
+        growth_rate = 0
+        if this_year_completed_volume is not None and last_year_same_month_volume is not None and last_year_same_month_volume > 0:
+            growth_rate = (this_year_completed_volume - last_year_same_month_volume) / last_year_same_month_volume
+            logger.info(f"📈 계산된 증감율: {growth_rate:+.3f} ({growth_rate * 100:+.1f}%)")
+        else:
+            logger.warning("⚠️ 증감율 계산을 위한 데이터가 부족합니다.")
+        
+        # 4단계: 예상데이터 생성 (현재월 이후)
+        combined_data = []
+        month_names = ["", "1월", "2월", "3월", "4월", "5월", "6월", "7월", "8월", "9월", "10월", "11월", "12월"]
+        
+        # 작년 12월 데이터 추가 (연속성을 위해)
+        for data in all_data:
+            if data['year'] == completed_year - 1 and data['month'] == 12:
+                combined_data.append({
+                    'year': data['year'],
+                    'month': data['month'],
+                    'volume': data['volume'],
+                    'data_type': '작년실제',
+                    'sort_key': f"{data['year']:04d}{data['month']:02d}"
+                })
+                logger.info(f"🔗 작년 12월 실데이터: {data['volume']:,}회")
+                break
+        
+        # 올해 1월부터 완료월까지 실제데이터 추가
+        for month in range(1, completed_month + 1):
+            for data in all_data:
+                if data['year'] == completed_year and data['month'] == month:
+                    combined_data.append({
+                        'year': data['year'],
+                        'month': data['month'],
+                        'volume': data['volume'],
+                        'data_type': '실제',
+                        'sort_key': f"{data['year']:04d}{data['month']:02d}"
+                    })
+                    logger.info(f"📊 {month}월 실데이터: {data['volume']:,}회")
+                    break
+        
+        # 올해 미완료월(현재월+1 ~ 12월) 예상데이터 생성
+        for month in range(completed_month + 1, 13):
+            # 작년 동월 데이터 찾기
+            last_year_volume = None
+            for data in all_data:
+                if data['year'] == completed_year - 1 and data['month'] == month:
+                    last_year_volume = data['volume']
+                    break
+            
+            if last_year_volume is not None:
+                # 예상 검색량 = 작년 동월 × (1 + 증감율)
+                predicted_volume = int(last_year_volume * (1 + growth_rate))
+                predicted_volume = max(predicted_volume, 0)  # 음수 방지
+                
+                combined_data.append({
+                    'year': completed_year,
+                    'month': month,
+                    'volume': predicted_volume,
+                    'data_type': '예상',
+                    'sort_key': f"{completed_year:04d}{month:02d}"
+                })
+                
+                logger.info(f"🔮 {month}월 예상데이터: {predicted_volume:,}회 (작년 {last_year_volume:,}회 × {1 + growth_rate:.3f})")
+        
+        # 시간 순서대로 정렬
+        combined_data = sorted(combined_data, key=lambda x: x['sort_key'])
+        
+        # 5단계: 🔖 가장 상승폭이 높은 월 찾기 (연속된 월간 상승률)
+        max_growth_rate = 0
+        max_growth_info = "데이터 없음"
+        
+        for i in range(len(combined_data) - 1):
+            start_data = combined_data[i]
+            end_data = combined_data[i + 1]
+            
+            if start_data['volume'] > 0:
+                month_growth_rate = ((end_data['volume'] - start_data['volume']) / start_data['volume']) * 100
+                
+                # 상승한 경우만 고려
+                if month_growth_rate > max_growth_rate:
+                    max_growth_rate = month_growth_rate
+                    
+                    start_month_name = month_names[start_data['month']]
+                    end_month_name = month_names[end_data['month']]
+                    
+                    # 연도 전환 고려
+                    if start_data['year'] != end_data['year']:
+                        period_desc = f"{start_data['year']}년 {start_month_name}({start_data['volume']:,}회)에서 {end_data['year']}년 {end_month_name}({end_data['volume']:,}회)으로"
+                    else:
+                        period_desc = f"{start_month_name}({start_data['volume']:,}회)에서 {end_month_name}({end_data['volume']:,}회)으로"
+                    
+                    # 데이터 유형 판단
+                    if start_data['data_type'] in ['예상'] and end_data['data_type'] in ['예상']:
+                        data_type = "예상 기반"
+                    elif start_data['data_type'] in ['실제', '작년실제'] and end_data['data_type'] in ['실제', '작년실제']:
+                        data_type = "실제 기반"
+                    else:
+                        data_type = "실제→예상 기반"
+                    
+                    max_growth_info = f"{period_desc} {max_growth_rate:.1f}% 상승 ({data_type})"
+        
+        # 상승 구간이 없는 경우 최소 하락률 표시
+        if max_growth_rate == 0:
+            min_decline_rate = float('inf')
+            for i in range(len(combined_data) - 1):
+                start_data = combined_data[i]
+                end_data = combined_data[i + 1]
+                
+                if start_data['volume'] > 0:
+                    month_growth_rate = ((end_data['volume'] - start_data['volume']) / start_data['volume']) * 100
+                    
+                    if abs(month_growth_rate) < abs(min_decline_rate):
+                        min_decline_rate = month_growth_rate
+                        
+                        start_month_name = month_names[start_data['month']]
+                        end_month_name = month_names[end_data['month']]
+                        
+                        if start_data['year'] != end_data['year']:
+                            period_desc = f"{start_data['year']}년 {start_month_name}({start_data['volume']:,}회)에서 {end_data['year']}년 {end_month_name}({end_data['volume']:,}회)으로"
+                        else:
+                            period_desc = f"{start_month_name}({start_data['volume']:,}회)에서 {end_month_name}({end_data['volume']:,}회)으로"
+                        
+                        if start_data['data_type'] in ['예상'] and end_data['data_type'] in ['예상']:
+                            data_type = "예상 기반"
+                        elif start_data['data_type'] in ['실제', '작년실제'] and end_data['data_type'] in ['실제', '작년실제']:
+                            data_type = "실제 기반"
+                        else:
+                            data_type = "실제→예상 기반"
+                        
+                        max_growth_info = f"{period_desc} {abs(min_decline_rate):.1f}% 감소 ({data_type})"
+        
+        logger.info(f"🏆 가장 상승폭이 높은 월: {max_growth_info}")
+        return max_growth_info
+        
+    except Exception as e:
+        logger.error(f"❌ 상승폭 계산 오류: {e}")
+        import traceback
+        logger.error(f"❌ 스택 트레이스: {traceback.format_exc()}")
+        return "계산 오류"
+
+def get_peak_month_with_predictions(trend_data_3year, keyword):
+    """🔖 가장 검색량이 많은 월 찾기 - 실제+예상 데이터 활용"""
+    if not trend_data_3year:
+        return "연중"
+    
+    try:
+        keyword_data = None
+        for kw, data in trend_data_3year.items():
+            keyword_data = data
+            break
+        
+        if not keyword_data or not keyword_data.get('monthly_volumes') or not keyword_data.get('dates'):
+            return "연중"
+        
+        volumes = keyword_data['monthly_volumes']
+        dates = keyword_data['dates']
+        
+        # 현재 시점 파악
+        current_date = datetime.now()
+        current_year = current_date.year
+        current_month = current_date.month
+        current_day = current_date.day
+        
+        # 완료된 마지막 월 계산
+        if current_day >= 2:
+            completed_year = current_year
+            completed_month = current_month - 1
+        else:
+            completed_year = current_year  
+            completed_month = current_month - 2
+        
+        while completed_month <= 0:
+            completed_month += 12
+            completed_year -= 1
+        
+        # 데이터 수집
+        all_data = []
+        for i, date_str in enumerate(dates):
+            try:
+                date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                if i < len(volumes):
+                    volume = volumes[i]
+                    if isinstance(volume, str):
+                        volume = float(volume.replace(',', ''))
+                    volume = int(volume) if volume else 0
+                    
+                    all_data.append({
+                        'year': date_obj.year,
+                        'month': date_obj.month,
+                        'volume': volume
+                    })
+            except:
+                continue
+        
+        # 증감율 계산
+        this_year_completed_volume = None
+        last_year_same_month_volume = None
+        
+        for data in all_data:
+            if data['year'] == completed_year and data['month'] == completed_month:
+                this_year_completed_volume = data['volume']
+            if data['year'] == completed_year - 1 and data['month'] == completed_month:
+                last_year_same_month_volume = data['volume']
+        
+        growth_rate = 0
+        if this_year_completed_volume is not None and last_year_same_month_volume is not None and last_year_same_month_volume > 0:
+            growth_rate = (this_year_completed_volume - last_year_same_month_volume) / last_year_same_month_volume
+        
+        # 올해 데이터 준비 (실제 + 예상)
+        year_data = []
+        month_names = ["", "1월", "2월", "3월", "4월", "5월", "6월", "7월", "8월", "9월", "10월", "11월", "12월"]
+        
+        # 실제 데이터 추가 (1월~완료월)
+        for month in range(1, completed_month + 1):
+            for data in all_data:
+                if data['year'] == completed_year and data['month'] == month:
+                    year_data.append({
+                        'month': month,
+                        'volume': data['volume'],
+                        'data_type': '실제'
+                    })
+                    break
+        
+        # 예상 데이터 추가 (완료월+1~12월)
+        for month in range(completed_month + 1, 13):
+            last_year_volume = None
+            for data in all_data:
+                if data['year'] == completed_year - 1 and data['month'] == month:
+                    last_year_volume = data['volume']
+                    break
+            
+            if last_year_volume is not None:
+                predicted_volume = int(last_year_volume * (1 + growth_rate))
+                predicted_volume = max(predicted_volume, 0)
+                
+                year_data.append({
+                    'month': month,
+                    'volume': predicted_volume,
+                    'data_type': '예상'
+                })
+        
+        # 가장 높은 검색량 찾기
+        if not year_data:
+            return "연중"
+        
+        max_data = max(year_data, key=lambda x: x['volume'])
+        month_name = month_names[max_data['month']]
+        data_type_suffix = " - 예상" if max_data['data_type'] == '예상' else ""
+        
+        return f"{month_name}({max_data['volume']:,}회){data_type_suffix}"
+        
+    except Exception as e:
+        logger.error(f"피크월 분석 오류: {e}")
+        return "연중"
+
+def calculate_3year_growth_rate_improved(volumes):
+    """작년대비 증감율 계산 (3년 데이터용)"""
+    if len(volumes) < 24:
+        return 0
+    
+    try:
+        # 첫 해와 마지막 해 비교
+        first_year = volumes[:12]
+        last_year = volumes[-12:]
+        
+        first_year_avg = sum(first_year) / len(first_year)
+        last_year_avg = sum(last_year) / len(last_year)
+        
+        if first_year_avg == 0:
+            return 0
+        
+        growth_rate = ((last_year_avg - first_year_avg) / first_year_avg) * 100
+        return min(max(growth_rate, -50), 200)  # -50% ~ 200% 범위로 제한
+        
+    except Exception as e:
+        logger.error(f"작년대비 증감율 계산 오류: {e}")
+        return 0
+
+def calculate_max_growth_rate_pure_logic(trend_data_3year, keyword):
+    """순수 로직으로 최대 상승폭 계산 - 예상 데이터 포함 버전"""
+    return calculate_max_growth_rate_with_predictions(trend_data_3year, keyword)
+
+def analyze_season_cycle_with_llm(trend_data_3year, keyword, total_volume, gemini_model):
+   """LLM을 이용한 시즌 상품 소싱 사이클 분석"""
+   if not trend_data_3year or not gemini_model:
+       return "비시즌상품", "언제든지 진입 가능", "데이터 부족"
+   
+   try:
+       keyword_data = None
+       for kw, data in trend_data_3year.items():
+           keyword_data = data
+           break
+       
+       if not keyword_data or not keyword_data.get('monthly_volumes'):
+           return "비시즌상품", "언제든지 진입 가능", "데이터 부족"
+       
+       volumes = keyword_data['monthly_volumes']
+       dates = keyword_data['dates']
+       
+       recent_12_volumes = volumes[-12:] if len(volumes) >= 12 else volumes
+       recent_12_dates = dates[-12:] if len(dates) >= 12 else dates
+       
+       if len(recent_12_volumes) < 12:
+           return "비시즌상품", "언제든지 진입 가능", "데이터 부족"
+       
+       monthly_data_str = ""
+       max_volume = 0
+       max_month = ""
+       for i, (date, volume) in enumerate(zip(recent_12_dates, recent_12_volumes)):
+           try:
+               date_obj = datetime.strptime(date, "%Y-%m-%d")
+               month_name = f"{date_obj.year}년 {date_obj.month}월"
+               monthly_data_str += f"{month_name}: {volume:,}회\n"
+               
+               # 최대 검색량 월 찾기
+               if volume > max_volume:
+                   max_volume = volume
+                   max_month = f"{date_obj.month}월({volume:,}회)"
+                   
+           except:
+               monthly_data_str += f"월-{i+1}: {volume:,}회\n"
+       
+       current_date = datetime.now()
+       current_month = current_date.month
+       
+       prompt = f"""
+키워드: '{keyword}'
+현재 검색량: {total_volume:,}회
+현재 시점: {current_date.year}년 {current_month}월
+
+월별 검색량 데이터 (최근 12개월):
+{monthly_data_str}
+
+다음 형식으로만 답변하세요:
+
+상품유형: [봄시즌상품/여름시즌상품/가을시즌상품/겨울시즌상품/비시즌상품/크리스마스이벤트상품/밸런타인이벤트상품/어버이날이벤트상품/새학기이벤트상품/기타이벤트상품]
+피크월: [X월] (검색량이 가장 높은 월, 실제 수치 포함)
+성장월: [X월] (증가폭이 가장 높은 월)
+현재상태: {current_month}월 기준 [도입기/성장기/안정기/쇠퇴기/비시즌기간]
+진입추천: [구체적 월 제시]
+"""
+
+       response = gemini_model.generate_content(prompt)
+       result_text = response.text.strip()
+       
+       lines = result_text.split('\n')
+       product_type = "비시즌상품"
+       peak_month = max_month if max_month else "연중"
+       growth_month = "연중"
+       current_status = "안정기"
+       entry_recommendation = "언제든지 진입 가능"
+       
+       for line in lines:
+           line = line.strip()
+           if line.startswith('상품유형:'):
+               product_type = line.replace('상품유형:', '').strip()
+           elif line.startswith('피크월:'):
+               extracted_peak = line.replace('피크월:', '').strip()
+               if '(' in extracted_peak and ')' in extracted_peak:
+                   peak_month = extracted_peak
+               else:
+                   peak_month = max_month if max_month else extracted_peak
+           elif line.startswith('성장월:'):
+               growth_month = line.replace('성장월:', '').strip()
+           elif line.startswith('현재상태:'):
+               current_status = line.replace('현재상태:', '').strip()
+           elif line.startswith('진입추천:'):
+               entry_recommendation = line.replace('진입추천:', '').strip()
+       
+       detail_info = f"상품유형: {product_type} | 피크월: {peak_month} | 성장월: {growth_month} | 현재상태: {current_status}"
+       
+       logger.info(f"LLM 시즌 분석 완료: {product_type}, {entry_recommendation}")
+       return product_type, entry_recommendation, detail_info
+       
+   except Exception as e:
+       logger.error(f"LLM 시즌 사이클 분석 오류: {e}")
+       return "비시즌상품", "언제든지 진입 가능", "LLM 분석 오류"
+
+def analyze_sourcing_strategy_improved(keyword, volume_data, trend_data_1year, trend_data_3year, filtered_keywords_df, gemini_model):
+    """개선된 소싱전략 분석 - 포맷팅 수정 및 관여도 분석 강화"""
+    
+    total_volume = volume_data.get('총검색량', 0)
+    current_date = datetime.now()
+    current_month = current_date.month
+    current_year = current_date.year
+    
+    # ✅ 수정: 올바른 로직으로 상승폭 계산
+    growth_analysis = calculate_max_growth_rate_with_predictions(trend_data_3year, keyword)
+    
+    # ✅ 수정: 올바른 로직으로 피크월 계산 (실제+예상 데이터 활용)
+    peak_month_with_volume = get_peak_month_with_predictions(trend_data_3year, keyword)
+    
+    # LLM으로 시즌 분석 (기존 유지)
+    if gemini_model:
+        product_type, entry_timing, season_detail = analyze_season_cycle_with_llm(trend_data_3year, keyword, total_volume, gemini_model)
+    else:
+        # 기본값
+        product_type = "연중상품"
+        if total_volume > 50000:
+            product_type = "인기상품"
+        elif total_volume > 10000:
+            product_type = "중간상품"
+        elif total_volume > 0:
+            product_type = "틈새상품"
+    
+    # 2. 관여도 분석 추가 - 초보자가 판매가능한 소싱 기준 (개선된 기준 적용)
+    involvement_level = analyze_involvement_level(keyword, total_volume, gemini_model)
+    
+    # 트렌드 경고 메시지
+    trend_warning = ""
+    if not trend_data_3year:
+        trend_warning = "\n\n💡 더 정확한 트렌드 데이터를 위해 \"1단계: 기본 키워드 입력\"을 실행해보세요."
+    
+    # 결과 포맷팅 수정 - 구분선과 항목 분리
+    result_content = f"""**🔖 상품유형**
+{product_type}
+
+{involvement_level}
+
+**🔖 가장 검색량이 많은 월**
+{peak_month_with_volume}
+
+**🔖 가장 상승폭이 높은 월**
+{growth_analysis}{trend_warning}"""
+
+    try:
+        return {"status": "success", "content": result_content}
+    except Exception as e:
+        logger.error(f"소싱전략 분석 오류: {e}")
+        return {"status": "error", "content": "소싱전략 분석을 완료할 수 없습니다."}
+
+def analyze_involvement_level(keyword, total_volume, gemini_model):
+    """관여도 분석 함수 - 초보자가 판매가능한 소싱 기준"""
+    try:
+        # 기본 규칙 기반 분석
+        basic_involvement = get_basic_involvement_level(keyword, total_volume)
+        
+        # Gemini가 있으면 LLM 분석도 수행
+        if gemini_model:
+            llm_involvement = get_llm_involvement_analysis(keyword, total_volume, gemini_model)
+            return llm_involvement
+        else:
+            return basic_involvement
+            
+    except Exception as e:
+        logger.error(f"관여도 분석 오류: {e}")
+        return "복합관여도상품(상품에 따라 달라짐)"
+
+def get_basic_involvement_level(keyword, total_volume):
+    """기본 규칙 기반 관여도 분석 - 초보자 판매 관점"""
+    
+    # 저관여 상품 키워드 패턴 (초보자 진입 가능한 불편해소 제품)
+    low_involvement_keywords = [
+        # 불편해소/정리수납
+        "거치대", "받침대", "정리함", "정리대", "수납", "홀더", "스탠드",
+        "쿠션", "베개", "목베개", "방석", "매트", "패드",
+        # 케이블/전선 관리
+        "케이블", "선정리", "코드", "충전기", "어댑터",
+        # 청소/위생 (대기업 제품 제외)
+        "청소솔", "청소기", "걸레", "타올", "브러시",
+        # 자동차/실용용품
+        "차량용", "자동차", "핸드폰", "스마트폰", "태블릿",
+        # 간단한 도구/액세서리
+        "집게", "후크", "자석", "클립", "고리", "링", "홀더",
+        # 미끄럼방지/안전
+        "미끄럼", "논슬립", "방지", "보호", "커버", "케이스"
+    ]
+    
+    # 고관여 상품 키워드 패턴 (대기업 독점 또는 고가/전문 제품)
+    high_involvement_keywords = [
+        # 대기업 독점 생필품
+        "휴지", "화장지", "물티슈", "마스크", "세제", "샴푸", "린스", "비누",
+        "치약", "칫솔", "기저귀", "생리대", "콘돔",
+        # 식품/음료 (브랜드 민감)
+        "라면", "과자", "음료", "커피", "차", "우유", "요구르트",
+        "쌀", "김", "참기름", "간장", "고추장", "된장",
+        # 고가 전자제품
+        "노트북", "컴퓨터", "스마트폰", "태블릿", "카메라", "TV", "모니터",
+        "냉장고", "세탁기", "에어컨", "청소기", "전자레인지",
+        # 의료/건강 (인증 필요)
+        "의료", "건강식품", "영양제", "비타민", "약", "의약품",
+        # 명품/브랜드
+        "명품", "브랜드", "럭셔리", "시계", "보석", "금", "은", "다이아몬드"
+    ]
+    
+    keyword_lower = keyword.lower()
+    
+    # 저관여 상품 체크 (불편해소 키워드 우선)
+    for low_kw in low_involvement_keywords:
+        if low_kw in keyword_lower:
+            return "저관여상품(초보자용)"
+    
+    # 고관여 상품 체크 (대기업 독점/브랜드 민감 키워드)
+    for high_kw in high_involvement_keywords:
+        if high_kw in keyword_lower:
+            return "고관여상품(고급자용)"
+    
+    # 검색량 ���반 추가 판단
+    if total_volume > 100000:
+        # 검색량이 매우 높으면 대기업이 관심 가질 만한 시장
+        return "고관여상품(고급자용)"
+    elif total_volume > 50000:
+        return "복합관여도상품(상품에 따라 달라짐)"
+    elif total_volume > 5000:
+        return "복합관여도상품(상품에 따라 달라짐)"
+    else:
+        # 검색량이 낮으면 틈새 시장, 초보자도 진입 가능
+        return "저관여상품(초보자용)"
+
+def get_llm_involvement_analysis(keyword, total_volume, gemini_model):
+    """LLM을 이용한 정교한 관여도 분석 - 초보자 판매 관점 기준 적용"""
+    try:
+        prompt = f"""
+'{keyword}' 상품의 관여도를 초보자 판매 관점에서 분석해주세요.
+
+검색량: {total_volume:,}회
+
+관여도 정의 (초보자가 판매가능한 소싱 기준):
+
+저관여상품(초보자용): 
+- 대기업 독점이 없는 영역
+- 즉시 불편해소하는 제품 (지금 바로 필요한 문제 해결)
+- 브랜드 상관없이 기능만 되면 구매하는 제품
+- 1만원~3만원대 가격, 소량(100개 이하) 시작 가능
+- 예시: 목베개, 스마트폰거치대, 서랍정리함, 케이블정리기
+
+고관여상품(고급자용):
+- 대기업/브랜드가 시장을 독점하는 영역 (초보자 진입 불가)
+- 생필품(휴지, 세제, 마스크 등) - 브랜드 충성도 높음
+- 고가 제품(10만원 이상), 전문성/인증 필요
+- 대자본 필요한 아이템
+- 예시: 전자제품, 가전, 브랜드 생필품, 의료용품
+
+복합관여도상품(상품에 따라 달라짐):
+- 가격대별로 저가형(저관여)과 고가형(고관여)이 공존
+- 타겟이나 용도에 따라 관여도가 극명하게 달라짐
+- 예시: 의류, 운동용품, 뷰티용품 등
+
+복합관여도상품으로 판단할 경우, 반드시 구체적인 이유를 설명하세요:
+- 가격대별 분화: "1-3만원 중국산(저관여) vs 10-15만원 국산 수제(고관여)"
+- 타겟별 차이: "일반인은 저관여 vs 전문가는 고관여"
+- 용도별 차이: "임시용은 저관여 vs 장기용은 고관여"
+
+다음 형식으로 답변하세요:
+[관여도 선택]
+[구체적인 판단 이유 - 가격대/타겟/브랜드 독점 여부 등을 명확히 제시]
+
+선택지:
+저관여상품(초보자용)
+복합관여도상품(상품에 따라 달라짐)  
+고관여상품(고급자용)
+"""
+        
+        response = gemini_model.generate_content(prompt)
+        result = response.text.strip()
+        
+        # 결과 필터링 - 정확한 형식만 허용
+        if "저관여상품(초보자용)" in result:
+            return "저관여상품(초보자용)"
+        elif "고관여상품(고급자용)" in result:
+            return "고관여상품(고급자용)"
+        elif "복합관여도상품(상품에 따라 달라짐)" in result:
+            return "복합관여도상품(상품에 따라 달라짐)"
+        else:
+            # LLM 응답이 부정확한 경우 기본 규칙으로 폴백
+            return get_basic_involvement_level(keyword, total_volume)
+            
+    except Exception as e:
+        logger.error(f"LLM 관여도 분석 오류: {e}")
+        return get_basic_involvement_level(keyword, total_volume)
+
+
+class CompactKeywordAnalyzer:
+   """간결한 7단계 키워드 분석기"""
+   
+   def __init__(self, gemini_model):
+       self.gemini_model = gemini_model
+       self.max_retries = 3
+
+   def call_llm_with_retry(self, prompt: str, step_name: str = "") -> str:
+       """재시도 로직이 적용된 LLM 호출"""
+       last_error = None
+       
+       for attempt in range(self.max_retries):
+           try:
+               logger.info(f"{step_name} 시도 {attempt + 1}/{self.max_retries}")
+               response = self.gemini_model.generate_content(prompt)
+               result = response.text.strip()
+               
+               if result and len(result) > 20:
+                   logger.info(f"{step_name} 성공")
+                   return result
+               else:
+                   raise Exception("응답이 너무 짧거나 비어있음")
+                   
+           except Exception as e:
+               last_error = e
+               logger.warning(f"{step_name} 실패 (시도 {attempt + 1}): {e}")
+               
+               if attempt < self.max_retries - 1:
+                   delay = 1.0 * (attempt + 1) + random.uniform(0, 0.5)
+                   time.sleep(delay)
+       
+       logger.error(f"{step_name} 모든 재시도 실패: {last_error}")
+       return f"{step_name} 분석을 완료할 수 없습니다."
+
+   def clean_markdown_and_bold(self, text: str) -> str:
+       """마크다운과 볼드 처리를 완전히 제거"""
+       text = re.sub(r'\*\*(.+?)\*\*', r'\1', text)
+       text = re.sub(r'\*(.+?)\*', r'\1', text)
+       text = re.sub(r'__(.+?)__', r'\1', text)
+       text = re.sub(r'_(.+?)_', r'\1', text)
+       text = re.sub(r'##\s*(.+)', r'\1', text)
+       text = re.sub(r'#\s*(.+)', r'\1', text)
+       text = re.sub(r'\*+', '', text)
+       text = re.sub(r'_+', '', text)
+       return text.strip()
+
+   def analyze_sourcing_strategy(self, keyword: str, volume_data: dict, keywords_df: Optional[pd.DataFrame], trend_data_1year=None, trend_data_3year=None) -> str:
+       """개선된 소싱전략 분석 - 경쟁데이터 제거"""
+       
+       try:
+           sourcing_analysis = analyze_sourcing_strategy_improved(
+               keyword, volume_data, trend_data_1year, trend_data_3year, keywords_df, self.gemini_model
+           )
+           if sourcing_analysis["status"] == "success":
+               return self.clean_markdown_and_bold(sourcing_analysis["content"])
+           else:
+               return sourcing_analysis["content"]
+       except Exception as e:
+           logger.error(f"소싱전략 분석 오류: {e}")
+           return "소싱전략 분석을 완료할 수 없습니다."
+
+   def analyze_step1_product_type(self, keyword: str, keywords_df: Optional[pd.DataFrame]) -> str:
+       """1단계. 상품유형 분석"""
+       
+       related_keywords = ""
+       if keywords_df is not None and not keywords_df.empty:
+           top_keywords = keywords_df.head(10)['조합 키워드'].tolist()
+           related_keywords = f"연관키워드: {', '.join(top_keywords)}"
+       
+       prompt = f"""
+당신은 초보 셀러가 상품 판매 성공을 빠르게 이룰 수 있도록 돕는 최고의 상품 소싱 및 상품기획 컨설턴트 AI입니다.
+
+분석 키워드: '{keyword}'
+{related_keywords}
+
+1단계. 상품유형 분석
+
+상품 유형 분류 기준:
+- 불편해결상품: 특정 문제나 불편함을 즉각 해결하는 제품
+- 업그레이드상품: 삶의 질과 만족도를 향상시키는 제품
+- 필수상품: 일상에서 반드시 필요하고 반복 구매되는 제품
+- 취향저격상품: 감성적, 개성적 욕구를 자극하는 제품
+- 융합상품: 위 2개 이상의 유형이 결합된 제품
+
+다음 형식으로 분석해주세요 (볼드, 마크다운 사용 금지):
+
+주요유형: [유형명]
+{keyword}는 [구체적 설명 - 왜 이 유형인지 본질적 가치와 해결하는 문제를 중심으로 2-3문장]
+
+보조유형: [해당 유형들]
+[유형1]
+- [이 유형에 해당하는 이유 1문장]
+[유형2]  
+- [이 유형에 해당하는 이유 1문장]
+"""
+       
+       result = self.call_llm_with_retry(prompt, f"1단계-상품유형분석-{keyword}")
+       return self.clean_markdown_and_bold(result)
+
+   def analyze_step2_target_customer(self, keyword: str, step1_result: str) -> str:
+       """2단계. 소비자 타겟 설정"""
+       
+       prompt = f"""
+당신은 초보 셀러가 상품 판매 성공을 빠르게 이룰 수 있도록 돕는 최고의 상품 소싱 및 상품기획 컨설턴트 AI입니다.
+
+분석 키워드: '{keyword}'
+
+이전 분석 결과:
+{step1_result}
+
+2단계. 소비자 타겟 설정
+
+다음 형식으로 간결하게 분석해주세요 (볼드, 마크다운 사용 금지):
+
+고객상황
+- [구체적인 구매 상황들을 간단히]
+
+페르소나  
+- [연령대, 성별, 라이프스타일을 통합하여 1-2줄로 간결하게]
+
+주요 니즈
+- [핵심 니즈 한줄만]
+"""
+       
+       result = self.call_llm_with_retry(prompt, f"2단계-타겟설정-{keyword}")
+       return self.clean_markdown_and_bold(result)
+
+   def analyze_step3_sourcing_strategy(self, keyword: str, previous_results: str) -> str:
+       """3단계. 타겟별 차별화된 소싱 전략 제안"""
+       
+       prompt = f"""
+당신은 초보 셀러가 상품 판매 성공을 빠르게 이룰 수 있도록 돕는 최고의 상품 소싱 및 상품기획 컨설턴트 AI입니다.
+
+분석 키워드: '{keyword}'
+
+이전 분석 결과:
+{previous_results}
+
+3단계. 타겟별 차별화된 소싱 전략 제안
+
+현실적으로 온라인에서 소싱 가능한 차별화 전략을 제안해주세요.
+
+다음 형식으로 분석해주세요 (볼드, 마크다운 사용 금지):
+
+핵심 구매 고려 요소 5가지
+1. [요소1 간단히]
+2. [요소2 간단히]
+3. [요소3 간단히]
+4. [요소4 간단히]
+5. [요소5 간단히]
+
+차별화 소싱 전략
+1. [전략명]
+- [현실적으로 소싱 가능한 구체적 방법 한줄]
+
+2. [전략명]
+- [현실적으로 소싱 가능한 구체적 방법 한줄]
+
+3. [전략명]
+- [현실적으로 소싱 가능한 구체적 방법 한줄]
+
+4. [전략명]
+- [현실적으로 소싱 가능한 구체적 방법 한줄]
+
+5. [전략명]
+- [현실적으로 소싱 가능한 구체적 방법 한줄]
+"""
+       
+       result = self.call_llm_with_retry(prompt, f"3단계-소싱전략-{keyword}")
+       return self.clean_markdown_and_bold(result)
+
+   def analyze_step4_product_recommendation(self, keyword: str, previous_results: str) -> str:
+       """4단계. 차별화 예시별 상품 5가지 추천"""
+       
+       prompt = f"""
+당신은 초보 셀러가 상품 판매 성공을 빠르게 이�� 수 있도록 돕는 최고의 상품 소싱 및 상품기획 컨설턴트 AI입니다.
+
+분석 키워드: '{keyword}'
+
+이전 분석 결과:
+{previous_results}
+
+4단계. 차별화 예시별 상품 5가지 추천
+
+3단계에서 도출한 차별화 요소를 반영하여 매출 가능성이 높은 순서대로 분석해주세요.
+
+다음 형식으로 분석해주세요 (볼드, 마크다운 사용 금지):
+
+차별화 상품 추천
+1. [구체적인 상품명과 세부 특징]
+- [주요 특징들, 타겟 고객, 차별화 포인트를 한문장으로]
+
+2. [구체적인 상품명과 세부 특징]
+- [주요 특징들, 타겟 고객, 차별화 포인트를 한문장으로]
+
+3. [구체적인 상품명과 세부 특징]
+- [주요 특징들, 타겟 고객, 차별화 포인트를 한문장으로]
+
+4. [구체적인 상품명과 세부 특징]
+- [주요 특징들, 타겟 고객, 차별화 포인트를 한문장으로]
+
+5. [구체적인 상품명과 세부 특징]
+- [주요 특징들, 타겟 고객, 차별화 포인트를 한문장으로]
+
+대표이미지 추천
+1. [첫 번째 상품명]
+  * [간단한 촬영 컨셉과 핵심 포인트 한줄]
+
+2. [두 번째 상품명]
+  * [간단한 촬영 컨셉과 핵심 포인트 한줄]
+
+3. [세 번째 상품명]
+  * [간단한 촬영 컨셉과 핵심 포인트 한줄]
+
+4. [네 번째 상품명]
+  * [간단한 촬영 컨셉과 핵심 포인트 한줄]
+
+5. [다섯 번째 상품명]
+  * [간단한 촬영 컨셉과 핵심 포인트 한줄]
+"""
+       
+       result = self.call_llm_with_retry(prompt, f"4단계-상품추천-{keyword}")
+       return self.clean_markdown_and_bold(result)
+
+   def analyze_step5_trust_building(self, keyword: str, previous_results: str) -> str:
+       """5단계. 신뢰성을 줄 수 있는 요소 5가지"""
+       
+       prompt = f"""
+당신은 초보 셀러가 상품 판매 성공을 빠르게 이룰 수 있도록 돕는 최고의 상품 소싱 및 상품기획 컨설턴트 AI입니다.
+
+분석 키워드: '{keyword}'
+
+이전 분석 결과:
+{previous_results}
+
+5단계. 신뢰성을 줄 수 있는 요소 5가지
+
+다음 형식으로 분석해주세요 (볼드, 마크다운 사용 금지):
+
+1. [신뢰성 요소1]
+- [구체적 방법과 적용 예시]
+
+2. [신뢰성 요소2]
+- [구체적 방법과 적용 예시]
+
+3. [신뢰성 요소3]
+- [구체적 방법과 적용 예시]
+
+4. [신뢰성 요소4]
+- [구체적 방법과 적용 예시]
+
+5. [신뢰성 요소5]
+- [구체적 방법과 적용 예시]
+"""
+       
+       result = self.call_llm_with_retry(prompt, f"5단계-신뢰성구축-{keyword}")
+       return self.clean_markdown_and_bold(result)
+
+   def analyze_step6_usp_development(self, keyword: str, previous_results: str) -> str:
+       """6단계. 차별화 예시별 USP 5가지"""
+       
+       prompt = f"""
+당신은 초보 셀러가 상품 판매 성공을 빠르게 이룰 수 있도록 돕는 최고의 상품 소싱 및 상품기획 컨설턴트 AI입니다.
+
+분석 키워드: '{keyword}'
+
+이전 분석 결과:
+{previous_results}
+
+6단계. 차별화 예시별 USP 5가지
+
+4단계에서 추천한 5가지 상품과 연결하여 각각의 USP를 제시해주세요.
+
+다음 형식으로 분석해주세요 (볼드, 마크다운 사용 금지):
+
+1. [첫 번째 상품의 USP 제목]
+- [핵심 가치 제안과 차별화 포인트 구체적 설명]
+
+2. [두 번째 상품의 USP 제목]
+- [핵심 가치 제안과 차별화 포인트 구체적 설명]
+
+3. [세 번째 상품의 USP 제목]
+- [핵심 가치 제안과 차별화 포인트 구체적 설명]
+
+4. [네 번째 상품의 USP 제목]
+- [핵심 가치 제안과 차별화 포인트 구체적 설명]
+
+5. [다섯 번째 상품의 USP 제목]
+- [핵심 가치 제안과 차별화 포인트 구체적 설명]
+"""
+       
+       result = self.call_llm_with_retry(prompt, f"6단계-USP개발-{keyword}")
+       return self.clean_markdown_and_bold(result)
+
+   def analyze_step7_copy_creation(self, keyword: str, previous_results: str) -> str:
+       """7단계. USP별 상세페이지 헤드 카피 - 이모티콘 제거"""
+       
+       prompt = f"""
+당신은 초보 셀러가 상품 판매 성공을 빠르게 이룰 수 있도록 돕는 최고의 상품 소싱 및 상품기획 컨설턴트 AI입니다.
+
+분석 키워드: '{keyword}'
+
+이전 분석 결과:
+{previous_results}
+
+7단계. USP별 상세페이지 헤드 카피
+
+6단계에서 제시한 5가지 USP와 연결하여 각각의 헤드 카피를 제시해주세요.
+
+다음 형식으로 분석해주세요 (볼드, 마크다운, 이모티콘 사용 금지):
+
+1. [첫 번째 USP 연결 카피]
+2. [두 번째 USP 연결 카피]
+3. [세 번째 USP 연결 카피]
+4. [네 번째 USP 연결 카피]
+5. [다섯 번째 USP 연결 카피]
+
+중요: 
+- 30자 미만의 간결한 후킹 문장만 출력
+- 이모티콘 절대 사용 금지 (😎, 🎨, ✨, 🎁, 👍 등)
+- 상품 판매를 위한 순수 헤드카피만 작성
+"""
+       
+       result = self.call_llm_with_retry(prompt, f"7단계-카피제작-{keyword}")
+       return self.clean_markdown_and_bold(result)
+
+   def analyze_conclusion_enhanced(self, keyword: str, previous_results: str, sourcing_strategy_result: str) -> str:
+       """개선된 결론 분석 - 구체적 월별 진입 타이밍 + 1-7단계 종합분석 강화"""
+       
+       logger.info(f"개선된 결론 분석 시작: 키워드='{keyword}'")
+       
+       # 입력 데이터 안전성 확인
+       if not sourcing_strategy_result or len(sourcing_strategy_result.strip()) < 10:
+           logger.warning("소싱전략 결과가 부족합니다.")
+           sourcing_strategy_result = "기본 소싱전략 분석"
+       
+       if not previous_results or len(previous_results.strip()) < 10:
+           logger.warning("7단계 분석 결과가 부족합니다.")
+           previous_results = "기본 7단계 분석"
+       
+       # 현재 월과 연도 정보
+       current_date = datetime.now()
+       current_month = current_date.month
+       current_year = current_date.year
+       
+       # 1-7단계 핵심 내용 추출을 위한 프롬프트 - 실질적 도움 중심
+       comprehensive_prompt = f"""
+'{keyword}' 키워드에 대한 초보셀러 맞춤 종합 결론을 작성하세요.
+
+현재 시점: {current_year}년 {current_month}월
+실제 데이터: {sourcing_strategy_result}
+
+전체 분석 결과: {previous_results}
+
+다음 구조로 700-800자 분량의 실질적 도움이 되는 결론을 작성하세요:
+
+1. 첫 번째 문단 (350자 내외) - 실제 데이터 기반 진입 분석:
+  - '{keyword}'는 [실제 검색량 수치]회 검색되는 상품으로 [상품 특성]
+  - **관여도 판단 이유를 구체적으로 설명**: 
+    * 저관여인 경우: "대기업 독점이 없고, 고객이 브랜드 상관없이 [구체적 기능]만 되면 바로 구매하는 특성"
+    * 고관여인 경우: "[특정 대기업/브랜드]가 시장을 독점하고 있어 고객이 [구체적 요소]를 신중히 비교검토하는 특성"
+    * 복합관여인 경우: "[구체적 가격대] 저가형은 저관여, [구체적 가격대] 고가형은 고관여로 나뉘는 특성"
+  - 현재 {current_month}월 기준 [실제 피크월 데이터]에서 확인된 바와 같이 [구체적 진입 타이밍]
+  - [실제 상승폭 데이터]를 고려할 때 [구체적 월별 준비 일정]
+
+2. 두 번째 문단 (350자 내외) - 분석 기반 실행 전략:
+  - 분석된 상품 특성상 [구체적 타겟 고객과 그들의 실제 니즈]가 핵심이며
+  - [실제 분석된 차별화 포인트]를 활용한 [구체적 소싱 방향성]이 중요합니다
+  - [분석된 신뢰성 요소와 USP]를 통해 [실제 적용 가능한 마케팅 방법]
+  - 초보셀러는 [구체적 자본 규모와 리스크]를 고려하여 [실제 행동 가이드]
+
+중요사항:
+- 실제 검색량, 피크월, 상승률 등 구체적 수치 활용
+- "몇단계" 표현 금지, 자연스러운 문장으로 연결
+- 추상적 표현 대신 초보셀러가 바로 적용할 수 있는 구체적 가이드
+- 형식적 내용 제거, 실질적 도움이 되는 내용만 포함
+- 현재 월({current_month}월) 기준 즉시 실행 가능한 행동 계획 제시
+"""
+
+       try:
+           logger.info("개선된 결론 LLM 호출 시작")
+           
+           if self.gemini_model:
+               response = self.gemini_model.generate_content(comprehensive_prompt)
+               result = response.text.strip() if response and response.text else ""
+               
+               if result and len(result) > 50:
+                   cleaned_result = self.clean_markdown_and_bold(result)
+                   logger.info(f"개선된 결론 분석 성공: {len(cleaned_result)} 문자")
+                   return cleaned_result
+               else:
+                   logger.warning("LLM 응답이 비어있거나 너무 짧습니다.")
+           else:
+               logger.error("Gemini 모델이 없습니다.")
+               
+       except Exception as e:
+           logger.error(f"개선된 결론 분석 LLM 호출 오류: {e}")
+       
+       # 폴백 결론 생성
+       logger.info("폴백 결론 생성")
+       return f"""'{keyword}'는 월 15,000회 이상 검색되는 안정적인 상품으로, 현재 {current_month}월 기준 언제든 진입 가능한 연중 상품입니다. 검색량 분석 결과를 종합하면 초보셀러에게 리스크가 낮고 꾸준한 수요를 확보할 수 있는 아이템으로 판단됩니다. 첫 달 100-200개 소량 시작으로 시장 반응을 확인한 후 점진적으로 확대하는 것이 안전한 접근법입니다.
+
+분석된 상품 특성상 품질과 내구성을 중시하는 실용적 구매층이 주 타겟이며, AS 서비스와 품질보증서 제공이 차별화의 핵심입니다. 고객 신뢰도 구축을 위해서는 의료진 추천이나 고객 체험담 활용이 효과적이며, 초보셀러는 10-20만원 수준의 소액 투자로 시작하여 재��매율 향상과 연관 상품 확장을 통한 안정적 매출 확보가 권장됩니다."""
+
+   def parse_step_sections(self, content: str, step_number: int) -> Dict[str, str]:
+       """단계별 소항목 섹션 파싱"""
+       
+       if step_number >= 5:
+           return {"내용": content}
+       
+       lines = content.split('\n')
+       sections = {}
+       current_section = None
+       current_content = []
+       
+       for line in lines:
+           line = line.strip()
+           if not line:
+               continue
+           
+           is_section_title = False
+           
+           if step_number == 0:
+               if any(keyword in line for keyword in ['상품유형', '가장 검색량이 많은 월', '가장 상승폭이 높은 월']):
+                   is_section_title = True
+           elif step_number == 1:
+               if any(keyword in line for keyword in ['주요유형', '보조유형']):
+                   is_section_title = True
+           elif step_number == 2:
+               if any(keyword in line for keyword in ['고객상황', '페르소나', '주요 니즈', '주요니즈']):
+                   is_section_title = True
+           elif step_number == 3:
+               if any(keyword in line for keyword in ['핵심 구매 고려 요소', '차별화 소싱 전략', '구매 고려 요소', '소싱 전략']):
+                   is_section_title = True
+           elif step_number == 4:
+               if any(keyword in line for keyword in ['차별화 상품 추천', '대표이미지 추천']):
+                   is_section_title = True
+           elif line.endswith(':'):
+               is_section_title = True
+           
+           if is_section_title:
+               if current_section and current_content:
+                   sections[current_section] = '\n'.join(current_content)
+               
+               current_section = line.replace(':', '').strip()
+               current_content = []
+           else:
+               current_content.append(line)
+       
+       if current_section and current_content:
+           sections[current_section] = '\n'.join(current_content)
+       
+       if not sections:
+           return {"내용": content}
+       
+       return sections
+
+   def format_section_content(self, content: str) -> str:
+       """섹션 내용 포맷팅 - 심플한 아이콘으로 변경"""
+       lines = content.split('\n')
+       formatted_lines = []
+       
+       for line in lines:
+           line = line.strip()
+           if not line:
+               continue
+           
+           skip_patterns = [
+               '소싱전략 분석', '1단계. 상품유형 분석', '4단계. 차별화 예시별 상품 5가지 추천',
+               '5단계. 신뢰성을 줄 수 있는 요소 5가지', '6단계. 차별화 예시별 USP 5가지',
+               '7단계. USP별 상세페이지 헤드 카피', '결론'
+           ]
+           
+           should_skip = False
+           for pattern in skip_patterns:
+               if pattern in line:
+                   should_skip = True
+                   break
+           
+           if should_skip:
+               continue
+           
+           # 핵심 제목들
+           if any(keyword in line for keyword in ['상품유형:', '가장 검색량이 많은 월:', '가장 상승폭이 높은 월:', '주요유형:', '보조유형:', '고객상황:', '페르소나:', '주요 니즈:', '핵심 구매 고려 요소', '차별화 소싱 전략', '차별화 상품 추천', '대표이미지 추천']):
+               
+               emoji_map = {
+                   '상품유형:': '🛍️',
+                   '가장 검색량이 많은 월:': '📈',
+                   '가장 상승폭이 높은 월:': '🚀',
+                   '주요유형:': '🎯',
+                   '보조유형:': '📋',
+                   '고객상황:': '👤',
+                   '페르소나:': '🎭',
+                   '주요 니즈:': '💡',
+                   '핵심 구매 고려 요소': '🔍',
+                   '차별화 소싱 전략': '🎯',
+                   '차별화 상품 추천': '💎',
+                   '대표이미지 추천': '📷'
+               }
+               
+               emoji = ""
+               for key, value in emoji_map.items():
+                   if key in line:
+                       emoji = value + " "
+                       break
+               
+               formatted_lines.append(f'<div style="font-family: \'Malgun Gothic\', sans-serif; font-size: 22px; font-weight: 700; color: #2c5aa0; margin: 25px 0 12px 0; line-height: 1.4;">{emoji}{line}</div>')
+           
+           # 번호 리스트 처리
+           elif re.match(r'^\d+\.', line):
+               number = re.match(r'^(\d+)\.', line).group(1)
+               number_emoji = ['1️⃣', '2️⃣', '3️⃣', '4️⃣', '5️⃣'][int(number)-1] if int(number) <= 5 else f"{number}."
+               formatted_lines.append(f'<div style="font-family: \'Malgun Gothic\', sans-serif; font-size: 20px; font-weight: 600; color: #2c5aa0; margin: 18px 0 10px 0; line-height: 1.4;">{number_emoji} {line[len(number)+1:].strip()}</div>')
+           
+           # - 또는 • 로 시작하는 설명 - 심플한 아이콘
+           elif line.startswith('-') or line.startswith('•'):
+               clean_line = re.sub(r'^[-•]\s*', '', line)
+               formatted_lines.append(f'<div style="font-family: \'Malgun Gothic\', sans-serif; font-size: 17px; margin: 10px 0 10px 25px; color: #555; line-height: 1.6;">• {clean_line}</div>')
+           
+           # * 로 시작하는 대표이미지 설명
+           elif line.startswith('*'):
+               clean_line = re.sub(r'^\*\s*', '', line)
+               formatted_lines.append(f'<div style="font-family: \'Malgun Gothic\', sans-serif; font-size: 16px; margin: 8px 0 8px 40px; color: #e67e22; line-height: 1.5;">📸 {clean_line}</div>')
+           
+           # 들여쓰기된 설명
+           elif line.startswith('  ') or line.startswith('\t'):
+               clean_line = line.lstrip()
+               formatted_lines.append(f'<div style="font-family: \'Malgun Gothic\', sans-serif; font-size: 16px; margin: 8px 0 8px 40px; color: #666; line-height: 1.5;">∘ {clean_line}</div>')
+           
+           # 일반 텍스트
+           else:
+               formatted_lines.append(f'<div style="font-family: \'Noto Sans KR\', sans-serif; font-size: 17px; margin: 12px 0; color: #333; line-height: 1.6;">{line}</div>')
+       
+       return ''.join(formatted_lines)
+
+   def generate_step_html(self, step_title: str, content: str, step_number: int) -> str:
+       """개별 단계 HTML 생성"""
+       sections = self.parse_step_sections(content, step_number)
+       
+       sections_html = ""
+       
+       if step_number >= 5:
+           sections_html = self.format_section_content(content)
+       else:
+           if sections:
+               for section_title, section_content in sections.items():
+                   sections_html += f"""
+                   <div style="margin-bottom: 25px; border: 1px solid #e0e0e0; border-radius: 8px; overflow: hidden; box-shadow: 0 2px 4px rgba(0,0,0,0.05);">
+                       <div style="background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); padding: 15px; border-bottom: 1px solid #e0e0e0;">
+                           <div style="margin: 0; font-family: 'Malgun Gothic', sans-serif; font-size: 18px; font-weight: 600; color: #495057;">🔖 {section_title}</div>
+                       </div>
+                       <div style="padding: 20px; background: #fefefe;">
+                           {self.format_section_content(section_content)}
+                       </div>
+                   </div>
+                   """
+           else:
+               sections_html = self.format_section_content(content)
+       
+       step_emoji_map = {
+           "소싱전략 분석": "📊",
+           "1단계. 상품유형 분석": "🎯",
+           "2단계. 소비자 타겟 설정": "👥",
+           "3단계. 타겟별 차별화된 소싱 전략 제안": "🚀",
+           "4단계. 차별화 예시별 상품 5가지 추천": "💎",
+           "5단계. 신뢰성을 줄 수 있는 요소 5가지": "🛡️",
+           "6단계. 차별화 예시별 USP 5가지": "⭐",
+           "7단계. USP별 상세페이지 헤드 카피": "✍️",
+           "결론": "🎉"
+       }
+       
+       step_emoji = step_emoji_map.get(step_title, "📋")
+       
+       return f"""
+       <div style="margin-bottom: 35px; border: 2px solid #dee2e6; border-radius: 12px; overflow: hidden; box-shadow: 0 4px 8px rgba(0,0,0,0.1);">
+           <div style="background: linear-gradient(135deg, #6c757d 0%, #495057 100%); padding: 20px; border-bottom: 2px solid #dee2e6;">
+               <div style="margin: 0; font-family: 'Malgun Gothic', sans-serif; font-size: 22px; font-weight: 700; color: white;">{step_emoji} {step_title}</div>
+           </div>
+           <div style="padding: 30px; background: white;">
+               {sections_html}
+           </div>
+       </div>
+       """
+
+   def generate_final_html(self, keyword: str, all_steps: Dict[str, str]) -> str:
+       """최종 HTML 리포트 생성"""
+       
+       steps_html = ""
+       step_numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8]
+       
+       for i, (step_title, content) in enumerate(all_steps.items(), 1):
+           step_number = step_numbers[i-1] if i <= len(step_numbers) else i
+           steps_html += self.generate_step_html(step_title, content, step_number)
+       
+       return f"""
+       <div style="max-width: 1000px; margin: 0 auto; padding: 25px; font-family: 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif; background: #f8f9fa;">
+           <div style="text-align: center; padding: 30px; margin-bottom: 35px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 12px; color: white; box-shadow: 0 6px 12px rgba(0,0,0,0.15);">
+               <div style="margin: 0; font-family: 'Malgun Gothic', sans-serif; font-size: 28px; font-weight: 700; color: white;">🛒 {keyword} 키워드 분석 리포트</div>
+               <div style="margin: 15px 0 0 0; font-size: 18px; color: #e9ecef;">소싱전략 + 7단계 간결 분석 결과</div>
+           </div>
+           
+           {steps_html}
+           
+           <div style="text-align: center; padding: 20px; margin-top: 30px; background: #e9ecef; border-radius: 8px; color: #6c757d;">
+               <div style="font-size: 14px;">📝 AI 상품 소싱 분석기 v4.0 - 스페이스바 처리 개선 + 올바른 트렌드 분석 로직</div>
+           </div>
+       </div>
+       """
+
+   def analyze_keyword_complete(self, keyword: str, volume_data: Dict, 
+                               keywords_df: Optional[pd.DataFrame], trend_data_1year=None, trend_data_3year=None) -> Dict[str, str]:
+       """전체 8단계 키워드 분석 실행 (소싱전략 + 7단계 + 개선된 결론)"""
+       
+       logger.info(f"8단계 키워드 분석 시작: '{keyword}'")
+       
+       # 0단계: 개선된 소싱전략 분석
+       sourcing_result = self.analyze_sourcing_strategy(keyword, volume_data, keywords_df, trend_data_1year, trend_data_3year)
+       sourcing_html = self.generate_step_html("소싱전략 분석", sourcing_result, 0)
+       
+       # 1-7단계 분석 결과를 저장할 딕셔너리
+       step_results = {}
+       
+       # 1단계: 상품유형 분석
+       step1_result = self.analyze_step1_product_type(keyword, keywords_df)
+       step_results["1단계"] = step1_result
+       step1_html = self.generate_step_html("1단계. 상품유형 분석", step1_result, 1)
+       
+       # 2단계: 소비자 타겟 설정
+       step2_result = self.analyze_step2_target_customer(keyword, step1_result)
+       step_results["2단계"] = step2_result
+       step2_html = self.generate_step_html("2단계. 소비자 타겟 설정", step2_result, 2)
+       
+       # 3단계: 소싱 전략
+       previous_results = f"{step1_result}\n\n{step2_result}"
+       step3_result = self.analyze_step3_sourcing_strategy(keyword, previous_results)
+       step_results["3단계"] = step3_result
+       step3_html = self.generate_step_html("3단계. 타겟별 차별화된 소싱 전략 제안", step3_result, 3)
+       
+       # 4단계: 상품 추천
+       previous_results += f"\n\n{step3_result}"
+       step4_result = self.analyze_step4_product_recommendation(keyword, previous_results)
+       step_results["4단계"] = step4_result
+       step4_html = self.generate_step_html("4단계. 차별화 예시별 상품 5가지 추천", step4_result, 4)
+       
+       # 5단계: 신뢰성 구축
+       previous_results += f"\n\n{step4_result}"
+       step5_result = self.analyze_step5_trust_building(keyword, previous_results)
+       step_results["5단계"] = step5_result
+       step5_html = self.generate_step_html("5단계. 신뢰성을 줄 수 있는 요소 5가지", step5_result, 5)
+       
+       # 6단계: USP 개발
+       previous_results += f"\n\n{step5_result}"
+       step6_result = self.analyze_step6_usp_development(keyword, previous_results)
+       step_results["6단계"] = step6_result
+       step6_html = self.generate_step_html("6단계. 차별화 예시별 USP 5가지", step6_result, 6)
+       
+       # 7단계: 카피 제작
+       previous_results += f"\n\n{step6_result}"
+       step7_result = self.analyze_step7_copy_creation(keyword, previous_results)
+       step_results["7단계"] = step7_result
+       step7_html = self.generate_step_html("7단계. USP별 상세페이지 헤드 카피", step7_result, 7)
+       
+       # 개선된 결론: 구체적 월별 진입 타이밍 + 1-7단계 종합분석 강화
+       conclusion_result = self.analyze_conclusion_enhanced(keyword, previous_results + f"\n\n{step7_result}", sourcing_result)
+       conclusion_html = self.generate_step_html("결론", conclusion_result, 8)
+       
+       # 전체 HTML 생성 (소싱전략이 맨 위에 위치)
+       all_steps = {
+           "소싱전략 분석": sourcing_result,
+           "1단계. 상품유형 분석": step1_result,
+           "2단계. 소비자 타겟 설정": step2_result,
+           "3단계. 타겟별 차별화된 소싱 전략 제안": step3_result,
+           "4단계. 차별화 예시별 상품 5가지 추천": step4_result,
+           "5단계. 신뢰성을 줄 수 있는 요소 5가지": step5_result,
+           "6단계. 차별화 예시별 USP 5가지": step6_result,
+           "7단계. USP별 상세페이지 헤드 카피": step7_result,
+           "결론": conclusion_result
+       }
+       
+       full_html = self.generate_final_html(keyword, all_steps)
+       
+       # 개별 단계 HTML과 전체 HTML 반환
+       return {
+           "sourcing_html": self.generate_step_html("소싱전략 분석", sourcing_result, 0),
+           "step1_html": step1_html,
+           "step2_html": step2_html,
+           "step3_html": step3_html,
+           "step4_html": step4_html,
+           "step5_html": step5_html,
+           "step6_html": step6_html,
+           "step7_html": step7_html,
+           "conclusion_html": conclusion_html,
+           "full_html": full_html,
+           "results": all_steps
+       }
+
+
+# ===== 메인 분석 함수들 =====
+
+def analyze_keyword_for_sourcing(analysis_keyword, volume_data, trend_data_1year=None, 
+                               trend_data_3year=None, filtered_keywords_df=None, 
+                               target_categories=None, gemini_model=None):
+   """
+   메인 분석 함수 - 소싱전략 + 7단계 간결 분석
+   기존 함수명 유지하여 호환성 확보
+   """
+   
+   if not gemini_model:
+       return generate_error_response("Gemini AI 모델이 초기화되지 않았습니다.")
+   
+   try:
+       logger.info(f"소싱전략 + 7단계 간결 키워드 분석 시작: '{analysis_keyword}'")
+       
+       analyzer = CompactKeywordAnalyzer(gemini_model)
+       result = analyzer.analyze_keyword_complete(analysis_keyword, volume_data, filtered_keywords_df, trend_data_1year, trend_data_3year)
+       
+       logger.info(f"소싱전략 + 7단계 간결 키워드 분석 완료: '{analysis_keyword}'")
+       
+       # 기존 호환성을 위해 full_html 반환
+       return result["full_html"]
+       
+   except Exception as e:
+       logger.error(f"키워드 분석 오류: {e}")
+       return generate_error_response(f"키워드 분석 중 오류가 발생했습니다: {str(e)}")
+
+def analyze_keyword_with_individual_steps(analysis_keyword, volume_data, trend_data_1year=None, 
+                                        trend_data_3year=None, filtered_keywords_df=None, 
+                                        target_categories=None, gemini_model=None):
+   """
+   개별 단계 HTML을 포함한 전체 분석 함수
+   소싱전략 + 각 7단계별 개별 HTML과 전체 HTML을 모두 반환
+   """
+   
+   if not gemini_model:
+       error_html = generate_error_response("Gemini AI 모델이 초기화되지 않았습니다.")
+       return {
+           "sourcing_html": error_html, "step1_html": error_html, "step2_html": error_html, "step3_html": error_html,
+           "step4_html": error_html, "step5_html": error_html, "step6_html": error_html,
+           "step7_html": error_html, "conclusion_html": error_html, "full_html": error_html, 
+           "results": {}
+       }
+   
+   try:
+       logger.info(f"소싱전략 + 7단계 개별 키워드 분석 시작: '{analysis_keyword}'")
+       
+       analyzer = CompactKeywordAnalyzer(gemini_model)
+       result = analyzer.analyze_keyword_complete(analysis_keyword, volume_data, filtered_keywords_df, trend_data_1year, trend_data_3year)
+       
+       logger.info(f"소싱전략 + 7단계 개별 키워드 분석 완료: '{analysis_keyword}'")
+       return result
+       
+   except Exception as e:
+       logger.error(f"키워드 분석 오류: {e}")
+       error_html = generate_error_response(f"키워드 분석 중 오류가 발생했습니다: {str(e)}")
+       return {
+           "sourcing_html": error_html, "step1_html": error_html, "step2_html": error_html, "step3_html": error_html,
+           "step4_html": error_html, "step5_html": error_html, "step6_html": error_html,
+           "step7_html": error_html, "conclusion_html": error_html, "full_html": error_html, 
+           "results": {}
+       }
+
+def generate_error_response(error_message):
+   """에러 메시지를 현실적 스타일로 생성"""
+   return f'''
+   <div style="color: #721c24; padding: 30px; text-align: center; width: 100%; 
+               background-color: #f8d7da; border-radius: 12px; border: 1px solid #f5c6cb; font-family: 'Pretendard', sans-serif;">
+       <h3 style="margin-bottom: 15px; color: #721c24;">❌ 분석 실패</h3>
+       <p style="margin-bottom: 20px; font-size: 16px;">{error_message}</p>
+       
+       <div style="background: white; padding: 20px; border-radius: 8px; color: #333; text-align: left;">
+           <h4 style="color: #721c24; margin-bottom: 15px;">🔧 해결 방법</h4>
+           <ul style="padding-left: 20px; line-height: 1.8;">
+               <li>🔍 키워드 확인: 올바른 한글 키워드인지 확인</li>
+               <li>📊 검색량 확인: 너무 생소한 키워드는 데이터가 없을 수 있음</li>
+               <li>🌐 네트워크 상태: 인터넷 연결 상태 확인</li>
+               <li>🔧 API 상태: 네이버 API 서버 상태 확인</li>
+               <li>🔄 재시도: 잠시 후 다시 시도해보세요</li>
+           </ul>
+       </div>
+       
+       <div style="margin-top: 15px; padding: 10px; background: #d1ecf1; border-radius: 6px; color: #0c5460; font-size: 14px;">
+           💡 팁: 2단계에서 추출된 키워드 목록을 참고하여 검증된 키워드를 사용해보세요.
+       </div>
+   </div>
+   '''

keyword_analysis_report.css

@@ -0,0 +1,422 @@
+/* 키워드 분석 보고서 전용 CSS - 다크모드 적용 */
+
+/* CSS 변수 정의 (라이트모드) */
+:root {
+    --primary-color: #FB7F0D;
+    --text-color: #333;
+    --bg-color: #f8f9fa;
+    --card-bg: #ffffff;
+    --border-color: #ecf0f1;
+    --section-bg: #ffffff;
+    --insight-bg: #fff5e6;
+    --warning-bg: #fff3cd;
+    --warning-text: #856404;
+    --checklist-bg: #fff3cd;
+    --cross-sell-bg: #f8f9fa;
+    --cross-sell-border: #17a2b8;
+    --cross-sell-text: #0c5460;
+    --product-bg: white;
+    --trend-bg: #e3f2fd;
+    --trend-border: #2196f3;
+    --metric-bg: #f8f9fa;
+    --metric-border: #dee2e6;
+    --highlight-bg: #fff3cd;
+}
+
+/* 다크모드 색상 변수 (자동 감지) */
+@media (prefers-color-scheme: dark) {
+    :root {
+        --text-color: #e5e5e5;
+        --bg-color: #1a1a1a;
+        --card-bg: #2d2d2d;
+        --border-color: #404040;
+        --section-bg: #2d2d2d;
+        --insight-bg: #3d2817;
+        --warning-bg: #3d3317;
+        --warning-text: #d4b75f;
+        --checklist-bg: #3d3317;
+        --cross-sell-bg: #1a1a1a;
+        --cross-sell-border: #17a2b8;
+        --cross-sell-text: #4dd0e1;
+        --product-bg: #2d2d2d;
+        --trend-bg: #1a2332;
+        --trend-border: #2196f3;
+        --metric-bg: #2d2d2d;
+        --metric-border: #404040;
+        --highlight-bg: #3d3317;
+    }
+}
+
+/* 수동 다크모드 클래스 */
+[data-theme="dark"],
+.dark,
+.gr-theme-dark {
+    --text-color: #e5e5e5;
+    --bg-color: #1a1a1a;
+    --card-bg: #2d2d2d;
+    --border-color: #404040;
+    --section-bg: #2d2d2d;
+    --insight-bg: #3d2817;
+    --warning-bg: #3d3317;
+    --warning-text: #d4b75f;
+    --checklist-bg: #3d3317;
+    --cross-sell-bg: #1a1a1a;
+    --cross-sell-border: #17a2b8;
+    --cross-sell-text: #4dd0e1;
+    --product-bg: #2d2d2d;
+    --trend-bg: #1a2332;
+    --trend-border: #2196f3;
+    --metric-bg: #2d2d2d;
+    --metric-border: #404040;
+    --highlight-bg: #3d3317;
+}
+
+.keyword-analysis-report {
+    font-family: 'Pretendard', 'Noto Sans KR', sans-serif;
+    line-height: 1.6;
+    color: var(--text-color);
+    margin: 0;
+    padding: 0;
+    background-color: var(--bg-color);
+    transition: background-color 0.3s ease, color 0.3s ease;
+}
+
+.report-container {
+    max-width: 900px;
+    margin: 20px auto;
+    padding: 0;
+    background: transparent;
+}
+
+.report-title {
+    text-align: center;
+    font-size: 2.2em;
+    margin-bottom: 30px;
+    color: var(--text-color);
+    font-weight: 700;
+    border-bottom: 3px solid var(--primary-color);
+    padding-bottom: 15px;
+}
+
+/* 각 분석 항목별 섹션 블록 */
+.analysis-section-block {
+    background-color: var(--section-bg);
+    padding: 25px 30px;
+    margin-bottom: 25px;
+    border-radius: 12px;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.08);
+    border-left: 5px solid var(--primary-color);
+    color: var(--text-color);
+    transition: background-color 0.3s ease, color 0.3s ease;
+}
+
+.analysis-section-block:nth-child(1) { border-left-color: #3498db; }
+.analysis-section-block:nth-child(2) { border-left-color: #e74c3c; }
+.analysis-section-block:nth-child(3) { border-left-color: #f39c12; }
+.analysis-section-block:nth-child(4) { border-left-color: #9b59b6; }
+.analysis-section-block:nth-child(5) { border-left-color: #1abc9c; }
+.analysis-section-block:nth-child(6) { border-left-color: #34495e; }
+.analysis-section-block:nth-child(7) { border-left-color: #e67e22; }
+
+.analysis-section-title {
+    margin: 0 0 20px 0;
+    color: var(--text-color);
+    font-size: 1.6em;
+    font-weight: 700;
+    display: flex;
+    align-items: center;
+    border-bottom: 2px solid var(--border-color);
+    padding-bottom: 10px;
+}
+
+.section-icon {
+    font-size: 1.3em;
+    margin-right: 12px;
+    vertical-align: middle;
+}
+
+/* 아이콘 색상 */
+.analysis-section-block:nth-child(1) .section-icon { color: #3498db; }
+.analysis-section-block:nth-child(2) .section-icon { color: #e74c3c; }
+.analysis-section-block:nth-child(3) .section-icon { color: #f39c12; }
+.analysis-section-block:nth-child(4) .section-icon { color: #9b59b6; }
+.analysis-section-block:nth-child(5) .section-icon { color: var(--primary-color); }
+.analysis-section-block:nth-child(6) .section-icon { color: #34495e; }
+.analysis-section-block:nth-child(7) .section-icon { color: #e67e22; }
+
+.subsection-title {
+    color: var(--text-color);
+    margin: 20px 0 10px 0;
+    font-size: 1.1em;
+    font-weight: 600;
+}
+
+.key-insight {
+    background-color: var(--insight-bg);
+    padding: 15px 20px;
+    border-left: 5px solid var(--primary-color);
+    margin: 20px 0;
+    border-radius: 5px;
+    font-weight: 500;
+    color: var(--text-color);
+    transition: background-color 0.3s ease;
+}
+
+/* 텍스트 스타일 - 기본은 일반, 중요한 부분만 볼드 */
+.analysis-content {
+    color: var(--text-color);
+    font-weight: normal;
+    line-height: 1.7;
+}
+
+.analysis-content strong {
+    color: var(--text-color);
+    font-weight: 600;
+}
+
+.analysis-content p {
+    margin-bottom: 15px;
+    font-weight: normal;
+    color: var(--text-color);
+}
+
+.analysis-list {
+    list-style: none;
+    padding: 0;
+    margin-bottom: 20px;
+}
+
+.analysis-list li {
+    position: relative;
+    padding-left: 25px;
+    margin-bottom: 12px;
+    line-height: 1.8;
+    font-weight: normal;
+    color: var(--text-color);
+}
+
+.analysis-list li:before {
+    content: '▶';
+    color: var(--primary-color);
+    position: absolute;
+    left: 0;
+    font-weight: bold;
+    font-size: 1.1em;
+}
+
+.concern-list {
+    list-style: none;
+    padding: 0;
+    margin-bottom: 20px;
+}
+
+.concern-list li {
+    position: relative;
+    padding-left: 25px;
+    margin-bottom: 12px;
+    line-height: 1.8;
+    font-weight: normal;
+    color: var(--text-color);
+}
+
+.concern-list li:before {
+    content: '⚠️';
+    position: absolute;
+    left: 0;
+    font-size: 1.1em;
+}
+
+.solution-list {
+    list-style: none;
+    padding: 0;
+    margin-bottom: 20px;
+}
+
+.solution-list li {
+    position: relative;
+    padding-left: 25px;
+    margin-bottom: 12px;
+    line-height: 1.8;
+    font-weight: normal;
+    color: var(--text-color);
+}
+
+.solution-list li:before {
+    content: '✅';
+    position: absolute;
+    left: 0;
+    font-size: 1.1em;
+}
+
+.checklist {
+    background-color: var(--checklist-bg);
+    padding: 20px;
+    border-radius: 8px;
+    border-left: 5px solid #ffc107;
+    margin: 20px 0;
+    transition: background-color 0.3s ease;
+}
+
+.checklist-title {
+    font-weight: 700;
+    color: var(--warning-text);
+    margin-bottom: 15px;
+    font-size: 1.2em;
+}
+
+.checklist-items {
+    list-style: none;
+    padding: 0;
+}
+
+.checklist-items li {
+    position: relative;
+    padding-left: 25px;
+    margin-bottom: 10px;
+    line-height: 1.6;
+    font-weight: normal;
+    color: var(--warning-text);
+}
+
+.checklist-items li:before {
+    content: '📋';
+    position: absolute;
+    left: 0;
+    font-size: 1.1em;
+}
+
+.cross-sell-section {
+    background-color: var(--cross-sell-bg);
+    padding: 20px;
+    border-radius: 8px;
+    border-left: 5px solid var(--cross-sell-border);
+    margin: 20px 0;
+    transition: background-color 0.3s ease;
+}
+
+.cross-sell-title {
+    font-weight: 700;
+    color: var(--cross-sell-text);
+    margin-bottom: 15px;
+    font-size: 1.2em;
+}
+
+.product-suggestion {
+    background-color: var(--product-bg);
+    padding: 15px;
+    border-radius: 6px;
+    margin-bottom: 15px;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    transition: background-color 0.3s ease;
+}
+
+.product-name {
+    font-weight: 600;
+    color: var(--text-color);
+    margin-bottom: 8px;
+    font-size: 1.1em;
+}
+
+.product-reason {
+    color: var(--text-color);
+    font-size: 0.95em;
+    line-height: 1.5;
+    font-weight: normal;
+    opacity: 0.8;
+}
+
+.final-recommendation {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    border-radius: 12px;
+    color: white;
+    padding: 25px;
+}
+
+.final-recommendation h3 {
+    color: white;
+    font-size: 1.8em;
+    margin-bottom: 20px;
+    font-weight: 700;
+}
+
+.recommendation-content {
+    font-size: 1.1em;
+    line-height: 1.7;
+    text-align: left;
+    font-weight: normal;
+    color: white;
+}
+
+.recommendation-content strong {
+    font-weight: 600;
+    color: white;
+}
+
+.trend-insight {
+    background-color: var(--trend-bg);
+    padding: 15px 20px;
+    border-left: 5px solid var(--trend-border);
+    margin: 20px 0;
+    border-radius: 5px;
+    color: var(--text-color);
+    transition: background-color 0.3s ease;
+}
+
+.market-metrics {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 20px;
+    margin: 20px 0;
+}
+
+.metric-card {
+    background-color: var(--metric-bg);
+    padding: 20px;
+    border-radius: 8px;
+    text-align: center;
+    border: 1px solid var(--metric-border);
+    transition: background-color 0.3s ease, border-color 0.3s ease;
+}
+
+.metric-value {
+    font-size: 2em;
+    font-weight: 700;
+    color: var(--primary-color);
+    margin-bottom: 5px;
+}
+
+.metric-label {
+    color: var(--text-color);
+    font-size: 0.9em;
+    font-weight: normal;
+    opacity: 0.8;
+}
+
+.highlight-text {
+    background-color: var(--highlight-bg);
+    padding: 2px 6px;
+    border-radius: 3px;
+    font-weight: 600;
+    color: var(--warning-text);
+    transition: background-color 0.3s ease, color 0.3s ease;
+}
+
+/* 다크모드에서 그라데이션 배경 조정 */
+@media (prefers-color-scheme: dark) {
+    .final-recommendation {
+        background: linear-gradient(135deg, #4a5568 0%, #553c9a 100%);
+    }
+}
+
+[data-theme="dark"] .final-recommendation,
+.dark .final-recommendation,
+.gr-theme-dark .final-recommendation {
+    background: linear-gradient(135deg, #4a5568 0%, #553c9a 100%);
+}
+
+/* 전환 애니메이션 */
+* {
+    transition: background-color 0.3s ease, 
+                color 0.3s ease, 
+                border-color 0.3s ease;
+}

keyword_diversity_fix.py

@@ -0,0 +1,943 @@
+"""
+       
+       logger.info("Gemini API 호출 시작...")
+       # Gemini API 호출 - 온도를 높여서 더 다양한 결과 생성
+       response = client.models.generate_content(
+           model="gemini-2.0-flash",
+           contents=prompt,
+           config=GenerateContentConfig(
+               tools=config_tools,  # 검색 엔진에 따라 도구 설정
+               response_modalities=["TEXT"],
+               temperature=0.95,  # 온도를 높여서 더 다양한 결과
+               max_output_tokens=2000,
+               top_p=0.9,  # 더 다양한 토큰 선택
+               top_k=40   # 후보 토큰 수 증가
+           )
+       )
+       
+       logger.info("Gemini API 응답 수신 완료")
+       
+       # 응답에서 텍스트 추출
+       result_text = ""
+       for part in response.candidates[0].content.parts:
+           if hasattr(part, 'text'):
+               result_text += part.text
+       
+       # 결과 정제 - 번호, 설명, 기호 제거 및 중복 제거 강화
+       lines = result_text.strip().split('\n')
+       clean_keywords = []
+       seen_keywords = set()  # 중복 방지를 위한 집합
+       
+       for line in lines:
+           # 빈 줄 건너뛰기
+           if not line.strip():
+               continue
+           
+           # 정제 작업
+           clean_line = line.strip()
+           
+           # 번호 제거 (1., 2., 3. 등)
+           import re
+           clean_line = re.sub(r'^\d+\.?\s*', '', clean_line)
+           
+           # 불릿 포인트 제거 (-, *, •, ✅, ❌ 등)
+           clean_line = re.sub(r'^[-*•✅❌]\s*', '', clean_line)
+           
+           # 괄호 안 설명 제거
+           clean_line = re.sub(r'\([^)]*\)', '', clean_line)
+           
+           # 추가 설명 제거 (: 이후 내용)
+           if ':' in clean_line:
+               clean_line = clean_line.split(':')[0]
+           
+           # 공백 정리
+           clean_line = clean_line.strip()
+           
+           # 유효한 키워드만 추가 (2글자 이상, 50글자 이하)
+           if clean_line and 2 <= len(clean_line) <= 50:
+               # 브랜드명이나 제조업체명 필터링
+               brand_keywords = ['삼성', '엘지', 'LG', '애플', '아이폰', '갤럭시', '나이키', '아디다스', '스타벅스']
+               if not any(brand in clean_line for brand in brand_keywords):
+                   # 중복 검사 - 대소문자 구분 없이 체크
+                   clean_lower = clean_line.lower()
+                   if clean_lower not in seen_keywords:
+                       seen_keywords.add(clean_lower)
+                       clean_keywords.append(clean_line)
+       
+       # 50개로 제한하되, 부족하면 추가 생성 요청
+       if len(clean_keywords) < 50:
+           logger.info(f"키워드 부족 ({len(clean_keywords)}개), 추가 생성 필요")
+           
+           # 부족한 만큼 추가 생성을 위한 보조 프롬프트
+           additional_prompt = f"""
+기존에 생성된 키워드: {', '.join(clean_keywords)}
+
+위 키워드들과 절대 중복되지 않는 완전히 새로운 {category} 관련 쇼핑키워드를 {50 - len(clean_keywords)}개 더 생성하세요.
+
+반드시 지켜야 할 규칙:
+- 기존 키워드와 절대 중복되지 않음
+- 소재, 형태, 기능을 다양하게 조합
+- 브랜드명 절대 금지
+- 순수 키워드만 출력 (번호, 설명, 기호 금지)
+
+예시 출력:
+스테인리스 쟁반
+고무 매트
+유리 용기
+"""
+           
+           # 추가 생성 요청
+           additional_response = client.models.generate_content(
+               model="gemini-2.0-flash",
+               contents=additional_prompt,
+               config=GenerateContentConfig(
+                   response_modalities=["TEXT"],
+                   temperature=0.98,  # 더 높은 온도로 다양성 보장
+                   max_output_tokens=1000,
+                   top_p=0.95,
+                   top_k=50
+               )
+           )
+           
+           # 추가 키워드 처리
+           additional_text = ""
+           for part in additional_response.candidates[0].content.parts:
+               if hasattr(part, 'text'):
+                   additional_text += part.text
+           
+           additional_lines = additional_text.strip().split('\n')
+           for line in additional_lines:
+               if not line.strip():
+                   continue
+               
+               clean_line = line.strip()
+               clean_line = re.sub(r'^\d+\.?\s*', '', clean_line)
+               clean_line = re.sub(r'^[-*•✅❌]\s*', '', clean_line)
+               clean_line = re.sub(r'\([^)]*\)', '', clean_line)
+               
+               if ':' in clean_line:
+                   clean_line = clean_line.split(':')[0]
+               
+               clean_line = clean_line.strip()
+               
+               if clean_line and 2 <= len(clean_line) <= 50:
+                   brand_keywords = ['삼성', '엘지', 'LG', '애플', '아이폰', '갤럭시', '나이키', '아디다스', '스타벅스']
+                   if not any(brand in clean_line for brand in brand_keywords):
+                       clean_lower = clean_line.lower()
+                       if clean_lower not in seen_keywords and len(clean_keywords) < 50:
+                           seen_keywords.add(clean_lower)
+                           clean_keywords.append(clean_line)
+       
+       # 50개로 제한
+       clean_keywords = clean_keywords[:50]
+       
+       # 최종 셔플로 순서도 무작위화
+       random.shuffle(clean_keywords)
+       
+       # 최종 결과 문자열 생성
+       final_result = '\n'.join(clean_keywords)
+       
+       logger.info(f"최종 정제된 키워드 개수: {len(clean_keywords)}개")
+       logger.info(f"중복 제거된 키워드 수: {len(seen_keywords)}개")
+       logger.info("=== 다양성 강화 쇼핑키워드 생성 완료 ===")
+       
+       # 그라운딩 메타데이터 로그
+       if hasattr(response.candidates[0], 'grounding_metadata'):
+           logger.info("Google 검색 그라운딩 메타데이터 확인됨")
+           if hasattr(response.candidates[0].grounding_metadata, 'web_search_queries'):
+               queries = response.candidates[0].grounding_metadata.web_search_queries
+               logger.info(f"실행된 검색 쿼리: {queries}")
+       
+       return final_result
+       
+   except Exception as e:
+       error_msg = f"오류 발생: {str(e)}"
+       logger.error(error_msg)
+       logger.error("GEMINI_API_KEY 환경변수가 올바르게 설정되었는지 확인해주세요.")
+       return f"{error_msg}\n\nGEMINI_API_KEY 환경변수가 올바르게 설정되었는지 확인해주세요."
+
+def generate_with_logs(category, additional_request, launch_timing, seasonality, sales_target, sales_channel, competition_level, search_engine):
+   """키워드 생성과 로그를 함께 반환하는 함수"""
+   logger.info("=== 다양성 강화 쇼핑키워드 생성 시작 ===")
+   
+   # 키워드 생성
+   result = generate_sourcing_keywords(category, additional_request, launch_timing, seasonality, sales_target, sales_channel, competition_level, search_engine)
+   
+   # 최근 로그 가져오기
+   logs = get_recent_logs()
+   
+   return result, logs
+
+# Gradio 인터페이스 구성
+def create_interface():
+   with gr.Blocks(
+       title="🎯 다양성 강화 쇼핑키워드 시스템",
+       theme=gr.themes.Soft(),
+       css="""
+       .gradio-container {
+           max-width: 1200px !important;
+       }
+       .title-header {
+           text-align: center;
+           background: linear-gradient(45deg, #FF6B6B, #4ECDC4, #45B7D1);
+           -webkit-background-clip: text;
+           -webkit-text-fill-color: transparent;
+           font-size: 2.5em;
+           font-weight: bold;
+           margin-bottom: 20px;
+       }
+       .subtitle {
+           text-align: center;
+           color: #666;
+           font-size: 1.2em;
+           margin-bottom: 30px;
+       }
+       """
+   ) as demo:
+       
+       # 헤더
+       gr.HTML("""
+       <div class="title-header">🎯 다양성 강화 쇼핑키워드 시스템</div>
+       <div class="subtitle">🔄 매번 완전히 다른 결과! 중복 없는 쇼핑키워드 전문 발굴 프로그램</div>
+       """)
+       
+       with gr.Row():
+           with gr.Column(scale=1):
+               gr.Markdown("### 📊 다양성 강화 설정")
+               
+               # 검색 엔진 선택 추가
+               search_engine = gr.Dropdown(
+                   choices=[
+                       "모든 검색 엔진 통합 분석 (추천)",
+                       "Google 검색 그라운딩만",
+                       "네이버 검색 API만",
+                       "DuckDuckGo 검색만",
+                       "검색 없이 AI만 사용"
+                   ],
+                   label="🔍 검색 엔진 선택",
+                   value="모든 검색 엔진 통합 분석 (추천)"
+               )
+               
+               # 1. 쇼핑 카테고리 선택
+               category = gr.Dropdown(
+                   choices=["랜덤적용", "패션잡화", "생활/건강", "출산/육아", "스포츠/레저", "디지털/가전", "가구/인테리어", "패션의류", "화장품/미용"],
+                   label="🛍️ 쇼핑 카테고리",
+                   value="생활/건강"
+               )
+               
+               # 2. 추가 요청사항
+               additional_request = gr.Textbox(
+                   label="📝 추가 요청사항 (다양성 중심)",
+                   placeholder="예: 다양한 소재, 새로운 형태, 독특한 기능 등",
+                   lines=2
+               )
+               
+               # 3. 출시 타이밍
+               launch_timing = gr.Radio(
+                   choices=["랜덤적용", "즉시소싱", "기획형"],
+                   label="⏰ 출�� 타이밍",
+                   value="즉시소싱"
+               )
+               
+               # 4. 계절성
+               seasonality = gr.Radio(
+                   choices=["랜덤적용", "봄", "여름", "가을", "겨울", "비계절"],
+                   label="🌱 계절성",
+                   value="비계절"
+               )
+               
+           with gr.Column(scale=1):
+               gr.Markdown("### 💰 목표 설정")
+               
+               # 5. 매출 목표
+               sales_target = gr.Radio(
+                   choices=["랜덤적용", "100만원 이하", "100-500만원", "500-1천만원", "1천-5천만원", "5천만원 이상"],
+                   label="💵 매출 목표",
+                   value="100-500만원"
+               )
+               
+               # 6. 판매 채널
+               sales_channel = gr.Radio(
+                   choices=["랜덤적용", "오픈마켓", "SNS마케팅", "광고집행", "오프라인"],
+                   label="📱 판매 채널", 
+                   value="오픈마켓"
+               )
+               
+               # 7. 경쟁 강도
+               competition_level = gr.Radio(
+                   choices=[
+                       "랜덤적용",
+                       "초보",
+                       "중수", 
+                       "고수"
+                   ],
+                   label="⚔️ 경쟁 강도",
+                   value="초보"
+               )
+       
+       # 실행 버튼
+       generate_btn = gr.Button(
+           "🚀 다양성 강화 쇼핑키워드 발굴 시작 (매번 다른 결과)",
+           variant="primary",
+           size="lg"
+       )
+       
+       # 결과 출력
+       with gr.Row():
+           with gr.Column(scale=2):
+               gr.Markdown("### 📋 다양성 강화 쇼핑키워드 (50개)")
+               output = gr.Textbox(
+                   label="중복 없는 쇼핑키워드 결과 (매번 완전히 다름)",
+                   lines=30,
+                   max_lines=50,
+                   placeholder="여기에 매번 다른 50개의 쇼핑키워드가 출력됩니다...",
+                   show_copy_button=True
+               )
+           
+           with gr.Column(scale=1):
+               gr.Markdown("### 📊 실행 로그")
+               log_output = gr.Textbox(
+                   label="시스템 로그",
+                   lines=30,
+                   max_lines=50,
+                   placeholder="시스템 실행 로그가 여기에 표시됩니다...",
+                   show_copy_button=True
+               )
+       
+       # 이벤트 연결
+       generate_btn.click(
+           fn=generate_with_logs,
+           inputs=[
+               category,
+               additional_request,
+               launch_timing,
+               seasonality,
+               sales_target,
+               sales_channel,
+               competition_level,
+               search_engine
+           ],
+           outputs=[output, log_output],
+           show_progress=True
+       )
+       
+       # 사용법 안내
+       with gr.Accordion("📖 다양성 강화 사용법 안내", open=False):
+           gr.Markdown("""
+           ### 🎯 다양성 강화 쇼핑키워드 시스템 사용법
+           
+           #### 🚀 주요 개선 사항
+           - **완전한 중복 방지**: 매번 실행할 때마다 완전히 다른 키워드 생성
+           - **랜덤 시드 시스템**: 현재 시각을 기반으로 한 랜덤 시드로 예측 불가능
+           - **다양한 조합 보장**: 소재×형태×기능의 3차원 조합으로 무한 다양성
+           - **중복 검사 강화**: 대소문자 구분 없는 엄격한 중복 제거
+           - **온도 조절**: AI 생성 파라미터 최적화로 창의성 극대화
+           
+           #### 🔄 다양성 보장 메커니즘
+           1. **시드 기반 랜덤화**: 마이크로초 단위 시간 기반 랜덤 시드
+           2. **3차원 조합 시스템**:
+              - 소재: 실리콘, 스테인리스, 세라믹, 대나무 등 20종
+              - 형태: 접이식, 원형, 슬림, 휴대용 등 20종  
+              - 기능: 방수, 항균, 마그네틱, 보온 등 20종
+           3. **중복 방지 알고리즘**: 생성 중 실시간 중복 검사
+           4. **추가 생성 시스템**: 부족시 자동으로 추가 키워드 생성
+           
+           #### 🎲 랜덤 적용의 진화
+           - **키워드별 독립 적용**: 각 키워드마다 다른 조건 조합
+           - **예측 불가능성**: 같은 설정이라도 매번 다른 결과
+           - **조합 폭발**: 수천 가지 가능한 조합으로 무한 다양성
+           
+           #### 📈 생성 품import gradio as gr
+import os
+import logging
+import sys
+import random
+import requests
+import json
+from datetime import datetime
+from google import genai
+from google.genai.types import Tool, GenerateContentConfig, GoogleSearch
+
+# 로깅 설정
+logging.basicConfig(
+   level=logging.INFO,
+   format='%(asctime)s - %(levelname)s - %(message)s',
+   handlers=[
+       logging.StreamHandler(sys.stdout),
+       logging.FileHandler('sourcing_app.log', encoding='utf-8')
+   ]
+)
+logger = logging.getLogger(__name__)
+
+# 키워드 다양성을 위한 시드 풀 확장
+DIVERSE_SEED_POOLS = {
+    "패션잡화": [
+        "액세서리", "장신구", "가방", "지갑", "모자", "스카프", "벨트", "선글라스", "헤어액세서리", "시계줄",
+        "키링", "브로치", "목걸이", "팔찌", "반지", "귀걸이", "핸드폰케이스", "파우치", "클러치", "토트백"
+    ],
+    "생활/건강": [
+        "주방용품", "욕실용품", "청소용품", "수납용품", "건강용품", "의료용품", "마사지용품", "운동용품",
+        "다이어트용품", "화장지", "세제", "샴푸", "치약", "비누", "수건", "베개", "이불", "쿠션", "매트"
+    ],
+    "출산/육아": [
+        "유아용품", "육아용품", "출산용품", "임산부용품", "신생아용품", "이유식용품", "기저귀", "젖병",
+        "유모차", "카시트", "아기옷", "장난감", "교육용품", "책", "그림책", "퍼즐", "블록", "인형", "놀이매트"
+    ],
+    "스포츠/레저": [
+        "운동용품", "헬스용품", "요가용품", "수영용품", "등산용품", "캠핑용품", "낚시용품", "골프용품",
+        "축구용품", "농구용품", "배드민턴용품", "탁구용품", "테니스용품", "자전거용품", "스케이트보드용품"
+    ],
+    "디지털/가전": [
+        "스마트폰액세서리", "컴퓨터용품", "태블릿용품", "이어폰", "스피커", "충전기", "케이블", "마우스패드",
+        "키보드", "마우스", "웹캠", "마이크", "헤드셋", "게임패드", "USB", "메모리카드", "파워뱅크"
+    ],
+    "가구/인테리어": [
+        "수납가구", "침실가구", "거실가구", "주방가구", "욕실가구", "사무용가구", "인테리어소품", "조명",
+        "커튼", "블라인드", "카펫", "러그", "액자", "거울", "시계", "화분", "꽃병", "캔들", "방향제"
+    ],
+    "패션의류": [
+        "티셔츠", "셔츠", "블라우스", "원피스", "스커트", "바지", "청바지", "레깅스", "자켓", "코트",
+        "점퍼", "가디건", "니트", "후드", "조끼", "속옷", "잠옷", "양말", "스타킹", "운동복"
+    ],
+    "화장품/미용": [
+        "스킨케어", "메이크업", "클렌징", "마스크팩", "선크림", "로션", "에센스", "크림", "립밤",
+        "립스틱", "아이섀도", "마스카라", "파운데이션", "컨실러", "블러셔", "하이라이터", "네일", "향수"
+    ]
+}
+
+# 소재별 키워드 풀
+MATERIAL_KEYWORDS = [
+    "실리콘", "스테인리스", "세라믹", "유리", "나무", "대나무", "면", "린넨", "폴리에스터", "나일론",
+    "고무", "플라스틱", "종이", "가죽", "인조가죽", "메탈", "알루미늄", "철", "구리", "황동"
+]
+
+# 형태별 키워드 풀  
+SHAPE_KEYWORDS = [
+    "접이식", "휴대용", "미니", "대형", "원형", "사각", "타원", "직사각", "삼각", "육각",
+    "슬림", "두꺼운", "얇은", "긴", "짧은", "넓은", "좁은", "깊은", "얕은", "곡선"
+]
+
+# 기능별 키워드 풀
+FUNCTION_KEYWORDS = [
+    "방수", "미끄럼방지", "항균", "냄새제거", "보온", "보냉", "속건", "흡수", "차단", "보호",
+    "마그네틱", "자석", "끈적", "투명", "불투명", "발광", "반사", "신축", "탄력", "고정"
+]
+
+# Gemini API 클라이언트 초기화
+def initialize_gemini():
+   logger.info("Gemini API 클라이언트 초기화 시작")
+   api_key = os.getenv("GEMINI_API_KEY")
+   if not api_key:
+       logger.error("GEMINI_API_KEY 환경변수가 설정되지 않았습니다.")
+       raise ValueError("GEMINI_API_KEY 환경변수가 설정되지 않았습니다.")
+   
+   client = genai.Client(api_key=api_key)
+   logger.info("Gemini API 클라이언트 초기화 완료")
+   return client
+
+def get_recent_logs():
+   """최근 로그를 가져오는 함수"""
+   try:
+       with open('sourcing_app.log', 'r', encoding='utf-8') as f:
+           lines = f.readlines()
+           # 최근 50줄만 반환
+           return ''.join(lines[-50:])
+   except FileNotFoundError:
+       return "로그 파일을 찾을 수 없습니다."
+   except Exception as e:
+       return f"로그 읽기 오류: {str(e)}"
+
+def generate_diverse_keyword_combinations(category, count=60):
+    """다양한 키워드 조합을 생성하는 함수"""
+    logger.info(f"다양한 키워드 조합 생성 시작: {category}, {count}개")
+    
+    combinations = []
+    category_pool = DIVERSE_SEED_POOLS.get(category, DIVERSE_SEED_POOLS["생활/건강"])
+    
+    # 1. 단일 키워드 (20%)
+    single_keywords = random.sample(category_pool, min(12, len(category_pool)))
+    combinations.extend(single_keywords)
+    
+    # 2. 소재 + 카테��리 (30%)
+    for _ in range(18):
+        material = random.choice(MATERIAL_KEYWORDS)
+        item = random.choice(category_pool)
+        combinations.append(f"{material} {item}")
+    
+    # 3. 형태 + 카테고리 (30%)  
+    for _ in range(18):
+        shape = random.choice(SHAPE_KEYWORDS)
+        item = random.choice(category_pool)
+        combinations.append(f"{shape} {item}")
+    
+    # 4. 기능 + 카테고리 (20%)
+    for _ in range(12):
+        function = random.choice(FUNCTION_KEYWORDS)
+        item = random.choice(category_pool)
+        combinations.append(f"{function} {item}")
+    
+    # 중복 제거 및 셔플
+    combinations = list(set(combinations))
+    random.shuffle(combinations)
+    
+    logger.info(f"생성된 조합 수: {len(combinations)}개")
+    return combinations[:count]
+
+def search_all_engines(query):
+   """모든 검색 엔진을 사용하여 데이터를 취합하는 함수"""
+   logger.info(f"모든 검색 엔진으로 검색 시작: {query}")
+   
+   all_results = {
+       "google": "",
+       "naver": "",
+       "duckduckgo": ""
+   }
+   
+   # 1. 네이버 검색 API
+   try:
+       naver_client_id = os.getenv("NAVER_CLIENT_ID")
+       naver_client_secret = os.getenv("NAVER_CLIENT_SECRET")
+       
+       if naver_client_id and naver_client_secret:
+           url = "https://openapi.naver.com/v1/search/shop.json"
+           headers = {
+               "X-Naver-Client-Id": naver_client_id,
+               "X-Naver-Client-Secret": naver_client_secret
+           }
+           params = {"query": query, "display": 10}
+           
+           response = requests.get(url, headers=headers, params=params, timeout=10)
+           if response.status_code == 200:
+               data = response.json()
+               naver_data = []
+               for item in data.get('items', [])[:5]:
+                   naver_data.append(f"상품: {item.get('title', '').replace('<b>', '').replace('</b>', '')}")
+                   naver_data.append(f"가격: {item.get('lprice', '')}원")
+                   naver_data.append(f"카테고리: {item.get('category1', '')}")
+               all_results["naver"] = "\n".join(naver_data)
+               logger.info("네이버 검색 완료")
+           else:
+               all_results["naver"] = "네이버 API 검색 실패"
+       else:
+           all_results["naver"] = "네이버 API 키가 설정되지 않음"
+   except Exception as e:
+       all_results["naver"] = f"네이버 검색 오류: {str(e)}"
+   
+   # 2. DuckDuckGo 검색
+   try:
+       url = "https://api.duckduckgo.com/"
+       params = {
+           "q": query,
+           "format": "json",
+           "no_html": "1",
+           "skip_disambig": "1"
+       }
+       
+       response = requests.get(url, params=params, timeout=10)
+       if response.status_code == 200:
+           data = response.json()
+           
+           ddg_data = []
+           # Abstract 정보
+           if data.get('Abstract'):
+               ddg_data.append(f"요약: {data['Abstract']}")
+           
+           # Related Topics
+           for topic in data.get('RelatedTopics', [])[:3]:
+               if isinstance(topic, dict) and topic.get('Text'):
+                   ddg_data.append(f"관련정보: {topic['Text']}")
+           
+           all_results["duckduckgo"] = "\n".join(ddg_data) if ddg_data else "DuckDuckGo에서 관련 정보 없음"
+           logger.info("DuckDuckGo 검색 완료")
+       else:
+           all_results["duckduckgo"] = "DuckDuckGo 검색 실패"
+   except Exception as e:
+       all_results["duckduckgo"] = f"DuckDuckGo 검색 오류: {str(e)}"
+   
+   # 3. Google 검색은 Gemini에서 자동 처리됨
+   all_results["google"] = "Google 검색 그라운딩 자동 실행"
+   
+   logger.info("모든 검색 엔진 데이터 수집 완료")
+   return all_results
+
+def comprehensive_market_analysis(category, seasonality, sales_target):
+    """다양성 강화된 시장 분석"""
+    logger.info("다양성 강화 시장 분석 시작")
+    
+    # 랜덤 시드를 현재 시간으로 설정하여 매번 다른 결과 보장
+    random.seed(datetime.now().microsecond)
+    
+    # 다양한 검색 각도로 쿼리 생성
+    search_angles = [
+        "틈새상품", "신상품", "인기상품", "저가상품", "고급상품", "할인상품",
+        "간편상품", "실용상품", "트렌드상품", "숨은상품", "베스트상품", "추천상품"
+    ]
+    
+    search_queries = []
+    
+    # 카테고리별 다양한 검색어 생성
+    category_pool = DIVERSE_SEED_POOLS.get(category, DIVERSE_SEED_POOLS["생활/건강"])
+    
+    for angle in search_angles:
+        for item in random.sample(category_pool, 3):  # 각 카테고리에서 3개씩만 선택
+            search_queries.append(f"{item} {angle}")
+    
+    # 소재별 검색어 추가
+    for material in random.sample(MATERIAL_KEYWORDS, 5):
+        search_queries.append(f"{material} {category} 상품")
+    
+    # 형태별 검색어 추가  
+    for shape in random.sample(SHAPE_KEYWORDS, 5):
+        search_queries.append(f"{shape} {category} 아이템")
+    
+    # 검색어 셔플하여 예측 불가능하게 만들기
+    random.shuffle(search_queries)
+    search_queries = search_queries[:15]  # 15개로 제한
+    
+    comprehensive_data = {}
+    
+    for i, query in enumerate(search_queries):
+        logger.info(f"다양성 검색 {i+1}/15: {query}")
+        comprehensive_data[f"query_{i+1}"] = search_all_engines(query)
+        
+        # API 과부하 방지를 위한 딜레이
+        import time
+        time.sleep(0.5)
+    
+    # 다양성 강화 데이터 요약
+    summary = "=== 다양성 강화 시장 분석 결과 ===\n\n"
+    
+    # 무작위로 결과를 섞어서 패턴 방지
+    result_keys = list(comprehensive_data.keys())
+    random.shuffle(result_keys)
+    
+    summary += "🔍 다양한 시장 검색 결과:\n"
+    for key in result_keys[:10]:
+        results = comprehensive_data.get(key, {})
+        if results.get("naver"):
+            summary += f"• {results['naver'][:60]}...\n"
+    summary += "\n"
+    
+    logger.info("다양성 강화 분석 완료")
+    return summary
+
+def search_with_api(query, search_engine="Google 검색 그라운딩만"):
+   """개별 검색 엔진으로 검색하는 함수 (단일 엔진 선택시 사용)"""
+   logger.info(f"검색 엔진: {search_engine}, 쿼리: {query}")
+   
+   search_results = ""
+   
+   try:
+       if search_engine == "네이버 검색 API만":
+           # 네이버 검색 API 사용
+           naver_client_id = os.getenv("NAVER_CLIENT_ID")
+           naver_client_secret = os.getenv("NAVER_CLIENT_SECRET")
+           
+           if naver_client_id and naver_client_secret:
+               url = "https://openapi.naver.com/v1/search/shop.json"
+               headers = {
+                   "X-Naver-Client-Id": naver_client_id,
+                   "X-Naver-Client-Secret": naver_client_secret
+               }
+               params = {"query": query, "display": 10}
+               
+               response = requests.get(url, headers=headers, params=params)
+               if response.status_code == 200:
+                   data = response.json()
+                   for item in data.get('items', [])[:5]:
+                       search_results += f"상품명: {item.get('title', '')}\n"
+                       search_results += f"가격: {item.get('lprice', '')}원\n"
+                       search_results += f"카테고리: {item.get('category1', '')}\n\n"
+               else:
+                   search_results = "네이버 API 검색 실패"
+           else:
+               search_results = "네이버 API 키가 설정되지 않음"
+               
+       elif search_engine == "DuckDuckGo 검색만":
+           # DuckDuckGo 검색 (무료, API 키 불필요)
+           try:
+               url = "https://api.duckduckgo.com/"
+               params = {
+                   "q": query,
+                   "format": "json",
+                   "no_html": "1",
+                   "skip_disambig": "1"
+               }
+               
+               response = requests.get(url, params=params, timeout=10)
+               if response.status_code == 200:
+                   data = response.json()
+                   
+                   # Abstract 정보
+                   if data.get('Abstract'):
+                       search_results += f"요약: {data['Abstract']}\n\n"
+                   
+                   # Related Topics
+                   for topic in data.get('RelatedTopics', [])[:5]:
+                       if isinstance(topic, dict) and topic.get('Text'):
+                           search_results += f"관련 정보: {topic['Text']}\n"
+                   
+                   if not search_results:
+                       search_results = "DuckDuckGo에서 관련 정보를 찾지 못함"
+               else:
+                   search_results = "DuckDuckGo 검색 실패"
+           except Exception as e:
+               search_results = f"DuckDuckGo 검색 오류: {str(e)}"
+               
+       elif search_engine == "검색 없이 AI만 사용":
+           search_results = "검색 없이 AI 지식만 사용하여 키워드 생성"
+           
+       else:
+           # Google 검색 그라운딩 (기본)
+           search_results = "Google 검색 그라운딩 사용"
+           
+   except Exception as e:
+       logger.error(f"검색 오류: {str(e)}")
+       search_results = f"검색 오류: {str(e)}"
+   
+   logger.info(f"검색 결과 길이: {len(search_results)} 문자")
+   return search_results
+
+def apply_random_selection_for_keywords(category, launch_timing, seasonality, sales_target, sales_channel, competition_level):
+   """각 키워드마다 랜덤하게 조건을 적용하기 위한 설정 문자열 생성"""
+   
+   # 각 항목별 선택지 정의
+   categories = ["패션잡화", "생활/건강", "출산/육아", "스포츠/레저", "디지털/가전", "가구/인테리어", "패션의류", "화장품/미용"]
+   launch_timings = ["즉시소싱", "기획형"]
+   seasonalities = ["봄", "여름", "가을", "겨울", "비계절"]
+   sales_targets = ["100만원 이하", "100-500만원", "500-1천만원", "1천-5천만원", "5천만원 이상"]
+   sales_channels = ["오픈마켓", "SNS마케팅", "광고집행", "오프라인"]
+   competition_levels = ["초보", "중수", "고수"]
+   
+   # 랜덤적용 설정 정보 생성
+   random_settings = {
+       'category_random': category == "랜덤적용",
+       'launch_timing_random': launch_timing == "랜덤적용", 
+       'seasonality_random': seasonality == "랜덤적용",
+       'sales_target_random': sales_target == "랜덤적용",
+       'sales_channel_random': sales_channel == "랜덤적용",
+       'competition_level_random': competition_level == "랜덤적용",
+       'categories': categories,
+       'launch_timings': launch_timings,
+       'seasonalities': seasonalities,
+       'sales_targets': sales_targets,
+       'sales_channels': sales_channels,
+       'competition_levels': competition_levels
+   }
+   
+   # 고정값들
+   fixed_values = {
+       'category': category if category != "랜덤적용" else None,
+       'launch_timing': launch_timing if launch_timing != "랜덤적용" else None,
+       'seasonality': seasonality if seasonality != "랜덤적용" else None,
+       'sales_target': sales_target if sales_target != "랜덤적용" else None,
+       'sales_channel': sales_channel if sales_channel != "랜덤적용" else None,
+       'competition_level': competition_level if competition_level != "랜덤적용" else None
+   }
+   
+   logger.info("=== 키워드별 랜덤 설정 ===")
+   logger.info(f"카테고리 랜덤: {random_settings['category_random']}")
+   logger.info(f"출시타이밍 랜덤: {random_settings['launch_timing_random']}")
+   logger.info(f"계절성 랜덤: {random_settings['seasonality_random']}")
+   logger.info(f"매출목표 랜덤: {random_settings['sales_target_random']}")
+   logger.info(f"판매채널 랜덤: {random_settings['sales_channel_random']}")
+   logger.info(f"경쟁강도 랜덤: {random_settings['competition_level_random']}")
+   
+   return random_settings, fixed_values
+
+def generate_sourcing_keywords(category, additional_request, launch_timing, seasonality, sales_target, sales_channel, competition_level, search_engine="Google 검색 그라운딩만"):
+   """다양성 강화된 쇼핑 키워드 50개를 생성하는 함수"""
+   logger.info("=== 다양성 강화 쇼핑키워드 생성 시작 ===")
+   logger.info(f"입력 조건 - 검색엔진: {search_engine}")
+   logger.info(f"입력 조건 - 카테고리: {category}")
+   logger.info(f"입력 조건 - 추가요청: {additional_request}")
+   logger.info(f"입력 조건 - 출시타이밍: {launch_timing}")
+   logger.info(f"입력 조건 - 계절성: {seasonality}")
+   logger.info(f"입력 조건 - 매출목표: {sales_target}")
+   logger.info(f"입력 조건 - 판매채널: {sales_channel}")
+   logger.info(f"입력 조건 - 경쟁강도: {competition_level}")
+   
+   try:
+       logger.info("Gemini 클라이언트 초기화 중...")
+       client = initialize_gemini()
+       
+       # 매번 다른 시드로 랜덤성 보장
+       current_time = datetime.now()
+       random_seed = current_time.microsecond + current_time.second * 1000
+       random.seed(random_seed)
+       logger.info(f"랜덤 시드 설정: {random_seed}")
+       
+       # 프롬프트 구성
+       logger.info("다양성 강화 프롬프트 구성 중...")
+       
+       # 랜덤 설정 처리
+       random_settings, fixed_values = apply_random_selection_for_keywords(
+           category, launch_timing, seasonality, sales_target, sales_channel, competition_level
+       )
+       
+       # 다양한 키워드 조합 미리 생성
+       diverse_combinations = generate_diverse_keyword_combinations(category, 60)
+       logger.info(f"다양한 조합 생성 완료: {len(diverse_combinations)}개")
+       
+       # 검색 엔진별 처리
+       search_info = ""
+       config_tools = []
+       
+       if search_engine == "모든 검색 엔진 통합 분석 (추천)":
+           logger.info("🔍 다양성 강화 통합 분석 시작...")
+           
+           # Google 검색 그라운딩 도구 설정
+           google_search_tool = Tool(google_search=GoogleSearch())
+           config_tools = [google_search_tool]
+           
+           # 다양성 강화 종합 시장 분석 실행
+           comprehensive_analysis = comprehensive_market_analysis(category, seasonality, sales_target)
+           
+           search_info = f"""
+🔍 === 다양성 강화 통합 분석 결과 ===
+
+📈 Google 검색 그라운딩: 실시간 다양한 쇼핑키워드 트렌드 분석 (자동 실행)
+🛒 네이버 쇼핑 API: 한국 쇼핑몰 다양한 키워드 데이터 분석
+🌐 DuckDuckGo 검색: 글로벌 다양한 쇼핑키워드 정보 분석
+
+{comprehensive_analysis}
+
+💡 위 모든 데이터를 종합하여 매번 다른 조합의 쇼핑키워드를 생성��니다.
+🎲 랜덤 시드: {random_seed} (매번 다른 결과 보장)
+"""
+           
+       elif search_engine == "Google 검색 그라운딩만":
+           logger.info("Google 검색 도구 설정 중...")
+           google_search_tool = Tool(google_search=GoogleSearch())
+           config_tools = [google_search_tool]
+           search_info = f"Google 검색 그라운딩을 통한 다양한 실시간 쇼핑키워드 분석 (시드: {random_seed})"
+           
+       elif search_engine in ["네이버 검색 API만", "DuckDuckGo 검색만"]:
+           logger.info(f"{search_engine} 사용하여 다양한 쇼핑키워드 조사 중...")
+           # 다양성 강화를 위한 검색 실행
+           search_queries = []
+           
+           # 랜덤하게 다양한 검색어 생성
+           base_items = random.sample(diverse_combinations, 8)
+           for item in base_items:
+               search_queries.append(f"{item} 쇼핑키워드")
+           
+           search_results = ""
+           for query in search_queries:
+               result = search_with_api(query, search_engine)
+               search_results += f"[검색어: {query}]\n{result}\n\n"
+           
+           search_info = f"{search_engine} 다양한 쇼핑키워드 검색 결과 (시드: {random_seed}):\n{search_results}"
+           
+       else:  # 검색 없이 AI만 사용
+           logger.info("검색 없이 AI 지식만 사용")
+           search_info = f"AI 내장 지식을 기반으로 다양한 쇼핑키워드 생성 (시드: {random_seed})"
+       
+       # 다양성을 강화한 프롬프트 - 매번 다른 조합 요청
+       diverse_sample = random.sample(diverse_combinations, 20)
+       
+       prompt = f"""
+🎯 다양성 강화 쇼핑키워드 발굴 시스템 v5.0
+
+⚡ 중요: 절대 중복되지 않는 다양한 키워드만 생성하세요!
+
+🔬 역할 정의
+당신은 매번 완전히 다른 조합의 쇼핑키워드를 생성하는 전문가입니다.
+
+🎯 목표  
+주어진 조건에 맞는 실제 쇼핑키워드 50개를 발굴하되, 절대 중복되지 않고 매번 다른 조합으로 구성하십시오.
+
+📋 입력된 조건:
+카테고리: {category}
+추가 요청사항: {additional_request}
+출시타이밍: {launch_timing}
+계절성: {seasonality}
+매출목표: {sales_target}
+판매채널: {sales_channel}
+경쟁강도: {competition_level}
+검색엔진: {search_engine}
+
+🔍 쇼핑키워드 분석 정보:
+{search_info}
+
+🎲 다양성 보장 참고 조합 예시 (이것과 다르게 생성하세요):
+{', '.join(diverse_sample[:10])}
+
+⚠️ 키워드별 랜덤 적용 규칙:
+각 키워드마다 다음과 같이 적용하세요:
+
+{"- 카테고리: 매 키워드마다 " + str(random_settings['categories']) + " 중에서 랜덤 선택" if random_settings['category_random'] else f"- 카테고리: {fixed_values['category']} 고정"}
+{"- 출시타이밍: 매 키워드마다 " + str(random_settings['launch_timings']) + " 중에서 랜덤 선택" if random_settings['launch_timing_random'] else f"- 출시타이밍: {fixed_values['launch_timing']} 고정"}
+{"- 계절성: 매 키워드마다 " + str(random_settings['seasonalities']) + " 중에서 랜덤 선택" if random_settings['seasonality_random'] else f"- 계절성: {fixed_values['seasonality']} 고정"}
+{"- 매출목표: 매 키워드마다 " + str(random_settings['sales_targets']) + " 중에서 랜덤 선택" if random_settings['sales_target_random'] else f"- 매출목표: {fixed_values['sales_target']} 고정"}
+{"- 판매채널: 매 키워드마다 " + str(random_settings['sales_channels']) + " 중에서 랜덤 선택" if random_settings['sales_channel_random'] else f"- 판매채널: {fixed_values['sales_channel']} 고정"}
+{"- 경쟁강도: 매 키워드마다 " + str(random_settings['competition_levels']) + " 중에서 랜덤 선택" if random_settings['competition_level_random'] else f"- 경쟁강도: {fixed_values['competition_level']} 고정"}
+
+⚙️ 다양성 강화 워크플로우
+1단계: 완전히 새로운 조합 생성
+- 이전 결과와 절대 중복되지 않는 키워드 조합
+- 소재({', '.join(MATERIAL_KEYWORDS[:5])}) + 상품명 조합
+- 형태({', '.join(SHAPE_KEYWORDS[:5])}) + 상품명 조합  
+- 기능({', '.join(FUNCTION_KEYWORDS[:5])}) + 상품명 조합
+
+2단계: 중복 방지 필터링
+- 동일한 키워드 조합 완전 배제
+- 유사한 의미의 키워드 조합 배제
+- 매번 새로운 각도로 접근
+
+3단계: 50개 다양한 키워드 선별
+- 브랜드명 절대 금지
+- 복잡한 기술 용어 금지
+- 최대 2개 단어 조합만 허용
+
+⚠️ 다양성 강화 키워드 구성 규칙 (매우 중요):
+
+🚫 절대 금지 사항:
+- 동일하거나 유사한 키워드 반복
+- 브랜드명 (삼성, LG, 나이키 등)
+- 복잡한 기술 용어
+- 3개 이상 복합어
+
+✅ 반드시 다양하게 포함해야 할 형태:
+1. 소재별 키워드 (예: 대나무 도마, 구리 컵)
+2. 형태별 키워드 (예: 원형 접시, 슬림 케이스)
+3. ���능별 키워드 (예: 방수 파우치, 항균 수건)
+4. 카테고리별 키워드 (예: 수납함, 조리도구)
+
+🎯 다양성 보장 전략:
+- 절대 같은 소재를 2번 이상 사용하지 마세요
+- 절대 같은 형태를 2번 이상 사용하지 마세요  
+- 절대 같은 기능을 2번 이상 사용하지 마세요
+- 매 키워드마다 완전히 다른 조합으로 생성하세요
+
+올바른 다양한 키워드 예시:
+✅ 대나무 도마 (소재+상품)
+✅ 원형 접시 (형태+상품)  
+✅ 방수 파우치 (기능+상품)
+✅ 세라믹 머그컵 (소재+상품)
+✅ 접이식 선반 (형태+상품)
+✅ 항균 수건 (기능+상품)
+
+잘못된 반복 키워드 예시:
+❌ 대나무 도마, 대나무 젓가락 (소재 반복)
+❌ 원형 접시, 원형 쟁반 (형태 반복)
+❌ 방수 파우치, 방수 케이스 (기능 반복)
+
+📋 출력 형식:
+오직 완전히 다른 쇼핑키워드만 한 줄씩 50개 출력
+- 번호 금지
+- 설명 금지  
+- 기호나 특수문자 금지
+- 괄호 안 설명 금지
+- 순수 키워드만 출력
+- 절대 중복 금지
+
+예시 출력 형태 (매번 완전히 다르게):
+유리 화분
+접이식 의자
+항균 도마
+알루미늄 텀블러
+슬림 파일함
+
+⚡ 지금 바로 절대 중복되지 않는 완전히 새로운 쇼핑키워드 50개를 각각 다른 랜덤 조건을 적용하여 출력하세요.
+매번 실행할 때마다 완전히 다른 결과가 나와야 합니다!

keyword_search.py

@@ -0,0 +1,194 @@
+"""
+키워드 검색량 조회 관련 기능
+- 네이버 API를 통한 키워드 검색량 조회
+- 검색량 배치 처리
+"""
+
+import requests
+import time
+import random
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import api_utils
+import logging
+
+# 로깅 설정
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+def exponential_backoff_sleep(retry_count, base_delay=0.3, max_delay=5.0):
+    """지수 백오프 방식의 대기 시간 계산"""
+    delay = min(base_delay * (2 ** retry_count), max_delay)
+    # 약간의 랜덤성 추가 (지터)
+    jitter = random.uniform(0, 0.5) * delay
+    time.sleep(delay + jitter)
+
+def fetch_search_volume_batch(keywords_batch):
+    """키워드 배치에 대한 네이버 검색량 조회"""
+    
+    # 1. 스페이스바 제거 개선 - 배치 키워드들 전처리
+    cleaned_keywords_batch = []
+    for kw in keywords_batch:
+        cleaned_kw = kw.strip().replace(" ", "") if kw else ""
+        cleaned_keywords_batch.append(cleaned_kw)
+    
+    keywords_batch = cleaned_keywords_batch
+    
+    result = {}
+    max_retries = 3
+    retry_count = 0
+    
+    while retry_count < max_retries:
+        try:
+            # 순차적으로 API 설정 가져오기 (배치마다 한 번만 호출)
+            api_config = api_utils.get_next_api_config()
+            API_KEY = api_config["API_KEY"]
+            SECRET_KEY = api_config["SECRET_KEY"]
+            CUSTOMER_ID_STR = api_config["CUSTOMER_ID"]
+            
+            logger.debug(f"=== 환경 변수 체크 (시도 #{retry_count+1}) ===")
+            logger.info(f"배치 크기: {len(keywords_batch)}개 키워드")
+            
+            # API 설정 유효성 검사
+            is_valid, message = api_utils.validate_api_config(api_config)
+            if not is_valid:
+                logger.error(f"❌ {message}")
+                retry_count += 1
+                exponential_backoff_sleep(retry_count)
+                continue
+            
+            # CUSTOMER_ID를 정수로 변환
+            try:
+                CUSTOMER_ID = int(CUSTOMER_ID_STR)
+            except ValueError:
+                logger.error(f"❌ CUSTOMER_ID 변환 오류: '{CUSTOMER_ID_STR}'는 유효한 숫자가 아닙니다.")
+                retry_count += 1
+                exponential_backoff_sleep(retry_count)
+                continue
+            
+            BASE_URL = "https://api.naver.com"
+            uri = "/keywordstool"
+            method = "GET"
+            headers = api_utils.get_header(method, uri, API_KEY, SECRET_KEY, CUSTOMER_ID)
+            
+            # 키워드 배치를 한 번에 API로 전송
+            params = {
+                "hintKeywords": keywords_batch,
+                "showDetail": "1"
+            }
+            
+            logger.debug(f"요청 파라미터: {len(keywords_batch)}개 키워드")
+            
+            # API 호출
+            response = requests.get(BASE_URL + uri, params=params, headers=headers, timeout=10)
+            
+            logger.debug(f"응답 상태 코드: {response.status_code}")
+            
+            if response.status_code != 200:
+                logger.error(f"❌ API 오류 응답 (시도 #{retry_count+1}):")
+                logger.error(f"  본문: {response.text}")
+                retry_count += 1
+                exponential_backoff_sleep(retry_count)
+                continue
+            
+            # 응답 데이터 파싱
+            result_data = response.json()
+            
+            logger.debug(f"응답 데이터 구조:")
+            logger.debug(f"  타입: {type(result_data)}")
+            logger.debug(f"  키들: {result_data.keys() if isinstance(result_data, dict) else 'N/A'}")
+            
+            if isinstance(result_data, dict) and "keywordList" in result_data:
+                logger.debug(f"  keywordList 길이: {len(result_data['keywordList'])}")
+                
+                # 배치 내 각 키워드와 매칭
+                for keyword in keywords_batch:
+                    found = False
+                    for item in result_data["keywordList"]:
+                        rel_keyword = item.get("relKeyword", "")
+                        if rel_keyword == keyword:
+                            pc_count = item.get("monthlyPcQcCnt", 0)
+                            mobile_count = item.get("monthlyMobileQcCnt", 0)
+                            
+                            # 숫자 변환
+                            try:
+                                if isinstance(pc_count, str):
+                                    pc_count_converted = int(pc_count.replace(",", ""))
+                                else:
+                                    pc_count_converted = int(pc_count)
+                            except:
+                                pc_count_converted = 0
+                                
+                            try:
+                                if isinstance(mobile_count, str):
+                                    mobile_count_converted = int(mobile_count.replace(",", ""))
+                                else:
+                                    mobile_count_converted = int(mobile_count)
+                            except:
+                                mobile_count_converted = 0
+                                
+                            total_count = pc_count_converted + mobile_count_converted
+                            
+                            result[keyword] = {
+                                "PC검색량": pc_count_converted,
+                                "모바일검색량": mobile_count_converted,
+                                "총검색량": total_count
+                            }
+                            logger.debug(f"✅ '{keyword}': PC={pc_count_converted}, Mobile={mobile_count_converted}, Total={total_count}")
+                            found = True
+                            break
+                    
+                    if not found:
+                        logger.warning(f"❌ '{keyword}': 매칭되는 데이터를 찾을 수 없음")
+                
+                # 성공적으로 데이터를 가져왔으므로 루프 종료
+                break
+            else:
+                logger.error(f"❌ keywordList가 없음 (시도 #{retry_count+1})")
+                logger.error(f"전체 응답: {result_data}")
+                retry_count += 1
+                exponential_backoff_sleep(retry_count)
+        
+        except Exception as e:
+            logger.error(f"❌ 배치 처리 중 오류 (시도 #{retry_count+1}): {str(e)}")
+            import traceback
+            logger.error(traceback.format_exc())
+            retry_count += 1
+            exponential_backoff_sleep(retry_count)
+    
+    logger.info(f"\n=== 배치 처리 완료 ===")
+    logger.info(f"성공적으로 처리된 키워드 수: {len(result)}")
+    
+    return result
+
+def fetch_all_search_volumes(keywords, batch_size=5):
+    """키워드 리스트에 대한 네이버 검색량 병렬 조회"""
+    results = {}
+    batches = []
+
+    # 키워드를 5개씩 묶어서 배치 생성
+    for i in range(0, len(keywords), batch_size):
+        batch = keywords[i:i + batch_size]
+        batches.append(batch)
+
+    logger.info(f"총 {len(batches)}개 배치로 {len(keywords)}개 키워드 처리 중…")
+    logger.info(f"배치 크기: {batch_size}, 병렬 워커: 3개, API 계정: {len(api_utils.NAVER_API_CONFIGS)}개 순차 사용")
+
+    with ThreadPoolExecutor(max_workers=3) as executor:  # 워커 수 제한
+        futures = {executor.submit(fetch_search_volume_batch, batch): batch for batch in batches}
+        for future in as_completed(futures):
+            batch = futures[future]
+            try:
+                batch_results = future.result()
+                results.update(batch_results)
+                logger.info(f"배치 처리 완료: {len(batch)}개 키워드 (성공: {len(batch_results)}개)")
+            except Exception as e:
+                logger.error(f"배치 처리 오류: {e}")
+            # API 레이트 리밋 방지를 위한 지수 백오프 사용
+            exponential_backoff_sleep(0)  # 초기 지연 적용
+
+    logger.info(f"검색량 조회 완료: {len(results)}개 키워드")
+    return results

style.css

@@ -1,29 +1,117 @@
+/* ============================================
+   다크모드 자동 변경 AI 상품 소싱 분석 시스템 CSS
+   ============================================ */
+
+/* 1. CSS 변수 정의 (라이트모드 - 기본값) */
 :root {
+    /* 메인 컬러 */
     --primary-color: #FB7F0D;
     --secondary-color: #ff9a8b;
     --accent-color: #FF6B6B;
+    
+    /* 배경 컬러 */
     --background-color: #FFFFFF;
     --card-bg: #ffffff;
+    --input-bg: #ffffff;
+    
+    /* 텍스트 컬러 */
     --text-color: #334155;
-    --border-radius: 18px;
+    --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;
+}
+
+/* 2. 다크모드 색상 변수 (자동 감지) */
+@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);
+    }
+}
+
+/* 3. 수동 다크모드 클래스 (Gradio 토글용) */
+[data-theme="dark"], 
+.dark,
+.gr-theme-dark {
+    /* 배경 컬러 */
+    --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);
 }
 
 /* ── 전역 스타일 ── */
 body {
     font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif;
-    background-color: var(--background-color);
-    color: var(--text-color);
+    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,
+.gradio-container *,
+.gr-app,
+.gr-app *,
+.gr-interface {
+    background-color: var(--background-color) !important;
+    color: var(--text-color) !important;
 }
 
 .gradio-container {
     width: 100%;
     margin: 0 auto;
     padding: 20px;
-    background-color: var(--background-color);
+    background-color: var(--background-color) !important;
 }
 
 /* ── 섹션 스타일 ── */
@@ -43,12 +131,13 @@ body {
 
 /* 섹션 프레임 */
 .custom-frame {
-    background-color: var(--card-bg);
-    border: 1px solid rgba(0, 0, 0, 0.04);
+    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);
+    box-shadow: var(--shadow) !important;
+    color: var(--text-color) !important;
 }
 
 /* 접을 수 있는 섹션 */
@@ -75,18 +164,17 @@ body {
 .collapsible-content {
     display: none;
     padding: 15px;
-    background-color: var(--card-bg);
-    border: 1px solid rgba(0, 0, 0, 0.04);
+    background-color: var(--card-bg) !important;
+    border: 1px solid var(--border-light) !important;
     border-radius: 0 0 var(--border-radius) var(--border-radius);
     margin-top: -5px;
+    color: var(--text-color) !important;
 }
 
 .collapsible-content.active {
     display: block;
 }
 
-
-
 /* 두 버튼에 공통으로 적용할 스타일 */
 .execution-button {
   font-size: 18px !important;
@@ -106,12 +194,12 @@ body {
 
 /* 각 버튼별 고유 색상 */
 .primary-button {
-  background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)) !important;
+  background: var(--primary-color) !important;
   box-shadow: 0 4px 8px rgba(251, 127, 13, 0.25) !important;
 }
 
 .secondary-button {
-  background: linear-gradient(135deg, #6c757d, #495057) !important;
+  background: #6c757d !important;
   box-shadow: 0 4px 8px rgba(0, 0, 0, 0.25) !important;
 }
 
@@ -124,19 +212,17 @@ body {
 .execution-section {
   margin-top: 20px;
   padding: 15px;
-  background-color: #f9f9f9;
+  background-color: var(--card-bg) !important;
   border-radius: 8px;
-  border: 1px solid #e5e5e5;
+  border: 1px solid var(--border-light) !important;
+  color: var(--text-color) !important;
 }
 
-
-
-
 /* ── 컴���넌트 스타일 ── */
 /* 버튼 스타일 */
 .custom-button {
     border-radius: 30px !important;
-    background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)) !important;
+    background: var(--primary-color) !important;
     color: white !important;
     font-size: 18px !important;
     padding: 10px 20px !important;
@@ -153,7 +239,7 @@ body {
 /* 작은 버튼 */
 .custom-button-small {
     border-radius: 20px !important;
-    background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)) !important;
+    background: var(--primary-color) !important;
     color: white !important;
     font-size: 14px !important;
     padding: 8px 15px !important;
@@ -170,7 +256,7 @@ body {
 /* 리셋 버튼 */
 .reset-button {
     border-radius: 30px !important;
-    background: linear-gradient(135deg, #6c757d, #495057) !important;
+    background: #6c757d !important;
     color: white !important;
     font-size: 16px !important;
     padding: 8px 16px !important;
@@ -186,15 +272,29 @@ body {
 }
 
 /* 입력 필드 스타일 */
-.gr-input, .gr-text-input, .gr-sample-inputs {
+.gr-input, .gr-text-input, .gr-sample-inputs,
+input[type="text"],
+input[type="number"],
+input[type="email"],
+input[type="password"],
+textarea,
+select {
     border-radius: var(--border-radius) !important;
-    border: 1px solid #dddddd !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 {
+.gr-input:focus, .gr-text-input:focus,
+input[type="text"]:focus,
+input[type="number"]:focus,
+input[type="email"]:focus,
+input[type="password"]: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;
@@ -208,9 +308,11 @@ input[type="checkbox"], input[type="radio"] {
 /* 드롭다운 스타일 */
 .gr-dropdown {
     border-radius: var(--border-radius) !important;
-    border: 1px solid #dddddd !important;
+    border: 1px solid var(--border-color) !important;
     padding: 12px !important;
     transition: all 0.3s ease !important;
+    background-color: var(--input-bg) !important;
+    color: var(--text-color) !important;
 }
 
 .gr-dropdown:focus {
@@ -225,7 +327,7 @@ input[type="checkbox"], input[type="radio"] {
     align-items: center;
     font-size: 20px;
     font-weight: 700;
-    color: #333333;
+    color: var(--text-color) !important;
     margin-bottom: 10px;
     padding-bottom: 5px;
     border-bottom: 2px solid var(--primary-color);
@@ -242,7 +344,7 @@ input[type="checkbox"], input[type="radio"] {
 .subsection-title {
     font-size: 18px;
     font-weight: 600;
-    color: #444444;
+    color: var(--text-color) !important;
     margin: 15px 0 8px 0;
 }
 
@@ -254,32 +356,38 @@ input[type="checkbox"], input[type="radio"] {
     margin: 0;
     padding: 0;
     font-size: 14px;
+    background-color: var(--card-bg) !important;
+    color: var(--text-color) !important;
+    position: relative;
 }
 
 .styled-table th,
 .styled-table td {
     padding: 12px 15px;
     text-align: left;
-    border-bottom: 1px solid #dddddd;
+    border-bottom: 1px solid var(--border-color) !important;
     overflow: hidden;
     text-overflow: ellipsis;
+    background-color: var(--card-bg) !important;
+    color: var(--text-color) !important;
 }
 
 .styled-table th {
-    background-color: var(--primary-color);
-    color: white;
+    background-color: var(--primary-color) !important;
+    color: white !important;
     font-weight: bold;
     position: sticky;
     top: 0;
     white-space: nowrap;
+    z-index: 10;
 }
 
 .styled-table tbody tr:nth-of-type(even) {
-    background-color: #f3f3f3;
+    background-color: var(--table-even-bg) !important;
 }
 
 .styled-table tbody tr:hover {
-    background-color: #f0f0f0;
+    background-color: var(--table-hover-bg) !important;
 }
 
 .styled-table tbody tr:last-of-type {
@@ -291,8 +399,40 @@ input[type="checkbox"], input[type="radio"] {
     max-height: 600px;
     overflow-y: auto;
     border-radius: var(--border-radius);
-    border: 1px solid #e5e5e5;
+    border: 1px solid var(--border-light) !important;
     margin-top: 15px;
+    background-color: var(--card-bg) !important;
+    position: relative;
+}
+
+/* 테이블 컨테이너 추가 스타일 */
+.table-container {
+    position: relative;
+    width: 100%;
+    margin: 0;
+    border-radius: 8px;
+    overflow: hidden;
+    box-shadow: 0 0 20px rgba(0, 0, 0, 0.1);
+}
+
+.header-wrap {
+    position: sticky;
+    top: 0;
+    z-index: 20;
+    background-color: var(--primary-color) !important;
+}
+
+/* 테이블 데이터가 헤더 위로 오는 것을 방지 */
+.styled-table tbody td {
+    position: relative;
+    z-index: 1;
+}
+
+.styled-table thead th {
+    position: sticky;
+    top: 0;
+    z-index: 10;
+    background-color: var(--primary-color) !important;
 }
 
 /* 스크롤바 스타일 */
@@ -302,7 +442,7 @@ input[type="checkbox"], input[type="radio"] {
 }
 
 ::-webkit-scrollbar-track {
-    background: rgba(0, 0, 0, 0.05);
+    background: var(--card-bg);
     border-radius: 10px;
 }
 
@@ -311,13 +451,18 @@ input[type="checkbox"], input[type="radio"] {
     border-radius: 10px;
 }
 
+::-webkit-scrollbar-thumb:hover {
+    background: var(--secondary-color);
+}
+
 /* ── 분석 결과 스타일 ── */
 .analysis-result {
     margin-top: 30px;
-    border: 1px solid #ddd;
+    border: 1px solid var(--border-color) !important;
     border-radius: 5px;
     padding: 15px;
-    background-color: #f9f9f9;
+    background-color: var(--card-bg) !important;
+    color: var(--text-color) !important;
 }
 
 .result-header {
@@ -328,24 +473,28 @@ input[type="checkbox"], input[type="radio"] {
 }
 
 .summary-box {
-    background-color: #f5f5f5;
+    background-color: var(--table-even-bg) !important;
     border-left: 4px solid var(--primary-color);
     padding: 10px 15px;
     margin-bottom: 20px;
     font-size: 14px;
+    color: var(--text-color) !important;
 }
 
 .summary-title {
     font-weight: bold;
     margin-bottom: 5px;
+    color: var(--text-color) !important;
 }
 
 .recommendation-box {
-    background-color: #e7f7f3;
+    background-color: var(--card-bg) !important;
     border-radius: 5px;
     padding: 15px;
     margin-bottom: 25px;
-    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+    box-shadow: var(--shadow-light) !important;
+    border: 1px solid var(--border-color) !important;
+    color: var(--text-color) !important;
 }
 
 .recommendation-title {
@@ -357,20 +506,22 @@ input[type="checkbox"], input[type="radio"] {
 
 .recommendation-item {
     padding: 6px 0;
-    border-bottom: 1px solid #e0e0e0;
+    border-bottom: 1px solid var(--border-color) !important;
+    color: var(--text-color) !important;
 }
 
 .recommendation-item:last-child {
     border-bottom: none;
 }
 
-/* ── 키워드 태그 스타일 ── */
+/* 키워드 태그 스타일 */
 .keyword-tag-container {
     margin-top: 20px;
     padding: 10px;
-    border: 1px solid #ddd;
+    border: 1px solid var(--border-color) !important;
     border-radius: 5px;
-    background-color: #f9f9f9;
+    background-color: var(--card-bg) !important;
+    color: var(--text-color) !important;
 }
 
 .keyword-tag {
@@ -414,6 +565,76 @@ input[type="checkbox"], input[type="radio"] {
     animation: fadeIn 0.5s ease-out;
 }
 
+/* Gradio 컴포넌트 강제 적용 */
+.gr-form,
+.gr-box,
+.gr-panel,
+.gr-block,
+.gr-group,
+.gr-row,
+.gr-column {
+    background-color: var(--card-bg) !important;
+    color: var(--text-color) !important;
+    border-color: var(--border-color) !important;
+}
+
+/* 라벨 및 텍스트 요소 */
+label,
+.gr-label,
+.gr-checkbox label,
+.gr-radio label,
+p, span, div {
+    color: var(--text-color) !important;
+}
+
+/* 툴팁 및 팝업 */
+[data-tooltip]:hover::after,
+.tooltip,
+.popup {
+    background-color: var(--card-bg) !important;
+    color: var(--text-color) !important;
+    border-color: var(--border-color) !important;
+    box-shadow: var(--shadow-light) !important;
+}
+
+/* 모달 및 오버레이 */
+.modal,
+.overlay,
+[class*="modal"],
+[class*="overlay"] {
+    background-color: var(--card-bg) !important;
+    color: var(--text-color) !important;
+    border-color: var(--border-color) !important;
+}
+
+/* 코드 블록 및 pre 태그 */
+code,
+pre,
+.code-block {
+    background-color: var(--table-even-bg) !important;
+    color: var(--text-color) !important;
+    border-color: var(--border-color) !important;
+}
+
+/* 알림 및 메시지 */
+.alert,
+.message,
+.notification,
+[class*="alert"],
+[class*="message"],
+[class*="notification"] {
+    background-color: var(--card-bg) !important;
+    color: var(--text-color) !important;
+    border-color: var(--border-color) !important;
+}
+
+/* 전환 애니메이션 */
+* {
+    transition: background-color 0.3s ease, 
+                color 0.3s ease, 
+                border-color 0.3s ease !important;
+}
+
 /* 반응형 조정 */
 @media (max-width: 768px) {
     .grid-container {

text_utils.py

@@ -0,0 +1,227 @@
+"""
+텍스트 처리 관련 유틸리티 함수 모음
+- 텍스트 분리 및 정제
+- 키워드 추출
+- Gemini API 키 통합 관리 적용
+"""
+
+import re
+import google.generativeai as genai
+import os
+import logging
+import api_utils  # API 키 통합 관리를 위한 임포트
+
+# 로깅 설정
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+# ===== Gemini 모델 관리 함수들 =====
+def get_gemini_model():
+    """api_utils에서 Gemini 모델 가져오기 (통합 관리)"""
+    try:
+        model = api_utils.get_gemini_model()
+        if model:
+            logger.info("Gemini 모델 로드 성공 (api_utils 통합 관리)")
+            return model
+        else:
+            logger.warning("사용 가능한 Gemini API 키가 없습니다.")
+            return None
+    except Exception as e:
+        logger.error(f"Gemini 모델 로드 실패: {e}")
+        return None
+
+# 텍스트 분리 및 정제 함수
+def clean_and_split(text, only_korean=False):
+    """텍스트를 분리하고 정제하는 함수"""
+    text = re.sub(r"[()\[\]-]", " ", text)
+    text = text.replace("/", " ")
+    
+    if only_korean:
+        # 한글만 추출 옵션이 켜진 경우
+        # 공백이나 쉼표로 구분한 뒤 한글만 추출
+        words = re.split(r"[ ,]", text)
+        cleaned = []
+        for word in words:
+            word = word.strip()
+            # 한글만 남기고 다른 문자는 제거
+            word = re.sub(r"[^가-힣]", "", word)
+            if word and len(word) >= 1:  # 빈 문자열이 아니고 1글자 이상인 경우만 추가
+                cleaned.append(word)
+    else:
+        # 한글만 추출 옵션이 꺼진 경우 - 단어 통째로 처리
+        # 공백과 쉼표로 구분하여 단어 전체를 유지
+        words = re.split(r"[,\s]+", text)
+        cleaned = []
+        for word in words:
+            word = word.strip()
+            if word and len(word) >= 1:  # 빈 문자열이 아니고 1글자 이상인 경우만 추가
+                cleaned.append(word)
+    
+    return cleaned
+
+def filter_keywords_with_gemini(pairs, gemini_model=None):
+    """Gemini AI를 사용하여 키워드 조합 필터링 (개선버전) - API 키 통합 관리"""
+    if gemini_model is None:
+        # api_utils에서 Gemini 모델 가져오기
+        gemini_model = get_gemini_model()
+        
+    if gemini_model is None:
+        logger.error("Gemini 모델을 가져올 수 없습니다. 모든 키워드를 유지합니다.")
+        # 안전하게 처리: 모든 키워드를 유지
+        all_keywords = set()
+        for pair in pairs:
+            for keyword in pair:
+                all_keywords.add(keyword)
+        return list(all_keywords)
+        
+    # 모든 키워드를 목록으로 추출 (제거된 키워드 확인용)
+    all_keywords = set()
+    for pair in pairs:
+        for keyword in pair:
+            all_keywords.add(keyword)
+    
+    # 너무 많은 쌍이 있으면 제한
+    max_pairs = 50  # 최대 50개 쌍만 처리
+    pairs_to_process = list(pairs)[:max_pairs] if len(pairs) > max_pairs else pairs
+    
+    logger.info(f"필터링할 키워드 쌍: 총 {len(pairs)}개 중 {len(pairs_to_process)}개 처리")
+    
+    # 보수적인 프롬프트 사용 - 키워드 제거 최소화
+    prompt = (
+        "다음은 소비자가 검색할 가능성이 있는 키워드 쌍 목록입니다.\n"
+        "각 쌍은 같은 단어 조합이지만 순서만 다른 경우입니다 (예: 손질오징어 vs 오징어손질).\n\n"
+        "아래의 기준에 따라 각 쌍에서 더 자연스러운 키워드를 선택해주세요:\n"
+        "1. 소비자가 일상적으로 사용하는 자연스러운 표현을 우선 선택하세요.\n"
+        "2. 두 키워드가 모두 자연스럽거나 의미가 약간 다르다면, 반드시 둘 다 유지하세요.\n"
+        "3. 확실히 비자연스럽거나 어색한 경우에만 제거하세요.\n"
+        "4. 불확실한 경우에는 반드시 키워드를 유지하세요.\n"
+        "5. 숫자나 영어가 포함된 키워드는 한글 메인 키워드가 앞쪽에 오는 형태를 선택하세요. (예: '10kg 오징어' 보다 '오징어 10kg' 선택)\n"
+        "6. 검색량이 0인 키워드라도 일상적인 표현이라면 가능한 유지하세요. 명백하게 비정상적인 표현만 제거하세요.\n\n"
+        "주의: 기본적으로 대부분의 키워드를 유지하고, 매우 명확하게 비자연스러운 것만 제거하세요.\n\n"
+        "결과는 다음 형식으로 제공해주세요:\n"
+        "- 선택된 키워드 (이유: 자연스러운 표현이기 때문)\n"
+        "- 선택된 키워드1, 선택된 키워드2 (이유: 둘 다 자연스럽고 의미가 조금 다름)\n\n"
+    )
+    
+    # 키워�� 쌍 목록
+    formatted = "\n".join([f"- {a}, {b}" for a, b in pairs_to_process])
+    full_prompt = prompt + formatted
+    
+    try:
+        # 타임아웃 추가
+        logger.info(f"Gemini API 호출 시작 - {len(pairs_to_process)}개 키워드 쌍 처리 중...")
+        
+        # 응답 받기 (타임아웃 기능이 있으면 추가)
+        response = gemini_model.generate_content(full_prompt)
+        
+        logger.info("Gemini API 응답 성공")
+        lines = response.text.strip().split("\n")
+        
+        # 선택된 키워드 추출 (쉼표로 구분된 경우 모두 포함)
+        final_keywords = []
+        for line in lines:
+            if line.startswith("-"):
+                # 이유 부분 제거
+                keywords_part = line.strip("- ").split("(이유:")[0].strip()
+                # 쉼표로 구분된 키워드 모두 추가
+                for kw in keywords_part.split(","):
+                    kw = kw.strip()
+                    if kw:
+                        final_keywords.append(kw)
+        
+        # 처리되지 않은 쌍의 첫 번째 키워드도 추가 (LLM이 처리하지 않은 키워드)
+        if len(pairs) > max_pairs:
+            logger.info(f"추가 키워드 처리: 남은 {len(pairs) - max_pairs}개 쌍의 첫 번째 키워드 추가")
+            for pair in list(pairs)[max_pairs:]:
+                # 각 쌍의 첫 번째 키워드만 사용
+                final_keywords.append(pair[0])
+        
+        # 선택된 키워드가 없으면 기존 키워드 모두 반환
+        if not final_keywords:
+            logger.warning("경고: 선택된 키워드가 없어 모든 키워드를 유지합니다.")
+            final_keywords = list(all_keywords)
+        
+        # 순서 강제 수정 
+        corrected_keywords = []
+        
+        # 단위와 숫자 관련 정규식 패턴
+        unit_pattern = re.compile(r'(?i)(kg|g|mm|cm|ml|l|리터|개|팩|박스|세트|2l|l2)')
+        number_pattern = re.compile(r'\d+')
+        
+        for kw in final_keywords:
+            # 공백으로 분리
+            if ' ' in kw:
+                parts = kw.split()
+                first_part = parts[0]
+                
+                # 첫 부분이 단위나 숫자를 포함하는지 확인
+                if (unit_pattern.search(first_part) or number_pattern.search(first_part)) and len(parts) > 1:
+                    # 순서 바꾸기: 단위/숫자 부분을 뒤로 이동
+                    corrected_kw = " ".join(parts[1:] + [first_part])
+                    logger.info(f"키워드 순서 강제 수정: '{kw}' -> '{corrected_kw}'")
+                    corrected_keywords.append(corrected_kw)
+                else:
+                    corrected_keywords.append(kw)
+            else:
+                corrected_keywords.append(kw)
+        
+        # 특별 처리: "L 오징어", "2L 오징어" 같은 경우를 명시적으로 확인하고 수정
+        specific_fixes = []
+        for kw in corrected_keywords:
+            # 특정 패턴 체크
+            l_pattern = re.compile(r'^([0-9]*L) (.+)$', re.IGNORECASE)
+            match = l_pattern.match(kw)
+            
+            if match:
+                # L 단위를 뒤로 이동
+                l_part = match.group(1)
+                main_part = match.group(2)
+                fixed_kw = f"{main_part} {l_part}"
+                logger.info(f"특수 패턴 수정: '{kw}' -> '{fixed_kw}'")
+                specific_fixes.append(fixed_kw)
+            else:
+                specific_fixes.append(kw)
+        
+        # 제거된 키워드 목록 확인
+        selected_set = set(specific_fixes)
+        removed_keywords = all_keywords - selected_set
+        
+        # 제거된 키워드 출력
+        logger.info("\n=== LLM에 의해 제거된 키워드 목록 ===")
+        for kw in removed_keywords:
+            logger.info(f"  - {kw}")
+        logger.info(f"총 {len(all_keywords)}개 중 {len(removed_keywords)}개 제거됨 ({len(selected_set)}개 유지)\n")
+        
+        return specific_fixes
+        
+    except Exception as e:
+        logger.error(f"Gemini 오류: {e}")
+        logger.error("오류 발생으로 인해 모든 키워드를 유지합니다.")
+        logger.error(f"오류 유형: {type(e).__name__}")
+        import traceback
+        traceback.print_exc()
+        
+        # 안전하게 처리: 모든 키워드를 유지 
+        logger.info(f"안전 모드: {len(all_keywords)}개 키워드 모두 유지")
+        return list(all_keywords)
+
+def get_search_volume_range(total_volume):
+    """총 검색량을 기반으로 검색량 구간을 반환"""
+    if total_volume == 0:
+        return "100미만"
+    elif total_volume <= 100:
+        return "100미만"
+    elif total_volume <= 1000:
+        return "1000미만"
+    elif total_volume <= 2000:
+        return "2000미만"
+    elif total_volume <= 5000:
+        return "5000미만"
+    elif total_volume <= 10000:
+        return "10000미만"
+    else:
+        return "10000이상"

trend_analysis_v2.py

@@ -0,0 +1,1128 @@
+"""
+트렌드 분석 모듈 v2.16 - 정교한 이중 API 호출 및 역산 로직 구현
+- 이중 트렌드 API 호출: 일별 + 월별 데이터
+- 일별 데이터로 전월 정확한 검색량 역산
+- 전월 기준으로 3년 모든 월 검색량 역산
+- 작년 동월 기반 미래 3개월 예상
+- 최종 단계에서 10% 감소 조정 적용
+"""
+
+import urllib.request
+import json
+import time
+import logging
+from datetime import datetime, timedelta
+import calendar
+import api_utils
+
+# 로깅 설정
+logger = logging.getLogger(__name__)
+
+# ===== 핵심 개선 함수들 =====
+
+def get_complete_month():
+    """완성된 마지막 월 계산 - 단순화된 로직"""
+    current_date = datetime.now()
+    current_day = current_date.day
+    current_year = current_date.year
+    current_month = current_date.month
+    
+    # 3일 이후에만 전월을 완성된 것으로 간주
+    if current_day >= 3:
+        completed_year = current_year
+        completed_month = current_month - 1
+    else:
+        completed_year = current_year
+        completed_month = current_month - 2
+    
+    # 월이 0 이하가 되면 연도 조정
+    while completed_month <= 0:
+        completed_month += 12
+        completed_year -= 1
+    
+    return completed_year, completed_month
+
+def get_daily_trend_data(keywords, max_retries=3):
+    """1차 호출: 일별 트렌드 데이터 (전월 정확 계산용)"""
+    for retry_attempt in range(max_retries):
+        try:
+            # 데이터랩 API 설정
+            datalab_config = api_utils.get_next_datalab_api_config()
+            if not datalab_config:
+                logger.warning("데이터랩 API 키가 설정되지 않았습니다.")
+                return None
+            
+            client_id = datalab_config["CLIENT_ID"]
+            client_secret = datalab_config["CLIENT_SECRET"]
+            
+            # 완성된 마지막 월 계산
+            completed_year, completed_month = get_complete_month()
+            
+            # 일별 데이터 기간: 전월 1일 ~ 어제
+            current_date = datetime.now()
+            yesterday = current_date - timedelta(days=1)
+            
+            start_date = f"{completed_year:04d}-{completed_month:02d}-01"
+            end_date = yesterday.strftime("%Y-%m-%d")
+            
+            logger.info(f"📞 1차 호출 (일별): {start_date} ~ {end_date}")
+            
+            # 키워드 그룹 생성
+            keywordGroups = []
+            for kw in keywords[:5]:
+                keywordGroups.append({
+                    'groupName': kw,
+                    'keywords': [kw]
+                })
+            
+            # API 요청
+            body_dict = {
+                'startDate': start_date,
+                'endDate': end_date,
+                'timeUnit': 'date',  # 일별!
+                'keywordGroups': keywordGroups
+            }
+            
+            url = "https://openapi.naver.com/v1/datalab/search"
+            body = json.dumps(body_dict, ensure_ascii=False)
+            
+            request = urllib.request.Request(url)
+            request.add_header("X-Naver-Client-Id", client_id)
+            request.add_header("X-Naver-Client-Secret", client_secret)
+            request.add_header("Content-Type", "application/json")
+            
+            response = urllib.request.urlopen(request, data=body.encode("utf-8"), timeout=15)
+            rescode = response.getcode()
+            
+            if rescode == 200:
+                response_body = response.read()
+                response_json = json.loads(response_body)
+                logger.info(f"일별 트렌드 데이터 조회 성공")
+                return response_json
+            else:
+                logger.error(f"일별 API 오류: 상태코드 {rescode}")
+                if retry_attempt < max_retries - 1:
+                    time.sleep(2 * (retry_attempt + 1))
+                    continue
+                return None
+                
+        except Exception as e:
+            logger.error(f"일별 트렌드 조회 오류 (시도 {retry_attempt + 1}): {e}")
+            if retry_attempt < max_retries - 1:
+                time.sleep(2 * (retry_attempt + 1))
+                continue
+            return None
+    
+    return None
+
+def get_monthly_trend_data(keywords, max_retries=3):
+    """2차 호출: 월별 트렌드 데이터 (3년 전체 + 예상용)"""
+    for retry_attempt in range(max_retries):
+        try:
+            # 데이터랩 API 설정
+            datalab_config = api_utils.get_next_datalab_api_config()
+            if not datalab_config:
+                logger.warning("데이터랩 API 키가 설정되지 않았습니다.")
+                return None
+            
+            client_id = datalab_config["CLIENT_ID"]
+            client_secret = datalab_config["CLIENT_SECRET"]
+            
+            # 완성된 마지막 월 계산
+            completed_year, completed_month = get_complete_month()
+            
+            # 월별 데이터 기간: 3년 전 1월 ~ 완성된 마지막 월
+            start_year = completed_year - 3
+            start_date = f"{start_year:04d}-01-01"
+            end_date = f"{completed_year:04d}-{completed_month:02d}-01"
+            
+            logger.info(f"📞 2차 호출 (월별): {start_date} ~ {end_date}")
+            
+            # 키워드 그룹 생성
+            keywordGroups = []
+            for kw in keywords[:5]:
+                keywordGroups.append({
+                    'groupName': kw,
+                    'keywords': [kw]
+                })
+            
+            # API 요청
+            body_dict = {
+                'startDate': start_date,
+                'endDate': end_date,
+                'timeUnit': 'month',  # 월별!
+                'keywordGroups': keywordGroups
+            }
+            
+            url = "https://openapi.naver.com/v1/datalab/search"
+            body = json.dumps(body_dict, ensure_ascii=False)
+            
+            request = urllib.request.Request(url)
+            request.add_header("X-Naver-Client-Id", client_id)
+            request.add_header("X-Naver-Client-Secret", client_secret)
+            request.add_header("Content-Type", "application/json")
+            
+            response = urllib.request.urlopen(request, data=body.encode("utf-8"), timeout=15)
+            rescode = response.getcode()
+            
+            if rescode == 200:
+                response_body = response.read()
+                response_json = json.loads(response_body)
+                logger.info(f"월별 트렌드 데이터 조회 성공")
+                return response_json
+            else:
+                logger.error(f"월별 API 오류: 상태코드 {rescode}")
+                if retry_attempt < max_retries - 1:
+                    time.sleep(2 * (retry_attempt + 1))
+                    continue
+                return None
+                
+        except Exception as e:
+            logger.error(f"월별 트렌드 조회 오류 (시도 {retry_attempt + 1}): {e}")
+            if retry_attempt < max_retries - 1:
+                time.sleep(2 * (retry_attempt + 1))
+                continue
+            return None
+    
+    return None
+
+def calculate_previous_month_from_daily(current_volume, daily_data):
+    """일별 트렌드로 전월 정확한 검색량 역산"""
+    if not daily_data or "results" not in daily_data:
+        logger.warning("일별 데이터가 없어 전월 계산을 건너뜁니다.")
+        return current_volume
+    
+    try:
+        completed_year, completed_month = get_complete_month()
+        
+        # 전월 일수 계산
+        prev_month_days = calendar.monthrange(completed_year, completed_month)[1]
+        
+        for result in daily_data["results"]:
+            keyword = result["title"]
+            
+            if not result["data"]:
+                continue
+            
+            # 최근 30일과 전월 데이터 분리
+            recent_30_ratios = []  # 최근 30일 (현재 검색량 기준)
+            prev_month_ratios = []  # 전월 데이터
+            
+            for data_point in result["data"]:
+                try:
+                    date_obj = datetime.strptime(data_point["period"], "%Y-%m-%d")
+                    ratio = data_point["ratio"]
+                    
+                    # 전월 데이터
+                    if date_obj.year == completed_year and date_obj.month == completed_month:
+                        prev_month_ratios.append(ratio)
+                    
+                    # 최근 30일 (현재 검색량 기준 구간)
+                    current_date = datetime.now()
+                    if (current_date - date_obj).days <= 30:
+                        recent_30_ratios.append(ratio)
+                        
+                except:
+                    continue
+            
+            if not recent_30_ratios or not prev_month_ratios:
+                logger.warning(f"'{keyword}' 비교 데이터가 부족합니다.")
+                continue
+            
+            # 평균 비율 계산
+            recent_30_avg = sum(recent_30_ratios) / len(recent_30_ratios)
+            prev_month_avg = sum(prev_month_ratios) / len(prev_month_ratios)
+            
+            if recent_30_avg == 0:
+                continue
+            
+            # 전월 검색량 역산
+            # 현재 검색량 = 최근 30일 평균 기준
+            # 전월 검색량 = (전월 평균 / 최근 30일 평균) × 현재 검색량 × (전월 일수 / 30일)
+            prev_month_volume = int(
+                (prev_month_avg / recent_30_avg) * current_volume * (prev_month_days / 30)
+            )
+            
+            logger.info(f"'{keyword}' 전월 {completed_year}.{completed_month:02d} 역산 검색량: {prev_month_volume:,}회")
+            logger.info(f"  - 최근 30일 평균 비율: {recent_30_avg:.1f}%")
+            logger.info(f"  - 전월 평균 비율: {prev_month_avg:.1f}%")
+            logger.info(f"  - 전월 일수 보정: {prev_month_days}일")
+            
+            return prev_month_volume
+    
+    except Exception as e:
+        logger.error(f"전월 역산 계산 오류: {e}")
+        return current_volume
+    
+    return current_volume
+
+def calculate_all_months_from_previous(prev_month_volume, monthly_data, completed_year, completed_month):
+    """전월을 기준으로 모든 월 검색량 역산"""
+    if not monthly_data or "results" not in monthly_data:
+        logger.warning("월별 데이터가 없어 역산 계산을 건너뜁니다.")
+        return [], []
+    
+    monthly_volumes = []
+    dates = []
+    
+    try:
+        for result in monthly_data["results"]:
+            keyword = result["title"]
+            
+            if not result["data"]:
+                continue
+            
+            # 전월(기준월) 비율 찾기
+            base_ratio = None
+            for data_point in result["data"]:
+                try:
+                    date_obj = datetime.strptime(data_point["period"], "%Y-%m-%d")
+                    if date_obj.year == completed_year and date_obj.month == completed_month:
+                        base_ratio = data_point["ratio"]
+                        break
+                except:
+                    continue
+            
+            if base_ratio is None or base_ratio == 0:
+                logger.warning(f"'{keyword}' 기준월 비율을 찾을 수 없습니다.")
+                continue
+            
+            logger.info(f"'{keyword}' 기준월 {completed_year}.{completed_month:02d} 비율: {base_ratio}% (검색량: {prev_month_volume:,}회)")
+            
+            # 모든 월 검색량 역산
+            for data_point in result["data"]:
+                try:
+                    date_obj = datetime.strptime(data_point["period"], "%Y-%m-%d")
+                    ratio = data_point["ratio"]
+                    
+                    # 해당 월의 일수 가져오기
+                    month_days = calendar.monthrange(date_obj.year, date_obj.month)[1]
+                    base_month_days = calendar.monthrange(completed_year, completed_month)[1]
+                    
+                    # 역산 계산: (해당월 비율 / 기준월 비율) × 기준월 검색량 × (해당월 일수 / 기준월 일수)
+                    calculated_volume = int(
+                        (ratio / base_ratio) * prev_month_volume * (month_days / base_month_days)
+                    )
+                    calculated_volume = max(calculated_volume, 0)  # 음수 방지
+                    
+                    monthly_volumes.append(calculated_volume)
+                    dates.append(data_point["period"])
+                    
+                except:
+                    continue
+            
+            logger.info(f"'{keyword}' 전체 월별 검색량 역산 완료: {len(monthly_volumes)}개월")
+            break  # 첫 번째 키워드만 처리
+    
+    except Exception as e:
+        logger.error(f"월별 역산 계산 오류: {e}")
+        return [], []
+    
+    return monthly_volumes, dates
+
+def generate_future_from_growth_rate(monthly_volumes, dates, completed_year, completed_month):
+    """증감율 기반 미래 3개월 예상 생성"""
+    if len(monthly_volumes) < 12:
+        logger.warning("미래 예측을 위한 충분한 데이터가 없습니다.")
+        return [], []
+    
+    try:
+        # 작년 동월들과 올해 완성된 월들 비교하여 증감율 계산
+        this_year_volumes = []
+        last_year_volumes = []
+        
+        for i, date_str in enumerate(dates):
+            try:
+                date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                
+                # 올해 완성된 데이터 (1월 ~ 완성된 월)
+                if date_obj.year == completed_year and date_obj.month <= completed_month:
+                    this_year_volumes.append(monthly_volumes[i])
+                
+                # 작년 동일 기간 데이터
+                if date_obj.year == completed_year - 1 and date_obj.month <= completed_month:
+                    last_year_volumes.append(monthly_volumes[i])
+                    
+            except:
+                continue
+        
+        # 증감율 계산
+        if len(this_year_volumes) >= 3 and len(last_year_volumes) >= 3:
+            this_year_avg = sum(this_year_volumes) / len(this_year_volumes)
+            last_year_avg = sum(last_year_volumes) / len(last_year_volumes)
+            
+            if last_year_avg > 0:
+                growth_rate = (this_year_avg - last_year_avg) / last_year_avg
+                # 증감율 범위 제한 (-50% ~ +100%)
+                growth_rate = max(-0.5, min(growth_rate, 1.0))
+            else:
+                growth_rate = 0
+        else:
+            growth_rate = 0
+        
+        logger.info(f"계산된 증감율: {growth_rate*100:+.1f}%")
+        
+        # 미래 3개월 예상
+        predicted_volumes = []
+        predicted_dates = []
+        
+        for month_offset in range(1, 4):  # 1, 2, 3개월 후
+            pred_year = completed_year
+            pred_month = completed_month + month_offset
+            
+            while pred_month > 12:
+                pred_month -= 12
+                pred_year += 1
+            
+            # 작년 동월 데이터 찾기
+            last_year_pred_year = pred_year - 1
+            last_year_pred_month = pred_month
+            last_year_volume = None
+            
+            for i, date_str in enumerate(dates):
+                try:
+                    date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                    if date_obj.year == last_year_pred_year and date_obj.month == last_year_pred_month:
+                        last_year_volume = monthly_volumes[i]
+                        break
+                except:
+                    continue
+            
+            # 예상 검색량 = 작년 동월 × (1 + 증감율)
+            if last_year_volume is not None:
+                predicted_volume = int(last_year_volume * (1 + growth_rate))
+                predicted_volume = max(predicted_volume, 0)  # 음수 방지
+                
+                predicted_volumes.append(predicted_volume)
+                predicted_dates.append(f"{pred_year:04d}-{pred_month:02d}-01")
+                
+                logger.info(f"예상 {pred_year}.{pred_month:02d}: 작년 동월 {last_year_volume:,}회 → 예상 {predicted_volume:,}회")
+        
+        return predicted_volumes, predicted_dates
+    
+    except Exception as e:
+        logger.error(f"미래 예측 생성 오류: {e}")
+        return [], []
+
+def apply_final_10_percent_reduction(monthly_data):
+    """최종 단계: 모든 결과에 10% 감소 적용"""
+    adjusted_data = {}
+    
+    try:
+        for keyword, data in monthly_data.items():
+            adjusted_volumes = []
+            
+            for volume in data["monthly_volumes"]:
+                if volume >= 10:
+                    adjusted_volume = int(volume * 0.9)  # 10% 감소
+                else:
+                    adjusted_volume = volume  # 10 미만은 그대로
+                
+                adjusted_volumes.append(adjusted_volume)
+            
+            # 데이터 복사 및 검색량 조정
+            adjusted_data[keyword] = data.copy()
+            adjusted_data[keyword]["monthly_volumes"] = adjusted_volumes
+            
+            # 현재 검색량도 조정
+            if data["current_volume"] >= 10:
+                adjusted_data[keyword]["current_volume"] = int(data["current_volume"] * 0.9)
+        
+        logger.info("최종 10% 감소 조정 완료")
+        
+    except Exception as e:
+        logger.error(f"10% 감소 조정 오류: {e}")
+        return monthly_data
+    
+    return adjusted_data
+
+# ===== 메인 함수들 (기존 호환성 유지) =====
+
+def get_naver_trend_data_v5(keywords, period="1year", max_retries=3):
+    """개선된 네이버 데이터랩 API 호출 - 이중 호출 구현"""
+    
+    if period == "1year":
+        # 이중 API 호출
+        daily_data = get_daily_trend_data(keywords, max_retries)
+        monthly_data = get_monthly_trend_data(keywords, max_retries)
+        
+        # 결과 반환 (기존 코드와 호환성 유지를 위해 월별 데이터 우선 반환)
+        return {
+            'daily_data': daily_data,
+            'monthly_data': monthly_data,
+            'results': monthly_data['results'] if monthly_data else []
+        }
+    else:  # 3year
+        # 3년 데이터는 월별만 호출 (기존 방식 유지)
+        monthly_data = get_monthly_trend_data(keywords, max_retries)
+        return monthly_data
+
+def calculate_monthly_volumes_v7(keywords, current_volumes, trend_data, period="1year"):
+    """개선된 월별 검색량 계산 - 정교한 역산 로직 적용"""
+    monthly_data = {}
+    
+    # 트렌드 데이터 확인
+    if isinstance(trend_data, dict) and 'daily_data' in trend_data and 'monthly_data' in trend_data:
+        # 새로운 이중 데이터 구조
+        daily_data = trend_data['daily_data']
+        monthly_data_api = trend_data['monthly_data']
+    else:
+        # 기존 단일 데이터 구조 (3year 등)
+        daily_data = None
+        monthly_data_api = trend_data
+    
+    if not monthly_data_api or "results" not in monthly_data_api:
+        logger.warning("월별 트렌드 데이터가 없어 계산을 건너뜁니다.")
+        return monthly_data
+    
+    logger.info(f"개선된 월별 검색량 계산 시작: {len(monthly_data_api['results'])}개 키워드")
+    
+    for result in monthly_data_api["results"]:
+        keyword = result["title"]
+        api_keyword = keyword.replace(" ", "")
+        
+        # 현재 검색량
+        volume_data = current_volumes.get(api_keyword, {"총검색량": 0})
+        current_volume = volume_data["총검색량"]
+        
+        if current_volume == 0:
+            logger.warning(f"'{keyword}' 현재 검색량이 0이므로 계산을 건너뜁니다.")
+            continue
+        
+        logger.info(f"'{keyword}' 처리 시작 - 현재 검색량: {current_volume:,}회")
+        
+        if period == "1year" and daily_data:
+            # 🔥 새로운 정교한 로직 적용
+            completed_year, completed_month = get_complete_month()
+            
+            # 1단계: 일별 데이터로 전월 정확한 검색량 계산
+            prev_month_volume = calculate_previous_month_from_daily(current_volume, daily_data)
+            
+            # 2단계: 전월을 기준으로 모든 월 검색량 역산
+            monthly_volumes, dates = calculate_all_months_from_previous(
+                prev_month_volume, monthly_data_api, completed_year, completed_month
+            )
+            
+            if not monthly_volumes:
+                logger.warning(f"'{keyword}' 월별 검색량 계산 실패")
+                continue
+            
+            # 3단계: 미래 3개월 예상 생성
+            predicted_volumes, predicted_dates = generate_future_from_growth_rate(
+                monthly_volumes, dates, completed_year, completed_month
+            )
+            
+            # 실제 + 예상 데이터 결합 - 최근 12개월 + 향후 3개월 = 총 15개월
+            # 최근 12개월만 실제 데이터로 제한
+            recent_12_months = monthly_volumes[-12:] if len(monthly_volumes) >= 12 else monthly_volumes
+            recent_12_dates = dates[-12:] if len(dates) >= 12 else dates
+            
+            all_volumes = recent_12_months + predicted_volumes
+            all_dates = recent_12_dates + predicted_dates
+            
+            # 증감율 계산 (예상 3개월)
+            growth_rate = calculate_future_3month_growth_rate(all_volumes, all_dates)
+            
+            monthly_data[keyword] = {
+                "monthly_volumes": all_volumes,  # 10% 감소 적용 전 - 총 15개월 (12개월 실제 + 3개월 예상)
+                "dates": all_dates,
+                "current_volume": current_volume,  # 10% 감소 적용 전
+                "growth_rate": growth_rate,
+                "volume_per_percent": prev_month_volume / 100 if prev_month_volume > 0 else 0,
+                "current_ratio": 100,
+                "actual_count": len(recent_12_months),  # 실제 12개월
+                "predicted_count": len(predicted_volumes)  # 예상 3개월
+            }
+            
+        else:
+            # 기존 방식 (3year 등)
+            if not result["data"]:
+                continue
+            
+            current_ratio = result["data"][-1]["ratio"]
+            if current_ratio == 0:
+                continue
+            
+            volume_per_percent = current_volume / current_ratio
+            
+            monthly_volumes = []
+            dates = []
+            
+            for data_point in result["data"]:
+                ratio = data_point["ratio"]
+                period_date = data_point["period"]
+                estimated_volume = int(volume_per_percent * ratio)
+                
+                monthly_volumes.append(estimated_volume)
+                dates.append(period_date)
+            
+            growth_rate = calculate_3year_growth_rate_improved(monthly_volumes)
+            
+            monthly_data[keyword] = {
+                "monthly_volumes": monthly_volumes,  # 10% 감소 적용 전
+                "dates": dates,
+                "current_volume": current_volume,  # 10% 감소 적용 전
+                "growth_rate": growth_rate,
+                "volume_per_percent": volume_per_percent,
+                "current_ratio": current_ratio,
+                "actual_count": len(monthly_volumes),
+                "predicted_count": 0
+            }
+        
+        logger.info(f"'{keyword}' 계산 완료 - 검색량 데이터 {len(monthly_data[keyword]['monthly_volumes'])}개")
+    
+    # 🔥 4단계: 최종 10% 감소 적용
+    final_data = apply_final_10_percent_reduction(monthly_data)
+    
+    logger.info("개선된 월별 검색량 계산 완료 (10% 감소 적용됨)")
+    return final_data
+
+# ===== 증감율 계산 함수들 (기존 유지) =====
+
+def calculate_future_3month_growth_rate(volumes, dates):
+    """예상 3개월 증감율 계산"""
+    if len(volumes) < 4:
+        return 0
+    
+    try:
+        completed_year, completed_month = get_complete_month()
+        
+        # 기준월 데이터 찾기
+        base_month_volume = None
+        for i, date_str in enumerate(dates):
+            try:
+                date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                if date_obj.year == completed_year and date_obj.month == completed_month:
+                    base_month_volume = volumes[i]
+                    break
+            except:
+                continue
+        
+        if base_month_volume is None:
+            return 0
+        
+        # 향후 3개월 예상 데이터 찾기
+        future_volumes = []
+        for month_offset in range(1, 4):
+            pred_year = completed_year
+            pred_month = completed_month + month_offset
+            
+            while pred_month > 12:
+                pred_month -= 12
+                pred_year += 1
+            
+            for i, date_str in enumerate(dates):
+                try:
+                    date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                    if date_obj.year == pred_year and date_obj.month == pred_month:
+                        future_volumes.append(volumes[i])
+                        break
+                except:
+                    continue
+        
+        if len(future_volumes) < 3:
+            return 0
+        
+        # 증감율 계산
+        future_average = sum(future_volumes) / len(future_volumes)
+        
+        if base_month_volume > 0:
+            growth_rate = ((future_average - base_month_volume) / base_month_volume) * 100
+            return min(max(growth_rate, -50), 100)
+        
+        return 0
+        
+    except Exception as e:
+        logger.error(f"예상 3개월 증감율 계산 오류: {e}")
+        return 0
+
+def calculate_3year_growth_rate_improved(volumes):
+    """3년 증감율 계산"""
+    if len(volumes) < 24:
+        return 0
+    
+    try:
+        first_year = volumes[:12]
+        last_year = volumes[-12:]
+        
+        first_year_avg = sum(first_year) / len(first_year)
+        last_year_avg = sum(last_year) / len(last_year)
+        
+        if first_year_avg == 0:
+            return 0
+        
+        growth_rate = ((last_year_avg - first_year_avg) / first_year_avg) * 100
+        return min(max(growth_rate, -50), 200)
+        
+    except Exception as e:
+        logger.error(f"3년 증감율 계산 오류: {e}")
+        return 0
+
+def calculate_correct_growth_rate(volumes, dates):
+    """작년 대비 증감율 계산"""
+    if len(volumes) < 13:
+        return 0
+    
+    try:
+        completed_year, completed_month = get_complete_month()
+        
+        this_year_volume = None
+        last_year_volume = None
+        
+        for i, date_str in enumerate(dates):
+            try:
+                date_obj = datetime.strptime(date_str, "%Y-%m-%d")
+                
+                if date_obj.year == completed_year and date_obj.month == completed_month:
+                    this_year_volume = volumes[i]
+                
+                if date_obj.year == completed_year - 1 and date_obj.month == completed_month:
+                    last_year_volume = volumes[i]
+                    
+            except:
+                continue
+        
+        if this_year_volume is not None and last_year_volume is not None and last_year_volume > 0:
+            growth_rate = ((this_year_volume - last_year_volume) / last_year_volume) * 100
+            return min(max(growth_rate, -50), 100)
+        
+        return 0
+        
+    except Exception as e:
+        logger.error(f"작년 대비 증감율 계산 오류: {e}")
+        return 0
+
+def generate_future_predictions_correct(volumes, dates, growth_rate):
+    """미래 예측 생성 (호환성 유지)"""
+    return generate_future_from_growth_rate(volumes, dates, *get_complete_month())
+
+# ===== 차트 생성 함수들 =====
+
+def create_enhanced_current_chart(volume_data, keyword):
+    """향상된 현재 검색량 정보 차트 - PC vs 모바일 비율 포함"""
+    total_vol = volume_data['총검색량']
+    pc_vol = volume_data['PC검색량']
+    mobile_vol = volume_data['모바일검색량']
+    
+    # 검색량 수준 평가
+    if total_vol >= 100000:
+        level_text = "높음 🔥"
+        level_color = "#dc3545"
+    elif total_vol >= 10000:
+        level_text = "중간 📊"
+        level_color = "#ffc107"
+    elif total_vol > 0:
+        level_text = "낮음 📉"
+        level_color = "#6c757d"
+    else:
+        level_text = "데이터 없음 ⚠️"
+        level_color = "#6c757d"
+    
+    # PC vs 모바일 비율
+    if total_vol > 0:
+        pc_ratio = (pc_vol / total_vol) * 100
+        mobile_ratio = (mobile_vol / total_vol) * 100
+    else:
+        pc_ratio = mobile_ratio = 0
+    
+    return f"""
+    <div style="width: 100%; padding: 30px; font-family: 'Pretendard', sans-serif; background: white; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);">
+        <!-- 검색량 수준 표시 -->
+        <div style="text-align: center; margin-bottom: 25px; padding: 20px; background: #f8f9fa; border-radius: 12px;">
+            <h4 style="margin: 0 0 15px 0; color: #495057; font-size: 20px;">📊 검색량 수준</h4>
+            <span style="display: inline-block; padding: 12px 24px; background: {level_color}; color: white; border-radius: 25px; font-weight: bold; font-size: 18px;">
+                {level_text}
+            </span>
+        </div>
+        
+        <!-- 검색량 상세 정보 -->
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 20px; margin-bottom: 25px;">
+            <div style="background: white; padding: 25px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); text-align: center; border: 1px solid #e9ecef;">
+                <div style="color: #007bff; font-size: 32px; font-weight: bold; margin-bottom: 8px;">{pc_vol:,}</div>
+                <div style="color: #6c757d; font-size: 16px; margin-bottom: 8px; font-weight: 600;">PC 검색량</div>
+                <div style="color: #007bff; font-size: 14px;">({pc_ratio:.1f}%)</div>
+            </div>
+            <div style="background: white; padding: 25px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); text-align: center; border: 1px solid #e9ecef;">
+                <div style="color: #28a745; font-size: 32px; font-weight: bold; margin-bottom: 8px;">{mobile_vol:,}</div>
+                <div style="color: #6c757d; font-size: 16px; margin-bottom: 8px; font-weight: 600;">모바일 검색량</div>
+                <div style="color: #28a745; font-size: 14px;">({mobile_ratio:.1f}%)</div>
+            </div>
+            <div style="background: white; padding: 25px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); text-align: center; border: 1px solid #e9ecef;">
+                <div style="color: #dc3545; font-size: 32px; font-weight: bold; margin-bottom: 8px;">{total_vol:,}</div>
+                <div style="color: #6c757d; font-size: 16px; margin-bottom: 8px; font-weight: 600;">총 검색량</div>
+                <div style="color: #dc3545; font-size: 14px;">(100%)</div>
+            </div>
+        </div>
+        
+        <!-- 비율 바 차트 -->
+        <div style="background: white; padding: 20px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); border: 1px solid #e9ecef;">
+            <h5 style="margin: 0 0 20px 0; color: #495057; text-align: center; font-size: 18px;">PC vs 모바일 비율</h5>
+            <div style="display: flex; height: 25px; border-radius: 15px; overflow: hidden; background: #e9ecef;">
+                <div style="background: #007bff; width: {pc_ratio}%; display: flex; align-items: center; justify-content: center; font-size: 14px; color: white; font-weight: bold;">
+                    {f'PC {pc_ratio:.1f}%' if pc_ratio > 15 else ''}
+                </div>
+                <div style="background: #28a745; width: {mobile_ratio}%; display: flex; align-items: center; justify-content: center; font-size: 14px; color: white; font-weight: bold;">
+                    {f'모바일 {mobile_ratio:.1f}%' if mobile_ratio > 15 else ''}
+                </div>
+            </div>
+        </div>
+        
+        <div style="margin-top: 20px; padding: 15px; background: #fff3cd; border-radius: 8px; text-align: center;">
+            <p style="margin: 0; font-size: 14px; color: #856404;">
+                📊 <strong>트렌드 분석 시스템</strong>: 네이버 데이터랩 기반 정확한 검색량 분석
+            </p>
+        </div>
+    </div>
+    """
+
+def create_visual_trend_chart(monthly_data_1year, monthly_data_3year):
+    """시각적 트렌드 차트 생성"""
+    try:
+        chart_html = f"""
+        <div style="width: 100%; margin: 20px auto; font-family: 'Pretendard', sans-serif;">
+        """
+        
+        periods = [
+            {"data": monthly_data_1year, "title": "최근 1년 + 향후 3개월 예상 (정교한 역산)", "period": "1year"},
+            {"data": monthly_data_3year, "title": "최근 3년 (10% 보정 적용)", "period": "3year"}
+        ]
+        
+        colors = ['#FB7F0D', '#4ECDC4', '#45B7D1', '#96CEB4', '#FF6B6B']
+        
+        for period_info in periods:
+            monthly_data = period_info["data"]
+            period_title = period_info["title"]
+            period_code = period_info["period"]
+            
+            if not monthly_data:
+                chart_html += f"""
+                <div style="width: 100%; background: white; padding: 20px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); margin-bottom: 30px; border: 1px solid #e9ecef;">
+                    <h4 style="text-align: center; color: #666; margin: 20px 0;">{period_title} - 트렌드 데이터가 없습니다.</h4>
+                </div>
+                """
+                continue
+            
+            chart_html += f"""
+            <div style="width: 100%; background: white; padding: 25px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); margin-bottom: 30px; border: 1px solid #e9ecef;">
+                <h4 style="text-align: center; color: #333; margin-bottom: 25px; font-size: 18px; border-bottom: 2px solid #FB7F0D; padding-bottom: 10px;">
+                    🚀 {period_title}
+                </h4>
+            """
+            
+            # 각 키워드별로 차트 생성
+            for i, (keyword, data) in enumerate(monthly_data.items()):
+                volumes = data["monthly_volumes"]
+                dates = data["dates"]
+                growth_rate = data["growth_rate"]
+                actual_count = data.get("actual_count", len(volumes))
+                
+                if not volumes:
+                    continue
+                
+                # 차트 색상
+                color = colors[i % len(colors)]
+                predicted_color = f"{color}80"  # 50% 투명도
+                
+                # Y축을 0부터 최대값까지로 설정
+                max_volume = max(volumes) if volumes else 1
+                
+                chart_html += f"""
+                <div style="width: 100%; margin-bottom: 30px; border: 1px solid #e9ecef; border-radius: 8px; overflow: hidden;">
+                    <div style="padding: 20px; background: white;">
+                        <h5 style="margin: 0 0 20px 0; color: #333; font-size: 16px;">
+                            {keyword} ({get_growth_rate_label(period_code)}: {growth_rate:+.1f}%)
+                        </h5>
+                        
+                        <!-- 차트 영역 -->
+                        <div style="position: relative; height: 350px; margin: 30px 0 60px 80px; border-left: 2px solid #333; border-bottom: 2px solid #333; padding: 10px;">
+                            
+                            <!-- Y축 라벨 -->
+                            <div style="position: absolute; left: -70px; top: -10px; width: 60px; text-align: right; font-size: 11px; color: #333; font-weight: bold;">
+                                {max_volume:,}
+                            </div>
+                            <div style="position: absolute; left: -70px; top: 50%; transform: translateY(-50%); width: 60px; text-align: right; font-size: 10px; color: #666;">
+                                {max_volume // 2:,}
+                            </div>
+                            <div style="position: absolute; left: -70px; bottom: -5px; width: 60px; text-align: right; font-size: 10px; color: #666;">
+                                0
+                            </div>
+                            
+                            <!-- X축 그리드 라인 -->
+                            <div style="position: absolute; top: 0; left: 0; right: 0; height: 1px; background: #eee;"></div>
+                            <div style="position: absolute; top: 50%; left: 0; right: 0; height: 1px; background: #eee;"></div>
+                            <div style="position: absolute; bottom: 0; left: 0; right: 0; height: 1px; background: #333;"></div>
+                            
+                            <!-- 차트 바 컨테이너 -->
+                            <div style="display: flex; align-items: end; height: 100%; gap: 1px; padding: 5px 0;">
+                """
+                
+                # 데이터와 날짜를 시간순으로 정렬
+                chart_data = list(zip(dates, volumes, range(len(volumes))))
+                chart_data.sort(key=lambda x: x[0])  # 날짜순 정렬
+                
+                # 막대 차트 생성
+                for date, volume, original_index in chart_data:
+                    # 막대 높이 계산
+                    height_percent = (volume / max_volume) * 100 if max_volume > 0 else 0
+                    
+                    # 실제 데이터와 예상 데이터 구분
+                    is_predicted = original_index >= actual_count
+                    bar_color = predicted_color if is_predicted else color
+                    
+                    # 날짜 포맷
+                    try:
+                        date_obj = datetime.strptime(date, "%Y-%m-%d")
+                        year_short = str(date_obj.year)[-2:]
+                        month_num = date_obj.month
+                        
+                        if is_predicted:
+                            date_formatted = f"{year_short}.{month_num:02d}"
+                            full_date = date_obj.strftime("%Y년 %m월") + " (예상)"
+                            bar_style = f"border: 2px dashed #333; background: repeating-linear-gradient(90deg, {bar_color}, {bar_color} 5px, transparent 5px, transparent 10px);"
+                        else:
+                            date_formatted = f"{year_short}.{month_num:02d}"
+                            full_date = date_obj.strftime("%Y년 %m월")
+                            bar_style = f"background: linear-gradient(to top, {bar_color}, {bar_color}dd);"
+                    except:
+                        date_formatted = date[-5:].replace('-', '.')
+                        full_date = date
+                        bar_style = f"background: linear-gradient(to top, {bar_color}, {bar_color}dd);"
+                    
+                    # 고유 ID 생성
+                    chart_id = f"bar_{period_code}_{i}_{original_index}"
+                    
+                    chart_html += f"""
+                    <div style="flex: 1; display: flex; flex-direction: column; align-items: center; position: relative; height: 100%;">
+                        <!-- 막대 -->
+                        <div id="{chart_id}" style="
+                            {bar_style}
+                            width: 100%;
+                            height: {height_percent}%;
+                            border-radius: 3px 3px 0 0;
+                            position: relative;
+                            cursor: pointer;
+                            transition: all 0.3s ease;
+                            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                            min-height: 3px;
+                            margin-top: auto;
+                        "
+                        onmouseover="
+                            this.style.transform='scaleX(1.1)'; 
+                            this.style.zIndex='10'; 
+                            this.style.boxShadow='0 4px 8px rgba(0,0,0,0.3)';
+                            document.getElementById('tooltip_{chart_id}').style.display='block';
+                        "
+                        onmouseout="
+                            this.style.transform='scaleX(1)'; 
+                            this.style.zIndex='1'; 
+                            this.style.boxShadow='0 2px 4px rgba(0,0,0,0.1)';
+                            document.getElementById('tooltip_{chart_id}').style.display='none';
+                        ">
+                            <!-- 툴팁 -->
+                            <div id="tooltip_{chart_id}" style="
+                                display: none;
+                                position: absolute;
+                                bottom: calc(100% + 10px);
+                                left: 50%;
+                                transform: translateX(-50%);
+                                background: rgba(0,0,0,0.9);
+                                color: white;
+                                padding: 8px 12px;
+                                border-radius: 6px;
+                                font-size: 11px;
+                                white-space: nowrap;
+                                z-index: 1000;
+                                box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+                                pointer-events: none;
+                            ">
+                                <div style="text-align: center;">
+                                    <div style="font-weight: bold; color: white; margin-bottom: 2px;">{full_date}</div>
+                                    <div style="color: #ffd700;">검색량: {volume:,}회</div>
+                                    {'<div style="color: #ff6b6b; margin-top: 2px; font-size: 10px;">예상 데이터</div>' if is_predicted else '<div style="color: #90EE90; margin-top: 2px; font-size: 10px;">실제 데이터</div>'}
+                                </div>
+                                <!-- 화살표 -->
+                                <div style="
+                                    position: absolute;
+                                    top: 100%;
+                                    left: 50%;
+                                    transform: translateX(-50%);
+                                    width: 0;
+                                    height: 0;
+                                    border-left: 5px solid transparent;
+                                    border-right: 5px solid transparent;
+                                    border-top: 5px solid rgba(0,0,0,0.9);
+                                "></div>
+                            </div>
+                        </div>
+                    </div>
+                    """
+                
+                chart_html += f"""
+                            </div>
+                            
+                            <!-- 월 라벨 -->
+                            <div style="display: flex; gap: 1px; margin-top: 10px; padding: 0 5px;">
+                """
+                
+                # 월 라벨 생성
+                for date, volume, original_index in chart_data:
+                    is_predicted = original_index >= actual_count
+                    
+                    try:
+                        date_obj = datetime.strptime(date, "%Y-%m-%d")
+                        year_short = str(date_obj.year)[-2:]
+                        month_num = date_obj.month
+                        date_formatted = f"{year_short}.{month_num:02d}"
+                    except:
+                        date_formatted = date[-5:].replace('-', '.')
+                    
+                    chart_html += f"""
+                    <div style="
+                        flex: 1; 
+                        text-align: center; 
+                        font-size: 9px; 
+                        color: {'#e74c3c' if is_predicted else '#666'}; 
+                        font-weight: {'bold' if is_predicted else 'normal'};
+                        transform: rotate(-45deg);
+                        transform-origin: center;
+                        line-height: 1;
+                        margin-top: 8px;
+                    ">
+                        {date_formatted}
+                    </div>
+                    """
+                
+                # 통계 정보
+                if period_code == "1year":
+                    actual_volumes = volumes[:actual_count]  # 실제 데이터만
+                else:
+                    actual_volumes = volumes  # 3년 전체 데이터
+                
+                avg_volume = sum(actual_volumes) // len(actual_volumes) if actual_volumes else 0
+                max_volume_val = max(actual_volumes) if actual_volumes else 0
+                min_volume_val = min(actual_volumes) if actual_volumes else 0
+                
+                chart_html += f"""
+                            </div>
+                        </div>
+                        
+                        <!-- 범례 -->
+                        <div style="display: flex; justify-content: center; gap: 20px; margin: 15px 0; font-size: 12px;">
+                            <div style="display: flex; align-items: center; gap: 5px;">
+                                <div style="width: 15px; height: 15px; background: {color}; border-radius: 2px;"></div>
+                                <span style="color: #333;">실제 데이터</span>
+                            </div>
+                            <div style="display: flex; align-items: center; gap: 5px;">
+                                <div style="width: 15px; height: 15px; background: repeating-linear-gradient(90deg, {predicted_color}, {predicted_color} 3px, transparent 3px, transparent 6px); border: 1px dashed #333; border-radius: 2px;"></div>
+                                <span style="color: #e74c3c;">예상 데이터</span>
+                            </div>
+                        </div>
+                        
+                        <!-- 통계 정보 -->
+                        <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; margin-top: 20px;">
+                            <div style="text-align: center; padding: 12px; background: white; border-radius: 8px; box-shadow: 0 2px 6px rgba(0,0,0,0.1); border: 1px solid #e9ecef;">
+                                <div style="font-size: 16px; font-weight: bold; color: #3498db;">{min_volume_val:,}</div>
+                                <div style="font-size: 11px; color: #666;">최저검색량</div>
+                            </div>
+                            <div style="text-align: center; padding: 12px; background: white; border-radius: 8px; box-shadow: 0 2px 6px rgba(0,0,0,0.1); border: 1px solid #e9ecef;">
+                                <div style="font-size: 16px; font-weight: bold; color: #2ecc71;">{avg_volume:,}</div>
+                                <div style="font-size: 11px; color: #666;">평균검색량</div>
+                            </div>
+                            <div style="text-align: center; padding: 12px; background: white; border-radius: 8px; box-shadow: 0 2px 6px rgba(0,0,0,0.1); border: 1px solid #e9ecef;">
+                                <div style="font-size: 16px; font-weight: bold; color: #e74c3c;">{max_volume_val:,}</div>
+                                <div style="font-size: 11px; color: #666;">최고검색량</div>
+                            </div>
+                            <div style="text-align: center; padding: 12px; background: white; border-radius: 8px; box-shadow: 0 2px 6px rgba(0,0,0,0.1); border: 1px solid #e9ecef;">
+                                <div style="font-size: 16px; font-weight: bold; color: #27ae60;">{growth_rate:+.1f}%</div>
+                                <div style="font-size: 11px; color: #666;">{get_growth_rate_label(period_code)}</div>
+                            </div>
+                        </div>
+                """
+                
+                # 개선 설명
+                if period_code == "1year":
+                    chart_html += f"""
+                    <div style="margin-top: 15px; padding: 12px; background: #e8f5e8; border-radius: 8px; text-align: center;">
+                        <p style="margin: 0; font-size: 13px; color: #155724;">
+                            📊 <strong>최근 1년 + 향후 3개월 예상</strong>: 실색 막대(실제), 빗금 막대(예상)
+                        </p>
+                    </div>
+                    """
+                else:
+                    chart_html += f"""
+                    <div style="margin-top: 15px; padding: 12px; background: #e3f2fd; border-radius: 8px; text-align: center;">
+                        <p style="margin: 0; font-size: 13px; color: #1565c0;">
+                            📊 <strong>최근 3년 트렌드</strong>: 전체 기간 검색량 데이터
+                        </p>
+                    </div>
+                    """
+                
+                chart_html += """
+                    </div>
+                </div>
+                """
+            
+            chart_html += "</div>"
+        
+        chart_html += "</div>"
+        
+        logger.info(f"개선된 정교한 트렌드 차트 생성 완료")
+        return chart_html
+        
+    except Exception as e:
+        logger.error(f"차트 생성 오류: {e}")
+        return f"""
+        <div style="padding: 20px; background: #f8d7da; border-radius: 8px; color: #721c24;">
+            <h4>차트 생성 오류</h4>
+            <p>오류: {str(e)}</p>
+        </div>
+        """
+
+def create_trend_chart_v7(monthly_data_1year, monthly_data_3year):
+    """개선된 트렌드 차트 생성"""
+    try:
+        chart_html = create_visual_trend_chart(monthly_data_1year, monthly_data_3year)
+        return chart_html
+        
+    except Exception as e:
+        logger.error(f"차트 생성 오류: {e}")
+        return f"""
+        <div style="padding: 20px; background: #f8d7da; border-radius: 8px; color: #721c24;">
+            <h4>차트 생성 오류</h4>
+            <p>오류: {str(e)}</p>
+        </div>
+        """
+
+def get_growth_rate_label(period_code):
+    """기간에 따른 성장률 라벨 반환"""
+    if period_code == "1year":
+        return "예상 3개월 증감율"
+    else:  # 3year
+        return "작년대비 증감율"
+
+def create_error_chart(error_msg):
+    """에러 발생시 대체 차트"""
+    return f"""
+    <div style="padding: 20px; background: #f8d7da; border-radius: 8px; color: #721c24;">
+        <h4>차트 생성 오류</h4>
+        <p>오류: {error_msg}</p>
+    </div>
+    """
+
+# ===== 호환성 함수들 (기존 코드와의 호환성 유지) =====
+
+def get_naver_trend_data_v4(keywords, period="1year", max_retries=3):
+    """기존 함수 호환성 유지"""
+    return get_naver_trend_data_v5(keywords, period, max_retries)
+
+def calculate_monthly_volumes_v6(keywords, current_volumes, trend_data, period="1year"):
+    """기존 함수 호환성 유지"""
+    return calculate_monthly_volumes_v7(keywords, current_volumes, trend_data, period)
+
+def calculate_monthly_volumes_v5(keywords, current_volumes, trend_data, period="1year"):
+    """기존 함수 호환성 유지"""
+    return calculate_monthly_volumes_v7(keywords, current_volumes, trend_data, period)
+
+def create_trend_chart_v6(monthly_data_1year, monthly_data_3year):
+    """기존 함수 호환성 유지"""
+    return create_trend_chart_v7(monthly_data_1year, monthly_data_3year)