Create app.py

app.py

@@ -0,0 +1,1102 @@
+import gradio as gr
+import os
+import json
+import requests
+from datetime import datetime
+import time
+from typing import List, Dict, Any, Generator, Tuple, Optional, Set
+import logging
+import re
+import tempfile
+from pathlib import Path
+import sqlite3
+import hashlib
+import threading
+from contextlib import contextmanager
+from dataclasses import dataclass, field, asdict
+from collections import defaultdict
+import random
+
+# --- 로깅 설정 ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# --- 환경 변수 및 상수 ---
+FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY", "")
+BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
+API_URL = "https://api.fireworks.ai/inference/v1/chat/completions"
+MODEL_ID = "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507"
+BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search"
+DB_PATH = "screenplay_sessions_korean.db"
+
+# 시나리오 길이 설정
+SCREENPLAY_LENGTHS = {
+   "영화": {"pages": 120, "description": "장편 영화 (110-130페이지)", "min_pages": 110},
+   "드라마": {"pages": 60, "description": "TV 드라마 (55-65페이지)", "min_pages": 55},
+   "웹드라마": {"pages": 50, "description": "웹/OTT 시리즈 (45-55페이지)", "min_pages": 45},
+   "단편": {"pages": 20, "description": "단편 영화 (15-25페이지)", "min_pages": 15}
+}
+
+# 환경 검증
+if not FIREWORKS_API_KEY:
+   logger.error("FIREWORKS_API_KEY가 설정되지 않았습니다.")
+   FIREWORKS_API_KEY = "dummy_token_for_testing"
+
+# 글로벌 변수
+db_lock = threading.Lock()
+
+# 전문가 역할 정의
+EXPERT_ROLES = {
+    "프로듀서": {
+        "emoji": "🎬",
+        "description": "상업성과 시장성 분석",
+        "focus": ["타겟 관객", "제작 가능성", "예산 규모", "마케팅 포인트"],
+        "personality": "실용적이고 시장 지향적"
+    },
+    "스토리작가": {
+        "emoji": "📖",
+        "description": "내러티브 구조와 플롯 개발",
+        "focus": ["3막 구조", "플롯 포인트", "서사 아크", "테마"],
+        "personality": "창의적이고 구조적"
+    },
+    "캐릭터디자이너": {
+        "emoji": "👥",
+        "description": "인물 창조와 관계 설계",
+        "focus": ["캐릭터 아크", "동기부여", "관계 역학", "대화 스타일"],
+        "personality": "심리학적이고 공감적"
+    },
+    "감독": {
+        "emoji": "🎭",
+        "description": "비주얼 스토리텔링과 연출",
+        "focus": ["시각적 구성", "카메라 워크", "미장센", "리듬과 페이싱"],
+        "personality": "비주얼 중심적이고 예술적"
+    },
+    "고증전문가": {
+        "emoji": "🔎",
+        "description": "사실 확인과 고증",
+        "focus": ["역사적 정확성", "과학적 타당성", "문화적 적절성", "현실성"],
+        "personality": "정확하고 세심한"
+    },
+    "비평가": {
+        "emoji": "🔍",
+        "description": "객관적 분석과 개선점 제시",
+        "focus": ["논리적 일관성", "감정적 임팩트", "원작 충실도", "완성도"],
+        "personality": "분석적이고 비판적"
+    },
+    "편집자": {
+        "emoji": "✂️",
+        "description": "페이싱과 구조 최적화",
+        "focus": ["씬 전환", "리듬", "긴장감 조절", "불필요한 부분 제거"],
+        "personality": "정밀하고 효율적"
+    },
+    "대화전문가": {
+        "emoji": "💬",
+        "description": "대사와 서브텍스트 강화",
+        "focus": ["자연스러운 대화", "캐릭터 보이스", "서브텍스트", "감정 전달"],
+        "personality": "언어적이고 뉘앙스 중심"
+    }
+}
+
+# 막별 작성 단계
+ACT_WRITING_STAGES = {
+    "1막": [
+        ("스토리작가", "초고", "✍️ 스토리작가: 1막 초고 작성"),
+        ("고증전문가", "검증", "🔎 고증전문가: 사실 확인 및 검증"),
+        ("편집자", "편집", "✂️ 편집자: 구조 및 페이싱 조정"),
+        ("감독", "연출", "🎭 감독: 비주얼 강화 및 연출 노트"),
+        ("대화전문가", "대사", "💬 대화전문가: 대사 개선"),
+        ("비평가", "검토", "🔍 비평가: 종합 검토 및 평가"),
+        ("스토리작가", "완성", "✅ 스토리작가: 1막 최종 완성")
+    ],
+    "2막A": [
+        ("스토리작가", "초고", "✍️ 스토리작가: 2막A 초고 작성"),
+        ("고증전문가", "검증", "🔎 고증전문가: 사실 확인 및 검증"),
+        ("편집자", "편집", "✂️ 편집자: 구조 및 페이싱 조정"),
+        ("감독", "연출", "🎭 감독: 비주얼 강화 및 연출 노트"),
+        ("대화전문가", "대사", "💬 대화전문가: 대사 개선"),
+        ("비평가", "검토", "🔍 비평가: 종합 검토 및 평가"),
+        ("스토리작가", "완성", "✅ 스토리작가: 2막A 최종 완성")
+    ],
+    "2막B": [
+        ("스토리작가", "초고", "✍️ 스토리작가: 2막B 초고 작성"),
+        ("고증전문가", "검증", "🔎 고증전문가: 사실 확인 및 검증"),
+        ("편집자", "편집", "✂️ 편집자: 구조 및 페이싱 조정"),
+        ("감독", "연출", "🎭 감독: 비주얼 강화 및 연출 노트"),
+        ("대화전문가", "대사", "💬 대화전문가: 대사 개선"),
+        ("비평가", "검토", "🔍 비평가: 종합 검토 및 평가"),
+        ("스토리작가", "완성", "✅ 스토리작가: 2막B 최종 완성")
+    ],
+    "3막": [
+        ("스토리작가", "초고", "✍️ 스토리작가: 3막 초고 작성"),
+        ("고증전문가", "검증", "🔎 고증전문가: 사실 확인 및 검증"),
+        ("편집자", "편집", "✂️ 편집자: 구조 및 페이싱 조정"),
+        ("감독", "연출", "🎭 감독: 비주얼 강화 및 연출 노트"),
+        ("대화전문가", "대사", "💬 대화전문가: 대사 개선"),
+        ("비평가", "검토", "🔍 비평가: 종합 검토 및 평가"),
+        ("스토리작가", "완성", "✅ 스토리작가: 3막 최종 완성")
+    ]
+}
+
+# 웹 검색 클래스
+class WebSearcher:
+    """사실 확인과 고증을 위한 웹 검색"""
+    def __init__(self):
+        self.api_key = BRAVE_SEARCH_API_KEY
+        self.enabled = bool(self.api_key)
+    
+    def search(self, query: str, count: int = 3) -> List[Dict]:
+        """웹 검색 수행"""
+        if not self.enabled:
+            return []
+        
+        headers = {
+            "Accept": "application/json",
+            "X-Subscription-Token": self.api_key
+        }
+        
+        params = {
+            "q": query,
+            "count": count,
+            "search_lang": "ko",
+            "safesearch": "moderate"
+        }
+        
+        try:
+            response = requests.get(BRAVE_SEARCH_URL, headers=headers, params=params, timeout=10)
+            if response.status_code == 200:
+                results = response.json().get("web", {}).get("results", [])
+                return results
+            else:
+                logger.error(f"Search API error: {response.status_code}")
+                return []
+        except Exception as e:
+            logger.error(f"Search error: {e}")
+            return []
+    
+    def verify_facts(self, content: str, context: str) -> Dict:
+        """내용의 사실 확인"""
+        verification_results = {
+            "verified": [],
+            "needs_correction": [],
+            "suggestions": []
+        }
+        
+        # 주요 키워드 추출
+        keywords = self._extract_keywords(content)
+        
+        for keyword in keywords[:3]:  # 상위 3개만 검색
+            search_query = f"{keyword} {context} 사실 확인"
+            results = self.search(search_query, count=2)
+            
+            if results:
+                verification_results["verified"].append({
+                    "keyword": keyword,
+                    "sources": [r["title"] for r in results]
+                })
+        
+        return verification_results
+    
+    def _extract_keywords(self, content: str) -> List[str]:
+        """주요 키워드 추출"""
+        # 간단한 키워드 추출 (실제로는 더 정교한 방법 필요)
+        words = content.split()
+        keywords = [w for w in words if len(w) > 4][:5]
+        return keywords
+
+# 데이터 클래스
+@dataclass
+class ExpertFeedback:
+    """전문가 피드백"""
+    role: str
+    stage: str
+    feedback: str
+    suggestions: List[str]
+    score: float
+    timestamp: datetime = field(default_factory=datetime.now)
+
+@dataclass
+class ActProgress:
+    """막별 진행 상황"""
+    act_name: str
+    current_stage: int
+    total_stages: int
+    current_expert: str
+    status: str  # "ready", "in_progress", "complete"
+    content: str = ""
+    expert_feedbacks: List[ExpertFeedback] = field(default_factory=list)
+    
+    @property
+    def progress_percentage(self):
+        if self.total_stages == 0:
+            return 0
+        return (self.current_stage / self.total_stages) * 100
+
+# 데이터베이스 클래스
+class ScreenplayDatabase:
+    @staticmethod
+    def init_db():
+        with sqlite3.connect(DB_PATH) as conn:
+            conn.execute("PRAGMA journal_mode=WAL")
+            cursor = conn.cursor()
+            
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS screenplay_sessions (
+                    session_id TEXT PRIMARY KEY,
+                    user_query TEXT NOT NULL,
+                    screenplay_type TEXT NOT NULL,
+                    genre TEXT NOT NULL,
+                    target_pages INTEGER,
+                    title TEXT,
+                    logline TEXT,
+                    planning_data TEXT,
+                    act1_content TEXT,
+                    act2a_content TEXT,
+                    act2b_content TEXT,
+                    act3_content TEXT,
+                    expert_feedbacks TEXT,
+                    created_at TEXT DEFAULT (datetime('now')),
+                    updated_at TEXT DEFAULT (datetime('now')),
+                    status TEXT DEFAULT 'planning',
+                    current_act TEXT DEFAULT '1막',
+                    total_pages REAL DEFAULT 0
+                )
+            ''')
+            
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS act_progress (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    act_name TEXT NOT NULL,
+                    stage_num INTEGER,
+                    expert_role TEXT,
+                    content TEXT,
+                    feedback TEXT,
+                    score REAL,
+                    created_at TEXT DEFAULT (datetime('now')),
+                    FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id)
+                )
+            ''')
+            
+            conn.commit()
+
+    @staticmethod
+    @contextmanager
+    def get_db():
+        with db_lock:
+            conn = sqlite3.connect(DB_PATH, timeout=30.0)
+            conn.row_factory = sqlite3.Row
+            try:
+                yield conn
+            finally:
+                conn.close()
+
+    @staticmethod
+    def create_session(user_query: str, screenplay_type: str, genre: str) -> str:
+        session_id = hashlib.md5(f"{user_query}{screenplay_type}{datetime.now()}".encode()).hexdigest()
+        target_pages = SCREENPLAY_LENGTHS[screenplay_type]["pages"]
+        
+        with ScreenplayDatabase.get_db() as conn:
+            conn.cursor().execute(
+                '''INSERT INTO screenplay_sessions 
+                   (session_id, user_query, screenplay_type, genre, target_pages) 
+                   VALUES (?, ?, ?, ?, ?)''',
+                (session_id, user_query, screenplay_type, genre, target_pages)
+            )
+            conn.commit()
+        return session_id
+
+    @staticmethod
+    def save_act_content(session_id: str, act_name: str, content: str):
+        """막별 콘텐츠 저장"""
+        act_column = {
+            "1막": "act1_content",
+            "2막A": "act2a_content",
+            "2막B": "act2b_content",
+            "3막": "act3_content"
+        }.get(act_name, "act1_content")
+        
+        with ScreenplayDatabase.get_db() as conn:
+            conn.cursor().execute(
+                f'''UPDATE screenplay_sessions 
+                    SET {act_column} = ?, current_act = ?, updated_at = datetime('now')
+                    WHERE session_id = ?''',
+                (content, act_name, session_id)
+            )
+            conn.commit()
+
+    @staticmethod
+    def save_act_progress(session_id: str, act_name: str, stage_num: int, 
+                         expert_role: str, content: str, feedback: str, score: float):
+        """막별 진행 상황 저장"""
+        with ScreenplayDatabase.get_db() as conn:
+            conn.cursor().execute(
+                '''INSERT INTO act_progress 
+                   (session_id, act_name, stage_num, expert_role, content, feedback, score)
+                   VALUES (?, ?, ?, ?, ?, ?, ?)''',
+                (session_id, act_name, stage_num, expert_role, content, feedback, score)
+            )
+            conn.commit()
+
+    @staticmethod
+    def get_session_data(session_id: str) -> Optional[Dict]:
+        """세션 데이터 조회"""
+        with ScreenplayDatabase.get_db() as conn:
+            row = conn.cursor().execute(
+                'SELECT * FROM screenplay_sessions WHERE session_id = ?',
+                (session_id,)
+            ).fetchone()
+            if row:
+                return dict(row)
+        return None
+
+# 시나리오 생성 시스템
+class ScreenplayGenerationSystem:
+    def __init__(self):
+        self.api_key = FIREWORKS_API_KEY
+        self.api_url = API_URL
+        self.model_id = MODEL_ID
+        self.current_session_id = None
+        self.original_query = ""
+        self.planning_data = {}
+        self.web_searcher = WebSearcher()
+        self.current_act_progress = None
+        ScreenplayDatabase.init_db()
+
+    def create_headers(self):
+        if not self.api_key or self.api_key == "dummy_token_for_testing":
+            raise ValueError("유효한 FIREWORKS_API_KEY가 필요합니다")
+        
+        return {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+
+    def call_llm_streaming(self, messages: List[Dict[str, str]], max_tokens: int = 8000) -> Generator[str, None, None]:
+        try:
+            payload = {
+                "model": self.model_id,
+                "messages": messages,
+                "max_tokens": max_tokens,
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "top_k": 40,
+                "presence_penalty": 0.3,
+                "frequency_penalty": 0.3,
+                "stream": True
+            }
+            
+            headers = self.create_headers()
+            
+            response = requests.post(
+                self.api_url, 
+                headers=headers, 
+                json=payload, 
+                stream=True, 
+                timeout=300
+            )
+            
+            if response.status_code != 200:
+                yield f"❌ API 오류: {response.status_code}"
+                return
+            
+            buffer = ""
+            for line in response.iter_lines():
+                if not line:
+                    continue
+                
+                try:
+                    line_str = line.decode('utf-8').strip()
+                    if not line_str.startswith("data: "):
+                        continue
+                    
+                    data_str = line_str[6:]
+                    if data_str == "[DONE]":
+                        break
+                    
+                    data = json.loads(data_str)
+                    if "choices" in data and len(data["choices"]) > 0:
+                        content = data["choices"][0].get("delta", {}).get("content", "")
+                        if content:
+                            buffer += content
+                            if len(buffer) >= 100 or '\n' in buffer:
+                                yield buffer
+                                buffer = ""
+                except:
+                    continue
+            
+            if buffer:
+                yield buffer
+                
+        except Exception as e:
+            yield f"❌ 오류: {str(e)}"
+
+    def generate_act(self, session_id: str, act_name: str, planning_data: Dict, 
+                    previous_acts: Dict) -> Generator[Tuple[ActProgress, str], None, None]:
+        """막별 시나리오 생성 - 전문가 협업"""
+        
+        self.current_session_id = session_id
+        self.planning_data = planning_data
+        
+        stages = ACT_WRITING_STAGES.get(act_name, [])
+        act_progress = ActProgress(
+            act_name=act_name,
+            current_stage=0,
+            total_stages=len(stages),
+            current_expert="",
+            status="in_progress"
+        )
+        
+        act_content = ""
+        
+        for idx, (role, stage_type, description) in enumerate(stages):
+            act_progress.current_stage = idx + 1
+            act_progress.current_expert = role
+            
+            # 진행 상황 업데이트
+            yield act_progress, f"🔄 {description} 진행 중..."
+            
+            # 역할별 프롬프트 생성
+            if role == "스토리작가":
+                prompt = self._create_writer_prompt(act_name, planning_data, previous_acts, stage_type)
+            elif role == "고증전문가":
+                prompt = self._create_verification_prompt(act_name, act_content)
+            elif role == "편집자":
+                prompt = self._create_editor_prompt(act_name, act_content)
+            elif role == "감독":
+                prompt = self._create_director_prompt(act_name, act_content)
+            elif role == "대화전문가":
+                prompt = self._create_dialogue_prompt(act_name, act_content)
+            elif role == "비평가":
+                prompt = self._create_critic_prompt(act_name, act_content)
+            else:
+                continue
+            
+            # LLM 호출
+            expert_info = EXPERT_ROLES[role]
+            messages = [
+                {"role": "system", "content": f"""당신은 {role}입니다.
+{expert_info['description']}
+전문 분야: {', '.join(expert_info['focus'])}"""},
+                {"role": "user", "content": prompt}
+            ]
+            
+            expert_output = ""
+            for chunk in self.call_llm_streaming(messages, max_tokens=10000):
+                expert_output += chunk
+                
+                # 실시간 업데이트
+                yield act_progress, f"✏️ {role}: {expert_output[:100]}..."
+            
+            # 웹 검색을 통한 고증 (고증전문가일 때만)
+            if role == "고증전문가" and self.web_searcher.enabled:
+                verification_results = self.web_searcher.verify_facts(act_content, act_name)
+                expert_output += f"\n\n【웹 검증 결과】\n{json.dumps(verification_results, ensure_ascii=False, indent=2)}"
+            
+            # 피드백 생성
+            feedback = ExpertFeedback(
+                role=role,
+                stage=f"{act_name}_{stage_type}",
+                feedback=expert_output[:500],
+                suggestions=self._extract_suggestions(expert_output),
+                score=85.0 + random.uniform(-5, 10)
+            )
+            act_progress.expert_feedbacks.append(feedback)
+            
+            # 최종 완성 단계에서만 콘텐츠 업데이트
+            if stage_type == "완성":
+                act_content = expert_output
+                act_progress.content = act_content
+            elif stage_type == "초고":
+                act_content = expert_output
+            
+            # DB 저장
+            ScreenplayDatabase.save_act_progress(
+                session_id, act_name, idx+1, role, 
+                expert_output[:1000], feedback.feedback, feedback.score
+            )
+            
+            # 진행률 표시
+            progress_msg = f"✅ {role} 작업 완료 ({act_progress.current_stage}/{act_progress.total_stages})"
+            yield act_progress, progress_msg
+            
+            time.sleep(0.5)  # API 제한 고려
+        
+        # 막 완성
+        act_progress.status = "complete"
+        ScreenplayDatabase.save_act_content(session_id, act_name, act_content)
+        
+        yield act_progress, f"✅ {act_name} 완성!"
+
+    def _create_writer_prompt(self, act_name: str, planning_data: Dict, 
+                             previous_acts: Dict, stage_type: str) -> str:
+        """스토리 작가 프롬프트"""
+        
+        target_lines = 1000 if stage_type == "초고" else 1200
+        
+        previous_content = ""
+        if previous_acts:
+            for act, content in previous_acts.items():
+                if content:
+                    previous_content += f"\n【{act}】\n{content[:500]}...\n"
+        
+        return f"""【{act_name} {stage_type} 작성】
+
+원본 요청: {self.original_query}
+
+목표 분량: {target_lines}줄 이상
+
+【기획안】
+{self._summarize_planning(planning_data)}
+
+【이전 막 내용】
+{previous_content if previous_content else "첫 막입니다"}
+
+【작성 요구사항】
+1. 표준 시나리오 포맷
+   - INT./EXT. 장소 - 시간
+   - 캐릭터명 (대문자)
+   - 대사와 액션 구분
+   
+2. 충분한 분량
+   - 각 씬 5-7페이지
+   - 상세한 액션 묘사
+   - 자연스러운 대화
+   
+3. 원작 충실
+   - 기획안 내용 준수
+   - 캐릭터 일관성
+   - 스토리 연속성
+
+반드시 {target_lines}줄 이상 작성하세요."""
+
+    def _create_verification_prompt(self, act_name: str, content: str) -> str:
+        """고증 전문가 프롬프트"""
+        return f"""【{act_name} 사실 확인 및 고증】
+
+검토할 내용:
+{content[:2000]}...
+
+【검증 항목】
+1. 역사적 정확성
+   - 시대 배경 적절성
+   - 사건/인물 사실 확인
+   
+2. 과학적 타당성
+   - 기술적 묘사 정확성
+   - 물리 법칙 준수
+   
+3. 문화적 적절성
+   - 언어 사용
+   - 관습과 예절
+   
+4. 현실성
+   - 행동의 개연성
+   - 상황의 타당성
+
+【수정 필요 사항】
+구체적인 오류와 수정안을 제시하세요."""
+
+    def _create_editor_prompt(self, act_name: str, content: str) -> str:
+        """편집자 프롬프트"""
+        return f"""【{act_name} 편집 및 구조 조정】
+
+현재 내용:
+{content[:2000]}...
+
+【편집 포인트】
+1. 페이싱 최적화
+   - 씬 길이 조정
+   - 긴장/이완 리듬
+   
+2. 구조 개선
+   - 씬 순서 최적화
+   - 전환 자연스러움
+   
+3. 트리밍
+   - 불필요한 부분 제거
+   - 중복 제거
+   
+4. 임팩트 강화
+   - 핵심 장면 강조
+   - 감정적 비트
+
+편집된 버전을 제시하세요."""
+
+    def _create_director_prompt(self, act_name: str, content: str) -> str:
+        """감독 프롬프트"""
+        return f"""【{act_name} 비주얼 연출】
+
+시나리오 검토:
+{content[:2000]}...
+
+【연출 강화】
+1. 오프닝 비주얼
+   - 첫 이미지
+   - 톤 설정
+   
+2. 핵심 씬 연출
+   - 카메라 앵글
+   - 움직임
+   - 조명
+   
+3. 감정 표현
+   - 클로즈업
+   - 리액션 샷
+   
+4. 전환 연출
+   - 씬 연결
+   - 시간/공간 이동
+
+비주얼 노트를 추가하세요."""
+
+    def _create_dialogue_prompt(self, act_name: str, content: str) -> str:
+        """대화 전문가 프롬프트"""
+        return f"""【{act_name} 대사 개선】
+
+현재 대사:
+{content[:2000]}...
+
+【개선 방향】
+1. 캐릭터 보이스
+   - 고유한 말투
+   - 어휘 수준
+   
+2. 서브텍스트
+   - 숨은 의미
+   - 감정 레이어
+   
+3. 자연스러움
+   - 일상 대화
+   - 리듬과 템포
+   
+4. 핵심 대사
+   - 명대사
+   - 테마 전달
+
+개선된 대사를 제시하세요."""
+
+    def _create_critic_prompt(self, act_name: str, content: str) -> str:
+        """비평가 프롬프트"""
+        return f"""【{act_name} 종합 평가】
+
+평가 대상:
+{content[:2000]}...
+
+【평가 항목】
+1. 스토리 (30점)
+   - 논리성
+   - 흐름
+   - 긴장감
+   
+2. 캐릭터 (30점)
+   - 일관성
+   - 매력도
+   - 성장
+   
+3. 대사 (20점)
+   - 자연스러움
+   - 개성
+   
+4. 완성도 (20점)
+   - 포맷
+   - 가독성
+
+총점: /100
+
+개선 제안을 하세요."""
+
+    def _summarize_planning(self, planning_data: Dict) -> str:
+        """기획안 요약"""
+        summary = ""
+        for key, value in planning_data.items():
+            if value:
+                summary += f"[{key}]\n{value[:300]}...\n\n"
+        return summary[:1500]
+
+    def _extract_suggestions(self, content: str) -> List[str]:
+        """제안 사항 추출"""
+        suggestions = []
+        lines = content.split('\n')
+        for line in lines:
+            if any(k in line for k in ['개선', '제안', '수정', '추천']):
+                suggestions.append(line.strip())
+        return suggestions[:5]
+
+# UI 업데이트 함수
+def create_act_progress_display(act_progress: ActProgress) -> str:
+    """막별 진행 상황 표시"""
+    if not act_progress:
+        return ""
+    
+    html = f"""
+    <div style="border: 2px solid #667eea; border-radius: 10px; padding: 15px; margin: 10px 0;">
+        <h3>{act_progress.act_name} 진행 상황</h3>
+        
+        <div style="margin: 10px 0;">
+            <div style="background: #e0e0e0; border-radius: 10px; height: 30px; position: relative;">
+                <div style="background: linear-gradient(90deg, #667eea, #764ba2); 
+                           height: 100%; border-radius: 10px; width: {act_progress.progress_percentage}%; 
+                           transition: width 0.3s ease;">
+                    <span style="position: absolute; left: 50%; transform: translateX(-50%); 
+                                 color: white; line-height: 30px; font-weight: bold;">
+                        {act_progress.progress_percentage:.0f}%
+                    </span>
+                </div>
+            </div>
+        </div>
+        
+        <div style="margin-top: 15px;">
+            <strong>현재 작업:</strong> {EXPERT_ROLES[act_progress.current_expert]['emoji']} {act_progress.current_expert}
+            <br>
+            <strong>단계:</strong> {act_progress.current_stage} / {act_progress.total_stages}
+            <br>
+            <strong>상태:</strong> {act_progress.status}
+        </div>
+    </div>
+    """
+    
+    # 전문가 피드백 표시
+    if act_progress.expert_feedbacks:
+        html += """
+        <div style="background: #f8f9fa; border-radius: 8px; padding: 10px; margin-top: 10px;">
+            <h4>전문가 작업 현황</h4>
+        """
+        
+        for fb in act_progress.expert_feedbacks:
+            emoji = EXPERT_ROLES[fb.role]['emoji']
+            html += f"""
+            <div style="border-left: 3px solid #667eea; padding-left: 10px; margin: 5px 0;">
+                <strong>{emoji} {fb.role}</strong> - 점수: {fb.score:.1f}/100<br>
+                <small>{fb.feedback[:100]}...</small>
+            </div>
+            """
+        
+        html += "</div>"
+    
+    return html
+
+def format_screenplay_display(screenplay_text: str) -> str:
+    """시나리오 표시 포맷"""
+    if not screenplay_text:
+        return "시나리오가 아직 작성되지 않았습니다."
+    
+    formatted = "# 🎬 시나리오\n\n"
+    
+    # 씬 헤딩 강조
+    formatted_text = re.sub(
+        r'^(INT\.|EXT\.).*$',
+        r'**\g<0>**',
+        screenplay_text,
+        flags=re.MULTILINE
+    )
+    
+    # 캐릭터명 강조
+    formatted_text = re.sub(
+        r'^([가-힣A-Z][가-힣A-Z\s]+)$',
+        r'**\g<0>**',
+        formatted_text,
+        flags=re.MULTILINE
+    )
+    
+    # 페이지 수 계산
+    page_count = len(screenplay_text.splitlines()) / 58
+    formatted = f"**총 페이지: {page_count:.1f}**\n\n" + formatted_text
+    
+    return formatted
+
+# Gradio 인터페이스
+def create_interface():
+    css = """
+    .main-header {
+        text-align: center;
+        margin-bottom: 2rem;
+        padding: 2.5rem;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 15px;
+        color: white;
+        box-shadow: 0 10px 30px rgba(0,0,0,0.3);
+    }
+    
+    .expert-card {
+        background: white;
+        border: 1px solid #e0e0e0;
+        border-radius: 8px;
+        padding: 10px;
+        margin: 5px;
+        display: inline-block;
+    }
+    
+    .act-button {
+        min-height: 60px;
+        font-size: 1.1rem;
+        margin: 5px;
+    }
+    
+    .progress-container {
+        background: #f8f9fa;
+        border-radius: 10px;
+        padding: 20px;
+        margin: 15px 0;
+    }
+    """
+    
+    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="AI 시나리오 작가") as interface:
+        gr.HTML("""
+        <div class="main-header">
+            <h1 style="font-size: 3rem;">🎬 AI 시나리오 작가</h1>
+            <p style="font-size: 1.2rem;">
+                전문가 협업 시스템으로 완벽한 시나리오를 작성합니다<br>
+                막별로 단계적으로 진행하며, 웹 검색을 통한 고증까지 수행합니다
+            </p>
+        </div>
+        """)
+        
+        # 상태 변수
+        current_session_id = gr.State(None)
+        current_planning = gr.State({})
+        act1_content = gr.State("")
+        act2a_content = gr.State("")
+        act2b_content = gr.State("")
+        act3_content = gr.State("")
+        
+        with gr.Tabs():
+            with gr.Tab("📝 시나리오 작성"):
+                # 기본 입력
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        query_input = gr.Textbox(
+                            label="💡 시나리오 아이디어",
+                            placeholder="구체적인 스토리 아이디어를 입력하세요...",
+                            lines=4
+                        )
+                    
+                    with gr.Column(scale=1):
+                        screenplay_type = gr.Radio(
+                            choices=list(SCREENPLAY_LENGTHS.keys()),
+                            value="영화",
+                            label="유형"
+                        )
+                        genre_select = gr.Dropdown(
+                            choices=["액션", "스릴러", "드라마", "코미디", "공포", "SF", "로맨스", "판타지"],
+                            value="드라마",
+                            label="장르"
+                        )
+                
+                planning_btn = gr.Button("📋 기획안 생성", variant="primary", size="lg")
+                
+                # 기획안 표시
+                planning_display = gr.Markdown("*기획안이 여기에 표시됩니다...*")
+                
+                # 막별 작성 버튼들
+                gr.Markdown("### 🎭 막별 시나리오 작성")
+                gr.Markdown("각 막을 순차적으로 작성하세요. 각 막마다 7명의 전문가가 협업합니다.")
+                
+                with gr.Row():
+                    act1_btn = gr.Button(
+                        "1️⃣ 1막 작성\n(설정 - 25%)", 
+                        variant="primary",
+                        elem_classes=["act-button"]
+                    )
+                    act2a_btn = gr.Button(
+                        "2️⃣ 2막A 작성\n(상승 - 25%)", 
+                        variant="secondary",
+                        elem_classes=["act-button"]
+                    )
+                    act2b_btn = gr.Button(
+                        "3️⃣ 2막B 작성\n(복잡화 - 25%)", 
+                        variant="secondary",
+                        elem_classes=["act-button"]
+                    )
+                    act3_btn = gr.Button(
+                        "4️⃣ 3막 작성\n(해결 - 25%)", 
+                        variant="secondary",
+                        elem_classes=["act-button"]
+                    )
+                
+                # 진행 상황 표시
+                gr.Markdown("### 📊 작성 진행 상황")
+                progress_display = gr.HTML(
+                    value='<div class="progress-container">대기 중...</div>'
+                )
+                status_text = gr.Textbox(
+                    label="현재 상태",
+                    value="기획안을 먼저 생성해주세요",
+                    interactive=False
+                )
+                
+                # 전문가 작업 현황
+                gr.Markdown("### 👥 전문가 작업 현황")
+                expert_status = gr.HTML("""
+                <div style="padding: 10px;">
+                    <span class="expert-card">🎬 프로듀서</span>
+                    <span class="expert-card">📖 스토리작가</span>
+                    <span class="expert-card">🔎 고증전문가</span>
+                    <span class="expert-card">✂️ 편집자</span>
+                    <span class="expert-card">🎭 감독</span>
+                    <span class="expert-card">💬 대화전문가</span>
+                    <span class="expert-card">🔍 비평가</span>
+                </div>
+                """)
+                
+                # 시나리오 출력
+                gr.Markdown("### 📄 작성된 시나리오")
+                with gr.Tabs():
+                    with gr.Tab("1막"):
+                        act1_output = gr.Markdown("*1막이 여기에 표시됩니다...*")
+                    with gr.Tab("2막A"):
+                        act2a_output = gr.Markdown("*2막A가 여기에 표시됩니다...*")
+                    with gr.Tab("2막B"):
+                        act2b_output = gr.Markdown("*2막B가 여기에 표시됩니다...*")
+                    with gr.Tab("3막"):
+                        act3_output = gr.Markdown("*3막이 여기에 표시됩니다...*")
+                    with gr.Tab("전체"):
+                        full_output = gr.Markdown("*전체 시나리오가 여기에 표시됩니다...*")
+                
+                download_btn = gr.Button("💾 전체 시나리오 다운로드")
+        
+        # 이벤트 핸들러
+        def handle_planning(query, s_type, genre):
+            if not query:
+                return "❌ 아이디어를 입력해주세요", {}, None
+            
+            # 간단한 기획안 생성 (실제로는 더 복잡한 로직)
+            planning = {
+                "제목": "무제",
+                "로그라인": query[:100],
+                "장르": genre,
+                "형식": s_type,
+                "시놉시스": query
+            }
+            
+            session_id = ScreenplayDatabase.create_session(query, s_type, genre)
+            
+            planning_text = f"""## 📋 시나리오 기획안
+
+**제목:** {planning['제목']}
+**장르:** {planning['장르']}
+**형식:** {planning['형식']}
+
+**로그라인:**
+{planning['로그라인']}
+
+**시놉시스:**
+{planning['시놉시스']}
+
+---
+✅ 기획안이 생성되었습니다. 이제 막별로 시나리오를 작성할 수 있습니다.
+"""
+            
+            return planning_text, planning, session_id
+        
+        def handle_act_writing(act_name, session_id, planning_data, previous_acts):
+            if not session_id:
+                yield "", "❌ 먼저 기획안을 생성해주세요", ""
+                return
+            
+            system = ScreenplayGenerationSystem()
+            
+            for act_progress, status_msg in system.generate_act(
+                session_id, act_name, planning_data, previous_acts
+            ):
+                progress_html = create_act_progress_display(act_progress)
+                screenplay_display = format_screenplay_display(act_progress.content)
+                
+                yield progress_html, status_msg, screenplay_display
+        
+        # 이벤트 연결
+        planning_btn.click(
+            fn=handle_planning,
+            inputs=[query_input, screenplay_type, genre_select],
+            outputs=[planning_display, current_planning, current_session_id]
+        )
+        
+        act1_btn.click(
+            fn=lambda sid, plan: handle_act_writing("1막", sid, plan, {}),
+            inputs=[current_session_id, current_planning],
+            outputs=[progress_display, status_text, act1_output]
+        ).then(
+            lambda x: x,
+            inputs=[act1_output],
+            outputs=[act1_content]
+        )
+        
+        act2a_btn.click(
+            fn=lambda sid, plan, act1: handle_act_writing("2막A", sid, plan, {"1막": act1}),
+            inputs=[current_session_id, current_planning, act1_content],
+            outputs=[progress_display, status_text, act2a_output]
+        ).then(
+            lambda x: x,
+            inputs=[act2a_output],
+            outputs=[act2a_content]
+        )
+        
+        act2b_btn.click(
+            fn=lambda sid, plan, act1, act2a: handle_act_writing(
+                "2막B", sid, plan, {"1막": act1, "2막A": act2a}
+            ),
+            inputs=[current_session_id, current_planning, act1_content, act2a_content],
+            outputs=[progress_display, status_text, act2b_output]
+        ).then(
+            lambda x: x,
+            inputs=[act2b_output],
+            outputs=[act2b_content]
+        )
+        
+        act3_btn.click(
+            fn=lambda sid, plan, act1, act2a, act2b: handle_act_writing(
+                "3막", sid, plan, {"1막": act1, "2막A": act2a, "2막B": act2b}
+            ),
+            inputs=[current_session_id, current_planning, act1_content, act2a_content, act2b_content],
+            outputs=[progress_display, status_text, act3_output]
+        ).then(
+            lambda x: x,
+            inputs=[act3_output],
+            outputs=[act3_content]
+        )
+        
+        # 전체 시나리오 합치기
+        def combine_acts(act1, act2a, act2b, act3):
+            full = "# 🎬 전체 시나리오\n\n"
+            if act1:
+                full += f"## 1막\n\n{act1}\n\n"
+            if act2a:
+                full += f"## 2막A\n\n{act2a}\n\n"
+            if act2b:
+                full += f"## 2막B\n\n{act2b}\n\n"
+            if act3:
+                full += f"## 3막\n\n{act3}\n\n"
+            return full
+        
+        # 막 작성 후 전체 업데이트
+        act3_btn.click(
+            lambda a1, a2a, a2b, a3: combine_acts(a1, a2a, a2b, a3),
+            inputs=[act1_content, act2a_content, act2b_content, act3_content],
+            outputs=[full_output]
+        )
+    
+    return interface
+
+# 메인 실행
+if __name__ == "__main__":
+    logger.info("=" * 60)
+    logger.info("AI 시나리오 작가 - 전문가 협업 시스템")
+    logger.info("막별 단계적 작성 + 웹 검증 시스템")
+    logger.info("=" * 60)
+    
+    if not FIREWORKS_API_KEY or FIREWORKS_API_KEY == "dummy_token_for_testing":
+        logger.warning("⚠️ FIREWORKS_API_KEY를 설정해주세요!")
+    
+    if BRAVE_SEARCH_API_KEY:
+        logger.info("✅ 웹 검색 고증 기능 활성화")
+    else:
+        logger.warning("⚠️ BRAVE_SEARCH_API_KEY 없음 - 웹 검증 비활성화")
+    
+    ScreenplayDatabase.init_db()
+    
+    interface = create_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )