Update app.py

app.py

@@ -10,7 +10,8 @@ import tempfile
 import base64
 from datetime import datetime
 import re
-from bs4 import BeautifulSoup  # BeautifulSoup 추가
+from bs4 import BeautifulSoup  # BeautifulSoup는 이제 사용하지 않지만, 필요 시 유지
+# (직접 구글 검색 로직은 삭제했으므로 사실상 BeautifulSoup는 필요 없습니다.)
 
 # 로깅 설정
 logging.basicConfig(
@@ -34,23 +35,53 @@ 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. 가독성: 명확한 단락 구분과 강조점 사용
+독자 연결 단계
+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. 가독성: 명확한 단락 구분과 강조점 사용
 
 이러한 프레임워크를 바탕으로, 요청받은 주제에 대해 체계적이고 매력적인 블로그 포스트를 작성하겠습니다.
 """
@@ -205,254 +236,64 @@ def generate_mock_search_results(query):
     
     return notice + "\n".join(summary_lines)
 
-# Google 검색 함수 (SerpAPI 대신 직접 검색)
-# Google 검색 함수 (BeautifulSoup을 사용하여 결과 파싱)
-# Google 검색 함수 개선
-def do_google_search(query, num_results=5):
-    try:
-        # 다양한 User-Agent 사용 (Google 차단 방지)
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
-            'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
-            'Referer': 'https://www.google.com/',
-        }
-        
-        # 검색 URL
-        search_url = f"https://www.google.com/search?q={query}&num={num_results}&hl=ko&gl=kr"
-        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 파싱을 위한 디버깅
-        with open("google_response.html", "w", encoding="utf-8") as f:
-            f.write(response.text)
-        logging.info("Google 응답 HTML을 'google_response.html'에 저장했습니다.")
-        
-        # BeautifulSoup으로 HTML 파싱
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
-        # 검색 결과 추출
-        organic_results = []
-        
-        # 2023-2025 구글 검색 결과 선택자 시도 (다양한 선택자 시도)
-        selectors = [
-            'div.g', 'div.Gx5Zad', 'div.tF2Cxc', 'div.yuRUbf', 
-            '.v5yQqb', '.MjjYud', 'div[jscontroller]', '.fP1Qef',
-            'div[data-sokoban-container]', '.hlcw0c'
-        ]
-        
-        # 모든 선택자 시도
-        containers = []
-        for selector in selectors:
-            elements = soup.select(selector)
-            if elements:
-                logging.info(f"선택자 '{selector}'로 {len(elements)}개 요소를 찾았습니다.")
-                containers.extend(elements)
-                # 충분한 요소를 찾았으면 중단
-                if len(containers) >= num_results * 2:  # 중복 가능성 고려해 2배로 찾음
-                    break
-        
-        # 대안: 모든 <a> 태그에서 href가 http로 시작하는 것만 선택
-        if not containers:
-            logging.warning("구조화된 컨테이너를 찾을 수 없어 직접 링크를 검색합니다.")
-            link_elements = soup.select('a[href^="http"]')
-            
-            for link in link_elements:
-                if len(organic_results) >= num_results:
-                    break
-                    
-                href = link.get('href', '')
-                # Google 리다이렉트 URL 필터링
-                if '/url?' in href or 'google.com' in href:
-                    continue
-                
-                # 부모 요소에서 텍스트 추출 시도
-                parent = link.parent
-                title = link.get_text(strip=True) or "제목 없음"
-                
-                # 충분한 길이의 텍스트가 있는 경우만 결과로 추가
-                if len(title) > 5:  # 의미 있는 제목은 보통 5자 이상
-                    # 주변 텍스트 추출 시도
-                    surrounding_text = ""
-                    for sibling in parent.next_siblings:
-                        if sibling.name and sibling.get_text(strip=True):
-                            surrounding_text = sibling.get_text(strip=True)
-                            break
-                    
-                    # 결과 추가
-                    organic_results.append({
-                        "title": title,
-                        "link": href,
-                        "snippet": surrounding_text or "추가 설명 없음",
-                        "displayed_link": href.split('/')[2] if '/' in href else href
-                    })
-        
-        # 선택자 기반 파싱 시도
-        else:
-            for container in containers:
-                if len(organic_results) >= num_results:
-                    break
-                
-                # 1. 링크 찾기
-                link_element = container.select_one('a[href^="http"]')
-                if not link_element:
-                    continue
-                
-                link = link_element.get('href', '')
-                # Google의 리다이렉트 URL이면 건너뛰기
-                if '/url?' in link or 'google.com' in link:
-                    continue
-                
-                # 2. 제목 찾기 (다양한 선택자)
-                title_selectors = ['h3', '.LC20lb', '.DKV0Md', '.l', '.vvjwJb']
-                title = None
-                for selector in title_selectors:
-                    title_element = container.select_one(selector)
-                    if title_element and title_element.get_text(strip=True):
-                        title = title_element.get_text(strip=True)
-                        break
-                
-                if not title:
-                    title = link_element.get_text(strip=True) or "제목 없음"
-                
-                # 3. 스니펫 찾기 (다양한 선택자)
-                snippet_selectors = ['.VwiC3b', '.lyLwlc', '.yXK7lf', '.lEBKkf', '.s', '.st']
-                snippet = "설명 없음"
-                for selector in snippet_selectors:
-                    snippet_element = container.select_one(selector)
-                    if snippet_element and snippet_element.get_text(strip=True):
-                        snippet = snippet_element.get_text(strip=True)
-                        break
-                
-                # 4. 표시 링크 찾기
-                displayed_link_selectors = ['cite', '.UPmit', '.qLRx3b', '.iUh30']
-                displayed_link = link.split('/')[2] if '/' in link else link
-                for selector in displayed_link_selectors:
-                    element = container.select_one(selector)
-                    if element and element.get_text(strip=True):
-                        displayed_link = element.get_text(strip=True)
-                        break
-                
-                # 중복 제거
-                is_duplicate = False
-                for result in organic_results:
-                    if result["link"] == link or result["title"] == title:
-                        is_duplicate = True
-                        break
-                
-                if not is_duplicate:
-                    organic_results.append({
-                        "title": title,
-                        "link": link,
-                        "snippet": snippet,
-                        "displayed_link": displayed_link
-                    })
-        
-        if not organic_results:
-            logging.warning("검색 결과를 파싱할 수 없습니다. 가상 결과를 반환합니다.")
-            return generate_mock_search_results(query)
-        
-        # 검색 결과 마크다운 형식으로 변환
-        summary_lines = []
-        for idx, item in enumerate(organic_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"
-            )
-        
-        # 모델에게 명확한 지침 추가
-        instructions = """
-# 웹 검색 결과
-아래는 검색 결과입니다. 질문에 답변할 때 이 정보를 활용하세요:
-1. 각 결과의 제목, 내용, 출처 링크를 참고하세요
-2. 답변에 관련 정보의 출처를 명시적으로 인용하세요 (예: "X 출처에 따르면...")
-3. 응답에 실제 출처 링크를 포함하세요
-4. 여러 출처의 정보를 종합하여 답변하세요
-"""
-        
-        search_results = instructions + "\n".join(summary_lines)
-        logging.info(f"Google 검색 결과 {len(organic_results)}개 파싱 완료")
-        return search_results
-        
-    except Exception as e:
-        logging.error(f"Google 검색 실패: {e}")
-        return generate_mock_search_results(query)
 
-# 웹 검색 함수
+###################################################
+#   SerpHouse 만 사용하는 웹 검색 함수
+###################################################
 def do_web_search(query: str) -> str:
     """
-    웹 검색을 수행하는 함수 - SerpHouse API 또는 직접 구글 검색
+    웹 검색을 **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:
-        # 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 사용
+        # SerpHouse API
         url = "https://api.serphouse.com/serp/live"
         params = {
             "q": query,
             "domain": "google.com",
-            "serp_type": "web",
-            "device": "desktop", 
-            "lang": "ko",  # 한국어 결과
-            "num": "5"     # 결과 수 줄임
+            "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()
         
-        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"]
-            
+        
+        # organic 결과가 없다면 가상 결과
         if not organic:
-            logging.warning("응답에서 organic 결과를 찾을 수 없습니다. 구글 직접 검색으로 전환합니다.")
-            return do_google_search(query)
-
-        # 결과 수 제한 및 컨텍스트 길이 최적화
-        max_results = min(5, len(organic))
-        limited_organic = organic[:max_results]
+            logging.warning("SerpHouse 응답에서 organic 항목을 찾을 수 없습니다.")
+            return generate_mock_search_results(query)
+        
+        # 최대 5개만 슬라이싱
+        organic = organic[:5]
         
-        # 결과 형식 개선
+        # 결과 요약 문자열 만들기
         summary_lines = []
-        for idx, item in enumerate(limited_organic, start=1):
+        for idx, item in enumerate(organic, start=1):
             title = item.get("title", "No title")
             link = item.get("link", "#")
             snippet = item.get("snippet", "No description")
@@ -465,7 +306,6 @@ def do_web_search(query: str) -> str:
                 f"---\n"
             )
         
-        # 모델에게 명확한 지침 추가
         instructions = """
 # 웹 검색 결과
 아래는 검색 결과입니다. 질문에 답변할 때 이 정보를 활용하세요:
@@ -475,16 +315,15 @@ def do_web_search(query: str) -> str:
 4. 여러 출처의 정보를 종합하여 답변하세요
 """
         
-        search_results = instructions + "\n".join(summary_lines)
-        logging.info(f"검색 결과 {len(limited_organic)}개 처리 완료")
-        return search_results
-    
+        return instructions + "\n".join(summary_lines)
+
     except requests.exceptions.Timeout:
-        logging.error("Web search timed out, 직접 구글 검색으로 전환합니다.")
-        return do_google_search(query)
+        logging.error("SerpHouse 검색 타임아웃. => 가상 검색 결과를 반환합니다.")
+        return generate_mock_search_results(query)
     except Exception as e:
-        logging.error(f"Web search failed: {e}, 직접 구글 검색으로 전환합니다.")
-        return do_google_search(query)
+        logging.error(f"SerpHouse 검색 실패: {e}")
+        return generate_mock_search_results(query)
+
 
 def chatbot_interface():
     st.title("Ginigen Blog")
@@ -631,7 +470,7 @@ def chatbot_interface():
             message_placeholder = st.empty()
             full_response = ""
             
-            # 웹 검색 수행 (웹 검색 옵션이 켜져 있을 경우)
+            # 웹 검색 수행 (옵션이 켜져 있을 경우)
             system_prompt = get_system_prompt()
             if st.session_state.use_web_search:
                 with st.spinner("웹에서 관련 정보를 검색 중..."):
@@ -639,7 +478,7 @@ def chatbot_interface():
                         search_query = extract_keywords(prompt, top_k=5)
                         st.info(f"검색어: {search_query}")
                         
-                        # 두 가지 방법 모두 시도 (SerpHouse API와 직접 검색)
+                        # SerpHouse API로 검색
                         search_results = do_web_search(search_query)
                         
                         if "가상 검색 결과" in search_results:
@@ -773,4 +612,4 @@ if __name__ == "__main__":
         f.write("markdown>=3.5.1\n")
         f.write("pillow>=10.1.0\n")
     
-    main()
+    main()