Upload 15 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,46 +1,62 @@
+# -*- coding: utf-8 -*-
+"""
+AI 상품 소싱 분석 시스템 v2.9 - 출력 기능 추가 + 멀티사용자 안전
+- 연관검색어 엑셀 출력
+- 키워드 심충분석 HTML 출력
+- 압축파일로 결과 다운로드
+- Gemini API 키 통합 관리
+- 한국시간 적용
+- 멀티 사용자 안전: 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 pytz  # 한국시간 적용을 위한 추가
 import time
-import tempfile
-import zipfile
 import re
-import json
+from collections import Counter
+import zipfile
+import tempfile
 
 # 로깅 설정
-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 text_utils
+import keyword_search
+import product_search
+import keyword_processor
+import export_utils
+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_ENDPOINT 환경변수가 설정되지 않았습니다.")
-            raise ValueError("API_ENDPOINT 환경변수가 설정되지 않았습니다.")
-        
-        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():
     """한국시간 반환"""
@@ -61,108 +77,427 @@ def format_korean_datetime(dt=None, format_type="filename"):
     else:
         return dt.strftime("%y%m%d_%H%M")
 
-# ===== 데이터 처리 및 검증 함수들 =====
-def create_export_data_from_html(analysis_keyword, main_keyword, analysis_html, step1_data=None):
-    """분석 HTML과 1단계 데이터를 기반으로 export용 데이터 구조 생성 (더미 데이터 제거)"""
-    logger.info("=== 📊 Export 데이터 구조 생성 시작 (더미 데이터 제거 버전) ===")
-    
-    # 기본 export 데이터 구조
-    export_data = {
-        "main_keyword": main_keyword or analysis_keyword,
-        "analysis_keyword": analysis_keyword,
-        "analysis_html": analysis_html,
-        "main_keywords_df": None,
-        "related_keywords_df": None,
-        "analysis_completed": True,
-        "created_at": get_korean_time().isoformat()
+# ===== 출력 전용 상태 변수 제거 (멀티 사용자 안전을 위해 gr.State 사용) =====
+# export_state 전역 변수 제거 - 멀티 사용자 환경에서 데이터 혼합 문제 해결
+
+# ===== 연관검색어 분석 기능 =====
+def analyze_related_keywords(keyword):
+    """연관검색어 분석 - 네이버 상품 40개를 기반으로 복합키워드 추출"""
+    logger.info(f"연관검색어 분석 시작: '{keyword}'")
+    
+    try:
+        # 1단계: 네이버 상품 40개 추출
+        api_keyword = keyword.replace(" ", "")
+        products_data = []
+        
+        # 40개 상품을 가져오기 위해 여러 페이지 호출
+        for page in range(1, 5):  # 4페이지 * 10개 = 40개
+            result = product_search.fetch_products_by_keyword(api_keyword, page=page, display=10)
+            if result["status"] == "success" and result["products"]:
+                products_data.extend(result["products"])
+            else:
+                break
+            time.sleep(0.3)  # API 레이트 리밋 방지
+        
+        if not products_data:
+            return {
+                "status": "error",
+                "message": f"'{keyword}' 키워드로 상품을 찾을 수 없습니다.",
+                "keywords_df": pd.DataFrame()
+            }
+        
+        # 실제 가져온 상품 수 제한
+        products_data = products_data[:40]
+        logger.info(f"상품 추출 완료: {len(products_data)}개")
+        
+        # 2단계: 상품명에서 키워드 추출 (스페이스바로 분류)
+        all_words = []
+        for product in products_data:
+            title = product.get("상품명", "")
+            # 공백과 쉼표로 분리
+            words = re.split(r'[,\s]+', title)
+            all_words.extend([word.strip() for word in words if word.strip() and len(word.strip()) >= 1])
+        
+        # 중복 제거
+        unique_words = list(set(all_words))
+        logger.info(f"추출된 단어 수: {len(unique_words)}개")
+        
+        # 3단계: 분석할 키워드를 앞뒤로 붙여서 복합키워드 생성
+        compound_keywords = []
+        main_keyword = keyword.strip()
+        
+        for word in unique_words:
+            if word != main_keyword and len(word) >= 2:  # 단일 글자 제외
+                # 앞에 붙이기
+                front_compound = f"{word} {main_keyword}"
+                compound_keywords.append(front_compound)
+                
+                # 뒤에 붙이기
+                back_compound = f"{main_keyword} {word}"
+                compound_keywords.append(back_compound)
+        
+        # 중복 제거
+        compound_keywords = list(set(compound_keywords))
+        logger.info(f"생성된 복합키워드 수: {len(compound_keywords)}개")
+        
+        # 4단계: 검색량 추출
+        api_keywords = [kw.replace(" ", "") for kw in compound_keywords]
+        search_volumes = keyword_search.fetch_all_search_volumes(api_keywords)
+        
+        # 5단계: 앞뒤 키워드 중 높은 것 선택, 낮은 것 제거
+        keyword_pairs = {}  # {base_word: {"front": front_kw, "back": back_kw, "front_vol": vol, "back_vol": vol}}
+        
+        for word in unique_words:
+            if word != main_keyword and len(word) >= 2:
+                front_kw = f"{word} {main_keyword}"
+                back_kw = f"{main_keyword} {word}"
+                
+                front_api = front_kw.replace(" ", "")
+                back_api = back_kw.replace(" ", "")
+                
+                front_vol = search_volumes.get(front_api, {}).get("총검색량", 0)
+                back_vol = search_volumes.get(back_api, {}).get("총검색량", 0)
+                
+                keyword_pairs[word] = {
+                    "front": front_kw,
+                    "back": back_kw,
+                    "front_vol": front_vol,
+                    "back_vol": back_vol
+                }
+        
+        # 6단계: 높은 검색량의 키워드만 선택
+        final_keywords = []
+        for word, data in keyword_pairs.items():
+            if data["front_vol"] > data["back_vol"]:
+                selected_kw = data["front"]
+                selected_vol = data["front_vol"]
+                selected_api = selected_kw.replace(" ", "")
+            elif data["back_vol"] > data["front_vol"]:
+                selected_kw = data["back"]
+                selected_vol = data["back_vol"]
+                selected_api = selected_kw.replace(" ", "")
+            elif data["front_vol"] == data["back_vol"] and data["front_vol"] > 0:
+                # 같은 검색량이면 자연스러운 순서 선택 (일반적으로 뒤에 붙이는 것이 자연스러움)
+                selected_kw = data["back"]
+                selected_vol = data["back_vol"]
+                selected_api = selected_kw.replace(" ", "")
+            else:
+                # 둘 다 0이면 제외
+                continue
+            
+            if selected_vol > 0:  # 검색량이 있는 것만 포함
+                vol_data = search_volumes.get(selected_api, {})
+                final_keywords.append({
+                    "연관 키워드": selected_kw,
+                    "PC검색량": vol_data.get("PC검색량", 0),
+                    "모바일검색량": vol_data.get("모바일검색량", 0),
+                    "총검색량": selected_vol,
+                    "검색량구간": text_utils.get_search_volume_range(selected_vol)
+                })
+        
+        # 검색량 기준으로 내림차순 정렬
+        final_keywords = sorted(final_keywords, key=lambda x: x["총검색량"], reverse=True)
+        
+        # DataFrame 생성
+        df_keywords = pd.DataFrame(final_keywords)
+        
+        logger.info(f"연관검색어 분석 완료: {len(final_keywords)}개 키워드")
+        
+        return {
+            "status": "success",
+            "message": f"'{keyword}' 연관검색어 {len(final_keywords)}개를 찾았습니다.",
+            "keywords_df": df_keywords,
+            "total_products": len(products_data)
+        }
+        
+    except Exception as e:
+        logger.error(f"연관검색어 분석 오류: {e}")
+        return {
+            "status": "error",
+            "message": f"연관검색어 분석 중 오류가 발생했습니다: {str(e)}",
+            "keywords_df": pd.DataFrame()
+        }
+
+# ===== 로딩 애니메이션 =====
+def create_loading_animation():
+    """로딩 애니메이션 HTML"""
+    return """
+    <div style="display: flex; flex-direction: column; align-items: center; padding: 40px; background: white; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);">
+        <div style="width: 60px; height: 60px; border: 4px solid #f3f3f3; border-top: 4px solid #FB7F0D; border-radius: 50%; animation: spin 1s linear infinite; margin-bottom: 20px;"></div>
+        <h3 style="color: #FB7F0D; margin: 10px 0; font-size: 18px;">분석 중입니다...</h3>
+        <p style="color: #666; margin: 5px 0; text-align: center;">네이버 데이터를 수집하고 AI가 분석하고 있습니다.<br>잠시만 기다려주세요.</p>
+        <div style="width: 200px; height: 4px; background: #f0f0f0; border-radius: 2px; margin-top: 15px; overflow: hidden;">
+            <div style="width: 100%; height: 100%; background: linear-gradient(90deg, #FB7F0D, #ff9a8b); border-radius: 2px; animation: progress 2s ease-in-out infinite;"></div>
+        </div>
+    </div>
+    
+    <style>
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
     }
     
-    # 1단계 데이터에서 main_keywords_df 추출 (실제 데이터만)
-    if step1_data and isinstance(step1_data, dict):
-        if "keywords_df" in step1_data:
-            keywords_df = step1_data["keywords_df"]
-            if isinstance(keywords_df, dict):
-                try:
-                    export_data["main_keywords_df"] = pd.DataFrame(keywords_df)
-                    logger.info(f"✅ 1단계 키워드 데이터를 DataFrame으로 변환: {export_data['main_keywords_df'].shape}")
-                except Exception as e:
-                    logger.warning(f"⚠️ 1단계 데이터 변환 실패: {e}")
-                    export_data["main_keywords_df"] = None
-            elif hasattr(keywords_df, 'shape'):
-                export_data["main_keywords_df"] = keywords_df
-                logger.info(f"✅ 1단계 키워드 DataFrame 사용: {keywords_df.shape}")
+    @keyframes progress {
+        0% { transform: translateX(-100%); }
+        100% { transform: translateX(100%); }
+    }
+    </style>
+    """
+
+# ===== 에러 처리 함수 =====
+def generate_error_response(error_message):
+    """에러 응답 생성"""
+    return f'''
+    <div style="color: red; padding: 30px; text-align: center; width: 100%; 
+                background-color: #f8d7da; border-radius: 12px; border: 1px solid #f5c6cb;">
+        <h3 style="margin-bottom: 15px;">❌ 분석 오류</h3>
+        <p style="margin-bottom: 20px;">{error_message}</p>
+        <div style="background: white; padding: 15px; border-radius: 8px; color: #333;">
+            <h4>해결 방법:</h4>
+            <ul style="text-align: left; padding-left: 20px;">
+                <li>키워드 철자를 확인해주세요</li>
+                <li>더 간단한 키워드를 사용해보세요</li>
+                <li>네트워크 연결을 확인해주세요</li>
+                <li>잠시 후 다시 시도해주세요</li>
+            </ul>
+        </div>
+    </div>
+    '''
+
+# ===== 메인 키워드 분석 함수 =====
+def safe_keyword_analysis(analysis_keyword, base_keyword, keywords_data):
+    """에러 방지를 위한 안전한 키워드 분석 - 세션별 데이터 반환"""
+    
+    # 입력값 검증
+    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>2단계에서 제안한 키워드 목록을 참고해주세요</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("📋 1단계 키워드 데이터가 유효하지 않음 - None으로 유지")
-                export_data["main_keywords_df"] = None
-    
-    # 분석 HTML에서 연관검색어 정보 추출 시도 (실제 데이터만)
-    if analysis_html and "연관검색어 분석" in analysis_html:
-        logger.info("🔍 분석 HTML에서 연관검색어 정보 발견 - 실제 파싱 필요")
-        # 실제 HTML 파싱 로직이 필요한 부분
-        # 현재는 더미 데이터 대신 None으로 유지
-        export_data["related_keywords_df"] = None
-        logger.info("💡 실제 HTML 파싱 로직 구현 필요 - 연관검색어 데이터는 None으로 유지")
-    
-    logger.info(f"📊 Export 데이터 구조 생성 완료 (더미 데이터 없음):")
-    logger.info(f"   - analysis_keyword: {export_data['analysis_keyword']}")
-    logger.info(f"   - main_keywords_df: {export_data['main_keywords_df'].shape if export_data['main_keywords_df'] is not None else 'None'}")
-    logger.info(f"   - related_keywords_df: {export_data['related_keywords_df'].shape if export_data['related_keywords_df'] is not None else 'None'}")
-    logger.info(f"   - analysis_html: {len(str(export_data['analysis_html']))} 문자")
-    
-    return export_data
+                logger.info("데이터랩 API 키가 설정되지 않음")
+        except Exception as e:
+            logger.info(f"트렌드 분석 건너뜀: {str(e)[:100]}")
+        
+        # 키워드 데이터 준비
+        step2_keywords_df = keywords_data.get("keywords_df") if keywords_data else None
+        filtered_keywords_df = step2_keywords_df  # 단순히 원본 데이터 사용
+        target_categories = []  # 빈 리스트
+        
+        # === 📈 검색량 트렌드 분석 섹션 ===
+        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,
+            filtered_keywords_df, target_categories, 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 = {
+            "main_keyword": base_keyword,
+            "analysis_keyword": analysis_keyword,
+            "main_keywords_df": keywords_data.get("keywords_df") if keywords_data else None,
+            "related_keywords_df": None,  # 여기서는 연관검색어 분석하지 않음
+            "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 validate_and_repair_export_data(export_data):
-    """Export 데이터 유효성 검사 및 복구 (더미 데이터 제거)"""
-    logger.info("🔧 Export 데이터 유효성 검사 및 복구 시작 (더미 데이터 제거 버전)")
+# ===== 2단계: 상품 데이터 기반 키워드 추출 =====
+def extract_keywords_from_products(keyword):
+    """네이버 쇼핑에서 실제 상품 데이터를 수집하고 모든 키워드 표시"""
+    logger.info(f"상품 키워드 추출 시작: 키워드='{keyword}'")
+
+    api_keyword = keyword_analysis.normalize_keyword_for_api(keyword)
+    search_results = product_search.fetch_naver_shopping_data(
+        keyword, korean_only=True, apply_main_keyword=True, exclude_zero_volume=True
+    )
     
-    if not export_data or not isinstance(export_data, dict):
-        logger.warning("⚠️ Export 데이터가 없거나 딕셔너리가 아님 - 기본 구조 생성")
+    if not search_results.get("product_list"):
         return {
-            "main_keyword": "기본키워드",
-            "analysis_keyword": "기본분석키워드",
-            "analysis_html": "<div>기본 분석 결과</div>",
-            "main_keywords_df": None,  # 더미 데이터 대신 None
-            "related_keywords_df": None,  # 더미 데이터 대신 None
-            "analysis_completed": True
+            "status": "error",
+            "message": "상품 데이터를 가져올 수 없습니다.",
+            "products": [],
+            "keywords": []
         }
     
-    # 필수 키들 확인 및 복구
-    required_keys = {
-        "analysis_keyword": "분석키워드",
-        "main_keyword": "메인키워드", 
-        "analysis_html": "<div>분석 완료</div>",
-        "analysis_completed": True
-    }
+    processed_results = keyword_processor.process_search_results(
+        search_results, keyword, exclude_zero_volume=True
+    )
     
-    for key, default_value in required_keys.items():
-        if key not in export_data or not export_data[key]:
-            export_data[key] = default_value
-            logger.info(f"🔧 {key} 키 복구: {default_value}")
+    df_keywords = processed_results["keywords_df"]
+    df_products = processed_results["products_df"]
     
-    # DataFrame 데이터 검증 및 변환 (더미 데이터 생성 안함)
-    for df_key in ["main_keywords_df", "related_keywords_df"]:
-        if df_key in export_data and export_data[df_key] is not None:
-            df_data = export_data[df_key]
-            
-            # 딕셔너리를 DataFrame으로 변환
-            if isinstance(df_data, dict):
-                try:
-                    # 빈 딕셔너리는 None으로 처리
-                    if not df_data:
-                        export_data[df_key] = None
-                        logger.info(f"📋 {df_key} 빈 딕셔너리 - None으로 설정")
-                    else:
-                        export_data[df_key] = pd.DataFrame(df_data)
-                        logger.info(f"✅ {df_key} 딕셔너리를 DataFrame으로 변환 성공")
-                except Exception as e:
-                    logger.warning(f"⚠️ {df_key} 변환 실패: {e}")
-                    export_data[df_key] = None
-            elif not hasattr(df_data, 'shape'):
-                logger.warning(f"⚠️ {df_key}가 DataFrame이 아님 - None으로 설정")
-                export_data[df_key] = None
-    
-    logger.info("✅ Export 데이터 유효성 검사 및 복구 완료 (더미 데이터 없음)")
-    return export_data
+    if df_keywords.empty:
+        return {
+            "status": "error", 
+            "message": "추출된 키워드가 없습니다.",
+            "products": [],
+            "keywords": []
+        }
+    
+    logger.info(f"키워드 추출 완료: 총 {len(df_keywords)}개 키워드")
+    
+    return {
+        "status": "success",
+        "message": "키워드 추출 완료",
+        "products": df_products,
+        "keywords_df": df_keywords,
+        "categories": processed_results["categories"]
+    }
 
 # ===== 파일 출력 함수들 =====
 def create_timestamp_filename(analysis_keyword):
@@ -173,16 +508,8 @@ def create_timestamp_filename(analysis_keyword):
     return f"{safe_keyword}_{timestamp}_분석결과"
 
 def export_to_excel(main_keyword, main_keywords_df, analysis_keyword, related_keywords_df, filename_base):
-    """엑셀 파일로 출력 (실제 데이터만)"""
+    """엑셀 파일로 출력"""
     try:
-        # 실제 데��터가 있는지 확인
-        has_main_data = main_keywords_df is not None and not main_keywords_df.empty
-        has_related_data = related_keywords_df is not None and not related_keywords_df.empty
-        
-        if not has_main_data and not has_related_data:
-            logger.info("📋 생성할 데이터가 없어 엑셀 파일 생성 건너뜀")
-            return None
-        
         excel_filename = f"{filename_base}.xlsx"
         excel_path = os.path.join(tempfile.gettempdir(), excel_filename)
         
@@ -214,8 +541,8 @@ def export_to_excel(main_keyword, main_keywords_df, analysis_keyword, related_ke
                 'border': 1
             })
             
-            # 첫 번째 시트: 메인키워드 조합키워드 (실제 데이터만)
-            if has_main_data:
+            # 첫 번째 시트: 메인키워드 조합키워드
+            if main_keywords_df is not None and not main_keywords_df.empty:
                 main_keywords_df.to_excel(writer, sheet_name=f'{main_keyword}_조합키워드', index=False)
                 worksheet1 = writer.sheets[f'{main_keyword}_조합키워드']
                 
@@ -226,7 +553,7 @@ def export_to_excel(main_keyword, main_keywords_df, analysis_keyword, related_ke
                 # 데이터 스타일 적용
                 for row_num in range(1, len(main_keywords_df) + 1):
                     for col_num, value in enumerate(main_keywords_df.iloc[row_num-1]):
-                        if isinstance(value, (int, float)) and col_num in [1, 2, 3]:  # 검색량 컬럼
+                        if col_num in [1, 2, 3]:  # PC검색량, 모바일검색량, 총검색량 컬럼
                             worksheet1.write(row_num, col_num, value, number_format)
                         else:
                             worksheet1.write(row_num, col_num, value, data_format)
@@ -238,11 +565,9 @@ def export_to_excel(main_keyword, main_keywords_df, analysis_keyword, related_ke
                         len(str(col))
                     )
                     worksheet1.set_column(i, i, min(max_len + 2, 50))
-                
-                logger.info(f"✅ 메인키워드 시트 생성: {main_keywords_df.shape}")
             
-            # 두 번째 시트: 분석키워드 연관검색어 (실제 데이터만)
-            if has_related_data:
+            # 두 번째 시트: 분석키워드 연관검색어
+            if related_keywords_df is not None and not related_keywords_df.empty:
                 related_keywords_df.to_excel(writer, sheet_name=f'{analysis_keyword}_연관검색어', index=False)
                 worksheet2 = writer.sheets[f'{analysis_keyword}_연관검색어']
                 
@@ -253,7 +578,7 @@ def export_to_excel(main_keyword, main_keywords_df, analysis_keyword, related_ke
                 # 데이터 스타일 적용
                 for row_num in range(1, len(related_keywords_df) + 1):
                     for col_num, value in enumerate(related_keywords_df.iloc[row_num-1]):
-                        if isinstance(value, (int, float)) and col_num in [1, 2, 3]:  # 검색량 컬럼
+                        if col_num in [1, 2, 3]:  # PC검색량, 모바일검색량, 총검색량 컬럼
                             worksheet2.write(row_num, col_num, value, number_format)
                         else:
                             worksheet2.write(row_num, col_num, value, data_format)
@@ -265,8 +590,6 @@ def export_to_excel(main_keyword, main_keywords_df, analysis_keyword, related_ke
                         len(str(col))
                     )
                     worksheet2.set_column(i, i, min(max_len + 2, 50))
-                
-                logger.info(f"✅ 연관검색어 시트 생성: {related_keywords_df.shape}")
         
         logger.info(f"엑셀 파일 생성 완료: {excel_path}")
         return excel_path
@@ -396,7 +719,7 @@ def export_to_html(analysis_html, filename_base):
     <div class="container">
         <div class="header">
             <h1><i class="fas fa-chart-line"></i> 키워드 심충분석 결과</h1>
-            <p>AI 상품 소싱 분석 시스템 v3.2 (더미 데이터 제거 버전)</p>
+            <p>AI 상품 소싱 분석 시스템 v2.9</p>
         </div>
         <div class="content">
             {analysis_html}
@@ -425,71 +748,48 @@ def create_zip_file(excel_path, html_path, filename_base):
         zip_filename = f"{filename_base}.zip"
         zip_path = os.path.join(tempfile.gettempdir(), zip_filename)
         
-        files_added = 0
         with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
             if excel_path and os.path.exists(excel_path):
                 zipf.write(excel_path, f"{filename_base}.xlsx")
                 logger.info(f"엑셀 파일 압축 추가: {filename_base}.xlsx")
-                files_added += 1
             
             if html_path and os.path.exists(html_path):
                 zipf.write(html_path, f"{filename_base}.html")
                 logger.info(f"HTML 파일 압축 추가: {filename_base}.html")
-                files_added += 1
         
-        if files_added == 0:
-            logger.warning("압축할 파일이 없음")
-            return None
-        
-        logger.info(f"압축 파일 생성 완료: {zip_path} ({files_added}개 파일)")
+        logger.info(f"압축 파일 생성 완료: {zip_path}")
         return zip_path
         
     except Exception as e:
         logger.error(f"압축 파일 생성 오류: {e}")
         return None
 
-def export_analysis_results_enhanced(export_data):
-    """강화된 분석 결과 출력 메인 함수 (더미 데이터 제거)"""
+def export_analysis_results(export_data):
+    """분석 결과 출력 메인 함수 - 세션별 데이터 처리"""
     try:
-        logger.info("=== 📊 강화된 출력 함수 시작 (더미 데이터 제거 버전) ===")
-        
-        # 데이터 유효성 검사 및 복구
-        export_data = validate_and_repair_export_data(export_data)
+        # 출력할 데이터 확인
+        if not export_data or not isinstance(export_data, dict):
+            return None, "분석 데이터가 없습니다. 먼저 키워드 심충분석을 실행해주세요."
         
-        analysis_keyword = export_data.get("analysis_keyword", "기본키워드")
-        analysis_html = export_data.get("analysis_html", "<div>분석 완료</div>")
-        main_keyword = export_data.get("main_keyword", analysis_keyword)
+        analysis_keyword = export_data.get("analysis_keyword", "")
+        analysis_html = export_data.get("analysis_html", "")
+        main_keyword = export_data.get("main_keyword", "")
         main_keywords_df = export_data.get("main_keywords_df")
         related_keywords_df = export_data.get("related_keywords_df")
         
-        logger.info(f"🔍 처리할 데이터:")
-        logger.info(f"   - analysis_keyword: '{analysis_keyword}'")
-        logger.info(f"   - main_keyword: '{main_keyword}'")
-        logger.info(f"   - analysis_html: {len(str(analysis_html))} 문자")
-        logger.info(f"   - main_keywords_df: {main_keywords_df.shape if main_keywords_df is not None else 'None'}")
-        logger.info(f"   - related_keywords_df: {related_keywords_df.shape if related_keywords_df is not None else 'None'}")
+        if not analysis_keyword:
+            return None, "분석할 키워드가 설정되지 않았습니다. 먼저 키워드 분석을 실행해주세요."
+        
+        if not analysis_html:
+            return None, "분석 결과가 없습니다. 먼저 키워드 심충분석을 실행해주세요."
         
         # 파일명 생성 (한국시간 적용)
         filename_base = create_timestamp_filename(analysis_keyword)
-        logger.info(f"📁 출력 파일명: {filename_base}")
-        
-        # HTML 파일은 분석 결과가 있으면 생성
-        html_path = None
-        if analysis_html and len(str(analysis_html).strip()) > 20:  # 의미있는 HTML인지 확인
-            logger.info("🌐 HTML 파일 생성 시작...")
-            html_path = export_to_html(analysis_html, filename_base)
-            if html_path:
-                logger.info(f"✅ HTML 파일 생성 성공: {html_path}")
-            else:
-                logger.error("❌ HTML 파일 생성 실패")
-        else:
-            logger.info("📄 분석 HTML이 없어 HTML 파일 생성 건너뜀")
+        logger.info(f"출력 파일명: {filename_base}")
         
-        # 엑셀 파일 생성 (실제 DataFrame이 있는 경우만)
+        # 엑셀 파일 생성
         excel_path = None
-        if (main_keywords_df is not None and not main_keywords_df.empty) or \
-           (related_keywords_df is not None and not related_keywords_df.empty):
-            logger.info("📊 엑셀 파일 생성 시작...")
+        if main_keywords_df is not None or related_keywords_df is not None:
             excel_path = export_to_excel(
                 main_keyword,
                 main_keywords_df,
@@ -497,340 +797,53 @@ def export_analysis_results_enhanced(export_data):
                 related_keywords_df,
                 filename_base
             )
-            if excel_path:
-                logger.info(f"✅ 엑셀 파일 생성 성공: {excel_path}")
-            else:
-                logger.warning("⚠️ 엑셀 파일 생성 실패")
-        else:
-            logger.info("📊 실제 DataFrame 데이터가 없어 엑셀 파일 생성 생략")
         
-        # 생성된 파일이 있는지 확인
-        if not html_path and not excel_path:
-            logger.warning("⚠️ 생성된 파일이 없음")
-            return None, "⚠️ 생성할 수 있는 데이터가 없습니다. 분석을 먼저 완료해주세요."
+        # HTML 파일 생성
+        html_path = export_to_html(analysis_html, filename_base)
         
         # 압축 파일 생성
-        logger.info("📦 압축 파일 생성 시작...")
-        zip_path = create_zip_file(excel_path, html_path, filename_base)
-        if zip_path:
-            file_types = []
-            if html_path:
-                file_types.append("HTML")
-            if excel_path:
-                file_types.append("엑셀")
-            
-            file_list = " + ".join(file_types)
-            logger.info(f"✅ 압축 파일 생성 성공: {zip_path} ({file_list})")
-            return zip_path, f"✅ 분석 결과가 성공적으로 출력되었습니다!\n파일명: {filename_base}.zip\n포함 파일: {file_list}\n\n💡 더미 데이터 제거 버전 - 실제 분석 데이터만 포함됩니다."
+        if excel_path or html_path:
+            zip_path = create_zip_file(excel_path, html_path, filename_base)
+            if zip_path:
+                return zip_path, f"✅ 분석 결과가 성공적으로 출력되었습니다!\n파일명: {filename_base}.zip"
+            else:
+                return None, "압축 파일 생성에 실패했습니다."
         else:
-            logger.error("❌ 압축 파일 생성 실패")
-            return None, "압축 파일 생성에 실패했습니다."
+            return None, "출력할 파일이 없습니다."
     
     except Exception as e:
-        logger.error(f"❌ 강화된 출력 함수 전체 오류: {e}")
-        import traceback
-        logger.error(f"스택 트레이스:\n{traceback.format_exc()}")
+        logger.error(f"분석 결과 출력 오류: {e}")
         return None, f"출력 중 오류가 발생했습니다: {str(e)}"
 
-# ===== 로딩 애니메이션 =====
-def create_loading_animation():
-    """로딩 애니메이션 HTML"""
-    return """
-    <div style="display: flex; flex-direction: column; align-items: center; padding: 40px; background: white; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);">
-        <div style="width: 60px; height: 60px; border: 4px solid #f3f3f3; border-top: 4px solid #FB7F0D; border-radius: 50%; animation: spin 1s linear infinite; margin-bottom: 20px;"></div>
-        <h3 style="color: #FB7F0D; margin: 10px 0; font-size: 18px;">분석 중입니다...</h3>
-        <p style="color: #666; margin: 5px 0; text-align: center;">원격 서버에서 데이터를 수집하고 AI가 분석하고 있습니다.<br>잠시만 기다려주세요.</p>
-        <div style="width: 200px; height: 4px; background: #f0f0f0; border-radius: 2px; margin-top: 15px; overflow: hidden;">
-            <div style="width: 100%; height: 100%; background: linear-gradient(90deg, #FB7F0D, #ff9a8b); border-radius: 2px; animation: progress 2s ease-in-out infinite;"></div>
-        </div>
-    </div>
-    
-    <style>
-    @keyframes spin {
-        0% { transform: rotate(0deg); }
-        100% { transform: rotate(360deg); }
-    }
-    
-    @keyframes progress {
-        0% { transform: translateX(-100%); }
-        100% { transform: translateX(100%); }
-    }
-    </style>
-    """
-
-# ===== 에러 처리 함수 =====
-def generate_error_response(error_message):
-    """에러 응답 생성"""
-    return f'''
-    <div style="color: red; padding: 30px; text-align: center; width: 100%; 
-                background-color: #f8d7da; border-radius: 12px; border: 1px solid #f5c6cb;">
-        <h3 style="margin-bottom: 15px;">❌ 연결 오류</h3>
-        <p style="margin-bottom: 20px;">{error_message}</p>
-        <div style="background: white; padding: 15px; border-radius: 8px; color: #333;">
-            <h4>해결 방법:</h4>
-            <ul style="text-align: left; padding-left: 20px;">
-                <li>네트워크 연결을 확인해주세요</li>
-                <li>원격 서버 상태를 확인해주세요</li>
-                <li>잠시 후 다시 시도해주세요</li>
-                <li>문제가 지속되면 관리자에게 문의하세요</li>
-            </ul>
-        </div>
-    </div>
-    '''
-
-# ===== 원격 API 호출 함수들 =====
-def call_collect_data_api(keyword):
-    """1단계: 상품 데이터 수집 API 호출"""
-    try:
-        client = get_api_client()
-        if not client:
-            return generate_error_response("API 클라이언트를 초기화할 수 없습니다."), {}
-        
-        logger.info("원격 API 호출: 상품 데이터 수집")
-        result = client.predict(
-            keyword=keyword,
-            api_name="/on_collect_data"
-        )
-        
-        logger.info(f"데이터 수집 API 결과 타입: {type(result)}")
-        
-        # 결과가 튜플인 경우 첫 번째 요소는 HTML, 두 번째는 세션 데이터
-        if isinstance(result, tuple) and len(result) == 2:
-            html_result, session_data = result
-            
-            # 세션 데이터가 제대로 있는지 확인
-            if isinstance(session_data, dict):
-                logger.info(f"데이터 수집 세션 데이터 수신: {list(session_data.keys()) if session_data else '빈 딕셔너리'}")
-                return html_result, session_data
-            else:
-                logger.warning("세션 데이터가 딕셔너리가 아닙니다.")
-                return html_result, {}
-        else:
-            logger.warning("예상과 다른 데이터 수집 결과 형태")
-            return str(result), {"keywords_collected": True}
-            
-    except Exception as e:
-        logger.error(f"상품 데이터 수집 API 호출 오류: {e}")
-        return generate_error_response(f"원격 서버 연결 실패: {str(e)}"), {}
-
-def call_analyze_keyword_api_enhanced(analysis_keyword, base_keyword, keywords_data):
-    """3단계: 강화된 키워드 심충분석 API 호출 (더미 데이터 제거)"""
-    try:
-        client = get_api_client()
-        if not client:
-            return generate_error_response("API 클라이언트를 초기화할 수 없습니다."), {}
-        
-        logger.info("=== 🚀 강화된 키워드 심충분석 API 호출 (더미 데이터 제거) ===")
-        logger.info(f"파라미터 - analysis_keyword: '{analysis_keyword}'")
-        logger.info(f"파라미터 - base_keyword: '{base_keyword}'")
-        logger.info(f"파라미터 - keywords_data 타입: {type(keywords_data)}")
-        
-        # 원격 API 호출
-        result = client.predict(
-            analysis_keyword,
-            base_keyword, 
-            keywords_data,
-            api_name="/on_analyze_keyword"
-        )
-        
-        logger.info(f"📡 원격 API 응답 수신:")
-        logger.info(f"   - 응답 타입: {type(result)}")
-        logger.info(f"   - 응답 길이: {len(result) if hasattr(result, '__len__') else 'N/A'}")
-        
-        # 응답 처리 및 Export 데이터 구조 생성
-        if isinstance(result, tuple) and len(result) == 2:
-            html_result, remote_export_data = result
-            
-            logger.info(f"📊 원격 export 데이터:")
-            logger.info(f"   - 타입: {type(remote_export_data)}")
-            logger.info(f"   - 키들: {list(remote_export_data.keys()) if isinstance(remote_export_data, dict) else 'None'}")
-            
-            # HTML 결과가 있으면 Export 데이터 구조 생성 (더미 데이터 없이)
-            if html_result:
-                logger.info("🔧 Export 데이터 구조 생성 시작 (더미 데이터 제거)")
-                enhanced_export_data = create_export_data_from_html(
-                    analysis_keyword=analysis_keyword,
-                    main_keyword=base_keyword,
-                    analysis_html=html_result,
-                    step1_data=keywords_data
-                )
-                
-                # 원격에서 온 실제 데이터가 있으면 병합
-                if isinstance(remote_export_data, dict) and remote_export_data:
-                    logger.info("🔗 원격 실제 데이터와 로컬 데이터 병합")
-                    for key, value in remote_export_data.items():
-                        if value is not None and key in ["main_keywords_df", "related_keywords_df"]:
-                            # DataFrame 데이터만 검증하여 병합
-                            if isinstance(value, dict) and value:  # 빈 딕셔너리가 아닌 경우만
-                                enhanced_export_data[key] = value
-                                logger.info(f"   - {key} 원격 실제 데이터로 업데이트")
-                            elif hasattr(value, 'shape') and not value.empty:  # DataFrame이고 비어있지 않은 경우
-                                enhanced_export_data[key] = value
-                                logger.info(f"   - {key} 원격 DataFrame 데이터로 업데이트")
-                        elif value is not None and key not in ["main_keywords_df", "related_keywords_df"]:
-                            enhanced_export_data[key] = value
-                            logger.info(f"   - {key} 원격 데이터로 업데이트")
-                
-                logger.info(f"✅ 최종 Export 데이터 구조 (더미 데이터 없음):")
-                logger.info(f"   - 키 개수: {len(enhanced_export_data)}")
-                logger.info(f"   - 키 목록: {list(enhanced_export_data.keys())}")
-                
-                return html_result, enhanced_export_data
-            else:
-                logger.warning("⚠️ HTML 결과가 비어있음")
-                return str(result), {}
-        else:
-            logger.warning("⚠️ 예상과 다른 API 응답 형태")
-            # HTML만 반환된 경우도 처리
-            if isinstance(result, str) and len(result) > 100:  # HTML일 가능성이 높음
-                logger.info("📄 HTML 문자열로 추정되는 응답 - Export 데이터 생성 (더미 데이터 없이)")
-                enhanced_export_data = create_export_data_from_html(
-                    analysis_keyword=analysis_keyword,
-                    main_keyword=base_keyword,
-                    analysis_html=result,
-                    step1_data=keywords_data
-                )
-                return result, enhanced_export_data
-            else:
-                return str(result), {}
-            
-    except Exception as e:
-        logger.error(f"❌ 키워드 심충분석 API 호출 오류: {e}")
-        import traceback
-        logger.error(f"��택 트레이스:\n{traceback.format_exc()}")
-        return generate_error_response(f"원격 서버 연결 실패: {str(e)}"), {}
-
 # ===== 그라디오 인터페이스 =====
 def create_interface():
-    # CSS 스타일링 (기존과 동일)
-    custom_css = """
-    /* 기존 다크모드 자동 변경 AI 상품 소싱 분석 시스템 CSS */
-    :root {
-        --primary-color: #FB7F0D;
-        --secondary-color: #ff9a8b;
-        --accent-color: #FF6B6B;
-        --background-color: #FFFFFF;
-        --card-bg: #ffffff;
-        --input-bg: #ffffff;
-        --text-color: #334155;
-        --text-secondary: #64748b;
-        --border-color: #dddddd;
-        --border-light: #e5e5e5;
-        --table-even-bg: #f3f3f3;
-        --table-hover-bg: #f0f0f0;
-        --shadow: 0 8px 30px rgba(251, 127, 13, 0.08);
-        --shadow-light: 0 2px 4px rgba(0, 0, 0, 0.1);
-        --border-radius: 18px;
-    }
-    @media (prefers-color-scheme: dark) {
-        :root {
-            --background-color: #1a1a1a;
-            --card-bg: #2d2d2d;
-            --input-bg: #2d2d2d;
-            --text-color: #e5e5e5;
-            --text-secondary: #a1a1aa;
-            --border-color: #404040;
-            --border-light: #525252;
-            --table-even-bg: #333333;
-            --table-hover-bg: #404040;
-            --shadow: 0 8px 30px rgba(0, 0, 0, 0.3);
-            --shadow-light: 0 2px 4px rgba(0, 0, 0, 0.2);
+    # CSS 파일 로드
+    try:
+        with open('style.css', 'r', encoding='utf-8') as f:
+            custom_css = f.read()
+        
+        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; }
+        .custom-button { 
+            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)) !important;
+            color: white !important; border-radius: 30px !important; height: 45px !important;
+            font-size: 16px !important; font-weight: bold !important; width: 100% !important;
         }
-    }
-    body {
-        font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif;
-        background-color: var(--background-color) !important;
-        color: var(--text-color) !important;
-        line-height: 1.6;
-        margin: 0;
-        padding: 0;
-        transition: background-color 0.3s ease, color 0.3s ease;
-    }
-    .gradio-container {
-        width: 100%;
-        margin: 0 auto;
-        padding: 20px;
-        background-color: var(--background-color) !important;
-    }
-    .custom-frame {
-        background-color: var(--card-bg) !important;
-        border: 1px solid var(--border-light) !important;
-        border-radius: var(--border-radius);
-        padding: 20px;
-        margin: 10px 0;
-        box-shadow: var(--shadow) !important;
-        color: var(--text-color) !important;
-    }
-    .custom-button {
-        border-radius: 30px !important;
-        background: var(--primary-color) !important;
-        color: white !important;
-        font-size: 18px !important;
-        padding: 10px 20px !important;
-        border: none;
-        box-shadow: 0 4px 8px rgba(251, 127, 13, 0.25);
-        transition: transform 0.3s ease;
-        height: 45px !important;
-        width: 100% !important;
-    }
-    .custom-button:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 6px 12px rgba(251, 127, 13, 0.3);
-    }
-    .export-button {
-        background: linear-gradient(135deg, #28a745, #20c997) !important;
-        color: white !important; 
-        border-radius: 25px !important; 
-        height: 50px !important;
-        font-size: 17px !important; 
-        font-weight: bold !important; 
-        width: 100% !important;
-        margin-top: 20px !important;
-    }
-    .section-title {
-        display: flex;
-        align-items: center;
-        font-size: 20px;
-        font-weight: 700;
-        color: var(--text-color) !important;
-        margin-bottom: 10px;
-        padding-bottom: 5px;
-        border-bottom: 2px solid var(--primary-color);
-        font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif;
-    }
-    .section-title img, .section-title i {
-        margin-right: 10px;
-        font-size: 20px;
-        color: var(--primary-color);
-    }
-    .gr-input, .gr-text-input, .gr-sample-inputs,
-    input[type="text"], input[type="number"], textarea, select {
-        border-radius: var(--border-radius) !important;
-        border: 1px solid var(--border-color) !important;
-        padding: 12px !important;
-        box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.05) !important;
-        transition: all 0.3s ease !important;
-        background-color: var(--input-bg) !important;
-        color: var(--text-color) !important;
-    }
-    .gr-input:focus, .gr-text-input:focus,
-    input[type="text"]:focus, textarea:focus, select:focus {
-        border-color: var(--primary-color) !important;
-        outline: none !important;
-        box-shadow: 0 0 0 2px rgba(251, 127, 13, 0.2) !important;
-    }
-    .fade-in {
-        animation: fadeIn 0.5s ease-out;
-    }
-    @keyframes fadeIn {
-        from { opacity: 0; transform: translateY(10px); }
-        to { opacity: 1; transform: translateY(0); }
-    }
-    """
+        .export-button {
+            background: linear-gradient(135deg, #28a745, #20c997) !important;
+            color: white !important; border-radius: 25px !important; height: 50px !important;
+            font-size: 17px !important; font-weight: bold !important; width: 100% !important;
+            margin-top: 20px !important;
+        }
+        """
     
     with gr.Blocks(
         css=custom_css, 
-        title="🛒 AI 상품 소싱 분석기 v3.2 (더미 데이터 제거)",
+        title="🛒 AI 상품 소싱 분석기 v2.9",
         theme=gr.themes.Default(primary_hue="orange", secondary_hue="orange")
     ) as interface:
         
@@ -840,11 +853,11 @@ def create_interface():
         <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css">
         """)
         
-        # 세션별 상태 변수
+        # 세션별 상태 변수 (멀티 사용자 안전)
         keywords_data_state = gr.State()
         export_data_state = gr.State({})
         
-        # === UI 컴포넌트들 ===
+        # === 1단계: 메인 키워드 입력 ===
         with gr.Column(elem_classes="custom-frame fade-in"):
             gr.HTML('<div class="section-title"><i class="fas fa-search"></i> 1단계: 메인 키워드 입력</div>')
             
@@ -857,10 +870,12 @@ def create_interface():
             
             collect_data_btn = gr.Button("1단계: 상품 데이터 수집하기", elem_classes="custom-button", size="lg")
         
+        # === 2단계: 수집된 키워드 목록 ===
         with gr.Column(elem_classes="custom-frame fade-in"):
             gr.HTML('<div class="section-title"><i class="fas fa-database"></i> 2단계: 수집된 키워드 목록</div>')
             keywords_result = gr.HTML()
         
+        # === 3단계: 분석할 키워드 선택 ===
         with gr.Column(elem_classes="custom-frame fade-in"):
             gr.HTML('<div class="section-title"><i class="fas fa-bullseye"></i> 3단계: 분석할 키워드 선택</div>')
             
@@ -873,21 +888,14 @@ def create_interface():
             
             analyze_keyword_btn = gr.Button("키워드 심충분석 하기", elem_classes="custom-button", size="lg")
         
+        # === 키워드 심충분석 ===
         with gr.Column(elem_classes="custom-frame fade-in"):
             gr.HTML('<div class="section-title"><i class="fas fa-chart-line"></i> 키워드 심충분석</div>')
             analysis_result = gr.HTML(label="키워드 심충분석")
         
+        # === 결과 출력 섹션 ===
         with gr.Column(elem_classes="custom-frame fade-in"):
             gr.HTML('<div class="section-title"><i class="fas fa-download"></i> 분석 결과 출력</div>')
-            
-            gr.HTML("""
-            <div style="background: #e3f2fd; border-left: 4px solid #2196f3; padding: 15px; margin: 10px 0; border-radius: 5px;">
-                <h4 style="margin: 0 0 10px 0; color: #1976d2;"><i class="fas fa-info-circle"></i> 실제 데이터 출력 버전</h4>
-                <p style="margin: 0; color: #1976d2; font-size: 14px;">
-                    • 분석된 데이터를 파일로 출력됩니다<br>
-                </p>
-            </div>
-            """)
         
             export_btn = gr.Button("📊 분석결과 출력하기", elem_classes="export-button", size="lg")
             export_result = gr.HTML()
@@ -901,10 +909,30 @@ def create_interface():
             # 로딩 상태 표시
             yield (create_loading_animation(), None)
             
-            # 원격 API 호출
-            result_html, result_data = call_collect_data_api(keyword)
+            result = extract_keywords_from_products(keyword)
+            
+            if result["status"] == "error":
+                yield (f"<div style='color: red; padding: 20px; text-align: center; width: 100%;'>{result['message']}</div>", None)
+                return
+            
+            keywords_df = result["keywords_df"]
+            html_table = export_utils.create_table_without_checkboxes(keywords_df)
             
-            yield (result_html, result_data)
+            success_html = f"""
+            <div style="width: 100%; background: #d4edda; border: 1px solid #c3e6cb; padding: 15px; border-radius: 5px; margin-bottom: 20px;">
+                <h4 style="color: #155724; margin: 0 0 10px 0;">✅ 네이버 데이터 수집 완료!</h4>
+                <p style="margin: 0; color: #155724;">
+                    • 실제 상품 {len(result['products'])}개 분석<br>
+                    • 추출된 키워드: <strong>{len(keywords_df)}개</strong><br>
+                    • 아래 목록에서 원하는 키워드를 선택하여 분석하세요
+                </p>
+            </div>
+            
+            <h5 style="margin: 20px 0 10px 0; color: #495057;">📊 전체 키워드 목록</h5>
+            {html_table}
+            """
+            
+            yield (success_html, result)
         
         def on_analyze_keyword(analysis_keyword, base_keyword, keywords_data):
             if not analysis_keyword.strip():
@@ -913,30 +941,78 @@ def create_interface():
             # 로딩 상태 표시
             yield create_loading_animation(), {}
             
-            # 강화된 API 호출 (더미 데이터 제거)
-            html_result, enhanced_export_data = call_analyze_keyword_api_enhanced(
-                analysis_keyword, base_keyword, keywords_data
-            )
+            # 연관검색어 분석 먼저 실행
+            related_result = analyze_related_keywords(analysis_keyword)
+            
+            # 실제 키워드 분석 실행 (세션별 데이터 반환)
+            keyword_result, session_export_data = safe_keyword_analysis(analysis_keyword, base_keyword, keywords_data)
             
-            yield html_result, enhanced_export_data
+            # 연관검색어 분석 결과를 세션 데이터에 추가
+            if related_result["status"] == "success" and not related_result["keywords_df"].empty:
+                session_export_data["related_keywords_df"] = related_result["keywords_df"]
+            
+            # 연관검색어 분석 결과 HTML 생성
+            if related_result["status"] == "success" and not related_result["keywords_df"].empty:
+                df_keywords = related_result["keywords_df"]
+                related_table = export_utils.create_table_without_checkboxes(df_keywords)
                 
+                related_html = f"""
+                <div style="width: 100%; margin: 30px auto; font-family: 'Pretendard', sans-serif;">
+                    <div style="background: linear-gradient(135deg, #17a2b8 0%, #20c997 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);">
+                        <div style="background: #e8f5e8; border: 1px solid #c3e6cb; padding: 15px; border-radius: 5px; margin-bottom: 20px;">
+                            <h4 style="color: #155724; margin: 0 0 10px 0;">🔗 연관검색어 분석 완료!</h4>
+                            <p style="margin: 0; color: #155724;">
+                                • 분석 기준 상품: <strong>{related_result['total_products']}개</strong><br>
+                                • 발견된 연관검색어: <strong>{len(df_keywords)}개</strong><br>
+                                • 메인 키워드와 결합된 복합키워드만 표시됩니다
+                            </p>
+                        </div>
+                        {related_table}
+                    </div>
+                </div>
+                """
+                
+                # 세션 데이터의 analysis_html을 업데이트
+                session_export_data["analysis_html"] = related_html + session_export_data["analysis_html"]
+            else:
+                related_html = f"""
+                <div style="width: 100%; margin: 30px auto; font-family: 'Pretendard', sans-serif;">
+                    <div style="background: linear-gradient(135deg, #17a2b8 0%, #20c997 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);">
+                        <div style="color: orange; padding: 20px; text-align: center; background: #fff3cd; border-radius: 8px;">
+                            '{analysis_keyword}' 키워드의 연관검색어를 찾을 수 없습니다.
+                        </div>
+                    </div>
+                </div>
+                """
+                
+                # 세션 데이터의 analysis_html을 업데이트
+                session_export_data["analysis_html"] = related_html + session_export_data["analysis_html"]
+            
+            # 최종 결과 조합
+            final_result = related_html + keyword_result
+            yield final_result, session_export_data
+        
         def on_export_results(export_data):
-            """강화된 분석 결과 출력 핸들러 (더미 데이터 제거)"""
+            """분석 결과 출력 핸들러 - 세션별 데이터 처리"""
             try:
-                logger.info(f"📊 입력 export_data: {type(export_data)}")
-                if isinstance(export_data, dict):
-                    logger.info(f"📋 export_data 키들: {list(export_data.keys())}")
-                
-                # 강화된 출력 함수 호출 (더미 데이터 제거)
-                zip_path, message = export_analysis_results_enhanced(export_data)
+                zip_path, message = export_analysis_results(export_data)
                 
                 if zip_path:
+                    # 성공 메시지와 함께 다운로드 파일 제공
                     success_html = f"""
                     <div style="background: #d4edda; border: 1px solid #c3e6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
                         <h4 style="color: #155724; margin: 0 0 15px 0;"><i class="fas fa-check-circle"></i> 출력 완료!</h4>
                         <p style="color: #155724; margin: 0; line-height: 1.6;">
                             {message}<br>
-                            <strong>데이터출력:</strong><br>
+                            <strong>포함 파일:</strong><br>
+                            • 📊 엑셀 파일: 메인키워드 조합키워드 + 연관검색어 데이터<br>
+                            • 🌐 HTML 파일: 키워드 심충분석 결과 (그래프 포함)<br>
                             <br>
                             <i class="fas fa-download"></i> 아래 다운로드 버튼을 클릭하여 파일을 저장하세요.<br>
                             <small style="color: #666;">⏰ 한국시간 기준으로 파일명이 생성됩니다.</small>
@@ -945,40 +1021,21 @@ def create_interface():
                     """
                     return success_html, gr.update(value=zip_path, visible=True)
                 else:
+                    # 실패 메시지
                     error_html = f"""
                     <div style="background: #f8d7da; border: 1px solid #f5c6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
                         <h4 style="color: #721c24; margin: 0 0 10px 0;"><i class="fas fa-exclamation-triangle"></i> 출력 실패</h4>
                         <p style="color: #721c24; margin: 0;">{message}</p>
-                        <div style="margin-top: 15px; padding: 15px; background: white; border-radius: 5px;">
-                            <h5 style="color: #721c24; margin: 0 0 10px 0;">🔍 디버깅 정보:</h5>
-                            <ul style="color: #721c24; margin: 0; padding-left: 20px;">
-                                <li>Export 데이터 타입: {type(export_data)}</li>
-                                <li>Export 데이터 유효성: {'유효' if export_data else '무효'}</li>
-                                <li>키워드 심충분석 상태: {'완료' if export_data.get('analysis_completed') else '미완료'}</li>
-                            </ul>
-                        </div>
                     </div>
                     """
-                    logger.error("❌ 강화된 출력 실패")
                     return error_html, gr.update(visible=False)
                     
             except Exception as e:
-                logger.error(f"❌ 강화된 출력 핸들러 오류: {e}")
-                import traceback
-                logger.error(f"스택 트레이스:\n{traceback.format_exc()}")
-                
+                logger.error(f"출력 핸들러 오류: {e}")
                 error_html = f"""
                 <div style="background: #f8d7da; border: 1px solid #f5c6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
                     <h4 style="color: #721c24; margin: 0 0 10px 0;"><i class="fas fa-exclamation-triangle"></i> 시스템 오류</h4>
-                    <p style="color: #721c24; margin: 0;">강화된 출력 중 시스템 오류가 발생했습니다:</p>
-                    <code style="display: block; margin: 10px 0; padding: 10px; background: #f8f9fa; border-radius: 3px; color: #721c24;">
-                        {type(e).__name__}: {str(e)}
-                    </code>
-                    <div style="margin-top: 15px; padding: 10px; background: #fff3cd; border-radius: 5px;">
-                        <p style="margin: 0; color: #856404; font-size: 14px;">
-                            💡 실제 분석 결과가 있어야만 파일이 생성됩니다.
-                        </p>
-                    </div>
+                    <p style="color: #721c24; margin: 0;">출력 중 시스템 오류가 발생했습니다: {str(e)}</p>
                 </div>
                 """
                 return error_html, gr.update(visible=False)
@@ -987,26 +1044,80 @@ def create_interface():
         collect_data_btn.click(
             fn=on_collect_data,
             inputs=[keyword_input],
-            outputs=[keywords_result, keywords_data_state],
-            api_name="on_collect_data"
+            outputs=[keywords_result, keywords_data_state]
         )
         
         analyze_keyword_btn.click(
             fn=on_analyze_keyword,
-            inputs=[analysis_keyword_input, keyword_input, keywords_data_state],  
-            outputs=[analysis_result, export_data_state],
-            api_name="on_analyze_keyword"
+            inputs=[analysis_keyword_input, keyword_input, keywords_data_state],
+            outputs=[analysis_result, export_data_state]
         )
         
         export_btn.click(
             fn=on_export_results,
             inputs=[export_data_state],
-            outputs=[export_result, download_file],
-            api_name="on_export_results"
+            outputs=[export_result, download_file]
         )
     
     return interface
 
+# ===== 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 모듈 설치 확인
@@ -1014,8 +1125,64 @@ if __name__ == "__main__":
         import pytz
         logger.info("✅ pytz 모듈 로드 성공 - 한국시간 지원")
     except ImportError:
+        logger.warning("⚠️ pytz 모듈이 설치되지 않음 - pip install pytz 실행 필요")
         logger.info("시스템 시간을 사용합니다.")
     
+    # API 설정 초기화
+    api_utils.initialize_api_configs()
+    logger.info("===== 상품 소싱 분석 시스템 v2.9 (출력기능 추가 + 한국시간 + 멀티사용자 안전) 시작 =====")
+    
+    # 네이버 데이터랩 API 설정 확인
+    datalab_available = check_datalab_api_config()
+    
+    # Gemini API 설정 확인
+    gemini_available = check_gemini_api_config()
+    
+    # 필요한 패키지 안내
+    print("📦 필요한 패키지:")
+    print("   pip install gradio google-generativeai pandas requests xlsxwriter markdown plotly pytz")
+    print()
+    
+    # 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 설정 완료 - 1년, 3년 트렌드 분석이 가능합니다!")
+        print()
+    
+    if gemini_available:
+        print("✅ Gemini API 설정 완료 - AI 분석이 가능합니다!")
+        print()
+    
+    print("🛡️ v2.9 멀티사용자 안전 개선사항:")
+    print("   • 전역 변수 export_state 완전 제거")
+    print("   ��� gr.State({}) 사용으로 각 사용자별 세션 데이터 완전 분리")
+    print("   • safe_keyword_analysis() 함수에서 세션별 데이터 반환")
+    print("   • export_analysis_results() 함수에서 세션별 데이터 처리")
+    print("   • 이벤트 핸들러에서 export_data_state 세션 상태 관리")
+    print("   • 허깅페이스 스페이스 등 멀티사용자 환경에서 안전한 동시 사용 보장")
+    print()
+    
+    print("🚀 기존 v2.9 기능:")
+    print("   • 연관검색어 엑셀 출력")
+    print("   • 키워드 심충분석 HTML 출력")
+    print("   • 압축파일로 결과 다운로드")
+    print("   • Gemini API 키 통합 관리")
+    print("   • 한국시간 적용")
+    print()
+    
     # 앱 실행
     app = create_interface()
     app.launch(server_name="0.0.0.0", server_port=7860, share=True)

category_analysis.py

@@ -0,0 +1,1029 @@
+"""
+카테고리 분석 모듈 - 상품의 카테고리 분석 기능 제공 (개선버전)
+- 1년/3년 트렌드 모두 분석
+- 너비 100% 적용
+- 3년 기준 성장률 계산
+"""
+
+import pandas as pd
+import time
+import re
+import random
+from collections import Counter, defaultdict
+import text_utils
+import product_search
+import keyword_search
+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)
+
+# 마지막 키워드 분석 결과를 저장할 전역 변수
+_last_keyword_results = []
+
+def get_last_keyword_results():
+    """마지막으로 분석된 키워드 결과 반환"""
+    global _last_keyword_results
+    return _last_keyword_results
+
+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 analyze_product_categories(main_keyword, product_name, category_filter=None):
+    """
+    메인 키워드와 상품명으로 카테고리 분석을 수행
+    
+    Args:
+        main_keyword (str): 메인 검색 키워드
+        product_name (str): 분석할 상품명
+        category_filter (str, optional): 카테고리 필터
+        
+    Returns:
+        dict: 분석 결과
+    """
+    logger.info(f"카테고리 분석 시작: 메인 키워드={main_keyword}, 상품명={product_name}")
+    
+    # 1단계: 메인 키워드로 100개 상품 가져오기 (10개씩 10페이지)
+    all_products = []
+    for page in range(1, 11):
+        result = product_search.fetch_products_by_keyword(main_keyword, page=page, display=10)
+        if result["products"]:
+            all_products.extend(result["products"])
+        exponential_backoff_sleep(0)  # API 레이트 리밋 방지
+    
+    if not all_products:
+        return {
+            "status": "error",
+            "message": "상품을 가져오지 못했습니다.",
+            "main_keyword": main_keyword,
+            "product_name": product_name,
+            "total_count": 0,
+            "products": [],
+            "categories": [],
+            "analysis": None
+        }
+    
+    # 2단계: 상품명에서 키워드 추출 (개선: 더 정확한 키워드 추출)
+    product_keywords = []
+    
+    # 공백과 쉼표를 기준으로 자연스럽게 분리
+    words = re.split(r'[,\s]+', product_name)
+    for word in words:
+        word = word.strip()
+        if word and len(word) >= 2:  # 최소 2글자 이상인 단어만
+            # 중복 제거
+            if word not in product_keywords:
+                product_keywords.append(word)
+    
+    logger.info(f"상품명에서 추출한 키워드: {product_keywords}")
+    
+    # 3단계: 상품 카테고리 분석
+    category_counter = Counter()
+    products_by_category = defaultdict(list)
+    
+    for product in all_products:
+        category = product["카테고리"]
+        category_counter[category] += 1
+        products_by_category[category].append(product)
+    
+    # 카테고리 필터 적용
+    if category_filter and category_filter != "전체 보기":
+        # 카테고리에서 괄호 부분 제거
+        category_filter_clean = category_filter.split(" (")[0] if " (" in category_filter else category_filter
+        
+        filtered_categories = {}
+        for cat, count in category_counter.items():
+            # 상품 카테고리에서도 괄호 있으면 제거
+            cat_clean = cat
+            if " (" in cat_clean:
+                cat_clean = cat_clean.split(" (")[0]
+                
+            if category_filter_clean.lower() in cat_clean.lower():
+                filtered_categories[cat] = count
+                
+        category_counter = Counter(filtered_categories)
+    
+    # 4단계: 키워드 검색량 조회
+    all_keywords = [main_keyword] + product_keywords
+    search_volumes = keyword_search.fetch_all_search_volumes(all_keywords)
+    
+    # 5단계: 카테고리별 매칭 상태 분석
+    category_matching = []
+    
+    # 정렬된 카테고리 목록 (출현 빈도순)
+    sorted_categories = [cat for cat, _ in category_counter.most_common()]
+    
+    for category in sorted_categories:
+        products_in_category = products_by_category[category]
+        count = len(products_in_category)
+        
+        # 이 카테고리에 속한 상품들 중 10개만 가져옴
+        sample_products = products_in_category[:100]
+        
+        category_matching.append({
+            "카테고리": category,
+            "상품수": count,
+            "매칭상품": sample_products
+        })
+    
+    # 6단계: 검색량 정보 추가 및 결과 정리
+    keyword_info = []
+    for kw in all_keywords:
+        volume = search_volumes.get(kw, {"PC검색량": 0, "모바일검색량": 0, "총검색량": 0})
+        keyword_info.append({
+            "키워드": kw,
+            "PC검색량": volume.get("PC검색량", 0),
+            "모바일검색량": volume.get("모바일검색량", 0),
+            "총검색량": volume.get("총검색량", 0),
+            "검색량구간": text_utils.get_search_volume_range(volume.get("총검색량", 0))
+        })
+    
+    # 결과 반환
+    return {
+        "status": "success",
+        "message": "분석이 완료되었습니다.",
+        "main_keyword": main_keyword,
+        "product_name": product_name,
+        "total_count": len(all_products),
+        "products": all_products,
+        "categories": sorted_categories,
+        "category_counter": dict(category_counter),
+        "category_matching": category_matching,
+        "keyword_info": keyword_info
+    }
+
+def analyze_keywords_by_category(keywords, selected_category, df_all=None):
+    """
+    입력된 키워드 목록과 선택된 카테고리로 분석을 수행하는 함수
+    """
+    import re
+    
+    if not keywords or not selected_category:
+        return "키워드와 카테고리를 모두 선택해주세요."
+    
+    # 카테고리에서 카운트 정보 제거 (예: "패션의류 (10)" -> "패션의류")
+    selected_category_clean = selected_category
+    is_overall_view = False # '전체 보기'인지 여부 플래그
+    if " (" in selected_category and selected_category != "전체 보기":
+        selected_category_clean = selected_category.split(" (")[0]
+    elif selected_category == "전체 보기":
+        selected_category_clean = ""  # 전체 카테고리 분석용
+        is_overall_view = True
+    
+    # 키워드 리스트 처리 (최대 20개)
+    if isinstance(keywords, str):
+        # 쉼표나 엔터로 분리
+        keywords_list = [k.strip() for k in re.split(r'[,\n]+', keywords) if k.strip()]
+        # 20개로 제한
+        keywords_list = keywords_list[:20]
+    else:
+        keywords_list = keywords[:20]
+    
+    if not keywords_list:
+        return "분석할 키워드가 없습니다."
+    
+    logger.info(f"카테고리 분석 시작: {len(keywords_list)}개 키워드, 선택 카테고리: '{selected_category_clean if not is_overall_view else '전체 보기'}'")
+    
+    # 개선된 HTML 결과 - 너비 100% 적용
+    result_html = f'''
+    <style>
+    .result-container {{
+        width: 100%;
+        margin-top: 20px;
+        padding: 15px;
+        border-radius: 8px;
+        box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+        background-color: #f9f9f9;
+    }}
+    
+    .result-header {{
+        font-size: 18px;
+        font-weight: bold;
+        margin-bottom: 15px;
+        color: #009879;
+        border-bottom: 2px solid #009879;
+        padding-bottom: 5px;
+    }}
+    
+    .keyword-tags {{
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        margin-bottom: 20px;
+        width: 100%;
+    }}
+    
+    .keyword-tag {{
+        display: inline-block;
+        background-color: #009879;
+        color: white;
+        padding: 8px 15px;
+        border-radius: 20px;
+        font-size: 14px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+        transition: transform 0.2s;
+    }}
+    
+    .keyword-tag:hover {{
+        transform: translateY(-2px);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.15);
+    }}
+    
+    .category-container {{
+        width: 100%;
+        margin-bottom: 20px;
+        padding: 10px 15px;
+        background-color: #f0f8ff;
+        border-left: 4px solid #2c7fb8;
+        border-radius: 4px;
+    }}
+    
+    .category-title {{
+        font-weight: bold;
+        margin-bottom: 5px;
+        color: #2c7fb8;
+    }}
+    
+    .category-path {{
+        font-size: 16px;
+        color: #333;
+        word-break: break-word;
+    }}
+    
+    .analysis-result {{
+        width: 100%;
+        margin-top: 30px;
+        border: 1px solid #ddd;
+        border-radius: 5px;
+        padding: 15px;
+        background-color: #ffffff;
+    }}
+    
+    .result-header-analysis {{
+        font-weight: bold;
+        margin-bottom: 15px;
+        color: #009879;
+        font-size: 16px;
+    }}
+    
+    .match-item {{
+        width: 100%;
+        margin: 12px 0;
+        padding: 8px 12px;
+        border-bottom: 1px solid #eee;
+        transition: background-color 0.2s;
+        display: grid;
+        grid-template-columns: 3fr 1fr 4fr;
+        gap: 10px;
+    }}
+    
+    .match-item:hover {{
+        background-color: #f5f5f5;
+    }}
+    
+    .match-keyword {{
+        font-weight: bold;
+        color: #2c7fb8;
+        font-size: 15px;
+    }}
+    
+    .match-count {{
+        display: inline-block;
+        background-color: #009879;
+        color: white;
+        padding: 3px 10px;
+        border-radius: 15px;
+        font-size: 13px;
+        margin-left: 10px;
+    }}
+    
+    .match-status {{
+        text-align: center;
+        font-weight: bold;
+        color: #009879;
+    }}
+    
+    .match-categories {{
+        color: #555;
+        font-size: 14px;
+        line-height: 1.4;
+    }}
+    
+    .match-header {{
+        width: 100%;
+        display: grid;
+        grid-template-columns: 3fr 1fr 4fr;
+        gap: 10px;
+        padding: 10px 12px;
+        background-color: #e7f7f3;
+        border-radius: 5px 5px 0 0;
+        font-weight: bold;
+        margin-bottom: 10px;
+    }}
+    </style>
+    
+    <div class="result-container">
+        <div class="result-header">분석 결과 요약</div>
+        
+        <div class="keyword-tags">
+            <div class="category-title">분석 키워드 ({len(keywords_list)}개)</div>
+            <div class="keyword-tags">
+                {''.join([f'<span class="keyword-tag">{k}</span>' for k in keywords_list])}
+            </div>
+        </div>
+        
+        <div class="category-container">
+            <div class="category-title">선택된 카테고리</div>
+            <div class="category-path">{selected_category}</div>
+        </div>
+        
+        <div class="analysis-result">
+            <div class="result-header-analysis">카테고리 일치 분석 결과</div>
+            
+            <div class="match-header">
+                <div>키워드</div>
+                <div>분석 키워드</div>
+                <div>매칭된 카테고리</div>
+            </div>
+    '''
+    
+    # 키워드 배치 처리 준비 (5개씩 묶음)
+    batch_size = 5
+    batches = []
+    for i in range(0, len(keywords_list), batch_size):
+        batches.append(keywords_list[i:i + batch_size])
+    
+    logger.info(f"총 {len(batches)}개 배치로 {len(keywords_list)}개 키워드 처리")
+    
+    # 각 배치 처리
+    match_results = {} # 각 키워드별 매칭 정보 저장 (match_count, total_count)
+    batch_categories_info = {} # 각 키워드별로 추출된 카테고리 목록 및 비율 저장
+    
+    for batch_idx, batch in enumerate(batches):
+        logger.info(f"배치 {batch_idx+1}/{len(batches)} 처리 중...")
+        
+        # 각 키워드 처리
+        for keyword in batch:
+            max_retries = 3
+            retry_count = 0
+            api_keyword = keyword.replace(" ", "")  # 공백 제거
+            
+            current_keyword_match_count = 0
+            current_keyword_total_products = 0
+            current_keyword_categories_found = [] # 비율과 함께 저장될 카테고리 문자열 리스트
+            
+            while retry_count < max_retries:
+                try:
+                    # 네이버 API 호출
+                    products = product_search.fetch_naver_shopping_data_for_analysis(api_keyword, count=100) # 상위 10개 상품
+                    
+                    if products:
+                        current_keyword_total_products = len(products)
+                        categories_counter_for_keyword = Counter() # 현재 키워드의 상품들 카테고리 분포
+                        
+                        for product in products:
+                            product_category_full = product.get("category", "") or product.get("카테고리", "")
+                            if product_category_full:
+                                categories_counter_for_keyword[product_category_full] += 1
+                            
+                            # 실제 매칭 여부 카운트 (is_overall_view가 아닐 때만)
+                            if not is_overall_view and selected_category_clean:
+                                product_category_for_match = product_category_full
+                                if " (" in product_category_for_match: # 상품 카테고리 이름에서 count 제거
+                                     product_category_for_match = product_category_for_match.split(" (")[0]
+
+                                sel_lower = selected_category_clean.lower()
+                                prod_lower = product_category_for_match.lower()
+                                
+                                if sel_lower in prod_lower or prod_lower in sel_lower:
+                                    current_keyword_match_count += 1
+                        
+                        if is_overall_view: # '전체 보기'일 경우, 모든 상품이 매칭된 것으로 간주
+                            current_keyword_match_count = current_keyword_total_products
+
+                        # 카테고리별 비율 계산 및 저장
+                        category_percentages = []
+                        for cat, count in categories_counter_for_keyword.most_common(): # 빈도 높은 순으로
+                            percentage = (count / current_keyword_total_products) * 100 if current_keyword_total_products > 0 else 0
+                            category_percentages.append((cat, percentage))
+                        
+                        # category_percentages.sort(key=lambda x: x[1], reverse=True) # 이미 most_common으로 정렬됨
+
+                        for cat, percentage in category_percentages:
+                            current_keyword_categories_found.append(f"{cat} ({percentage:.0f}%)")
+                        
+                        logger.info(f"  - '{keyword}' 처리 완료: {current_keyword_match_count}/{current_keyword_total_products} 일치")
+                        break  # 성공했으므로 재시도 루프 종료
+                    else:
+                        logger.warning(f"  - '{keyword}' API 결과 없음 (시도 {retry_count+1}/{max_retries})")
+                        retry_count += 1
+                        exponential_backoff_sleep(retry_count)
+                
+                except Exception as e:
+                    logger.error(f"  - '{keyword}' 처리 중 오류: {e} (시도 {retry_count+1}/{max_retries})")
+                    retry_count += 1
+                    exponential_backoff_sleep(retry_count)
+            
+            # 결과 저장
+            if retry_count >= max_retries and current_keyword_total_products == 0: # 최종 실패
+                 match_results[keyword] = {
+                    "match_count": 0,
+                    "total_count": 0,
+                    "error": True
+                }
+                 batch_categories_info[keyword] = ["오류 발생"]
+                 logger.error(f"  - '{keyword}' 최대 재시도 후 실패")
+            else:
+                match_results[keyword] = {
+                    "match_count": current_keyword_match_count,
+                    "total_count": current_keyword_total_products,
+                    "error": False
+                }
+                batch_categories_info[keyword] = current_keyword_categories_found if current_keyword_categories_found else ["카테고리 정보 없음"]
+
+            # API 레이트 리밋 방지 - 지수 백오프 사용
+            exponential_backoff_sleep(0)
+            
+    logger.info(f"전체 {len(keywords_list)}개 키워드 중 {len(match_results)}개 처리 완료")
+    
+    # 결과를 HTML로 변환
+    for keyword in keywords_list:
+        result = match_results.get(keyword, {"match_count": 0, "total_count": 0, "error": True})
+        
+        # 수정된 부분: keyword_status 결정 로직 변경
+        # 선택된 카테고리와 하나라도 매칭되면 "O", 아니면 "X"
+        # "전체 보기" 선택 시에는 항상 "O" (모든 상품이 매칭된 것으로 간주했으므로)
+        if result.get("error"):
+            keyword_status = "오류" # 에러 발생 시
+            status_color = "red"
+        elif is_overall_view: # '전체 보기'의 경우
+            keyword_status = "O"
+            status_color = "#009879" # Green
+        else: # 특정 카테고리 선택 시
+            keyword_status = "O" if result["match_count"] > 0 else "X"
+            status_color = "#009879" if keyword_status == "O" else "red"
+
+        
+        # 매칭된 카테고리 정보
+        categories_html_list = batch_categories_info.get(keyword, ["정보 없음"])
+        categories_html = "<br>".join(categories_html_list)
+        
+        if result.get("error", False):
+            result_html += f'''
+            <div class="match-item">
+                <div class="match-keyword">{keyword}</div>
+                <div class="match-status" style="color:{status_color}; font-weight:bold;">{keyword_status}</div>
+                <div class="match-categories">분석 중 오류 발생</div>
+            </div>
+            '''
+        else:
+            match_count_display = result["match_count"]
+            total_count_display = result["total_count"]
+            
+            result_html += f'''
+            <div class="match-item">
+                <div class="match-keyword">{keyword}<span class="match-count">{match_count_display}/{total_count_display}</span></div>
+                <div class="match-status" style="color:{status_color}; font-weight:bold;">{keyword_status}</div>
+                <div class="match-categories">{categories_html}</div>
+            </div>
+            '''
+    
+    result_html += '</div></div></div>' # .analysis-result, .result-container 닫기
+    
+    return result_html
+
+def analyze_product_terms(product_name, main_keyword=""):
+    """
+    상품명에서 추출한 키워드들을 분석하여 카테고리 항목 제공 (1년, 3년 트렌드 모두 분석)
+    
+    Args:
+        product_name (str): 분석할 상품명
+        main_keyword (str): 메인 키워드 (optional)
+        
+    Returns:
+        tuple: (HTML 형식의 결과 테이블, 키워드 분석 결과 리스트, 트렌드 분석 결과)
+    """
+    global _last_keyword_results  # 함수 시작 부분에 global 선언
+    
+    # 전처리: 상품명 앞뒤 공백 제거 및 유효성 확인
+    product_name = product_name.strip() if product_name else ""
+    if not product_name:
+        return "상품명이 비어있습니다. 유효한 상품명을 입력해주세요.", [], None
+    
+    # 디버깅용 로그
+    logger.info(f"분석 시작 - 상품명: '{product_name}', 메인 키워드: '{main_keyword}'")
+    
+    # 상품명에서 키워드를 더 자연스럽게 분리 (공백과 쉼표 기준으로 분리)
+    # 수정된 부분: 정규표현식 패턴 조정 및 예외처리 추가
+    try:
+        words = []
+        # 먼저 쉼표로 분리
+        comma_parts = product_name.split(',')
+        
+        for part in comma_parts:
+            # 각 부분을 공백으로 분리
+            space_parts = part.split()
+            words.extend([word.strip() for word in space_parts if word.strip()])
+        
+        # 중복 제거 및 1글자 이상 키워드만 유지
+        words = list(set([word for word in words if len(word) >= 1]))
+        
+        logger.info(f"상품명에서 추출한 원본 키워드 (총 {len(words)}개): {words}")
+        
+        # 키워드가 하나도 추출되지 않았다면 원본 상품명 사용
+        if not words:
+            words = [product_name]
+            logger.warning(f"키워드 추출 실패, 원본 상품명 사용: '{product_name}'")
+    except Exception as e:
+        logger.error(f"키워드 추출 중 오류 발생: {e}")
+        # 오류 발생 시 원본 상품명을 그대로 사용
+        words = [product_name]
+    
+    # 메인 키워드 처리
+    if not main_keyword:
+        # 메인 키워드가 없는 경우, 오징어 관련 키워드 찾기 (기존 로직)
+        for word in words:
+            if "오징어" in word:
+                main_keyword = "오징어"
+                break
+    
+    # 원본 키워드 목록 저장
+    keywords = []
+    for word in words:
+        # 숫자, 영문 등을 포함한 모든 단어 허용
+        if word and word != main_keyword:
+            # 메인 키워드가 있고, 단어에 메인 키워드가 없으면 조합
+            if main_keyword and main_keyword not in word:
+                # 조합 키워드 생성 (자연스러운 형태로)
+                combined = f"{word} {main_keyword}"
+                if combined not in keywords:
+                    keywords.append(combined)
+            # 원래 키워드도 따로 추가 (개선: 단일 키워드도 유지)
+            if word not in keywords:
+                keywords.append(word)
+    
+    # 메인 키워드도 단독으로 추가
+    if main_keyword and main_keyword not in keywords:
+        keywords.append(main_keyword)
+    
+    if not keywords:
+        return "상품명에서 키워드를 추출할 수 없습니다.", [], None
+    
+    logger.info(f"분석할 최종 키워드 목록 (총 {len(keywords)}개): {keywords}")
+    
+    # 추출된 키워드를 배치로 나누기 (배치당 5개씩)
+    batch_size = 5
+    keyword_batches = []
+    for i in range(0, len(keywords), batch_size):
+        keyword_batches.append(keywords[i:i + batch_size])
+    
+    logger.info(f"총 {len(keyword_batches)}개 배치로 {len(keywords)}개 키워드 처리")
+    
+    # 키워드 분석 결과 저장
+    keyword_results = []
+    
+    # 각 배치 처리
+    for batch_idx, batch in enumerate(keyword_batches):
+        logger.info(f"배치 {batch_idx+1}/{len(keyword_batches)} 처리 중...")
+        
+        # 상품 검색 배치 처리
+        batch_products = {}
+        for keyword in batch:
+            # API 호출용 키워드 (공백 제거)
+            api_keyword = keyword.replace(" ", "")
+            
+            # 최대 3번 재시도
+            max_retries = 3
+            retry_count = 0
+            
+            while retry_count < max_retries:
+                try:
+                    # 키워드로 상품 검색
+                    products = product_search.fetch_naver_shopping_data_for_analysis(api_keyword, count=100)
+                    
+                    if products:
+                        batch_products[keyword] = products
+                        logger.info(f"  - '{keyword}' 상품 검색 성공: {len(products)}개")
+                        break  # 성공했으므로 루프 종료
+                    else:
+                        logger.warning(f"  - '{keyword}' 상품 없음 (시도 {retry_count+1}/{max_retries})")
+                        retry_count += 1
+                        exponential_backoff_sleep(retry_count)
+                except Exception as e:
+                    logger.error(f"  - '{keyword}' 상품 검색 중 오류: {e} (시도 {retry_count+1}/{max_retries})")
+                    retry_count += 1
+                    exponential_backoff_sleep(retry_count)
+            
+            # 최대 재시도 후에도 실패한 경우 로그 기록
+            if retry_count >= max_retries and keyword not in batch_products:
+                logger.error(f"  - '{keyword}' 최대 재시도 후 실패")
+        
+        # 검색량 조회 배치 처리
+        api_keywords = [kw.replace(" ", "") for kw in batch]
+        volumes = keyword_search.fetch_all_search_volumes(api_keywords)
+        
+        # 각 키워드 처리
+        for keyword in batch:
+            if keyword in batch_products:
+                products = batch_products[keyword]
+                
+                # 개선: 카테고리 항목과 함께 카테고리별 점유율 계산
+                category_counter = Counter()
+                for product in products:
+                    category = product.get("category", "") or product.get("카테고리", "")
+                    if category:
+                        category_counter[category] += 1
+                
+                # 카테고리와 점유율 계산
+                total_products = len(products)
+                categories_with_percentage = []
+                for category, count in category_counter.most_common():
+                    percentage = (count / total_products) * 100 if total_products > 0 else 0
+                    categories_with_percentage.append(f"{category}({percentage:.0f}%)")
+                
+                # 검색량 조회 (API 호출용 키워드 사용)
+                api_keyword = keyword.replace(" ", "")
+                volume_data = volumes.get(api_keyword, {"PC검색량": 0, "모바일검색량": 0, "총검색량": 0})
+                
+                # 결과 저장 (카테고리 항목과 카운트 정보 포함)
+                keyword_results.append({
+                    "키워드": keyword,  # UI 표시용 키워드 (공백 포함)
+                    "PC검색량": volume_data.get("PC검색량", 0),
+                    "모바일검색량": volume_data.get("모바일검색량", 0),
+                    "총검색량": volume_data.get("총검색량", 0),
+                    "검색량구간": text_utils.get_search_volume_range(volume_data.get("총검색량", 0)),
+                    "카테고리항목": "\n".join(categories_with_percentage) if categories_with_percentage else "-",
+                    "카테고리정보": dict(category_counter)  # 원본 카테고리 카운터 저장 (요약용)
+                })
+                
+                logger.info(f"  - '{keyword}' 분석 완료: 카테고리 항목 {len(category_counter)}개, 검색량 {volume_data.get('총검색량', 0)}")
+    
+    # 최종 결과 요약 출력
+    logger.info(f"키워드 분석 완료: 총 {len(keywords)}개 중 {len(keyword_results)}개 성공")
+    
+    # 결과를 검색량 기준으로 내림차순 정렬 (높은 것이 먼저 나오도록)
+    keyword_results = sorted(keyword_results, key=lambda x: x["총검색량"], reverse=True)
+    
+    # 추천 카테고리 계산
+    recommended_categories = Counter()
+    for result in keyword_results:
+        for category, count in result.get("카테고리정보", {}).items():
+            recommended_categories[category] += count
+    
+    # 추천 카테고리 상위 3개 선택
+    top_categories = recommended_categories.most_common(3)
+    
+    # 총 상품 수 계산
+    total_products_count = sum(recommended_categories.values())
+    
+    # 카테고리별 점유율 계산
+    top_categories_with_percentage = []
+    for category, count in top_categories:
+        percentage = (count / total_products_count) * 100 if total_products_count > 0 else 0
+        top_categories_with_percentage.append({
+            "카테고리": category,
+            "개수": count,
+            "점유율": f"{percentage:.0f}%"
+        })
+    
+    # 1년, 3년 트렌드 분석 실행
+    trend_results = {"1year": None, "3year": None}
+    trend_html = ""
+    
+    if keyword_results:
+        try:
+            # 트렌드 분석 모듈 import
+            import trend_analysis
+            
+            # 상위 5개 키워드로 1년, 3년 트렌드 분석
+            top_keywords = [result["키워드"] for result in keyword_results[:5]]
+            logger.info(f"1년, 3년 트렌드 분석 시작: {top_keywords}")
+            
+            # 1년 트렌드 분석
+            trend_result_1year = trend_analysis.get_trend_data(top_keywords, "1year")
+            if trend_result_1year["status"] == "success":
+                trend_results["1year"] = trend_result_1year
+            
+            # 3년 트렌드 분석
+            trend_result_3year = trend_analysis.get_trend_data(top_keywords, "3year")
+            if trend_result_3year["status"] == "success":
+                trend_results["3year"] = trend_result_3year
+            
+            # 트렌드 분석 HTML 생성 (1년, 3년 모두)
+            if trend_results["1year"] or trend_results["3year"]:
+                trend_html = f'''
+                <div class="trend-analysis-section" style="width: 100%; margin-top: 30px;">
+                    <div class="section-title">🔍 검색량 트렌드 분석</div>
+                '''
+                
+                for period, result in trend_results.items():
+                    if result and result["status"] == "success":
+                        period_text = "최근 1년" if period == "1year" else "최근 3년"
+                        
+                        # 트렌드 인사이트 추출
+                        insights = trend_analysis.analyze_trend_insights(result["trend_data"])
+                        
+                        trend_html += f'''
+                        <div class="trend-period-section" style="width: 100%; background-color: #f0f8ff; padding: 15px; border-radius: 8px; margin-bottom: 20px;">
+                            <div class="insights-title" style="font-weight: bold; margin-bottom: 15px; color: #2c7fb8;">📊 {period_text} 주요 인사이트</div>
+                            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 15px; width: 100%;">
+                        '''
+                        
+                        for keyword, insight in insights.items():
+                            growth_icon = "📈" if insight['growth_rate'] > 0 else "📉" if insight['growth_rate'] < 0 else "📊"
+                            growth_color = "#28a745" if insight['growth_rate'] > 0 else "#dc3545" if insight['growth_rate'] < 0 else "#6c757d"
+                            
+                            trend_html += f'''
+                                <div class="insight-item" style="background: white; padding: 12px; border-radius: 6px; border-left: 4px solid {growth_color};">
+                                    <div style="font-weight: bold; color: #2c7fb8; margin-bottom: 8px;">{keyword} {growth_icon}</div>
+                                    <div style="font-size: 13px; line-height: 1.4;">
+                                        <div>🏆 최고점: <strong>{insight['max_volume']:,}</strong> ({insight['max_period']})</div>
+                                        <div>📊 전체 평균: <strong>{insight['total_avg']:,}</strong></div>
+                                        <div style="color: {growth_color};">📈 성장률: <strong>{insight['growth_rate']:+.1f}%</strong></div>
+                                    </div>
+                                </div>
+                            '''
+                        
+                        trend_html += '''
+                                </div>
+                                
+                                <div class="trend-graph-container" style="width: 100%; background: white; padding: 15px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); margin-top: 15px;">
+                        '''
+                        trend_html += result["graph_html"]
+                        trend_html += '''
+                                </div>
+                            </div>
+                        '''
+                
+                trend_html += '''
+                </div>
+                '''
+                
+                logger.info(f"1년, 3년 트렌드 분석 완료")
+            else:
+                logger.warning(f"트렌드 분석 실패")
+                trend_html = '''
+                <div class="trend-analysis-section" style="width: 100%; margin-top: 30px;">
+                    <div class="section-title">🔍 검색량 트렌드 분석</div>
+                    <div style="width: 100%; background-color: #fff3cd; padding: 15px; border-radius: 8px; color: #856404;">
+                        ⚠️ 트렌드 분석을 실행할 수 없습니다. 나중에 다시 시도해주세요.
+                    </div>
+                </div>
+                '''
+        except Exception as e:
+            logger.error(f"트렌드 분석 중 오류 발생: {e}")
+            trend_html = '''
+            <div class="trend-analysis-section" style="width: 100%; margin-top: 30px;">
+                <div class="section-title">🔍 검색량 트렌드 분석</div>
+                <div style="width: 100%; background-color: #f8d7da; padding: 15px; border-radius: 8px; color: #721c24;">
+                    ❌ 트렌드 분석 중 오류가 발생했습니다.
+                </div>
+            </div>
+            '''
+    
+    # 결과를 HTML 테이블로 변환 - 너비 100% 적용
+    html = f'''
+    <style>
+    .product-analysis-table {{
+        width: 100%;
+        border-collapse: collapse;
+        margin: 25px 0;
+        font-size: 14px;
+        box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+        border-radius: 5px;
+        overflow: hidden;
+    }}
+    
+    .product-analysis-table thead tr {{
+        background-color: #009879;
+        color: white;
+        text-align: left;
+    }}
+    
+    .product-analysis-table th,
+    .product-analysis-table td {{
+        padding: 12px 15px;
+        border-bottom: 1px solid #dddddd;
+    }}
+    
+    .product-analysis-table tbody tr {{
+        background-color: white;
+    }}
+    
+    .product-analysis-table tbody tr:nth-of-type(even) {{
+        background-color: #f3f3f3;
+    }}
+    
+    .product-analysis-table tbody tr:hover {{
+        background-color: #f5f5f5;
+    }}
+    
+    .product-analysis-table tbody tr:last-of-type {{
+        border-bottom: 2px solid #009879;
+    }}
+    
+    .section-title {{
+        font-size: 18px;
+        font-weight: bold;
+        color: #009879;
+        margin-bottom: 15px;
+        padding-bottom: 5px;
+        border-bottom: 2px solid #009879;
+    }}
+    
+    .summary-box {{
+        width: 100%;
+        background-color: #f5f5f5;
+        border-left: 4px solid #009879;
+        padding: 10px 15px;
+        margin-bottom: 20px;
+        font-size: 14px;
+    }}
+    
+    .summary-title {{
+        font-weight: bold;
+        margin-bottom: 5px;
+    }}
+    
+    .recommendation-box {{
+        width: 100%;
+        background-color: #e7f7f3;
+        border-radius: 5px;
+        padding: 15px;
+        margin-bottom: 25px;
+        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+    }}
+    
+    .recommendation-title {{
+        font-weight: bold;
+        font-size: 16px;
+        color: #009879;
+        margin-bottom: 10px;
+    }}
+    
+    .recommendation-item {{
+        padding: 6px 0;
+        border-bottom: 1px solid #e0e0e0;
+    }}
+    
+    .recommendation-item:last-child {{
+        border-bottom: none;
+    }}
+    </style>
+    
+    <div style="width: 100%;">
+        <div class="section-title">상품명 키워드 분석 결과</div>
+        
+        <div class="summary-box">
+            <div class="summary-title">분석 요약</div>
+            <p>총 <strong>{len(keyword_results)}</strong>개 키워드 분석</p>
+            <p>메인 키워드: <strong>{main_keyword if main_keyword else '없음'}</strong></p>
+        </div>
+        
+        <div class="recommendation-box">
+            <div class="recommendation-title">추천 카테고리</div>
+    '''
+    
+    # 추천 카테고리 목록 추가
+    for idx, cat_info in enumerate(top_categories_with_percentage, 1):
+        html += f'''
+        <div class="recommendation-item">
+            추천 카테고리 {idx} : {cat_info['카테고리']}({cat_info['점유율']})
+        </div>
+        '''
+    
+    html += '''
+        </div>
+        
+        <table class="product-analysis-table">
+            <thead>
+                <tr>
+                    <th>순번</th>
+                    <th>키워드</th>
+                    <th>PC검색량</th>
+                    <th>모바일검색량</th>
+                    <th>총검색량</th>
+                    <th>검색량구간</th>
+                    <th>카테고리항목</th>
+                </tr>
+            </thead>
+            <tbody>
+    '''
+    
+    for idx, result in enumerate(keyword_results):
+        # 카테고리 항목 준비 (줄바꿈을 <br>로 변환)
+        category_items = result.get("카테고리항목", "-").replace("\n", "<br>")
+        
+        html += f'''
+        <tr>
+            <td>{idx + 1}</td>
+            <td>{result["키워드"]}</td>
+            <td>{result["PC검색량"]:,}</td>
+            <td>{result["모바일검색량"]:,}</td>
+            <td>{result["총검색량"]:,}</td>
+            <td>{result["검색량구간"]}</td>
+            <td>{category_items}</td>
+        </tr>
+        '''
+    
+    html += '''
+            </tbody>
+        </table>
+    </div>
+    '''
+    
+    # 트렌드 분석 HTML 추가
+    html += trend_html
+    
+    # 분석 결과가 없는 경우 안내 메시지
+    if not keyword_results:
+        html += '''
+        <div style="width: 100%; margin-top: 20px; padding: 15px; background-color: #f1f1f1; border-radius: 5px; text-align: center;">
+            <p>표시할 키워드가 없습니다. 다른 상품명을 입력해보세요.</p>
+        </div>
+        '''
+    
+    # 분석 결과를 전역 변수에 저장 (다운로드용)
+    _last_keyword_results = keyword_results
+    
+    # HTML과 함께 키워드 분석 결과 및 트렌드 결과도 함께 반환
+    return html, keyword_results, trend_results
+
+def collect_categories_per_keyword(keywords, max_products=10):
+    """
+    키워드마다 상품 n개를 호출하여 카테고리 집합 반환
+    
+    Args:
+        keywords (list): 키워드 목록
+        max_products (int): 키워드당 검색할 최대 상품 수
+        
+    Returns:
+        dict: 키워드별 카테고리 집합을 담은 사전 {키워드: {카테고리1, 카테고리2, ...}}
+    """
+    logger.info(f"키워드별 카테고리 수집 시작: {len(keywords)}개 키워드")
+    keyword_category_map = {}
+    
+    # 배치 처리를 위한 준비
+    batch_size = 5
+    batches = []
+    for i in range(0, len(keywords), batch_size):
+        batches.append(keywords[i:i + batch_size])
+    
+    logger.info(f"총 {len(batches)}개 배치로 {len(keywords)}개 키워드 처리")
+    
+    # 각 배치 처리
+    for batch_idx, batch in enumerate(batches):
+        logger.info(f"배치 {batch_idx+1}/{len(batches)} 처리 중...")
+        
+        for keyword in batch:
+            # API 호출용 키워드 (공백 제거)
+            api_keyword = keyword.replace(" ", "")
+            
+            max_retries = 3
+            retry_count = 0
+            
+            while retry_count < max_retries:
+                try:
+                    # 키워드로 상품 검색
+                    products = product_search.fetch_naver_shopping_data_for_analysis(api_keyword, count=max_products)
+                    
+                    if products:
+                        # 카테고리 추출
+                        categories = set()
+                        for product in products:
+                            # 두 가지 키 모두 시도 (category와 카테고리)
+                            category = product.get("category", "") or product.get("카테고리", "")
+                            if category:
+                                categories.add(category)
+                        
+                        keyword_category_map[keyword] = categories
+                        logger.info(f"  - '{keyword}' 카테고리 수집 완료: {len(categories)}개")
+                        break  # 성공했으므로 루프 종료
+                    else:
+                        logger.warning(f"  - '{keyword}' 상품 검색 결과 없음 (시도 {retry_count+1}/{max_retries})")
+                        retry_count += 1
+                        exponential_backoff_sleep(retry_count)
+                
+                except Exception as e:
+                    logger.error(f"  - '{keyword}' 처리 중 오류: {e} (시도 {retry_count+1}/{max_retries})")
+                    retry_count += 1
+                    exponential_backoff_sleep(retry_count)
+            
+            if retry_count >= max_retries:
+                logger.error(f"  - '{keyword}' 최대 재시도 후 실패")
+                keyword_category_map[keyword] = set()
+            
+            # API 레이트 리밋 방지 (안정적인 지연으로 변경)
+            exponential_backoff_sleep(0)  # 초기 지연 적용
+    
+    logger.info(f"키워드별 카테고리 수집 완료: {len(keyword_category_map)}개")
+    return keyword_category_map

export_utils.py

@@ -0,0 +1,510 @@
+"""
+결과 출력 관련 유틸리티 함수 모음 - 카테고리 항목 제거 + 키워드 클릭 시 네이버 쇼핑 이동 기능 추가
+- HTML 테이블 생성
+- 엑셀 파일 생성
+- 키워드 클릭 시 네이버 쇼핑 링크 기능
+"""
+
+import pandas as pd
+import tempfile
+import os
+import threading
+import time
+import logging
+import urllib.parse  # URL 인코딩을 위해 추가
+
+# 로깅 설정
+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",
+        "연관 키워드": "col-keyword",  # 연관검색어 분석용 추가
+        "키워드": "col-keyword",        # 일반 키워드용 추가
+        "PC검색량": "col-pc",
+        "모바일검색량": "col-mobile",
+        "총검색량": "col-total",
+        "검색량구간": "col-range",
+        "키워드 사용자순위": "col-rank",
+        "키워드 사용횟수": "col-count"
+        # 카테고리 관련 매핑 제거됨
+    }
+    
+    # 네이버 쇼핑 링크 생성 함수
+    def create_naver_shopping_link(keyword):
+        """키워드를 네이버 쇼핑 링크로 변환"""
+        # URL 인코딩 (한글 키워드 처리)
+        encoded_keyword = urllib.parse.quote(keyword.strip())
+        naver_shopping_url = f"https://search.shopping.naver.com/search/all?where=all&frm=NVSCTAB&query={encoded_keyword}"
+        
+        # 링크가 포함된 HTML 반환
+        return f'''<a href="{naver_shopping_url}" target="_blank" class="keyword-link" title="네이버 쇼핑에서 '{keyword}' 검색하기">
+                    {keyword}
+                    <span class="keyword-tooltip">클릭하면 네이버 쇼핑으로 이동</span>
+                   </a>'''
+    
+    # 테이블 컨테이너 시작
+    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 in ["조합 키워드", "연관 키워드", "키워드"]:
+                # 키워드 셀에 네이버 쇼핑 링크 적용
+                keyword_with_link = create_naver_shopping_link(value)
+                html += f'<td class="{col_class}">{keyword_with_link}</td>'
+            elif 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 닫기
+    
+    # 사용법 안내 추가
+    html += '''
+    <div style="margin-top: 15px; padding: 12px; background: #e8f5e8; border-radius: 8px; border-left: 4px solid #009879;">
+        <div style="font-weight: bold; color: #155724; margin-bottom: 5px;">💡 사용팁</div>
+        <div style="font-size: 14px; color: #155724;">
+            키워드를 클릭하면 네이버 쇼핑에서 해당 키워드로 검색한 결과를 새 창에서 확인할 수 있습니다.
+        </div>
+    </div>
+    '''
+    
+    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,1687 @@
+"""
+키워드 매칭 및 상승폭 계산 개선 - 전체 코드
+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,918 @@
+"""
+       
+       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_processor.py

@@ -0,0 +1,388 @@
+"""
+키워드 처리 관련 기능 - 앞뒤 조합 중 높은 검색량만 선택, 카테고리 항목 제거
+- 키워드 추출 및 조합
+- 검색 결과 처리
+"""
+
+import pandas as pd
+import re
+from collections import defaultdict, Counter
+import text_utils
+import keyword_search
+import product_search
+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 process_search_results(search_results, current_keyword="", exclude_zero_volume=True):
+    """
+    검색 결과에서 키워드와 카테고리 정보 추출 및 처리 - 앞뒤 조합 중 높은 검색량만 선택
+    
+    Args:
+        search_results (dict): 검색 결과 정보
+        current_keyword (str): 현재 검색 중인 키워드
+        exclude_zero_volume (bool): 검색량이 0인 키워드 제외 여부
+        
+    Returns:
+        dict: 처리된 결과
+    """
+    logger.info("\n===== 검색 결과 처리 시작 =====")
+    logger.info(f"현재 키워드: '{current_keyword}'")
+    logger.info(f"검색량 0 키워드 제외: {exclude_zero_volume}")
+    
+    if not search_results or not search_results.get("product_list"):
+        logger.warning("검색 결과가 없습니다.")
+        return {
+            "products_df": None,
+            "keywords_df": None,
+            "categories": ["전체 보기"],
+            "message": "검색 결과가 없습니다."
+        }
+    
+    product_list = search_results["product_list"]
+    combo_candidates = search_results["combo_candidates"]
+    category_counter = search_results["category_counter"]
+    keyword_indices = search_results["keyword_indices"]
+    keyword_pairs = search_results.get("keyword_pairs", {})  # 앞뒤 조합 정보
+    
+    logger.info(f"검색 결과 - 상품 수: {len(product_list)}개")
+    logger.info(f"검색 결과 - 조합 후보 수: {len(combo_candidates)}개")
+    logger.info(f"검색 결과 - 카테고리 수: {len(category_counter)}개")
+    
+    # 상품 정보 데이터프레임 생성
+    df_products = pd.DataFrame(product_list)
+    
+    # API 키워드를 UI 키워드로 변환하는 매핑 생성
+    api_to_ui_keywords = {}
+    
+    for api_keyword in combo_candidates.keys():
+        # API 키워드에서 UI 키워드로 변환
+        if current_keyword and current_keyword in api_keyword:
+            # 메인 키워드 자체인 경우
+            if api_keyword == current_keyword:
+                api_to_ui_keywords[api_keyword] = current_keyword
+                continue
+                
+            # 메인 키워드가 이미 포함된 경우 (예: 갑오징어, 귀오징어)
+            # 공백 있는 형태로 변환
+            ui_keyword = api_keyword
+            # 공백이 없는 형태라면 적절한 위치에 공백 추가
+            if " " not in api_keyword:
+                # 메인 키워드 기준으로 분리
+                if api_keyword.startswith(current_keyword):
+                    # 오징어갑 => 오징어 갑
+                    prefix = current_keyword
+                    suffix = api_keyword[len(current_keyword):]
+                    if suffix:
+                        ui_keyword = f"{prefix} {suffix}"
+                elif api_keyword.endswith(current_keyword):
+                    # 갑오징어 => 갑 오징어
+                    prefix = api_keyword[:-len(current_keyword)]
+                    suffix = current_keyword
+                    if prefix:
+                        ui_keyword = f"{prefix} {suffix}"
+                else:
+                    # 메인 키워드가 중간에 있는 경우
+                    idx = api_keyword.find(current_keyword)
+                    if idx > 0:
+                        prefix = api_keyword[:idx]
+                        middle = current_keyword
+                        suffix = api_keyword[idx+len(current_keyword):]
+                        ui_keyword = f"{prefix} {middle}"
+                        if suffix:
+                            ui_keyword += f" {suffix}"
+            
+            api_to_ui_keywords[api_keyword] = ui_keyword
+        else:
+            # 메인 키워드가 없는 경우 - 그대로 사용
+            api_to_ui_keywords[api_keyword] = api_keyword
+    
+    # === 수정된 부분: 검색량 조회 후 앞뒤 조합 중 높은 것만 선택 ===
+    logger.info(f"\n검색량 조회 대상 키워드 수: {len(combo_candidates)}개")
+    search_volumes = keyword_search.fetch_all_search_volumes(list(combo_candidates.keys()))
+    logger.info(f"검색량 조회 완료: {len(search_volumes)}개 결과")
+    
+    # 앞뒤 조합 중 높은 검색량만 선택
+    if keyword_pairs and current_keyword:
+        logger.info("\n=== 앞뒤 조합 중 높은 검색량 선택 ===")
+        filtered_candidates = {}
+        
+        # 메인 키워드는 항상 포함
+        main_api = current_keyword.replace(" ", "")
+        if main_api in combo_candidates:
+            filtered_candidates[main_api] = combo_candidates[main_api]
+            logger.info(f"메인 키워드 유지: '{current_keyword}'")
+        
+        # 메인 키워드가 포함된 복합어도 유지
+        for api_kw, categories in combo_candidates.items():
+            ui_kw = api_to_ui_keywords[api_kw]
+            if current_keyword in ui_kw and api_kw != main_api and api_kw not in [pair_info["front"].replace(" ", "") for pair_info in keyword_pairs.values()] and api_kw not in [pair_info["back"].replace(" ", "") for pair_info in keyword_pairs.values()]:
+                filtered_candidates[api_kw] = categories
+                logger.info(f"메인 키워드 포함 복합어 유지: '{ui_kw}'")
+        
+        # 앞뒤 조합 비교
+        for base_word, pair_info in keyword_pairs.items():
+            front_kw = pair_info["front"]  # "키워드 메인키워드"
+            back_kw = pair_info["back"]    # "메인키워드 키워드"
+            
+            front_api = front_kw.replace(" ", "")
+            back_api = back_kw.replace(" ", "")
+            
+            front_vol = search_volumes.get(front_api, {}).get("총검색량", 0)
+            back_vol = search_volumes.get(back_api, {}).get("총검색량", 0)
+            
+            # 높은 검색량 선택
+            if front_vol > back_vol:
+                selected_api = front_api
+                selected_kw = front_kw
+                selected_vol = front_vol
+                removed_kw = back_kw
+                removed_vol = back_vol
+            elif back_vol > front_vol:
+                selected_api = back_api
+                selected_kw = back_kw
+                selected_vol = back_vol
+                removed_kw = front_kw
+                removed_vol = front_vol
+            elif front_vol == back_vol and front_vol > 0:
+                # 같은 검색량이면 더 자연스러운 순서 선택 (메인키워드가 뒤에 오는 것)
+                selected_api = back_api
+                selected_kw = back_kw
+                selected_vol = back_vol
+                removed_kw = front_kw
+                removed_vol = front_vol
+            else:
+                # 둘 다 0이면 제외
+                logger.info(f"  '{base_word}' 조합: 둘 다 검색량 0으로 제외")
+                continue
+            
+            # 선택된 키워드만 추가
+            if selected_vol > 0 or not exclude_zero_volume:
+                filtered_candidates[selected_api] = combo_candidates[selected_api]
+                logger.info(f"  '{base_word}' 조합 선택: '{selected_kw}' ({selected_vol:,}) > '{removed_kw}' ({removed_vol:,})")
+            else:
+                logger.info(f"  '{base_word}' 조합: 검색량 0으로 제외")
+        
+        # 필터링된 조합으로 교체
+        combo_candidates = filtered_candidates
+        logger.info(f"앞뒤 조합 필터링 완료: {len(combo_candidates)}개 키워드 선택")
+    
+    # 검색량 0 키워드 통계
+    zero_volume_count = sum(1 for vol in search_volumes.values() if vol.get("총검색량", 0) == 0)
+    logger.info(f"검색량 0인 키워드 수: {zero_volume_count}개 ({zero_volume_count/max(1, len(search_volumes))*100:.1f}%)")
+    
+    # 중복 키워드 제거를 위한 정규화된 키워드 집합
+    normalized_keywords = {}
+    
+    for api_keyword in combo_candidates.keys():
+        ui_keyword = api_to_ui_keywords[api_keyword]
+        
+        # 검색량 정보 가져오기
+        pc_count = 0
+        mobile_count = 0
+        total_count = 0
+        if api_keyword in search_volumes:
+            pc_count = search_volumes[api_keyword]["PC검색량"]
+            mobile_count = search_volumes[api_keyword]["모바일검색량"]
+            total_count = search_volumes[api_keyword]["총검색량"]
+        
+        # 검색량 0인 키워드 제외 옵션 적용
+        if exclude_zero_volume and total_count == 0:
+            logger.debug(f"  - '{ui_keyword}' (API: '{api_keyword}') - 검색량 0으로 제외됨")
+            continue
+        
+        # 1. 공백을 기준으로 단어 분리 후 정렬해 정규화 키 생성
+        words = ui_keyword.split()
+        normalized = "".join(sorted(words))
+        
+        # 2. 이미 정규화된 키워드가 있으면 검색량이 더 높은 것을 선택
+        if normalized in normalized_keywords:
+            existing_api_keyword, existing_ui_keyword, existing_total = normalized_keywords[normalized]
+            if total_count > existing_total:
+                logger.debug(f"  - 중복 키워드 대체: '{existing_ui_keyword}' ({existing_total}) -> '{ui_keyword}' ({total_count})")
+                normalized_keywords[normalized] = (api_keyword, ui_keyword, total_count)
+            else:
+                logger.debug(f"  - 중복 키워드 제외: '{ui_keyword}' ({total_count}) < '{existing_ui_keyword}' ({existing_total})")
+        else:
+            normalized_keywords[normalized] = (api_keyword, ui_keyword, total_count)
+            logger.debug(f"  - 키워드 추가: '{ui_keyword}' (검색량: {total_count})")
+    
+    logger.info(f"\n중복 제거 후 키워드 수: {len(normalized_keywords)}개")
+    
+    # 중복이 제거된 키워드만 처리
+    final_combos = []
+    for normalized, (api_keyword, ui_keyword, total_count) in normalized_keywords.items():
+        
+        # 키워드 가독성 개선 - fix_keyword_order 함수 적용
+        readable = fix_keyword_order(ui_keyword, current_keyword)
+        
+        # 검색량 정보 가져오기
+        pc_count = 0
+        mobile_count = 0
+        if api_keyword in search_volumes:
+            pc_count = search_volumes[api_keyword]["PC검색량"]
+            mobile_count = search_volumes[api_keyword]["모바일검색량"]
+            total_count = search_volumes[api_keyword]["총검색량"]
+        
+        # 검색량 구간 계산
+        search_volume_range = text_utils.get_search_volume_range(total_count)
+        
+        # 등장 순위 및 횟수 계산
+        base_word = readable.replace(current_keyword, "").strip() if current_keyword else readable
+        ranks = []
+        if base_word in keyword_indices:
+            ranks = [idx + 1 for idx in keyword_indices[base_word]]
+        elif api_keyword in keyword_indices:  # 메인 키워드가 포함된 단어인 경우
+            ranks = [idx + 1 for idx in keyword_indices.get(api_keyword, [])]
+        
+        ranks_str = ", ".join(map(str, ranks)) if ranks else "-"
+        usage_count = len(ranks)
+        
+        # === 수정된 부분: "상품 등록 카테고리(상위100위)" 항목 제거 ===
+        # 카테고리 정보는 내부적으로만 사용하고 테이블에는 표시하지 않음
+        
+        final_combos.append({
+            "조합 키워드": readable.strip(),
+            "PC검색량": pc_count,
+            "모바일검색량": mobile_count,
+            "총검색량": total_count,
+            "검색량구간": search_volume_range,
+            "키워드 사용자순위": ranks_str,
+            "키워드 사용횟수": usage_count
+            # "상품 등록 카테고리(상위100위)" 항목 제거됨
+        })
+    
+    # 키워드 정보 데이터프레임 생성
+    df_keywords = pd.DataFrame(final_combos)
+    
+    # 검색량 기준으로 내림차순 정렬
+    if not df_keywords.empty:
+        df_keywords = df_keywords.sort_values(by="총검색량", ascending=False)
+        # 순번을 위해 인덱스 리셋 (순차적 순번 보장)
+        df_keywords = df_keywords.reset_index(drop=True)
+    
+    # 데이터프레임 생성 후 로깅
+    logger.info(f"\n생성된 키워드 데이터프레임 행 수: {len(df_keywords)}")
+    if not df_keywords.empty:
+        logger.debug(f"데이터프레임 열: {df_keywords.columns.tolist()}")
+        logger.info(f"총 {len(df_keywords)}개 키워드 생성 완료")
+    
+    # 카테고리 정보 가공
+    category_with_counts = [f"{cat} ({category_counter[cat]})" for cat in sorted(category_counter.keys())]
+    category_with_counts.insert(0, "전체 보기")
+    
+    logger.info(f"카테고리 수: {len(category_counter)}개")
+    logger.info("===== 검색 결과 처리 완료 =====\n")
+
+    return {
+        "products_df": df_products,
+        "keywords_df": df_keywords,
+        "categories": category_with_counts,
+        "message": "✅ 검색이 완료되었습니다. 아래에서 키워드를 확인하세요."
+    }
+
+def filter_and_sort_table(df, selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume=False):
+    """테이블 필터링 및 정렬 함수 (검색량 0 제외 기능 추가)"""
+    if df is None or df.empty:
+        return ""
+        
+    # 필터링 적용
+    filtered = df.copy()
+    
+    # 카테고리 필터 적용 (카테고리 열이 제거되었으므로 주석 처리)
+    # if selected_cat and selected_cat != "전체 보기":
+    #     cat_name = selected_cat.rsplit(" (", 1)[0]
+    #     filtered = filtered[filtered["관련 카테고리"].str.contains(cat_name)]
+    
+    # 검색량 구간 필터 적용
+    if selected_volume_range and selected_volume_range != "전체":
+        filtered = filtered[filtered["검색량구간"] == selected_volume_range]
+    
+    # 검색량 0 제외 필터 적용
+    if exclude_zero_volume:
+        filtered = filtered[filtered["총검색량"] > 0]
+        logger.info(f"검색량 0 제외 필터 적용 - 남은 키워드 수: {len(filtered)}")
+    
+    # 정렬 적용
+    if keyword_sort != "정렬 없음":
+        is_ascending = keyword_sort == "오름차순"
+        filtered = filtered.sort_values(by="조합 키워드", ascending=is_ascending)
+    
+    if total_volume_sort != "정렬 없음":
+        is_ascending = total_volume_sort == "오름차순"
+        filtered = filtered.sort_values(by="총검색량", ascending=is_ascending)
+        
+    # 키워드 사용횟수 정��� 적용
+    if usage_count_sort != "정렬 없음":
+        is_ascending = usage_count_sort == "오름차순"
+        filtered = filtered.sort_values(by="키워드 사용횟수", ascending=is_ascending)
+    
+    # 데이터프레임 내용 로깅
+    logger.info(f"필터 적용 후 - 필터링된 DataFrame 행 수: {len(filtered)}")
+    
+    # 순번을 1부터 순차적으로 유지하기 위해 행 인덱스 재설정
+    filtered = filtered.reset_index(drop=True)
+    
+    from export_utils import create_table_without_checkboxes
+    
+    # 순번을 포함한 HTML 테이블 생성
+    html = create_table_without_checkboxes(filtered)
+    
+    return html
+
+def fix_keyword_order(keyword, main_keyword):
+    """
+    키워드 순서를 수정하는 함수 - 한글이 앞에 오고 영어/숫자가 뒤에 오도록 함
+    
+    Args:
+        keyword (str): 수정할 키워드
+        main_keyword (str): 메인 키워드
+        
+    Returns:
+        str: 순서가 수정된 키워드
+    """
+    # 공백 없이 숫자+영어와 한글이 붙어있는 패턴 처리
+    # 예: "300g오징어" → "오징어 300g"
+    pattern_combined = re.compile(r'^([0-9]+[a-zA-Z]*)([가-힣]+.*)$')
+    match = pattern_combined.match(keyword)
+    if match:
+        number_part = match.group(1)  # 숫자+영어 부분
+        korean_part = match.group(2)  # 한글 부분
+        fixed_keyword = f"{korean_part} {number_part}"
+        logger.debug(f"붙어있는 패턴 수정: '{keyword}' -> '{fixed_keyword}'")
+        return fixed_keyword
+    
+    # 공백으로 분리된 경우 처리
+    if ' ' in keyword:
+        parts = keyword.split()
+        
+        # 한글 포함 여부와 영어/숫자 포함 여부를 각 부분별로 확인
+        korean_parts = []
+        non_korean_parts = []
+        
+        for part in parts:
+            if re.search(r'[가-힣]', part):
+                korean_parts.append(part)  # 한글이 포함된 부분
+            else:
+                non_korean_parts.append(part)  # 한글이 없는 부분 (영어, 숫자, 기호 등)
+        
+        # 한글 부분이 하나도 없거나 비한글 부분이 하나도 없으면 그대로 반환
+        if not korean_parts or not non_korean_parts:
+            return keyword
+        
+        # 한글 부분을 앞으로, 비한글 부분을 뒤로 배치
+        fixed_keyword = " ".join(korean_parts + non_korean_parts)
+        
+        # 원래 키워드와 다른 경우에만 로그 출력
+        if fixed_keyword != keyword:
+            logger.debug(f"키워드 순서 수정: '{keyword}' -> '{fixed_keyword}'")
+        
+        return fixed_keyword
+    
+    return keyword

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

product_search.py

@@ -0,0 +1,430 @@
+"""
+상품 검색 관련 기능 - 메인키워드 앞뒤 조합만 생성하도록 수정
+- 네이버 쇼핑 API를 통한 상품 검색
+- 검색 결과 처리
+"""
+
+import requests
+import time
+import re
+import random
+from collections import defaultdict, Counter
+import api_utils
+import text_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)
+
+# 모듈 레벨에서 Gemini 모델 초기화 (싱글톤 패턴)
+gemini_model = None
+try:
+    gemini_model = text_utils.get_gemini_model()
+    logger.info("Gemini 모델 초기화 성공")
+except Exception as e:
+    logger.error(f"Gemini 모델 초기화 실패: {e}")
+
+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 extract_keywords_with_dedup(titles):
+    """
+    상품명에서 키워드를 추출하고 즉시 중복을 제거하는 함수
+    
+    Args:
+        titles (list): 상품명 목록
+        
+    Returns:
+        list: 중복이 제거된 키워드 목록
+    """
+    all_words = []
+    
+    for title in titles:
+        # 상품명에서 키워드 추출 (공백과 쉼표 기준)
+        words = re.split(r'[,\s]+', title)
+        all_words.extend(words)
+    
+    # 빈 문자열 제거 및 정리
+    all_words = [word.strip() for word in all_words if word.strip() and len(word.strip()) >= 2]
+    
+    # 중복 제거 - 정규화 기반 (스페이스 차이 무시)
+    normalized_dict = {}
+    
+    for word in all_words:
+        # 정규화: 소문자 변환, 공백 제거
+        normalized = word.lower().replace(" ", "")
+        
+        # 이미 있는 경우, 가독성이 좋은 버전(공백 있는) 선택
+        if normalized in normalized_dict:
+            existing = normalized_dict[normalized]
+            # 공백이 있는 버전 선호
+            if " " in word and " " not in existing:
+                normalized_dict[normalized] = word
+        else:
+            normalized_dict[normalized] = word
+    
+    # 정규화된 딕셔너리에서 원본 형태 추출
+    return list(normalized_dict.values())
+
+def fetch_naver_shopping_data(keyword, korean_only=True, apply_main_keyword=True, exclude_zero_volume=True):
+    """
+    네이버 쇼핑 API를 통해 상품 데이터 가져오기 - 메인키워드 앞뒤 조합만 생성
+    
+    Args:
+        keyword (str): 검색 키워드
+        korean_only (bool): 한글만 추출 여부
+        apply_main_keyword (bool): 메인키워드 적용 여부
+        exclude_zero_volume (bool): 검색량이 0인 키워드 제외 여부
+        
+    Returns:
+        dict: 검색 결과 데이터
+    """
+    global gemini_model
+
+    # 1. 스페이스바 제거 개선 - 입력 키워드 전처리
+    cleaned_keyword = keyword.strip().replace(" ", "") if keyword else ""    
+    
+    # 로그 추가 - 함수 시작
+    logger.info(f"===== 키워드 검색 시작 =====")
+    logger.info(f"검색 키워드: '{keyword}'")
+    logger.info(f"옵션: 한글만 추출={korean_only}, 메인키워드 적용={apply_main_keyword}")
+    logger.info(f"Gemini 모델 상태: {'사용 가능' if gemini_model else '사용 불가'}")
+    
+    # 공백 제거한 키워드로 API 호출
+    api_keyword = cleaned_keyword
+    logger.info(f"API 호출 키워드: '{api_keyword}'")
+    
+    # 네이버 쇼핑 API 호출 
+    all_products = []
+    total_count = 0
+    
+    if apply_main_keyword:
+        # 메인 키워드 적용 시 한 번에 100개 상품 가져오기
+        logger.info("메인 키워드 적용 - 한 번에 100개 상품 가져오기")
+        result = fetch_products_by_keyword(api_keyword, page=1, display=100)
+        if result["status"] == "success" and result["products"]:
+            all_products.extend(result["products"])
+            total_count = result.get("total", 0)
+            logger.info(f"한 번에 {len(result['products'])}개 상품 검색됨")
+    else:
+        # 메인 키워드 미적용 시 페이지당 10개씩 최대 10페이지 가져오기
+        logger.info("메인 키워드 미적용 - 페이지당 10개씩 가져오기")
+        for page in range(1, 11):  # 1~10 페이지
+            result = fetch_products_by_keyword(api_keyword, page=page, display=100)
+            if result["status"] == "success" and result["products"]:
+                all_products.extend(result["products"])
+                total_count = result.get("total", 0)
+                logger.info(f"페이지 {page}: {len(result['products'])}개 상품 검색됨")
+            else:
+                logger.info(f"페이지 {page}: 상품 검색 실패 또는 결과 없음")
+            
+            # API 레이트 리밋 방지를 위한 짧은 대기 시간
+            exponential_backoff_sleep(0)  # 초기 지연
+            
+            # 이미 충분한 상품을 가져왔거나 더 이상 결과가 없으면 중단
+            if len(all_products) >= 100 or (result["status"] == "success" and len(result["products"]) < 10):
+                break
+    
+    if not all_products:
+        logger.warning("검색 결과가 없습니다.")
+        return {
+            "product_list": [],
+            "combo_candidates": {},
+            "category_counter": {},
+            "keyword_indices": {},
+            "keyword_pairs": {}
+        }
+    
+    logger.info(f"검색 결과: 총 {len(all_products)}개의 상품을 찾았습니다. (전체 검색 결과: {total_count}개)")
+    
+    # 상품 데이터에서 키워드 추출
+    product_list = []
+    combo_candidates = {}
+    category_counter = {}
+    keyword_indices = {}
+    keyword_pairs = {}  # 앞뒤 조합 정보 저장
+    
+    all_extracted_keywords = set()  # 모든 추출된 키워드 추적
+    
+    # 각 상품 처리
+    for idx, product in enumerate(all_products):
+        # 상품 정보 추출
+        title = product.get("상품명", "")
+        category = product.get("카테고리", "")
+        
+        logger.debug(f"\n상품 #{idx+1}: '{title}' (카테고리: {category})")
+        
+        # 상품명에서 키워드 추출 - 1글자 이상 단어도 포함하도록 변경
+        keywords = text_utils.clean_and_split(title, only_korean=korean_only)
+        logger.debug(f"  - 추출된 키워드 ({len(keywords)}개): {keywords}")
+        
+        # 모든 추출된 키워드 추적
+        all_extracted_keywords.update(keywords)
+        
+        # 키워드 위치 기록
+        for kw in keywords:
+            if kw not in keyword_indices:
+                keyword_indices[kw] = []
+            if idx not in keyword_indices[kw]:
+                keyword_indices[kw].append(idx)
+        
+        # 카테고리 카운터 업데이트
+        if category not in category_counter:
+            category_counter[category] = 0
+        category_counter[category] += 1
+        
+        # 상품 정보 저장
+        product_list.append(product)
+    
+    logger.info(f"\n총 추출된 고유 키워드: {len(all_extracted_keywords)}개")
+    logger.debug(f"추출된 고유 키워드 목록: {sorted(list(all_extracted_keywords))}")
+    
+    # === 수정된 부분: 메인키워드 앞뒤 조합만 생성 ===
+    if apply_main_keyword:
+        logger.info(f"\n메인 키워드 '{keyword}'로 앞뒤 조합만 생성:")
+        combo_count = 0
+        
+        # 메인 키워드 자체도 추가
+        combo_candidates[keyword] = set([category for category in category_counter.keys()])
+        logger.info(f"  - 메인 키워드 추가: '{keyword}'")
+        
+        # 메인 키워드와 앞뒤 조합 생성
+        main_keyword = keyword.strip()
+        
+        for kw in all_extracted_keywords:
+            if kw == main_keyword:
+                continue
+                
+            # 메인 키워드가 이미 포함된 경우는 그대로 추가
+            if main_keyword in kw:
+                kw_api = kw.replace(" ", "")
+                if kw_api not in combo_candidates:
+                    combo_candidates[kw_api] = set()
+                for cat in category_counter.keys():
+                    combo_candidates[kw_api].add(cat)
+                logger.info(f"  - 메인 키워드 포함 단어 추가: '{kw}' (API: '{kw_api}')")
+                combo_count += 1
+                continue
+            
+            # 앞뒤 조합 생성
+            front_combo = f"{kw} {main_keyword}"  # 키워드 + 메인키워드
+            back_combo = f"{main_keyword} {kw}"   # 메인키워드 + 키워드
+            
+            # 앞뒤 조합 정보 저장
+            keyword_pairs[kw] = {
+                "front": front_combo,
+                "back": back_combo
+            }
+            
+            # API 호출을 위한 공백 없는 버전
+            front_api = front_combo.replace(" ", "")
+            back_api = back_combo.replace(" ", "")
+            
+            logger.debug(f"  - 조합 생성: '{front_combo}' (API: '{front_api}') / '{back_combo}' (API: '{back_api}')")
+            
+            # 첫 번째 조합 처리
+            if front_api not in combo_candidates:
+                combo_candidates[front_api] = set()
+            for cat in category_counter.keys():
+                combo_candidates[front_api].add(cat)
+            combo_count += 1
+            
+            # 두 번째 조합 처리
+            if back_api not in combo_candidates:
+                combo_candidates[back_api] = set()
+            for cat in category_counter.keys():
+                combo_candidates[back_api].add(cat)
+            combo_count += 1
+
+        logger.info(f"조합 생성 완료: 총 {combo_count}개 조합 생성")
+    else:
+        logger.info("\n메인 키워드 적용 안함 - 개별 키워드만 사용")
+        for kw in all_extracted_keywords:
+            kw_api = kw.replace(" ", "")
+            if kw_api not in combo_candidates:
+                combo_candidates[kw_api] = set()
+            for cat in category_counter.keys():
+                combo_candidates[kw_api].add(cat)
+    
+    logger.info(f"\n최종 조합 키워드 수: {len(combo_candidates)}개")
+    logger.debug(f"조합 키워드 샘플(최대 10개): {list(combo_candidates.keys())[:10]}")
+    logger.info("===== 키워드 검색 완료 =====\n")
+    
+    return {
+        "product_list": product_list,
+        "combo_candidates": combo_candidates,
+        "category_counter": category_counter,
+        "keyword_indices": keyword_indices,
+        "keyword_pairs": keyword_pairs  # 앞뒤 조합 정보 추가
+    }
+
+def fetch_products_by_keyword(keyword, page=1, display=10, max_retries=3):
+    """
+    네이버 쇼핑 API를 통해 키워드로 상품 검색
+    
+    Args:
+        keyword (str): 검색 키워드
+        page (int): 페이지 번호
+        display (int): 한 페이지에 표시할 상품 수 (최대 100)
+        max_retries (int): 최대 재시도 횟수
+        
+    Returns:
+        dict: 검색 결과
+    """
+    # 상품 수가 100을 초과하지 않도록 제한
+    if display > 100:
+        display = 100
+        logger.info(f"상품 표시 수 100으로 제한됨")
+    
+    retry_count = 0
+    while retry_count < max_retries:
+        try:
+            # API 설정 가져오기
+            api_config = api_utils.get_next_shopping_api_config()
+            
+            # 요청 헤더
+            headers = {
+                'X-Naver-Client-Id': api_config["CLIENT_ID"],
+                'X-Naver-Client-Secret': api_config["CLIENT_SECRET"]
+            }
+            
+            # 요청 URL (스페이스 없이 호출)
+            url = f"https://openapi.naver.com/v1/search/shop.json?query={keyword}&display={display}&start={(page-1)*display+1}"
+            
+            logger.debug(f"API 요청: page={page}, display={display}, 시작 위치={(page-1)*display+1}")
+            response = requests.get(url, headers=headers, timeout=10)  # 타임아웃 설정
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                # 상품 정보 추출
+                products = []
+                
+                for item in result.get("items", []):
+                    title = item.get("title", "").replace("<b>", "").replace("</b>", "")
+                    link = item.get("link", "")
+                    image = item.get("image", "")
+                    lprice = item.get("lprice", "0")
+                    mall_name = item.get("mallName", "")
+                    
+                    # 카테고리 정보 추출
+                    category1 = item.get("category1", "")
+                    category2 = item.get("category2", "")
+                    category3 = item.get("category3", "")
+                    category4 = item.get("category4", "")
+                    
+                    # 전체 카테고리 경로 생성
+                    category_path = " > ".join([c for c in [category1, category2, category3, category4] if c])
+                    
+                    products.append({
+                        "상품명": title,
+                        "가격": lprice,
+                        "쇼핑몰": mall_name,
+                        "카테고리": category_path if category_path else category1
+                    })
+                
+                logger.info(f"API 응답: {len(products)}개 상품 검색됨 (전체 결과수: {result.get('total', 0)})")
+                return {
+                    "status": "success",
+                    "products": products,
+                    "total": result.get("total", 0)
+                }
+            else:
+                error_msg = f"API 오류: {response.status_code} - {response.text}"
+                logger.warning(error_msg)
+                retry_count += 1
+                exponential_backoff_sleep(retry_count)
+        
+        except Exception as e:
+            error_msg = f"상품 검색 중 오류 발생: {e}"
+            logger.error(error_msg)
+            retry_count += 1
+            exponential_backoff_sleep(retry_count)
+    
+    # 최대 재시도 횟수를 초과한 경우
+    logger.error(f"최대 재시도 횟수({max_retries})를 초과하여 빈 결과 반환")
+    return {
+        "status": "error",
+        "message": f"최대 재시도 횟수({max_retries})를 초과했습니다.",
+        "products": []
+    }
+
+def fetch_naver_shopping_data_for_analysis(keyword, count=10):
+    """
+    네이버 쇼핑 API를 통해 키워드로 상품 검색 (분석용, 스페이스 없이 호출)
+    
+    Args:
+        keyword (str): 검색 키워드
+        count (int): 검색할 상품 수
+        
+    Returns:
+        list: 검색된 상품 정�� 목록
+    """
+    # 스페이스 제거
+    api_keyword = keyword.replace(" ", "")
+    
+    # 최대 재시도 횟수
+    max_retries = 3
+    retry_count = 0
+    
+    while retry_count < max_retries:
+        try:
+            # API 설정 가져오기
+            api_config = api_utils.get_next_shopping_api_config()
+            
+            # 요청 헤더
+            headers = {
+                'X-Naver-Client-Id': api_config["CLIENT_ID"],
+                'X-Naver-Client-Secret': api_config["CLIENT_SECRET"]
+            }
+            
+            # 요청 URL
+            url = f"https://openapi.naver.com/v1/search/shop.json?query={api_keyword}&display={count}"
+            
+            response = requests.get(url, headers=headers, timeout=10)
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                # 상품 정보 추출
+                products = []
+                
+                for item in result.get("items", []):
+                    # 카테고리 정보 추출 및 전체 경로 생성
+                    category1 = item.get("category1", "")
+                    category2 = item.get("category2", "")
+                    category3 = item.get("category3", "")
+                    category4 = item.get("category4", "")
+                    
+                    # 전체 카테고리 경로 생성 (fetch_products_by_keyword와 일관성 유지)
+                    category_path = " > ".join([c for c in [category1, category2, category3, category4] if c])
+                    
+                    products.append({
+                        "title": item.get("title", "").replace("<b>", "").replace("</b>", ""),
+                        "price": item.get("lprice", "0"),
+                        "category": category_path if category_path else category1,
+                        "카테고리": category_path if category_path else category1  # 한글 키로도 저장 (호환성)
+                    })
+                
+                return products
+            else:
+                logger.warning(f"API 오류 (시도 {retry_count+1}/{max_retries}): {response.status_code} - {response.text}")
+                retry_count += 1
+                exponential_backoff_sleep(retry_count)
+        
+        except Exception as e:
+            logger.error(f"상품 검색 중 오류 발생 (시도 {retry_count+1}/{max_retries}): {e}")
+            retry_count += 1
+            exponential_backoff_sleep(retry_count)
+    
+    logger.error(f"최대 재시도 횟수({max_retries})를 초과하여 빈 결과 반환")
+    return []

requirements.txt

@@ -1,5 +1,9 @@
-gradio_client>=0.8.0 
-pandas>=1.5.0 
-xlsxwriter>=3.0.0 
-requests>=2.28.0 
-pytz>=2022.1
+gradio
+pandas
+requests
+google-generativeai
+xlsxwriter
+beautifulsoup4
+fpdf
+markdown
+plotly

style.css

@@ -97,11 +97,6 @@ body {
     transition: background-color 0.3s ease, color 0.3s ease;
 }
 
-/* 푸터 숨김 설정 */
-footer {
-    visibility: hidden;
-}
-
 .gradio-container,
 .gradio-container *,
 .gr-app,
@@ -644,4 +639,4 @@ pre,
     .grid-container {
         grid-template-columns: 1fr;
     }
-}
+}

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.py

@@ -0,0 +1,323 @@
+"""
+트렌드 분석 모듈 - 네이버 데이터랩 API를 통한 검색 트렌드 분석
+- 성장률을 3년 기준으로 변경
+- 너비 100% 적용
+"""
+
+import requests
+import json
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime, timedelta
+import api_utils
+import keyword_search
+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 get_trend_data(keywords, period="1year"):
+    """
+    네이버 데이터랩 API를 통해 검색 트렌드 데이터 가져오기 (수정된 버전)
+    
+    Args:
+        keywords (list): 분석할 키워드 목록 (최대 5개)
+        period (str): 분석 기간 ("1year" 또는 "3year")
+        
+    Returns:
+        dict: 트렌드 데이터 및 그래프 HTML
+    """
+    logger.info(f"트렌드 분석 시작: {len(keywords)}개 키워드, 기간: {period}")
+    
+    # 날짜 계산 (어제 기준으로 월 단위 계산)
+    yesterday = datetime.now() - timedelta(days=1)
+    end_year = yesterday.year
+    end_month = yesterday.month
+    
+    if period == "1year":
+        # 1년 전 같은 달
+        start_year = end_year - 1
+        start_month = end_month
+    else:  # 3year
+        # 3년 전 같은 달
+        start_year = end_year - 3
+        start_month = end_month
+    
+    # 월 첫째 날로 날짜 설정
+    start_date_str = f"{start_year:04d}-{start_month:02d}-01"
+    end_date_str = f"{end_year:04d}-{end_month:02d}-01"
+    
+    logger.info(f"분석 기간: {start_date_str} ~ {end_date_str} (월간 데이터)")
+    
+    # 키워드는 최대 5개까지만 처리
+    keywords = keywords[:5]
+    
+    # API 설정 가져오기
+    api_config = api_utils.get_next_datalab_api_config()
+    if not api_config:
+        logger.error("데이터랩 API 설정을 가져올 수 없습니다.")
+        return {
+            "status": "error",
+            "message": "데이터랩 API 설정 없음"
+        }
+    
+    # 키워드 그룹 생성
+    keyword_groups = []
+    for keyword in keywords:
+        keyword_groups.append({
+            'groupName': keyword,
+            'keywords': [keyword]
+        })
+    
+    # API 요청 데이터 (device 파라미터 제거)
+    body_dict = {
+        'startDate': start_date_str,
+        'endDate': end_date_str,
+        'timeUnit': 'month',
+        'keywordGroups': keyword_groups
+        # device 파라미터 제거 → 전체 환경(PC+모바일) 조회
+    }
+    
+    body = json.dumps(body_dict)
+    
+    # API 호출
+    url = "https://openapi.naver.com/v1/datalab/search"
+    headers = {
+        'X-Naver-Client-Id': api_config["CLIENT_ID"],
+        'X-Naver-Client-Secret': api_config["CLIENT_SECRET"],
+        'Content-Type': 'application/json'
+    }
+    
+    try:
+        response = requests.post(url, data=body, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            response_json = response.json()
+            
+            # 데이터 처리
+            trend_data = []
+            for result in response_json['results']:
+                for data_point in result['data']:
+                    trend_data.append({
+                        'keyword': result['title'],
+                        'period': data_point['period'],
+                        'ratio': data_point['ratio']
+                    })
+            
+            df_trend = pd.DataFrame(trend_data)
+            
+            # 현재 월별 검색량 조회 (검색광고 API)
+            search_volumes = keyword_search.fetch_all_search_volumes(keywords)
+            
+            # 절대 검색량으로 변환
+            df_trend_with_volume = convert_to_absolute_volume(df_trend, search_volumes)
+            
+            # 그래프 생성 (너비 100% 적용)
+            graph_html = create_trend_graph(df_trend_with_volume, period)
+            
+            logger.info(f"트렌드 분석 완료: {len(trend_data)}개 데이터 포인트")
+            
+            return {
+                "status": "success",
+                "trend_data": df_trend_with_volume,
+                "graph_html": graph_html,
+                "period": period,
+                "keywords": keywords
+            }
+            
+        else:
+            logger.error(f"데이터랩 API 오류: {response.status_code} - {response.text}")
+            return {
+                "status": "error",
+                "message": f"API 오류: {response.status_code}"
+            }
+            
+    except Exception as e:
+        logger.error(f"트렌드 분석 중 오류 발생: {e}")
+        return {
+            "status": "error",
+            "message": f"분석 중 오류: {str(e)}"
+        }
+
+def convert_to_absolute_volume(df_trend, search_volumes):
+    """
+    상대 검���량을 절대 검색량으로 변환
+    
+    Args:
+        df_trend (DataFrame): 트렌드 데이터 (상대값)
+        search_volumes (dict): 현재 월별 검색량 데이터
+        
+    Returns:
+        DataFrame: 절대 검색량이 추가된 트렌드 데이터
+    """
+    df_result = df_trend.copy()
+    df_result['absolute_volume'] = 0
+    
+    # 각 키워드별로 처리
+    for keyword in df_trend['keyword'].unique():
+        keyword_data = df_trend[df_trend['keyword'] == keyword]
+        
+        # 현재 월의 비율 (마지막 데이터)
+        current_ratio = keyword_data['ratio'].iloc[-1]
+        
+        # 현재 월의 검색량 (PC + 모바일)
+        volume_data = search_volumes.get(keyword.replace(" ", ""), {"총검색량": 0})
+        current_volume = volume_data.get("총검색량", 0)
+        
+        if current_ratio > 0 and current_volume > 0:
+            # 1%당 검색량 계산
+            volume_per_percent = current_volume / current_ratio
+            
+            # 각 기간의 절대 검색량 계산
+            mask = df_result['keyword'] == keyword
+            df_result.loc[mask, 'absolute_volume'] = (
+                df_result.loc[mask, 'ratio'] * volume_per_percent
+            ).astype(int)
+            
+            logger.info(f"'{keyword}': 현재 비율 {current_ratio}%, 검색량 {current_volume:,}, 1%당 {volume_per_percent:.0f}")
+        else:
+            logger.warning(f"'{keyword}': 검색량 변환 불가 (비율: {current_ratio}, 검색량: {current_volume})")
+    
+    return df_result
+
+def create_trend_graph(df_trend, period):
+    """
+    트렌드 그래프 생성 (너비 100% 적용)
+    
+    Args:
+        df_trend (DataFrame): 트렌드 데이터
+        period (str): 분석 기간
+        
+    Returns:
+        str: HTML 형태의 그래프
+    """
+    # Plotly 그래프 생성
+    fig = go.Figure()
+    
+    # 키워드별로 라인 추가
+    colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7']
+    
+    for i, keyword in enumerate(df_trend['keyword'].unique()):
+        keyword_data = df_trend[df_trend['keyword'] == keyword]
+        
+        fig.add_trace(go.Scatter(
+            x=keyword_data['period'],
+            y=keyword_data['absolute_volume'],
+            mode='lines+markers',
+            name=keyword,
+            line=dict(color=colors[i % len(colors)], width=3),
+            marker=dict(size=6),
+            hovertemplate='<b>%{fullData.name}</b><br>' +
+                         '기간: %{x}<br>' +
+                         '검색량: %{y:,}<br>' +
+                         '<extra></extra>'
+        ))
+    
+    # 레이아웃 설정 (너비 100% 적용)
+    period_text = "최근 1년" if period == "1year" else "최근 3년"
+    
+    fig.update_layout(
+        title=f'키워드별 월별 검색량 트렌드 ({period_text})',
+        xaxis_title='기간',
+        yaxis_title='월별 검색량',
+        hovermode='x unified',
+        template='plotly_white',
+        height=500,
+        showlegend=True,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="right",
+            x=1
+        ),
+        width=None,  # 너비 자동 조정
+        autosize=True  # 자동 크기 조정
+    )
+    
+    # y축 포맷 설정 (천 단위 구분)
+    fig.update_yaxis(tickformat=',')
+    
+    # HTML로 변환 (너비 100% 적용)
+    graph_html = fig.to_html(
+        include_plotlyjs='cdn', 
+        div_id="trend-graph",
+        config={'responsive': True}  # 반응형 그래프
+    )
+    
+    return graph_html
+
+def calculate_3year_growth_rate(volumes):
+    """
+    3년 기준 성장률 계산 (전체 기간 기준)
+    
+    Args:
+        volumes (list): 월별 검색량 데이터
+        
+    Returns:
+        float: 3년 기준 성장률
+    """
+    if len(volumes) < 6:  # 최소 6개월 데이터 필요
+        return 0
+    
+    # 전체 기간을 3등분하여 성장률 계산
+    total_months = len(volumes)
+    period_size = max(1, total_months // 3)  # 최소 1개월
+    
+    # 초기 기간 평균 (첫 1/3)
+    early_period = volumes[:period_size]
+    early_avg = sum(early_period) / len(early_period)
+    
+    # 최근 기간 평균 (마지막 1/3)
+    recent_period = volumes[-period_size:]
+    recent_avg = sum(recent_period) / len(recent_period)
+    
+    if early_avg > 0:
+        return round(((recent_avg - early_avg) / early_avg) * 100, 1)
+    return 0
+
+def analyze_trend_insights(df_trend):
+    """
+    트렌드 데이터에서 인사이트 추출 (3년 기준 성장률로 변경)
+    
+    Args:
+        df_trend (DataFrame): 트렌드 데이터
+        
+    Returns:
+        dict: 트렌드 인사이트
+    """
+    insights = {}
+    
+    for keyword in df_trend['keyword'].unique():
+        keyword_data = df_trend[df_trend['keyword'] == keyword].sort_values('period')
+        
+        # 최고점과 최저점
+        max_volume = keyword_data['absolute_volume'].max()
+        min_volume = keyword_data['absolute_volume'].min()
+        max_period = keyword_data[keyword_data['absolute_volume'] == max_volume]['period'].iloc[0]
+        min_period = keyword_data[keyword_data['absolute_volume'] == min_volume]['period'].iloc[0]
+        
+        # 전체 기간 평균
+        total_avg = keyword_data['absolute_volume'].mean()
+        
+        # 3년 기준 성장률 계산 (전체 기간 기준)
+        volumes = keyword_data['absolute_volume'].tolist()
+        growth_rate = calculate_3year_growth_rate(volumes)
+        
+        insights[keyword] = {
+            'max_volume': int(max_volume),
+            'max_period': max_period,
+            'min_volume': int(min_volume),
+            'min_period': min_period,
+            'total_avg': int(total_avg),
+            'growth_rate': growth_rate,
+            'total_months': len(volumes)
+        }
+    
+    return insights

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)