Update app.py

app.py

@@ -14,7 +14,7 @@ import pathlib
 import sqlite3
 import pytz
 
-# List of target companies/keywords
+# List of target companies/keywords (영문으로 검색어는 그대로 유지)
 KOREAN_COMPANIES = [
     "NVIDIA",
     "ALPHABET",
@@ -36,7 +36,7 @@ KOREAN_COMPANIES = [
 
 def convert_to_seoul_time(timestamp_str):
     """
-    Convert a given timestamp string (UTC) to Seoul time (KST).
+    주어진 UTC 타임스탬프 문자열을 서울 시간(KST)으로 변환.
     """
     try:
         dt = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
@@ -44,36 +44,36 @@ def convert_to_seoul_time(timestamp_str):
         seoul_time = seoul_tz.localize(dt)
         return seoul_time.strftime('%Y-%m-%d %H:%M:%S KST')
     except Exception as e:
-        print(f"Time conversion error: {str(e)}")
+        print(f"시간 변환 오류: {str(e)}")
         return timestamp_str
 
 def analyze_sentiment_batch(articles, client):
     """
-    Perform a comprehensive sentiment analysis of the news articles using the OpenAI API.
+    OpenAI API를 사용하여 뉴스 기사 모음에 대한 전반적인 감성 분석을 수행한다.
+    분석 결과는 한글로 반환된다.
     """
     try:
-        # Combine all articles into a single text
+        # 모든 기사를 하나의 텍스트로 결합
         combined_text = "\n\n".join([
-            f"Title: {article.get('title', '')}\nContent: {article.get('snippet', '')}"
+            f"제목: {article.get('title', '')}\n내용: {article.get('snippet', '')}"
             for article in articles
         ])
         
-        prompt = f"""Please perform an overall sentiment analysis of the following collection of news articles:
+        prompt = f"""아래 뉴스 기사 모음에 대한 전반적인 감성 분석을 수행하세요.
 
-News content:
+뉴스 내용:
 {combined_text}
 
-Please follow this format:
-1. Overall Sentiment: [Positive/Negative/Neutral]
-2. Key Positive Factors:
-   - [Item1]
-   - [Item2]
-3. Key Negative Factors:
-   - [Item1]
-   - [Item2]
-4. Summary: [Detailed explanation]
+다음 형식을 따라 작성해 주세요:
+1. 전체 감성: [긍정/부정/중립]
+2. 주요 긍정 요인:
+   - [항목1]
+   - [항목2]
+3. 주요 부정 요인:
+   - [항목1]
+   - [항목2]
+4. 요약: [자세한 설명]
 """
-
         response = client.chat.completions.create(
             model="CohereForAI/c4ai-command-r-plus-08-2024",
             messages=[{"role": "user", "content": prompt}],
@@ -83,13 +83,13 @@ Please follow this format:
         
         return response.choices[0].message.content
     except Exception as e:
-        return f"Sentiment analysis failed: {str(e)}"
+        return f"감성 분석 실패: {str(e)}"
 
 
-# Initialize the database
+# 데이터베이스 초기화
 def init_db():
     """
-    Initialize the SQLite database (search_results.db) if it doesn't already exist.
+    SQLite 데이터베이스(search_results.db)를 초기화 (없으면 생성).
     """
     db_path = pathlib.Path("search_results.db")
     conn = sqlite3.connect(db_path)
@@ -105,7 +105,7 @@ def init_db():
 
 def save_to_db(keyword, country, results):
     """
-    Save the search results for a specific (keyword, country) combination into the database.
+    특정 (키워드, 국가) 조합에 대한 검색 결과를 데이터베이스에 저장.
     """
     conn = sqlite3.connect("search_results.db")
     c = conn.cursor()
@@ -122,8 +122,8 @@ def save_to_db(keyword, country, results):
 
 def load_from_db(keyword, country):
     """
-    Load the most recent search results for a specific (keyword, country) combination from the database.
-    Returns the data and the timestamp.
+    특정 (키워드, 국가) 조합에 대한 가장 최근 검색 결과를 데이터베이스에서 불러옴.
+    데이터를 불러오고 타임스탬프를 변환하여 반환.
     """
     conn = sqlite3.connect("search_results.db")
     c = conn.cursor()
@@ -139,84 +139,83 @@ def load_from_db(keyword, country):
 
 def display_results(articles):
     """
-    Convert a list of news articles into a Markdown string for display.
+    뉴스 기사 목록을 마크다운 문자열로 변환하여 반환.
     """
     output = ""
     for idx, article in enumerate(articles, 1):
         output += f"### {idx}. {article['title']}\n"
-        output += f"Source: {article['channel']}\n"
-        output += f"Time: {article['time']}\n"
-        output += f"Link: {article['link']}\n"
-        output += f"Summary: {article['snippet']}\n\n"
+        output += f"출처: {article['channel']}\n"
+        output += f"시간: {article['time']}\n"
+        output += f"링크: {article['link']}\n"
+        output += f"요약: {article['snippet']}\n\n"
     return output
 
 
 ########################################
-# 1) Search => Articles + Analysis, then save to DB
+# 1) 검색 => 기사 + 감성 분석, DB 저장
 ########################################
 def search_company(company):
     """
-    For a single company (or keyword), search US news.
-    1) Retrieve a list of articles
-    2) Perform sentiment analysis
-    3) Save results to DB
-    4) Return (articles + analysis) in a single output.
+    단일 회사(또는 키워드)에 대해 미국 뉴스 검색을 진행:
+      1) 기사 목록을 검색
+      2) 감성 분석 수행
+      3) 결과를 DB에 저장
+      4) 기사와 분석 결과를 하나의 출력으로 반환
     """
     error_message, articles = serphouse_search(company, "United States")
     if not error_message and articles:
-        # Perform sentiment analysis
+        # 감성 분석 수행 (한글 결과 반환)
         analysis = analyze_sentiment_batch(articles, client)
         
-        # Prepare data to save in DB
+        # DB에 저장할 데이터 준비
         store_dict = {
             "articles": articles,
             "analysis": analysis
         }
         save_to_db(company, "United States", store_dict)
         
-        # Prepare output for display
+        # 출력용 데이터 준비
         output = display_results(articles)
-        output += f"\n\n### Analysis Report\n{analysis}\n"
+        output += f"\n\n### 감성 분석 보고서\n{analysis}\n"
         return output
-    return f"No search results found for {company}."
+    return f"{company}에 대한 검색 결과가 없습니다."
 
 ########################################
-# 2) Load => Return articles + analysis from DB
+# 2) 불러오기 => DB에서 기사 + 분석 결과 반환
 ########################################
 def load_company(company):
     """
-    Load the most recent US news search results for the given company (or keyword) from the database,
-    and return the articles + analysis in a single output.
+    주어진 회사(또는 키워드)에 대해 데이터베이스에서 가장 최근 미국 뉴스 검색 결과(기사 + 감성 분석)를 불러옴.
     """
     data, timestamp = load_from_db(company, "United States")
     if data:
         articles = data.get("articles", [])
         analysis = data.get("analysis", "")
         
-        output = f"### {company} Search Results\nLast Updated: {timestamp}\n\n"
+        output = f"### {company} 검색 결과\n마지막 업데이트: {timestamp}\n\n"
         output += display_results(articles)
-        output += f"\n\n### Analysis Report\n{analysis}\n"
+        output += f"\n\n### 감성 분석 보고서\n{analysis}\n"
         return output
-    return f"No saved results for {company}."
+    return f"{company}에 대한 저장된 결과가 없습니다."
 
 
 ########################################
-# 3) Updated show_stats() with new title
+# 3) show_stats() – 보고서 제목 변경
 ########################################
 def show_stats():
     """
-    For each company in KOREAN_COMPANIES:
-      - Retrieve the most recent timestamp in DB
-      - Number of articles
-      - Sentiment analysis result
-    Return these in a report format.
-
-    Title changed to: "EarnBOT Analysis Report"
+    각 회사(KOREAN_COMPANIES)에 대해:
+      - DB에 저장된 최신 타임스탬프
+      - 저장된 기사 개수
+      - 감성 분석 결과
+    을 보고서 형식으로 반환.
+    
+    제목: "EarnBOT 분석 보고서"
     """
     conn = sqlite3.connect("search_results.db")
     c = conn.cursor()
     
-    output = "## EarnBOT Analysis Report\n\n"
+    output = "## EarnBOT 분석 보고서\n\n"
     
     data_list = []
     for company in KOREAN_COMPANIES:
@@ -253,10 +252,10 @@ def show_stats():
     for comp, tstamp, count, analysis in results_list:
         seoul_time = convert_to_seoul_time(tstamp)
         output += f"### {comp}\n"
-        output += f"- Last updated: {seoul_time}\n"
-        output += f"- Number of articles stored: {count}\n\n"
+        output += f"- 마지막 업데이트: {seoul_time}\n"
+        output += f"- 저장된 기사 수: {count}\n\n"
         if analysis:
-            output += "#### News Sentiment Analysis\n"
+            output += "#### 뉴스 감성 분석\n"
             output += f"{analysis}\n\n"
         output += "---\n\n"
     
@@ -265,10 +264,10 @@ def show_stats():
 
 def search_all_companies():
     """
-    Search all companies in KOREAN_COMPANIES (in parallel), 
-    perform sentiment analysis + save to DB => return Markdown of all results.
+    KOREAN_COMPANIES의 모든 항목에 대해(병렬 처리) 검색 후,
+    감성 분석 수행 및 DB 저장 => 모든 결과를 마크다운 문자열로 반환.
     """
-    overall_result = "# [Search Results for All Companies]\n\n"
+    overall_result = "# [전체 회사 검색 결과]\n\n"
     
     def do_search(comp):
         return comp, search_company(comp)
@@ -284,9 +283,9 @@ def search_all_companies():
 
 def load_all_companies():
     """
-    Load articles + analysis for all companies in KOREAN_COMPANIES from the DB => return Markdown.
+    DB에 저장된 모든 회사(KOREAN_COMPANIES)의 기사와 분석 결과를 불러와 마크다운으로 반환.
     """
-    overall_result = "# [All Companies Data Output]\n\n"
+    overall_result = "# [전체 회사 데이터 출력]\n\n"
     
     for comp in KOREAN_COMPANIES:
         overall_result += f"## {comp}\n"
@@ -296,81 +295,81 @@ def load_all_companies():
 
 def full_summary_report():
     """
-    1) Search all companies (in parallel) -> 2) Load results -> 3) Show sentiment analysis stats
-    Return a combined report with all three steps.
+    1) 모든 회사를 검색(병렬 처리) -> 2) DB에서 결과 불러오기 -> 3) 감성 분석 통계 표시
+    세 단계의 결과를 하나의 종합 보고서로 반환.
     """
-    # 1) Search all companies => store to DB
+    # 1) 모든 회사 검색 및 DB 저장
     search_result_text = search_all_companies()
     
-    # 2) Load all results => from DB
+    # 2) DB에서 결과 불러오기
     load_result_text = load_all_companies()
     
-    # 3) Show stats => EarnBOT Analysis Report
+    # 3) 통계 표시 – EarnBOT 분석 보고서
     stats_text = show_stats()
     
     combined_report = (
-        "# Full Analysis Summary Report\n\n"
-        "Executed in the following order:\n"
-        "1. Search all companies (parallel) + sentiment analysis => 2. Load results from DB => 3. Show overall sentiment analysis stats\n\n"
+        "# 전체 분석 종합 보고서\n\n"
+        "실행 순서:\n"
+        "1. 모든 회사 검색(병렬 처리) 및 감성 분석 → 2. DB에서 결과 불러오기 → 3. 전체 감성 분석 통계 표시\n\n"
         f"{search_result_text}\n\n"
         f"{load_result_text}\n\n"
-        "## [Overall Sentiment Analysis Stats]\n\n"
+        "## [전체 감성 분석 통계]\n\n"
         f"{stats_text}"
     )
     return combined_report
 
 
 ########################################
-# Additional feature: User custom search
+# 추가 기능: 사용자 정의 검색
 ########################################
 def search_custom(query, country):
     """
-    For a user-provided (query, country):
-    1) Search + sentiment analysis => save to DB
-    2) Load from DB => display articles + analysis
+    사용자가 입력한 (키워드, 국가)에 대해:
+    1) 검색 및 감성 분석 수행 후 DB 저장
+    2) DB에서 불러와 기사와 분석 결과 표시
     """
     error_message, articles = serphouse_search(query, country)
     if error_message:
-        return f"An error occurred: {error_message}"
+        return f"오류 발생: {error_message}"
     if not articles:
-        return "No results were found for your query."
+        return "입력하신 검색어에 대한 결과가 없습니다."
     
-    # 1) Perform analysis
+    # 1) 감성 분석 수행 (한글)
     analysis = analyze_sentiment_batch(articles, client)
     
-    # 2) Save to DB
+    # 2) DB에 저장
     save_data = {
         "articles": articles,
         "analysis": analysis
     }
     save_to_db(query, country, save_data)
     
-    # 3) Reload from DB
+    # 3) DB에서 불러오기
     loaded_data, timestamp = load_from_db(query, country)
     if not loaded_data:
-        return "Failed to load data from DB."
+        return "DB에서 데이터를 불러오지 못했습니다."
 
-    # 4) Prepare final output
-    out = f"## [Custom Search Results]\n\n"
-    out += f"**Keyword**: {query}\n\n"
-    out += f"**Country**: {country}\n\n"
-    out += f"**Timestamp**: {timestamp}\n\n"
+    # 4) 최종 출력 준비
+    out = f"## [사용자 정의 검색 결과]\n\n"
+    out += f"**검색어**: {query}\n\n"
+    out += f"**국가**: {country}\n\n"
+    out += f"**타임스탬프**: {timestamp}\n\n"
 
     arts = loaded_data.get("articles", [])
     analy = loaded_data.get("analysis", "")
     
     out += display_results(arts)
-    out += f"### News Sentiment Analysis\n{analy}\n"
+    out += f"### 뉴스 감성 분석\n{analy}\n"
     
     return out
 
 
 ########################################
-# API Authentication
+# API 인증 설정
 ########################################
 ACCESS_TOKEN = os.getenv("HF_TOKEN")
 if not ACCESS_TOKEN:
-    raise ValueError("HF_TOKEN environment variable is not set")
+    raise ValueError("HF_TOKEN 환경변수가 설정되어 있지 않습니다.")
 
 client = OpenAI(
     base_url="https://api-inference.huggingface.co/v1/",
@@ -381,7 +380,7 @@ API_KEY = os.getenv("SERPHOUSE_API_KEY")
 
 
 ########################################
-# Country-specific settings
+# 국가별 설정
 ########################################
 COUNTRY_LANGUAGES = {
     "United States": "en",
@@ -439,8 +438,8 @@ COUNTRY_LANGUAGES = {
     "Nigeria": "en",
     "Kenya": "sw",
     "Ukraine": "uk",
-    "Croatia": "hr",
-    "Slovakia": "sk",
+    "Croatia": "Croatia",
+    "Slovakia": "Slovakia",
     "Bulgaria": "bg",
     "Serbia": "sr",
     "Estonia": "et",
@@ -527,8 +526,8 @@ COUNTRY_LOCATIONS = {
 @lru_cache(maxsize=100)
 def translate_query(query, country):
     """
-    Use the unofficial Google Translation API to translate the query into the target country's language.
-    If the query is already in English, or if translation fails, return the original query.
+    비공식 Google Translation API를 사용해 대상 국가의 언어로 검색어 번역.
+    번역에 실패하거나 영어일 경우 원본 검색어 반환.
     """
     try:
         if is_english(query):
@@ -558,20 +557,20 @@ def translate_query(query, country):
         return query
         
     except Exception as e:
-        print(f"Translation error: {str(e)}")
+        print(f"번역 오류: {str(e)}")
         return query
 
 def is_english(text):
     """
-    Check if a string is (mostly) English by verifying character code ranges.
+    문자열이 주로 영어인지 확인 (문자 코드 범위 확인).
     """
     return all(ord(char) < 128 for char in text.replace(' ', '').replace('-', '').replace('_', ''))
 
 def search_serphouse(query, country, page=1, num_result=10):
     """
-    Send a real-time search request to the SerpHouse API,
-    specifying the 'news' tab (sort_by=date) for the given query.
-    Returns a dict with 'results' or 'error'.
+    SerpHouse API에 실시간 검색 요청을 보내며,
+    'news' 탭(날짜순 정렬)로 검색.
+    반환값은 'results' 또는 'error'가 포함된 dict.
     """
     url = "https://api.serphouse.com/serp/live"
     
@@ -628,26 +627,26 @@ def search_serphouse(query, country, page=1, num_result=10):
         
     except requests.exceptions.Timeout:
         return {
-            "error": "Search timed out. Please try again later.",
+            "error": "검색 시간이 초과되었습니다. 잠시 후 다시 시도해 주세요.",
             "translated_query": query
         }
     except requests.exceptions.RequestException as e:
         return {
-            "error": f"Error during search: {str(e)}",
+            "error": f"검색 중 오류 발생: {str(e)}",
             "translated_query": query
         }
     except Exception as e:
         return {
-            "error": f"Unexpected error occurred: {str(e)}",
+            "error": f"예상치 못한 오류 발생: {str(e)}",
             "translated_query": query
         }
 
 def format_results_from_raw(response_data):
     """
-    Process the SerpHouse API response data and return (error_message, article_list).
+    SerpHouse API의 응답 데이터를 처리하여 (오류 메시지, 기사 목록)을 반환.
     """
     if "error" in response_data:
-        return "Error: " + response_data["error"], []
+        return "오류: " + response_data["error"], []
 
     try:
         results = response_data["results"]
@@ -655,9 +654,9 @@ def format_results_from_raw(response_data):
         
         news_results = results.get('results', {}).get('results', {}).get('news', [])
         if not news_results:
-            return "No search results found.", []
+            return "검색 결과가 없습니다.", []
         
-        # Filter out Korean domains and Korean keywords (example filtering)
+        # 한국 도메인 및 키워드 필터링 (예시)
         korean_domains = [
             '.kr', 'korea', 'korean', 'yonhap', 'hankyung', 'chosun', 
             'donga', 'joins', 'hani', 'koreatimes', 'koreaherald'
@@ -678,27 +677,27 @@ def format_results_from_raw(response_data):
                 any(keyword in title for keyword in korean_keywords)
             )
             
-            # Exclude Korean content
+            # 한국 관련 콘텐츠 제외
             if not is_korean_content:
                 filtered_articles.append({
                     "index": idx,
-                    "title": result.get("title", "No Title"),
+                    "title": result.get("title", "제목 없음"),
                     "link": url,
-                    "snippet": result.get("snippet", "No Content"),
-                    "channel": result.get("channel", result.get("source", "Unknown")),
-                    "time": result.get("time", result.get("date", "Unknown Time")),
+                    "snippet": result.get("snippet", "내용 없음"),
+                    "channel": result.get("channel", result.get("source", "알 수 없음")),
+                    "time": result.get("time", result.get("date", "시간 정보 없음")),
                     "image_url": result.get("img", result.get("thumbnail", "")),
                     "translated_query": translated_query
                 })
 
         return "", filtered_articles
     except Exception as e:
-        return f"Error processing results: {str(e)}", []
+        return f"결과 처리 중 오류 발생: {str(e)}", []
 
 def serphouse_search(query, country):
     """
-    Helper function to search and then format results.
-    Returns (error_message, article_list).
+    검색 및 결과 포맷팅을 위한 헬퍼 함수.
+    (오류 메시지, 기사 목록)을 반환.
     """
     response_data = search_serphouse(query, country)
     return format_results_from_raw(response_data)
@@ -907,9 +906,9 @@ footer {
 }
 """
 
-# --- Gradio Interface (UI portion only) ---
-with gr.Blocks(css=css, title="NewsAI Service") as iface:
-    # Initialize the database first (keeping the call to init_db(), unchanged)
+# --- Gradio 인터페이스 (UI 부분) ---
+with gr.Blocks(css=css, title="NewsAI 서��스") as iface:
+    # 데이터베이스 초기화 (init_db() 호출)
     init_db()
 
     gr.HTML("""<a href="https://visitorbadge.io/status?path=https%3A%2F%2Fopenfree-MoneyRadar.hf.space">
@@ -919,50 +918,54 @@ with gr.Blocks(css=css, title="NewsAI Service") as iface:
     
     with gr.Tabs():
         with gr.Tab("MoneyRadar"):
-            # Added usage instructions and feature explanations here:
+            # 사용 방법 및 기능 설명 (한글)
             gr.Markdown(
                 """
-                ## MoneyRadar: Implies scanning(Automatic extraction of top 100 priority news within the last 24 hours) the market to spot money-making opportunities.
-
-                **How to Use This Service**:
-                1. **Custom Search**: Enter any keyword and choose a target country to fetch the latest news. The system automatically performs sentiment analysis and stores results in the database.
-                2. **Generate Full Analysis Summary Report**: This will automatically:
-                   - Search all predefined companies (in parallel),
-                   - Store the articles and sentiment analysis,
-                   - Display a combined overall report.
-                3. **Individual Companies**:
-                   - **Search**: Fetch and analyze the latest news from Google (for the chosen company).
-                   - **Load from DB**: Retrieve the most recent saved news and sentiment analysis from the local database.
-
-                **Features**:
-                - **Real-time News Scraping**: Retrieves fresh articles from multiple regions.
-                - **Advanced Sentiment Analysis**: Uses state-of-the-art NLP models via the API.
-                - **Data Persistence**: Automatically saves and retrieves search results in a local SQLite database for quick reference.
-                - **Flexible**: Ability to search any keyword/country or select from predefined Big Tech & finance-related terms.
-                0. **Community: https://discord.gg/openfreeai
-                ---                
+                ## MoneyRadar
+                최신 24시간 내 상위 100개의 우선순위 뉴스를 자동으로 추출하여  
+                수익 기회를 포착합니다.
+
+                **서비스 사용 방법**:
+                1. **사용자 정의 검색**: 키워드를 입력하고 대상 국가를 선택하여 최신 뉴스를 가져옵니다.  
+                   시스템이 자동으로 감성 분석을 수행하고 결과를 데이터베이스에 저장합니다.
+                2. **전체 분석 종합 보고서 생성**: 아래 작업을 자동으로 수행합니다.
+                   - 사전 정의된 모든 회사를 병렬로 검색
+                   - 기사와 감성 분석 결과를 데이터베이스에 저장
+                   - 전체 결과를 종합 보고서로 표시
+                3. **개별 회사 검색/불러오기**:
+                   - **검색**: 선택한 회사에 대해 Google에서 최신 뉴스를 검색 및 분석
+                   - **DB 불러오기**: 로컬 데이터베이스에서 저장된 최신 뉴스와 감성 분석 결과를 불러옵니다.
+
+                **주요 기능**:
+                - **실시간 뉴스 스크래핑**: 여러 지역에서 최신 기사를 가져옵니다.
+                - **고급 감성 분석**: 최신 NLP 모델을 활용한 감성 분석을 수행합니다.
+                - **데이터 영속성**: 검색 결과를 SQLite 데이터베이스에 자동 저장 및 불러오기.
+                - **유연성**: 사전 정의된 키워드뿐 아니라 원하는 키워드/국가 검색이 가능합니다.
+
+                **커뮤니티**: https://discord.gg/openfreeai
+                ---
                 """
             )
             
-            # User custom search section
+            # 사용자 정의 검색 섹션
             with gr.Group():
-                gr.Markdown("### Custom Search")
+                gr.Markdown("### 사용자 정의 검색")
                 with gr.Row():
                     with gr.Column():
                         user_input = gr.Textbox(
-                            label="Enter your keyword",
-                            placeholder="e.g., Apple, Samsung, etc.",
+                            label="키워드를 입력하세요",
+                            placeholder="예: Apple, Samsung 등",
                             elem_classes="textbox"
                         )
                     with gr.Column():
                         country_selection = gr.Dropdown(
                             choices=list(COUNTRY_LOCATIONS.keys()),
                             value="United States",
-                            label="Select Country"
+                            label="국가 선택"
                         )
                     with gr.Column():
                         custom_search_btn = gr.Button(
-                            "Search", 
+                            "검색", 
                             variant="primary", 
                             elem_classes="primary-btn"
                         )
@@ -975,10 +978,10 @@ with gr.Blocks(css=css, title="NewsAI Service") as iface:
                     outputs=custom_search_output
                 )
 
-            # Button to generate a full report
+            # 전체 보고서 생성을 위한 버튼
             with gr.Row():
                 full_report_btn = gr.Button(
-                    "Generate Full Analysis Summary Report", 
+                    "전체 분석 종합 보고서 생성", 
                     variant="primary", 
                     elem_classes="primary-btn"
                 )
@@ -989,23 +992,23 @@ with gr.Blocks(css=css, title="NewsAI Service") as iface:
                 outputs=full_report_display
             )
             
-            # Individual search/load for companies in KOREAN_COMPANIES
+            # 개별 회사에 대한 검색/불러오기
             with gr.Column():
                 for i in range(0, len(KOREAN_COMPANIES), 2):
                     with gr.Row():
-                        # Left column
+                        # 왼쪽 컬럼
                         with gr.Column():
                             company = KOREAN_COMPANIES[i]
                             with gr.Group():
                                 gr.Markdown(f"### {company}")
                                 with gr.Row():
                                     search_btn = gr.Button(
-                                        "Search", 
+                                        "검색", 
                                         variant="primary", 
                                         elem_classes="primary-btn"
                                     )
                                     load_btn = gr.Button(
-                                        "Load from DB", 
+                                        "DB 불러오기", 
                                         variant="secondary", 
                                         elem_classes="secondary-btn"
                                     )
@@ -1020,7 +1023,7 @@ with gr.Blocks(css=css, title="NewsAI Service") as iface:
                                     outputs=result_display
                                 )
                         
-                        # Right column (if exists)
+                        # 오른쪽 컬럼 (존재할 경우)
                         if i + 1 < len(KOREAN_COMPANIES):
                             with gr.Column():
                                 company = KOREAN_COMPANIES[i + 1]
@@ -1028,12 +1031,12 @@ with gr.Blocks(css=css, title="NewsAI Service") as iface:
                                     gr.Markdown(f"### {company}")
                                     with gr.Row():
                                         search_btn = gr.Button(
-                                            "Search", 
+                                            "검색", 
                                             variant="primary", 
                                             elem_classes="primary-btn"
                                         )
                                         load_btn = gr.Button(
-                                            "Load from DB", 
+                                            "DB 불러오기", 
                                             variant="secondary", 
                                             elem_classes="secondary-btn"
                                         )
@@ -1048,7 +1051,7 @@ with gr.Blocks(css=css, title="NewsAI Service") as iface:
                                         outputs=result_display
                                     )
 
-    # Launch the Gradio interface
+    # Gradio 인터페이스 실행
     iface.launch(
         server_name="0.0.0.0",
         server_port=7860,