Update app.py

app.py

@@ -81,7 +81,7 @@ BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
 
 @dataclass
 class ConversationConfig:
-    max_words: int = 4000
+    max_words: int = 6000  # 4000에서 6000으로 증가 (1.5배)
     prefix_url: str = "https://r.jina.ai/"
     api_model_name: str = "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo"
     legacy_local_model_name: str = "NousResearch/Hermes-2-Pro-Llama-3-8B"
@@ -89,8 +89,10 @@ class ConversationConfig:
     local_model_name: str = "Private-BitSix-Mistral-Small-3.1-24B-Instruct-2503.gguf"
     local_model_repo: str = "ginigen/Private-BitSix-Mistral-Small-3.1-24B-Instruct-2503"
     # 토큰 수 증가
-    max_tokens: int = 3000  # 2048에서 6000으로 증가
-    max_new_tokens: int = 6000  # 4000에서 8000으로 증가
+    max_tokens: int = 4500  # 3000에서 4500으로 증가 (1.5배)
+    max_new_tokens: int = 9000  # 6000에서 9000으로 증가 (1.5배)
+    min_conversation_turns: int = 12  # 최소 대화 턴 수
+    max_conversation_turns: int = 15  # 최대 대화 턴 수
 
 
 def brave_search(query: str, count: int = 8, freshness_days: int | None = None):
@@ -119,20 +121,28 @@ def brave_search(query: str, count: int = 8, freshness_days: int | None = None):
         logging.error(f"Brave search error: {e}")
         return []
 
-def format_search_results(query: str) -> str:
-    """검색 결과를 포맷팅하여 반환 (간략하게)"""
-    rows = brave_search(query, 3, freshness_days=3)  # 6개에서 3개로 줄임
+def format_search_results(query: str, for_keyword: bool = False) -> str:
+    """검색 결과를 포맷팅하여 반환"""
+    # 키워드 검색의 경우 더 많은 결과 사용
+    count = 5 if for_keyword else 3
+    rows = brave_search(query, count, freshness_days=7 if not for_keyword else None)
     if not rows:
-        return ""  # 빈 문자열 반환
+        return ""
     
-    # 검색 결과를 더 간략하게 요약
     results = []
-    for r in rows[:2]:  # 최대 2개만 사용
-        # 스니펫을 100자로 제한
-        snippet = r['snippet'][:100] + "..." if len(r['snippet']) > 100 else r['snippet']
-        results.append(f"- {r['title']}: {snippet}")
+    # 키워드 검색의 경우 더 상세한 정보 포함
+    max_results = 4 if for_keyword else 2
+    for r in rows[:max_results]:
+        if for_keyword:
+            # 키워드 검색은 더 긴 스니펫 사용
+            snippet = r['snippet'][:200] + "..." if len(r['snippet']) > 200 else r['snippet']
+            results.append(f"**{r['title']}**\n{snippet}\nSource: {r['host']}")
+        else:
+            # 일반 검색은 짧은 스니펫
+            snippet = r['snippet'][:100] + "..." if len(r['snippet']) > 100 else r['snippet']
+            results.append(f"- {r['title']}: {snippet}")
     
-    return "\n".join(results) + "\n"
+    return "\n\n".join(results) + "\n"
 
 def extract_keywords_for_search(text: str, language: str = "English") -> List[str]:
     """텍스트에서 검색할 키워드 추출 (개선)"""
@@ -157,6 +167,47 @@ def extract_keywords_for_search(text: str, language: str = "English") -> List[st
             return [max(keywords, key=len)]  # 가장 긴 단어 1개
         return []
 
+def search_and_compile_content(keyword: str, language: str = "English") -> str:
+    """키워드로 검색하여 콘텐츠 컴파일"""
+    if not BRAVE_KEY:
+        return f"Search API not available. Using keyword: {keyword}"
+    
+    # 언어에 따른 검색 쿼리 조정
+    if language == "Korean":
+        queries = [
+            f"{keyword} 최신 뉴스",
+            f"{keyword} 정보",
+            f"{keyword} 트렌드 2024"
+        ]
+    else:
+        queries = [
+            f"{keyword} latest news",
+            f"{keyword} explained",
+            f"{keyword} trends 2024"
+        ]
+    
+    all_content = []
+    
+    for query in queries:
+        results = brave_search(query, count=3)
+        for r in results[:2]:  # 각 쿼리당 상위 2개 결과
+            content = f"**{r['title']}**\n{r['snippet']}\n"
+            all_content.append(content)
+    
+    if not all_content:
+        return f"No search results found for: {keyword}"
+    
+    # 컴파일된 콘텐츠 반환
+    compiled = "\n\n".join(all_content)
+    
+    # 키워드 기반 소개 추가
+    if language == "Korean":
+        intro = f"'{keyword}'에 대한 최신 정보와 트렌드:\n\n"
+    else:
+        intro = f"Latest information and trends about '{keyword}':\n\n"
+    
+    return intro + compiled
+
 class UnifiedAudioConverter:
     def __init__(self, config: ConversationConfig):
         self.config = config
@@ -310,16 +361,25 @@ class UnifiedAudioConverter:
 
 
     def _build_prompt(self, text: str, language: str = "English", search_context: str = "") -> str:
-        """Build prompt for conversation generation with search context"""
-            # 텍스트 길이 제한을 더 강하게 적용
-        max_text_length = 3000 if search_context else 4000
+        """Build prompt for conversation generation with enhanced radio talk show style"""
+        # 텍스트 길이 제한
+        max_text_length = 4500 if search_context else 6000
         if len(text) > max_text_length:
             text = text[:max_text_length] + "..."
         
         if language == "Korean":
+            # 대화 템플릿을 더 많은 턴으로 확장
             template = """
             {
                 "conversation": [
+                    {"speaker": "준수", "text": ""},
+                    {"speaker": "민호", "text": ""},
+                    {"speaker": "준수", "text": ""},
+                    {"speaker": "민호", "text": ""},
+                    {"speaker": "준수", "text": ""},
+                    {"speaker": "민호", "text": ""},
+                    {"speaker": "준수", "text": ""},
+                    {"speaker": "민호", "text": ""},
                     {"speaker": "준수", "text": ""},
                     {"speaker": "민호", "text": ""},
                     {"speaker": "준수", "text": ""},
@@ -328,7 +388,6 @@ class UnifiedAudioConverter:
             }
             """
             
-            # 검색 컨텍스트가 있을 때만 포함
             context_part = ""
             if search_context:
                 context_part = f"# 최신 관련 정보:\n{search_context}\n"
@@ -336,22 +395,38 @@ class UnifiedAudioConverter:
             base_prompt = (
                 f"# 원본 콘텐츠:\n{text}\n\n"
                 f"{context_part}"
-                f"위 내용으로 한국어 팟캐스트 대화를 만들어주세요.\n\n"
+                f"위 내용으로 라디오 대담 프로그램 대본을 작성해주세요.\n\n"
                 f"## 핵심 지침:\n"
-                f"- 준수(진행자)와 민호(전문가) 두 30대 남성의 대화\n"
-                f"- 서로 존댓말 사용 필수 (반말 절대 금지)\n"
-                f"- 자연스러운 한국어 표현 사용\n"
-                f"- 각 대화 2-3문장, 전체 8-10회 주고받기\n"
-                f"- 최신 정보가 있다면 자연스럽게 포함\n\n"
+                f"1. **대화 스타일**: 실제 라디오 대담처럼 아주 자연스럽고 편안한 구어체 사용\n"
+                f"2. **화자 역할**:\n"
+                f"   - 준수: 진행자/호스트 (주로 질문하고 대화를 이끌어감)\n"
+                f"   - 민호: 전문가 (질문에 답하고 설명함)\n"
+                f"3. **대화 패턴**:\n"
+                f"   - 준수는 주로 짧은 질문이나 리액션 (\"아, 그렇군요\", \"흥미롭네요\", \"그럼 ~는 어떤가요?\")\n"
+                f"   - 민호는 1-2문장으로 간결하게 답변\n"
+                f"   - 절대 한 사람이 3문장 이상 연속으로 말하지 않음\n"
+                f"4. **자연스러움**:\n"
+                f"   - \"음...\", \"아...\", \"네,\" 같은 추임새 사용\n"
+                f"   - 때로는 상대방 말에 짧게 반응 (\"맞아요\", \"그렇죠\")\n"
+                f"5. **필수 규칙**: 서로 존댓말 사용, 12-15회 대화 교환\n\n"
                 f"JSON 형식으로만 반환:\n{template}"
             )
             
             return base_prompt
             
         else:
+            # 영어 템플릿도 확장
             template = """
             {
                 "conversation": [
+                    {"speaker": "Alex", "text": ""},
+                    {"speaker": "Jordan", "text": ""},
+                    {"speaker": "Alex", "text": ""},
+                    {"speaker": "Jordan", "text": ""},
+                    {"speaker": "Alex", "text": ""},
+                    {"speaker": "Jordan", "text": ""},
+                    {"speaker": "Alex", "text": ""},
+                    {"speaker": "Jordan", "text": ""},
                     {"speaker": "Alex", "text": ""},
                     {"speaker": "Jordan", "text": ""},
                     {"speaker": "Alex", "text": ""},
@@ -367,13 +442,20 @@ class UnifiedAudioConverter:
             base_prompt = (
                 f"# Content:\n{text}\n\n"
                 f"{context_part}"
-                f"Create a podcast conversation.\n\n"
-                f"Guidelines:\n"
-                f"- Alex (Host) and Jordan (Expert)\n"
-                f"- Natural conversational English\n"
-                f"- Each response 2-3 sentences\n"
-                f"- 8-10 exchanges total\n"
-                f"- Include latest info if available\n\n"
+                f"Create a natural radio talk show conversation.\n\n"
+                f"## Key Guidelines:\n"
+                f"1. **Style**: Natural, conversational English like a real radio show\n"
+                f"2. **Roles**:\n"
+                f"   - Alex: Host (asks questions, guides conversation)\n"
+                f"   - Jordan: Expert (answers, explains)\n"
+                f"3. **Pattern**:\n"
+                f"   - Alex mostly asks short questions or reacts (\"I see\", \"Interesting\", \"What about...?\")\n"
+                f"   - Jordan gives brief 1-2 sentence answers\n"
+                f"   - Never more than 2-3 sentences per turn\n"
+                f"4. **Natural flow**:\n"
+                f"   - Use fillers like \"Well,\" \"You know,\" \"Actually,\"\n"
+                f"   - Short reactions (\"Right\", \"Exactly\")\n"
+                f"5. **Length**: 12-15 exchanges total\n\n"
                 f"Return JSON only:\n{template}"
             )
             
@@ -382,27 +464,30 @@ class UnifiedAudioConverter:
 
 
     def _build_messages_for_local(self, text: str, language: str = "English", search_context: str = "") -> List[Dict]:
-        """Build messages for local LLM with enhanced Korean guidelines"""
+        """Build messages for local LLM with enhanced radio talk show style"""
         if language == "Korean":
             system_message = (
-                "당신은 한국 최고의 팟캐스트 대본 전문 작가입니다. "
-                "한국인의 정서와 문화를 완벽히 이해하고, 30대 한국인 청취자들이 끝까지 집중할 수 있는 "
-                "매력적이고 유익한 대화를 만들어냅니다.\n\n"
+                "당신은 한국 최고의 라디오 대담 프로그램 작가입니다. "
+                "실제 라디오 방송처럼 자연스럽고 생동감 있는 대화를 만들어냅니다.\n\n"
                 "핵심 원칙:\n"
-                "1. 두 화자는 반드시 서로에게 존댓말을 사용합니다 (반말 절대 금지)\n"
-                "2. 한국 문화의 정서적 코드와 가치관을 자연스럽게 반영합니다\n"
-                "3. 실제 한국인들이 일상에서 사용하는 자연스러운 표현을 구사합니다\n"
-                "4. 청취자가 공감하고 실용적으로 활용할 수 있는 내용을 제공합니다\n"
-                "5. 최신 정보와 트렌드를 적절히 반영하여 시의성을 확보합니다\n\n"
-                "당신의 대본은 한국 팟캐스트 시장에서 최고 수준의 품질로 인정받고 있습니다."
+                "1. 라디오 진행자(준수)는 주로 짧은 질문과 리액션으로 대화를 이끌어갑니다\n"
+                "2. 전문가(민호)는 질문에 간결하고 이해하기 쉽게 답합니다\n"
+                "3. 한 번에 너무 많은 정보를 전달하지 않고, 대화를 통해 점진적으로 풀어갑니다\n"
+                "4. \"음...\", \"아...\", \"네,\" 등 자연스러운 구어체 표현을 사용합니다\n"
+                "5. 청취자가 라디오를 듣는 것처럼 몰입할 수 있도록 생생하게 작성합니다\n"
+                "6. 반드시 서로 존댓말을 사용하며, 정중하면서도 친근한 톤을 유지합니다"
             )
         else:
             system_message = (
-                "You are an expert podcast scriptwriter who creates engaging, "
-                "natural conversations that keep listeners hooked. "
-                "You understand how to balance information with entertainment, "
-                "using real conversational patterns and authentic reactions. "
-                "You excel at incorporating current information and trends to make content relevant and timely."
+                "You are an expert radio talk show scriptwriter who creates engaging, "
+                "natural conversations that sound like real radio broadcasts.\n\n"
+                "Key principles:\n"
+                "1. The host (Alex) mainly asks short questions and gives reactions to guide the conversation\n"
+                "2. The expert (Jordan) answers concisely and clearly\n"
+                "3. Information is revealed gradually through dialogue, not in long monologues\n"
+                "4. Use natural speech patterns with fillers like 'Well,' 'You know,' etc.\n"
+                "5. Make it sound like an actual radio show that listeners would enjoy\n"
+                "6. Keep each turn brief - no more than 2-3 sentences"
             )
         
         return [
@@ -412,15 +497,14 @@ class UnifiedAudioConverter:
 
     @spaces.GPU(duration=120)
     def extract_conversation_local(self, text: str, language: str = "English", progress=None) -> Dict:
-        """Extract conversation using new local LLM with search context"""
+        """Extract conversation using new local LLM with enhanced search and style"""
         try:
-            # 검색 컨텍스트 생성
+            # 검색 컨텍스트 생성 (키워드 기반이 아닌 경우)
             search_context = ""
-            if BRAVE_KEY:
+            if BRAVE_KEY and not text.startswith("Keyword-based content:"):
                 try:
                     keywords = extract_keywords_for_search(text, language)
                     if keywords:
-                        # 첫 번째 키워드로 검색
                         search_query = keywords[0] if language == "Korean" else f"{keywords[0]} latest news"
                         search_context = format_search_results(search_query)
                         print(f"Search context added for: {search_query}")
@@ -433,26 +517,31 @@ class UnifiedAudioConverter:
             chat_template = self._get_messages_formatter_type(self.config.local_model_name)
             provider = LlamaCppPythonProvider(self.local_llm)
 
-            # 강화된 언어별 시스템 메시지
+            # 강화된 라디오 스타일 시스템 메시지
             if language == "Korean":
                 system_message = (
-                    "당신은 한국어 팟캐스트 전문 작가입니다. "
-                    "한국 청취자들의 문화적 맥락과 언어적 특성을 완벽히 이해하고, "
-                    "자연스럽고 매력적인 대본을 작성합니다. "
-                    "특히 두 화자가 서로에게 존댓말을 사용하는 것이 필수이며, "
-                    "반말은 절대 사용하지 않습니다. "
-                    "실제 한국인이 대화하는 것처럼 자연스러운 표현, 적절한 감탄사, "
-                    "문화적으로 적합한 예시를 사용하여 청취자가 공감하고 몰입할 수 있는 "
-                    "대화를 만들어주세요. 최신 정보도 자연스럽게 반영하세요. JSON 형식으로만 응답하세요."
+                    "당신은 한국의 인기 라디오 대담 프로그램 전문 작가입니다. "
+                    "청취자들이 실제 라디오를 듣는 것처럼 몰입할 수 있는 자연스러운 대화를 만듭니다.\n\n"
+                    "작성 규칙:\n"
+                    "1. 진행자(준수)는 주로 짧은 질문으로 대화를 이끌어가세요 (\"그렇군요\", \"어떤 점이 특별한가요?\", \"청취자분들이 궁금해하실 것 같은데요\")\n"
+                    "2. 전문가(민호)는 1-2문장으로 간결하게 답변하세요\n"
+                    "3. 절대 한 사람이 3문장 이상 연속으로 말하지 마세요\n"
+                    "4. 구어체와 추임새를 자연스럽게 사용하세요\n"
+                    "5. 반드시 서로 존댓말을 사용하세요\n"
+                    "6. 12-15회의 대화 교환으로 구성하세요\n"
+                    "7. JSON 형식으로만 응답하세요"
                 )
             else:
                 system_message = (
-                    "You are an expert podcast scriptwriter specializing in creating "
-                    "engaging, natural conversations that captivate listeners. "
-                    "You excel at transforming complex information into accessible, "
-                    "entertaining dialogue while maintaining authenticity and educational value. "
-                    "Incorporate current trends and latest information naturally. "
-                    "Respond only in JSON format."
+                    "You are a professional radio talk show scriptwriter creating engaging, "
+                    "natural conversations that sound like real radio broadcasts.\n\n"
+                    "Writing rules:\n"
+                    "1. Host (Alex) mainly asks short questions to guide the conversation (\"I see\", \"What makes it special?\", \"Our listeners might wonder...\")\n"
+                    "2. Expert (Jordan) answers in 1-2 concise sentences\n"
+                    "3. Never have one person speak more than 2-3 sentences at once\n"
+                    "4. Use natural speech patterns and fillers\n"
+                    "5. Create 12-15 conversation exchanges\n"
+                    "6. Respond only in JSON format"
                 )
 
             agent = LlamaCppAgent(
@@ -463,7 +552,7 @@ class UnifiedAudioConverter:
             )
             
             settings = provider.get_provider_default_settings()
-            settings.temperature = 0.8  # 약간 높여서 더 자연스러운 대화 생성
+            settings.temperature = 0.85  # 약간 높여서 더 자연스러운 대화 생성
             settings.top_k = 40
             settings.top_p = 0.95
             settings.max_tokens = self.config.max_tokens  # 증가된 토큰 수 사용
@@ -486,7 +575,12 @@ class UnifiedAudioConverter:
             json_match = re.search(pattern, response)
             
             if json_match:
-                return json.loads(json_match.group())
+                conversation_data = json.loads(json_match.group())
+                # 대화 길이 확인 및 조정
+                if len(conversation_data["conversation"]) < self.config.min_conversation_turns:
+                    print(f"Conversation too short ({len(conversation_data['conversation'])} turns), regenerating...")
+                    # 재시도 로직 추가 가능
+                return conversation_data
             else:
                 raise ValueError("No valid JSON found in local LLM response")
                 
@@ -496,24 +590,24 @@ class UnifiedAudioConverter:
 
     @spaces.GPU(duration=120)
     def extract_conversation_legacy_local(self, text: str, language: str = "English", progress=None, search_context: str = "") -> Dict:
-        """Extract conversation using legacy local model (fallback)"""
+        """Extract conversation using legacy local model with enhanced style"""
         try:
             self.initialize_legacy_local_mode()
             
-            # 강화된 언어별 시스템 메시지
+            # 강화된 라디오 스타일 시스템 메시지
             if language == "Korean":
                 system_message = (
-                    "당신은 한국어 팟캐스트 전문 작가입니다. "
-                    "30대 한국인 청취자를 대상으로 자연스럽고 흥미로운 대화를 만들어주세요. "
-                    "두 화자는 반드시 서로에게 존댓말을 사용하며, 반말은 절대 사용하지 않습니다. "
-                    "실제 사용하는 한국어 표현과 문화적 맥락을 반영하여 작성해주세요. "
-                    "최신 정보도 자연스럽게 포함시켜주세요."
+                    "당신은 라디오 대담 프로그램 작가입니다. "
+                    "진행자(준수)는 짧은 질문으로, 전문가(민호)는 간결한 답변으로 "
+                    "자연스러운 대화를 만드세요. 서로 존댓말을 사용하고, "
+                    "한 번에 2-3문장 이내로 말하세요. 12-15회 대화 교환으로 구성하세요."
                 )
             else:
                 system_message = (
-                    "You are an expert podcast scriptwriter. "
-                    "Create natural, engaging conversations that inform and entertain listeners. "
-                    "Incorporate current information and trends naturally."
+                    "You are a radio talk show scriptwriter. "
+                    "Create natural dialogue where the host (Alex) asks short questions "
+                    "and the expert (Jordan) gives brief answers. "
+                    "Keep each turn to 2-3 sentences max. Create 12-15 exchanges."
                 )
 
             chat = [
@@ -540,7 +634,7 @@ class UnifiedAudioConverter:
                 streamer=streamer,
                 max_new_tokens=self.config.max_new_tokens,  # 증가된 토큰 수 사용
                 do_sample=True,
-                temperature=0.9,
+                temperature=0.85,
                 eos_token_id=terminators,
             )
 
@@ -561,35 +655,59 @@ class UnifiedAudioConverter:
                 
         except Exception as e:
             print(f"Legacy local model also failed: {e}")
-            # Return default template with Korean male names using formal speech
+            # Return enhanced default template
             if language == "Korean":
-                return {
-                    "conversation": [
-                        {"speaker": "준수", "text": "안녕하세요, 여러분! 오늘도 저희 팟캐스트를 찾아주셔서 정말 감사합니다. 민호씨, 오늘 정말 흥미로운 주제를 준비해주셨다고 들었어요."},
-                        {"speaker": "민호", "text": "네, 안녕하세요! 준수씨 말씀처럼 오늘은 정말 흥미로운 이야기를 준비했습니다. 청취자 여러분들께서도 많은 관심을 가지고 계실 주제인 것 같아요."},
-                        {"speaker": "준수", "text": "정말 기대되는데요. 그런데 민호씨, 이 주제가 요즘 왜 이렇게 화제가 되고 있는 건가요? 청취자 여러분들도 궁금해하실 것 같아요."},
-                        {"speaker": "민호", "text": "좋은 질문이세요, 준수씨. 사실 최근에 이 분야에 많은 변화가 있었거든요. 그럼 본격적으로 하나씩 차근차근 설명해드릴게요."}
-                    ]
-                }
+                return self._get_default_korean_conversation()
             else:
-                return {
-                    "conversation": [
-                        {"speaker": "Alex", "text": "Welcome everyone to our podcast! We have an fascinating topic to discuss today."},
-                        {"speaker": "Jordan", "text": "Thanks for having me, Alex. I'm excited to dive into this subject with our listeners."},
-                        {"speaker": "Alex", "text": "So let's get started. Can you give us an overview of what we'll be covering?"},
-                        {"speaker": "Jordan", "text": "Absolutely! Today we'll explore some really interesting aspects that I think will surprise many people."}
-                    ]
-                }
+                return self._get_default_english_conversation()
+
+    def _get_default_korean_conversation(self) -> Dict:
+        """더 긴 기본 한국어 대화 템플릿"""
+        return {
+            "conversation": [
+                {"speaker": "준수", "text": "안녕하세요, 여러분! 오늘도 저희 팟캐스트를 찾아주셔서 정말 감사합니다."},
+                {"speaker": "민호", "text": "네, 안녕하세요! 오늘 정말 흥미로운 주제를 준비했습니다."},
+                {"speaker": "준수", "text": "아, 그래요? 어떤 내용인지 정말 궁금한데요?"},
+                {"speaker": "민호", "text": "오늘은 최근 많은 분들이 관심을 가지고 계신 주제에 대해 이야기해볼까 해요."},
+                {"speaker": "준수", "text": "음, 요즘 정말 화제가 되고 있죠. 구체적으로 어떤 측면을 다룰 예정이신가요?"},
+                {"speaker": "민호", "text": "네, 먼저 기본적인 개념부터 차근차근 설명드리고, 실생활에 어떻게 적용할 수 있는지 알아볼게요."},
+                {"speaker": "준수", "text": "좋아요! 청취자분들도 이해하기 쉽게 설명해주실 거죠?"},
+                {"speaker": "민호", "text": "물론이죠. 최대한 쉽고 재미있게 풀어서 설명드릴게요."},
+                {"speaker": "준수", "text": "그럼 본격적으로 시작해볼까요?"},
+                {"speaker": "민호", "text": "네, 좋습니다. 우선 이 주제가 왜 중요한지부터 말씀드릴게요."},
+                {"speaker": "준수", "text": "아, 맞아요. 그 부분이 정말 중요하죠."},
+                {"speaker": "민호", "text": "최근 연구 결과를 보면 정말 놀라운 발견들이 많았어요."}
+            ]
+        }
+
+    def _get_default_english_conversation(self) -> Dict:
+        """Enhanced default English conversation template"""
+        return {
+            "conversation": [
+                {"speaker": "Alex", "text": "Welcome everyone to our podcast! We have a fascinating topic today."},
+                {"speaker": "Jordan", "text": "Thanks, Alex. I'm excited to dive into this subject with our listeners."},
+                {"speaker": "Alex", "text": "So, what makes this topic particularly relevant right now?"},
+                {"speaker": "Jordan", "text": "Well, there have been some significant developments recently that everyone should know about."},
+                {"speaker": "Alex", "text": "Interesting! Can you break it down for us?"},
+                {"speaker": "Jordan", "text": "Absolutely. Let me start with the basics and build from there."},
+                {"speaker": "Alex", "text": "That sounds perfect. Our listeners will appreciate that approach."},
+                {"speaker": "Jordan", "text": "So, first, let's understand what we're really talking about here."},
+                {"speaker": "Alex", "text": "Right, the fundamentals are crucial."},
+                {"speaker": "Jordan", "text": "Exactly. And once we grasp that, the rest becomes much clearer."},
+                {"speaker": "Alex", "text": "I'm already learning something new! What's next?"},
+                {"speaker": "Jordan", "text": "Now, here's where it gets really interesting..."}
+            ]
+        }
 
     def extract_conversation_api(self, text: str, language: str = "English") -> Dict:
-        """Extract conversation using API with search context"""
+        """Extract conversation using API with enhanced radio style"""
         if not self.llm_client:
             raise RuntimeError("API mode not initialized")
 
         try:
             # 검색 컨텍스트 생성
             search_context = ""
-            if BRAVE_KEY:
+            if BRAVE_KEY and not text.startswith("Keyword-based content:"):
                 try:
                     keywords = extract_keywords_for_search(text, language)
                     if keywords:
@@ -599,21 +717,24 @@ class UnifiedAudioConverter:
                 except Exception as e:
                     print(f"Search failed, continuing without context: {e}")
 
-            # 강화된 언어별 프롬프트 구성
+            # 강화된 라디오 스타일 프롬프트
             if language == "Korean":
                 system_message = (
-                    "당신은 한국어 팟캐스트 전문 작가입니다. "
-                    "한국 청취자들의 문화적 맥락과 언어적 특성을 완벽히 이해하고, "
-                    "자연스럽고 매력적인 대본을 작성합니다. "
-                    "준수(진행자)와 민호(전문가)라는 두 명의 30대 남성이 서로에게 존댓말을 사용하여 대화하는 형식으로 작성하세요. "
-                    "반말은 절대 사용하지 않으며, 최신 정보도 자연스럽게 반영하세요."
+                    "당신은 한국의 인기 라디오 대담 프로그램 작가입니다. "
+                    "실제 라디오 방송처럼 자연스럽고 편안한 대화를 만드세요.\n"
+                    "준수(진행자)는 주로 짧은 질문과 리액션으로 대화를 이끌고, "
+                    "민호(전문가)는 1-2문장으로 간결하게 답변합니다. "
+                    "구어체와 추임새를 사용하고, 반드시 서로 존댓말을 사용하세요. "
+                    "12-15회의 대화 교환으로 구성하세요."
                 )
             else:
                 system_message = (
-                    "You are an expert podcast scriptwriter who creates engaging, "
-                    "natural conversations between Alex (host) and Jordan (expert). "
-                    "Create informative yet entertaining dialogue that keeps listeners engaged. "
-                    "Incorporate current trends and latest information naturally."
+                    "You are a professional radio talk show scriptwriter. "
+                    "Create natural, engaging dialogue like a real radio broadcast. "
+                    "Alex (host) mainly asks short questions and gives reactions, "
+                    "while Jordan (expert) answers in 1-2 concise sentences. "
+                    "Use conversational language with natural fillers. "
+                    "Create 12-15 conversation exchanges."
                 )
 
             chat_completion = self.llm_client.chat.completions.create(
@@ -622,6 +743,7 @@ class UnifiedAudioConverter:
                     {"role": "user", "content": self._build_prompt(text, language, search_context)}
                 ],
                 model=self.config.api_model_name,
+                temperature=0.85,
             )
 
             pattern = r"\{(?:[^{}]|(?:\{[^{}]*\}))*\}"
@@ -871,18 +993,23 @@ converter = UnifiedAudioConverter(ConversationConfig())
 
 
 async def synthesize(article_input, input_type: str = "URL", mode: str = "Local", tts_engine: str = "Edge-TTS", language: str = "English"):
-    """Main synthesis function - handles both URL and PDF inputs"""
+    """Main synthesis function - handles URL, PDF, and Keyword inputs"""
     try:
         # Extract text based on input type
         if input_type == "URL":
             if not article_input or not isinstance(article_input, str):
                 return "Please provide a valid URL.", None
             text = converter.fetch_text(article_input)
-        else:  # PDF
+        elif input_type == "PDF":
             if not article_input:
                 return "Please upload a PDF file.", None
-            # Gradio returns the file path as a string
             text = converter.extract_text_from_pdf(article_input)
+        else:  # Keyword
+            if not article_input or not isinstance(article_input, str):
+                return "Please provide a keyword or topic.", None
+            # 키워드로 검색하여 콘텐츠 생성
+            text = search_and_compile_content(article_input, language)
+            text = f"Keyword-based content:\n{text}"  # 마커 추가
         
         # Limit text to max words
         words = text.split()
@@ -942,7 +1069,7 @@ async def regenerate_audio(conversation_text: str, tts_engine: str = "Edge-TTS",
 
         # 한국어인 경우 Edge-TTS만 사용 (다른 TTS는 한국어 지원이 제한적)
         if language == "Korean" and tts_engine != "Edge-TTS":
-            return "한국어는 Edge-TTS만 지원됩니다. TTS 엔진이 자동으로 Edge-TTS로 변경됩니다.", None
+            tts_engine = "Edge-TTS"  # 자동으로 Edge-TTS로 변경
 
         # Generate audio based on TTS engine
         if tts_engine == "Edge-TTS":
@@ -997,11 +1124,13 @@ def update_tts_engine_for_korean(language):
 
 
 def toggle_input_visibility(input_type):
-    """Toggle visibility of URL input and file upload based on input type"""
+    """Toggle visibility of URL input, file upload, and keyword input based on input type"""
     if input_type == "URL":
-        return gr.update(visible=True), gr.update(visible=False)
-    else:  # PDF
-        return gr.update(visible=False), gr.update(visible=True)
+        return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+    elif input_type == "PDF":
+        return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
+    else:  # Keyword
+        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
 
 
 # 모델 초기화 (앱 시작 시)
@@ -1018,29 +1147,30 @@ if LLAMA_CPP_AVAILABLE:
 
 
 # Gradio Interface
-with gr.Blocks(theme='soft', title="URL/PDF to Podcast Converter") as demo:
-    gr.Markdown("# 🎙️ URL/PDF to Podcast Converter")
-    gr.Markdown("Convert any article, blog, news, or PDF document into an engaging podcast conversation!")
+with gr.Blocks(theme='soft', title="AI Podcast Generator") as demo:
+    gr.Markdown("# 🎙️ AI Podcast Generator")
+    gr.Markdown("Convert any article, blog, PDF document, or topic into an engaging podcast conversation!")
     
     # 상단에 로컬 LLM 상태 표시
     with gr.Row():
         gr.Markdown(f"""
-        ### 🤖 LLM Configuration:
+        ### 🤖 Enhanced Configuration:
         - **Primary**: Local LLM ({converter.config.local_model_name}) - Runs on your device
         - **Fallback**: API LLM ({converter.config.api_model_name}) - Used when local fails
         - **Status**: {"✅ Llama CPP Available" if LLAMA_CPP_AVAILABLE else "❌ Llama CPP Not Available - Install llama-cpp-python"}
-        - **Max Tokens**: {converter.config.max_tokens} (Extended for longer conversations)
+        - **Conversation Length**: {converter.config.min_conversation_turns}-{converter.config.max_conversation_turns} exchanges (1.5x longer)
         - **Search**: {"✅ Brave Search Enabled" if BRAVE_KEY else "❌ Brave Search Not Available - Set BSEARCH_API"}
+        - **New**: 🎯 Keyword input for topic-based podcast generation
         """)
     
     with gr.Row():
         with gr.Column(scale=3):
-            # Input type selector
+            # Input type selector - 키워드 옵션 추가
             input_type_selector = gr.Radio(
-                choices=["URL", "PDF"],
+                choices=["URL", "PDF", "Keyword"],
                 value="URL",
                 label="Input Type",
-                info="Choose between URL or PDF file upload"
+                info="Choose between URL, PDF file upload, or keyword/topic"
             )
             
             # URL input
@@ -1058,8 +1188,17 @@ with gr.Blocks(theme='soft', title="URL/PDF to Podcast Converter") as demo:
                 visible=False
             )
             
+            # Keyword input (새로 추가)
+            keyword_input = gr.Textbox(
+                label="Topic/Keyword",
+                placeholder="Enter a topic or keyword (e.g., 'AI trends', '인공지능 최신 동향')",
+                value="",
+                visible=False,
+                info="The system will search for latest information about this topic"
+            )
+            
         with gr.Column(scale=1):
-            # 언어 선택 추가
+            # 언어 선택
             language_selector = gr.Radio(
                 choices=["English", "Korean"],
                 value="English",
@@ -1085,17 +1224,22 @@ with gr.Blocks(theme='soft', title="URL/PDF to Podcast Converter") as demo:
                 )
                 
                 gr.Markdown("""
-                **Recommended:**
-                - 🌟 **Edge-TTS**: Best quality, cloud-based, instant setup
-                - 🤖 **Spark-TTS**: Local AI model (0.5B), zero-shot voice cloning
+                **📻 Radio Talk Show Style:**
+                - Natural, conversational dialogue
+                - Host asks short questions
+                - Expert gives brief, clear answers
+                - 12-15 conversation exchanges
                 
-                **Additional Option:**
-                - ⚡ **MeloTTS**: Local processing, GPU recommended
+                **🔍 Keyword Feature:**
+                - Enter any topic to generate a podcast
+                - Automatically searches latest information
+                - Creates engaging discussion from search results
                 
-                **한국어 지원:**
-                - 🇰🇷 한국어 선택 시 Edge-TTS만 사용 가능합니다
-                - 👨‍👨 한국어 대화는 준수(진행자)와 민호(전문가) 두 남성이 존댓말로 진행합니다
-                - 🔍 **최신 정보 반영**: Brave Search를 통해 최신 시사 내용을 자동으로 검색하여 대본에 반영합니다
+                **🇰🇷 한국어 지원:**
+                - 자연스러운 라디오 대담 스타일
+                - 진행자(준수)가 짧은 질문으로 대화 유도
+                - 전문가(민호)가 간결하게 답변
+                - 최신 정보 자동 검색 및 반영
                 """)
     
     convert_btn = gr.Button("🎯 Generate Conversation / 대화 생성", variant="primary", size="lg")
@@ -1104,10 +1248,10 @@ with gr.Blocks(theme='soft', title="URL/PDF to Podcast Converter") as demo:
         with gr.Column():
             conversation_output = gr.Textbox(
                 label="Generated Conversation (Editable) / 생성된 대화 (편집 가능)",
-                lines=25,  # 더 긴 대화를 위해 증가
-                max_lines=50,
+                lines=30,  # 더 긴 대화를 위해 증가
+                max_lines=60,
                 interactive=True,
-                placeholder="Generated conversation will appear here. You can edit it before generating audio.\n생성된 대화가 여기에 표시됩니다. 오디오 생성 전에 편집할 수 있습니다.\n\n한국어 대화는 존댓말로 진행되며 최신 시사 내용이 반영됩니다.",
+                placeholder="Generated conversation will appear here. You can edit it before generating audio.\n생성된 대화가 여기에 표시됩니다. 오디오 생성 전에 편집할 수 있습니다.\n\n라디오 대담 스타일로 자연스럽게 진행됩니다.",
                 info="Edit the conversation as needed. Format: 'Speaker Name: Text' / 필요에 따라 대화를 편집하세요. 형식: '화자 이름: 텍스트'"
             )
             
@@ -1134,8 +1278,9 @@ with gr.Blocks(theme='soft', title="URL/PDF to Podcast Converter") as demo:
     gr.Examples(
         examples=[
             ["https://huggingface.co/blog/openfree/cycle-navigator", "URL", "Local", "Edge-TTS", "English"],
-            ["https://www.bbc.com/news/technology-67988517", "URL", "Local", "Spark-TTS", "English"],
+            ["", "Keyword", "Local", "Edge-TTS", "English"],  # Keyword example
             ["https://huggingface.co/papers/2505.14810", "URL", "Local", "Edge-TTS", "Korean"],
+            ["", "Keyword", "Local", "Edge-TTS", "Korean"],  # Korean keyword example
         ],
         inputs=[url_input, input_type_selector, mode_selector, tts_selector, language_selector],
         outputs=[conversation_output, status_output],
@@ -1143,11 +1288,11 @@ with gr.Blocks(theme='soft', title="URL/PDF to Podcast Converter") as demo:
         cache_examples=False,
     )
     
-    # Input type change handler
+    # Input type change handler - 수정됨
     input_type_selector.change(
         fn=toggle_input_visibility,
         inputs=[input_type_selector],
-        outputs=[url_input, pdf_input]
+        outputs=[url_input, pdf_input, keyword_input]
     )
     
     # 언어 변경 시 TTS 엔진 옵션 업데이트
@@ -1158,18 +1303,20 @@ with gr.Blocks(theme='soft', title="URL/PDF to Podcast Converter") as demo:
     )
     
     # 이벤트 연결 - 수정된 부분
-    def get_article_input(input_type, url_input, pdf_input):
+    def get_article_input(input_type, url_input, pdf_input, keyword_input):
         """Get the appropriate input based on input type"""
         if input_type == "URL":
             return url_input
-        else:
+        elif input_type == "PDF":
             return pdf_input
+        else:  # Keyword
+            return keyword_input
     
     convert_btn.click(
-        fn=lambda input_type, url_input, pdf_input, mode, tts, lang: synthesize_sync(
-            get_article_input(input_type, url_input, pdf_input), input_type, mode, tts, lang
+        fn=lambda input_type, url_input, pdf_input, keyword_input, mode, tts, lang: synthesize_sync(
+            get_article_input(input_type, url_input, pdf_input, keyword_input), input_type, mode, tts, lang
         ),
-        inputs=[input_type_selector, url_input, pdf_input, mode_selector, tts_selector, language_selector],
+        inputs=[input_type_selector, url_input, pdf_input, keyword_input, mode_selector, tts_selector, language_selector],
         outputs=[conversation_output, status_output]
     )