Create feature_focus_blog.py

feature_focus_blog.py

@@ -0,0 +1,557 @@
+import os
+import random
+import re
+import requests
+import logging
+import tempfile
+from bs4 import BeautifulSoup
+from datetime import datetime 
+from zoneinfo import ZoneInfo
+import html
+from PIL import Image
+from urllib.request import urlopen
+import markdown2
+import gradio as gr
+
+# 로깅 설정 (INFO 레벨)
+logging.basicConfig(level=logging.INFO)
+
+# 상수 정의
+TARGET_CHAR_LENGTH = 4000
+MIN_SECTION_LENGTH = 600
+MAX_TOKENS = 15000
+TEMPERATURE = 0.75
+TOP_P = 0.95
+
+# API 관련 설정
+gemini_api_key = os.getenv("GEMINI_API_KEY")
+
+# --- Google Gemini SDK 초기화 ---
+from google import genai
+from google.genai import types
+client = genai.Client(api_key=gemini_api_key)
+
+# -------------------------------
+# 기본 도우미 함수들
+# -------------------------------
+
+def remove_unwanted_phrases(text):
+    """불필요한 표현 제거 함수"""
+    unwanted_phrases = [
+        '여러분', '최근', '마지막으로', '결론적으로', '결국',
+        '종합적으로', '따라서', '마무리', '끝으로', '요약',
+        '한 줄 요약', '정리하자면', '총정리', '글을 마치며',
+        '이상으로', '추천드립니다', '참고하세요', '도움이 되셨길',
+        '좋은 하루 되세요', '다음 글에서', '도움이 되었길',
+        '즐거운 하루 되세요', '감사합니다'
+    ]
+    
+    # 문단별로 나누어 처리
+    lines = text.split('\n')
+    result_lines = []
+
+    for line in lines:
+        if "다음 섹션에서는" in line:
+            parts = line.split("다음 섹션에서는")
+            if parts[0].strip():
+                result_lines.append(parts[0].strip())
+        else:
+            # 불필요한 표현 제거 (구두점 포함)
+            for phrase in unwanted_phrases:
+                # 불필요한 표현 앞뒤의 구두점과 공백까지 포함하여 제거
+                pattern = rf'(\b{re.escape(phrase)}\b[\s,.!?]*)|([,.!?]*\b{re.escape(phrase)}\b)'
+                line = re.sub(pattern, '', line)
+
+            # 문장 내 잔여 공백 및 구두점 정리
+            line = re.sub(r'\s{2,}', ' ', line)  # 연속 공백 제거
+            line = line.strip()  # 앞뒤 공백 제거
+            result_lines.append(line)
+    
+    return '\n'.join(result_lines)
+
+def convert_to_html(text):
+    """마크다운 형식을 HTML로 변환 - 개선된 버전"""
+    # 제목 형식 변환 (# -> h1, ## -> h2, 등)
+    for i in range(6, 0, -1):
+        pattern = r'^' + r'#' * i + r'\s+(.+)$'
+        text = re.sub(pattern, r'<h' + str(i) + r'>\1</h' + str(i) + r'>', text, flags=re.MULTILINE)
+
+    # 볼드체 변환 (**text** -> <strong>text</strong>)
+    text = re.sub(r'\*\*(.+?)\*\*', r'<strong>\1</strong>', text)
+    
+    # 이탤릭체 변환 (*text* -> <em>text</em>)
+    text = re.sub(r'\*([^*]+?)\*', r'<em>\1</em>', text)
+    
+    # 목록 변환 (- item -> <li>item</li>)
+    lines = text.split('\n')
+    in_list = False
+    result_lines = []
+    
+    for line in lines:
+        list_match = re.match(r'^[\*\-+]\s+(.+)$', line)
+        if list_match:
+            if not in_list:
+                result_lines.append('<ul>')
+                in_list = True
+            result_lines.append(f'<li>{list_match.group(1)}</li>')
+        else:
+            if in_list:
+                result_lines.append('</ul>')
+                in_list = False
+                
+            # 단락 처리
+            if line.strip() and not re.match(r'^<h[1-6]>|<ul>|<li>|<\/ul>|<\/li>', line):
+                result_lines.append(f'<p>{line}</p>')
+            elif not line.strip():
+                result_lines.append('<br>')
+            else:
+                result_lines.append(line)
+    
+    if in_list:
+        result_lines.append('</ul>')
+            
+    # 최종 HTML 결합
+    html_content = '\n'.join(result_lines)
+    
+    # HTML 스타일 적용 (제목과 소재목에 Bold 및 폰트 지정)
+    styled_html = f"""
+    <div style="font-family: 'Pretendard', Arial, sans-serif; color: #333; line-height: 1.6;">
+        <style>
+            h1 {{ 
+                font-size: 1.8em; 
+                margin-top: 1.5em; 
+                margin-bottom: 0.8em; 
+                color: #111; 
+                font-weight: bold; 
+                font-family: 'Pretendard', Arial, sans-serif; 
+            }}
+            h2 {{ 
+                font-size: 1.5em; 
+                margin-top: 1.3em; 
+                margin-bottom: 0.7em; 
+                color: #222; 
+                font-weight: bold; 
+                font-family: 'Pretendard', Arial, sans-serif; 
+            }}
+            h3 {{ 
+                font-size: 1.3em; 
+                margin-top: 1.1em; 
+                margin-bottom: 0.6em; 
+                color: #333; 
+                font-weight: bold; 
+                font-family: 'Pretendard', Arial, sans-serif; 
+            }}
+            p {{ 
+                margin-bottom: 1em; 
+                line-height: 1.7; 
+                font-size: 1.05em; 
+            }}
+            strong {{ 
+                font-weight: bold; 
+                color: #000; 
+            }}
+            em {{ 
+                font-style: italic; 
+            }}
+            ul {{ 
+                margin-left: 1.5em; 
+                margin-bottom: 1em; 
+            }}
+            li {{ 
+                margin-bottom: 0.5em; 
+            }}
+        </style>
+        {html_content}
+    </div>
+    """
+    
+    return styled_html
+
+def post_process_blog(blog_content, style="친근한"):
+    """블로그 컨텐츠 후처리 함수"""
+    try:
+        # 마크다운 제거 (# 형식의 제목 제외)
+        blog_content = re.sub(r'^\s*[\*\-+]\s+', '- ', blog_content, flags=re.MULTILINE)  # 글머리 기호 통일
+        
+        # 스타일에 따른 어투 조정
+        if style == "친근한":
+            blog_content = re.sub(r'([가-힣]+)고요', r'\1구요', blog_content)
+            blog_content = re.sub(r'답니다', '어요', blog_content)
+            blog_content = re.sub(r'였답니다', '였어요', blog_content)
+            blog_content = re.sub(r'했답니다', '했어요', blog_content)
+            blog_content = re.sub(r'습니다', '요', blog_content)
+            blog_content = re.sub(r'합니다', '해요', blog_content)
+            blog_content = re.sub(r'됩니다', '돼요', blog_content)
+            blog_content = re.sub(r'입니다', '이에요', blog_content)
+
+        # 핵심기능 전문용어 강화 및 구체적 수치 강조
+        tech_terms = [
+            (r'성능\b(?!\s*분석|\s*테스트|\s*측정)', r'기술적 성능'),
+            (r'속도\b(?!\s*측정|\s*테스트)', r'처리 속도'),
+            (r'화면\b(?!\s*크기|\s*밝기)', r'디스플레이'),
+            (r'카메라\b(?!\s*모듈|\s*센서)', r'이미지 센서 시스템'),
+            (r'배터리\b(?!\s*용량|\s*수명)', r'전력 관리 시스템'),
+            (r'사용\b(?!\s*방법|\s*설명|\s*사례)', r'운용'),
+            (r'좋다\b(?!\s*고)', r'효율적이다'),
+            (r'빠르다\b', r'고성능이다')
+        ]
+        
+        for pattern, replacement in tech_terms:
+            blog_content = re.sub(pattern, replacement, blog_content)
+            
+        # 분석적 표현 강화
+        blog_content = re.sub(r'제 생각에는', r'분석 결과에 따르면', blog_content)
+        blog_content = re.sub(r'제가 봤을 때', r'기술적 관점에서', blog_content)
+        blog_content = re.sub(r'느낌이 들어요', r'확인됩니다', blog_content)
+        
+        # 수치와 단위 사이에 공백 추가 및 강조
+        def add_space_to_numbers(match):
+            number, unit = match.groups()
+            return f"{number} {unit}"
+            
+        blog_content = re.sub(r'(\d+(?:\.\d+)?)([가-힣]+)', add_space_to_numbers, blog_content)
+        
+        # 주요 숫자 데이터 볼드 처리
+        blog_content = re.sub(r'(\d+(?:\.\d+)?(?:\s*%|\s*dB|\s*Hz|\s*시간|\s*mAh|\s*GB|\s*MB|\s*TB|\s*MP))', r'**\1**', blog_content)
+        
+        # 과장된 표현 정리
+        exaggerated_expressions = [
+            (r'필수적인', r'중요한'),
+            (r'혁명적인', r'주목할만한'),
+            (r'놀라운', r'주목할 만한'),
+            (r'기적의', r'효과적인'),
+            (r'최고의', r'우수한'),
+            (r'세계적인', r'주요'),
+            (r'완벽한', r'우수한'),
+            (r'극적인', r'상당한'),
+            (r'무한한', r'다양한'),
+            (r'절대적인', r'중요한'),
+            (r'혁신적인', r'새로운'),
+            (r'환상적인', r'우수한'),
+            (r'근본적인', r'기본적인'),
+            (r'획기적인', r'중요한'),
+            (r'전례없는', r'특별한'),
+            (r'압도적인', r'두드러진'),
+            (r'기가 막힌', r'효과적인'),
+            (r'끝판왕', r'최상위 모델')
+        ]
+            
+        for pattern, replacement in exaggerated_expressions:
+            blog_content = re.sub(r'\b' + pattern + r'\b', replacement, blog_content, flags=re.IGNORECASE)
+        
+        # 참고글 관련 표현 정리
+        blog_content = re.sub(r'참고글에 따르면', r'기술 분석에 따르면', blog_content)
+        blog_content = re.sub(r'참고글', r'기술 문서', blog_content)
+        
+        return blog_content
+    except Exception as e:
+        logging.error(f"블로그 글 후처리 중 오류 발생: {str(e)}")
+        return blog_content
+
+def generate_outline(category, style, references1, references2, references3):
+    """핵심기능 선별 함수 - 간단한 설명 추가"""
+    try:
+        # 참고글 정보 준비
+        references = [
+            references1.strip() if references1.strip() else "참고 자료 없음",
+            references2.strip() if references2.strip() else "참고 자료 없음",
+            references3.strip() if references3.strip() else "참고 자료 없음"
+        ]
+        
+        # 의미 있는 참고글만 필터링
+        meaningful_refs = [ref for ref in references if ref != "참고 자료 없음"]
+        
+        if not meaningful_refs:
+            return ["참고 자료가 없습니다"] * 5
+        
+        # 스타일 프롬프트 가져오기
+        style_prompt = get_style_prompt(style)
+        
+        # 모든 참고글 결합
+        combined_refs = "\n\n".join(meaningful_refs)
+        
+        # LLM에 핵심기능 추출 요청
+        extract_prompt = f"""
+[핵심기능 선별 요청]
+제공된 참고글에서 가장 중요하고 핵심적인 기능 5가지를 선별하고 각각에 간단한 설명을 추가해주세요.
+
+참고글:
+{combined_refs}
+
+[시스템 역할]
+당신은 수년간의 경험을 가진 상품 기능 전문 분석가입니다. 제품의 단일 핵심 기능을 심층적으로 분석하고 다양한 측면에서 평가하여 많은 독자들의 신뢰를 받고 있습니다.
+
+[분석 단계]
+1. 참고 자료 3개를 철저히 분석하여 제품의 단일 핵심 기능 식별
+2. 선정한 핵심 기능의 5가지 주요 측면 파악 (성능, 사용성, 효율성, 기술적 특징, 활용 가치 등)
+3. 선정한 핵심 기능이 제품 전체에서 갖는 중요도와 차별성 평가
+
+[아웃라인 구성 원칙]
+1. 본론(5개) - 참고 자료 분석을 통해 발견한 핵심 기능의 5가지 중요 측면을 담은 소제목
+ - 핵심 기능의 기술적 원리와 작동 메커니즘
+ - 핵심 기능의 실제 성능 및 측정 데이터 분석
+ - 사용자 경험 측면에서의 기능 평가
+ - 경쟁 제품과의 해당 기능 비교 분석
+ - 핵심 기능의 실생활 활용 가치와 한계점
+ - (위 항목들은 선정된 핵심 기능에 따라 유연하게 조정)
+
+[핵심 지침]
+1. 완전히 한국어로만 작성할 것
+2. 소제목은 최대 30자 이내로 간결하게 작성
+3. 선정된 핵심 기능의 중요 측면을 명확히 드러내는 표현 사용 (예: "정밀 측정 실험으로 본 성능 한계", "일상 환경에서의 기능 안정성 분석")
+4. 기술적 정확성과 심층적 분석이 소제목에 반영되도록 구성
+5. 키워드는 소제목 결정에 영향을 주지 않음 (본문 작성 시 참고사항으로만 활용)
+6. 본론 5개 항목만으로 구성 (도입부와 결론 불필요)
+7. 다양한 제품 카테고리의 단일 기능 분석에 유연하게 적용할 수 있도록 구성
+8. 특수문자(**, :, #, ## 등)를 사용하지 말고 일반 텍스트로만 작성하세요.
+
+[출력 형식]
+1. 참고 자료 분석을 통해 선정된 핵심 기능의 5가지 중요 측면을 파악하여 자유롭게 아웃라인 구성
+2. 반드시 본론 5개 항목으로만 구성할 것:(각 항목당 1번 엔터를 적용하여 빈칸이 나오지 않도록하라.)
+ - 본론1: [핵심 기능의 기술적 원리/작동 메커니즘 관련 제목]
+ - 본론2: [핵심 기능의 성능/측정 데이터 관련 제목]
+ - 본론3: [사용자 경험 측면의 기능 평가 관련 제목]
+ - 본론4: [경쟁 제품과의 기능 비교 관련 제목]
+ - 본론5: [실생활 활용 가치/한계점 관련 제목]
+3. 소제목은 선정된 핵심 기능의 특성에 맞게 자유롭게 구성
+4. 키워드에 맞추지 말고, 참고 자료 분석을 통해 발견한 핵심 기능의 중요 측면 기반으로 구성
+5. 예시 형식 (참고용일 뿐, 내용은 선정된 핵심 기능과 참고 자료에 따라 완전히 달라질 수 있음):
+ - 본론1: [핵심 기능의 기술적 원리/메커니즘 관련 제목]
+ - 본론2: [실측 테스트 결과/성능 데이터 관련 제목]
+ - 본론3: [실사용 환경에서의 사용성/효율성 관련 제목]
+ - 본론4: [타 제품 동일 기능과의 차별점 관련 제목]
+ - 본론5: [기능의 미래 발전 가능성/개선점 관련 제목]
+
+{style_prompt}
+"""
+        
+        # Gemini API 호출
+        outline_result = call_gemini_api(extract_prompt, temperature=0.3)
+        
+        # 결과에서 핵심기능 추출
+        features = []
+        for line in outline_result.strip().split('\n'):
+            if line.strip():
+                # 특수문자와 불필요한 형식 제거
+                clean_feature = re.sub(r'^\s*[-*#]\s*', '', line)  # 번호, 불릿 제거
+                clean_feature = re.sub(r'\*\*|\*|##|#', '', clean_feature)  # 특수문자 제거
+                clean_feature = clean_feature.strip()
+                
+                if clean_feature:
+                    features.append(clean_feature)
+        
+        # 5개가 안 되면 빈 값으로 채우기
+        while len(features) < 5:
+            features.append(f"특징 {len(features) + 1} - 추가 설명 필요")
+            
+        return features[:5]  # 최대 5개만 반환
+    
+    except Exception as e:
+        logging.error(f"핵심기능 선별 중 오류 발생: {str(e)}")
+        return ["특징을 추출하지 못했습니다"] * 5
+
+def generate_blog_post(category, style, references1, references2, references3, selected_feature):
+    """핵심기능집중형 블로그 글 생성 함수 - 유연한 소재 구성"""
+    try:
+        # 참고글 준비
+        references = [
+            references1.strip() if references1.strip() else "참고 자료 없음",
+            references2.strip() if references2.strip() else "참고 자료 없음",
+            references3.strip() if references3.strip() else "참고 자료 없음"
+        ]
+        
+        # 의미 있는 참고글만 필터링
+        references = [ref for ref in references if ref != "참고 자료 없음"]
+        
+        if not references:
+            return "<p>참고 자료가 없습니다. 최소 하나 이상의 참고 자료를 입력해주세요.</p>"
+            
+        if not selected_feature.strip():
+            return "<p>핵심기능이 선택되지 않았습니다. 핵심기능을 입력해주세요.</p>"
+            
+        # 스타일 프롬프트 가져오기
+        style_prompt = get_style_prompt(style)
+        
+        # 블로그 글 생성 프롬프트 구성
+        blog_prompt = f"""
+[핵심기능 집중형 상품리뷰 작성 요청]
+선택한 핵심기능: {selected_feature}
+
+[리뷰 작성 형식]
+1. 리뷰는 '도입부', '5가지 소재', '마무리' 구조로 작성하세요.
+2. 마크다운 형식은 최소한으로 사용하고, 가능한 한 일반 텍스트로 작성하세요.
+3. 각 부분은 명확히 구분되어야 하며, 서술형 문장으로 자연스럽게 이어지도록 작성하세요.
+4. 단락은 적절히 나누되, 너무 짧은 단락을 많이 만들지 마세요.
+
+[리뷰 내용 구조]
+1. 도입부 (전체의 10%)
+   - 선택한 핵심기능의 중요성과 특징을 간략히 소개
+   - 이 기능이 상품에서 어떤 가치를 제공하는지 설명
+   - 마지막 문장에서 본문에서 다룰 내용을 예고
+
+2. 5가지 소재 (전체의 80%)
+   - 선택한 핵심기능에 가장 적합한 5가지 소재를 자유롭게 선정하세요
+   - 각 소재는 기능의 서로 다른 측면을 다루어야 합니다
+   - 예시 소재: 기술적 원리, 작동 방식, 성능 분석, 경쟁 제품 비교, 활용 방법, 사용 경험, 설정 팁, 
+     업데이트 이력, 산업 표준과의 비교, 사용 시나리오, 호환성, 한계점과 개선 방향 등
+   - 각 소재는 비슷한 분량으로 자연스럽게 연결되어야 합니다
+
+3. 마무리 (전체의 10%)
+   - 이 기능의 종합적 평가와 가치
+   - 어떤 유형의 사용자에게 특히 유용한지
+   - 핵심기능과 제품 전체에 대한 최종 견해
+
+[중요 작성 지침]
+1. 전체 글은 최소 4000자 이상으로 작성하세요.
+2. 각 소재는 최소 600자 이상 작성하고, 서로 유기적으로 연결되게 하세요.
+3. 제목은 따로 사용하지 말고, 도입부, 소재, 마무리를 하나의 연결된 글로 작성하세요.
+4. 기술적 정확성을 유지하면서 선택한 핵심기능에 대한 심층적 분석과 구체적인 정보를 제공하세요.
+5. 마케팅적 과장 표현보다는 사실적이고 분석적인 표현을 사용하세요.
+6. 불필요한 반복이나 장황한 설명은 피하고, 핵심 정보와 통찰을 강조하세요.
+7. 전체 글의 일관성을 유지하고, 문단 간 자연스러운 흐름을 만드세요.
+8. 소재는 핵심기능의 성격에 맞게 가장 적절한 것을 자유롭게 선정하세요.
+
+참고글:
+{references[0]}
+{references[1] if len(references) > 1 else ""}
+{references[2] if len(references) > 2 else ""}
+
+{style_prompt}
+"""
+
+        # Gemini API 호출
+        logging.info("핵심기능 집중형 블로그 글 생성 시작")
+        blog_content = call_gemini_api(blog_prompt, temperature=0.7)
+        logging.info(f"생성된 원본 글 길이: {len(blog_content)}")
+        
+        # 후처리
+        processed_content = post_process_blog(blog_content, style)
+        
+        # 글자 수 체크
+        char_count = len(processed_content)
+        logging.info(f"처리 후 블로그 글 글자 수: {char_count}")
+        
+        # 글자 수가 목표에 미달하면 확장 시도
+        if char_count < TARGET_CHAR_LENGTH:
+            logging.info(f"글자 수 부족 ({char_count} < {TARGET_CHAR_LENGTH}), 확장 시도")
+            
+            expansion_prompt = f"""
+[핵심기능 분석 확장 요청]
+현재 글은 목표 글자수인 4000자에 미치지 못합니다. 현재 글자수는 약 {char_count}자입니다.
+선택한 핵심기능: {selected_feature}
+
+[확장 지침]
+1. 원래 글의 구조(도입부, 5가지 소재, 마무리)를 유지하면서 내용을 확장하세요.
+2. 각 소재에 더 구체적인 정보, 예시, 분석 내용을 추가하세요.
+3. 서술적 흐름을 유지하고, 불필요한 마크다운 사용은 피하세요.
+4. 글의 전체 일관성과 응집성을 유지하세요.
+
+원본 글:
+{processed_content}
+"""
+            
+            # 확장 시도
+            expanded_content = call_gemini_api(expansion_prompt, temperature=0.75)
+            processed_content = post_process_blog(expanded_content, style)
+            
+            # 다시 글자 수 체크
+            char_count = len(processed_content)
+            logging.info(f"확장 후 블로그 글 글자 수: {char_count}")
+        
+        # HTML 변환
+        final_html = convert_to_html(processed_content)
+        
+        return final_html
+            
+    except Exception as e:
+        logging.error(f"블로그 글 생성 중 오류 발생: {str(e)}")
+        return f"<p>블로그 글 생성 중 오류 발생: {str(e)}</p>"
+
+def get_style_prompt(style="친근한"):
+    """블로그 글의 스타일 프롬프트를 반환"""
+    prompts = {
+        "친근한": """
+[친근한 핵심기능 리뷰 스타일 가이드]
+1. 톤과 어조
+  - 대화하듯 편안하고 친근한 말투 사용 (예: "오늘은 ~에 대해 알아볼게요")
+  - 1인칭 시점으로 직접 사용한 경험을 생생하게 표현
+  - 구어체와 일상적인 표현 사용하여 친근함 유지
+
+2. 문장 및 어투
+   - '해요체'로 작성 (예: "~했어요", "~인 것 같아요")
+   - 문장은 길지 않게 자연스럽게 연결
+   - 기술적 내용도 쉽고 이해하기 편한 표현으로 설명
+
+3. 정보 전달 방식
+   - 개인 경험과 체감을 중심으로 정보 전달
+   - 전문적인 내용도 일상적인 비유와 예시로 풀어서 설명
+   - "제가 사용해보니~", "실제로 경험해보면~"과 같은 표현 활용
+   - 독자에게 직접 말하듯 중간중간 "~하시면 좋아요" 같은 조언 추가
+""",
+        "일반": """
+[일반적인 핵심기능 리뷰 스타일 가이드]
+1. 톤과 어조
+   - 객관적이고 중립적인 톤 유지
+   - 직접적인 경험과 객관적 데이터를 균형 있게 활용
+   - 존댓말 사용하되 딱딱하지 않게 표현
+
+2. 문장 및 어투
+   - '합니다체' 사용 (예: "~합니다", "~입니다")
+   - 명확하고 간결한 문장 구성
+   - 내용의 논리적 흐름을 중시
+
+3. 정보 전달 방식
+   - 사실과 데이터를 중심으로 내용 전개
+   - 개인 경험과 객관적 분석을 적절히 혼합
+   - 불필요한 과장이나 주관적 평가 최소화
+   - 실용적인 관점에서 기능의 장단점 균형있게 서술
+""",
+        "전문적인": """
+[전문적인 핵심기능 리뷰 스타일 가이드]
+1. 톤과 어조
+   - 전문적이고 분석적인 톤 사용
+   - 기술적 깊이와 정확성 강조
+   - 존중과 권위를 느낄 수 있는 표현 사용
+
+2. 문장 및 어투
+   - '합니다체'로 일관성 있게 작성
+   - 논리적이고 체계적인 문장 구성
+   - 전문 용어를 적절히 활용하되 필요시 간략한 설명 제공
+
+3. 정보 전달 방식
+   - 기술적 원리와 메커니즘에 대한 심층 분석
+   - 벤치마크 데이터와 구체적 수치를 활용한 객관적 평가
+   - 경쟁 제품과의 세부적인 기술 비교 제공
+   - 기능의 기술적 한계와 발전 가능성에 대한 통찰 제시
+"""
+    }
+    return prompts.get(style, prompts["친근한"])
+
+def call_gemini_api(prompt, temperature=TEMPERATURE, top_p=TOP_P):
+    """Gemini API 호출 함수"""
+    try:
+        logging.info("Gemini API 호출 시작")
+        response = client.models.generate_content(
+            model="gemini-2.0-flash",
+            contents=[prompt],
+            config=types.GenerateContentConfig(
+                max_output_tokens=MAX_TOKENS,
+                temperature=temperature,
+                top_p=top_p
+            )
+        )
+        logging.info("Gemini API 호출 완료")
+        return response.text.strip()
+    except Exception as e:
+        logging.error(f"Gemini API 호출 중 오류 발생: {str(e)}")
+        return f"API 호출 중 오류 발생: {str(e)}"
+
+# API 함수들
+def generate_outline_4(category, style, ref1, ref2, ref3):
+    features = generate_outline(category, style, ref1, ref2, ref3)
+    # 3개의 문자열 튜플 반환
+    return (features[0], features[1], features[2])
+
+def generate_blog_post_4(category, style, ref1, ref2, ref3, outline):
+    # outline은 선택된 핵심기능 이름
+    return generate_blog_post(category, style, ref1, ref2, ref3, outline)