Update app.py

app.py

@@ -1,21 +1,29 @@
 import gradio as gr
 import requests
 from bs4 import BeautifulSoup
-import urllib.parse  # iframe 경로 보정을 위한 모듈
+import urllib.parse # iframe 경로 보정을 위한 모듈
 import re
 import logging
 import tempfile
 import pandas as pd
-import mecab  # python‑mecab‑ko 라이브러리 사용
+import mecab # python?mecab?ko 라이브러리 사용
 import os
 import time
 import hmac
 import hashlib
 import base64
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+# --- 병렬 처리 설정 ---
+# API 호출 제한에 맞춰 적절히 조절하세요.
+# 너무 높은 값은 API 제한에 걸릴 수 있습니다.
+MAX_WORKERS_RELATED_KEYWORDS = 5  # fetch_related_keywords 병렬 작업자 수
+MAX_WORKERS_BLOG_COUNT = 10       # fetch_blog_count 병렬 작업자 수
+
 
 # 디버깅(로그)용 함수
 def debug_log(message: str):
-    print(f"[DEBUG] {message}")
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] [DEBUG] {message}")
 
 # --- 네이버 블로그 스크래핑 ---
 def scrape_naver_blog(url: str) -> str:
@@ -29,7 +37,7 @@ def scrape_naver_blog(url: str) -> str:
         )
     }
     try:
-        response = requests.get(url, headers=headers)
+        response = requests.get(url, headers=headers, timeout=10)
         debug_log("HTTP GET 요청(메인 페이지) 완료")
         if response.status_code != 200:
             debug_log(f"요청 실패, 상태코드: {response.status_code}")
@@ -39,63 +47,127 @@ def scrape_naver_blog(url: str) -> str:
         iframe = soup.select_one("iframe#mainFrame")
         if not iframe:
             debug_log("iframe#mainFrame 태그를 찾을 수 없습니다.")
-            return "본문 iframe을 찾을 수 없습니다."
+            # 일부 블로그는 mainFrame이 없을 수 있음. 본문 직접 시도
+            content_div_direct = soup.select_one('.se-main-container')
+            if content_div_direct:
+                title_div_direct = soup.select_one('.se-module.se-module-text.se-title-text')
+                title = title_div_direct.get_text(strip=True) if title_div_direct else "제목을 찾을 수 없습니다."
+                content = content_div_direct.get_text("\n", strip=True)
+                debug_log("iframe 없이 본문 직접 추출 완료")
+                return f"[제목]\n{title}\n\n[본문]\n{content}"
+            return "본문 iframe을 찾을 수 없습니다. (본문 직접 추출 실패)"
+
         iframe_src = iframe.get("src")
         if not iframe_src:
             debug_log("iframe src가 존재하지 않습니다.")
             return "본문 iframe의 src를 찾을 수 없습니다."
-        parsed_iframe_url = urllib.parse.urljoin(url, iframe_src)
+        
+        # iframe_src가 절대 URL이 아닌 경우를 대비
+        if iframe_src.startswith("//"):
+            parsed_iframe_url = "https:" + iframe_src
+        elif iframe_src.startswith("/"):
+            parsed_main_url = urllib.parse.urlparse(url)
+            parsed_iframe_url = urllib.parse.urlunparse(
+                (parsed_main_url.scheme, parsed_main_url.netloc, iframe_src, None, None, None)
+            )
+        else:
+            parsed_iframe_url = urllib.parse.urljoin(url, iframe_src)
+            
         debug_log(f"iframe 페이지 요청 URL: {parsed_iframe_url}")
-        iframe_response = requests.get(parsed_iframe_url, headers=headers)
+        iframe_response = requests.get(parsed_iframe_url, headers=headers, timeout=10)
         debug_log("HTTP GET 요청(iframe 페이지) 완료")
         if iframe_response.status_code != 200:
             debug_log(f"iframe 요청 실패, 상태코드: {iframe_response.status_code}")
             return f"iframe에서 오류가 발생했습니다. 상태코드: {iframe_response.status_code}"
         iframe_soup = BeautifulSoup(iframe_response.text, "html.parser")
         debug_log("HTML 파싱(iframe 페이지) 완료")
-        title_div = iframe_soup.select_one('.se-module.se-module-text.se-title-text')
-        title = title_div.get_text(strip=True) if title_div else "제목을 찾을 수 없습니다."
+        
+        # 제목 추출 (다양한 구조 시도)
+        title_selectors = [
+            '.se-module.se-module-text.se-title-text', # 일반적인 스마트에디터 ONE
+            '.title_text', # 구버전 에디터 또는 다른 구조
+            'div[class*="title"] h3', 
+            'h1', 'h2', 'h3' # 일반적인 제목 태그
+        ]
+        title = "제목을 찾을 수 없습니다."
+        for selector in title_selectors:
+            title_div = iframe_soup.select_one(selector)
+            if title_div:
+                title = title_div.get_text(strip=True)
+                break
         debug_log(f"추출된 제목: {title}")
-        content_div = iframe_soup.select_one('.se-main-container')
-        if content_div:
-            content = content_div.get_text("\n", strip=True)
-        else:
-            content = "본문을 찾을 수 없습니다."
+
+        # 본문 추출 (다양한 구조 시도)
+        content_selectors = [
+            '.se-main-container', # 스마트에디터 ONE
+            'div#content',       # 구버전 에디터
+            'div.post_ct',       # 일부 블로그 구조
+            'article', 'main'    # 시맨틱 태그
+        ]
+        content = "본문을 찾을 수 없습니다."
+        for selector in content_selectors:
+            content_div = iframe_soup.select_one(selector)
+            if content_div:
+                # 불필요한 스크립트, 스타일 태그 제거
+                for s in content_div(['script', 'style']):
+                    s.decompose()
+                content = content_div.get_text("\n", strip=True)
+                break
+        
         debug_log("본문 추출 완료")
         result = f"[제목]\n{title}\n\n[본문]\n{content}"
         debug_log("제목과 본문 합침 완료")
         return result
+    except requests.exceptions.Timeout:
+        debug_log(f"요청 시간 초과: {url}")
+        return f"스크래핑 중 시간 초과가 발생했습니다: {url}"
     except Exception as e:
-        debug_log(f"에러 발생: {str(e)}")
+        debug_log(f"스크래핑 에러 발생: {str(e)}")
         return f"스크래핑 중 오류가 발생했습니다: {str(e)}"
 
 # --- 형태소 분석 (참조코드-1) ---
 def analyze_text(text: str):
-    logging.basicConfig(level=logging.DEBUG)
+    logging.basicConfig(level=logging.INFO) # INFO 레벨로 변경하여 너무 많은 로그 방지
     logger = logging.getLogger(__name__)
-    logger.debug("원본 텍스트: %s", text)
-    filtered_text = re.sub(r'[^가-힣]', '', text)
-    logger.debug("필터링된 텍스트: %s", filtered_text)
-    if not filtered_text:
-        logger.debug("유효한 한국어 텍스트가 없음.")
+    # logger.debug("원본 텍스트: %s", text) # 너무 길 수 있으므로 주석 처리
+    filtered_text = re.sub(r'[^가-힣a-zA-Z0-9\s]', '', text) # 영어, 숫자, 공백 포함
+    # logger.debug("필터링된 텍스트: %s", filtered_text)
+    if not filtered_text.strip():
+        logger.info("유효한 텍스트가 없음 (필터링 후).")
+        return pd.DataFrame(columns=["단어", "빈도수"]), ""
+    try:
+        mecab_instance = mecab.MeCab()
+        tokens = mecab_instance.pos(filtered_text)
+    except Exception as e:
+        logger.error(f"MeCab 형태소 분석 중 오류: {e}")
         return pd.DataFrame(columns=["단어", "빈도수"]), ""
-    mecab_instance = mecab.MeCab()
-    tokens = mecab_instance.pos(filtered_text)
-    logger.debug("형태소 분석 결과: %s", tokens)
+        
+    # logger.debug("형태소 분석 결과: %s", tokens)
     freq = {}
     for word, pos in tokens:
-        if word and word.strip() and pos.startswith("NN"):
+        # 일반명사(NNG), 고유명사(NNP), 외국어(SL), 숫자(SN) 등 포함, 한 글자 단어는 제외 (선택 사항)
+        if word and word.strip() and (pos.startswith("NN") or pos in ["SL", "SH"]) and len(word) > 1 :
             freq[word] = freq.get(word, 0) + 1
-            logger.debug("단어: %s, 품사: %s, 빈도: %d", word, pos, freq[word])
+            # logger.debug("단어: %s, 품사: %s, 빈도: %d", word, pos, freq[word])
+            
     sorted_freq = sorted(freq.items(), key=lambda x: x[1], reverse=True)
-    logger.debug("정렬된 단어 빈도: %s", sorted_freq)
+    # logger.debug("정렬된 단어 빈도: %s", sorted_freq)
     df = pd.DataFrame(sorted_freq, columns=["단어", "빈도수"])
-    logger.debug("형태소 분석 DataFrame 생성됨, shape: %s", df.shape)
-    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx")
-    df.to_excel(temp_file.name, index=False, engine='openpyxl')
-    temp_file.close()
-    logger.debug("Excel 파일 생성됨: %s", temp_file.name)
-    return df, temp_file.name
+    logger.info(f"형태소 분석 DataFrame 생성됨, shape: {df.shape}")
+    
+    temp_file_path = ""
+    if not df.empty:
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx", mode='w+b') as temp_file:
+                df.to_excel(temp_file.name, index=False, engine='openpyxl')
+                temp_file_path = temp_file.name
+            logger.info(f"Excel 파일 생성됨: {temp_file_path}")
+        except Exception as e:
+            logger.error(f"Excel 파일 저장 중 오류: {e}")
+            temp_file_path = "" # 오류 발생 시 경로 초기화
+
+    return df, temp_file_path
+
 
 # --- 네이버 검색 및 광고 API 관련 (참조코드-2) ---
 def generate_signature(timestamp, method, uri, secret_key):
@@ -114,189 +186,489 @@ def get_header(method, uri, api_key, secret_key, customer_id):
         "X-Signature": signature
     }
 
+# API 키 환경 변수 확인 함수
+def get_env_variable(var_name):
+    value = os.environ.get(var_name)
+    if value is None:
+        debug_log(f"환경 변수 '{var_name}'가 설정되지 않았습니다. API 호출이 실패할 수 있습니다.")
+        # 필요시 여기서 raise Exception 또는 ���본값 반환
+    return value
+
 def fetch_related_keywords(keyword):
-    debug_log(f"fetch_related_keywords 호출, 키워드: {keyword}")
-    API_KEY = os.environ["NAVER_API_KEY"]
-    SECRET_KEY = os.environ["NAVER_SECRET_KEY"]
-    CUSTOMER_ID = os.environ["NAVER_CUSTOMER_ID"]
+    debug_log(f"fetch_related_keywords 호출 시작, 키워드: {keyword}")
+    API_KEY = get_env_variable("NAVER_API_KEY")
+    SECRET_KEY = get_env_variable("NAVER_SECRET_KEY")
+    CUSTOMER_ID = get_env_variable("NAVER_CUSTOMER_ID")
+    
+    if not all([API_KEY, SECRET_KEY, CUSTOMER_ID]):
+        debug_log(f"네이버 광고 API 키 정보 부족으로 '{keyword}' 연관 키워드 조회를 건너<0xEB><0xB5>니다.")
+        return pd.DataFrame()
+
     BASE_URL = "https://api.naver.com"
     uri = "/keywordstool"
     method = "GET"
-    headers = get_header(method, uri, API_KEY, SECRET_KEY, CUSTOMER_ID)
-    params = {
-        "hintKeywords": [keyword],
-        "showDetail": "1"
-    }
-    response = requests.get(BASE_URL + uri, params=params, headers=headers)
-    data = response.json()
-    if "keywordList" not in data:
-        return pd.DataFrame()
-    df = pd.DataFrame(data["keywordList"])
-    if len(df) > 100:
-        df = df.head(100)
-    def parse_count(x):
-        try:
-            return int(str(x).replace(",", ""))
-        except:
-            return 0
-    df["PC월검색량"] = df["monthlyPcQcCnt"].apply(parse_count)
-    df["모바일월검색량"] = df["monthlyMobileQcCnt"].apply(parse_count)
-    df["토탈월검색량"] = df["PC월검색량"] + df["모바일월검색량"]
-    df.rename(columns={"relKeyword": "정보키워드"}, inplace=True)
-    result_df = df[["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량"]]
-    debug_log("fetch_related_keywords 완료")
-    return result_df
+    
+    try:
+        headers = get_header(method, uri, API_KEY, SECRET_KEY, CUSTOMER_ID)
+        params = {
+            "hintKeywords": keyword, # 단일 키워드 문자열로 전달
+            "showDetail": "1"
+        }
+        # hintKeywords는 리스트로 받을 수 있으나, 여기서는 단일 키워드 처리를 가정하고 문자열로 전달
+        # 만약 API가 hintKeywords를 리스트로만 받는다면 [keyword]로 수정 필요
+        
+        response = requests.get(BASE_URL + uri, params=params, headers=headers, timeout=10)
+        response.raise_for_status() # 오류 발생 시 예외 발생
+        data = response.json()
+        
+        if "keywordList" not in data or not data["keywordList"]:
+            debug_log(f"'{keyword}'에 대한 연관 키워드 결과 없음.")
+            return pd.DataFrame() # 빈 DataFrame 반환
+            
+        df = pd.DataFrame(data["keywordList"])
+        
+        # API 응답에 해당 컬럼이 없을 경우를 대비
+        df["monthlyPcQcCnt"] = df.get("monthlyPcQcCnt", 0)
+        df["monthlyMobileQcCnt"] = df.get("monthlyMobileQcCnt", 0)
+
+        def parse_count(x):
+            if pd.isna(x) or str(x).lower() == '< 10': # 네이버 API는 10 미만일 때 "< 10"으로 반환
+                return 5 # 또는 0, 또는 다른 대표값 (예: 5)
+            try:
+                return int(str(x).replace(",", ""))
+            except ValueError:
+                return 0
+                
+        df["PC월검색량"] = df["monthlyPcQcCnt"].apply(parse_count)
+        df["모바일월검색량"] = df["monthlyMobileQcCnt"].apply(parse_count)
+        df["토탈월검색량"] = df["PC월검색량"] + df["모바일월검색량"]
+        df.rename(columns={"relKeyword": "정보키워드"}, inplace=True)
+        
+        # 필요한 컬럼만 선택, 없는 경우 대비
+        required_cols = ["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량"]
+        result_df = pd.DataFrame(columns=required_cols)
+        for col in required_cols:
+            if col in df.columns:
+                result_df[col] = df[col]
+            else: # 해당 컬럼이 API 응답에 없을 경우 기본값으로 채움
+                 if col == "정보키워드": # 정보키워드는 필수
+                     debug_log(f"API 응답에 'relKeyword'가 없습니다. '{keyword}' 처리 중단.")
+                     return pd.DataFrame()
+                 result_df[col] = 0
+
+        debug_log(f"fetch_related_keywords '{keyword}' 완료, 결과 {len(result_df)}개")
+        return result_df.head(100) # 최대 100개로 제한
+        
+    except requests.exceptions.HTTPError as http_err:
+        debug_log(f"HTTP 오류 발생 (fetch_related_keywords for '{keyword}'): {http_err} - 응답: {response.text if 'response' in locals() else 'N/A'}")
+    except requests.exceptions.RequestException as req_err:
+        debug_log(f"요청 오류 발생 (fetch_related_keywords for '{keyword}'): {req_err}")
+    except Exception as e:
+        debug_log(f"알 수 없는 오류 발생 (fetch_related_keywords for '{keyword}'): {e}")
+    return pd.DataFrame() # 오류 발생 시 빈 DataFrame 반환
+
 
 def fetch_blog_count(keyword):
     debug_log(f"fetch_blog_count 호출, 키워드: {keyword}")
-    client_id = os.environ["NAVER_SEARCH_CLIENT_ID"]
-    client_secret = os.environ["NAVER_SEARCH_CLIENT_SECRET"]
+    client_id = get_env_variable("NAVER_SEARCH_CLIENT_ID")
+    client_secret = get_env_variable("NAVER_SEARCH_CLIENT_SECRET")
+
+    if not client_id or not client_secret:
+        debug_log(f"네이버 검색 API 키 정보 부족으로 '{keyword}' 블로그 수 조회를 건너<0xEB><0xB5>니다.")
+        return 0
+
     url = "https://openapi.naver.com/v1/search/blog.json"
     headers = {
         "X-Naver-Client-Id": client_id,
         "X-Naver-Client-Secret": client_secret
     }
-    params = {"query": keyword, "display": 1}
-    response = requests.get(url, headers=headers, params=params)
-    if response.status_code == 200:
+    params = {"query": keyword, "display": 1} # display=1로 설정하여 total 값만 빠르게 확인
+    
+    try:
+        response = requests.get(url, headers=headers, params=params, timeout=5)
+        response.raise_for_status() # HTTP 오류 발생 시 예외 발생
         data = response.json()
-        debug_log(f"fetch_blog_count 결과: {data.get('total', 0)}")
-        return data.get("total", 0)
-    else:
-        debug_log(f"fetch_blog_count 오류, 상태코드: {response.status_code}")
-        return 0
+        total_count = data.get("total", 0)
+        debug_log(f"fetch_blog_count 결과: {total_count} for '{keyword}'")
+        return total_count
+    except requests.exceptions.HTTPError as http_err:
+        debug_log(f"HTTP 오류 발생 (fetch_blog_count for '{keyword}'): {http_err} - 응답: {response.text}")
+    except requests.exceptions.RequestException as req_err: # Timeout, ConnectionError 등
+        debug_log(f"요청 오류 발생 (fetch_blog_count for '{keyword}'): {req_err}")
+    except Exception as e: # JSONDecodeError 등 기타 예외
+        debug_log(f"알 수 없는 오류 발생 (fetch_blog_count for '{keyword}'): {e}")
+    return 0 # 오류 발생 시 0 반환
 
 def create_excel_file(df):
-    with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
-        excel_path = tmp.name
-    df.to_excel(excel_path, index=False)
-    debug_log(f"Excel 파일 생성됨: {excel_path}")
-    return excel_path
+    if df.empty:
+        debug_log("빈 DataFrame으로 Excel 파일을 생성하지 않습니다.")
+        # 빈 파일을 생성하거나, None을 반환하여 Gradio에서 처리하도록 할 수 있음
+        # 여기서는 빈 임시 파일을 생성하여 반환 (Gradio File 컴포넌트가 경로를 기대하므로)
+        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
+            excel_path = tmp.name
+        # 빈 엑셀 파일에 헤더만이라도 써주려면
+        # pd.DataFrame(columns=df.columns).to_excel(excel_path, index=False)
+        # 아니면 그냥 빈 파일을 반환
+        return excel_path
+
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False, mode='w+b') as tmp:
+            excel_path = tmp.name
+        df.to_excel(excel_path, index=False, engine='openpyxl')
+        debug_log(f"Excel 파일 생성됨: {excel_path}")
+        return excel_path
+    except Exception as e:
+        debug_log(f"Excel 파일 생성 중 오류: {e}")
+        # 오류 발생 시 빈 파일 경로라도 반환 (Gradio 호환성)
+        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
+            return tmp.name
+
 
 def process_keyword(keywords: str, include_related: bool):
-    debug_log(f"process_keyword 호출, 키워드들: {keywords}, 연관검색어 포함: {include_related}")
-    input_keywords = [k.strip() for k in keywords.splitlines() if k.strip()]
-    result_dfs = []
-    for idx, kw in enumerate(input_keywords):
-        df_kw = fetch_related_keywords(kw)
-        if df_kw.empty:
-            continue
-        row_kw = df_kw[df_kw["정보키워드"] == kw]
-        if not row_kw.empty:
-            result_dfs.append(row_kw)
-        else:
-            result_dfs.append(df_kw.head(1))
-        if include_related and idx == 0:
-            df_related = df_kw[df_kw["정보키워드"] != kw]
-            if not df_related.empty:
-                result_dfs.append(df_related)
-    if result_dfs:
-        result_df = pd.concat(result_dfs, ignore_index=True)
-        result_df.drop_duplicates(subset=["정보키워드"], inplace=True)
+    debug_log(f"process_keyword 호출 시작, 키워드들: '{keywords[:100]}...', 연관검색어 포함: {include_related}")
+    input_keywords_orig = [k.strip() for k in keywords.splitlines() if k.strip()]
+    
+    if not input_keywords_orig:
+        debug_log("입력된 키워드가 없습니다.")
+        return pd.DataFrame(columns=["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]), ""
+
+    all_related_keywords_dfs = []
+    
+    # 1. fetch_related_keywords 병렬 처리
+    debug_log(f"연관 키��드 조회 병렬 처리 시작 (최대 작업자 수: {MAX_WORKERS_RELATED_KEYWORDS})")
+    with ThreadPoolExecutor(max_workers=MAX_WORKERS_RELATED_KEYWORDS) as executor:
+        future_to_keyword_related = {
+            executor.submit(fetch_related_keywords, kw): kw for kw in input_keywords_orig
+        }
+        for i, future in enumerate(as_completed(future_to_keyword_related)):
+            kw = future_to_keyword_related[future]
+            try:
+                df_kw_related = future.result() # DataFrame 반환
+                if not df_kw_related.empty:
+                    # 원본 키워드가 결과에 포함되어 있는지 확인하고, 없으면 추가 시도 (API가 항상 relKeyword로 자신을 주진 않음)
+                    # 하지만 fetch_related_keywords에서 이미 hintKeyword를 기반으로 검색하므로,
+                    # 일반적으로는 해당 키워드 정보가 있거나, 연관 키워드만 나옴.
+                    # 여기서는 API 응답을 그대로 활용.
+                    
+                    # 첫 번째 입력 키워드이고, 연관 키워드 포함 옵션이 켜져 있으면 모든 연관 키워드를 추가
+                    # 그 외의 경우에는 해당 키워드 자체의 정보만 (있다면) 사용하거나, 최상단 키워드 사용
+                    if include_related and kw == input_keywords_orig[0]:
+                         all_related_keywords_dfs.append(df_kw_related)
+                         debug_log(f"첫 번째 키워드 '{kw}'의 모든 연관 키워드 ({len(df_kw_related)}개) 추가됨.")
+                    else:
+                        # 해당 키워드와 일치하는 행을 찾거나, 없으면 API가 반환한 첫번째 행을 사용
+                        row_kw = df_kw_related[df_kw_related["정보키워드"] == kw]
+                        if not row_kw.empty:
+                            all_related_keywords_dfs.append(row_kw)
+                            debug_log(f"키워드 '{kw}'의 직접 정보 추가됨.")
+                        elif not df_kw_related.empty : # 직접 정보는 없지만 연관 키워드는 있을 때
+                            all_related_keywords_dfs.append(df_kw_related.head(1)) # 가장 연관성 높은 키워드 추가
+                            debug_log(f"키워드 '{kw}'의 직접 정보는 없으나, 가장 연관성 높은 키워드 1개 추가됨.")
+                        # else: 키워드 정보도, 연관 정보도 없을 때 (df_kw_related가 비어있음)
+
+                debug_log(f"'{kw}' 연관 키워드 처리 완료 ({i+1}/{len(input_keywords_orig)})")
+            except Exception as e:
+                debug_log(f"'{kw}' 연관 키워드 조회 중 병렬 작업 오류: {e}")
+
+    if not all_related_keywords_dfs:
+        debug_log("연관 키워드 조회 결과가 모두 비어있습니다.")
+        # 빈 DataFrame에 블로그 문서수 컬럼 추가
+        empty_df = pd.DataFrame(columns=["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량"])
+        empty_df["블로그문서수"] = None
+        return empty_df, create_excel_file(empty_df)
+
+    result_df = pd.concat(all_related_keywords_dfs, ignore_index=True)
+    result_df.drop_duplicates(subset=["정보키워드"], inplace=True) # 중복 제거
+    debug_log(f"연관 키워드 병렬 처리 완료. 통합된 DataFrame shape: {result_df.shape}")
+
+    # 2. fetch_blog_count 병렬 처리
+    keywords_for_blog_count = result_df["정보키워드"].dropna().unique().tolist()
+    blog_counts_map = {}
+
+    if keywords_for_blog_count:
+        debug_log(f"블로그 문서 수 조회 병렬 처리 시작 (키워드 {len(keywords_for_blog_count)}개, 최대 작업자 수: {MAX_WORKERS_BLOG_COUNT})")
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS_BLOG_COUNT) as executor:
+            future_to_keyword_blog = {
+                executor.submit(fetch_blog_count, kw): kw for kw in keywords_for_blog_count
+            }
+            for i, future in enumerate(as_completed(future_to_keyword_blog)):
+                kw = future_to_keyword_blog[future]
+                try:
+                    count = future.result() # 숫자 반환
+                    blog_counts_map[kw] = count
+                    if (i+1) % 50 == 0: # 너무 많은 로그 방지
+                         debug_log(f"블로그 수 조회 진행 중... ({i+1}/{len(keywords_for_blog_count)})")
+                except Exception as e:
+                    debug_log(f"'{kw}' 블로그 수 조회 중 병렬 작업 오류: {e}")
+                    blog_counts_map[kw] = 0 # 오류 시 0으로 처리
+        
+        result_df["블로그문서수"] = result_df["정보키워드"].map(blog_counts_map).fillna(0).astype(int)
+        debug_log("블로그 문서 수 병렬 처리 완료.")
     else:
-        result_df = pd.DataFrame(columns=["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량"])
-    result_df["블로그문서수"] = result_df["정보키워드"].apply(fetch_blog_count)
+        result_df["블로그문서수"] = 0 # 조회할 키워드가 없으면 0으로 채움
+
     result_df.sort_values(by="토탈월검색량", ascending=False, inplace=True)
-    debug_log("process_keyword 완료")
+    debug_log(f"process_keyword 최종 완료. DataFrame shape: {result_df.shape}")
+    
+    # 최종 컬럼 순서 및 존재 여부 확인
+    final_columns = ["정보키워드", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
+    for col in final_columns:
+        if col not in result_df.columns:
+            result_df[col] = 0 if col != "정보키워드" else "" # 없는 컬럼은 기본값으로 채움
+    
+    result_df = result_df[final_columns] # 컬럼 순서 고정
+
     return result_df, create_excel_file(result_df)
 
+
 # --- 형태소 분석과 검색량/블로그문서수 병합 ---
 def morphological_analysis_and_enrich(text: str, remove_freq1: bool):
     debug_log("morphological_analysis_and_enrich 함수 시작")
-    df_freq, _ = analyze_text(text)
+    df_freq, _ = analyze_text(text) # 엑셀 파일 경로는 여기선 사용 안 함
+    
     if df_freq.empty:
         debug_log("형태소 분석 결과가 빈 데이터프레임입니다.")
-        return df_freq, ""
+        return pd.DataFrame(columns=["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]), ""
+
     if remove_freq1:
-        before_shape = df_freq.shape
-        df_freq = df_freq[df_freq["빈도수"] != 1]
-        debug_log(f"빈도수 1 제거 적용됨. {before_shape} -> {df_freq.shape}")
-    keywords = "\n".join(df_freq["단어"].tolist())
-    debug_log(f"분석된 키워드: {keywords}")
-    df_keyword_info, _ = process_keyword(keywords, include_related=False)
-    debug_log("검색량 및 블로그문서수 조회 완료")
-    merged_df = pd.merge(df_freq, df_keyword_info, left_on="단어", right_on="정보키워드", how="left")
-    merged_df.drop(columns=["정보키워드"], inplace=True)
+        before_count = len(df_freq)
+        df_freq = df_freq[df_freq["빈도수"] > 1].copy() # .copy() 추가
+        debug_log(f"빈도수 1 제거 적용됨. {before_count} -> {len(df_freq)}")
+
+    if df_freq.empty:
+        debug_log("빈도수 1 제거 후 데이터가 없습니다.")
+        return pd.DataFrame(columns=["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]), ""
+
+    keywords_from_morph = "\n".join(df_freq["단어"].tolist())
+    debug_log(f"형태소 분석 기반 키워드 ({len(df_freq['단어'])}개)에 대한 정보 조회 시작")
+    
+    # process_keyword는 연관 키워드를 포함하지 않도록 호출 (include_related=False)
+    df_keyword_info, _ = process_keyword(keywords_from_morph, include_related=False)
+    debug_log("형태소 분석 키워드에 대한 검색량 및 블로그문서수 조회 완료")
+
+    if df_keyword_info.empty:
+        debug_log("형태소 분석 키워드에 대한 API 정보 조회 결과가 없습니다.")
+        # df_freq에 빈 컬럼들 추가
+        for col in ["PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]:
+            df_freq[col] = None
+        merged_df = df_freq
+    else:
+        merged_df = pd.merge(df_freq, df_keyword_info, left_on="단어", right_on="정보키워드", how="left")
+        if "정보키워드" in merged_df.columns: # merge 후 정보키워드 컬럼이 생겼다면 삭제
+            merged_df.drop(columns=["정보키워드"], inplace=True, errors='ignore')
+
+    # 누락된 컬럼 기본값으로 채우기
+    expected_cols = ["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
+    for col in expected_cols:
+        if col not in merged_df.columns:
+            merged_df[col] = None if col not in ["빈도수"] else 0
+    
+    merged_df = merged_df[expected_cols] # 컬럼 순서 고정
+
     merged_excel_path = create_excel_file(merged_df)
     debug_log("morphological_analysis_and_enrich 함수 완료")
     return merged_df, merged_excel_path
 
+
 # --- 직접 키워드 분석 (단독 분석) ---
 def direct_keyword_analysis(text: str, keyword_input: str):
     debug_log("direct_keyword_analysis 함수 시작")
-    keywords = re.split(r'[\n,]+', keyword_input)
-    keywords = [kw.strip() for kw in keywords if kw.strip()]
-    debug_log(f"입력된 키워드 목록: {keywords}")
-    results = []
-    for kw in keywords:
-        count = text.count(kw)
-        results.append((kw, count))
-        debug_log(f"키워드 '{kw}'의 빈도수: {count}")
-    df = pd.DataFrame(results, columns=["키워드", "빈도수"])
-    excel_path = create_excel_file(df)
+    direct_keywords_list = [kw.strip() for kw in re.split(r'[\n,]+', keyword_input) if kw.strip()]
+    debug_log(f"입력된 직접 키워드 목록: {direct_keywords_list}")
+
+    if not direct_keywords_list:
+        debug_log("직접 입력된 키워드가 없습니다.")
+        return pd.DataFrame(columns=["키워드", "빈도수"]), ""
+
+    # 1. 본문 내 빈도수 계산
+    results_freq = []
+    for kw in direct_keywords_list:
+        count = text.count(kw) # 대소문자 구분, 정확한 문자열 카운트
+        results_freq.append({"키워드": kw, "빈도수": count})
+        debug_log(f"직접 키워드 '{kw}'의 본문 내 빈도수: {count}")
+    df_direct_freq = pd.DataFrame(results_freq)
+
+    # 2. API를 통해 검색량 및 블로그 수 조회 (병렬 처리된 process_keyword 사용)
+    # 여기서는 각 직접 키워드에 대한 정보만 필요하므로 include_related=False
+    keywords_for_api = "\n".join(direct_keywords_list)
+    df_direct_api_info, _ = process_keyword(keywords_for_api, include_related=False)
+
+    # 3. 빈도수 결과와 API 결과 병합
+    if not df_direct_api_info.empty:
+        # API 결과의 '정보키워드'를 '키워드'로 변경하여 병합 기준 통일
+        df_direct_api_info.rename(columns={"정보키워드": "키워드"}, inplace=True)
+        merged_df = pd.merge(df_direct_freq, df_direct_api_info, on="키워드", how="left")
+    else:
+        merged_df = df_direct_freq
+        for col in ["PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]:
+            merged_df[col] = None # API 정보가 없을 경우 빈 컬럼 추가
+
+    # 컬럼 순서 및 기본값 정리
+    final_cols = ["키워드", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
+    for col in final_cols:
+        if col not in merged_df.columns:
+            merged_df[col] = 0 if col != "키워드" else ""
+    merged_df = merged_df[final_cols]
+
+
+    excel_path = create_excel_file(merged_df)
     debug_log("direct_keyword_analysis 함수 완료")
-    return df, excel_path
+    return merged_df, excel_path
+
 
 # --- 통합 분석 (형태소 분석 + 직접 키워드 분석) ---
 def combined_analysis(blog_text: str, remove_freq1: bool, direct_keyword_input: str):
     debug_log("combined_analysis 함수 시작")
-    merged_df, _ = morphological_analysis_and_enrich(blog_text, remove_freq1)
-    if "직접입력" not in merged_df.columns:
-        merged_df["직접입력"] = ""
-    direct_keywords = re.split(r'[\n,]+', direct_keyword_input)
-    direct_keywords = [kw.strip() for kw in direct_keywords if kw.strip()]
-    debug_log(f"입력된 직접 키워드: {direct_keywords}")
-    for dk in direct_keywords:
-        if dk in merged_df["단어"].values:
-            merged_df.loc[merged_df["단어"] == dk, "직접입력"] = "직접입력"
-        else:
-            freq = blog_text.count(dk)
-            df_direct, _ = process_keyword(dk, include_related=False)
-            if (not df_direct.empty) and (dk in df_direct["정보키워드"].values):
-                row = df_direct[df_direct["정보키워드"] == dk].iloc[0]
-                pc = row.get("PC월검색량", None)
-                mobile = row.get("모바일월검색량", None)
-                total = row.get("토탈월검색량", None)
-                blog_count = row.get("블로그문서수", None)
-            else:
-                pc = mobile = total = blog_count = None
-            new_row = {
-                "단어": dk,
-                "빈도수": freq,
-                "PC월검색량": pc,
-                "모바일월검색량": mobile,
-                "토탈월검색량": total,
-                "블로그문서수": blog_count,
-                "직접입력": "직접입력"
-            }
-            merged_df = pd.concat([merged_df, pd.DataFrame([new_row])], ignore_index=True)
-    merged_df = merged_df.sort_values(by="빈도수", ascending=False).reset_index(drop=True)
-    combined_excel = create_excel_file(merged_df)
+    
+    # 1. 형태소 분석 기반 결과 (API 정보 포함)
+    df_morph, _ = morphological_analysis_and_enrich(blog_text, remove_freq1)
+    # df_morph 컬럼: "단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"
+    
+    # 2. 직접 입력 키워드 처리
+    direct_keywords_list = [kw.strip() for kw in re.split(r'[\n,]+', direct_keyword_input) if kw.strip()]
+    debug_log(f"통합 분석 - 입력된 직접 키워드: {direct_keywords_list}")
+
+    if not direct_keywords_list: # 직접 입력 키워드가 없으면 형태소 분석 결과만 반환
+        if "직접입력" not in df_morph.columns and not df_morph.empty:
+             df_morph["직접입력"] = "" # 직접입력 컬럼 추가
+        # 컬럼 순서 조정
+        cols = ["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수", "직접입력"]
+        for col in cols:
+            if col not in df_morph.columns:
+                 df_morph[col] = "" if col == "직접입력" else (0 if col != "단어" else "")
+        df_morph = df_morph[cols]
+        return df_morph, create_excel_file(df_morph)
+
+    # 직접 입력 키워드에 대한 정��� (빈도수, API 정보) 가져오기
+    # direct_keyword_analysis는 "키워드" 컬럼을 사용하므로, df_morph의 "단어"와 통일 필요
+    df_direct_raw, _ = direct_keyword_analysis(blog_text, direct_keyword_input)
+    # df_direct_raw 컬럼: "키워드", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"
+    df_direct_raw.rename(columns={"키워드": "단어"}, inplace=True) # 컬럼명 통일
+
+    # 형태소 분석 결과에 '직접입력' 표기
+    if not df_morph.empty:
+        df_morph["직접입력"] = df_morph["단어"].apply(lambda x: "직접입력" if x in direct_keywords_list else "")
+    else: # 형태소 분석 결과가 비어있을 수 있음
+        df_morph = pd.DataFrame(columns=["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수", "직접입력"])
+
+
+    # 직접 입력된 키워드 중 형태소 분석 결과에 없는 것들을 추가
+    # df_direct_raw에는 모든 직접 입력 키워드의 정보가 있음
+    
+    # df_morph와 df_direct_raw를 합치되, '단어' 기준으로 중복 처리
+    # 먼저 df_direct_raw에 '직접입력' 컬럼을 추가하고 "직접입력"으로 채움
+    df_direct_raw["직접입력"] = "직접입력"
+    
+    # df_morph에 있는 단어는 df_morph 정보를 우선 사용 (직접입력 플래그만 업데이트)
+    # df_direct_raw에서 df_morph에 없는 단어만 골라서 추가
+    
+    # 합치기: df_morph를 기준으로 df_direct_raw의 정보를 추가/업데이트
+    # Pandas 0.25.0 이상에서는 combine_first의 overwrite 동작이 약간 다를 수 있으므로 merge 사용 고려
+    
+    # 1. df_morph의 단어들에 대해 df_direct_raw의 정보로 업데이트 (API 정보 등)
+    #    단, 빈도수는 각자 계산한 것을 유지할지, 아니면 한쪽을 택할지 결정 필요.
+    #    여기서는 df_morph의 빈도수(형태소분석 기반)와 df_direct_raw의 빈도수(단순 count)가 다를 수 있음.
+    #    일단은 df_morph 기준으로 하고, 없는 직접 키워드만 df_direct_raw에서 추가하는 방식.
+
+    # df_morph의 '직접입력' 컬럼은 이미 위에서 처리됨.
+    # 이제 df_direct_raw에만 있는 키워드를 df_morph에 추가
+    
+    # df_morph에 있는 단어 목록
+    morph_words = df_morph['단어'].tolist() if not df_morph.empty else []
+    
+    rows_to_add = []
+    for idx, row in df_direct_raw.iterrows():
+        if row['단어'] not in morph_words:
+            rows_to_add.append(row)
+            
+    if rows_to_add:
+        df_to_add = pd.DataFrame(rows_to_add)
+        combined_df = pd.concat([df_morph, df_to_add], ignore_index=True)
+    else:
+        combined_df = df_morph.copy() # df_morph가 비어있을 수도 있음
+
+    # 최종 컬럼 정리 및 순서
+    final_cols_combined = ["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수", "직접입력"]
+    for col in final_cols_combined:
+        if col not in combined_df.columns:
+            # 기본값 설정: '직접입력'은 "", 나머지는 0 또는 None (API 값은 None 허용)
+            if col == "직접입력":
+                combined_df[col] = ""
+            elif col == "빈도수":
+                 combined_df[col] = 0
+            elif col == "단어":
+                 combined_df[col] = ""
+            else: # API 관련 컬럼
+                 combined_df[col] = None # pd.NA도 가능
+
+    # NA 값들을 적절히 처리 (예: 0으로 채우거나 그대로 두기)
+    # API 값들은 숫자가 아닐 수 있으므로 (예: "< 10"), process_keyword에서 처리됨. 여기서는 int형 변환 전이므로 그대로 둠.
+    # Gradio Dataframe은 None을 잘 표시함.
+    # 빈도수는 정수형이어야 함
+    if "빈도수" in combined_df.columns:
+        combined_df["빈도수"] = combined_df["빈도수"].fillna(0).astype(int)
+
+
+    combined_df = combined_df[final_cols_combined].drop_duplicates(subset=['단어'], keep='first') # 만약을 위한 중복 제거
+    combined_df.sort_values(by=["직접입력", "빈도수"], ascending=[False, False], inplace=True, na_position='last') # 직접입력 우선, 그 다음 빈도수
+    combined_df.reset_index(drop=True, inplace=True)
+
+    combined_excel = create_excel_file(combined_df)
     debug_log("combined_analysis 함수 완료")
-    return merged_df, combined_excel
+    return combined_df, combined_excel
+
 
 # --- 분석 핸들러 ---
 def analysis_handler(blog_text: str, remove_freq1: bool, direct_keyword_input: str, direct_keyword_only: bool):
-    debug_log("analysis_handler 함수 시작")
+    debug_log(f"analysis_handler 함수 시작. 직접 키워드만 분석: {direct_keyword_only}")
+    start_time = time.time()
+
+    if not blog_text or blog_text.strip() == "스크래핑된 블로그 내용이 여기에 표시됩니다." or blog_text.strip() == "":
+        debug_log("분석할 블로그 내용이 없습니다.")
+        # 빈 결과를 반환하기 위한 DataFrame 구조 명시
+        empty_cols_direct = ["키워드", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
+        empty_cols_combined = ["단어", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수", "직접입력"]
+        df_empty = pd.DataFrame(columns=empty_cols_direct if direct_keyword_only else empty_cols_combined)
+        return df_empty, create_excel_file(df_empty)
+
+
     if direct_keyword_only:
         # "직접 키워드 입력만 분석" 선택 시 단독 분석 수행
-        return direct_keyword_analysis(blog_text, direct_keyword_input)
+        if not direct_keyword_input or not direct_keyword_input.strip():
+            debug_log("직접 키워드만 분석 선택되었으나, 입력된 직접 키워드가 없습니다.")
+            empty_cols_direct = ["키워드", "빈도수", "PC월검색량", "모바일월검색량", "토탈월검색량", "블로그문서수"]
+            df_empty = pd.DataFrame(columns=empty_cols_direct)
+            return df_empty, create_excel_file(df_empty)
+        
+        result_df, excel_path = direct_keyword_analysis(blog_text, direct_keyword_input)
     else:
         # 기본 통합 분석 수행
-        return combined_analysis(blog_text, remove_freq1, direct_keyword_input)
+        result_df, excel_path = combined_analysis(blog_text, remove_freq1, direct_keyword_input)
+    
+    end_time = time.time()
+    debug_log(f"analysis_handler 총 실행 시간: {end_time - start_time:.2f} 초")
+    return result_df, excel_path
+
 
 # --- 스크래핑 실행 ---
 def fetch_blog_content(url: str):
     debug_log("fetch_blog_content 함수 시작")
+    if not url or not url.strip():
+        return "블로그 URL을 입력해주세요."
+    if not url.startswith("http://") and not url.startswith("https://"):
+        return "유효한 URL 형식(http:// 또는 https://)으로 입력해주세요."
+    
+    start_time = time.time()
     content = scrape_naver_blog(url)
-    debug_log("fetch_blog_content 함수 완료")
+    end_time = time.time()
+    debug_log(f"fetch_blog_content 총 실행 시간: {end_time - start_time:.2f} 초. 내용 길이: {len(content)}")
     return content
 
 # --- Custom CSS ---
 custom_css = """
 /* 전체 컨테이너 스타일 */
 .gradio-container {
-    max-width: 960px;
+    max-width: 1080px; /* 너비 확장 */
     margin: auto;
     font-family: 'Helvetica Neue', Arial, sans-serif;
     background: #f5f7fa;
@@ -330,7 +702,12 @@ custom_css = """
     padding: 0.6rem 1.2rem;
     font-size: 1rem;
     cursor: pointer;
+    min-width: 150px; /* 버튼 최소 너비 */
 }
+.custom-button:hover {
+    background-color: #0056b3;
+}
+
 
 /* 체크박스 스타일 */
 .custom-checkbox {
@@ -351,39 +728,97 @@ custom_css = """
 """
 
 # --- Gradio 인터페이스 구성 ---
-with gr.Blocks(title="네이버 블로그 형태소 분석 서비스", css=custom_css) as demo:
-    gr.HTML("<div class='custom-header'>네이버 블로그 형태소 분석 서비스</div>")
-    # 블로그 링크와 스크래핑 실행 버튼을 한 그룹 내에 배치 (버튼은 가운데 정렬)
-    with gr.Group(elem_classes="custom-group"):
-        with gr.Row():
-            blog_url_input = gr.Textbox(label="네이버 블로그 링크", placeholder="예: https://blog.naver.com/ssboost/222983068507", lines=1)
-        with gr.Row(elem_classes="centered"):
-            scrape_button = gr.Button("스크래핑 실행", elem_classes="custom-button")
-    with gr.Group(elem_classes="custom-group"):
-        blog_content_box = gr.Textbox(label="블로그 내용 (수정 가능)", lines=10, placeholder="스크래핑된 블로그 내용이 여기에 표시됩니다.")
-    with gr.Group(elem_classes="custom-group"):
-        with gr.Row():
-            remove_freq_checkbox = gr.Checkbox(label="빈도수1 제거", value=True, elem_classes="custom-checkbox")
-        with gr.Row():
-            # "빈도수1 제거" 아래에 "직접 키워드 입력만 분석" 체크박스 배치
-            direct_keyword_only_checkbox = gr.Checkbox(label="직접 키워드 입력만 분석", value=False, elem_classes="custom-checkbox")
-        with gr.Row():
-            direct_keyword_box = gr.Textbox(label="직접 키워드 입력 (엔터 또는 ','로 구분)", lines=2, placeholder="예: 키워드1, 키워드2\n키워드3")
-    with gr.Group(elem_classes="custom-group"):
-        with gr.Row(elem_classes="centered"):
-            analyze_button = gr.Button("분석 실행", elem_classes="custom-button")
-    with gr.Group(elem_classes="custom-group custom-result"):
-        result_df = gr.Dataframe(label="통합 분석 결과 (단어, 빈도수, 검색량, 블로그문서수, 직접입력)", interactive=True)
-    with gr.Group(elem_classes="custom-group"):
-        excel_file = gr.File(label="Excel 다운로드")
+with gr.Blocks(title="네이버 블로그 키워드 분석 서비스", css=custom_css) as demo:
+    gr.HTML("<div class='custom-header'>네이버 블로그 키워드 분석 서비스</div>")
     
+    with gr.Row():
+        with gr.Column(scale=2): # 왼쪽 컬럼 (입력 영역)
+            with gr.Group(elem_classes="custom-group"):
+                blog_url_input = gr.Textbox(
+                    label="네이버 블로그 링크", 
+                    placeholder="예: https://blog.naver.com/아이디/글번호", 
+                    lines=1,
+                    info="분석할 네이버 블로그 게시물 URL을 입력하세요."
+                )
+                with gr.Row(elem_classes="centered"):
+                    scrape_button = gr.Button("블로그 내용 가져오기", elem_classes="custom-button", variant="primary")
+            
+            with gr.Group(elem_classes="custom-group"):
+                blog_content_box = gr.Textbox(
+                    label="블로그 내용 (수정 가능)", 
+                    lines=10, 
+                    placeholder="스크래핑된 블로그 내용이 여기에 표시됩니다. 직접 수정하거나 붙여넣을 수 있습니다."
+                )
+            
+            with gr.Group(elem_classes="custom-group"):
+                gr.Markdown("### 분석 옵션 설정")
+                with gr.Row():
+                    remove_freq_checkbox = gr.Checkbox(
+                        label="빈도수 1인 단어 제거 (형태소 분석 시)", 
+                        value=True, 
+                        elem_classes="custom-checkbox",
+                        info="형태소 분석 결과에서 빈도수가 1인 단어를 제외합니다."
+                    )
+                with gr.Row():
+                    direct_keyword_only_checkbox = gr.Checkbox(
+                        label="직접 키워드만 분석", 
+                        value=False, 
+                        elem_classes="custom-checkbox",
+                        info="이 옵션을 선택하면 아래 입력한 직접 키워드에 대해서만 분석을 수행합니다 (형태소 분석 생략)."
+                    )
+                with gr.Row():
+                    direct_keyword_box = gr.Textbox(
+                        label="직접 키워드 입력 (엔터 또는 ','로 구분)", 
+                        lines=3, 
+                        placeholder="예: 키워드1, 키워드2\n키워드3\n...\n(형태소 분석 결과와 별도로 분석하거나, 통합 분석에 추가할 키워드)",
+                        info="분석에 포함하거나 단독으로 분석할 키워드를 직접 입력합니다."
+                    )
+            
+            with gr.Group(elem_classes="custom-group"):
+                with gr.Row(elem_classes="centered"):
+                    analyze_button = gr.Button("키워드 분석 실행", elem_classes="custom-button", variant="primary")
+
+        with gr.Column(scale=3): # 오른쪽 컬럼 (결과 영역)
+            with gr.Group(elem_classes="custom-group custom-result"):
+                gr.Markdown("### 분석 결과")
+                result_df_display = gr.Dataframe(
+                    label="통합 분석 결과 (단어, 빈도수, 검색량, 블로그문서수, 직접입력 여부)", 
+                    interactive=False, # 사용자가 직접 수정 불가
+                    height=600, # 높이 조절
+                    wrap=True # 긴 텍스트 줄바꿈
+                )
+            with gr.Group(elem_classes="custom-group"):
+                gr.Markdown("### 결과 다운로드")
+                excel_file_display = gr.File(label="분석 결과 Excel 파일 다운로드")
+
     # 이벤트 연결
     scrape_button.click(fn=fetch_blog_content, inputs=blog_url_input, outputs=blog_content_box)
-    analyze_button.click(fn=analysis_handler, 
-                         inputs=[blog_content_box, remove_freq_checkbox, direct_keyword_box, direct_keyword_only_checkbox],
-                         outputs=[result_df, excel_file])
+    analyze_button.click(
+        fn=analysis_handler,
+        inputs=[blog_content_box, remove_freq_checkbox, direct_keyword_box, direct_keyword_only_checkbox],
+        outputs=[result_df_display, excel_file_display]
+    )
 
 if __name__ == "__main__":
+    # 환경 변수 설정 예시 (실제 실행 시에는 시스템 환경 변수로 설정하거나, .env 파일 등을 사용)
+    # os.environ["NAVER_API_KEY"] = "YOUR_NAVER_API_KEY"
+    # os.environ["NAVER_SECRET_KEY"] = "YOUR_NAVER_SECRET_KEY"
+    # os.environ["NAVER_CUSTOMER_ID"] = "YOUR_NAVER_CUSTOMER_ID"
+    # os.environ["NAVER_SEARCH_CLIENT_ID"] = "YOUR_NAVER_SEARCH_CLIENT_ID"
+    # os.environ["NAVER_SEARCH_CLIENT_SECRET"] = "YOUR_NAVER_SEARCH_CLIENT_SECRET"
+
+    # 환경 변수 설정 확인
+    required_env_vars = [
+        "NAVER_API_KEY", "NAVER_SECRET_KEY", "NAVER_CUSTOMER_ID",
+        "NAVER_SEARCH_CLIENT_ID", "NAVER_SEARCH_CLIENT_SECRET"
+    ]
+    missing_vars = [var for var in required_env_vars if not os.environ.get(var)]
+    if missing_vars:
+        debug_log(f"경고: 다음 필수 환경 변수가 설정되지 않았습니다 - {', '.join(missing_vars)}")
+        debug_log("API 호출 기능이 정상적으로 동작하지 않을 수 있습니다.")
+        debug_log("스크립트 실행 전에 해당 환경 변수를 설정해주세요.")
+        # Gradio 앱은 실행하되, API 호출 시 오류가 발생할 수 있음을 사용자에게 알림.
+
     debug_log("Gradio 앱 실행 시작")
-    demo.launch()
-    debug_log("Gradio 앱 실행 종료")
+    demo.launch(debug=True) # 개발 중에는 debug=True로 설정하여 오류 확인 용이
+    debug_log("Gradio 앱 실행 종료")