Update app-backup.py

app-backup.py

@@ -1591,1597 +1591,4 @@ if __name__ == "__main__":
         share=False,
         server_name="0.0.0.0",
         server_port=7860
-    )        import spaces  # 추가
-import gradio as gr
-import os
-import asyncio
-import torch
-import io
-import json
-import re
-import httpx
-import tempfile
-import wave
-import base64
-import numpy as np
-import soundfile as sf
-import subprocess
-import shutil
-import requests
-import logging
-from datetime import datetime, timedelta
-from dataclasses import dataclass
-from typing import List, Tuple, Dict, Optional
-from pathlib import Path
-from threading import Thread
-from dotenv import load_dotenv
-
-# PDF processing imports
-from langchain_community.document_loaders import PyPDFLoader
-
-# Edge TTS imports
-import edge_tts
-from pydub import AudioSegment
-
-# OpenAI imports
-from openai import OpenAI
-
-# Transformers imports (for legacy local mode)
-from transformers import (
-    AutoModelForCausalLM,
-    AutoTokenizer,
-    TextIteratorStreamer,
-    BitsAndBytesConfig,
-)
-
-# Llama CPP imports (for new local mode)
-try:
-    from llama_cpp import Llama
-    from llama_cpp_agent import LlamaCppAgent, MessagesFormatterType
-    from llama_cpp_agent.providers import LlamaCppPythonProvider
-    from llama_cpp_agent.chat_history import BasicChatHistory
-    from llama_cpp_agent.chat_history.messages import Roles
-    from huggingface_hub import hf_hub_download
-    LLAMA_CPP_AVAILABLE = True
-except ImportError:
-    LLAMA_CPP_AVAILABLE = False
-
-# Spark TTS imports
-try:
-    from huggingface_hub import snapshot_download
-    SPARK_AVAILABLE = True
-except:
-    SPARK_AVAILABLE = False
-
-# MeloTTS imports (for local mode)
-try:
-    # unidic 다운로드를 조건부로 처리
-    if not os.path.exists("/usr/local/lib/python3.10/site-packages/unidic"):
-        try:
-            os.system("python -m unidic download")
-        except:
-            pass
-    from melo.api import TTS as MeloTTS
-    MELO_AVAILABLE = True
-except:
-    MELO_AVAILABLE = False
-
-load_dotenv()
-
-# Brave Search API 설정
-BRAVE_KEY = os.getenv("BSEARCH_API")
-BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
-
-@dataclass
-class ConversationConfig:
-    max_words: int = 8000  # 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"
-    # 새로운 로컬 모델 설정
-    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 = 6000  # 3000에서 4500으로 증가 (1.5배)
-    max_new_tokens: int = 12000  # 6000에서 9000으로 증가 (1.5배)
-    min_conversation_turns: int = 18  # 최소 대화 턴 수
-    max_conversation_turns: int = 20  # 최대 대화 턴 수
-
-
-def brave_search(query: str, count: int = 8, freshness_days: int | None = None):
-    """Brave Search API를 사용하여 최신 정보 검색"""
-    if not BRAVE_KEY:
-        return []
-    params = {"q": query, "count": str(count)}
-    if freshness_days:
-        dt_from = (datetime.utcnow() - timedelta(days=freshness_days)).strftime("%Y-%m-%d")
-        params["freshness"] = dt_from
-    try:
-        r = requests.get(
-            BRAVE_ENDPOINT,
-            headers={"Accept": "application/json", "X-Subscription-Token": BRAVE_KEY},
-            params=params,
-            timeout=15
-        )
-        raw = r.json().get("web", {}).get("results") or []
-        return [{
-            "title": r.get("title", ""),
-            "url": r.get("url", r.get("link", "")),
-            "snippet": r.get("description", r.get("text", "")),
-            "host": re.sub(r"https?://(www\.)?", "", r.get("url", "")).split("/")[0]
-        } for r in raw[:count]]
-    except Exception as e:
-        logging.error(f"Brave search error: {e}")
-        return []
-
-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 ""
-    
-    results = []
-    # 키워드 검색의 경우 더 상세한 정보 포함
-    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\n".join(results) + "\n"
-
-def extract_keywords_for_search(text: str, language: str = "English") -> List[str]:
-    """텍스트에서 검색할 키워드 추출 (개선)"""
-    # 텍스트 앞부분만 사용 (너무 많은 텍스트 처리 방지)
-    text_sample = text[:500]  
-    
-    if language == "Korean":
-        import re
-        # 한국어 명사 추출 (2글자 이상)
-        keywords = re.findall(r'[가-힣]{2,}', text_sample)
-        # 중복 제거하고 가장 긴 단어 1개만 선택
-        unique_keywords = list(dict.fromkeys(keywords))
-        # 길이 순으로 정렬하고 가장 의미있을 것 같은 단어 선택
-        unique_keywords.sort(key=len, reverse=True)
-        return unique_keywords[:1]  # 1개만 반환
-    else:
-        # 영어는 대문자로 시작하는 단어 중 가장 긴 것 1개
-        words = text_sample.split()
-        keywords = [word.strip('.,!?;:') for word in words 
-                   if len(word) > 4 and word[0].isupper()]
-        if keywords:
-            return [max(keywords, key=len)]  # 가장 긴 단어 1개
-        return []
-
-def search_and_compile_content(keyword: str, language: str = "English") -> str:
-    """키워드로 검색하여 충분한 콘텐츠 컴파일"""
-    if not BRAVE_KEY:
-        # API 없을 때도 기본 콘텐츠 생성
-        if language == "Korean":
-            return f"""
-'{keyword}'에 대한 종합적인 정보:
-
-{keyword}는 현대 사회에서 매우 중요한 주제입니다. 
-이 주제는 다양한 측면에서 우리의 삶에 영향을 미치고 있으며, 
-최근 들어 더욱 주목받고 있습니다.
-
-주요 특징:
-1. 기술적 발전과 혁신
-2. 사회적 영향과 변화
-3. 미래 전망과 가능성
-4. 실용적 활용 방안
-5. 글로벌 트렌드와 동향
-
-전문가들은 {keyword}가 앞으로 더욱 중요해질 것으로 예상하고 있으며,
-이에 대한 깊이 있는 이해가 필요한 시점입니다.
-"""
-        else:
-            return f"""
-Comprehensive information about '{keyword}':
-
-{keyword} is a significant topic in modern society.
-This subject impacts our lives in various ways and has been 
-gaining increasing attention recently.
-
-Key aspects:
-1. Technological advancement and innovation
-2. Social impact and changes
-3. Future prospects and possibilities
-4. Practical applications
-5. Global trends and developments
-
-Experts predict that {keyword} will become even more important,
-and it's crucial to develop a deep understanding of this topic.
-"""
-    
-    # 언어에 따른 다양한 검색 쿼리
-    if language == "Korean":
-        queries = [
-            f"{keyword} 최신 뉴스 2024",
-            f"{keyword} 정보 설명",
-            f"{keyword} 트렌드 전망",
-            f"{keyword} 장점 단점",
-            f"{keyword} 활용 방법",
-            f"{keyword} 전문가 의견"
-        ]
-    else:
-        queries = [
-            f"{keyword} latest news 2024",
-            f"{keyword} explained comprehensive",
-            f"{keyword} trends forecast",
-            f"{keyword} advantages disadvantages",
-            f"{keyword} how to use",
-            f"{keyword} expert opinions"
-        ]
-    
-    all_content = []
-    total_content_length = 0
-    
-    for query in queries:
-        results = brave_search(query, count=5)  # 더 많은 결과 가져오기
-        for r in results[:3]:  # 각 쿼리당 상위 3개
-            content = f"**{r['title']}**\n{r['snippet']}\nSource: {r['host']}\n"
-            all_content.append(content)
-            total_content_length += len(r['snippet'])
-    
-    # 콘텐츠가 부족하면 추가 생성
-    if total_content_length < 1000:  # 최소 1000자 확보
-        if language == "Korean":
-            additional_content = f"""
-추가 정보:
-{keyword}와 관련된 최근 동향을 살펴보면, 이 분야는 빠르게 발전하고 있습니다.
-많은 전문가들이 이 주제에 대해 활발히 연구하고 있으며, 
-실생활에서의 응용 가능성도 계속 확대되고 있습니다.
-
-특히 주목할 점은:
-- 기술 혁신의 가속화
-- 사용자 경험의 개선
-- 접근성의 향상
-- 비용 효율성 증대
-- 글로벌 시장의 성장
-
-이러한 요소들이 {keyword}의 미래를 더욱 밝게 만들고 있습니다.
-"""
-        else:
-            additional_content = f"""
-Additional insights:
-Recent developments in {keyword} show rapid advancement in this field.
-Many experts are actively researching this topic, and its practical 
-applications continue to expand.
-
-Key points to note:
-- Accelerating technological innovation
-- Improving user experience
-- Enhanced accessibility
-- Increased cost efficiency
-- Growing global market
-
-These factors are making the future of {keyword} increasingly promising.
-"""
-        all_content.append(additional_content)
-    
-    # 컴파일된 콘텐츠 반환
-    compiled = "\n\n".join(all_content)
-    
-    # 키워드 기반 소개
-    if language == "Korean":
-        intro = f"### '{keyword}'에 대한 종합적인 정���와 최신 동향:\n\n"
-    else:
-        intro = f"### Comprehensive information and latest trends about '{keyword}':\n\n"
-    
-    return intro + compiled
-
-
-def _build_prompt(self, text: str, language: str = "English", search_context: str = "") -> str:
-    """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":
-        # 대화 템플릿을 더 많은 턴으로 확장 (15-20회)
-        template = """
-        {
-            "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": ""},
-                {"speaker": "준수", "text": ""},
-                {"speaker": "민호", "text": ""},
-                {"speaker": "준수", "text": ""},
-                {"speaker": "민호", "text": ""},
-                {"speaker": "준수", "text": ""},
-                {"speaker": "민호", "text": ""}
-            ]
-        }
-        """
-        
-        context_part = ""
-        if search_context:
-            context_part = f"# 최신 관련 정보:\n{search_context}\n"
-    
-        base_prompt = (
-            f"# 원본 콘텐츠:\n{text}\n\n"
-            f"{context_part}"
-            f"위 내용으로 전문적이고 심층적인 라디오 팟캐스트 대담 프로그램 대본을 작성해주세요.\n\n"
-            f"## 필수 요구사항:\n"
-            f"1. **최소 18회 이상의 대화 교환** (준수 9회, 민호 9회 이상)\n"
-            f"2. **대화 스타일**: 전문적이고 깊이 있는 팟캐스트 대담\n"
-            f"3. **화자 역할**:\n"
-            f"   - 준수: 진행자 (통찰력 있는 질문, 핵심 포인트 정리, 청취자 관점 대변)\n"
-            f"   - 민호: 전문가 (상세하고 전문적인 설명, 구체적 예시, 데이터 기반 분석)\n"
-            f"4. **답변 규칙**:\n"
-            f"   - 준수: 1-2문장의 명확한 질문이나 요약\n"
-            f"   - 민호: **반드시 2-4문장으로 충실하게 답변** (핵심 개념 설명 + 부연 설명 + 예시/근거)\n"
-            f"   - 전문 용어는 쉽게 풀어서 설명\n"
-            f"   - 구체적인 수치, 사례, 연구 결과 인용\n"
-            f"5. **내용 구성**:\n"
-            f"   - 도입부 (2-3회): 주제의 중요성과 배경 설명\n"
-            f"   - 전개부 (12-14회): 핵심 내용을 다각도로 심층 분석\n"
-            f"   - 마무리 (2-3회): 핵심 요약과 미래 전망\n"
-            f"6. **전문성**: 학술적 근거와 실무적 통찰을 균형있게 포함\n"
-            f"7. **필수**: 서로 존댓말 사용, 청취자가 전문 지식을 얻을 수 있도록 상세히 설명\n\n"
-            f"반드시 위 JSON 형식으로 18회 이상의 전문적인 대화를 작성하세요:\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": ""},
-                {"speaker": "Jordan", "text": ""},
-                {"speaker": "Alex", "text": ""},
-                {"speaker": "Jordan", "text": ""},
-                {"speaker": "Alex", "text": ""},
-                {"speaker": "Jordan", "text": ""},
-                {"speaker": "Alex", "text": ""},
-                {"speaker": "Jordan", "text": ""}
-            ]
-        }
-        """
-        
-        context_part = ""
-        if search_context:
-            context_part = f"# Latest Information:\n{search_context}\n"
-        
-        base_prompt = (
-            f"# Content:\n{text}\n\n"
-            f"{context_part}"
-            f"Create a professional and in-depth podcast conversation.\n\n"
-            f"## Requirements:\n"
-            f"1. **Minimum 18 conversation exchanges** (Alex 9+, Jordan 9+)\n"
-            f"2. **Style**: Professional, insightful podcast discussion\n"
-            f"3. **Roles**:\n"
-            f"   - Alex: Host (insightful questions, key point summaries, audience perspective)\n"
-            f"   - Jordan: Expert (detailed explanations, concrete examples, data-driven analysis)\n"
-            f"4. **Response Rules**:\n"
-            f"   - Alex: 1-2 sentence clear questions or summaries\n"
-            f"   - Jordan: **Must answer in 2-4 sentences** (core concept + elaboration + example/evidence)\n"
-            f"   - Explain technical terms clearly\n"
-            f"   - Include specific data, cases, research findings\n"
-            f"5. **Structure**:\n"
-            f"   - Introduction (2-3 exchanges): Topic importance and context\n"
-            f"   - Main content (12-14 exchanges): Multi-angle deep analysis\n"
-            f"   - Conclusion (2-3 exchanges): Key takeaways and future outlook\n"
-            f"6. **Expertise**: Balance academic rigor with practical insights\n\n"
-            f"Create exactly 18+ professional exchanges in this JSON format:\n{template}"
-        )
-        
-        return base_prompt
-
-class UnifiedAudioConverter:
-    def __init__(self, config: ConversationConfig):
-        self.config = config
-        self.llm_client = None
-        self.legacy_local_model = None
-        self.legacy_tokenizer = None
-        # 새로운 로컬 LLM 관련
-        self.local_llm = None
-        self.local_llm_model = None
-        self.melo_models = None
-        self.spark_model_dir = None
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        
-    def initialize_api_mode(self, api_key: str):
-        """Initialize API mode with Together API (now fallback)"""
-        self.llm_client = OpenAI(api_key=api_key, base_url="https://api.together.xyz/v1")
-        
-    @spaces.GPU(duration=120)
-    def initialize_local_mode(self):
-        """Initialize new local mode with Llama CPP"""
-        if not LLAMA_CPP_AVAILABLE:
-            raise RuntimeError("Llama CPP dependencies not available. Please install llama-cpp-python and llama-cpp-agent.")
-        
-        if self.local_llm is None or self.local_llm_model != self.config.local_model_name:
-            try:
-                # 모델 다운로드
-                model_path = hf_hub_download(
-                    repo_id=self.config.local_model_repo,
-                    filename=self.config.local_model_name,
-                    local_dir="./models"
-                )
-                
-                model_path_local = os.path.join("./models", self.config.local_model_name)
-                
-                if not os.path.exists(model_path_local):
-                    raise RuntimeError(f"Model file not found at {model_path_local}")
-                
-                # Llama 모델 초기화
-                self.local_llm = Llama(
-                    model_path=model_path_local,
-                    flash_attn=True,
-                    n_gpu_layers=81 if torch.cuda.is_available() else 0,
-                    n_batch=1024,
-                    n_ctx=16384,
-                )
-                self.local_llm_model = self.config.local_model_name
-                print(f"Local LLM initialized: {model_path_local}")
-                
-            except Exception as e:
-                print(f"Failed to initialize local LLM: {e}")
-                raise RuntimeError(f"Failed to initialize local LLM: {e}")
-
-    @spaces.GPU(duration=60)
-    def initialize_legacy_local_mode(self):
-        """Initialize legacy local mode with Hugging Face model (fallback)"""
-        if self.legacy_local_model is None:
-            quantization_config = BitsAndBytesConfig(
-                load_in_4bit=True, 
-                bnb_4bit_compute_dtype=torch.float16
-            )
-            self.legacy_local_model = AutoModelForCausalLM.from_pretrained(
-                self.config.legacy_local_model_name, 
-                quantization_config=quantization_config
-            )
-            self.legacy_tokenizer = AutoTokenizer.from_pretrained(
-                self.config.legacy_local_model_name,
-                revision='8ab73a6800796d84448bc936db9bac5ad9f984ae'
-            )
-
-    def initialize_spark_tts(self):
-        """Initialize Spark TTS model by downloading if needed"""
-        if not SPARK_AVAILABLE:
-            raise RuntimeError("Spark TTS dependencies not available")
-        
-        model_dir = "pretrained_models/Spark-TTS-0.5B"
-        
-        # Check if model exists, if not download it
-        if not os.path.exists(model_dir):
-            print("Downloading Spark-TTS model...")
-            try:
-                os.makedirs("pretrained_models", exist_ok=True)
-                snapshot_download(
-                    "SparkAudio/Spark-TTS-0.5B", 
-                    local_dir=model_dir
-                )
-                print("Spark-TTS model downloaded successfully")
-            except Exception as e:
-                raise RuntimeError(f"Failed to download Spark-TTS model: {e}")
-        
-        self.spark_model_dir = model_dir
-        
-        # Check if we have the CLI inference script
-        if not os.path.exists("cli/inference.py"):
-            print("Warning: Spark-TTS CLI not found. Please clone the Spark-TTS repository.")
-
-    @spaces.GPU(duration=60)
-    def initialize_melo_tts(self):
-        """Initialize MeloTTS models"""        
-        if MELO_AVAILABLE and self.melo_models is None:
-            self.melo_models = {"EN": MeloTTS(language="EN", device=self.device)}
-
-    def fetch_text(self, url: str) -> str:
-        """Fetch text content from URL"""
-        if not url:
-            raise ValueError("URL cannot be empty")
-            
-        if not url.startswith("http://") and not url.startswith("https://"):
-            raise ValueError("URL must start with 'http://' or 'https://'")
-
-        full_url = f"{self.config.prefix_url}{url}"
-        try:
-            response = httpx.get(full_url, timeout=60.0)
-            response.raise_for_status()
-            return response.text
-        except httpx.HTTPError as e:
-            raise RuntimeError(f"Failed to fetch URL: {e}")
-
-    def extract_text_from_pdf(self, pdf_file) -> str:
-        """Extract text content from PDF file"""
-        try:
-            # Gradio returns file path, not file object
-            if isinstance(pdf_file, str):
-                pdf_path = pdf_file
-            else:
-                # If it's a file object (shouldn't happen with Gradio)
-                with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_file:
-                    tmp_file.write(pdf_file.read())
-                    pdf_path = tmp_file.name
-            
-            # PDF 로드 및 텍스트 추출
-            loader = PyPDFLoader(pdf_path)
-            pages = loader.load()
-            
-            # 모든 페이지의 텍스트를 결합
-            text = "\n".join([page.page_content for page in pages])
-            
-            # 임시 파일인 경우 삭제
-            if not isinstance(pdf_file, str) and os.path.exists(pdf_path):
-                os.unlink(pdf_path)
-            
-            return text
-        except Exception as e:
-            raise RuntimeError(f"Failed to extract text from PDF: {e}")
-
-    def _get_messages_formatter_type(self, model_name):
-        """Get appropriate message formatter for the model"""
-        if "Mistral" in model_name or "BitSix" in model_name:
-            return MessagesFormatterType.CHATML
-        else:
-            return MessagesFormatterType.LLAMA_3
-
-
-    def _build_prompt(self, text: str, language: str = "English", search_context: str = "") -> str:
-        """Build prompt for conversation generation with enhanced professional podcast 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": ""},
-                    {"speaker": "민호", "text": ""}
-                ]
-            }
-            """
-            
-            context_part = ""
-            if search_context:
-                context_part = f"# 최신 관련 정보:\n{search_context}\n"
-        
-            base_prompt = (
-                f"# 원본 콘텐츠:\n{text}\n\n"
-                f"{context_part}"
-                f"위 내용으로 전문적이고 심층적인 팟캐스트 대담 프로그램 대본을 작성해주세요.\n\n"
-                f"## 핵심 지침:\n"
-                f"1. **대화 스타일**: 전문적이면서도 이해하기 쉬운 팟캐스트 대담\n"
-                f"2. **화자 역할**:\n"
-                f"   - 준수: 진행자/호스트 (핵심을 짚는 질문, 청취자 관점에서 궁금한 점 질문)\n"
-                f"   - 민호: 전문가 (깊이 있는 설명, 구체적 사례와 데이터 제시)\n"
-                f"3. **중요한 답변 규칙**:\n"
-                f"   - 준수: 1-2문장의 명확한 질문 (\"그렇다면 구체적으로 어떤 의미인가요?\", \"실제 사례를 들어주시겠어요?\")\n"
-                f"   - 민호: **반드시 2-4문장으로 충실히 답변** (개념 설명 + 구체적 설명 + 예시나 함의)\n"
-                f"   - 예: \"이것은 ~를 의미합니다. 구체적으로 ~한 측면에서 중요한데요. 실제로 최근 ~한 사례가 있었고, 이는 ~를 보여줍니다.\"\n"
-                f"4. **전문성 요소**:\n"
-                f"   - 통계나 연구 결과 인용\n"
-                f"   - 실제 사례와 케이스 스터디\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": ""},
-                    {"speaker": "Jordan", "text": ""}
-                ]
-            }
-            """
-            
-            context_part = ""
-            if search_context:
-                context_part = f"# Latest Information:\n{search_context}\n"
-            
-            base_prompt = (
-                f"# Content:\n{text}\n\n"
-                f"{context_part}"
-                f"Create a professional and insightful podcast conversation.\n\n"
-                f"## Key Guidelines:\n"
-                f"1. **Style**: Professional yet accessible podcast discussion\n"
-                f"2. **Roles**:\n"
-                f"   - Alex: Host (insightful questions, audience perspective)\n"
-                f"   - Jordan: Expert (in-depth explanations, concrete examples and data)\n"
-                f"3. **Critical Response Rules**:\n"
-                f"   - Alex: 1-2 sentence clear questions (\"Could you elaborate on that?\", \"What's a real-world example?\")\n"
-                f"   - Jordan: **Must answer in 2-4 sentences** (concept + detailed explanation + example/implication)\n"
-                f"   - Example: \"This refers to... Specifically, it's important because... For instance, recent studies show... This demonstrates...\"\n"
-                f"4. **Professional Elements**:\n"
-                f"   - Cite statistics and research\n"
-                f"   - Real cases and case studies\n"
-                f"   - Explain technical terms clearly\n"
-                f"   - Present multiple perspectives\n"
-                f"5. **Length**: 12-15 exchanges total\n\n"
-                f"Return JSON only:\n{template}"
-            )
-            
-            return base_prompt
-
-
-
-    def _build_messages_for_local(self, text: str, language: str = "English", search_context: str = "") -> List[Dict]:
-        """Build messages for local LLM with enhanced professional podcast style"""
-        if language == "Korean":
-            system_message = (
-                "당신은 한국 최고의 전문 팟캐스트 작가입니다. "
-                "청취자들이 전문 지식을 쉽게 이해할 수 있는 고품질 대담을 만들어냅니다.\n\n"
-                "핵심 원칙:\n"
-                "1. 진행자(준수)는 핵심을 짚는 통찰력 있는 질문으로 대화를 이끌어갑니다\n"
-                "2. 전문가(민호)는 반드시 2-4문장으로 깊이 있게 답변합니다 (개념+설명+예시)\n"
-                "3. 구체적인 데이터, 연구 결과, 실제 사례를 포함합니다\n"
-                "4. 전문 용어는 쉽게 풀어서 설명하되, 정확성을 유지합니다\n"
-                "5. 다양한 관점을 제시하여 균형잡힌 시각을 제공합니다\n"
-                "6. 반드시 서로 존댓말을 사용하며, 전문적이면서도 친근한 톤을 유지합니다"
-            )
-        else:
-            system_message = (
-                "You are an expert podcast scriptwriter who creates high-quality, "
-                "professional discussions that make complex topics accessible.\n\n"
-                "Key principles:\n"
-                "1. The host (Alex) asks insightful questions that drive the conversation\n"
-                "2. The expert (Jordan) MUST answer in 2-4 sentences (concept+explanation+example)\n"
-                "3. Include specific data, research findings, and real cases\n"
-                "4. Explain technical terms clearly while maintaining accuracy\n"
-                "5. Present multiple perspectives for balanced views\n"
-                "6. Maintain a professional yet approachable tone"
-            )
-        
-        return [
-            {"role": "system", "content": system_message},
-            {"role": "user", "content": self._build_prompt(text, language, search_context)}
-        ]
-
-    @spaces.GPU(duration=120)
-    def extract_conversation_local(self, text: str, language: str = "English", progress=None) -> Dict:
-        """Extract conversation using new local LLM with enhanced professional style"""
-        try:
-            # 검색 컨텍스트 생성 (키워드 기반이 아닌 경우)
-            search_context = ""
-            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}")
-                except Exception as e:
-                    print(f"Search failed, continuing without context: {e}")
-            
-            # 먼저 새로운 로컬 LLM 시도
-            self.initialize_local_mode()
-            
-            chat_template = self._get_messages_formatter_type(self.config.local_model_name)
-            provider = LlamaCppPythonProvider(self.local_llm)
-
-            # 강화된 전문 팟캐스트 스타일 시스템 메시지
-            if language == "Korean":
-                system_message = (
-                    "당신은 한국의 유명 팟캐스트 전문 작가입니다. "
-                    "청취자들이 깊이 있는 전문 지식을 얻을 수 있는 고품질 대담을 만듭니다.\n\n"
-                    "작성 규칙:\n"
-                    "1. 진행자(준수)는 핵심을 짚는 1-2문장 질문을 합니다\n"
-                    "2. 전문가(민호)는 반드시 2-4문장으로 충실히 답변합니다:\n"
-                    "   - 첫 문장: 핵심 개념 설명\n"
-                    "   - 둘째 문장: 구체적인 설명이나 맥락\n"
-                    "   - 셋째-넷째 문장: 실제 예시, 데이터, 함의\n"
-                    "3. 통계, 연구 결과, 실제 사례를 적극 활용하세요\n"
-                    "4. 전문성을 유지하면서도 이해하기 쉽게 설명하세요\n"
-                    "5. 12-15회의 대화 교환으로 구성하세요\n"
-                    "6. JSON 형식으로만 응답하세요"
-                )
-            else:
-                system_message = (
-                    "You are a professional podcast scriptwriter creating high-quality, "
-                    "insightful discussions that provide deep expertise to listeners.\n\n"
-                    "Writing rules:\n"
-                    "1. Host (Alex) asks focused 1-2 sentence questions\n"
-                    "2. Expert (Jordan) MUST answer in 2-4 substantial sentences:\n"
-                    "   - First sentence: Core concept explanation\n"
-                    "   - Second sentence: Specific details or context\n"
-                    "   - Third-fourth sentences: Real examples, data, implications\n"
-                    "3. Actively use statistics, research findings, real cases\n"
-                    "4. Maintain expertise while keeping explanations accessible\n"
-                    "5. Create 12-15 conversation exchanges\n"
-                    "6. Respond only in JSON format"
-                )
-
-            agent = LlamaCppAgent(
-                provider,
-                system_prompt=system_message,
-                predefined_messages_formatter_type=chat_template,
-                debug_output=False
-            )
-            
-            settings = provider.get_provider_default_settings()
-            settings.temperature = 0.75  # 약간 낮춰서 더 일관된 전문적 답변
-            settings.top_k = 40
-            settings.top_p = 0.95
-            settings.max_tokens = self.config.max_tokens  # 증가된 토큰 수 사용
-            settings.repeat_penalty = 1.1
-            settings.stream = False
-
-            messages = BasicChatHistory()
-            
-            prompt = self._build_prompt(text, language, search_context)
-            response = agent.get_chat_response(
-                prompt,
-                llm_sampling_settings=settings,
-                chat_history=messages,
-                returns_streaming_generator=False,
-                print_output=False
-            )
-
-            # JSON 파싱
-            pattern = r"\{(?:[^{}]|(?:\{[^{}]*\}))*\}"
-            json_match = re.search(pattern, response)
-            
-            if json_match:
-                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")
-                
-        except Exception as e:
-            print(f"Local LLM failed: {e}, falling back to legacy local method")
-            return self.extract_conversation_legacy_local(text, language, progress, search_context)
-
-    @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 with enhanced professional style"""
-        try:
-            self.initialize_legacy_local_mode()
-            
-            # 강화된 전문 팟캐스트 스타일 시스템 메시지
-            if language == "Korean":
-                system_message = (
-                    "당신은 전문 팟캐스트 작가입니다. "
-                    "진행자(준수)는 통찰력 있는 질문을, 전문가(민호)는 2-4문장의 상세한 답변을 합니다. "
-                    "구체적인 데이터와 사례를 포함하여 전문적이면서도 이해하기 쉽게 설명하세요. "
-                    "12-15회 대화 교환으로 구성하세요."
-                )
-            else:
-                system_message = (
-                    "You are a professional podcast scriptwriter. "
-                    "Create insightful dialogue where the host (Alex) asks focused questions "
-                    "and the expert (Jordan) gives detailed 2-4 sentence answers. "
-                    "Include specific data and examples. Create 12-15 exchanges."
-                )
-
-            chat = [
-                {"role": "system", "content": system_message},
-                {"role": "user", "content": self._build_prompt(text, language, search_context)}
-            ]
-
-            terminators = [
-                self.legacy_tokenizer.eos_token_id,
-                self.legacy_tokenizer.convert_tokens_to_ids("<|eot_id|>")
-            ]
-
-            messages = self.legacy_tokenizer.apply_chat_template(
-                chat, tokenize=False, add_generation_prompt=True
-            )
-            model_inputs = self.legacy_tokenizer([messages], return_tensors="pt").to(self.device)
-            
-            streamer = TextIteratorStreamer(
-                self.legacy_tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True
-            )
-            
-            generate_kwargs = dict(
-                model_inputs,
-                streamer=streamer,
-                max_new_tokens=self.config.max_new_tokens,  # 증가된 토큰 수 사용
-                do_sample=True,
-                temperature=0.75,
-                eos_token_id=terminators,
-            )
-
-            t = Thread(target=self.legacy_local_model.generate, kwargs=generate_kwargs)
-            t.start()
-
-            partial_text = ""
-            for new_text in streamer:
-                partial_text += new_text
-
-            pattern = r"\{(?:[^{}]|(?:\{[^{}]*\}))*\}"
-            json_match = re.search(pattern, partial_text)
-            
-            if json_match:
-                return json.loads(json_match.group())
-            else:
-                raise ValueError("No valid JSON found in legacy local response")
-                
-        except Exception as e:
-            print(f"Legacy local model also failed: {e}")
-            # Return enhanced default template
-            if language == "Korean":
-                return self._get_default_korean_conversation()
-            else:
-                return self._get_default_english_conversation()
-
-    def _get_default_korean_conversation(self) -> Dict:
-        """더 전문적인 기본 한국어 대화 템플릿"""
-        return {
-            "conversation": [
-                {"speaker": "준수", "text": "안녕하세요, 여러분! 오늘은 정말 중요하고 흥미로운 주제를 다뤄보려고 합니다. 민호 박사님, 먼저 이 주제가 왜 지금 이렇게 주목받고 있는지 설명해주시겠어요?"},
-                {"speaker": "민호", "text": "네, 안녕하세요. 최근 이 분야에서 획기적인 발전이 있었습니다. 특히 작년 MIT 연구팀의 발표에 따르면, 이 기술의 효율성이 기존 대비 300% 향상되었다고 합니다. 이는 단순한 기술적 진보를 넘어서 우리 일상생활에 직접적인 영향을 미칠 수 있는 변화인데요. 실제로 구글과 마이크로소프트 같은 빅테크 기업들이 이미 수십억 달러를 투자하고 있습니다."},
-                {"speaker": "준수", "text": "와, 300% 향상이라니 정말 놀라운데요. 그렇다면 이런 기술 발전이 일반인들에게는 구체적으로 어떤 혜택을 가져다줄 수 있을까요?"},
-                {"speaker": "민호", "text": "가장 직접적인 혜택은 비용 절감과 접근성 향상입니다. 예를 들어, 이전에는 전문가만 사용��� 수 있던 고급 기능들이 이제는 스마트폰 앱으로도 구현 가능해졌습니다. 맥킨지 보고서에 따르면, 2025년까지 이 기술로 인해 전 세계적으로 약 2조 달러의 경제적 가치가 창출될 것으로 예상됩니다. 특히 의료, 교육, 금융 분야에서 혁신적인 변화가 일어날 것으로 보입니다."},
-                {"speaker": "준수", "text": "2조 달러라는 엄청난 규모네요. 의료 분야에서는 어떤 변화가 예상되나요?"},
-                {"speaker": "민호", "text": "의료 분야의 변화는 정말 혁명적일 것으로 예상됩니다. 이미 스탠포드 대학병원에서는 이 기술을 활용해 암 진단 정확도를 95%까지 높였습니다. 기존에는 숙련된 의사도 놓칠 수 있던 미세한 병변들을 AI가 감지해내는 것이죠. 더 놀라운 것은 이런 진단이 단 몇 분 만에 이뤄진다는 점입니다. WHO 추산으로는 이 기술이 전 세계적으로 보급되면 연간 수백만 명의 생명을 구할 수 있을 것으로 예측하고 있습니다."},
-                {"speaker": "준수", "text": "정말 인상적이네요. 하지만 이런 급격한 기술 발전에 대한 우려의 목소리도 있을 것 같은데요?"},
-                {"speaker": "민호", "text": "맞습니다. 주요 우려사항은 크게 세 가지입니다. 첫째는 일자리 대체 문제로, 옥스포드 대학 연구에 따르면 향후 20년 내에 현재 직업의 47%가 자동화될 위험이 있습니다. 둘째는 프라이버시와 보안 문제입니다. 셋째는 기술 격차로 인한 불평등 심화입니다. 하지만 역사적으로 보면 새로운 기술은 항상 새로운 기회도 함께 만들어왔기 때문에, 적절한 정책과 교육으로 이런 문제들을 해결할 수 있을 것으로 봅니다."},
-                {"speaker": "준수", "text": "균형잡힌 시각이 중요하겠네요. 그렇다면 우리가 이런 변화에 어떻게 대비해야 할까요?"},
-                {"speaker": "민호", "text": "가장 중요한 것은 지속적인 학습과 적응력입니다. 세계경제포럼은 2025년까지 전 세계 근로자의 50%가 재교육이 필요할 것으로 예측했습니다. 특히 디지털 리터러시, 비판적 사고력, 창의성 같은 능력이 중요해질 것입니다. 개인적으로는 온라인 교육 플랫폼을 활용한 자기계발을 추천합니다. 예를 들어 Coursera나 edX 같은 플랫폼에서는 세계 최고 대학의 강의를 무료로 들을 수 있습니다."},
-                {"speaker": "준수", "text": "실용적인 조언 감사합니다. 마지막으로 이 분야의 미래 전망은 어떻게 보시나요?"},
-                {"speaker": "민호", "text": "향후 10년은 인류 역사상 가장 급격한 기술 발전을 경험하는 시기가 될 것입니다. 가트너의 하이프 사이클 분석에 따르면, 현재 우리는 이 기술의 초기 단계에 불과합니다. 2030년까지는 지금으로서는 상상하기 어려운 수준의 혁신이 일어날 것으로 예상됩니다. 중요한 것은 이런 변화를 두려워하기보다는 기회로 삼아 더 나은 미래를 만들어가는 것이라고 생각합니다."},
-                {"speaker": "준수", "text": "정말 통찰력 있는 말씀이네요. 오늘 너무나 유익한 시간이었습니다. 청취자 여러분도 오늘 논의된 내용을 바탕으로 미래를 준비하시길 바랍니다. 민호 박사님, 귀중한 시간 내주셔서 감사합니다!"},
-                {"speaker": "민호", "text": "감사합니다. 청취자 여러분들이 이 변화의 시대를 현명하게 헤쳐나가시길 바랍니다. 기술은 도구일 뿐이고, 그것을 어떻게 활용하는지는 우리에게 달려있다는 점을 기억해주세요. 오늘 말씀드린 내용에 대해 더 궁금하신 점이 있으시면 제가 운영하는 블로그나 최근 출간한 책에서 더 자세한 정보를 찾으실 수 있습니다."}
-            ]
-        }
-
-    def _get_default_english_conversation(self) -> Dict:
-        """Enhanced professional English conversation template"""
-        return {
-            "conversation": [
-                {"speaker": "Alex", "text": "Welcome everyone to our podcast! Today we're diving into a topic that's reshaping our world. Dr. Jordan, could you start by explaining why this subject has become so critical right now?"},
-                {"speaker": "Jordan", "text": "Thanks, Alex. We're witnessing an unprecedented convergence of technological breakthroughs. According to a recent Nature publication, advances in this field have accelerated by 400% in just the past two years. This isn't just incremental progress - it's a fundamental shift in how we approach problem-solving. Major institutions like Harvard and Stanford are completely restructuring their research programs to focus on this area, with combined investments exceeding $5 billion annually."},
-                {"speaker": "Alex", "text": "400% acceleration is staggering! What does this mean for everyday people who might not be tech-savvy?"},
-                {"speaker": "Jordan", "text": "The impact will be profound yet accessible. Think about how smartphones revolutionized communication - this will be similar but across every aspect of life. McKinsey's latest report projects that by 2026, these technologies will create $4.4 trillion in annual value globally. For individuals, this translates to personalized healthcare that can predict illnesses years in advance, educational systems that adapt to each student's learning style, and financial tools that democratize wealth-building strategies previously available only to the ultra-wealthy."},
-                {"speaker": "Alex", "text": "Those applications sound transformative. Can you give us a concrete example of how this is already being implemented?"},
-                {"speaker": "Jordan", "text": "Absolutely. Let me share a compelling case from Johns Hopkins Hospital. They've deployed an AI system that analyzes patient data in real-time, reducing diagnostic errors by 85% and cutting average diagnosis time from days to hours. In one documented case, the system identified a rare genetic disorder in a child that had been misdiagnosed for three years. The accuracy comes from analyzing patterns across millions of cases - something impossible for even the most experienced doctors to do manually. This technology is now being rolled out to rural hospitals, bringing world-class diagnostic capabilities to underserved communities."},
-                {"speaker": "Alex", "text": "That's truly life-changing technology. But I imagine there are significant challenges and risks we need to consider?"},
-                {"speaker": "Jordan", "text": "You're absolutely right to raise this. The challenges are as significant as the opportunities. The World Economic Forum identifies three critical risks: First, algorithmic bias could perpetuate or amplify existing inequalities if not carefully managed. Second, cybersecurity threats become exponentially more dangerous when AI systems control critical infrastructure. Third, there's the socioeconomic disruption - PwC estimates that 30% of jobs could be automated by 2030. However, history shows us that technological revolutions create new opportunities even as they displace old ones. The key is proactive adaptation and responsible development."},
-                {"speaker": "Alex", "text": "How should individuals and organizations prepare for these changes?"},
-                {"speaker": "Jordan", "text": "Preparation requires a multi-faceted approach. For individuals, I recommend focusing on skills that complement rather than compete with AI: critical thinking, emotional intelligence, and creative problem-solving. MIT's recent study shows that professionals who combine domain expertise with AI literacy see salary increases of 40% on average. Organizations need to invest in continuous learning programs - Amazon's $700 million worker retraining initiative is a good model. Most importantly, we need to cultivate an adaptive mindset. The half-life of specific technical skills is shrinking, but the ability to learn and unlearn quickly is becoming invaluable."},
-                {"speaker": "Alex", "text": "That's practical advice. What about the ethical considerations? How do we ensure this technology benefits humanity as a whole?"},
-                {"speaker": "Jordan", "text": "Ethics must be at the forefront of development. The EU's AI Act and similar regulations worldwide are establishing important guardrails. We need transparent AI systems where decisions can be explained and audited. Companies like IBM and Google have established AI ethics boards, but we need industry-wide standards. Additionally, we must address the digital divide - UNESCO reports that 37% of the global population still lacks internet access. Without inclusive development, these technologies could exacerbate global inequality rather than reduce it. The solution requires collaboration between technologists, ethicists, policymakers, and communities."},
-                {"speaker": "Alex", "text": "Looking ahead, what's your vision for how this technology will shape the next decade?"},
-                {"speaker": "Jordan", "text": "The next decade will be transformative beyond our current imagination. Ray Kurzweil's prediction of technological singularity by 2045 seems increasingly plausible. By 2035, I expect we'll see autonomous systems managing entire cities, personalized medicine extending human lifespan by 20-30 years, and educational AI that makes world-class education universally accessible. The convergence of AI with quantum computing, biotechnology, and nanotechnology will unlock possibilities we can barely conceive of today. However, the future isn't predetermined - it's shaped by the choices we make now about development priorities, ethical frameworks, and inclusive access."},
-                {"speaker": "Alex", "text": "That's both exciting and sobering. Any final thoughts for our listeners?"},
-                {"speaker": "Jordan", "text": "I'd encourage everyone to view this as humanity's next great adventure. Yes, there are risks and challenges, but we're also on the cusp of solving problems that have plagued us for millennia - disease, poverty, environmental degradation. The key is engaged participation rather than passive observation. Stay informed through reliable sources, experiment with new technologies, and most importantly, contribute to the conversation about what kind of future we want to build. The decisions we make in the next five years will reverberate for generations."},
-                {"speaker": "Alex", "text": "Dr. Jordan, this has been an incredibly enlightening discussion. Thank you for sharing your expertise and insights with us today."},
-                {"speaker": "Jordan", "text": "Thank you, Alex. It's been a pleasure discussing these crucial topics. For listeners wanting to dive deeper, I've compiled additional resources on my website, including links to the studies we discussed today. Remember, the future isn't something that happens to us - it's something we create together. I look forward to seeing how each of you contributes to shaping this exciting new era."}
-            ]
-        }
-
-    def extract_conversation_api(self, text: str, language: str = "English") -> Dict:
-        """Extract conversation using API with enhanced professional style"""
-        if not self.llm_client:
-            raise RuntimeError("API mode not initialized")
-
-        try:
-            # 검색 컨텍스트 생성
-            search_context = ""
-            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}")
-                except Exception as e:
-                    print(f"Search failed, continuing without context: {e}")
-
-            # 강화된 전문 팟캐스트 스타일 프롬프트
-            if language == "Korean":
-                system_message = (
-                    "당신은 한국의 최고 전문 팟캐스트 작가입니다. "
-                    "청취자들이 깊이 있는 인사이트를 얻을 수 있는 고품질 대담을 만드세요.\n"
-                    "준수(진행자)는 핵심을 짚는 1-2문장 질문을 하고, "
-                    "민호(전문가)는 반드시 2-4문장으로 상세히 답변합니다. "
-                    "구체적인 데이터, 연구 결과, 실제 사례를 포함하세요. "
-                    "전문 용어는 쉽게 설명하고, 반드시 서로 존댓말을 사용하세요. "
-                    "12-15회의 깊이 있는 대화 교환으로 구성하세요."
-                )
-            else:
-                system_message = (
-                    "You are a top professional podcast scriptwriter. "
-                    "Create high-quality discussions that provide deep insights to listeners. "
-                    "Alex (host) asks focused 1-2 sentence questions, "
-                    "while Jordan (expert) MUST answer in 2-4 detailed sentences. "
-                    "Include specific data, research findings, and real cases. "
-                    "Explain technical terms clearly. "
-                    "Create 12-15 insightful conversation exchanges."
-                )
-
-            chat_completion = self.llm_client.chat.completions.create(
-                messages=[
-                    {"role": "system", "content": system_message},
-                    {"role": "user", "content": self._build_prompt(text, language, search_context)}
-                ],
-                model=self.config.api_model_name,
-                temperature=0.75,
-            )
-
-            pattern = r"\{(?:[^{}]|(?:\{[^{}]*\}))*\}"
-            json_match = re.search(pattern, chat_completion.choices[0].message.content)
-
-            if not json_match:
-                raise ValueError("No valid JSON found in response")
-
-            return json.loads(json_match.group())
-        except Exception as e:
-            raise RuntimeError(f"Failed to extract conversation: {e}")
-
-    def parse_conversation_text(self, conversation_text: str) -> Dict:
-        """Parse conversation text back to JSON format"""
-        lines = conversation_text.strip().split('\n')
-        conversation_data = {"conversation": []}
-        
-        for line in lines:
-            if ':' in line:
-                speaker, text = line.split(':', 1)
-                conversation_data["conversation"].append({
-                    "speaker": speaker.strip(),
-                    "text": text.strip()
-                })
-        
-        return conversation_data
-
-    async def text_to_speech_edge(self, conversation_json: Dict, language: str = "English") -> Tuple[str, str]:
-        """Convert text to speech using Edge TTS"""
-        output_dir = Path(self._create_output_directory())
-        filenames = []
-
-        try:
-            # 언어별 음성 설정 - 한국어는 모두 남성 음성
-            if language == "Korean":
-                voices = [
-                    "ko-KR-HyunsuNeural",  # 남성 음성 1 (차분하고 신뢰감 있는)
-                    "ko-KR-InJoonNeural"   # 남성 음성 2 (활기차고 친근한)
-                ]
-            else:
-                voices = [
-                    "en-US-AndrewMultilingualNeural",    # 남성 음성 1
-                    "en-US-BrianMultilingualNeural"      # 남성 음성 2
-                ]
-
-            for i, turn in enumerate(conversation_json["conversation"]):
-                filename = output_dir / f"output_{i}.wav"
-                voice = voices[i % len(voices)]
-
-                tmp_path = await self._generate_audio_edge(turn["text"], voice)
-                os.rename(tmp_path, filename)
-                filenames.append(str(filename))
-
-            # Combine audio files
-            final_output = os.path.join(output_dir, "combined_output.wav")
-            self._combine_audio_files(filenames, final_output)
-            
-            # Generate conversation text
-            conversation_text = "\n".join(
-                f"{turn.get('speaker', f'Speaker {i+1}')}: {turn['text']}" 
-                for i, turn in enumerate(conversation_json["conversation"])
-            )
-            
-            return final_output, conversation_text
-        except Exception as e:
-            raise RuntimeError(f"Failed to convert text to speech: {e}")
-
-    async def _generate_audio_edge(self, text: str, voice: str) -> str:
-        """Generate audio using Edge TTS"""
-        if not text.strip():
-            raise ValueError("Text cannot be empty")
-            
-        voice_short_name = voice.split(" - ")[0] if " - " in voice else voice
-        communicate = edge_tts.Communicate(text, voice_short_name)
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-            tmp_path = tmp_file.name
-            await communicate.save(tmp_path)
-
-        return tmp_path
-
-    @spaces.GPU(duration=60)
-    def text_to_speech_spark(self, conversation_json: Dict, language: str = "English", progress=None) -> Tuple[str, str]:
-        """Convert text to speech using Spark TTS CLI"""
-        if not SPARK_AVAILABLE or not self.spark_model_dir:
-            raise RuntimeError("Spark TTS not available")
-
-        try:
-            output_dir = self._create_output_directory()
-            audio_files = []
-            
-            # Create different voice characteristics for different speakers
-            if language == "Korean":
-                voice_configs = [
-                    {"prompt_text": "안녕하세요, 오늘 팟캐스트 진행을 맡은 준수입니다. 여러분과 함께 흥미로운 이야기를 나눠보겠습니다.", "gender": "male"},
-                    {"prompt_text": "안녕하세요, 저는 오늘 이 주제에 대해 설명드릴 민호입니다. 쉽고 재미있게 설명드릴게요.", "gender": "male"}
-                ]
-            else:
-                voice_configs = [
-                    {"prompt_text": "Hello everyone, I'm Alex, your host for today's podcast. Let's explore this fascinating topic together.", "gender": "male"},
-                    {"prompt_text": "Hi, I'm Jordan. I'm excited to share my insights on this subject with you all today.", "gender": "male"}
-                ]
-
-            for i, turn in enumerate(conversation_json["conversation"]):
-                text = turn["text"]
-                if not text.strip():
-                    continue
-                
-                # Use different voice config for each speaker
-                voice_config = voice_configs[i % len(voice_configs)]
-                
-                output_file = os.path.join(output_dir, f"spark_output_{i}.wav")
-                
-                # Run Spark TTS CLI inference
-                cmd = [
-                    "python", "-m", "cli.inference",
-                    "--text", text,
-                    "--device", "0" if torch.cuda.is_available() else "cpu",
-                    "--save_dir", output_dir,
-                    "--model_dir", self.spark_model_dir,
-                    "--prompt_text", voice_config["prompt_text"],
-                    "--output_name", f"spark_output_{i}.wav"
-                ]
-                
-                try:
-                    # Run the command
-                    result = subprocess.run(
-                        cmd, 
-                        capture_output=True, 
-                        text=True, 
-                        timeout=60,
-                        cwd="."  # Make sure we're in the right directory
-                    )
-                    
-                    if result.returncode == 0:
-                        audio_files.append(output_file)
-                    else:
-                        print(f"Spark TTS error for turn {i}: {result.stderr}")
-                        # Create a short silence as fallback
-                        silence = np.zeros(int(22050 * 1.0))  # 1 second of silence
-                        sf.write(output_file, silence, 22050)
-                        audio_files.append(output_file)
-                        
-                except subprocess.TimeoutExpired:
-                    print(f"Spark TTS timeout for turn {i}")
-                    # Create silence as fallback
-                    silence = np.zeros(int(22050 * 1.0))
-                    sf.write(output_file, silence, 22050)
-                    audio_files.append(output_file)
-                except Exception as e:
-                    print(f"Error running Spark TTS for turn {i}: {e}")
-                    # Create silence as fallback
-                    silence = np.zeros(int(22050 * 1.0))
-                    sf.write(output_file, silence, 22050)
-                    audio_files.append(output_file)
-
-            # Combine all audio files
-            if audio_files:
-                final_output = os.path.join(output_dir, "spark_combined.wav")
-                self._combine_audio_files(audio_files, final_output)
-            else:
-                raise RuntimeError("No audio files generated")
-
-            # Generate conversation text
-            conversation_text = "\n".join(
-                f"{turn.get('speaker', f'Speaker {i+1}')}: {turn['text']}" 
-                for i, turn in enumerate(conversation_json["conversation"])
-            )
-            
-            return final_output, conversation_text
-            
-        except Exception as e:
-            raise RuntimeError(f"Failed to convert text to speech with Spark TTS: {e}")
-
-    @spaces.GPU(duration=60)
-    def text_to_speech_melo(self, conversation_json: Dict, progress=None) -> Tuple[str, str]:
-        """Convert text to speech using MeloTTS"""
-        if not MELO_AVAILABLE or not self.melo_models:
-            raise RuntimeError("MeloTTS not available")
-
-        speakers = ["EN-Default", "EN-US"]
-        combined_audio = AudioSegment.empty()
-
-        for i, turn in enumerate(conversation_json["conversation"]):
-            bio = io.BytesIO()
-            text = turn["text"]
-            speaker = speakers[i % 2]
-            speaker_id = self.melo_models["EN"].hps.data.spk2id[speaker]
-            
-            # Generate audio
-            self.melo_models["EN"].tts_to_file(
-                text, speaker_id, bio, speed=1.0, 
-                pbar=progress.tqdm if progress else None, 
-                format="wav"
-            )
-            
-            bio.seek(0)
-            audio_segment = AudioSegment.from_file(bio, format="wav")
-            combined_audio += audio_segment
-
-        # Save final audio
-        final_audio_path = "melo_podcast.mp3"
-        combined_audio.export(final_audio_path, format="mp3")
-        
-        # Generate conversation text
-        conversation_text = "\n".join(
-            f"{turn.get('speaker', f'Speaker {i+1}')}: {turn['text']}" 
-            for i, turn in enumerate(conversation_json["conversation"])
-        )
-        
-        return final_audio_path, conversation_text
-
-    def _create_output_directory(self) -> str:
-        """Create a unique output directory"""
-        random_bytes = os.urandom(8)
-        folder_name = base64.urlsafe_b64encode(random_bytes).decode("utf-8")
-        os.makedirs(folder_name, exist_ok=True)
-        return folder_name
-
-    def _combine_audio_files(self, filenames: List[str], output_file: str) -> None:
-        """Combine multiple audio files into one"""
-        if not filenames:
-            raise ValueError("No input files provided")
-
-        try:
-            audio_segments = []
-            for filename in filenames:
-                if os.path.exists(filename):
-                    audio_segment = AudioSegment.from_file(filename)
-                    audio_segments.append(audio_segment)
-
-            if audio_segments:
-                combined = sum(audio_segments)
-                combined.export(output_file, format="wav")
-
-            # Clean up temporary files
-            for filename in filenames:
-                if os.path.exists(filename):
-                    os.remove(filename)
-
-        except Exception as e:
-            raise RuntimeError(f"Failed to combine audio files: {e}")
-
-
-# Global converter instance
-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 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)
-        elif input_type == "PDF":
-            if not article_input:
-                return "Please upload a PDF file.", None
-            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()
-        if len(words) > converter.config.max_words:
-            text = " ".join(words[:converter.config.max_words])
-
-        # Extract conversation based on mode
-        if mode == "Local":
-            # 로컬 모드가 기본 (새로운 Local LLM 사용)
-            try:
-                conversation_json = converter.extract_conversation_local(text, language)
-            except Exception as e:
-                print(f"Local mode failed: {e}, trying API fallback")
-                # API 폴백
-                api_key = os.environ.get("TOGETHER_API_KEY")
-                if api_key:
-                    converter.initialize_api_mode(api_key)
-                    conversation_json = converter.extract_conversation_api(text, language)
-                else:
-                    raise RuntimeError("Local mode failed and no API key available for fallback")
-        else:  # API mode (now secondary)
-            api_key = os.environ.get("TOGETHER_API_KEY")
-            if not api_key:
-                print("API key not found, falling back to local mode")
-                conversation_json = converter.extract_conversation_local(text, language)
-            else:
-                try:
-                    converter.initialize_api_mode(api_key)
-                    conversation_json = converter.extract_conversation_api(text, language)
-                except Exception as e:
-                    print(f"API mode failed: {e}, falling back to local mode")
-                    conversation_json = converter.extract_conversation_local(text, language)
-
-        # Generate conversation text
-        conversation_text = "\n".join(
-            f"{turn.get('speaker', f'Speaker {i+1}')}: {turn['text']}" 
-            for i, turn in enumerate(conversation_json["conversation"])
-        )
-
-        return conversation_text, None
-        
-    except Exception as e:
-        return f"Error: {str(e)}", None
-
-
-async def regenerate_audio(conversation_text: str, tts_engine: str = "Edge-TTS", language: str = "English"):
-    """Regenerate audio from edited conversation text"""
-    if not conversation_text.strip():
-        return "Please provide conversation text.", None
-
-    try:
-        # Parse the conversation text back to JSON format
-        conversation_json = converter.parse_conversation_text(conversation_text)
-        
-        if not conversation_json["conversation"]:
-            return "No valid conversation found in the text.", None
-
-        # 한국어인 경우 Edge-TTS만 사용 (다른 TTS는 한국어 지원이 제한적)
-        if language == "Korean" and tts_engine != "Edge-TTS":
-            tts_engine = "Edge-TTS"  # 자동으로 Edge-TTS로 변경
-
-        # Generate audio based on TTS engine
-        if tts_engine == "Edge-TTS":
-            output_file, _ = await converter.text_to_speech_edge(conversation_json, language)
-        elif tts_engine == "Spark-TTS":
-            if not SPARK_AVAILABLE:
-                return "Spark TTS not available. Please install required dependencies and clone the Spark-TTS repository.", None
-            converter.initialize_spark_tts()
-            output_file, _ = converter.text_to_speech_spark(conversation_json, language)
-        else:  # MeloTTS
-            if not MELO_AVAILABLE:
-                return "MeloTTS not available. Please install required dependencies.", None
-            if language == "Korean":
-                return "MeloTTS does not support Korean. Please use Edge-TTS for Korean.", None
-            converter.initialize_melo_tts()
-            output_file, _ = converter.text_to_speech_melo(conversation_json)
-
-        return "Audio generated successfully!", output_file
-        
-    except Exception as e:
-        return f"Error generating audio: {str(e)}", None
-
-
-def synthesize_sync(article_input, input_type: str = "URL", mode: str = "Local", tts_engine: str = "Edge-TTS", language: str = "English"):
-    """Synchronous wrapper for async synthesis"""
-    return asyncio.run(synthesize(article_input, input_type, mode, tts_engine, language))
-
-
-def regenerate_audio_sync(conversation_text: str, tts_engine: str = "Edge-TTS", language: str = "English"):
-    """Synchronous wrapper for async audio regeneration"""
-    return asyncio.run(regenerate_audio(conversation_text, tts_engine, language))
-
-
-def update_tts_engine_for_korean(language):
-    """한국어 선택 시 TTS 엔진 옵션 업데이트"""
-    if language == "Korean":
-        return gr.Radio(
-            choices=["Edge-TTS"],
-            value="Edge-TTS",
-            label="TTS Engine",
-            info="한국어는 Edge-TTS만 지원됩니다",
-            interactive=False
-        )
-    else:
-        return gr.Radio(
-            choices=["Edge-TTS", "Spark-TTS", "MeloTTS"],
-            value="Edge-TTS",
-            label="TTS Engine",
-            info="Edge-TTS: Cloud-based, natural voices | Spark-TTS: Local AI model | MeloTTS: Local, requires GPU",
-            interactive=True
-        )
-
-
-def toggle_input_visibility(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), 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)
-
-
-# 모델 초기화 (앱 시작 시)
-if LLAMA_CPP_AVAILABLE:
-    try:
-        model_path = hf_hub_download(
-            repo_id=converter.config.local_model_repo,
-            filename=converter.config.local_model_name,
-            local_dir="./models"
-        )
-        print(f"Model downloaded to: {model_path}")
-    except Exception as e:
-        print(f"Failed to download model at startup: {e}")
-
-
-# Gradio Interface - 개선된 레이아웃
-with gr.Blocks(theme='soft', title="AI Podcast Generator", css="""
-    .container {max-width: 1200px; margin: auto; padding: 20px;}
-    .header-text {text-align: center; margin-bottom: 30px;}
-    .input-group {background: #f7f7f7; padding: 20px; border-radius: 10px; margin-bottom: 20px;}
-    .output-group {background: #f0f0f0; padding: 20px; border-radius: 10px;}
-    .status-box {background: #e8f4f8; padding: 15px; border-radius: 8px; margin-top: 10px;}
-""") as demo:
-    with gr.Column(elem_classes="container"):
-        # 헤더
-        with gr.Row(elem_classes="header-text"):
-            gr.Markdown("""
-            # 🎙️ AI Podcast Generator - Professional Edition
-            ### Convert any article, blog, PDF document, or topic into an engaging professional podcast conversation with in-depth analysis!
-            """)
-
-        with gr.Row(elem_classes="discord-badge"):
-            gr.HTML("""
-            <p style="text-align: center;">
-                <a href="https://discord.gg/openfreeai" target="_blank">
-                    <img src="https://img.shields.io/static/v1?label=Discord&message=Openfree%20AI&color=%230000ff&labelColor=%23800080&logo=discord&logoColor=white&style=for-the-badge" alt="badge">
-                </a>
-            </p>
-            """)
-
-
-        
-        # 상태 표시 섹션
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown(f"""
-                #### 🤖 System Status
-                - **LLM**: {converter.config.local_model_name.split('.')[0]}
-                - **Fallback**: {converter.config.api_model_name.split('/')[-1]}
-                - **Llama CPP**: {"✅ Ready" if LLAMA_CPP_AVAILABLE else "❌ Not Available"}
-                - **Search**: {"✅ Brave API" if BRAVE_KEY else "❌ No API"}
-                """)
-            with gr.Column(scale=1):
-                gr.Markdown("""
-                #### 📻 Podcast Features
-                - **Length**: 12-15 professional exchanges
-                - **Style**: Expert discussions with data & insights
-                - **Languages**: English & Korean (한국어)
-                - **Input**: URL, PDF, or Keywords
-                """)
-        
-        # 메인 입력 섹션
-        with gr.Group(elem_classes="input-group"):
-            with gr.Row():
-                # 왼쪽: 입력 옵션들
-                with gr.Column(scale=2):
-                    # 입력 타입 선택
-                    input_type_selector = gr.Radio(
-                        choices=["URL", "PDF", "Keyword"],
-                        value="URL",
-                        label="📥 Input Type",
-                        info="Choose your content source"
-                    )
-                    
-                    # URL 입력
-                    url_input = gr.Textbox(
-                        label="🔗 Article URL", 
-                        placeholder="Enter the article URL here...",
-                        value="",
-                        visible=True,
-                        lines=2
-                    )
-                    
-                    # PDF 업로드
-                    pdf_input = gr.File(
-                        label="📄 Upload PDF",
-                        file_types=[".pdf"],
-                        visible=False
-                    )
-                    
-                    # 키워드 입력
-                    keyword_input = gr.Textbox(
-                        label="🔍 Topic/Keyword",
-                        placeholder="Enter a topic (e.g., 'AI trends 2024', '인공지능 최신 동향')",
-                        value="",
-                        visible=False,
-                        info="System will search and compile latest information",
-                        lines=2
-                    )
-                
-                # 오른쪽: 설정 옵션들
-                with gr.Column(scale=1):
-                    # 언어 선택
-                    language_selector = gr.Radio(
-                        choices=["English", "Korean"],
-                        value="English",
-                        label="🌐 Language / 언어",
-                        info="Output language"
-                    )
-                    
-                    # 처리 모드
-                    mode_selector = gr.Radio(
-                        choices=["Local", "API"],
-                        value="Local",
-                        label="⚙️ Processing Mode",
-                        info="Local: On-device | API: Cloud"
-                    )
-                    
-                    # TTS 엔진
-                    tts_selector = gr.Radio(
-                        choices=["Edge-TTS", "Spark-TTS", "MeloTTS"],
-                        value="Edge-TTS",
-                        label="🔊 TTS Engine",
-                        info="Voice synthesis engine"
-                    )
-            
-            # 생성 버튼
-            with gr.Row():
-                convert_btn = gr.Button(
-                    "🎯 Generate Professional Conversation", 
-                    variant="primary", 
-                    size="lg",
-                    scale=1
-                )
-        
-        # 출력 섹션
-        with gr.Group(elem_classes="output-group"):
-            with gr.Row():
-                # 왼쪽: 대화 텍스트
-                with gr.Column(scale=3):
-                    conversation_output = gr.Textbox(
-                        label="💬 Generated Professional Conversation (Editable)",
-                        lines=25,
-                        max_lines=50,
-                        interactive=True,
-                        placeholder="Professional podcast conversation will appear here...\n전문 팟캐스트 대화가 여기에 표시됩니다...",
-                        info="Edit the conversation as needed. Format: 'Speaker Name: Text'"
-                    )
-                    
-                    # 오디오 생성 버튼
-                    with gr.Row():
-                        generate_audio_btn = gr.Button(
-                            "🎙️ Generate Audio from Text", 
-                            variant="secondary", 
-                            size="lg"
-                        )
-                
-                # 오른쪽: 오디오 출력 및 상태
-                with gr.Column(scale=2):
-                    audio_output = gr.Audio(
-                        label="🎧 Professional Podcast Audio",
-                        type="filepath",
-                        interactive=False
-                    )
-                    
-                    status_output = gr.Textbox(
-                        label="📊 Status",
-                        interactive=False,
-                        lines=3,
-                        elem_classes="status-box"
-                    )
-                    
-                    # 도움말
-                    gr.Markdown("""
-                    #### 💡 Quick Tips:
-                    - **URL**: Paste any article link
-                    - **PDF**: Upload documents directly
-                    - **Keyword**: Enter topics for AI research
-                    - Edit conversation before audio generation
-                    - Korean (한국어) fully supported
-                    """)
-        
-        # 예제 섹션
-        with gr.Accordion("📚 Examples", open=False):
-            gr.Examples(
-                examples=[
-                    ["https://huggingface.co/blog/openfree/cycle-navigator", "URL", "Local", "Edge-TTS", "English"],
-                    ["quantum computing breakthroughs", "Keyword", "Local", "Edge-TTS", "English"],
-                    ["https://huggingface.co/papers/2505.14810", "URL", "Local", "Edge-TTS", "Korean"],
-                    ["인공지능 윤리와 규제", "Keyword", "Local", "Edge-TTS", "Korean"],
-                ],
-                inputs=[url_input, input_type_selector, mode_selector, tts_selector, language_selector],
-                outputs=[conversation_output, status_output],
-                fn=synthesize_sync,
-                cache_examples=False,
-            )
-    
-    # Input type change handler
-    input_type_selector.change(
-        fn=toggle_input_visibility,
-        inputs=[input_type_selector],
-        outputs=[url_input, pdf_input, keyword_input]
-    )
-    
-    # 언어 변경 시 TTS 엔진 옵션 업데이트
-    language_selector.change(
-        fn=update_tts_engine_for_korean,
-        inputs=[language_selector],
-        outputs=[tts_selector]
-    )
-    
-    # 이벤트 연결
-    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
-        elif input_type == "PDF":
-            return pdf_input
-        else:  # Keyword
-            return keyword_input
-    
-    convert_btn.click(
-        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, keyword_input, mode_selector, tts_selector, language_selector],
-        outputs=[conversation_output, status_output]
-    )
-    
-    generate_audio_btn.click(
-        fn=regenerate_audio_sync,
-        inputs=[conversation_output, tts_selector, language_selector],
-        outputs=[status_output, audio_output]
-    )
-
-
-# Launch the app
-if __name__ == "__main__":
-    demo.queue(api_open=True, default_concurrency_limit=10).launch(
-        show_api=True,
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860
-    )             
+    )