Update app-BACKUP2.py

app-BACKUP2.py

@@ -1,452 +1,432 @@
-import os
+# ──────────────────────────────── Imports ────────────────────────────────
+import os, json, re, logging, requests, markdown, time
+from datetime import datetime
+
 import streamlit as st
-import json
 import anthropic
-import requests
-import logging
 from gradio_client import Client
-import markdown
-import tempfile
-import base64
-from weasyprint import HTML
+# from bs4 import BeautifulSoup   # 필요 시 주석 해제
 
-# 로깅 설정
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s')
+# ──────────────────────────────── 환경 변수 / 상수 ───────────────────────────
+ANTHROPIC_KEY  = os.getenv("API_KEY", "")
+BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")  # 이름 유지
+BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
+IMAGE_API_URL  = "http://211.233.58.201:7896"
+MAX_TOKENS     = 7_999
 
-# API 설정
-api_key = os.environ.get("API_KEY")
-client = anthropic.Anthropic(api_key=api_key)
+# 블로그 템플릿 및 스타일 정의
+BLOG_TEMPLATES = {
+    "standard": "전문 블로그 작성 전문가로서 8단계 프레임워크를 따라 자연스럽고 매력적인 글 작성",
+    "tutorial": "단계별 튜토리얼 형식으로, 명확한 과정과 결과를 보여주는 가이드 작성",
+    "review": "제품/서비스 분석 중심의 리뷰 형식, 장단점 분석과 추천 포함",
+    "storytelling": "개인 경험이나 사례를 중심으로 한 스토리텔링 형식의 블로그 작성",
+    "seo_optimized": "검색엔진 최적화(SEO)를 고려한 키워드 중심 블로그 작성"
+}
 
-# 이미지 생성 API URL
-IMAGE_API_URL = "http://211.233.58.201:7896"
+BLOG_TONES = {
+    "professional": "전문적이고 공식적인 어조로 작성",
+    "casual": "친근하고 대화체 중심의 편안한 톤으로 작성",
+    "humorous": "유머와 재치를 가미한 가벼운 어조로 작성",
+    "storytelling": "이야기를 들려주듯 감성적이고 몰입감 있는 톤으로 작성"
+}
 
-# 최대 토큰 수 설정 (Claude-3 Sonnet의 최대 토큰 수)
-MAX_TOKENS = 7999
+# ──────────────────────────────── 로깅 ──────────────────────────────────────
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s - %(levelname)s - %(message)s")
 
-def get_system_prompt():
-    return """
-당신은 전문 블로그 작성 전문가입니다. 모든 블로그 글 작성 요청에 대해 다음의 8단계 프레임워크를 철저히 따르되, 자연스럽고 매력적인 글이 되도록 작성해야 합니다:
+# ──────────────────────────────── Anthropic Client ─────────────────────────
+client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
 
-독자 연결 단계 1.1. 공감대 형성을 위한 친근한 인사 1.2. 독자의 실제 고민을 반영한 도입 질문 1.3. 주제에 대한 즉각적 관심 유도
+# ──────────────────────────────── 블로그 작성 시스템 프롬프트 ────────────────
+def get_system_prompt(template="standard", tone="professional", word_count=1750) -> str:
+    base_prompt = """
+당신은 전문 블로그 작성 전문가입니다. 모든 블로그 글 작성 요청에 대해 다음의 8단계 프레임워크를 철저히 따르되, 자연스럽고 매력적인 글이 되도록 작성해야 합니다:
 
-문제 정의 단계 2.1. 독자의 페인포인트 구체화 2.2. 문제의 시급성과 영향도 분석 2.3. 해결 필요성에 대한 공감대 형성
+독자 연결 단계
+1.1. 공감대 형성을 위한 친근한 인사
+1.2. 독자의 실제 고민을 반영한 도입 질문
+1.3. 주제에 대한 즉각적 관심 유도
 
-전문성 입증 단계 3.1. 객관적 데이터 기반 분석 3.2. 전문가 견해와 연구 결과 인용 3.3. 실제 사례를 통한 문제 구체화
+문제 정의 단계
+2.1. 독자의 페인포인트 구체화
+2.2. 문제의 시급성과 영향도 분석
+2.3. 해결 필요성에 대한 공감대 형성
 
-솔루션 제공 단계 4.1. 단계별 실천 가이드라인 제시 4.2. 즉시 적용 가능한 구체적 팁 4.3. 예상 장애물과 극복 방안 포함
+전문성 입증 단계
+3.1. 객관적 데이터 기반 분석
+3.2. 전문가 견해와 연구 결과 인용
+3.3. 실제 사례를 통한 문제 구체화
 
-신뢰도 강화 단계 5.1. 실제 성공 사례 제시 5.2. 구체적 사용자 후기 인용 5.3. 객관적 데이터로 효과 입증
+솔루션 제공 단계
+4.1. 단계별 ���천 가이드라인 제시
+4.2. 즉시 적용 가능한 구체적 팁
+4.3. 예상 장애물과 극복 방안 포함
 
-행동 유도 단계 6.1. 명확한 첫 실천 단계 제시 6.2. 시급성을 강조한 행동 촉구 6.3. 실천 동기 부여 요소 포함
+신뢰도 강화 단계
+5.1. 실제 성공 사례 제시
+5.2. 구체적 사용자 후기 인용
+5.3. 객관적 데이터로 효과 입증
 
-진정성 강화 단계 7.1. 솔루션의 한계 투명하게 공개 7.2. 개인별 차이 존재 인정 7.3. 필요 조건과 주의사항 명시
+행동 유도 단계
+6.1. 명확한 첫 실천 단계 제시
+6.2. 시급성을 강조한 행동 촉구
+6.3. 실천 동기 부여 요소 포함
 
-관계 지속 단계 8.1. 진정성 있는 감사 인사 8.2. 다음 컨텐츠 예고로 기대감 조성 8.3. 소통 채널 안내
+진정성 강화 단계
+7.1. 솔루션의 한계 투명하게 공개
+7.2. 개인별 차이 존재 인정
+7.3. 필요 조건과 주의사항 명시
 
-작성 시 준수사항 9.1. 글자 수: 1500-2000자 내외 9.2. 문단 길이: 3-4문장 이내 9.3. 시각적 구분: 소제목, 구분선, 번호 목록 활용 9.4. 톤앤매너: 친근하고 전문적인 대화체 9.5. 데이터: 모든 정보의 출처 명시 9.6. 가독성: 명확한 단락 구분과 강조점 사용
+관계 지속 단계
+8.1. 진정성 있는 감사 인사
+8.2. 다음 컨텐츠 예고로 기대감 조성
+8.3. 소통 채널 안내
+"""
 
-이러한 프레임워크를 바탕으로, 요청받은 주제에 대해 체계적이고 매력적인 블로그 포스트를 작성하겠습니다.
+    # 템플릿별 추가 지침
+    template_guides = {
+        "tutorial": """
+이 블로그는 튜토리얼 형식으로 작성해 주세요:
+- 명확한 목표와 최종 결과물 먼저 제시
+- 단계별로 명확하게 구분된 과정 설명
+- 각 단계마다 이미지를 삽입할 위치 표시
+- 예상 소요 시간과 난이도 명시
+- 필요한 도구나 사전 지식 안내
+- 문제해결 팁과 자주 발생하는 실수 포함
+- 완료 후 다음 단계나 응용법 제안
+""",
+        
+        "review": """
+이 블로그는 리뷰 형식으로 작성해 주세요:
+- 객관적 사실과 주관적 평가 구분
+- 명확한 평가 기준 제시
+- 장점과 단점 균형있게 서술
+- 유사 제품/서비스와 비교
+- 누구에게 적합한지 타겟 설명
+- 구체적인 사용 경험과 결과 포함
+- 최종 추천 여부와 대안 제시
+""",
+        
+        "storytelling": """
+이 블로그는 스토리텔링 형식으로 작성해 주세요:
+- 실제 인물이나 사례로 시작
+- 문제 상황과 감정적 연결 강화
+- 갈등과 해결과정 중심의 내러티브
+- 교훈과 배움을 자연스럽게 포함
+- 독자가 공감할 수 있는 감정선 유지
+- 이야기와 유용한 정보의 균형 유지
+- 독자에게 자신의 이야기를 생각해보게 유도
+""",
+        
+        "seo_optimized": """
+이 블로그는 SEO 최적화 형식으로 작성해 주세요:
+- 핵심 키워드를 제목, 소제목, 첫 단락에 배치
+- 관련 키워드를 자연스럽게 본문에 분산
+- 300-500자 분량의 명확한 단락 구성
+- 질문 형식의 소제목 활용
+- 목록, 표, 강조 텍스트 등 다양한 서식 활용
+- 내부 링크 삽입 위치 표시
+- 2000-3000자 이상의 충분한 콘텐츠 제공
 """
+    }
+    
+    # 톤별 추가 지침
+    tone_guides = {
+        "professional": "전문적이고 권위있는 어조로 작성하되, 전문 용어는 적절히 설명해 주세요. 데이터와 연구 결과를 중심으로 논리적 흐름을 유지하세요.",
+        "casual": "친근하고 대화하듯 편안한 어조로 작성해 주세요. '~네요', '~해요' 같은 대화체를 사용하고, 개인적 경험과 비유를 통해 내용을 전달하세요.",
+        "humorous": "유머와 재치있는 표현을 적절히 활용해 주세요. 재미있는 비유나 예시, 가벼운 농담을 포함하되, 정보의 정확성과 유용성은 유지하세요.",
+        "storytelling": "이야기를 들려주듯 감성적이고 몰입감 있는 톤으로 작성해 주세요. 인물, 배경, 갈등, 해결과정이 담긴 내러티브 구조를 활용하세요."
+    }
+    
+    # 최종 프롬프트 조합
+    final_prompt = base_prompt
+    
+    # 선택된 템플릿 지침 추가
+    if template in template_guides:
+        final_prompt += "\n" + template_guides[template]
+    
+    # 선택된 톤 지침 추가
+    if tone in tone_guides:
+        final_prompt += f"\n\n톤앤매너: {tone_guides[tone]}"
+    
+    # 글자 수 지침 추가
+    final_prompt += f"\n\n작성 시 준수사항\n9.1. 글자 수: {word_count-250}-{word_count+250}자 내외\n9.2. 문단 길이: 3-4문장 이내\n9.3. 시각적 구분: 소제목, 구분선, 번호 목록 활용\n9.4. 데이터: 모든 정보의 출처 명시\n9.5. 가독성: 명확한 단락 구분과 강조점 사용"
+    
+    return final_prompt
 
-def test_image_api_connection():
-    """이미지 API 서버 연결 테스트"""
-    try:
-        client = Client(IMAGE_API_URL)
-        return "이미지 API 연결 성공: 정상 작동 중"
-    except Exception as e:
-        logging.error(f"이미지 API 연결 테스트 실패: {e}")
-        return f"이미지 API 연결 실패: {e}"
+# ──────────────────────────────── Brave Search API ─────────────────────────
+def brave_search(query: str, count: int = 5):
+    """
+    Brave Web Search API 호출 → list[dict]
+    반환 필드: index, title, link, snippet, displayed_link
+    """
+    if not BRAVE_KEY:
+        raise RuntimeError("⚠️  SERPHOUSE_API_KEY (Brave API Key) 환경변수가 비어 있습니다.")
 
-def generate_image(prompt, width=768, height=768, guidance=3.5, inference_steps=30, seed=3):
-    """이미지 생성 함수"""
-    if not prompt:
-        return None, "오류: 프롬프트를 입력해주세요"
+    headers = {
+        "Accept": "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": BRAVE_KEY
+    }
+    params = {"q": query, "count": str(count)}
     
+    for attempt in range(3):  # 최대 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())}")
+            
+            raw = data.get("web", {}).get("results") or data.get("results", [])
+            if not raw:
+                logging.warning(f"Brave 검색 결과 없음. 응답: {data}")
+                raise ValueError("검색 결과가 없습니다")
+                
+            arts = []
+            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", "제목 없음"),
+                    "link": url,
+                    "snippet": res.get("description", res.get("text", "내용 없음")),
+                    "displayed_link": host
+                })
+            
+            logging.info(f"Brave 검색 성공: {len(arts)}개 결과")
+            return arts
+            
+        except Exception as e:
+            logging.error(f"Brave 검색 실패 (시도 {attempt+1}/3): {e}")
+            if attempt < 2:  # 마지막 시도가 아니면 대기 후 재시도
+                time.sleep(2)
+            
+    return []  # 모든 시도 실패 시 빈 목록 반환
+
+def mock_results(query: str) -> str:
+    """검색 API 실패 시 가상 검색 결과 제공"""
+    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")
+
+def do_web_search(query: str) -> str:
+    """웹 검색 수행 및 결과 포맷팅"""
     try:
-        client = Client(IMAGE_API_URL)
-        result = client.predict(
-            prompt=prompt,
-            width=int(width),
-            height=int(height),
-            guidance=float(guidance),
-            inference_steps=int(inference_steps),
-            seed=int(seed),
-            do_img2img=False,
-            init_image=None,
-            image2image_strength=0.8,
-            resize_img=True,
-            api_name="/generate_image"
+        arts = brave_search(query, 5)
+        if not arts:
+            logging.warning("검색 결과 없음, 대체 콘텐츠 사용")
+            return mock_results(query)
+        
+        hdr = "# 웹 검색 결과\n아래 정보를 참고해서 답변하세요.\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"
+            for a in arts
         )
-        logging.info(f"이미지 생성 성공: {result[1]}")
-        return result[0], f"사용된 시드: {result[1]}"
+        return hdr + body
     except Exception as e:
-        logging.error(f"이미지 생성 실패: {str(e)}")
-        return None, f"오류: {str(e)}"
-
-def extract_image_prompt(blog_content, blog_topic):
-    """블로그 내용에서 이미지 생성을 위한 프롬프트 추출"""
-    image_prompt_system = f"""
-    다음은 '{blog_topic}'에 관한 블로그 글입니다. 이 블로그 글의 내용을 기반으로 적절한 이미지를 생성하기 위한 
-    프롬프트를 작성해주세요. 프롬프트는 영어로 작성하고, 구체적인 시각적 요소를 담아야 합니다.
-    프롬프트만 반환하세요(다른 설명 없이).
-    
-    예시 형식:
-    "A professional photo of [subject], [specific details], [atmosphere], [lighting], [perspective], high quality, detailed"
-    """
-    
+        logging.error(f"웹 검색 전체 프로세스 실패: {str(e)}")
+        return mock_results(query)
+
+# ──────────────────────────────── 이미지 · 변환 유틸 ────────────────────────
+def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
+    if not prompt: return None, "프롬프트 부족"
     try:
-        response = client.messages.create(
+        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")
+        return res[0], f"Seed: {res[1]}"
+    except Exception as e:
+        logging.error(e); return None, str(e)
+
+def extract_image_prompt(blog: str, topic: str):
+    sys = f"다음 글로부터 영어 1줄 이미지 프롬프트 생성:\n{topic}"
+    try:
+        res = client.messages.create(
             model="claude-3-7-sonnet-20250219",
-            max_tokens=150,
-            system=image_prompt_system,
-            messages=[{"role": "user", "content": blog_content}]
+            max_tokens=80, system=sys,
+            messages=[{"role": "user", "content": blog}]
         )
-        
-        # 응답에서 프롬프트 추출
-        image_prompt = response.content[0].text.strip()
-        logging.info(f"생성된 이미지 프롬프트: {image_prompt}")
-        return image_prompt
-    except Exception as e:
-        logging.error(f"이미지 프롬프트 생성 오류: {e}")
-        return f"A professional photo related to {blog_topic}, detailed, high quality"
-
-# 마크다운을 HTML로 변환하는 함수
-def convert_md_to_html(md_text, title="Ginigen Blog"):
-    html_content = markdown.markdown(md_text)
-    html_doc = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <title>{title}</title>
-        <meta charset="utf-8">
-        <style>
-            body {{ font-family: Arial, sans-serif; line-height: 1.6; max-width: 800px; margin: 0 auto; padding: 20px; }}
-            h1 {{ color: #2c3e50; font-size: 2.5em; margin-bottom: 20px; }}
-            h2 {{ color: #3498db; margin-top: 25px; font-size: 1.8em; }}
-            h3 {{ color: #2980b9; font-size: 1.5em; }}
-            p {{ margin-bottom: 15px; font-size: 1.1em; }}
-            blockquote {{ background: #f9f9f9; border-left: 10px solid #ccc; margin: 1.5em 10px; padding: 1em 10px; }}
-            ul, ol {{ margin-bottom: 15px; }}
-            li {{ margin-bottom: 5px; }}
-            hr {{ border: 0; height: 1px; background: #ddd; margin: 20px 0; }}
-            img {{ max-width: 100%; height: auto; display: block; margin: 20px auto; }}
-        </style>
-    </head>
-    <body>
-        {html_content}
-    </body>
-    </html>
-    """
-    return html_doc
+        return res.content[0].text.strip()
+    except Exception:
+        return f"A professional photo related to {topic}, high quality"
 
-# 마크다운을 PDF로 변환하는 함수
-def convert_md_to_pdf(md_text, title="Ginigen Blog"):
-    html_content = convert_md_to_html(md_text, title)
-    
-    # 임시 파일 생성
-    with tempfile.NamedTemporaryFile(suffix='.pdf', delete=False) as tmp:
-        tmp_path = tmp.name
-    
-    # HTML을 PDF로 변환
-    HTML(string=html_content).write_pdf(tmp_path)
-    
-    # 생성된 PDF 읽기
-    with open(tmp_path, 'rb') as f:
-        pdf_data = f.read()
-    
-    # 임시 파일 삭제
-    os.unlink(tmp_path)
-    
-    return pdf_data
+def md_to_html(md: str, title="Ginigen Blog"):
+    return f"<!DOCTYPE html><html><head><title>{title}</title><meta charset='utf-8'></head><body>{markdown.markdown(md)}</body></html>"
 
-# 다운로드 버튼 생성 헬퍼 함수
-def create_download_link(bin_data, download_filename, link_text):
-    b64 = base64.b64encode(bin_data).decode()
-    href = f'<a href="data:application/octet-stream;base64,{b64}" download="{download_filename}">{link_text}</a>'
-    return href
+def keywords(text: str, top=5):
+    return " ".join(re.sub(r"[^가-힣a-zA-Z0-9\\s]", "", text).split()[:top])
 
-def chatbot_interface():
+# ──────────────────────────────── Streamlit UI ────────────────────────────
+def ginigen_app():
     st.title("Ginigen Blog")
-    
-    # 모델 고정 ��정
-    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:
-        st.session_state.messages = []
-    
-    # 자동 저장 기능
-    if "auto_save" not in st.session_state:
-        st.session_state.auto_save = True
-    
-    # 이미지 생성 토글
-    if "generate_image" not in st.session_state:
-        st.session_state.generate_image = False
-    
-    # 이미지 API 상태
-    if "image_api_status" not in st.session_state:
-        st.session_state.image_api_status = test_image_api_connection()
 
-    # 대화 기록 관리 (사이드바)
-    st.sidebar.title("대화 기록 관리")
-    
-    # 자동 저장 토글
-    st.session_state.auto_save = st.sidebar.toggle("자동 저장", value=st.session_state.auto_save)
-    
-    # 이미지 생성 토글
-    st.session_state.generate_image = st.sidebar.toggle("블로그 글 작성 후 이미지 자동 생성", value=st.session_state.generate_image)
-    
-    # 이미지 API 상태 표시
-    st.sidebar.text(st.session_state.image_api_status)
+    # 세션 기본값
+    defaults = dict(
+        ai_model="claude-3-7-sonnet-20250219",
+        messages=[],
+        auto_save=True,
+        generate_image=False,
+        use_web_search=False,
+        blog_template="standard",
+        blog_tone="professional",
+        word_count=1750
+    )
+    for k, v in defaults.items():
+        st.session_state.setdefault(k, v)
+
+    # ── 사이드바 컨트롤
+    sb = st.sidebar
+    sb.title("블로그 설정")
     
-    # 이미지 생성 설정 (토글이 켜져 있을 때만 표시)
-    if st.session_state.generate_image:
-        st.sidebar.subheader("이미지 생성 설정")
-        width = st.sidebar.slider("너비", 256, 1024, 768, 64)
-        height = st.sidebar.slider("높이", 256, 1024, 768, 64)
-        guidance = st.sidebar.slider("가이던스 스케일", 1.0, 20.0, 3.5, 0.1)
-        inference_steps = st.sidebar.slider("인퍼런스 스텝", 1, 50, 30, 1)
-        seed = st.sidebar.number_input("시드", value=3, min_value=0, step=1)
-    else:
-        # 기본값 설정
-        width, height, guidance, inference_steps, seed = 768, 768, 3.5, 30, 3
+    # 블로그 템플릿 및 스타일 선택
+    sb.subheader("블로그 스타일 설정")
+    sb.selectbox("블로그 템플릿", options=list(BLOG_TEMPLATES.keys()), 
+                format_func=lambda x: x.replace("_", " ").title(),
+                key="blog_template")
     
-    # 블로그 내용 다운로드 섹션
-    st.sidebar.title("블로그 다운로드")
+    sb.selectbox("블로그 톤", options=list(BLOG_TONES.keys()),
+                format_func=lambda x: x.replace("_", " ").title(),
+                key="blog_tone")
     
-    # 최신 블로그 내용 가져오기
-    latest_blog = None
-    latest_blog_title = "블로그 글"
+    sb.slider("블로그 길이 (단어 수)", 800, 3000, 1750, key="word_count")
     
-    if len(st.session_state.messages) > 0:
-        # 가장 최근 assistant 메시지 찾기
-        for msg in reversed(st.session_state.messages):
-            if msg["role"] == "assistant" and msg["content"].strip():
-                latest_blog = msg["content"]
-                
-                # 타이틀 추출 시도 (첫 번째 제목 태그 사용)
-                import re
-                title_match = re.search(r'# (.*?)(\n|$)', latest_blog)
-                if title_match:
-                    latest_blog_title = title_match.group(1).strip()
-                # 사용자 입력을 타이틀로 사용
-                elif len(st.session_state.messages) >= 2:
-                    for i in range(len(st.session_state.messages)-1, -1, -1):
-                        if st.session_state.messages[i]["role"] == "user":
-                            latest_blog_title = st.session_state.messages[i]["content"][:30].strip()
-                            if len(st.session_state.messages[i]["content"]) > 30:
-                                latest_blog_title += "..."
-                            break
-                break
+    sb.subheader("기타 설정")
+    sb.toggle("자동 저장",   key="auto_save")
+    sb.toggle("이미지 자동 생성", key="generate_image")
     
-    # 다운로드 버튼 그룹
+    # 웹 검색 토글 (모니터링을 위해 유지하되 기본값은 False)
+    search_enabled = sb.toggle("웹 검색 사용", value=False, key="use_web_search")
+    if search_enabled:
+        st.warning("⚠️ 웹 검색 기능은 현재 불안정할 수 있습니다. 검색 결과가 없으면 기본 지식으로 대체됩니다.")
+
+    # ── 최근 블로그 다운로드 (마크다운 / HTML)
+    latest_blog = next(
+        (m["content"] for m in reversed(st.session_state.messages)
+         if m["role"] == "assistant" and m["content"].strip()), None)
+
     if latest_blog:
-        st.sidebar.subheader("최근 블로그 다운로드")
-        
-        col1, col2, col3 = st.sidebar.columns(3)
-        
-        # 마크다운으로 다운로드
-        with col1:
-            st.download_button(
-                label="마크다운",
-                data=latest_blog,
-                file_name=f"{latest_blog_title}.md",
-                mime="text/markdown"
-            )
-        
-        # HTML로 다운로드
-        with col2:
-            html_content = convert_md_to_html(latest_blog, latest_blog_title)
-            st.download_button(
-                label="HTML",
-                data=html_content,
-                file_name=f"{latest_blog_title}.html",
-                mime="text/html"
-            )
-        
-        # PDF로 다운로드
-        with col3:
-            try:
-                pdf_data = convert_md_to_pdf(latest_blog, latest_blog_title)
-                st.download_button(
-                    label="PDF",
-                    data=pdf_data,
-                    file_name=f"{latest_blog_title}.pdf",
-                    mime="application/pdf"
-                )
-            except Exception as e:
-                st.error(f"PDF 생성 오류: {e}")
-                logging.error(f"PDF 생성 오류: {e}")
-    
-    # 대화 기록 불러오기
-    uploaded_file = st.sidebar.file_uploader("대화 기록 불러오기", type=['json'])
-    if uploaded_file is not None:
+        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("Markdown", latest_blog,
+                           file_name=f"{title}.md", mime="text/markdown")
+        c2.download_button("HTML", md_to_html(latest_blog, title),
+                           file_name=f"{title}.html", mime="text/html")
+
+    # ── JSON 대화 기록 업로드
+    up = sb.file_uploader("대화 기록 불러오기 (.json)", type=["json"])
+    if up:
         try:
-            content = uploaded_file.getvalue().decode()
-            if content.strip():
-                st.session_state.messages = json.loads(content)
-                st.sidebar.success("대화 기록을 성공적으로 불러왔습니다!")
-            else:
-                st.sidebar.warning("업로드된 파일이 비어 있습니다.")
-        except json.JSONDecodeError:
-            st.sidebar.error("올바른 JSON 형식의 파일이 아닙니다.")
+            st.session_state.messages = json.load(up)
+            sb.success("대화 기록 불러오기 완료")
         except Exception as e:
-            st.sidebar.error(f"파일 처리 중 오류가 발생했습니다: {str(e)}")
-
-    # 대화 기록 초기화 버튼
-    if st.sidebar.button("대화 기록 초기화"):
-        st.session_state.messages = []
-        st.sidebar.success("대화 기록이 초기화되었습니다.")
-
-    # 메시지 표시
-    for message in st.session_state.messages:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-            # 이미지가 있는 경우 표시
-            if "image" in message:
-                st.image(message["image"], caption=message.get("image_caption", "생성된 이미지"))
-
-    # 사용자 입력
+            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")
+
+    # ── 기존 메시지 렌더링
+    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", ""))
+
+    # ── 사용자 입력
     if prompt := st.chat_input("무엇을 도와드릴까요?"):
         st.session_state.messages.append({"role": "user", "content": prompt})
-        with st.chat_message("user"):
-            st.markdown(prompt)
+        with st.chat_message("user"): st.markdown(prompt)
 
-        # AI 응답 생성
         with st.chat_message("assistant"):
-            message_placeholder = st.empty()
-            full_response = ""
+            placeholder = st.empty(); answer = ""
             
-            # API 호출
+            # 선택된 템플릿, 톤, 단어 수로 시스템 프롬프트 생성
+            sys_prompt = get_system_prompt(
+                template=st.session_state.blog_template,
+                tone=st.session_state.blog_tone,
+                word_count=st.session_state.word_count
+            )
+
+            if st.session_state.use_web_search:
+                with st.spinner("웹 검색 중…"):
+                    search_md = do_web_search(keywords(prompt))
+                    sys_prompt += f"\n\n검색 결과:\n{search_md}\n"
+
+            # Claude 스트리밍
             with client.messages.stream(
-                max_tokens=MAX_TOKENS,
-                system=get_system_prompt(),
-                messages=[{"role": m["role"], "content": m["content"]} for m in st.session_state.messages],
-                model=st.session_state["ai_model"]
+                model=st.session_state.ai_model, max_tokens=MAX_TOKENS,
+                system=sys_prompt,
+                messages=[{"role": m["role"], "content": m["content"]}
+                          for m in st.session_state.messages]
             ) as stream:
-                for text in stream.text_stream:
-                    full_response += str(text) if text is not None else ""
-                    message_placeholder.markdown(full_response + "▌")
-                    
-            message_placeholder.markdown(full_response)
-            
-            # 이미지 생성 옵션이 켜져 있는 경우
+                for t in stream.text_stream:
+                    answer += t or ""
+                    placeholder.markdown(answer + "▌")
+            placeholder.markdown(answer)
+
+            # 이미지 옵션
             if st.session_state.generate_image:
-                with st.spinner("블로그에 맞는 이미지 생성 중..."):
-                    # 이미지 프롬프트 생성
-                    image_prompt = extract_image_prompt(full_response, prompt)
-                    
-                    # 이미지 생성
-                    image, image_caption = generate_image(
-                        image_prompt, 
-                        width=width, 
-                        height=height, 
-                        guidance=guidance, 
-                        inference_steps=inference_steps, 
-                        seed=seed
-                    )
-                    
-                    if image:
-                        st.image(image, caption=image_caption)
-                        # 이미지 정보를 응답에 포함
-                        st.session_state.messages.append({
-                            "role": "assistant", 
-                            "content": full_response,
-                            "image": image,
-                            "image_caption": image_caption
-                        })
-                    else:
-                        st.error(f"이미지 생성 실패: {image_caption}")
-                        st.session_state.messages.append({
-                            "role": "assistant", 
-                            "content": full_response
-                        })
-            else:
-                # 이미지 생성 없이 응답만 저장
-                st.session_state.messages.append({
-                    "role": "assistant", 
-                    "content": full_response
-                })
-                
-            # 블로그 다운로드 버튼 표시 (응답 바로 아래에)
-            st.subheader("이 블로그 다운로드:")
-            col1, col2, col3 = st.columns(3)
-            
-            with col1:
-                st.download_button(
-                    label="마크다운으로 저장",
-                    data=full_response,
-                    file_name=f"{prompt[:30]}.md",
-                    mime="text/markdown"
-                )
-            
-            with col2:
-                html_content = convert_md_to_html(full_response, prompt[:30])
-                st.download_button(
-                    label="HTML로 저장",
-                    data=html_content,
-                    file_name=f"{prompt[:30]}.html",
-                    mime="text/html"
-                )
-            
-            with col3:
-                try:
-                    pdf_data = convert_md_to_pdf(full_response, prompt[:30])
-                    st.download_button(
-                        label="PDF로 저장",
-                        data=pdf_data,
-                        file_name=f"{prompt[:30]}.pdf",
-                        mime="application/pdf"
-                    )
-                except Exception as e:
-                    st.error(f"PDF 생성 오류: {e}")
-                    logging.error(f"PDF 생성 오류: {e}")
-
-        # 자동 저장 기능
-        if st.session_state.auto_save:
-            try:
-                # 이미지 정보는 저장하지 않음 (JSON에는 바이너리 데이터를 직접 저장할 수 없음)
-                save_messages = []
-                for msg in st.session_state.messages:
-                    save_msg = {"role": msg["role"], "content": msg["content"]}
-                    save_messages.append(save_msg)
-                
-                with open('chat_history_auto_save.json', 'w', encoding='utf-8') as f:
-                    json.dump(save_messages, f, ensure_ascii=False, indent=4)
-            except Exception as e:
-                st.sidebar.error(f"자동 저장 중 오류 발생: {str(e)}")
-
-    # 대화 기록 다운로드
-    if st.sidebar.button("대화 기록 다운로드"):
-        # 이미지 정보는 저장하지 않음
-        save_messages = []
-        for msg in st.session_state.messages:
-            save_msg = {"role": msg["role"], "content": msg["content"]}
-            save_messages.append(save_msg)
-        
-        json_history = json.dumps(save_messages, indent=4, ensure_ascii=False)
-        st.sidebar.download_button(
-            label="대화 기록 저장하기",
-            data=json_history,
-            file_name="chat_history.json",
-            mime="application/json"
-        )
+                with st.spinner("이미지 생성 중…"):
+                    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})
+                        answer_entry_saved = True
+            if not st.session_state.generate_image:
+                st.session_state.messages.append(
+                    {"role": "assistant", "content": answer})
 
-def main():
-    chatbot_interface()
+            # 본문 다운로드 버튼 (MD / HTML)
+            st.subheader("이 블로그 다운로드")
+            b1, b2 = st.columns(2)
+            b1.download_button("Markdown", 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")
+
+    # ── 자동 백업 저장
+    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)
+        except Exception as e:
+            logging.error(f"자동 저장 실패: {e}")
+
+# ──────────────────────────────── main / requirements ──────────────────────
+def main(): ginigen_app()
 
 if __name__ == "__main__":
-    # requirements.txt 파일 생성
+    # requirements.txt 동적 생성
     with open("requirements.txt", "w") as f:
-        f.write("streamlit>=1.31.0\n")
-        f.write("anthropic>=0.18.1\n")
-        f.write("gradio-client>=1.8.0\n")
-        f.write("requests>=2.32.3\n")
-        f.write("markdown>=3.5.1\n")
-        f.write("weasyprint>=60.2\n")
-        f.write("pillow>=10.1.0\n")
-    
+        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()