Update app.py

app.py

@@ -157,7 +157,7 @@ def extract_keywords(text: str, top_k: int = 5) -> str:
     key_tokens = tokens[:top_k]
     return " ".join(key_tokens)
 
-# Mock 검색 결과 생성 함수 추가 (API 키가 없거나 연결 실패 시 대체 사용)
+# Mock 검색 결과 생성 함수
 def generate_mock_search_results(query):
     """API 연결이 안될 때 사용할 가상 검색 결과 생성"""
     current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@@ -173,6 +173,628 @@ def generate_mock_search_results(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)
+
+# Google 검색 함수 (SerpAPI 대신 직접 검색)
+def do_google_search(query, num_results=5):
+    try:
+        # 기본 헤더 설정 (브라우저처럼 보이게)
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        
+        # 검색 URL 만들기
+        search_url = f"https://www.google.com/search?q={query}&num={num_results}"
+        logging.info(f"구글 검색 URL: {search_url}")
+        
+        # 요청 보내기 (짧은 타임아웃 설정)
+        response = requests.get(search_url, headers=headers, timeout=10)
+        
+        # 응답이 성공적인지 확인
+        if response.status_code != 200:
+            logging.error(f"Google 검색 응답 상태 코드: {response.status_code}")
+            return generate_mock_search_results(query)
+        
+        # 여기서는 HTML 분석이 복잡하므로, 실제로는 BeautifulSoup 같은 라이브러리를 사용하는 것이 좋음
+        # 간단한 데모 목적으로 대신 Mock 데이터 반환
+        logging.info("Google 검색 성공했으나 파싱 제한으로 Mock 데이터 반환")
+        return generate_mock_search_results(query)
+        
+    except Exception as e:
+        logging.error(f"Google 검색 실패: {e}")
+        return generate_mock_search_results(query)
+
+# 웹 검색 함수
+def do_web_search(query: str) -> str:
+    """
+    웹 검색을 수행하는 함수 - SerpHouse API 또는 직접 구글 검색
+    """
+    try:
+        # API 키가 없거나 'mock'인 경우
+        if not SERPHOUSE_API_KEY or "mock" in SERPHOUSE_API_KEY.lower():
+            logging.warning("API 키가 없거나 Mock 모드입니다. 가상 검색 결과를 반환합니다.")
+            return generate_mock_search_results(query)
+        
+        # SerpHouse API 사용
+        url = "https://api.serphouse.com/serp/live"
+        params = {
+            "q": query,
+            "domain": "google.com",
+            "serp_type": "web",
+            "device": "desktop", 
+            "lang": "ko",  # 한국어 결과
+            "num": "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()
+        
+        logging.info(f"SerpHouse API 응답 상태 코드: {response.status_code}")
+        data = response.json()
+        
+        # 다양한 응답 구조 처리
+        results = data.get("results", {})
+        organic = None
+        
+        # 가능한 응답 구조 1
+        if isinstance(results, dict) and "organic" in results:
+            organic = results["organic"]
+        # 가능한 응답 구조 2
+        elif isinstance(results, dict) and "results" in results:
+            if isinstance(results["results"], dict) and "organic" in results["results"]:
+                organic = results["results"]["organic"]
+        # 가능한 응답 구조 3
+        elif "organic" in data:
+            organic = data["organic"]
+            
+        if not organic:
+            logging.warning("응답에서 organic 결과를 찾을 수 없습니다. 구글 직접 검색으로 전환합니다.")
+            return do_google_search(query)
+
+        # 결과 수 제한 및 컨텍스트 길이 최적화
+        max_results = min(5, len(organic))
+        limited_organic = organic[:max_results]
+        
+        # 결과 형식 개선
+        summary_lines = []
+        for idx, item in enumerate(limited_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. 여러 출처의 정보를 종합하여 답변하세요
+"""
+        
+        search_results = instructions + "\n".join(summary_lines)
+        logging.info(f"검색 결과 {len(limited_organic)}개 처리 완료")
+        return search_results
+    
+    except requests.exceptions.Timeout:
+        logging.error("Web search timed out, 직접 구글 검색으로 전환합니다.")
+        return do_google_search(query)
+    except Exception as e:
+        logging.error(f"Web search failed: {e}, 직접 구글 검색으로 전환합니다.")
+        return do_google_search(query)
+
+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", "생성된 이미지"))
+
+    # 사용자 입력
+    if prompt := st.chat_input("무엇을 도와드릴까요?"):
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        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()
+            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 client.messages.stream(
+                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"]
+            ) 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)
+            
+            # 이미지 생성 옵션이 켜져 있는 경우
+            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 = 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"
+                )
+
+        # 자동 저장 기능
+        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"
+        )
+
+def main():
+    chatbot_interface()
+
+if __name__ == "__main__":
+    # 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")
+    
+    main()import os
+import streamlit as st
+import json
+import anthropic
+import requests
+import logging
+from gradio_client import Client
+import markdown
+import tempfile
+import base64
+from datetime import datetime
+import re
+
+# 로깅 설정
+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)
+
+# 이미지 생성 API URL
+IMAGE_API_URL = "http://211.233.58.201:7896"
+
+# 최대 토큰 수 설정 (Claude-3 Sonnet의 최대 토큰 수)
+MAX_TOKENS = 7999
+
+# SerpHouse API Key 설정
+SERPHOUSE_API_KEY = os.environ.get("SERPHOUSE_API_KEY", "")
+
+def get_system_prompt():
+    return """
+당신은 전문 블로그 작성 전문가입니다. 모든 블로그 글 작성 요청에 대해 다음의 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. 소통 채널 안내
+
+작성 시 준수사항 9.1. 글자 수: 1500-2000자 내외 9.2. 문단 길이: 3-4문장 이내 9.3. 시각적 구분: 소제목, 구분선, 번호 목록 활용 9.4. 톤앤매너: 친근하고 전문적인 대화체 9.5. 데이터: 모든 정보의 출처 명시 9.6. 가독성: 명확한 단락 구분과 강조점 사용
+
+이러한 프레임워크를 바탕으로, 요청받은 주제에 대해 체계적이고 매력적인 블로그 포스트를 작성하겠습니다.
+"""
+
+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}"
+
+def generate_image(prompt, width=768, height=768, guidance=3.5, inference_steps=30, seed=3):
+    """이미지 생성 함수"""
+    if not prompt:
+        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,
+            api_name="/generate_image"
+        )
+        logging.info(f"이미지 생성 성공: {result[1]}")
+        return result[0], f"사용된 시드: {result[1]}"
+    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"
+    """
+    
+    try:
+        response = client.messages.create(
+            model="claude-3-7-sonnet-20250219",
+            max_tokens=150,
+            system=image_prompt_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"
+
+# 마크다운을 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"
         }
     ]
     
@@ -198,23 +820,55 @@ def generate_mock_search_results(query):
     
     return notice + "\n".join(summary_lines)
 
+# Google 검색 함수 (SerpAPI 대신 직접 검색)
+def do_google_search(query, num_results=5):
+    try:
+        # 기본 헤더 설정 (브라우저처럼 보이게)
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        
+        # 검색 URL 만들기
+        search_url = f"https://www.google.com/search?q={query}&num={num_results}"
+        logging.info(f"구글 검색 URL: {search_url}")
+        
+        # 요청 보내기 (짧은 타임아웃 설정)
+        response = requests.get(search_url, headers=headers, timeout=10)
+        
+        # 응답이 성공적인지 확인
+        if response.status_code != 200:
+            logging.error(f"Google 검색 응답 상태 코드: {response.status_code}")
+            return generate_mock_search_results(query)
+        
+        # 여기서는 HTML 분석이 복잡하므로, 실제로는 BeautifulSoup 같은 라이브러리를 사용하는 것이 좋음
+        # 간단한 데모 목적으로 대신 Mock 데이터 반환
+        logging.info("Google 검색 성공했으나 파싱 제한으로 Mock 데이터 반환")
+        return generate_mock_search_results(query)
+        
+    except Exception as e:
+        logging.error(f"Google 검색 실패: {e}")
+        return generate_mock_search_results(query)
+
 # 웹 검색 함수
 def do_web_search(query: str) -> str:
     """
-    상위 20개 'organic' 결과 item 전체(제목, link, snippet 등)를
-    JSON 문자열 형태로 반환
+    웹 검색을 수행하는 함수 - SerpHouse API 또는 직접 구글 검색
     """
     try:
-        url = "https://api.serphouse.com/serp/live"
+        # API 키가 없거나 'mock'인 경우
+        if not SERPHOUSE_API_KEY or "mock" in SERPHOUSE_API_KEY.lower():
+            logging.warning("API 키가 없거나 Mock 모드입니다. 가상 검색 결과를 반환합니다.")
+            return generate_mock_search_results(query)
         
-        # 기본 GET 방식으로 파라미터 간소화하고 결과 수를 20개로 제한
+        # SerpHouse API 사용
+        url = "https://api.serphouse.com/serp/live"
         params = {
             "q": query,
             "domain": "google.com",
-            "serp_type": "web",  # 기본 웹 검색
+            "serp_type": "web",
             "device": "desktop", 
-            "lang": "ko",  # 한국어 검색 결과를 위해 변경
-            "num": "10"  # 결과 수를 10개로 줄임 (빠른 응답을 위해)
+            "lang": "ko",  # 한국어 결과
+            "num": "5"     # 결과 수 줄임
         }
         
         headers = {
@@ -222,15 +876,9 @@ def do_web_search(query: str) -> str:
         }
         
         logging.info(f"SerpHouse API 호출 중... 검색어: {query}")
-        logging.info(f"요청 URL: {url} - 파라미터: {params}")
-        
-        # Mock 응답 (실제 API 연결이 어려울 경우)
-        if not SERPHOUSE_API_KEY or "mock" in SERPHOUSE_API_KEY.lower():
-            logging.warning("API 키가 없거나 Mock 모드입니다. 모의 검색 결과를 반환합니다.")
-            return generate_mock_search_results(query)
         
-        # 타임아웃 줄임 (30초)
-        response = requests.get(url, headers=headers, params=params, timeout=30)
+        # 짧은 타임아웃으로 요청 시도
+        response = requests.get(url, headers=headers, params=params, timeout=15)
         response.raise_for_status()
         
         logging.info(f"SerpHouse API 응답 상태 코드: {response.status_code}")
@@ -243,28 +891,23 @@ def do_web_search(query: str) -> str:
         # 가능한 응답 구조 1
         if isinstance(results, dict) and "organic" in results:
             organic = results["organic"]
-        
-        # 가능한 응답 구조 2 (중첩된 results)
+        # 가능한 응답 구조 2
         elif isinstance(results, dict) and "results" in results:
             if isinstance(results["results"], dict) and "organic" in results["results"]:
                 organic = results["results"]["organic"]
-        
-        # 가능한 응답 구조 3 (최상위 organic)
+        # 가능한 응답 구조 3
         elif "organic" in data:
             organic = data["organic"]
             
         if not organic:
-            logging.warning("응답에서 organic 결과를 찾을 수 없습니다.")
-            logging.debug(f"응답 구조: {list(data.keys()) if isinstance(data, dict) else 'not a dict'}")
-            if isinstance(results, dict):
-                logging.debug(f"results 구조: {list(results.keys())}")
-            return "검색 결과를 찾을 수 없습니다. 대신 기존 지식을 활용하여 답변하겠습니다."
+            logging.warning("응답에서 organic 결과를 찾을 수 없습니다. 구글 직접 검색으로 전환합니다.")
+            return do_google_search(query)
 
         # 결과 수 제한 및 컨텍스트 길이 최적화
-        max_results = min(10, len(organic))
+        max_results = min(5, len(organic))
         limited_organic = organic[:max_results]
         
-        # 결과 형식 개선 - 마크다운 형식으로 출력하여 가독성 향상
+        # 결과 형식 개선
         summary_lines = []
         for idx, item in enumerate(limited_organic, start=1):
             title = item.get("title", "No title")
@@ -272,7 +915,6 @@ def do_web_search(query: str) -> str:
             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"
@@ -295,11 +937,11 @@ def do_web_search(query: str) -> str:
         return search_results
     
     except requests.exceptions.Timeout:
-        logging.error("Web search timed out")
-        return "Web search timed out. 검색 시간이 초과되었습니다. 기존 지식을 활용하여 답변하겠습니다."
+        logging.error("Web search timed out, 직접 구글 검색으로 전환합니다.")
+        return do_google_search(query)
     except Exception as e:
-        logging.error(f"Web search failed: {e}")
-        return f"Web search failed: {str(e)}. 검색 중 오류가 발생했습니다. 기존 지식을 활용하여 답변하겠습니다."
+        logging.error(f"Web search failed: {e}, 직접 구글 검색으로 전환합니다.")
+        return do_google_search(query)
 
 def chatbot_interface():
     st.title("Ginigen Blog")
@@ -452,18 +1094,22 @@ def chatbot_interface():
                 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 "search failed" not in search_results.lower() and "timed out" not in search_results.lower():
-                            # 시스템 프롬프트에 검색 결과 추가
-                            system_prompt += f"\n\n검색 결과:\n{search_results}\n"
-                            st.success(f"검색 완료: '{search_query}'에 대한 정보를 수집했습니다.")
+                        if "가상 검색 결과" in search_results:
+                            st.warning("실제 검색 결과를 가져올 수 없어 기존 지식을 활용합니다.")
                         else:
-                            st.warning("웹 검색을 진행했으나 결과를 가져오는데 실패했습니다. 기존 지식을 활용하여 답변합니다.")
-                            logging.warning(f"웹 검색 실패 또는 타임아웃: {search_results}")
+                            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 client.messages.stream(