Update app.py

app.py

@@ -1,3 +1,12 @@
+"""
+Ginigen Blog / Streamlit App
+────────────────────────────────────────────────────────────────────
+- 2025-04-23  : Brave Search API 버전
+- SerpHouse 전면 제거, Brave Search API 적용
+- API Key     : 환경변수  SERPHOUSE_API_KEY  (이름만 그대로 사용)
+────────────────────────────────────────────────────────────────────
+"""
+
 import os
 import streamlit as st
 import json
@@ -6,32 +15,29 @@ import requests
 import logging
 from gradio_client import Client
 import markdown
-import tempfile
-import base64
-from datetime import datetime
 import re
-from bs4 import BeautifulSoup  # BeautifulSoup는 이제 사용하지 않지만, 필요 시 유지
-# (직접 구글 검색 로직은 삭제했으므로 사실상 BeautifulSoup는 필요 없습니다.)
+from datetime import datetime
+# BeautifulSoup는 더 이상 사용하지 않지만, 필요 시 유지
+# from bs4 import BeautifulSoup
 
-# 로깅 설정
+# ───────────────────────────── 1) 로깅 ─────────────────────────────────────────
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s')
-
-# API 설정
-api_key = os.environ.get("API_KEY")
-client = anthropic.Anthropic(api_key=api_key)
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
 
-# 이미지 생성 API URL
-IMAGE_API_URL = "http://211.233.58.201:7896"
+# ───────────────────────────── 2) 전역 상수 / API 키 ───────────────────────────
+ANTHROPIC_KEY  = os.getenv("API_KEY", "")
+BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")     # Brave Search API 키
+BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
+IMAGE_API_URL  = "http://211.233.58.201:7896"
+MAX_TOKENS     = 7_999
 
-# 최대 토큰 수 설정 (Claude-3 Sonnet의 최대 토큰 수)
-MAX_TOKENS = 7999
+# ───────────────────────────── 3) 클라이언트 ──────────────────────────────────
+client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
 
-# SerpHouse API Key 설정
-SERPHOUSE_API_KEY = os.environ.get("SERPHOUSE_API_KEY", "")
-
-def get_system_prompt():
+# ───────────────────────────── 4) 시스템 프롬프트 ─────────────────────────────
+def get_system_prompt() -> str:
     return """
 당신은 전문 블로그 작성 전문가입니다. 모든 블로그 글 작성 요청에 대해 다음의 8단계 프레임워크를 철저히 따르되, 자연스럽고 매력적인 글이 되도록 작성해야 합니다:
 
@@ -82,382 +88,167 @@ def get_system_prompt():
 9.4. 톤앤매너: 친근하고 전문적인 대화체
 9.5. 데이터: 모든 정보의 출처 명시
 9.6. 가독성: 명확한 단락 구분과 강조점 사용
-
-이러한 프레임워크를 바탕으로, 요청받은 주제에 대해 체계적이고 매력적인 블로그 포스트를 작성하겠습니다.
 """
 
+# ───────────────────────────── 5) Brave Search 함수 ───────────────────────────
+def brave_search(query: str, count: int = 5):
+    """
+    Brave Web Search API 호출 → list[dict] 반환
+    반환 항목: title, link, snippet, displayed_link, index
+    """
+    if not BRAVE_KEY:
+        raise RuntimeError("환경변수 SERPHOUSE_API_KEY(=Brave API key)가 설정되어 있지 않습니다.")
+
+    headers = {
+        "Accept": "application/json",
+        "Accept-Encoding": "gzip",
+        "X-Subscription-Token": BRAVE_KEY
+    }
+    params = {"q": query, "count": str(count)}
+    resp = requests.get(BRAVE_ENDPOINT, headers=headers, params=params, timeout=15)
+    resp.raise_for_status()
+    data = resp.json()
+
+    web_results = (
+        data.get("web", {}).get("results") or
+        data.get("results", [])
+    )
+
+    articles = []
+    for idx, r in enumerate(web_results[:count], 1):
+        url = r.get("url", r.get("link", ""))
+        host = re.sub(r"https?://(www\\.)?", "", url).split("/")[0]
+        articles.append({
+            "index": idx,
+            "title": r.get("title", "제목 없음"),
+            "link": url,
+            "snippet": r.get("description", r.get("text", "내용 없음")),
+            "displayed_link": host
+        })
+    return articles
+
+# ───────────────────────────── 6) 검색 → 마���다운 ─────────────────────────────
+def generate_mock_search_results(query: str) -> str:
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    mock = [{
+        "title": f"{query} 관련 가상 결과",
+        "link": "https://example.com",
+        "snippet": "API 호출 실패로 생성된 예시 결과입니다.",
+        "displayed_link": "example.com"
+    }]
+    body = "\n".join(
+        f"### Result {i+1}: {m['title']}\n\n{m['snippet']}\n\n"
+        f"**출처**: [{m['displayed_link']}]({m['link']})\n\n---\n"
+        for i, m in enumerate(mock)
+    )
+    return f"# 가상 검색 결과 (생성: {ts})\n\n{body}"
+
+def do_web_search(query: str) -> str:
+    """
+    Brave Search 전용 검색 함수.
+    실패하거나 쿼터 초과 시 mock 결과 반환.
+    """
+    try:
+        articles = brave_search(query, count=5)
+    except Exception as e:
+        logging.error(f"Brave 검색 실패: {e}")
+        return generate_mock_search_results(query)
+
+    if not articles:
+        return generate_mock_search_results(query)
+
+    md_lines = []
+    for a in articles:
+        md_lines.append(
+            f"### Result {a['index']}: {a['title']}\n\n"
+            f"{a['snippet']}\n\n"
+            f"**출처**: [{a['displayed_link']}]({a['link']})\n\n---\n"
+        )
+    header = (
+        "# 웹 검색 결과\n"
+        "아래 정보를 답변에 활용하세요: 출처 인용·링크 포함·다수 출처 종합\n\n"
+    )
+    return header + "".join(md_lines)
+
+# ───────────────────────────── 7) 이미지·MD 변환 등 유틸 ───────────────────────
 def test_image_api_connection():
-    """이미지 API 서버 연결 테스트"""
     try:
-        client = Client(IMAGE_API_URL)
-        return "이미지 API 연결 성공: 정상 작동 중"
+        Client(IMAGE_API_URL)
+        return "이미지 API 연결 성공"
     except Exception as e:
-        logging.error(f"이미지 API 연결 테스트 실패: {e}")
+        logging.error(e)
         return f"이미지 API 연결 실패: {e}"
 
-def generate_image(prompt, width=768, height=768, guidance=3.5, inference_steps=30, seed=3):
-    """이미지 생성 함수"""
+def generate_image(prompt, width=768, height=768, guidance=3.5,
+                   inference_steps=30, seed=3):
     if not prompt:
-        return None, "오류: 프롬프트를 입력해주세요"
-    
+        return None, "프롬프트 부족"
     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,
+        c = Client(IMAGE_API_URL)
+        res = c.predict(
+            prompt=prompt, width=width, height=height,
+            guidance=guidance, inference_steps=inference_steps,
+            seed=seed, do_img2img=False, init_image=None,
+            image2image_strength=0.8, resize_img=True,
             api_name="/generate_image"
         )
-        logging.info(f"이미지 생성 성공: {result[1]}")
-        return result[0], f"사용된 시드: {result[1]}"
+        return res[0], f"Seed: {res[1]}"
     except Exception as e:
-        logging.error(f"이미지 생성 실패: {str(e)}")
-        return None, f"오류: {str(e)}"
+        logging.error(e)
+        return None, 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"
-    """
-    
+    system = f"다음 글을 바탕으로 적절한 이미지 프롬프트를 영어로 한 줄만 써줘:\n{blog_topic}"
     try:
-        response = client.messages.create(
+        res = client.messages.create(
             model="claude-3-7-sonnet-20250219",
-            max_tokens=150,
-            system=image_prompt_system,
+            max_tokens=80,
+            system=system,
             messages=[{"role": "user", "content": blog_content}]
         )
-        
-        # 응답에서 프롬프트 추출
-        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"
+        return res.content[0].text.strip()
+    except Exception:
+        return f"A professional photo related to {blog_topic}, 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
-
-# 웹 검색 키워드 추출 함수
-def extract_keywords(text: str, top_k: int = 5) -> str:
-    """
-    1) 한글(가-힣), 영어(a-zA-Z), 숫자(0-9), 공백만 남김
-    2) 공백 기준 토큰 분리
-    3) 최대 top_k개만
-    """
-    text = re.sub(r"[^a-zA-Z0-9가-힣\s]", "", text)
-    tokens = text.split()
-    key_tokens = tokens[:top_k]
-    return " ".join(key_tokens)
-
-# Mock 검색 결과 생성 함수
-def generate_mock_search_results(query):
-    """API 연결이 안될 때 사용할 가상 검색 결과 생성"""
-    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    mock_results = [
-        {
-            "title": f"{query}에 관한 최신 정보",
-            "link": "https://example.com/article1",
-            "snippet": f"{query}에 관한 가상 검색 결과입니다. 이 결과는 API 연결 문제로 인해 생성된 가상 데이터입니다. 실제 검색 결과가 아님을 참고하세요. 생성 시간: {current_time}",
-            "displayed_link": "example.com/article1"
-        },
-        {
-            "title": f"{query} 관련 연구 동향",
-            "link": "https://example.org/research",
-            "snippet": "이것은 API 연결 문제로 인한 가상 검색 결과입니다. 실제 검색 결과를 보여드리지 못해 죄송합니다. 대신 AI의 기존 지식을 활용하여 답변드리겠습니다.",
-            "displayed_link": "example.org/research"
-        },
-        {
-            "title": f"{query}의 역사적 배경",
-            "link": "https://example.net/history",
-            "snippet": "이 가상 검색 결과는 API 연결 문제로 인해 생성되었습니다. 참고용으로만 사용해주세요.",
-            "displayed_link": "example.net/history"
-        }
-    ]
-    
-    summary_lines = []
-    for idx, item in enumerate(mock_results, start=1):
-        title = item.get("title", "No title")
-        link = item.get("link", "#")
-        snippet = item.get("snippet", "No description")
-        displayed_link = item.get("displayed_link", link)
-        
-        summary_lines.append(
-            f"### Result {idx}: {title}\n\n"
-            f"{snippet}\n\n"
-            f"**출처**: [{displayed_link}]({link})\n\n"
-            f"---\n"
-        )
-    
-    notice = """
-# 가상 검색 결과 (API 연결 문제로 인해 생성됨)
-아래는 API 연결 문제로 인해 생성된 가상 검색 결과입니다. 실제 검색 결과가 아님을 참고하세요.
-대신 AI의 기존 지식을 활용하여 최대한 정확한 답변을 드리겠습니다.
-"""
-    
-    return notice + "\n".join(summary_lines)
-
-
-###################################################
-#   SerpHouse 만 사용하는 웹 검색 함수
-###################################################
-def do_web_search(query: str) -> str:
-    """
-    웹 검색을 **SerpHouse**로만 수행하는 함수.
-    - SERPHOUSE_API_KEY가 없거나 mock일 경우에는 가상 검색 결과를 반환
-    - API 호출이 성공하면 그 결과를 파싱하여 마크다운으로 반환
-    - 실패하면 가상 검색 결과를 반환
-    """
-    # 1) API 키 유효성 체크
-    if not SERPHOUSE_API_KEY or "mock" in SERPHOUSE_API_KEY.lower():
-        logging.warning("API 키가 없거나 Mock 모드입니다. => 가상 검색 결과 반환")
-        return generate_mock_search_results(query)
-
-    try:
-        # SerpHouse API
-        url = "https://api.serphouse.com/serp/live"
-        params = {
-            "q": query,
-            "domain": "google.com",
-            "serp_type": "web",     # 웹 검색
-            "device": "desktop",
-            "lang": "ko",  # 한국어
-            "num": "5"     # 결과 최대 5개
-        }
-        headers = {
-            "Authorization": f"Bearer {SERPHOUSE_API_KEY}"
-        }
-        
-        logging.info(f"SerpHouse API 호출 중... 검색어: {query}")
-        response = requests.get(url, headers=headers, params=params, timeout=15)
-        response.raise_for_status()
-        
-        data = response.json()
-        
-        # 결과 구조 파악
-        results = data.get("results", {})
-        organic = None
-        
-        # 가능한 응답 구조 확인
-        if isinstance(results, dict) and "organic" in results:
-            organic = results["organic"]
-        elif "organic" in data:
-            organic = data["organic"]
-        
-        # organic 결과가 없다면 가상 결과
-        if not organic:
-            logging.warning("SerpHouse 응답에서 organic 항목을 찾을 수 없습니다.")
-            return generate_mock_search_results(query)
-        
-        # 최대 5개만 슬라이싱
-        organic = organic[:5]
-        
-        # 결과 요약 문자열 만들기
-        summary_lines = []
-        for idx, item in enumerate(organic, start=1):
-            title = item.get("title", "No title")
-            link = item.get("link", "#")
-            snippet = item.get("snippet", "No description")
-            displayed_link = item.get("displayed_link", link)
-            
-            summary_lines.append(
-                f"### Result {idx}: {title}\n\n"
-                f"{snippet}\n\n"
-                f"**출처**: [{displayed_link}]({link})\n\n"
-                f"---\n"
-            )
-        
-        instructions = """
-# 웹 검색 결과
-아래는 검색 결과입니다. 질문에 답변할 때 이 정보를 활용하세요:
-1. 각 결과의 제목, 내용, 출처 링크를 참고하세요
-2. 답변에 관련 정보의 출처를 명시적으로 인용하세요 (예: "X 출처에 따르면...")
-3. 응답에 실제 출처 링크를 포함하세요
-4. 여러 출처의 정보를 종합하여 답변하세요
-"""
-        
-        return instructions + "\n".join(summary_lines)
-
-    except requests.exceptions.Timeout:
-        logging.error("SerpHouse 검색 타임아웃. => 가상 검색 결과를 반환합니다.")
-        return generate_mock_search_results(query)
-    except Exception as e:
-        logging.error(f"SerpHouse 검색 실패: {e}")
-        return generate_mock_search_results(query)
+    body = markdown.markdown(md_text)
+    return f"""<!DOCTYPE html><html><head>
+<title>{title}</title><meta charset="utf-8"></head><body>{body}</body></html>"""
 
+def extract_keywords(text: str, k: int = 5) -> str:
+    txt = re.sub(r"[^가-힣a-zA-Z0-9\\s]", "", text)
+    return " ".join(txt.split()[:k])
 
+# ───────────────────────────── 8) Streamlit UI ────────────────────────────────
 def chatbot_interface():
     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
-    
-    # 웹 검색 토글
-    if "use_web_search" not in st.session_state:
-        st.session_state.use_web_search = 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)
-    
-    # 웹 검색 토글
-    st.session_state.use_web_search = st.sidebar.toggle("주제 웹 검색 및 분석", value=st.session_state.use_web_search)
-    
-    # 이미지 API 상태 표시
-    st.sidebar.text(st.session_state.image_api_status)
-    
-    # 이미지 생성 설정 (토글이 켜져 있을 때만 표시)
-    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
-    
-    # 블로그 내용 다운로드 섹션
-    st.sidebar.title("블로그 다운로드")
-    
-    # 최신 블로그 내용 가져오기
-    latest_blog = None
-    latest_blog_title = "블로그 글"
-    
-    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"]
-                
-                # 타이틀 추출 시도 (첫 번째 제목 태그 사용)
-                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
-    
-    # 다운로드 버튼 그룹
-    if latest_blog:
-        st.sidebar.subheader("최근 블로그 다운로드")
-        
-        col1, col2 = st.sidebar.columns(2)
-        
-        # 마크다운으로 다운로드
-        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"
-            )
-    
-    # 대화 기록 불러오기
-    uploaded_file = st.sidebar.file_uploader("대화 기록 불러오기", type=['json'])
-    if uploaded_file is not None:
-        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 형식의 파일이 아닙니다.")
-        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", "생성된 이미지"))
+    # 세션 상태 초기화
+    defaults = {
+        "ai_model": "claude-3-7-sonnet-20250219",
+        "messages": [],
+        "auto_save": True,
+        "generate_image": False,
+        "use_web_search": False,
+        "image_api_status": test_image_api_connection()
+    }
+    for k, v in defaults.items():
+        if k not in st.session_state:
+            st.session_state[k] = v
+
+    sb = st.sidebar
+    sb.title("대화 기록 관리")
+    sb.toggle("자동 저장", key="auto_save")
+    sb.toggle("블로그 글 작성 후 이미지 자동 생성", key="generate_image")
+    sb.toggle("주제 웹 검색 및 분석", key="use_web_search")
+    sb.text(st.session_state.image_api_status)
+
+    # 기존 메시지 렌더링
+    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("무엇을 도와드릴까요?"):
@@ -465,151 +256,86 @@ def chatbot_interface():
         with st.chat_message("user"):
             st.markdown(prompt)
 
-        # AI 응답 생성
         with st.chat_message("assistant"):
-            message_placeholder = st.empty()
-            full_response = ""
-            
-            # 웹 검색 수행 (옵션이 켜져 있을 경우)
-            system_prompt = get_system_prompt()
+            placeholder = st.empty()
+            full_resp = ""
+            sys_prompt = get_system_prompt()
+
+            # (선택) Brave 검색
             if st.session_state.use_web_search:
-                with st.spinner("웹에서 관련 정보를 검색 중..."):
-                    try:
-                        search_query = extract_keywords(prompt, top_k=5)
-                        st.info(f"검색어: {search_query}")
-                        
-                        # SerpHouse API로 검색
-                        search_results = do_web_search(search_query)
-                        
-                        if "가상 검색 결과" in search_results:
-                            st.warning("실제 검색 결과를 가져올 수 없어 기존 지식을 활용합니다.")
-                        else:
-                            st.success(f"검색 완료: '{search_query}'에 대한 정보를 수집했습니다.")
-                        
-                        # 시스템 프롬프트에 검색 결과 추가
-                        system_prompt += f"\n\n검색 결과:\n{search_results}\n"
-                    except Exception as e:
-                        st.error(f"웹 검색 중 오류가 발생했습니다: {str(e)}")
-                        logging.error(f"웹 검색 오류: {str(e)}")
-                        system_prompt += "\n\n웹 검색이 실패했습니다. 기존 지식을 바탕으로 답변하세요."
-            
-            # API 호출
+                with st.spinner("웹 검색 중…"):
+                    q = extract_keywords(prompt)
+                    sb.info(f"검색어: {q}")
+                    search_md = do_web_search(q)
+                    if "가상 검색 결과" in search_md:
+                        sb.warning("실제 검색 결과를 가져오지 못했습니다.")
+                    sys_prompt += f"\n\n검색 결과:\n{search_md}\n"
+
+            # Claude 스트리밍
             with client.messages.stream(
+                model=st.session_state.ai_model,
                 max_tokens=MAX_TOKENS,
-                system=system_prompt,
-                messages=[{"role": m["role"], "content": m["content"]} for m in st.session_state.messages],
-                model=st.session_state["ai_model"]
+                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:
+                    full_resp += t or ""
+                    placeholder.markdown(full_resp + "▌")
+            placeholder.markdown(full_resp)
+
+            # (선택) 이미지 생성
             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
-                        })
+                with st.spinner("이미지 생성 중…"):
+                    img_prompt = extract_image_prompt(full_resp, prompt)
+                    img, caption = generate_image(img_prompt)
+                    if img:
+                        st.image(img, caption=caption)
+                        st.session_state.messages.append(
+                            {"role": "assistant", "content": full_resp,
+                             "image": img, "image_caption": caption}
+                        )
                     else:
-                        st.error(f"이미지 생성 실패: {image_caption}")
-                        st.session_state.messages.append({
-                            "role": "assistant", 
-                            "content": full_response
-                        })
+                        st.error(f"이미지 생성 실패: {caption}")
+                        st.session_state.messages.append(
+                            {"role": "assistant", "content": full_resp}
+                        )
             else:
-                # 이미지 생성 없이 응답만 저장
-                st.session_state.messages.append({
-                    "role": "assistant", 
-                    "content": full_response
-                })
-                
-            # 블로그 다운로드 버튼 표시 (응답 바로 아래에)
-            st.subheader("이 블로그 다운로드:")
-            col1, col2 = st.columns(2)
-            
-            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"
+                st.session_state.messages.append(
+                    {"role": "assistant", "content": full_resp}
                 )
 
-        # 자동 저장 기능
-        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)
-                
-                # 현재 시간을 포함한 파일명 생성
-                current_time = datetime.now().strftime("%Y%m%d_%H%M%S")
-                filename = f'chat_history_auto_save_{current_time}.json'
-                
-                with open(filename, '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"
-        )
+            # 다운로드 버튼
+            st.subheader("이 블로그 다운로드:")
+            c1, c2 = st.columns(2)
+            c1.download_button("마크다운", full_resp,
+                               file_name=f"{prompt[:30]}.md", mime="text/markdown")
+            html = convert_md_to_html(full_resp, prompt[:30])
+            c2.download_button("HTML", html,
+                               file_name=f"{prompt[:30]}.html", mime="text/html")
+
+    # 자동 저장
+    if st.session_state.auto_save and st.session_state.messages:
+        try:
+            fname = f"chat_history_{datetime.now():%Y%m%d_%H%M%S}.json"
+            with open(fname, "w", encoding="utf-8") as f:
+                json.dump(st.session_state.messages, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            sb.error(f"자동 저장 오류: {e}")
 
+# ───────────────────────────── 9) main ────────────────────────────────────────
 def main():
     chatbot_interface()
 
 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("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()