Update app.py

app.py

@@ -1,294 +1,546 @@
 # ──────────────────────────────── Imports ────────────────────────────────
-import os, json, re, logging, requests, markdown, time
+import os, json, re, logging, requests, markdown, time, io
 from datetime import datetime
 
 import streamlit as st
 import anthropic
 from gradio_client import Client
-# from bs4 import BeautifulSoup   # 필요 시 주석 해제
+import pandas as pd
+import PyPDF2  # For handling PDF files
 
-# ──────────────────────────────── 환경 변수 / 상수 ───────────────────────────
+# ──────────────────────────────── Environment Variables / Constants ─────────────────────────
 ANTHROPIC_KEY  = os.getenv("API_KEY", "")
-BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")  # 이름 유지
+BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")  # Keep this name
 BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
 IMAGE_API_URL  = "http://211.233.58.201:7896"
 MAX_TOKENS     = 7_999
 
-# 블로그 템플릿 및 스타일 정의 (한글화)
+# Blog template and style definitions (in English)
 BLOG_TEMPLATES = {
-    "standard": "표준 8단계 프레임워크 블로그",
-    "tutorial": "단계별 튜토리얼 형식",
-    "review": "제품/서비스 리뷰 형식",
-    "storytelling": "스토리텔링 형식",
-    "seo_optimized": "SEO 최적화 블로그"
+    "ginigen": "Recommended style by Ginigen",
+    "standard": "Standard 8-step framework blog",
+    "tutorial": "Step-by-step tutorial format",
+    "review": "Product/service review format",
+    "storytelling": "Storytelling format",
+    "seo_optimized": "SEO-optimized blog"
 }
 
 BLOG_TONES = {
-    "professional": "전문적이고 공식적인 톤",
-    "casual": "친근하고 대화체 중심 톤",
-    "humorous": "유머러스한 접근",
-    "storytelling": "이야기 중심의 접근"
+    "professional": "Professional and formal tone",
+    "casual": "Friendly and conversational tone",
+    "humorous": "Humorous approach",
+    "storytelling": "Story-driven approach"
 }
 
-# 예제 블로그 주제
+# Example blog topics
 EXAMPLE_TOPICS = {
-    "example1": "2025년 바뀐 부동산 세금 제도: 일반 가정에 미치는 영향과 절세 전략",
-    "example2": "2025년 여름 전국 지역별 대표 축제 총정리와 숨은 명소 추천",
-    "example3": "2025년 주목해야 할 신성장 산업 투자 가이드: 인공지능 관련 발굴 전략"
+    "example1": "Changes to the real estate tax system in 2025: Impact on average households and tax-saving strategies",
+    "example2": "Summer festivals in 2025: A comprehensive guide to major regional events and hidden attractions",
+    "example3": "Emerging industries to watch in 2025: An investment guide focused on AI opportunities"
 }
 
-# ──────────────────────────────── 로깅 ──────────────────────────────────────
+# ──────────────────────────────── Logging ────────────────────────────────
 logging.basicConfig(level=logging.INFO,
                     format="%(asctime)s - %(levelname)s - %(message)s")
 
-# ──────────────────────────────── Anthropic Client ─────────────────────────
-client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
+# ──────────────────────────────── Anthropic Client ────────────────────────
+@st.cache_resource
+def get_anthropic_client():
+    return anthropic.Anthropic(api_key=ANTHROPIC_KEY)
 
-# ──────────────────────────────── 블로그 작성 시스템 프롬프트 ────────────────
-# ──────────────────────────────── 블로그 작성 시스템 프롬프트 ────────────────
-def get_system_prompt(template="standard", tone="professional", word_count=1750, include_search_results=False) -> str:
+# ──────────────────────────────── Blog Creation System Prompt ─────────────
+def get_system_prompt(template="ginigen", tone="professional", word_count=1750, include_search_results=False, include_uploaded_files=False) -> str:
+    """
+    Generate a system prompt that includes:
+    - The 8-step blog writing framework
+    - The selected template and tone
+    - Guidelines for using web search results and uploaded files
+    """
+
+    # Ginigen recommended style prompt (English version)
+    ginigen_prompt = """
+## 🌟 Professional Blogger System Prompt
+
+### ✅ Official 8-step Prompt
+
+Follow these 8 steps exactly in order to write the blog post:
+
+### 1. Start with a greeting and empathy
+- Open with a friendly tone that draws the reader in
+- Ask questions or present scenarios that resonate with the reader’s real-life concerns
+
+### 2. Clearly present the problem
+- Pinpoint the exact and realistic problem the reader is facing
+- Emphasize the seriousness or urgency of this problem to maintain interest
+
+### 3. Analyze the cause of the problem to build credibility
+- Explain the causes of the problem logically
+- Clearly and specifically present your analysis so the reader can understand it easily
+- Include data, examples, or references if necessary
+
+### 4. Offer a concrete solution
+- Provide specific, actionable steps to solve the problem
+- Give tips, strategies, and guidelines so the reader can implement them right away
+
+### 5. Provide social proof
+- Include real success stories, reviews, user experiences, or data
+- Keep details factual and believable so the reader can trust the content
+
+### 6. Call to action (CTA)
+- Encourage the reader to take specific actions immediately
+- Use urgent language such as “right now,” “from today,” or “immediately” to drive action
+
+### 7. Add constraints or warnings to increase authenticity
+- Acknowledge that the solution might not work for everyone
+- Show sincerity and scarcity, which boosts trust
+
+### 8. Express gratitude and guide them to further connection
+- Thank the reader for their time
+- Provide a natural lead-in to the next post, or ask for comments/subscriptions
+
+---
+
+### 🚩 Writing Style Tips
+- Maintain a friendly and human-like tone
+- Frequently use questions and a conversational style to engage the reader
+- Use clear headings, horizontal lines, bullet points, or numbered lists for readability
+- Include real-life examples and specific data where possible
+"""
+
+    # Standard 8-step framework (English version)
     base_prompt = """
-당신은 전문 블로그 작성 전문가입니다. 모든 블로그 글 작성 요청에 대해 다음의 8단계 프레임워크를 철저히 따르되, 자연스럽고 매력적인 글이 되도록 작성해야 합니다:
-독자 연결 단계
-1.1. 공감대 형성을 위한 친근한 인사
-1.2. 독자의 실제 고민을 반영한 도입 질문
-1.3. 주제에 대한 즉각적 관심 유도
-문제 정의 단계
-2.1. 독자의 페인포인트 구체화
-2.2. 문제의 시급성과 영향도 분석
-2.3. 해결 필요성에 대한 공감대 형성
-전문성 입증 단계
-3.1. 객관적 데이터 기반 분석
-3.2. 전문가 견해와 연구 결과 인용
-3.3. 실제 사례를 통한 문제 구체화
-솔루션 제공 단계
-4.1. 단계별 실천 가이드라인 제시
-4.2. 즉시 적용 가능한 구체적 팁
-4.3. 예상 장애물과 극복 방안 포함
-신뢰도 강화 단계
-5.1. 실제 성공 사례 제시
-5.2. 구체적 사용자 후기 인용
-5.3. 객관적 데이터로 효과 입증
-행동 유도 단계
-6.1. 명확한 첫 실천 단계 제시
-6.2. 시급성을 강조한 행동 촉구
-6.3. 실천 동기 부여 요소 포함
-진정성 강화 단계
-7.1. 솔루션의 한계 투명하게 공개
-7.2. 개인별 차이 존재 인정
-7.3. 필요 조건과 주의사항 명시
-관계 지속 단계
-8.1. 진정성 있는 감사 인사
-8.2. 다음 컨텐츠 예고로 기대감 조성
-8.3. 소통 채널 안내
+You are an expert in writing professional blog posts. For every blog writing request, strictly follow this 8-step framework to produce a coherent, engaging post:
+
+Reader Connection Phase
+1.1. Friendly greeting to build rapport
+1.2. Reflect actual reader concerns through introductory questions
+1.3. Stimulate immediate interest in the topic
+
+Problem Definition Phase
+2.1. Define the reader’s pain points in detail
+2.2. Analyze the urgency and impact of the problem
+2.3. Build a consensus on why it needs to be solved
+
+Establish Expertise Phase
+3.1. Analyze based on objective data
+3.2. Cite expert views and research findings
+3.3. Use real-life examples to further clarify the issue
+
+Solution Phase
+4.1. Provide step-by-step guidance
+4.2. Suggest practical tips that can be applied immediately
+4.3. Mention potential obstacles and how to overcome them
+
+Build Trust Phase
+5.1. Present actual success stories
+5.2. Quote real user feedback
+5.3. Use objective data to prove effectiveness
+
+Action Phase
+6.1. Suggest the first clear step the reader can take
+6.2. Urge timely action by emphasizing urgency
+6.3. Motivate by highlighting incentives or benefits
+
+Authenticity Phase
+7.1. Transparently disclose any limits of the solution
+7.2. Admit that individual experiences may vary
+7.3. Mention prerequisites or cautionary points
+
+Relationship Continuation Phase
+8.1. Conclude with sincere gratitude
+8.2. Preview upcoming content to build anticipation
+8.3. Provide channels for further communication
 """
 
-    # 템플릿별 추가 지침
+    # Additional guidelines for each template
     template_guides = {
         "tutorial": """
-이 블로그는 튜토리얼 형식으로 작성해 주세요:
-- 명확한 목표와 최종 결과물 먼저 제시
-- 단계별로 명확하게 구분된 과정 설명
-- 각 단계마다 이미지를 삽입할 위치 표시
-- 예상 소요 시간과 난이도 명시
-- 필요한 도구나 사전 지식 안내
-- 문제해결 팁과 자주 발생하는 실수 포함
-- 완료 후 다음 단계나 응용법 제안
+This blog should be in a tutorial style:
+- Clearly state the goal and the final outcome first
+- Provide step-by-step explanations with clear separations
+- Indicate where images could be inserted for each step
+- Mention approximate time requirements and difficulty level
+- List necessary tools or prerequisite knowledge
+- Give troubleshooting tips and common mistakes to avoid
+- Conclude with suggestions for next steps or advanced applications
 """,
-        
         "review": """
-이 블로그는 리뷰 형식으로 작성해 주세요:
-- 객관적 사실과 주관적 평가 구분
-- 명확한 평가 기준 제시
-- 장점과 단점 균형있게 서술
-- 유사 제품/서비스와 비교
-- 누구에게 적합한지 타겟 설명
-- 구체적인 사용 경험과 결과 포함
-- 최종 추천 여부와 대안 제시
+This blog should be in a review style:
+- Separate objective facts from subjective opinions
+- Clearly list your evaluation criteria
+- Discuss both pros and cons in a balanced way
+- Compare with similar products/services
+- Specify the target audience for whom it is suitable
+- Provide concrete use cases and outcomes
+- Conclude with a final recommendation or alternatives
 """,
-        
         "storytelling": """
-이 블로그는 스토리텔링 형식으로 작성해 주세요:
-- 실제 인물이나 사례로 시작
-- 문제 상황과 감정적 연결 강화
-- 갈등과 해결과정 중심의 내러티브
-- 교훈과 배움을 자연스럽게 포함
-- 독자가 공감할 수 있는 감정선 유지
-- 이야기와 유용한 정보의 균형 유지
-- 독자에게 자신의 이야기를 생각해보게 유도
+This blog should be in a storytelling style:
+- Start with a real or hypothetical person or case
+- Emphasize emotional connection with the problem scenario
+- Follow a narrative structure centered on conflict and resolution
+- Include meaningful insights or lessons learned
+- Maintain an emotional thread the reader can relate to
+- Balance storytelling with useful information
+- Encourage the reader to reflect on their own story
 """,
-        
         "seo_optimized": """
-이 블로그는 SEO 최적화 형식으로 작성해 주세요:
-- 핵심 키워드를 제목, 소제목, 첫 단락에 배치
-- 관련 키워드를 자연스럽게 본문에 분산
-- 300-500자 분량의 명확한 단락 구성
-- 질문 형식의 소제목 활용
-- 목록, 표, 강조 텍스트 등 다양한 서식 활용
-- 내부 링크 삽입 위치 표시
-- 2000-3000자 이상의 충분한 콘텐츠 제공
+This blog should be SEO-optimized:
+- Include the main keyword in the title, headings, and first paragraph
+- Spread related keywords naturally throughout the text
+- Keep paragraphs around 300-500 characters
+- Use question-based subheadings
+- Make use of lists, tables, and bold text to diversify formatting
+- Indicate where internal links could be inserted
+- Provide sufficient content of at least 2000-3000 characters
 """
     }
-    
-    # 톤별 추가 지침
+
+    # Additional guidelines for each tone
     tone_guides = {
-        "professional": "전문적이고 권위있는 어조로 작성하되, 전문 용어는 적절히 설명해 주세요. 데이터와 연구 결과를 중심으로 논리적 흐름을 유지하세요.",
-        "casual": "친근하고 대화하듯 편안한 어조로 작성해 주세요. '~네요', '~해요' 같은 대화체를 사용하고, 개인적 경험과 비유를 통해 내용을 전달하세요.",
-        "humorous": "유머와 재치있는 표현을 적절히 활용해 주세요. 재미있는 비유나 예시, 가벼운 농담을 포함하되, 정보의 정확성과 유용성은 유지하세요.",
-        "storytelling": "이야기를 들려주듯 감성적이고 몰입감 있는 톤으로 작성해 주세요. 인물, 배경, 갈등, 해결과정이 담긴 내러티브 구조를 활용하세요."
+        "professional": "Use a professional, authoritative voice. Clearly explain any technical terms and present data or research to maintain a logical flow.",
+        "casual": "Use a relaxed, conversational style. Employ personal experiences, relatable examples, and a friendly voice (e.g., 'It’s super useful!').",
+        "humorous": "Use humor and witty expressions. Add funny analogies or jokes while preserving accuracy and usefulness.",
+        "storytelling": "Write as if telling a story, with emotional depth and narrative flow. Incorporate characters, settings, conflicts, and resolutions."
     }
-    
-    # 검색 결과 활용 지침 추가
+
+    # Guidelines for using search results
     search_guide = """
-검색 결과 활용 지침:
-- 제공된 검색 결과에서 핵심 정보를 정확하게 추출하여 반영하세요
-- 데이터, 통계, 사례는 검색 결과의 최신 정보를 활용하세요
-- 인용 시 출처를 본문 내에 언급하세요 (예: "OO 사이트에 따르면...")
-- 블로그 마지막에 "참고 자료" 섹션을 추가하고 사용한 주요 출처를 링크와 함께 나열하세요
-- 출처가 없는 정보는 "일반적으로..." 등의 표현을 사용하세요
-- 검색 결과의 정보가 상충할 경우, 다양한 관점을 균형있게 제시하세요
+Guidelines for Using Search Results:
+- Accurately incorporate key information from the search results into the blog
+- Include recent data, statistics, and case studies from the search results
+- When quoting, specify the source within the text (e.g., “According to XYZ website...”)
+- At the end of the blog, add a "References" section and list major sources with links
+- If there are conflicting pieces of information, present multiple perspectives
+- Make sure to reflect the latest trends and data from the search results
 """
-    
-    # 최종 프롬프트 조합
-    final_prompt = base_prompt
-    
-    # 선택된 템플릿 지침 추가
-    if template in template_guides:
+
+    # Guidelines for using uploaded files
+    upload_guide = """
+Guidelines for Using Uploaded Files (Highest Priority):
+- The uploaded files must be a main source of information for the blog
+- Carefully examine the data, statistics, or examples in the file and integrate them
+- Directly quote and thoroughly explain any key figures or claims from the file
+- Highlight the file content as a crucial aspect of the blog
+- Mention the source clearly, e.g., “According to the uploaded data...”
+- For CSV files, detail important stats or numerical data in the blog
+- For PDF files, quote crucial segments or statements
+- For text files, integrate relevant content effectively
+- Even if the file content seems tangential, do your best to connect it to the blog topic
+- Keep consistency throughout and ensure the file’s data is appropriately reflected
+"""
+
+    # Choose base prompt
+    if template == "ginigen":
+        final_prompt = ginigen_prompt
+    else:
+        final_prompt = base_prompt
+
+    # If the user chose a specific template (and not ginigen), append the relevant guidelines
+    if template != "ginigen" and template in template_guides:
         final_prompt += "\n" + template_guides[template]
-    
-    # 선택된 톤 지침 추가
+
+    # If a specific tone is selected, append that guideline
     if tone in tone_guides:
-        final_prompt += f"\n\n톤앤매너: {tone_guides[tone]}"
-    
-    # 검색 결과 활용 지침 추가 (웹 검색 활성화 시)
+        final_prompt += f"\n\nTone and Manner: {tone_guides[tone]}"
+
+    # If web search results should be included
     if include_search_results:
         final_prompt += f"\n\n{search_guide}"
-    
-    # 글자 수 지침 추가
-    final_prompt += f"\n\n작성 시 준수사항\n9.1. 글자 수: {word_count-250}-{word_count+250}자 내외\n9.2. 문단 길이: 3-4문장 이내\n9.3. 시각적 구분: 소제목, 구분선, 번호 목록 활용\n9.4. 데이터: 모든 정보의 출처 명시\n9.5. 가독성: 명확한 단락 구분과 강조점 사용"
-    
+
+    # If uploaded files should be included
+    if include_uploaded_files:
+        final_prompt += f"\n\n{upload_guide}"
+
+    # Word count guidelines
+    final_prompt += (
+        f"\n\nWriting Requirements:\n"
+        f"9.1. Word Count: around {word_count-250}-{word_count+250} characters\n"
+        f"9.2. Paragraph Length: 3-4 sentences each\n"
+        f"9.3. Visual Cues: Use subheadings, separators, and bullet/numbered lists\n"
+        f"9.4. Data: Cite all sources\n"
+        f"9.5. Readability: Use clear paragraph breaks and highlights where necessary"
+    )
+
     return final_prompt
 
-# ──────────────────────────────── Brave Search API ─────────────────────────
-def brave_search(query: str, count: int = 20):  # 기본값을 20으로 변경
+# ──────────────────────────────── Brave Search API ────────────────────────
+@st.cache_data(ttl=3600)
+def brave_search(query: str, count: int = 20):
     """
-    Brave Web Search API 호출 → list[dict]
-    반환 필드: index, title, link, snippet, displayed_link
+    Call the Brave Web Search API → list[dict]
+    Returns fields: index, title, link, snippet, displayed_link
     """
     if not BRAVE_KEY:
-        raise RuntimeError("⚠️  SERPHOUSE_API_KEY (Brave API Key) 환경변수가 비어 있습니다.")
+        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")
 
     headers = {
         "Accept": "application/json",
         "Accept-Encoding": "gzip",
         "X-Subscription-Token": BRAVE_KEY
     }
-    params = {"q": query, "count": str(count)}  # 카운트 파라미터 전달
-    
-    for attempt in range(3):  # 최대 3번 재시도
+    params = {"q": query, "count": str(count)}
+
+    for attempt in range(3):
         try:
             r = requests.get(BRAVE_ENDPOINT, headers=headers, params=params, timeout=15)
             r.raise_for_status()
             data = r.json()
-            
-            # 결과 형식 확인 및 로깅
-            logging.info(f"Brave 검색 결과 데이터 구조: {list(data.keys())}")
-            
+
+            logging.info(f"Brave search result data structure: {list(data.keys())}")
+
             raw = data.get("web", {}).get("results") or data.get("results", [])
             if not raw:
-                logging.warning(f"Brave 검색 결과 없음. 응답: {data}")
-                raise ValueError("검색 결과가 없습니다")
-                
+                logging.warning(f"No Brave search results found. Response: {data}")
+                raise ValueError("No search results found.")
+            
             arts = []
-            for i, res in enumerate(raw[:count], 1):  # count만큼 반복
-                url   = res.get("url", res.get("link", ""))
-                host  = re.sub(r"https?://(www\.)?", "", url).split("/")[0]
+            for i, res in enumerate(raw[:count], 1):
+                url = res.get("url", res.get("link", ""))
+                host = re.sub(r"https?://(www\.)?", "", url).split("/")[0]
                 arts.append({
                     "index": i,
-                    "title": res.get("title", "제목 없음"),
+                    "title": res.get("title", "No title"),
                     "link": url,
-                    "snippet": res.get("description", res.get("text", "내용 없음")),
+                    "snippet": res.get("description", res.get("text", "No snippet")),
                     "displayed_link": host
                 })
-            
-            logging.info(f"Brave 검색 성공: {len(arts)}개 결과")
+
+            logging.info(f"Brave search success: {len(arts)} results")
             return arts
-            
+
         except Exception as e:
-            logging.error(f"Brave 검색 실패 (시도 {attempt+1}/3): {e}")
-            if attempt < 2:  # 마지막 시도가 아니면 대기 후 재시도
+            logging.error(f"Brave search failure (attempt {attempt+1}/3): {e}")
+            if attempt < 2:
                 time.sleep(2)
-            
-    return []  # 모든 시도 실패 시 빈 목록 반환
+
+    return []
 
 def mock_results(query: str) -> str:
-    """검색 API 실패 시 가상 검색 결과 제공"""
+    """Fallback search results if API fails"""
     ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    return (f"# 검색 결과 대체 내용 (생성: {ts})\n\n"
-            f"검색 API 호출이 실패했습니다. 주제 '{query}'에 대해 기존 지식을 활용해 답변해 주세요.\n\n"
-            f"다음 내용이 도움이 될 수 있습니다:\n\n"
-            f"- {query}의 기본 개념과 중요성\n"
-            f"- 일반적으로 알려진 관련 통계와 트렌드\n"
-            f"- 해당 주제에 대한 전문가들의 일반적인 견해\n"
-            f"- 독자들이 실제로 궁금해할 만한 질문들\n\n"
-            f"참고: 이 내용은 실시간 검색 결과가 아닌 대체 안내입니다.\n\n")
+    return (f"# Fallback Search Content (Generated: {ts})\n\n"
+            f"The search API request failed. Please generate the blog based on any pre-existing knowledge about '{query}'.\n\n"
+            f"You may consider the following points:\n\n"
+            f"- Basic concepts and importance of {query}\n"
+            f"- Commonly known related statistics or trends\n"
+            f"- Typical expert opinions on this subject\n"
+            f"- Questions that readers might have\n\n"
+            f"Note: This is fallback guidance, not real-time data.\n\n")
 
 def do_web_search(query: str) -> str:
-    """웹 검색 수행 및 결과 포맷팅"""
+    """Perform web search and format the results."""
     try:
         arts = brave_search(query, 20)
         if not arts:
-            logging.warning("검색 결과 없음, 대체 콘텐츠 사용")
+            logging.warning("No search results, using fallback content")
             return mock_results(query)
-        
-        hdr = "# 웹 검색 결과\n제공된 검색 결과의 정보를 정확하게 반영하여 신뢰도 높은 블로그를 작성하세요. 정보 인용 시 출처를 명시하고, 블로그 마지막에 참고 자료 섹션을 추가하세요.\n\n"
+
+        hdr = "# Web Search Results\nUse the information below to enhance the reliability of your blog. When you quote, please cite the source, and add a References section at the end of the blog.\n\n"
         body = "\n".join(
             f"### Result {a['index']}: {a['title']}\n\n{a['snippet']}\n\n"
-            f"**출처**: [{a['displayed_link']}]({a['link']})\n\n---\n"
+            f"**Source**: [{a['displayed_link']}]({a['link']})\n\n---\n"
             for a in arts
         )
         return hdr + body
     except Exception as e:
-        logging.error(f"웹 검색 전체 프로세스 실패: {str(e)}")
+        logging.error(f"Web search process failed: {str(e)}")
         return mock_results(query)
 
-# ──────────────────────────────── 이미지 · 변환 유틸 ────────────────────────
+# ──────────────────────────────── File Upload Handling ─────────────────────
+def process_text_file(file):
+    """Handle text file"""
+    try:
+        content = file.read()
+        file.seek(0)
+
+        text = content.decode('utf-8', errors='ignore')
+        if len(text) > 10000:
+            text = text[:9700] + "...(truncated)..."
+
+        result = f"## Text File: {file.name}\n\n"
+        result += text
+        return result
+    except Exception as e:
+        logging.error(f"Error processing text file: {str(e)}")
+        return f"Error processing text file: {str(e)}"
+
+def process_csv_file(file):
+    """Handle CSV file"""
+    try:
+        content = file.read()
+        file.seek(0)
+
+        df = pd.read_csv(io.BytesIO(content))
+        result = f"## CSV File: {file.name}\n\n"
+        result += f"- Rows: {len(df)}\n"
+        result += f"- Columns: {len(df.columns)}\n"
+        result += f"- Column Names: {', '.join(df.columns.tolist())}\n\n"
+
+        result += "### Data Preview\n\n"
+        preview_df = df.head(10)
+        try:
+            markdown_table = preview_df.to_markdown(index=False)
+            if markdown_table:
+                result += markdown_table + "\n\n"
+            else:
+                result += "Unable to display CSV data.\n\n"
+        except Exception as e:
+            logging.error(f"Markdown table conversion error: {e}")
+            result += "Displaying data as text:\n\n"
+            result += str(preview_df) + "\n\n"
+
+        num_cols = df.select_dtypes(include=['number']).columns
+        if len(num_cols) > 0:
+            result += "### Basic Statistical Information\n\n"
+            try:
+                stats_df = df[num_cols].describe().round(2)
+                stats_markdown = stats_df.to_markdown()
+                if stats_markdown:
+                    result += stats_markdown + "\n\n"
+                else:
+                    result += "Unable to display statistical information.\n\n"
+            except Exception as e:
+                logging.error(f"Statistical info conversion error: {e}")
+                result += "Unable to generate statistical information.\n\n"
+
+        return result
+    except Exception as e:
+        logging.error(f"CSV file processing error: {str(e)}")
+        return f"Error processing CSV file: {str(e)}"
+
+def process_pdf_file(file):
+    """Handle PDF file"""
+    try:
+        # Read file in bytes
+        file_bytes = file.read()
+        file.seek(0)
+
+        # Use PyPDF2
+        pdf_file = io.BytesIO(file_bytes)
+        reader = PyPDF2.PdfReader(pdf_file, strict=False)
+
+        # Basic info
+        result = f"## PDF File: {file.name}\n\n"
+        result += f"- Total pages: {len(reader.pages)}\n\n"
+
+        # Extract text by page (limit to first 5 pages)
+        max_pages = min(5, len(reader.pages))
+        all_text = ""
+
+        for i in range(max_pages):
+            try:
+                page = reader.pages[i]
+                page_text = page.extract_text()
+
+                current_page_text = f"### Page {i+1}\n\n"
+                if page_text and len(page_text.strip()) > 0:
+                    # Limit to 1500 characters per page
+                    if len(page_text) > 1500:
+                        current_page_text += page_text[:1500] + "...(truncated)...\n\n"
+                    else:
+                        current_page_text += page_text + "\n\n"
+                else:
+                    current_page_text += "(No text could be extracted from this page)\n\n"
+
+                all_text += current_page_text
+
+                # If total text is too long, break
+                if len(all_text) > 8000:
+                    all_text += "...(truncating remaining pages; PDF is too large)...\n\n"
+                    break
+
+            except Exception as page_err:
+                logging.error(f"Error processing PDF page {i+1}: {str(page_err)}")
+                all_text += f"### Page {i+1}\n\n(Error extracting content: {str(page_err)})\n\n"
+
+        if len(reader.pages) > max_pages:
+            all_text += f"\nNote: Only the first {max_pages} pages are shown out of {len(reader.pages)} total.\n\n"
+
+        result += "### PDF Content\n\n" + all_text
+        return result
+
+    except Exception as e:
+        logging.error(f"PDF file processing error: {str(e)}")
+        return f"## PDF File: {file.name}\n\nError occurred: {str(e)}\n\nThis PDF file cannot be processed."
+
+def process_uploaded_files(files):
+    """Combine the contents of all uploaded files into one string."""
+    if not files:
+        return None
+
+    result = "# Uploaded File Contents\n\n"
+    result += "Below is the content from the files provided by the user. Integrate this data as a main source of information for the blog.\n\n"
+
+    for file in files:
+        try:
+            ext = file.name.split('.')[-1].lower()
+            if ext == 'txt':
+                result += process_text_file(file) + "\n\n---\n\n"
+            elif ext == 'csv':
+                result += process_csv_file(file) + "\n\n---\n\n"
+            elif ext == 'pdf':
+                result += process_pdf_file(file) + "\n\n---\n\n"
+            else:
+                result += f"### Unsupported File: {file.name}\n\n---\n\n"
+        except Exception as e:
+            logging.error(f"File processing error {file.name}: {e}")
+            result += f"### File processing error: {file.name}\n\nError: {e}\n\n---\n\n"
+
+    return result
+
+# ──────────────────────────────── Image & Utility ─────────────────────────
 def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
-    if not prompt: return None, "프롬프트 부족"
+    """Image generation function."""
+    if not prompt:
+        return None, "Insufficient prompt"
     try:
         res = Client(IMAGE_API_URL).predict(
             prompt=prompt, width=w, height=h, guidance=g,
             inference_steps=steps, seed=seed,
             do_img2img=False, init_image=None,
             image2image_strength=0.8, resize_img=True,
-            api_name="/generate_image")
+            api_name="/generate_image"
+        )
         return res[0], f"Seed: {res[1]}"
     except Exception as e:
-        logging.error(e); return None, str(e)
+        logging.error(e)
+        return None, str(e)
 
-def extract_image_prompt(blog: str, topic: str):
-    sys = f"다음 글로부터 영어 1줄 이미지 프롬프트 생성:\n{topic}"
+def extract_image_prompt(blog_text: str, topic: str):
+    """
+    Analyze the blog content (blog_text) to generate a one-line English image prompt
+    related to the topic.
+    """
+    client = get_anthropic_client()
+    sys = f"Generate a single-line English image prompt from the following text:\nTopic: {topic}"
     try:
+        # Simple one-time call
         res = client.messages.create(
             model="claude-3-7-sonnet-20250219",
-            max_tokens=80, system=sys,
-            messages=[{"role": "user", "content": blog}]
+            max_tokens=80,
+            system=sys,
+            messages=[{"role": "user", "content": blog_text}]
         )
         return res.content[0].text.strip()
     except Exception:
+        # Fallback prompt
         return f"A professional photo related to {topic}, high quality"
 
 def md_to_html(md: str, title="Ginigen Blog"):
+    """Convert Markdown to HTML."""
     return f"<!DOCTYPE html><html><head><title>{title}</title><meta charset='utf-8'></head><body>{markdown.markdown(md)}</body></html>"
 
 def keywords(text: str, top=5):
-    return " ".join(re.sub(r"[^가-힣a-zA-Z0-9\\s]", "", text).split()[:top])
+    """Simple keyword extraction."""
+    cleaned = re.sub(r"[^가-힣a-zA-Z0-9\s]", "", text)
+    return " ".join(cleaned.split()[:top])
 
 # ──────────────────────────────── Streamlit UI ────────────────────────────
 def ginigen_app():
-    st.title("지니젠 블로그")
+    st.title("Ginigen Blog")
 
-    # 세션 기본값 - 세션 상태가 이미 있는 경우 설정하지 않음
+    # Set default session state
     if "ai_model" not in st.session_state:
         st.session_state.ai_model = "claude-3-7-sonnet-20250219"
     if "messages" not in st.session_state:
@@ -297,143 +549,229 @@ def ginigen_app():
         st.session_state.auto_save = True
     if "generate_image" not in st.session_state:
         st.session_state.generate_image = False
-    if "use_web_search" not in st.session_state:
-        st.session_state.use_web_search = False
+    if "web_search_enabled" not in st.session_state:
+        st.session_state.web_search_enabled = True
     if "blog_template" not in st.session_state:
-        st.session_state.blog_template = "standard"
+        st.session_state.blog_template = "ginigen"  # Ginigen recommended style by default
     if "blog_tone" not in st.session_state:
         st.session_state.blog_tone = "professional"
     if "word_count" not in st.session_state:
         st.session_state.word_count = 1750
 
-    # ── 사이드바 컨트롤
+    # Sidebar UI
     sb = st.sidebar
-    sb.title("블로그 설정")
-    
-    # 블로그 템플릿 및 스타일 선택
-    sb.subheader("블로그 스타일 설정")
-    sb.selectbox("블로그 템플릿", options=list(BLOG_TEMPLATES.keys()), 
-                format_func=lambda x: BLOG_TEMPLATES[x],
-                key="blog_template")
+    sb.title("Blog Settings")
     
-    sb.selectbox("블로그 톤", options=list(BLOG_TONES.keys()),
-                format_func=lambda x: BLOG_TONES[x],
-                key="blog_tone")
+    sb.subheader("Blog Style Settings")
+    sb.selectbox(
+        "Blog Template", 
+        options=list(BLOG_TEMPLATES.keys()), 
+        format_func=lambda x: BLOG_TEMPLATES[x],
+        key="blog_template"
+    )
     
-    sb.slider("블로그 길이 (단어 수)", 800, 3000, key="word_count")
+    sb.selectbox(
+        "Blog Tone",
+        options=list(BLOG_TONES.keys()),
+        format_func=lambda x: BLOG_TONES[x],
+        key="blog_tone"
+    )
     
-    # 예제 주제 선택
-    sb.subheader("예제 주제")
+    sb.slider("Blog Length (word count)", 800, 3000, key="word_count")
     
-    col1, col2, col3 = sb.columns(3)
-    
-    # 수정: 예제 선택 시 직접 처리하도록 변경
-    if col1.button("부동산 세금", key="ex1"):
-        # 예제 주제를 입력으로 즉시 처리 (rerun 없이)
+    # Example topics
+    sb.subheader("Example Topics")
+    c1, c2, c3 = sb.columns(3)
+    if c1.button("Real Estate Tax", key="ex1"):
         process_example(EXAMPLE_TOPICS["example1"])
-    
-    if col2.button("여름 축제", key="ex2"):
+    if c2.button("Summer Festivals", key="ex2"):
         process_example(EXAMPLE_TOPICS["example2"])
-    
-    if col3.button("투자 가이드", key="ex3"):
+    if c3.button("Investment Guide", key="ex3"):
         process_example(EXAMPLE_TOPICS["example3"])
     
-    sb.subheader("기타 설정")
-    sb.toggle("자동 저장", key="auto_save")
-    sb.toggle("이미지 자동 생성", key="generate_image")
+    sb.subheader("Other Settings")
+    sb.toggle("Auto Save", key="auto_save")
+    sb.toggle("Auto Image Generation", key="generate_image")
+    
+    web_search_enabled = sb.toggle("Use Web Search", value=st.session_state.web_search_enabled)
+    st.session_state.web_search_enabled = web_search_enabled
     
-    # 웹 검색 토글 (모니터링을 위해 유지하되 기본값은 False)
-    search_enabled = sb.toggle("웹 검색 사용", value=False, key="use_web_search")
-    if search_enabled:
-        st.warning("⚠️ 웹 검색 기능은 현재 불안정할 수 있습니다. 검색 결과가 없으면 기본 지식으로 대체됩니다.")
+    if web_search_enabled:
+        st.sidebar.info("✅ Web search results will be integrated into the blog.")
 
-    # ── 최근 블로그 다운로드 (마크다운 / HTML)
+    # Download the latest blog (markdown/HTML)
     latest_blog = next(
-        (m["content"] for m in reversed(st.session_state.messages)
-         if m["role"] == "assistant" and m["content"].strip()), None)
-
+        (m["content"] for m in reversed(st.session_state.messages) 
+         if m["role"] == "assistant" and m["content"].strip()), 
+        None
+    )
     if latest_blog:
-        title = re.search(r"# (.*?)(\n|$)", latest_blog)
-        title = title.group(1).strip() if title else "blog"
-        sb.subheader("최근 블로그 다운로드")
-        c1, c2 = sb.columns(2)
-        c1.download_button("마크다운", latest_blog,
+        title_match = re.search(r"# (.*?)(\n|$)", latest_blog)
+        title = title_match.group(1).strip() if title_match else "blog"
+        sb.subheader("Download Latest Blog")
+        d1, d2 = sb.columns(2)
+        d1.download_button("Download as Markdown", latest_blog, 
                            file_name=f"{title}.md", mime="text/markdown")
-        c2.download_button("HTML", md_to_html(latest_blog, title),
+        d2.download_button("Download as HTML", md_to_html(latest_blog, title),
                            file_name=f"{title}.html", mime="text/html")
 
-    # ── JSON 대화 기록 업로드
-    up = sb.file_uploader("대화 기록 불러오기 (.json)", type=["json"])
+    # JSON conversation record upload
+    up = sb.file_uploader("Load Conversation History (.json)", type=["json"], key="json_uploader")
     if up:
         try:
             st.session_state.messages = json.load(up)
-            sb.success("대화 기록 불러오기 완료")
+            sb.success("Conversation history loaded successfully")
         except Exception as e:
-            sb.error(f"불러오기 실패: {e}")
-
-    # ── JSON 대화 기록 다운로드
-    if sb.button("대화 기록 JSON 다운로드"):
-        sb.download_button("저장", json.dumps(st.session_state.messages,
-                                              ensure_ascii=False, indent=2),
-                           file_name="chat_history.json",
-                           mime="application/json")
+            sb.error(f"Failed to load: {e}")
+
+    # JSON conversation record download
+    if sb.button("Download Conversation as JSON"):
+        sb.download_button(
+            "Save",
+            data=json.dumps(st.session_state.messages, ensure_ascii=False, indent=2),
+            file_name="chat_history.json",
+            mime="application/json"
+        )
 
-    # ── 기존 메시지 렌더링
+    # File Upload
+    st.subheader("File Upload")
+    uploaded_files = st.file_uploader(
+        "Upload files to be referenced in your blog (txt, csv, pdf)",
+        type=["txt", "csv", "pdf"],
+        accept_multiple_files=True,
+        key="file_uploader"
+    )
+    
+    if uploaded_files:
+        file_count = len(uploaded_files)
+        st.success(f"{file_count} files uploaded. They will be referenced in the blog.")
+        
+        with st.expander("Preview Uploaded Files", expanded=False):
+            for idx, file in enumerate(uploaded_files):
+                st.write(f"**File Name:** {file.name}")
+                ext = file.name.split('.')[-1].lower()
+                
+                if ext == 'txt':
+                    preview = file.read(1000).decode('utf-8', errors='ignore')
+                    file.seek(0)
+                    st.text_area(
+                        f"Preview of {file.name}",
+                        preview + ("..." if len(preview) >= 1000 else ""),
+                        height=150
+                    )
+                elif ext == 'csv':
+                    try:
+                        df = pd.read_csv(file)
+                        file.seek(0)
+                        st.write("CSV Preview (up to 5 rows)")
+                        st.dataframe(df.head(5))
+                    except Exception as e:
+                        st.error(f"CSV preview failed: {e}")
+                elif ext == 'pdf':
+                    try:
+                        file_bytes = file.read()
+                        file.seek(0)
+                        
+                        pdf_file = io.BytesIO(file_bytes)
+                        reader = PyPDF2.PdfReader(pdf_file, strict=False)
+                        
+                        pc = len(reader.pages)
+                        st.write(f"PDF File: {pc} pages")
+                        
+                        if pc > 0:
+                            try:
+                                page_text = reader.pages[0].extract_text()
+                                preview = page_text[:500] if page_text else "(No text extracted)"
+                                st.text_area("Preview of the first page", preview + "...", height=150)
+                            except:
+                                st.warning("Failed to extract text from the first page")
+                    except Exception as e:
+                        st.error(f"PDF preview failed: {e}")
+
+                if idx < file_count - 1:
+                    st.divider()
+
+    # Display existing messages
     for m in st.session_state.messages:
         with st.chat_message(m["role"]):
             st.markdown(m["content"])
             if "image" in m:
                 st.image(m["image"], caption=m.get("image_caption", ""))
 
-    # ── 사용자 입력 처리
-    prompt = st.chat_input("무엇을 도와드릴까요?")
-    
+    # User input
+    prompt = st.chat_input("Enter a blog topic or keywords.")
     if prompt:
-        process_input(prompt)
-
+        process_input(prompt, uploaded_files)
 
 def process_example(topic):
-    """예제 주제를 직접 처리하는 함수 (rerun 없이)"""
-    process_input(topic)
-
-
-def process_input(prompt):
-    """사용자 입력 처리 함수 (일반 입력과 예제 입력 모두 처리)"""
-    st.session_state.messages.append({"role": "user", "content": prompt})
-    with st.chat_message("user"): st.markdown(prompt)
+    """Process the selected example topic."""
+    process_input(topic, [])
 
+def process_input(prompt: str, uploaded_files):
+    # Add user's message if it doesn't already exist
+    if not any(m["role"] == "user" and m["content"] == prompt for m in st.session_state.messages):
+        st.session_state.messages.append({"role": "user", "content": prompt})
+    
+    with st.chat_message("user"):
+        st.markdown(prompt)
+    
     with st.chat_message("assistant"):
-        placeholder = st.empty(); answer = ""
-        
-        # 웹 검색 활성화 여부 확인
-        use_web_search = st.session_state.use_web_search
+        placeholder = st.empty()
+        answer = ""
+
+        use_web_search = st.session_state.web_search_enabled
+        has_uploaded_files = bool(uploaded_files) and len(uploaded_files) > 0
         
         try:
-            # 선택된 템플릿, 톤, 단어 수로 시스템 프롬프트 생성
-            # 웹 검색 활성화 시 이를 시스템 프롬프트에 반영
+            client = get_anthropic_client()
+            
+            # Prepare conversation messages
+            messages = [{"role": m["role"], "content": m["content"]} for m in st.session_state.messages]
+            
+            # Web search
+            if use_web_search:
+                with st.spinner("Performing web search..."):
+                    sr = do_web_search(keywords(prompt, top=5))
+                    if sr:
+                        messages.append({"role": "user", "content": sr})
+            
+            # Process uploaded files → content
+            file_content = None
+            if has_uploaded_files:
+                with st.spinner("Analyzing uploaded files..."):
+                    file_content = process_uploaded_files(uploaded_files)
+            
+            # Build system prompt
             sys_prompt = get_system_prompt(
                 template=st.session_state.blog_template,
                 tone=st.session_state.blog_tone,
                 word_count=st.session_state.word_count,
-                include_search_results=use_web_search
+                include_search_results=use_web_search,
+                include_uploaded_files=has_uploaded_files
             )
 
-            search_results = None
-            if use_web_search:
-                with st.spinner("웹 검색 중…"):
-                    search_results = do_web_search(keywords(prompt))
-                    
-            # 메시지 배열 준비
-            messages = [{"role": m["role"], "content": m["content"]} 
-                       for m in st.session_state.messages]
+            # If we have file content, append it to the system prompt
+            if file_content:
+                sys_prompt += (
+                    "\n\n"
+                    "Below is the content of the uploaded file(s). Please make sure to integrate it thoroughly in the blog:\n\n"
+                    f"{file_content}\n\n"
+                    "Ensure the file content is accurately reflected in the blog.\n"
+                )
             
-            # 웹 검색 결과가 있으면 별도 메시지로 추가 (시스템 프롬프트 대신)
-            if search_results:
-                messages.append({"role": "user", "content": search_results})
-
-            # Claude 스트리밍
+            # Append additional user message about file usage
+            if has_uploaded_files:
+                extra_user_msg = (
+                    f"{prompt}\n\n"
+                    "Additional note: Please make sure to reference the uploaded file content in the blog. "
+                    "Use and analyze any data, statistics, or text included in the file(s)."
+                )
+                messages.append({"role": "user", "content": extra_user_msg})
+            
+            # Claude streaming
             with client.messages.stream(
-                model=st.session_state.ai_model, max_tokens=MAX_TOKENS,
+                model=st.session_state.ai_model,
+                max_tokens=MAX_TOKENS,
                 system=sys_prompt,
                 messages=messages
             ) as stream:
@@ -441,70 +779,71 @@ def process_input(prompt):
                     answer += t or ""
                     placeholder.markdown(answer + "▌")
             placeholder.markdown(answer)
-
-            # 이미지 옵션
+            
+            # Image generation option
             answer_entry_saved = False
             if st.session_state.generate_image:
-                with st.spinner("이미지 생성 중…"):
+                with st.spinner("Generating image..."):
                     ip = extract_image_prompt(answer, prompt)
                     img, cap = generate_image(ip)
                     if img:
                         st.image(img, caption=cap)
-                        st.session_state.messages.append(
-                            {"role": "assistant", "content": answer,
-                             "image": img, "image_caption": cap})
+                        st.session_state.messages.append({
+                            "role": "assistant",
+                            "content": answer,
+                            "image": img,
+                            "image_caption": cap
+                        })
                         answer_entry_saved = True
+            
+            # Save the answer
             if not answer_entry_saved:
-                st.session_state.messages.append(
-                    {"role": "assistant", "content": answer})
-
-            # 본문 다운로드 버튼 (MD / HTML)
-            st.subheader("이 블로그 다운로드")
-            b1, b2 = st.columns(2)
-            b1.download_button("마크다운", answer,
-                              file_name=f"{prompt[:30]}.md", mime="text/markdown")
-            b2.download_button("HTML", md_to_html(answer, prompt[:30]),
-                              file_name=f"{prompt[:30]}.html", mime="text/html")
-
-            # ── 자동 백업 저장
+                st.session_state.messages.append({"role": "assistant", "content": answer})
+
+            # Download buttons
+            st.subheader("Download This Blog")
+            c1, c2 = st.columns(2)
+            c1.download_button(
+                "Markdown", 
+                data=answer, 
+                file_name=f"{prompt[:30]}.md",
+                mime="text/markdown"
+            )
+            c2.download_button(
+                "HTML",
+                data=md_to_html(answer, prompt[:30]),
+                file_name=f"{prompt[:30]}.html",
+                mime="text/html"
+            )
+
+            # Auto save
             if st.session_state.auto_save and st.session_state.messages:
                 try:
                     fn = f"chat_history_auto_{datetime.now():%Y%m%d_%H%M%S}.json"
                     with open(fn, "w", encoding="utf-8") as fp:
-                        json.dump(st.session_state.messages, fp,
-                                ensure_ascii=False, indent=2)
+                        json.dump(st.session_state.messages, fp, ensure_ascii=False, indent=2)
                 except Exception as e:
-                    logging.error(f"자동 저장 실패: {e}")
-                    
+                    logging.error(f"Auto-save failed: {e}")
+
         except anthropic.BadRequestError as e:
             error_message = str(e)
             if "credit balance is too low" in error_message:
-                placeholder.error("⚠️ API 크레딧 부족: Anthropic API 계정에 크레딧을 충전해주세요.")
-                answer = "API 크레딧이 부족하여 블로그를 생성할 수 없습니다. API 계정에 크레딧을 충전한 후 다시 시도해주세요."
+                placeholder.error("⚠️ Insufficient API credits: Please top up your Anthropic API account.")
+                ans = "Unable to generate blog due to low API credits. Please recharge and try again."
             else:
-                placeholder.error(f"API 요청 오류: {error_message}")
-                answer = f"API 요청 중 오류가 발생했습니다: {error_message}"
-            
-            st.session_state.messages.append({"role": "assistant", "content": answer})
+                placeholder.error(f"API request error: {error_message}")
+                ans = f"An error occurred while calling the API: {error_message}"
+            st.session_state.messages.append({"role": "assistant", "content": ans})
             
         except Exception as e:
             error_message = str(e)
-            placeholder.error(f"오류 발생: {error_message}")
-            answer = f"요청 처리 중 오류가 발생했습니다: {error_message}"
-            st.session_state.messages.append({"role": "assistant", "content": answer})
+            placeholder.error(f"An error occurred: {error_message}")
+            ans = f"An error occurred while processing your request: {error_message}"
+            st.session_state.messages.append({"role": "assistant", "content": ans})
 
-# ──────────────────────────────── main / requirements ──────────────────────
-def main(): ginigen_app()
+# ──────────────────────────────── main ────────────────────────────────────
+def main():
+    ginigen_app()
 
 if __name__ == "__main__":
-    # requirements.txt 동적 생성
-    with open("requirements.txt", "w") as f:
-        f.write("\n".join([
-            "streamlit>=1.31.0",
-            "anthropic>=0.18.1",
-            "gradio-client>=1.8.0",
-            "requests>=2.32.3",
-            "markdown>=3.5.1",
-            "pillow>=10.1.0"
-        ]))
-    main()
+    main()