feat: 단계별 타임아웃 분리 및 토큰 관리 기능 개선 - 파일 업로드를 단계별로 분리 - 각 단계별 독립적인 타임아웃 설정 - 입력/출력/Parent Chunk 토큰 수 별도 관리 - admin/settings 페이지 개선 - 파일 업로드 진행 상황 메시지 개선 - 가로 스크롤 문제 해결

EXAONE_설치_가이드.md

@@ -154,4 +154,16 @@ tokenizer = AutoTokenizer.from_pretrained("LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct"
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
 

EXAONE_추가_안내.md

@@ -71,4 +71,16 @@ Ollama를 거치지 않고 Python에서 직접 Hugging Face 모델을 사용할
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
 

add_exaone_model.py

@@ -149,4 +149,16 @@ if __name__ == "__main__":
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
 

app/__init__.py

@@ -150,6 +150,24 @@ def migrate_database(app: Flask) -> None:
                 conn.commit()
                 logger.info("document_chunk.chunk_metadata 컬럼 추가 완료")
         
+        # chat_session 테이블이 존재하는지 확인
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='chat_session'")
+        if cursor.fetchone():
+            cursor.execute("PRAGMA table_info(chat_session)")
+            chat_session_columns = [column[1] for column in cursor.fetchall()]
+            
+            if 'analysis_model' not in chat_session_columns:
+                logger.info("chat_session 테이블에 analysis_model 컬럼 추가 중...")
+                cursor.execute("ALTER TABLE chat_session ADD COLUMN analysis_model VARCHAR(100)")
+                conn.commit()
+                logger.info("chat_session.analysis_model 컬럼 추가 완료")
+            
+            if 'answer_model' not in chat_session_columns:
+                logger.info("chat_session 테이블에 answer_model 컬럼 추가 중...")
+                cursor.execute("ALTER TABLE chat_session ADD COLUMN answer_model VARCHAR(100)")
+                conn.commit()
+                logger.info("chat_session.answer_model 컬럼 추가 완료")
+        
         conn.close()
         logger.info("데이터베이스 마이그레이션 완료")
         

app/database.py

@@ -70,7 +70,9 @@ class ChatSession(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
     title = db.Column(db.String(255), nullable=True)
-    model_name = db.Column(db.String(100), nullable=True)
+    model_name = db.Column(db.String(100), nullable=True)  # 하위 호환성을 위해 유지
+    analysis_model = db.Column(db.String(100), nullable=True)  # 질문 분석용 모델
+    answer_model = db.Column(db.String(100), nullable=True)  # 최종 답변용 모델
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
     
@@ -83,7 +85,9 @@ class ChatSession(db.Model):
             'id': self.id,
             'user_id': self.user_id,
             'title': self.title,
-            'model_name': self.model_name,
+            'model_name': self.model_name,  # 하위 호환성
+            'analysis_model': self.analysis_model,
+            'answer_model': self.answer_model,
             'created_at': self.created_at.isoformat() if self.created_at else None,
             'updated_at': self.updated_at.isoformat() if self.updated_at else None,
             'message_count': len(self.messages)

app/routes.py

@@ -31,6 +31,85 @@ def admin_required(f):
 # Ollama 기본 URL (환경 변수로 설정 가능)
 OLLAMA_BASE_URL = os.getenv('OLLAMA_BASE_URL', 'http://localhost:11434')
 
+def get_model_token_limit(model_name, default_tokens=2000, token_type='output'):
+    """모델별 토큰 수 제한 가져오기 (하위 호환성을 위해 기본값은 출력 토큰)
+    
+    Args:
+        model_name: AI 모델명 (예: "gemini-2.0-flash-exp", "gemini:gemini-2.0-flash-exp", "gemma2:9b")
+        default_tokens: 기본 토큰 수 (설정이 없을 때 사용)
+        token_type: 'input' 또는 'output' (기본값: 'output')
+    
+    Returns:
+        토큰 수 (정수)
+    """
+    return get_model_token_limit_by_type(model_name, default_tokens, token_type)
+
+def get_model_token_limit_by_type(model_name, default_tokens=2000, token_type='output'):
+    """모델별 토큰 수 제한 가져오기 (입력/출력/Parent Chunk 구분)
+    
+    Args:
+        model_name: AI 모델명 (예: "gemini-2.0-flash-exp", "gemini:gemini-2.0-flash-exp", "gemma2:9b")
+        default_tokens: 기본 토큰 수 (설정이 없을 때 사용)
+        token_type: 'input', 'output', 또는 'parent_chunk'
+    
+    Returns:
+        토큰 수 (정수)
+    """
+    if not model_name:
+        return default_tokens
+    
+    try:
+        from app.database import SystemConfig
+        
+        # 여러 형식의 모델명을 시도
+        # 1. 원본 모델명 그대로
+        # 2. Gemini 모델의 경우 "gemini:" 접두사 추가/제거 버전
+        # 3. Ollama 모델의 경우 그대로
+        
+        model_name_clean = model_name.strip()
+        possible_keys = [model_name_clean]
+        
+        # Gemini 모델 처리
+        if model_name_clean.startswith('gemini:'):
+            # "gemini:gemini-2.0-flash-exp" -> "gemini:gemini-2.0-flash-exp" (그대로)
+            # 또는 "gemini-2.0-flash-exp" (접두사 제거)
+            possible_keys.append(model_name_clean.replace('gemini:', '', 1))
+        elif model_name_clean.startswith('gemini-'):
+            # "gemini-2.0-flash-exp" -> "gemini:gemini-2.0-flash-exp" (접두사 추가)
+            possible_keys.append(f'gemini:{model_name_clean}')
+        
+        # 각 가능한 키를 시도
+        for key in possible_keys:
+            # 새로운 형식: model_token_input_{model_name}, model_token_output_{model_name}, model_token_parent_chunk_{model_name}
+            config_key = f"model_token_{token_type}_{key}"
+            token_value = SystemConfig.get_config(config_key)
+            if token_value:
+                try:
+                    token_int = int(token_value)
+                    print(f"[get_model_token_limit_by_type] 모델 '{model_name}'의 {token_type} 토큰 수 {token_int} 사용 (키: {config_key})")
+                    return token_int
+                except (ValueError, TypeError):
+                    continue
+            
+            # 하위 호환성: 기존 형식 model_token_{model_name}도 확인 (출력 토큰으로 간주)
+            if token_type == 'output':
+                old_config_key = f"model_token_{key}"
+                token_value = SystemConfig.get_config(old_config_key)
+                if token_value:
+                    try:
+                        token_int = int(token_value)
+                        print(f"[get_model_token_limit_by_type] 모델 '{model_name}'의 출력 토큰 수 {token_int} 사용 (기존 키: {old_config_key})")
+                        return token_int
+                    except (ValueError, TypeError):
+                        continue
+        
+        # 설정이 없으면 기본값 사용
+        print(f"[get_model_token_limit_by_type] 모델 '{model_name}'의 {token_type} 토큰 수 설정이 없어 기본값 {default_tokens} 사용")
+    except Exception as e:
+        print(f"[get_model_token_limit_by_type] 오류: {e}")
+    
+    return default_tokens
+
 # 업로드 설정
 UPLOAD_FOLDER = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'uploads')
 ALLOWED_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'epub'}
@@ -357,7 +436,7 @@ character_relationships는 이 청크에 등장하는 인물들 간의 현재
                         prompt=prompt,
                         model_name="gemini-1.5-flash",
                         temperature=0.3,
-                        max_output_tokens=500
+                        max_output_tokens=get_model_token_limit(model_name or "gemini-1.5-flash", 500)  # 저장된 토큰 수 사용
                     )
                     if not result['error'] and result.get('response'):
                         response_text = result['response'].strip()
@@ -385,7 +464,7 @@ character_relationships는 이 청크에 등장하는 인물들 간의 현재
                         prompt=prompt,
                         model_name=gemini_model_name,
                         temperature=0.3,
-                        max_output_tokens=500
+                        max_output_tokens=get_model_token_limit(model_name or "gemini-1.5-flash", 500)  # 저장된 토큰 수 사용
                     )
                     if not result['error'] and result.get('response'):
                         response_text = result['response'].strip()
@@ -404,7 +483,7 @@ character_relationships는 이 청크에 등장하는 인물들 간의 현재
                             'stream': False,
                             'options': {
                                 'temperature': 0.3,
-                                'num_predict': 500
+                                'num_predict': get_model_token_limit(model_name, 500)  # 저장된 토큰 수 사용
                             }
                         },
                         timeout=120  # 2분 타임아웃
@@ -526,6 +605,15 @@ def analyze_episode(episode_content, episode_title, full_content=None, parent_ch
 ## 인물과 인물간의 관계 변화
 [이 회차에서 인물들 간의 관계가 어떻게 변화했는지, 새로운 관계가 형성되었는지 등을 분석해주세요]
 
+## {episode_title} 인물 외모 분석
+[이 회차에 등장한 인물들의 외모, 체형, 얼굴 특징, 신체적 특징 등을 상세히 분석해주세요. 특히 새로 등장한 인물이나 외모가 변경된 인물에 대해 자세히 설명해주세요]
+
+## {episode_title} 인물 의복 분석
+[이 회차에 등장한 인물들이 착용한 의복, 복장, 액세서리 등을 상세히 분석해주세요. 의복의 스타일, 색상, 특징, 상황에 맞는 복장인지 등을 분석해주세요]
+
+## {episode_title} 배경 분석
+[이 회차의 배경이 되는 장소, 환경, 시간대, 분위기 등을 상세히 분석해주세요. 장소의 특징, 분위기, 시간적 배경, 날씨, 계절 등을 포함하여 분석해주세요]
+
 ## 기타
 [이 회차의 특별한 점, 중요 사건, 떡밥, 복선 등 기타 중요한 내용을 분석해주세요]
 
@@ -541,7 +629,7 @@ def analyze_episode(episode_content, episode_title, full_content=None, parent_ch
                         prompt=prompt,
                         model_name="gemini-1.5-flash",
                         temperature=0.5,
-                        max_output_tokens=2000
+                        max_output_tokens=get_model_token_limit("gemini-1.5-flash", 3000)  # 저장된 토큰 수 사용
                     )
                     if not result['error'] and result.get('response'):
                         return result['response'].strip()
@@ -564,7 +652,7 @@ def analyze_episode(episode_content, episode_title, full_content=None, parent_ch
                         prompt=prompt,
                         model_name=gemini_model_name,
                         temperature=0.5,
-                        max_output_tokens=2000
+                        max_output_tokens=get_model_token_limit(model_name, 3000)  # 저장된 토큰 수 사용
                     )
                     if not result['error'] and result.get('response'):
                         return result['response'].strip()
@@ -579,7 +667,7 @@ def analyze_episode(episode_content, episode_title, full_content=None, parent_ch
                             'stream': False,
                             'options': {
                                 'temperature': 0.5,
-                                'num_predict': 2000
+                                'num_predict': get_model_token_limit(model_name, 3000)  # 저장된 토큰 수 사용
                             }
                         },
                         timeout=300  # 5분 타임아웃 (회차 분석은 시간이 오래 걸릴 수 있음)
@@ -813,7 +901,7 @@ def extract_graph_from_episode(episode_content, episode_title, file_id, full_con
         db.session.rollback()
         return False
 
-def create_chunks_for_file(file_id, content):
+def create_chunks_for_file(file_id, content, skip_episode_analysis=False, skip_graph_extraction=False):
     """파일 내용을 섹션별로 분할하여 의미 기반 청크로 저장 (벡터 DB 포함)
     
     섹션 분할 규칙:
@@ -823,6 +911,8 @@ def create_chunks_for_file(file_id, content):
     Args:
         file_id: 파일 ID
         content: 파일 내용
+        skip_episode_analysis: 회차 분석 건너뛰기 (기본값: False)
+        skip_graph_extraction: Graph Extraction 건너뛰기 (기본값: False)
     """
     try:
         print(f"[청크 생성] 파일 ID {file_id}에 대한 청크 생성 시작")
@@ -865,7 +955,7 @@ def create_chunks_for_file(file_id, content):
         
         # '#작품설명'을 제외한 각 회차 분석
         episode_sections = [s for s in sections if s[0] != '작품설명']  # section_type이 '작품설명'이 아닌 것만
-        if episode_sections and model_name:
+        if episode_sections and model_name and not skip_episode_analysis:
             print(f"[회차 분석] {len(episode_sections)}개 회차 분석 시작...")
             
             # Parent Chunk 가져오기
@@ -915,31 +1005,32 @@ def create_chunks_for_file(file_id, content):
                 print(f"[회차 분석] 완료: {len(episode_sections)}개 회차 분석 ���과를 하나의 텍스트로 저장")
                 
                 # 회차별 Graph Extraction 실행
-                print(f"[Graph Extraction] 회차별 Graph Extraction 시작...")
-                graph_extraction_success_count = 0
-                for section_type, section_title, section_content, section_metadata in episode_sections:
-                    try:
-                        print(f"[Graph Extraction] '{section_title}' Graph Extraction 중...")
-                        success = extract_graph_from_episode(
-                            episode_content=section_content,
-                            episode_title=section_title,
-                            file_id=file_id,
-                            full_content=content,
-                            parent_chunk=parent_chunk,
-                            model_name=model_name
-                        )
-                        if success:
-                            graph_extraction_success_count += 1
-                            print(f"[Graph Extraction] '{section_title}' Graph Extraction 완료")
-                        else:
-                            print(f"[Graph Extraction] '{section_title}' Graph Extraction 실패")
-                    except Exception as e:
-                        print(f"[Graph Extraction] '{section_title}' Graph Extraction 중 오류: {str(e)}")
-                        import traceback
-                        traceback.print_exc()
-                        continue
-                
-                print(f"[Graph Extraction] 완료: {graph_extraction_success_count}/{len(episode_sections)}개 회차 Graph Extraction 성공")
+                if not skip_graph_extraction:
+                    print(f"[Graph Extraction] 회차별 Graph Extraction 시작...")
+                    graph_extraction_success_count = 0
+                    for section_type, section_title, section_content, section_metadata in episode_sections:
+                        try:
+                            print(f"[Graph Extraction] '{section_title}' Graph Extraction 중...")
+                            success = extract_graph_from_episode(
+                                episode_content=section_content,
+                                episode_title=section_title,
+                                file_id=file_id,
+                                full_content=content,
+                                parent_chunk=parent_chunk,
+                                model_name=model_name
+                            )
+                            if success:
+                                graph_extraction_success_count += 1
+                                print(f"[Graph Extraction] '{section_title}' Graph Extraction 완료")
+                            else:
+                                print(f"[Graph Extraction] '{section_title}' Graph Extraction 실패")
+                        except Exception as e:
+                            print(f"[Graph Extraction] '{section_title}' Graph Extraction 중 오류: {str(e)}")
+                            import traceback
+                            traceback.print_exc()
+                            continue
+                    
+                    print(f"[Graph Extraction] 완료: {graph_extraction_success_count}/{len(episode_sections)}개 회차 Graph Extraction 성공")
             else:
                 print(f"[회차 분석] 경고: 분석 결과가 없습니다.")
         else:
@@ -1094,7 +1185,7 @@ def create_parent_chunk_with_ai(file_id, content, model_name):
                 prompt=analysis_prompt,
                 model_name=gemini_model_name,
                 temperature=0.7,
-                max_output_tokens=8192
+                max_output_tokens=get_model_token_limit_by_type(model_name or "gemini-1.5-flash", 8192, 'parent_chunk')  # Parent Chunk 전용 토큰 수 사용
             )
             
             if result['error']:
@@ -1666,6 +1757,12 @@ def admin_prompts():
     """프롬프트 관리 페이지"""
     return render_template('admin_prompts.html')
 
+@main_bp.route('/admin/settings')
+@admin_required
+def admin_settings():
+    """AI 설정 관리 페이지 (API 키, 토큰 수)"""
+    return render_template('admin_settings.html')
+
 @main_bp.route('/admin/files')
 @admin_required
 def admin_files():
@@ -1764,6 +1861,7 @@ def get_all_messages():
     try:
         user_id = request.args.get('user_id', type=int)
         session_id = request.args.get('session_id', type=int)
+        message_id = request.args.get('message_id', type=int)
         page = request.args.get('page', 1, type=int)
         per_page = request.args.get('per_page', 50, type=int)
         
@@ -1773,6 +1871,8 @@ def get_all_messages():
             query = query.filter(ChatSession.user_id == user_id)
         if session_id:
             query = query.filter(ChatMessage.session_id == session_id)
+        if message_id:
+            query = query.filter(ChatMessage.id == message_id)
         
         messages = query.order_by(ChatMessage.created_at.desc())\
             .paginate(page=page, per_page=per_page, error_out=False)
@@ -1861,6 +1961,201 @@ def get_gemini_api_key():
         traceback.print_exc()
         return jsonify({'error': f'API 키 조회 중 오류가 발생했습니다: {str(e)}'}), 500
 
+@main_bp.route('/api/admin/model-tokens', methods=['GET'])
+@admin_required
+def get_model_tokens():
+    """모든 모델의 토큰 수 설정 조회 (입력/출력 분리)"""
+    try:
+        # Ollama 모델 목록 가져오기
+        ollama_models = []
+        try:
+            response = requests.get(f'{OLLAMA_BASE_URL}/api/tags', timeout=5)
+            if response.status_code == 200:
+                data = response.json()
+                ollama_models = [model['name'] for model in data.get('models', [])]
+        except:
+            pass
+        
+        # Gemini 모델 목록 가져오기
+        gemini_models = []
+        try:
+            gemini_client = get_gemini_client()
+            if gemini_client.is_configured():
+                gemini_models = gemini_client.get_available_models()
+                gemini_models = [f'gemini:{m}' for m in gemini_models]
+        except:
+            pass
+        
+        # 모든 모델 목록
+        all_models = ollama_models + gemini_models
+        
+        # 각 모델의 토큰 수 설정 가져오기 (입력/출력/Parent Chunk 분리)
+        model_input_tokens = {}
+        model_output_tokens = {}
+        model_parent_chunk_tokens = {}
+        default_input_tokens = {}
+        default_output_tokens = {}
+        default_parent_chunk_tokens = {}
+        
+        # 모델별 기본값 결정
+        def get_default_token_for_model(model_name, token_type='output'):
+            """모델별 기본 토큰 수 결정"""
+            if not model_name:
+                if token_type == 'parent_chunk':
+                    return 8192
+                return 2000 if token_type == 'output' else 100000
+            
+            # Gemini 모델의 경우
+            if model_name.startswith('gemini:'):
+                if token_type == 'parent_chunk':
+                    return 8192  # Parent Chunk 기본값
+                return 2000 if token_type == 'output' else 100000  # Gemini 입력 기본값은 더 큼
+            
+            # Ollama 모델의 경우
+            if token_type == 'parent_chunk':
+                return 8192  # Parent Chunk 기본값
+            return 2000 if token_type == 'output' else 100000  # Ollama 입력 기본값도 더 큼
+        
+        for model_name in all_models:
+            # 입력 토큰 설정 가져오기
+            input_config_key = f"model_token_input_{model_name}"
+            input_token_value = SystemConfig.get_config(input_config_key)
+            default_input_token = get_default_token_for_model(model_name, 'input')
+            default_input_tokens[model_name] = default_input_token
+            
+            if input_token_value:
+                try:
+                    model_input_tokens[model_name] = int(input_token_value)
+                except (ValueError, TypeError):
+                    model_input_tokens[model_name] = None
+            else:
+                model_input_tokens[model_name] = None
+            
+            # 출력 토큰 설정 가져오기
+            output_config_key = f"model_token_output_{model_name}"
+            output_token_value = SystemConfig.get_config(output_config_key)
+            # 하위 호환성: 기존 형식도 확인
+            if not output_token_value:
+                old_config_key = f"model_token_{model_name}"
+                output_token_value = SystemConfig.get_config(old_config_key)
+            
+            default_output_token = get_default_token_for_model(model_name, 'output')
+            default_output_tokens[model_name] = default_output_token
+            
+            if output_token_value:
+                try:
+                    model_output_tokens[model_name] = int(output_token_value)
+                except (ValueError, TypeError):
+                    model_output_tokens[model_name] = None
+            else:
+                model_output_tokens[model_name] = None
+            
+            # Parent Chunk 토큰 설정 가져오기
+            parent_chunk_config_key = f"model_token_parent_chunk_{model_name}"
+            parent_chunk_token_value = SystemConfig.get_config(parent_chunk_config_key)
+            default_parent_chunk_token = get_default_token_for_model(model_name, 'parent_chunk')
+            default_parent_chunk_tokens[model_name] = default_parent_chunk_token
+            
+            if parent_chunk_token_value:
+                try:
+                    model_parent_chunk_tokens[model_name] = int(parent_chunk_token_value)
+                except (ValueError, TypeError):
+                    model_parent_chunk_tokens[model_name] = None
+            else:
+                model_parent_chunk_tokens[model_name] = None
+        
+        return jsonify({
+            'models': all_models,
+            'input_tokens': model_input_tokens,
+            'output_tokens': model_output_tokens,
+            'parent_chunk_tokens': model_parent_chunk_tokens,
+            'default_input_tokens': default_input_tokens,
+            'default_output_tokens': default_output_tokens,
+            'default_parent_chunk_tokens': default_parent_chunk_tokens
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'토큰 수 설정 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/model-tokens', methods=['POST'])
+@admin_required
+def save_model_tokens():
+    """모델별 토큰 수 설정 저장 (입력/출력 분리, 또는 삭제)"""
+    try:
+        data = request.json
+        model_name = data.get('model_name', '').strip()
+        token_type = data.get('token_type', 'output').strip()  # 'input' 또는 'output'
+        tokens = data.get('tokens', None)
+        
+        if not model_name:
+            return jsonify({'error': '모델명을 입력해주세요.'}), 400
+        
+        if token_type not in ['input', 'output', 'parent_chunk']:
+            return jsonify({'error': '토큰 타입은 "input", "output", 또는 "parent_chunk"이어야 합니다.'}), 400
+        
+        # tokens가 None이면 설정 삭제 (기본값 사용)
+        if tokens is None:
+            try:
+                config_key = f"model_token_{token_type}_{model_name}"
+                config = SystemConfig.query.filter_by(key=config_key).first()
+                if config:
+                    db.session.delete(config)
+                    db.session.commit()
+                    return jsonify({
+                        'message': f'{model_name} 모델의 {token_type} 토큰 수 설정이 삭제되었습니다. 기본값을 사용합니다.',
+                        'model_name': model_name,
+                        'token_type': token_type,
+                        'tokens': None
+                    }), 200
+                else:
+                    # 하위 호환성: 기존 형식도 삭제 시도 (출력 토큰인 경우)
+                    if token_type == 'output':
+                        old_config_key = f"model_token_{model_name}"
+                        old_config = SystemConfig.query.filter_by(key=old_config_key).first()
+                        if old_config:
+                            db.session.delete(old_config)
+                            db.session.commit()
+                            return jsonify({
+                                'message': f'{model_name} 모델의 출력 토큰 수 설정이 삭제되었습니다. 기본값을 사용합니다.',
+                                'model_name': model_name,
+                                'token_type': token_type,
+                                'tokens': None
+                            }), 200
+                    return jsonify({
+                        'message': f'{model_name} 모델은 이미 기본값을 사용하고 있습니다.',
+                        'model_name': model_name,
+                        'token_type': token_type,
+                        'tokens': None
+                    }), 200
+            except Exception as e:
+                db.session.rollback()
+                return jsonify({'error': f'설정 삭제 중 오류가 발생했습니다: {str(e)}'}), 500
+        
+        try:
+            tokens = int(tokens)
+            if tokens < 1:
+                return jsonify({'error': '토큰 수는 1 이상이어야 합니다.'}), 400
+        except (ValueError, TypeError):
+            return jsonify({'error': '토큰 수는 정수여야 합니다.'}), 400
+        
+        # SystemConfig에 저장
+        config_key = f"model_token_{token_type}_{model_name}"
+        SystemConfig.set_config(config_key, str(tokens), f'{model_name} 모델 {token_type} 토큰 수 제한')
+        
+        return jsonify({
+            'message': f'{model_name} 모델의 {token_type} 토큰 수가 {tokens}로 설정되었습니다.',
+            'model_name': model_name,
+            'token_type': token_type,
+            'tokens': tokens
+        }), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        print(f"[토큰 수 저장] 오류: {e}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': f'토큰 수 저장 중 오류가 발생했습니다: {str(e)}'}), 500
+
 @main_bp.route('/api/admin/gemini-api-key', methods=['POST'])
 @admin_required
 def set_gemini_api_key():
@@ -1911,59 +2206,74 @@ def set_gemini_api_key():
 def get_ollama_models():
     """Ollama 및 Gemini에서 사용 가능한 모델 목록 가져오기 (로컬 AI 모델은 학습된 웹소설이 있는 모델만 표시)"""
     try:
+        # 쿼리 파라미터로 all=true가 전달되면 모든 모델 반환
+        show_all = request.args.get('all', 'false').lower() == 'true'
+        
         all_models = []
         
-        # 1. Ollama 모델 목록 가져오기 (학습된 웹소설이 있는 모델만 필터링)
+        # 1. Ollama 모델 목록 가져오기
         try:
             response = requests.get(f'{OLLAMA_BASE_URL}/api/tags', timeout=5)
             if response.status_code == 200:
                 data = response.json()
                 ollama_models_raw = [model['name'] for model in data.get('models', [])]
                 
-                # 각 Ollama 모델에 대해 학습된 웹소설이 있는지 확인
-                filtered_ollama_models = []
-                for model_name in ollama_models_raw:
-                    # 해당 모델로 학습된 원본 파일이 있는지 확인 (parent_file_id가 None인 파일만)
-                    file_count = UploadedFile.query.filter_by(
-                        model_name=model_name,
-                        parent_file_id=None
-                    ).count()
+                if show_all:
+                    # 모든 Ollama 모델 반환
+                    ollama_models = [{'name': model_name, 'type': 'ollama'} for model_name in ollama_models_raw]
+                    all_models.extend(ollama_models)
+                    print(f"[모델 목록] Ollama 모델 {len(ollama_models)}개 추가 (전체 목록)")
+                else:
+                    # 학습된 웹소설이 있는 모델만 필터링
+                    filtered_ollama_models = []
+                    for model_name in ollama_models_raw:
+                        # 해당 모델로 학습된 원본 파일이 있는지 확인 (parent_file_id가 None인 파일만)
+                        file_count = UploadedFile.query.filter_by(
+                            model_name=model_name,
+                            parent_file_id=None
+                        ).count()
+                        
+                        if file_count > 0:
+                            filtered_ollama_models.append({'name': model_name, 'type': 'ollama'})
+                            print(f"[모델 목록] Ollama 모델 '{model_name}' - 학습된 웹소설 {file_count}개")
+                        else:
+                            print(f"[모델 목록] Ollama 모델 '{model_name}' - 학습된 웹소설 없음, 목록에서 제외")
                     
-                    if file_count > 0:
-                        filtered_ollama_models.append({'name': model_name, 'type': 'ollama'})
-                        print(f"[모델 목록] Ollama 모델 '{model_name}' - 학습된 웹소설 {file_count}개")
-                    else:
-                        print(f"[모델 목록] Ollama 모델 '{model_name}' - 학습된 웹소설 없음, 목록에서 제외")
-                
-                all_models.extend(filtered_ollama_models)
-                print(f"[모델 목록] Ollama 모델 {len(filtered_ollama_models)}개 추가 (전체 {len(ollama_models_raw)}개 중 {len(filtered_ollama_models)}개 필터링됨)")
+                    all_models.extend(filtered_ollama_models)
+                    print(f"[모델 목록] Ollama 모델 {len(filtered_ollama_models)}개 추가 (전체 {len(ollama_models_raw)}개 중 {len(filtered_ollama_models)}개 필터링됨)")
         except Exception as e:
             print(f"[모델 목록] Ollama 모델 목록 조회 실패: {e}")
         
-        # 2. Gemini 모델 목록 가져오기 (학습된 웹소설이 있는 모델만 필터링)
+        # 2. Gemini 모델 목록 가져오기
         try:
             gemini_client = get_gemini_client()
             if gemini_client.is_configured():
                 gemini_models = gemini_client.get_available_models()
                 
-                # 각 Gemini 모델에 대해 학습된 웹소설이 있는지 확인
-                filtered_gemini_models = []
-                for model_name in gemini_models:
-                    full_model_name = f'gemini:{model_name}'
-                    # 해당 모델로 학습된 원본 파일이 있는지 확인 (parent_file_id가 None인 파일만)
-                    file_count = UploadedFile.query.filter_by(
-                        model_name=full_model_name,
-                        parent_file_id=None
-                    ).count()
+                if show_all:
+                    # 모든 Gemini 모델 반환
+                    gemini_models_list = [{'name': f'gemini:{model_name}', 'type': 'gemini'} for model_name in gemini_models]
+                    all_models.extend(gemini_models_list)
+                    print(f"[모델 목록] Gemini 모델 {len(gemini_models_list)}개 추가 (전체 목록)")
+                else:
+                    # 학습된 웹소설이 있는 모델만 필터링
+                    filtered_gemini_models = []
+                    for model_name in gemini_models:
+                        full_model_name = f'gemini:{model_name}'
+                        # 해당 모델로 학습된 원본 파일이 있는지 확인 (parent_file_id가 None인 파일만)
+                        file_count = UploadedFile.query.filter_by(
+                            model_name=full_model_name,
+                            parent_file_id=None
+                        ).count()
+                        
+                        if file_count > 0:
+                            filtered_gemini_models.append({'name': full_model_name, 'type': 'gemini'})
+                            print(f"[모델 목록] Gemini 모델 '{full_model_name}' - 학습된 웹소설 {file_count}개")
+                        else:
+                            print(f"[모델 목록] Gemini 모델 '{full_model_name}' - 학습된 웹소설 없음, 목록에서 제외")
                     
-                    if file_count > 0:
-                        filtered_gemini_models.append({'name': full_model_name, 'type': 'gemini'})
-                        print(f"[모델 목록] Gemini 모델 '{full_model_name}' - 학습된 웹소설 {file_count}개")
-                    else:
-                        print(f"[모델 목록] Gemini 모델 '{full_model_name}' - 학습된 웹소설 없음, 목록에서 제외")
-                
-                all_models.extend(filtered_gemini_models)
-                print(f"[모델 목록] Gemini 모델 {len(filtered_gemini_models)}개 추가 (전체 {len(gemini_models)}개 중 {len(filtered_gemini_models)}개 필터링됨)")
+                    all_models.extend(filtered_gemini_models)
+                    print(f"[모델 목록] Gemini 모델 {len(filtered_gemini_models)}개 추가 (전체 {len(gemini_models)}개 중 {len(filtered_gemini_models)}개 필터링됨)")
             else:
                 print(f"[모델 목록] Gemini API 키가 설정되지 않아 Gemini 모델을 불러올 수 없습니다.")
         except Exception as e:
@@ -2085,22 +2395,32 @@ def chat():
     try:
         data = request.json
         message = data.get('message', '')
-        model = data.get('model', '')
+        # 하위 호환성을 위해 model도 확인 (기존 코드)
+        analysis_model = data.get('analysis_model', data.get('model', ''))  # 질문 분석용 모델
+        answer_model = data.get('answer_model', '')  # 최종 답변용 모델
         file_ids = [int(fid) for fid in data.get('file_ids', []) if fid]  # 선택한 웹소설 파일 ID 목록
         session_id = data.get('session_id', None)  # 대화 세션 ID (정수로 변환)
         
         if not message:
             return jsonify({'error': '메시지가 필요합니다.'}), 400
         
-        # 모델이 선택된 경우 Ollama 사용
-        if model:
+        # 답변용 모델이 없으면 분석용 모델 사용 (하위 호환성)
+        if not answer_model:
+            answer_model = analysis_model
+        
+        # 답변용 모델이 여전히 없으면 에러 반환
+        if not answer_model:
+            return jsonify({'error': '답변을 생성할 AI 모델이 선택되지 않았습니다. "사용 가능한 AI 목록"에서 답변을 생성할 AI 모델을 선택해주세요.'}), 400
+        
+        # 분석용 모델이 선택된 경우 RAG 검색 진행
+        if analysis_model:
             try:
                 # RAG: 질문과 관련된 청크 검색
                 context = ""
                 use_rag = True  # RAG 사용 여부
                 
                 if use_rag:
-                    print(f"\n[RAG 검색] 모델: {model}, 질문: {message[:50]}...")
+                    print(f"\n[RAG 검색] 분석 모델: {analysis_model}, 답변 모델: {answer_model}, 질문: {message[:50]}...")
                     print(f"[RAG 검색] 선택된 파일 ID: {file_ids if file_ids else '없음 (모든 파일 검색)'}")
                     
                     # 1단계: 회차별 분석(EpisodeAnalysis) 조회 (회차별 요약 참조용)
@@ -2120,12 +2440,12 @@ def chat():
                         )
                         print(f"[RAG 검색 2단계] GraphRAG 데이터 조회 완료: 엔티티 {len(graph_data['entities'])}개, 관계 {len(graph_data['relationships'])}개, 사건 {len(graph_data['events'])}개")
                     
-                    # 3단계: 벡터 검색 + 리랭킹으로 Child Chunk 정밀 검색
-                    print(f"[RAG 검색 3단계] 벡터 검색 + 리랭킹 시작...")
+                    # 3단계: 벡터 검색 + 리랭킹으로 Child Chunk 정밀 검색 (분석 모델 사용)
+                    print(f"[RAG 검색 3단계] 벡터 검색 + 리랭킹 시작 (분석 모델: {analysis_model})...")
                     relevant_chunks = search_relevant_chunks(
                         query=message,
                         file_ids=file_ids if file_ids else None,
-                        model_name=model,
+                        model_name=analysis_model,  # 질문 분석은 analysis_model 사용
                         top_k=5,  # 리랭킹 후 상위 5개만 선택
                         min_score=0.5  # 최소 점수 임계값
                     )
@@ -2421,13 +2741,13 @@ def chat():
                         
                         uploaded_files = UploadedFile.query.filter(
                             UploadedFile.id.in_(expanded_file_ids),
-                            UploadedFile.model_name == model
+                            UploadedFile.model_name == analysis_model
                         ).all()
                         print(f"[파일 사용] 선택된 파일 ID로 조회 (이어서 업로드 포함): {len(uploaded_files)}개 파일")
                     else:
                         # 파일 ID가 없으면 해당 모델의 모든 파일 사용 (원본 및 이어서 업로드 포함)
-                        uploaded_files = UploadedFile.query.filter_by(model_name=model).all()
-                        print(f"[파일 사용] 모델 '{model}'의 모든 파일 사용: {len(uploaded_files)}개 파일")
+                        uploaded_files = UploadedFile.query.filter_by(model_name=analysis_model).all()
+                        print(f"[파일 사용] 모델 '{analysis_model}'의 모든 파일 사용: {len(uploaded_files)}개 파일")
                     
                     if uploaded_files:
                         print(f"[파일 사용] 사용되는 파일 목록:")
@@ -2490,12 +2810,18 @@ def chat():
                 if system_prompt:
                     print(f"[프롬프트] 시스템 프롬프트 적용: {len(system_prompt)}자")
                 
+                # 최종 답변 생성은 answer_model 사용
+                if not answer_model:
+                    return jsonify({'error': '답변용 모델이 선택되지 않았습니다.'}), 400
+                
                 # 모델 타입 확인 (Gemini 또는 Ollama)
-                is_gemini = model.startswith('gemini:')
+                is_gemini = answer_model.startswith('gemini:')
+                
+                print(f"[최종 답변 생성] 답변 모델: {answer_model}, 프롬프트 길이: {len(full_prompt)}자")
                 
                 if is_gemini:
                     # Gemini API 호출
-                    gemini_model_name = model.replace('gemini:', '')
+                    gemini_model_name = answer_model.replace('gemini:', '')
                     print(f"[Gemini] 모델: {gemini_model_name}, 질문: {message[:50]}...")
                     
                     gemini_client = get_gemini_client()
@@ -2506,19 +2832,22 @@ def chat():
                         prompt=full_prompt,
                         model_name=gemini_model_name,
                         temperature=0.7,
-                        max_output_tokens=8192
+                        max_output_tokens=get_model_token_limit(model_name or "gemini-1.5-flash", 8192)  # 저장된 토큰 수 사용
                     )
                     
                     if result['error']:
                         return jsonify({'error': result['error']}), 500
                     
-                    response_text = result['response']
+                    response_text = result.get('response', '').strip()
+                    if not response_text:
+                        print(f"[채팅] Gemini 응답이 비어있습니다. result: {result}")
+                        response_text = '응답을 생성할 수 없었습니다. 다시 시도해주세요.'
                 else:
                     # Ollama API 호출
                     ollama_response = requests.post(
                         f'{OLLAMA_BASE_URL}/api/generate',
                         json={
-                            'model': model,
+                            'model': answer_model,  # 답변 모델 사용
                             'prompt': full_prompt,
                             'stream': False
                         },
@@ -2533,13 +2862,16 @@ def chat():
                             error_detail = ollama_response.text[:200] if ollama_response.text else '상세 정보 없음'
                         
                         if ollama_response.status_code == 404:
-                            error_msg = f'모델 "{model}"을(를) 찾을 수 없습니다. 모델이 Ollama에 설치되어 있는지 확인하세요. (오류: {error_detail})'
+                            error_msg = f'모델 "{answer_model}"을(를) 찾을 수 없습니다. 모델이 Ollama에 설치되어 있는지 확인하세요. (오류: {error_detail})'
                         else:
                             error_msg = f'Ollama 서버 오류: {ollama_response.status_code} (오류: {error_detail})'
                         return jsonify({'error': error_msg}), ollama_response.status_code
                     
                     ollama_data = ollama_response.json()
-                    response_text = ollama_data.get('response', '응답을 생성할 수 없습니다.')
+                    response_text = ollama_data.get('response', '').strip()
+                    if not response_text:
+                        print(f"[채팅] Ollama 응답이 비어있습니다. ollama_data: {ollama_data}")
+                        response_text = '응답을 생성할 수 없었습니다. 다시 시도해주세요.'
                 
                 # 대화 세션에 메시지 저장 (Gemini와 Ollama 공통)
                 session_id = data.get('session_id')
@@ -2603,6 +2935,15 @@ def chat():
                             )
                             db.session.add(ai_msg)
                             
+                            # 세션 모델 정보 업데이트 (첫 메시지인 경우 또는 변경된 경우)
+                            if not session.analysis_model or session.analysis_model != analysis_model:
+                                session.analysis_model = analysis_model
+                            if not session.answer_model or session.answer_model != answer_model:
+                                session.answer_model = answer_model
+                            # 하위 호환성을 위해 model_name도 업데이트
+                            if not session.model_name:
+                                session.model_name = answer_model or analysis_model
+                            
                             session.updated_at = datetime.utcnow()
                             db.session.commit()
                             
@@ -2613,6 +2954,13 @@ def chat():
                         db.session.rollback()
                         session_dict = None
                 
+                # 응답이 비어있으면 기본 메시지 사용
+                if not response_text or not response_text.strip():
+                    print(f"[채팅] 최종 응답이 비어있습니다. 기본 메시지를 사용합니다.")
+                    response_text = '응답을 생성할 수 없었습니다. 다시 시도해주세요.'
+                
+                print(f"[채팅] 최종 응답 길이: {len(response_text)}자, 미리보기: {response_text[:100]}...")
+                
                 response_data = {'response': response_text, 'session_id': session_id}
                 if session_dict:
                     response_data['session'] = session_dict
@@ -2827,88 +3175,45 @@ def upload_file():
             db.session.flush()  # ID를 얻기 위해 flush
             log_print(f"[7/8] 데이터베이스 flush 완료, 파일 ID: {uploaded_file.id}")
             
-            # 텍스트 파일인 경우 청크로 분할하여 저장 (RAG용)
+            # 파일 저장만 완료 (청크 생성은 별도 API로 처리)
+            db.session.commit()
+            log_print(f"[8/8] 데이터베이스 커밋 완료: {original_filename}")
+            log_print(f"[8/8] 연결된 모델: {model_name}")
+            log_print(f"{'='*60}")
+            log_print(f"=== 파일 업로드 완료 (처리 대기 중) ===")
+            log_print(f"{'='*60}\n")
+            
+            log_print(f"[8/8] 업로드 완료 - 파일: {original_filename}, 모델: {model_name}, 크기: {saved_file_size} bytes")
+            log_print(f"[8/8] 다음 단계: Parent Chunk 생성, Chunk 생성, 회차 분석, Graph Extraction을 별도로 진행합니다.")
+            
+            # 회차 수 계산 (섹션 분할 결과 기반) - 파일 읽기 필요
+            episode_count = 0
             if original_filename.lower().endswith(('.txt', '.md')):
                 try:
-                    log_print(f"[7/8] 청크 생성 시작: {original_filename}")
-                    log_print(f"[7/8] 파일 ID: {uploaded_file.id}")
-                    
-                    # 파일 내용 읽기
                     encoding = 'utf-8'
                     try:
                         with open(file_path, 'r', encoding=encoding) as f:
                             content = f.read()
-                        log_print(f"[7/8] UTF-8 인코딩으로 파일 읽기 성공: {len(content)}자")
                     except UnicodeDecodeError:
-                        log_print(f"[7/8] UTF-8 인코딩 실패, CP949 시도: {original_filename}")
                         with open(file_path, 'r', encoding='cp949') as f:
                             content = f.read()
-                        log_print(f"[7/8] CP949 인코딩으로 파일 읽기 성공: {len(content)}자")
-                    
-                    # 1. Parent Chunk 생성 (AI 분석) - 먼저 생성
-                    try:
-                        log_print(f"[7/8] Parent Chunk 생성 시작 (AI 분석)...")
-                        parent_chunk = create_parent_chunk_with_ai(uploaded_file.id, content, model_name)
-                        if parent_chunk:
-                            log_print(f"[7/8] ✅ Parent Chunk 생성 완료: {original_filename}")
-                            print(f"Parent Chunk가 생성되었습니다: {original_filename}")
-                        else:
-                            log_print(f"[7/8] ⚠️ 경고: Parent Chunk 생성 실패: {original_filename}")
-                            print(f"경고: Parent Chunk 생성에 실패했습니다: {original_filename}")
-                    except Exception as parent_chunk_error:
-                        # Parent Chunk 생성 실패해도 업로드는 계속 진행
-                        log_print(f"[7/8] ⚠️ 경고: Parent Chunk 생성 중 예외 발생: {str(parent_chunk_error)}")
-                        print(f"경고: Parent Chunk 생성 중 오류가 발생했습니다: {original_filename}")
-                        import traceback
-                        traceback.print_exc()
-                    
-                    # 2. Child Chunk 생성 및 저장 (섹션별 분할)
-                    log_print(f"[8/8] Child Chunk 생성 함수 호출 중...")
-                    chunk_count = create_chunks_for_file(uploaded_file.id, content)
-                    
-                    if chunk_count > 0:
-                        log_print(f"[8/8] ✅ 성공: 파일 {original_filename}을 {chunk_count}개의 청크로 분할했습니다.")
-                        print(f"파일 {original_filename}을 {chunk_count}개의 청크로 분할했습니다.")
-                    else:
-                        log_print(f"[8/8] ⚠️ 경고: 청크가 생성되지 않았습니다. (파일이 너무 짧거나 비어있을 수 있습니다.)")
-                        print(f"경고: 파일 {original_filename}에 대한 청크가 생성되지 않았습니다.")
                     
+                    sections = split_content_by_episodes(content)
+                    # '#작품설명'을 제외한 회차 수
+                    episode_sections = [s for s in sections if s[0] != '작품설명']
+                    episode_count = len(episode_sections)
+                    log_print(f"[8/8] 회차 수 계산: {episode_count}개 회차")
                 except Exception as e:
-                    error_msg = f"청크 생성 중 오류: {str(e)}"
-                    log_print(f"[7/8] ❌ 오류: {error_msg}")
-                    print(error_msg)
-                    import traceback
-                    traceback.print_exc()
-                    # 청크 생성 실패해도 파일 업로드는 계속 진행 (경고만 표시)
-                    log_print(f"[7/8] ⚠️ 경고: 청크 생성 실패했지만 파일 업로드는 계속 진행합니다.")
-            
-            # 최종 청크 개수 확인 및 저장
-            chunk_count = 0
-            if original_filename.lower().endswith(('.txt', '.md')):
-                chunk_count = DocumentChunk.query.filter_by(file_id=uploaded_file.id).count()
-                log_print(f"[8/8] 최종 청크 개수 확인: {chunk_count}개")
-            
-            db.session.commit()
-            log_print(f"[8/8] 데이터베이스 커밋 완료: {original_filename}")
-            log_print(f"[8/8] 연결된 모델: {model_name}")
-            log_print(f"[8/8] 생성된 청크 수: {chunk_count}")
-            
-            # 학습 상태 요약
-            if chunk_count > 0:
-                log_print(f"[8/8] ✅ AI 학습 준비 완료: {chunk_count}개 청크가 저장되어 RAG 검색에 사용 가능합니다.")
-            else:
-                log_print(f"[8/8] ⚠️ 경고: 청크가 생성되지 않아 RAG 검색이 불가능합니다.")
-            log_print(f"{'='*60}")
-            log_print(f"=== 파일 업로드 성공 ===")
-            log_print(f"{'='*60}\n")
-            
-            log_print(f"[8/8] 업로드 완료 - 파일: {original_filename}, 모델: {model_name}, 크기: {saved_file_size} bytes")
+                    log_print(f"[8/8] 회차 수 계산 오류: {str(e)}")
+                    episode_count = 0
             
             return jsonify({
                 'message': f'파일이 성공적으로 업로드되었습니다. (모델: {model_name})',
                 'file': uploaded_file.to_dict(),
                 'model_name': model_name,
-                'chunk_count': chunk_count
+                'file_id': uploaded_file.id,
+                'episode_count': episode_count,  # 회차 수 추가
+                'needs_processing': original_filename.lower().endswith(('.txt', '.md'))  # 처리 필요 여부
             }), 200
             
         except Exception as e:
@@ -3303,6 +3608,227 @@ def create_file_parent_chunk(file_id):
     except Exception as e:
         return jsonify({'error': f'Parent Chunk 생성 중 오류가 발생했습니다: {str(e)}'}), 500
 
+@main_bp.route('/api/files/<int:file_id>/process/parent-chunk', methods=['POST'])
+@login_required
+def process_parent_chunk(file_id):
+    """단계 1: Parent Chunk 생성"""
+    return create_file_parent_chunk(file_id)
+
+@main_bp.route('/api/files/<int:file_id>/process/chunks', methods=['POST'])
+@login_required
+def process_chunks(file_id):
+    """단계 2: Chunk 생성 (회차 분석, Graph Extraction 제외)"""
+    try:
+        file = UploadedFile.query.filter_by(id=file_id, uploaded_by=current_user.id).first()
+        if not file:
+            return jsonify({'error': '파일을 찾을 수 없습니다.'}), 404
+        
+        if not file.original_filename.lower().endswith(('.txt', '.md')):
+            return jsonify({'error': 'Chunk는 텍스트 파일(.txt, .md)에만 생성할 수 있습니다.'}), 400
+        
+        # 파일 내용 읽기
+        try:
+            encoding = 'utf-8'
+            try:
+                with open(file.file_path, 'r', encoding=encoding) as f:
+                    content = f.read()
+            except UnicodeDecodeError:
+                with open(file.file_path, 'r', encoding='cp949') as f:
+                    content = f.read()
+        except Exception as e:
+            return jsonify({'error': f'파일을 읽을 수 없습니다: {str(e)}'}), 500
+        
+        print(f"[단계 2: Chunk 생성] 파일 ID {file_id}에 대한 Chunk 생성 시작")
+        chunk_count = create_chunks_for_file(file_id, content, skip_episode_analysis=True, skip_graph_extraction=True)
+        
+        return jsonify({
+            'file_id': file_id,
+            'filename': file.original_filename,
+            'chunk_count': chunk_count,
+            'message': f'Chunk {chunk_count}개가 성공적으로 생성되었습니다.',
+            'step': 'chunks',
+            'completed': True
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'Chunk 생성 중 오류가 발생했습니다: {str(e)}', 'step': 'chunks'}), 500
+
+@main_bp.route('/api/files/<int:file_id>/process/episode-analysis', methods=['POST'])
+@login_required
+def process_episode_analysis(file_id):
+    """단계 3: 회차 분석"""
+    try:
+        file = UploadedFile.query.filter_by(id=file_id, uploaded_by=current_user.id).first()
+        if not file:
+            return jsonify({'error': '파일을 찾을 수 없습니다.'}), 404
+        
+        if not file.model_name:
+            return jsonify({'error': '파일에 연결된 AI 모델이 없습니다.'}), 400
+        
+        if not file.original_filename.lower().endswith(('.txt', '.md')):
+            return jsonify({'error': '회차 분석은 텍스트 파일(.txt, .md)에만 가능합니다.'}), 400
+        
+        # 파일 내용 읽기
+        try:
+            encoding = 'utf-8'
+            try:
+                with open(file.file_path, 'r', encoding=encoding) as f:
+                    content = f.read()
+            except UnicodeDecodeError:
+                with open(file.file_path, 'r', encoding='cp949') as f:
+                    content = f.read()
+        except Exception as e:
+            return jsonify({'error': f'파일을 읽을 수 없습니다: {str(e)}'}), 500
+        
+        # 섹션 분할
+        sections = split_content_by_episodes(content)
+        episode_sections = [s for s in sections if s[0] != '작품설명']
+        
+        if not episode_sections:
+            return jsonify({'error': '분석할 회차가 없습니다.'}), 400
+        
+        # Parent Chunk 가져오기
+        parent_chunk = None
+        try:
+            parent_chunk = ParentChunk.query.filter_by(file_id=file_id).first()
+        except:
+            pass
+        
+        # 기존 회차 분석 삭제
+        existing_analyses = EpisodeAnalysis.query.filter_by(file_id=file_id).all()
+        if existing_analyses:
+            for analysis in existing_analyses:
+                db.session.delete(analysis)
+            db.session.commit()
+        
+        print(f"[단계 3: 회차 분석] 파일 ID {file_id}에 대한 회차 분석 시작 ({len(episode_sections)}개 회차)")
+        
+        # 각 회차 분석
+        all_analyses = []
+        for section_type, section_title, section_content, section_metadata in episode_sections:
+            try:
+                print(f"[단계 3: 회차 분석] '{section_title}' 분석 중...")
+                analysis_result = analyze_episode(
+                    episode_content=section_content,
+                    episode_title=section_title,
+                    full_content=content,
+                    parent_chunk=parent_chunk,
+                    model_name=file.model_name
+                )
+                
+                if analysis_result:
+                    all_analyses.append(f"\n\n{analysis_result}")
+                    print(f"[단계 3: 회차 분석] '{section_title}' 분석 완료")
+            except Exception as e:
+                print(f"[단계 3: 회차 분석] '{section_title}' 분석 중 오류: {str(e)}")
+                continue
+        
+        # 모든 회차 분석 결과를 하나의 텍스트로 저장
+        if all_analyses:
+            combined_analysis = "\n".join(all_analyses).strip()
+            episode_analysis = EpisodeAnalysis(
+                file_id=file_id,
+                episode_title="전체 회차 통합 분석",
+                analysis_content=combined_analysis
+            )
+            db.session.add(episode_analysis)
+            db.session.commit()
+            
+            return jsonify({
+                'file_id': file_id,
+                'filename': file.original_filename,
+                'episode_count': len(episode_sections),
+                'message': f'{len(episode_sections)}개 회차 분석이 완료되었습니다.',
+                'step': 'episode-analysis',
+                'completed': True
+            }), 200
+        else:
+            return jsonify({
+                'error': '회차 분석 결과가 없습니다.',
+                'step': 'episode-analysis',
+                'completed': False
+            }), 500
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'회차 분석 ��� 오류가 발생했습니다: {str(e)}', 'step': 'episode-analysis'}), 500
+
+@main_bp.route('/api/files/<int:file_id>/process/graph', methods=['POST'])
+@login_required
+def process_graph(file_id):
+    """단계 4: Graph Extraction"""
+    try:
+        file = UploadedFile.query.filter_by(id=file_id, uploaded_by=current_user.id).first()
+        if not file:
+            return jsonify({'error': '파일을 찾을 수 없습니다.'}), 404
+        
+        if not file.model_name:
+            return jsonify({'error': '파일에 연결된 AI 모델이 없습니다.'}), 400
+        
+        if not file.original_filename.lower().endswith(('.txt', '.md')):
+            return jsonify({'error': 'Graph Extraction은 텍스트 파일(.txt, .md)에만 가능합니다.'}), 400
+        
+        # 파일 내용 읽기
+        try:
+            encoding = 'utf-8'
+            try:
+                with open(file.file_path, 'r', encoding=encoding) as f:
+                    content = f.read()
+            except UnicodeDecodeError:
+                with open(file.file_path, 'r', encoding='cp949') as f:
+                    content = f.read()
+        except Exception as e:
+            return jsonify({'error': f'파일을 읽을 수 없습니다: {str(e)}'}), 500
+        
+        # 섹션 분할
+        sections = split_content_by_episodes(content)
+        episode_sections = [s for s in sections if s[0] != '작품설명']
+        
+        if not episode_sections:
+            return jsonify({'error': 'Graph Extraction할 회차가 없습니다.'}), 400
+        
+        # Parent Chunk 가져오기
+        parent_chunk = None
+        try:
+            parent_chunk = ParentChunk.query.filter_by(file_id=file_id).first()
+        except:
+            pass
+        
+        print(f"[단계 4: Graph Extraction] 파일 ID {file_id}에 대한 Graph Extraction 시작 ({len(episode_sections)}개 회차)")
+        
+        # 각 회차 Graph Extraction
+        success_count = 0
+        for section_type, section_title, section_content, section_metadata in episode_sections:
+            try:
+                print(f"[단계 4: Graph Extraction] '{section_title}' Graph Extraction 중...")
+                success = extract_graph_from_episode(
+                    episode_content=section_content,
+                    episode_title=section_title,
+                    file_id=file_id,
+                    full_content=content,
+                    parent_chunk=parent_chunk,
+                    model_name=file.model_name
+                )
+                if success:
+                    success_count += 1
+                    print(f"[단계 4: Graph Extraction] '{section_title}' Graph Extraction 완료")
+            except Exception as e:
+                print(f"[단계 4: Graph Extraction] '{section_title}' Graph Extraction 중 오류: {str(e)}")
+                continue
+        
+        return jsonify({
+            'file_id': file_id,
+            'filename': file.original_filename,
+            'episode_count': len(episode_sections),
+            'success_count': success_count,
+            'message': f'{success_count}/{len(episode_sections)}개 회차 Graph Extraction이 완료되었습니다.',
+            'step': 'graph',
+            'completed': True
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'Graph Extraction 중 오류가 발생했습니다: {str(e)}', 'step': 'graph'}), 500
+
 @main_bp.route('/api/files/<int:file_id>/metadata', methods=['POST'])
 @login_required
 def create_file_metadata(file_id):
@@ -3574,12 +4100,16 @@ def create_chat_session():
     try:
         data = request.json
         title = data.get('title', '새 대화')
-        model_name = data.get('model_name', None)
+        model_name = data.get('model_name', None)  # 하위 호환성
+        analysis_model = data.get('analysis_model', None)
+        answer_model = data.get('answer_model', None)
         
         session = ChatSession(
             user_id=current_user.id,
             title=title,
-            model_name=model_name
+            model_name=model_name,  # 하위 호환성
+            analysis_model=analysis_model,
+            answer_model=answer_model
         )
         db.session.add(session)
         db.session.commit()

download_exaone_model.py

@@ -77,4 +77,16 @@ if __name__ == "__main__":
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
 

install_exaone_direct.py

@@ -82,4 +82,16 @@ if __name__ == "__main__":
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
 

install_exaone_simple.py

@@ -59,4 +59,16 @@ if __name__ == "__main__":
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
 

templates/admin.html

@@ -449,6 +449,7 @@
             <a href="{{ url_for('main.admin_files') }}" class="btn btn-secondary">파일 목록</a>
             <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
             <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
+            <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
             <a href="{{ url_for('main.index') }}" class="btn btn-secondary">메인으로</a>
             <a href="{{ url_for('main.logout') }}" class="btn btn-secondary">로그아웃</a>
         </div>
@@ -462,27 +463,6 @@
 
         <div id="alertContainer"></div>
 
-        <!-- Gemini API 키 설정 섹션 -->
-        <div class="card">
-            <div class="card-header">
-                <div class="card-title">Gemini API 키 설정</div>
-            </div>
-            <div style="padding: 16px 0;">
-                <div class="form-group">
-                    <label for="geminiApiKey">Gemini API 키</label>
-                    <div style="display: flex; gap: 8px;">
-                        <input type="password" id="geminiApiKey" placeholder="Gemini API 키를 입력하세요" style="flex: 1; padding: 8px 12px; border: 1px solid #dadce0; border-radius: 4px; font-size: 14px;">
-                        <button class="btn btn-primary" onclick="saveGeminiApiKey()">저장</button>
-                        <button class="btn btn-secondary" onclick="loadGeminiApiKey()">현재 상태 확인</button>
-                    </div>
-                    <small style="color: #5f6368; font-size: 12px; display: block; margin-top: 4px;">
-                        Google AI Studio(<a href="https://aistudio.google.com/app/apikey" target="_blank">https://aistudio.google.com/app/apikey</a>)에서 API 키를 발급받을 수 있습니다.
-                    </small>
-                    <div id="geminiApiKeyStatus" style="margin-top: 8px; font-size: 13px;"></div>
-                </div>
-            </div>
-        </div>
-
         <div class="card">
             <div class="card-header">
                 <div class="card-title">사용자 목록</div>
@@ -691,87 +671,6 @@
             }
         });
 
-        // Gemini API 키 관련 함수
-        async function loadGeminiApiKey() {
-            try {
-                const response = await fetch('/api/admin/gemini-api-key');
-                
-                // 응답이 JSON인지 확인
-                const contentType = response.headers.get('content-type');
-                if (!contentType || !contentType.includes('application/json')) {
-                    const text = await response.text();
-                    console.error('Non-JSON response:', text.substring(0, 200));
-                    const statusDiv = document.getElementById('geminiApiKeyStatus');
-                    statusDiv.innerHTML = `<span style="color: #ea4335;">서버 오류: 응답 형식이 올바르지 않습니다.</span>`;
-                    return;
-                }
-                
-                const data = await response.json();
-                
-                const statusDiv = document.getElementById('geminiApiKeyStatus');
-                if (!response.ok) {
-                    statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${data.error || '알 수 없는 오류'}</span>`;
-                    return;
-                }
-                
-                if (data.has_api_key) {
-                    statusDiv.innerHTML = `<span style="color: #137333;">✓ API 키가 설정되어 있습니다 (${data.masked_key})</span>`;
-                } else {
-                    statusDiv.innerHTML = `<span style="color: #ea4335;">⚠ API 키가 설정되지 않았습니다</span>`;
-                }
-            } catch (error) {
-                console.error('Gemini API 키 로드 오류:', error);
-                const statusDiv = document.getElementById('geminiApiKeyStatus');
-                statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${error.message}</span>`;
-            }
-        }
-
-        async function saveGeminiApiKey() {
-            const apiKeyInput = document.getElementById('geminiApiKey');
-            const apiKey = apiKeyInput.value.trim();
-            
-            if (!apiKey) {
-                showAlert('API 키를 입력해주세요.', 'error');
-                return;
-            }
-
-            try {
-                const response = await fetch('/api/admin/gemini-api-key', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                    body: JSON.stringify({ api_key: apiKey })
-                });
-
-                // 응답이 JSON인지 확인
-                const contentType = response.headers.get('content-type');
-                if (!contentType || !contentType.includes('application/json')) {
-                    const text = await response.text();
-                    console.error('Non-JSON response:', text.substring(0, 200));
-                    showAlert('서버 오류: 응답 형식이 올바르지 않습니다.', 'error');
-                    return;
-                }
-
-                const data = await response.json();
-
-                if (response.ok) {
-                    showAlert(data.message, 'success');
-                    apiKeyInput.value = ''; // 보안을 위해 입력 필드 초기화
-                    loadGeminiApiKey(); // 상태 업데이트
-                } else {
-                    showAlert(data.error || 'API 키 저장 중 오류가 발생했습니다.', 'error');
-                }
-            } catch (error) {
-                console.error('Gemini API 키 저장 오류:', error);
-                showAlert(`오류: ${error.message}`, 'error');
-            }
-        }
-
-        // 페이지 로드 시 API 키 상태 확인
-        window.addEventListener('load', () => {
-            loadGeminiApiKey();
-        });
 
     </script>
 </body>

templates/admin_messages.html

@@ -392,7 +392,8 @@
                         <th>ID</th>
                         <th>사용자</th>
                         <th>제목</th>
-                        <th>모델</th>
+                        <th>학습 모델</th>
+                        <th>답변 모델</th>
                         <th>메시지 수</th>
                         <th>생성일</th>
                         <th>수정일</th>
@@ -521,11 +522,15 @@
                             return;
                         }
                         
+                        const analysisModel = session.analysis_model || session.model_name || '-';
+                        const answerModel = session.answer_model || session.model_name || '-';
+                        
                         row.innerHTML = `
                             <td>${session.id}</td>
                             <td>${session.nickname || session.username || 'Unknown'}</td>
                             <td>${session.title || '-'}</td>
-                            <td>${session.model_name || '-'}</td>
+                            <td>${analysisModel}</td>
+                            <td>${answerModel}</td>
                             <td>${session.message_count || 0}</td>
                             <td>${createdDate}</td>
                             <td>${updatedDate}</td>
@@ -536,7 +541,7 @@
                         tbody.appendChild(row);
                     });
                 } else {
-                    tbody.innerHTML = '<tr><td colspan="8" style="text-align: center; padding: 20px; color: #5f6368;">대화 세션이 없습니다.</td></tr>';
+                    tbody.innerHTML = '<tr><td colspan="9" style="text-align: center; padding: 20px; color: #5f6368;">대화 세션이 없습니다.</td></tr>';
                 }
                 
                 // 페이지네이션
@@ -551,6 +556,9 @@
 
         // 메시지 목록 로드
         async function loadMessages(page = 1) {
+            const tbody = document.getElementById('messagesTableBody');
+            tbody.innerHTML = '<tr><td colspan="6" style="text-align: center; padding: 20px; color: #5f6368;">로딩 중...</td></tr>';
+            
             try {
                 const sessionId = document.getElementById('sessionIdFilter').value;
                 
@@ -561,17 +569,25 @@
                     url += `&session_id=${selectedSessionId}`;
                 }
                 
+                console.log('[메시지 목록] 요청 URL:', url);
                 const response = await fetch(url);
+                
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({ error: `HTTP ${response.status}` }));
+                    throw new Error(errorData.error || `HTTP ${response.status}`);
+                }
+                
                 const data = await response.json();
+                console.log('[메시지 목록] 응답 데이터:', data);
                 
-                const tbody = document.getElementById('messagesTableBody');
                 tbody.innerHTML = '';
                 
                 if (data.messages && data.messages.length > 0) {
+                    console.log('[메시지 목록] 메시지 개수:', data.messages.length);
                     data.messages.forEach(msg => {
                         const row = document.createElement('tr');
                         const date = new Date(msg.created_at).toLocaleString('ko-KR');
-                        const contentPreview = msg.content.length > 100 ? msg.content.substring(0, 100) + '...' : msg.content;
+                        const contentPreview = msg.content && msg.content.length > 100 ? msg.content.substring(0, 100) + '...' : (msg.content || '');
                         
                         row.innerHTML = `
                             <td>${msg.id}</td>
@@ -580,22 +596,33 @@
                             <td class="message-content">${escapeHtml(contentPreview)}</td>
                             <td>${date}</td>
                             <td>
-                                <button class="btn btn-secondary" onclick="viewMessage(${msg.id}, '${msg.role}', ${JSON.stringify(msg.content).replace(/"/g, '&quot;')})" style="padding: 4px 8px; font-size: 12px;">상세 보기</button>
+                                <button class="btn btn-secondary" onclick="viewMessageById(${msg.id})" style="padding: 4px 8px; font-size: 12px;">상세 보기</button>
                             </td>
                         `;
+                        // 메시지 데이터를 data 속성에 저장
+                        row.setAttribute('data-message-id', msg.id);
+                        row.setAttribute('data-message-role', msg.role);
+                        row.setAttribute('data-message-content', escapeHtml(msg.content || ''));
                         tbody.appendChild(row);
                     });
                 } else {
+                    console.log('[메시지 목록] 메시지가 없습니다');
                     tbody.innerHTML = '<tr><td colspan="6" style="text-align: center; padding: 20px; color: #5f6368;">메시지가 없습니다.</td></tr>';
                 }
                 
                 // 페이지네이션
-                updateMessagesPagination(data.current_page, data.pages);
-                currentMessagesPage = data.current_page;
+                if (data.current_page !== undefined && data.pages !== undefined) {
+                    updateMessagesPagination(data.current_page, data.pages);
+                    currentMessagesPage = data.current_page;
+                } else {
+                    // 페이지네이션 정보가 없으면 숨김
+                    document.getElementById('messagesPagination').innerHTML = '';
+                }
                 
             } catch (error) {
+                console.error('[메시지 목록] 조회 오류:', error);
                 showAlert(`메시지 조회 오류: ${error.message}`, 'error');
-                console.error('메시지 조회 오류:', error);
+                tbody.innerHTML = `<tr><td colspan="6" style="text-align: center; padding: 20px; color: #ea4335;">메시지 조회 중 오류가 발생했습니다.<br><small>${error.message || '알 수 없는 오류'}</small></td></tr>`;
             }
         }
 
@@ -606,6 +633,40 @@
             loadMessages(1);
         }
 
+        // 메시지 상세 보기 (ID로 조회)
+        async function viewMessageById(messageId) {
+            try {
+                const response = await fetch(`/api/admin/messages?page=1&per_page=1&message_id=${messageId}`);
+                const data = await response.json();
+                
+                if (data.messages && data.messages.length > 0) {
+                    const msg = data.messages[0];
+                    viewMessage(msg.id, msg.role, msg.content);
+                } else {
+                    // 데이터 속성에서 가져오기 (fallback)
+                    const row = document.querySelector(`tr[data-message-id="${messageId}"]`);
+                    if (row) {
+                        const role = row.getAttribute('data-message-role');
+                        const content = row.getAttribute('data-message-content');
+                        viewMessage(messageId, role, content);
+                    } else {
+                        showAlert('메시지를 찾을 수 없습니다.', 'error');
+                    }
+                }
+            } catch (error) {
+                // 데이터 속성에서 가져오기 (fallback)
+                const row = document.querySelector(`tr[data-message-id="${messageId}"]`);
+                if (row) {
+                    const role = row.getAttribute('data-message-role');
+                    const content = row.getAttribute('data-message-content');
+                    viewMessage(messageId, role, content);
+                } else {
+                    showAlert(`메시지 조회 오류: ${error.message}`, 'error');
+                    console.error('메시지 조회 오류:', error);
+                }
+            }
+        }
+        
         // 메시지 상세 보기
         function viewMessage(messageId, role, content) {
             const modal = document.getElementById('messageModal');
@@ -618,7 +679,7 @@
                             <span class="message-item-role role-badge role-${role}">${role === 'user' ? '사용자' : 'AI'}</span>
                             <span class="message-item-time">메시지 ID: ${messageId}</span>
                         </div>
-                        <div class="message-item-content">${escapeHtml(content)}</div>
+                        <div class="message-item-content">${content}</div>
                     </div>
                 </div>
             `;

templates/admin_settings.html

@@ -0,0 +1,596 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI 설정 관리 - SOY NV AI</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" rel="stylesheet">
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #f8f9fa;
+            color: #202124;
+        }
+
+        .header {
+            background: white;
+            border-bottom: 1px solid #dadce0;
+            padding: 16px 24px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+        }
+
+        .header-title {
+            font-size: 20px;
+            font-weight: 500;
+            display: flex;
+            align-items: center;
+            gap: 12px;
+        }
+
+        .header-actions {
+            display: flex;
+            gap: 12px;
+            align-items: center;
+        }
+
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            transition: all 0.2s;
+            text-decoration: none;
+            display: inline-block;
+        }
+
+        .btn-primary {
+            background: #1a73e8;
+            color: white;
+        }
+
+        .btn-primary:hover {
+            background: #1557b0;
+        }
+
+        .btn-secondary {
+            background: #f1f3f4;
+            color: #202124;
+        }
+
+        .btn-secondary:hover {
+            background: #e8eaed;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 24px;
+        }
+
+        .page-header {
+            margin-bottom: 24px;
+        }
+
+        .page-header h1 {
+            font-size: 28px;
+            font-weight: 600;
+            margin-bottom: 8px;
+        }
+
+        .page-header p {
+            color: #5f6368;
+        }
+
+        .card {
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+            padding: 24px;
+            margin-bottom: 24px;
+        }
+
+        .card-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+
+        .card-title {
+            font-size: 18px;
+            font-weight: 500;
+        }
+
+        .form-group {
+            margin-bottom: 16px;
+        }
+
+        .form-group label {
+            display: block;
+            font-size: 14px;
+            font-weight: 500;
+            margin-bottom: 8px;
+        }
+
+        .form-group input {
+            width: 100%;
+            padding: 10px 12px;
+            border: 1px solid #dadce0;
+            border-radius: 6px;
+            font-size: 14px;
+            font-family: inherit;
+        }
+
+        .form-group input:focus {
+            outline: none;
+            border-color: #1a73e8;
+            box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.1);
+        }
+
+        .alert {
+            padding: 12px 16px;
+            border-radius: 6px;
+            margin-bottom: 16px;
+            font-size: 14px;
+        }
+
+        .alert.error {
+            background: #fce8e6;
+            color: #c5221f;
+        }
+
+        .alert.success {
+            background: #e8f5e9;
+            color: #137333;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <div class="header-title">
+            <span>⚙️</span>
+            <span>AI 설정 관리</span>
+        </div>
+        <div class="header-actions">
+            <span style="margin-right: 12px; color: #5f6368;">{{ current_user.nickname or current_user.username }}</span>
+            <a href="{{ url_for('main.admin') }}" class="btn btn-secondary">사용자 관리</a>
+            <a href="{{ url_for('main.admin_webnovels') }}" class="btn btn-secondary">웹소설 관리</a>
+            <a href="{{ url_for('main.admin_files') }}" class="btn btn-secondary">파일 목록</a>
+            <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
+            <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
+            <a href="{{ url_for('main.index') }}" class="btn btn-secondary">메인으로</a>
+            <a href="{{ url_for('main.logout') }}" class="btn btn-secondary">로그아웃</a>
+        </div>
+    </div>
+
+    <div class="container">
+        <div class="page-header">
+            <h1>AI 설정 관리</h1>
+            <p>Gemini API 키와 AI 모델별 토큰 수를 관리할 수 있습니다.</p>
+        </div>
+
+        <div id="alertContainer"></div>
+
+        <!-- Gemini API 키 설정 섹션 -->
+        <div class="card">
+            <div class="card-header">
+                <div class="card-title">Gemini API 키 설정</div>
+            </div>
+            <div style="padding: 16px 0;">
+                <div class="form-group">
+                    <label for="geminiApiKey">Gemini API 키</label>
+                    <div style="display: flex; gap: 8px;">
+                        <input type="password" id="geminiApiKey" placeholder="Gemini API 키를 입력하세요" style="flex: 1; padding: 8px 12px; border: 1px solid #dadce0; border-radius: 4px; font-size: 14px;">
+                        <button class="btn btn-primary" onclick="saveGeminiApiKey()">저장</button>
+                        <button class="btn btn-secondary" onclick="loadGeminiApiKey()">현재 상태 확인</button>
+                    </div>
+                    <small style="color: #5f6368; font-size: 12px; display: block; margin-top: 4px;">
+                        Google AI Studio(<a href="https://aistudio.google.com/app/apikey" target="_blank">https://aistudio.google.com/app/apikey</a>)에서 API 키를 발급받을 수 있습니다.
+                    </small>
+                    <div id="geminiApiKeyStatus" style="margin-top: 8px; font-size: 13px;"></div>
+                </div>
+            </div>
+        </div>
+
+        <!-- AI 모델별 토큰 수 관리 섹션 -->
+        <div class="card">
+            <div class="card-header">
+                <div class="card-title">AI 모델별 토큰 수 관리</div>
+                <button class="btn btn-secondary" onclick="loadModelTokens()">새로고침</button>
+            </div>
+            <div style="padding: 16px 0;">
+                <div id="modelTokensStatus" style="margin-bottom: 16px; font-size: 13px;"></div>
+                <div id="modelTokensList" style="display: grid; gap: 12px;">
+                    <div style="text-align: center; padding: 20px; color: #5f6368;">로딩 중...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        function showAlert(message, type = 'success') {
+            const container = document.getElementById('alertContainer');
+            container.innerHTML = `<div class="alert ${type}">${message}</div>`;
+            setTimeout(() => {
+                container.innerHTML = '';
+            }, 5000);
+        }
+
+        // Gemini API 키 관련 함수
+        async function loadGeminiApiKey() {
+            try {
+                const response = await fetch('/api/admin/gemini-api-key', {
+                    credentials: 'include'
+                });
+                
+                // 응답이 JSON인지 확인
+                const contentType = response.headers.get('content-type');
+                if (!contentType || !contentType.includes('application/json')) {
+                    const text = await response.text();
+                    console.error('Non-JSON response:', text.substring(0, 200));
+                    const statusDiv = document.getElementById('geminiApiKeyStatus');
+                    statusDiv.innerHTML = `<span style="color: #ea4335;">서버 오류: 응답 형식이 올바르지 않습니다.</span>`;
+                    return;
+                }
+                
+                const data = await response.json();
+                
+                const statusDiv = document.getElementById('geminiApiKeyStatus');
+                if (!response.ok) {
+                    statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${data.error || '알 수 없는 오류'}</span>`;
+                    return;
+                }
+                
+                if (data.has_api_key) {
+                    statusDiv.innerHTML = `<span style="color: #137333;">✓ API 키가 설정되어 있습니다 (${data.masked_key})</span>`;
+                } else {
+                    statusDiv.innerHTML = `<span style="color: #ea4335;">⚠ API 키가 설정되지 않았습니다</span>`;
+                }
+            } catch (error) {
+                console.error('Gemini API 키 로드 오류:', error);
+                const statusDiv = document.getElementById('geminiApiKeyStatus');
+                statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${error.message}</span>`;
+            }
+        }
+
+        async function saveGeminiApiKey() {
+            const apiKeyInput = document.getElementById('geminiApiKey');
+            const apiKey = apiKeyInput.value.trim();
+            
+            if (!apiKey) {
+                showAlert('API 키를 입력해주세요.', 'error');
+                return;
+            }
+
+            try {
+                const response = await fetch('/api/admin/gemini-api-key', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    credentials: 'include',
+                    body: JSON.stringify({ api_key: apiKey })
+                });
+
+                // 응답이 JSON인지 확인
+                const contentType = response.headers.get('content-type');
+                if (!contentType || !contentType.includes('application/json')) {
+                    const text = await response.text();
+                    console.error('Non-JSON response:', text.substring(0, 200));
+                    showAlert('서버 오류: 응답 형식이 올바르지 않습니다.', 'error');
+                    return;
+                }
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    showAlert(data.message, 'success');
+                    apiKeyInput.value = ''; // 보안을 위해 입력 필드 초기화
+                    loadGeminiApiKey(); // 상태 업데이트
+                } else {
+                    showAlert(data.error || 'API 키 저장 중 오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                console.error('Gemini API 키 저장 오류:', error);
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+
+        // AI 모델별 토큰 수 관리 (입력/출력 분리)
+        async function loadModelTokens() {
+            const statusDiv = document.getElementById('modelTokensStatus');
+            const listDiv = document.getElementById('modelTokensList');
+            
+            try {
+                statusDiv.innerHTML = '<span style="color: #1a73e8;">토큰 수 설정을 불러오는 중...</span>';
+                listDiv.innerHTML = '<div style="text-align: center; padding: 20px; color: #5f6368;">로딩 중...</div>';
+                
+                const response = await fetch('/api/admin/model-tokens', {
+                    credentials: 'include'
+                });
+                
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ error: '서버 오류' }));
+                    statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${error.error || '토큰 수 설정을 불러올 수 없습니다'}</span>`;
+                    listDiv.innerHTML = '<div style="text-align: center; padding: 20px; color: #ea4335;">토큰 수 설정을 불러올 수 없습니다.</div>';
+                    return;
+                }
+                
+                const data = await response.json();
+                
+                if (!data.models || data.models.length === 0) {
+                    statusDiv.innerHTML = '<span style="color: #5f6368;">사용 가능한 AI 모델이 없습니다.</span>';
+                    listDiv.innerHTML = '<div style="text-align: center; padding: 20px; color: #5f6368;">사용 가능한 AI 모델이 없습니다.</div>';
+                    return;
+                }
+                
+                statusDiv.innerHTML = `<span style="color: #137333;">✓ ${data.models.length}개 모델 발견</span>`;
+                
+                let html = '';
+                data.models.forEach(modelName => {
+                    // 안전하게 토큰 데이터 접근 (undefined 체크)
+                    const inputTokens = data.input_tokens || {};
+                    const outputTokens = data.output_tokens || {};
+                    const parentChunkTokens = data.parent_chunk_tokens || {};
+                    const defaultInputTokens = data.default_input_tokens || {};
+                    const defaultOutputTokens = data.default_output_tokens || {};
+                    const defaultParentChunkTokens = data.default_parent_chunk_tokens || {};
+                    
+                    const currentInputTokens = inputTokens[modelName] || '';
+                    const currentOutputTokens = outputTokens[modelName] || '';
+                    const currentParentChunkTokens = parentChunkTokens[modelName] || '';
+                    const defaultInputToken = defaultInputTokens[modelName] || 100000;
+                    const defaultOutputToken = defaultOutputTokens[modelName] || 2000;
+                    const defaultParentChunkToken = defaultParentChunkTokens[modelName] || 8192;
+                    const modelType = modelName.startsWith('gemini:') ? 'Gemini' : 'Ollama';
+                    const displayName = modelName.startsWith('gemini:') ? modelName.replace('gemini:', '') : modelName;
+                    
+                    // 실제 사용 중인 값 계산
+                    const actualInputToken = currentInputTokens ? parseInt(currentInputTokens) : defaultInputToken;
+                    const actualOutputToken = currentOutputTokens ? parseInt(currentOutputTokens) : defaultOutputToken;
+                    const actualParentChunkToken = currentParentChunkTokens ? parseInt(currentParentChunkTokens) : defaultParentChunkToken;
+                    
+                    // 사용 중인 값 표시 텍스트 생성
+                    const getTokenStatusText = (actual, defaultVal, isUsingDefault) => {
+                        if (isUsingDefault) {
+                            return `실제 사용: ${actual.toLocaleString()} (기본값)`;
+                        } else {
+                            return `실제 사용: ${actual.toLocaleString()} (설정값)`;
+                        }
+                    };
+                    
+                    const inputStatusText = getTokenStatusText(actualInputToken, defaultInputToken, !currentInputTokens);
+                    const outputStatusText = getTokenStatusText(actualOutputToken, defaultOutputToken, !currentOutputTokens);
+                    const parentChunkStatusText = getTokenStatusText(actualParentChunkToken, defaultParentChunkToken, !currentParentChunkTokens);
+                    
+                    // 안전한 ID 생성 (특수문자 처리)
+                    const safeId = modelNameToId(modelName);
+                    
+                    html += `
+                        <div style="padding: 16px; background: #f8f9fa; border-radius: 6px; border: 1px solid #dadce0; margin-bottom: 12px;" data-model-name="${escapeHtml(modelName)}">
+                            <div style="margin-bottom: 12px;">
+                                <div style="font-weight: 500; margin-bottom: 4px; font-size: 15px;">${escapeHtml(displayName)}</div>
+                                <div style="font-size: 12px; color: #5f6368; line-height: 1.6;">
+                                    <div><strong>타입:</strong> ${modelType}</div>
+                                    <div><strong>입력 토큰:</strong> ${inputStatusText}</div>
+                                    <div><strong>출력 토큰:</strong> ${outputStatusText}</div>
+                                    <div><strong>Parent Chunk 토큰:</strong> ${parentChunkStatusText}</div>
+                                </div>
+                            </div>
+                            <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 12px;">
+                                <div>
+                                    <label style="display: block; font-size: 13px; font-weight: 500; margin-bottom: 6px; color: #202124;">입력 토큰</label>
+                                    <div style="display: flex; gap: 8px;">
+                                        <input 
+                                            type="number" 
+                                            id="input_tokens_${safeId}" 
+                                            data-model-name="${escapeHtml(modelName)}"
+                                            value="${currentInputTokens || ''}" 
+                                            placeholder="기본값: ${defaultInputToken.toLocaleString()}" 
+                                            min="1" 
+                                            style="flex: 1; padding: 6px 10px; border: 1px solid #dadce0; border-radius: 4px; font-size: 14px;"
+                                        >
+                                        <button 
+                                            class="btn btn-primary" 
+                                            onclick="saveModelTokens('${escapeHtml(modelName)}', 'input')"
+                                            style="padding: 6px 12px; font-size: 13px; white-space: nowrap;"
+                                        >
+                                            저장
+                                        </button>
+                                    </div>
+                                </div>
+                                <div>
+                                    <label style="display: block; font-size: 13px; font-weight: 500; margin-bottom: 6px; color: #202124;">출력 토큰</label>
+                                    <div style="display: flex; gap: 8px;">
+                                        <input 
+                                            type="number" 
+                                            id="output_tokens_${safeId}" 
+                                            data-model-name="${escapeHtml(modelName)}"
+                                            value="${currentOutputTokens || ''}" 
+                                            placeholder="기본값: ${defaultOutputToken.toLocaleString()}" 
+                                            min="1" 
+                                            style="flex: 1; padding: 6px 10px; border: 1px solid #dadce0; border-radius: 4px; font-size: 14px;"
+                                        >
+                                        <button 
+                                            class="btn btn-primary" 
+                                            onclick="saveModelTokens('${escapeHtml(modelName)}', 'output')"
+                                            style="padding: 6px 12px; font-size: 13px; white-space: nowrap;"
+                                        >
+                                            저장
+                                        </button>
+                                    </div>
+                                </div>
+                                <div>
+                                    <label style="display: block; font-size: 13px; font-weight: 500; margin-bottom: 6px; color: #202124;">Parent Chunk 토큰</label>
+                                    <div style="display: flex; gap: 8px;">
+                                        <input 
+                                            type="number" 
+                                            id="parent_chunk_tokens_${safeId}" 
+                                            data-model-name="${escapeHtml(modelName)}"
+                                            value="${currentParentChunkTokens || ''}" 
+                                            placeholder="기본값: ${defaultParentChunkToken.toLocaleString()}" 
+                                            min="1" 
+                                            style="flex: 1; padding: 6px 10px; border: 1px solid #dadce0; border-radius: 4px; font-size: 14px;"
+                                        >
+                                        <button 
+                                            class="btn btn-primary" 
+                                            onclick="saveModelTokens('${escapeHtml(modelName)}', 'parent_chunk')"
+                                            style="padding: 6px 12px; font-size: 13px; white-space: nowrap;"
+                                        >
+                                            저장
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                    `;
+                });
+                
+                listDiv.innerHTML = html;
+                
+            } catch (error) {
+                console.error('토큰 수 설정 로드 오류:', error);
+                statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${error.message}</span>`;
+                listDiv.innerHTML = '<div style="text-align: center; padding: 20px; color: #ea4335;">토큰 수 설정을 불러오는 중 오류가 발생했습니다.</div>';
+            }
+        }
+        
+        async function saveModelTokens(modelName, tokenType) {
+            // tokenType에 따라 input ID 결정 (안전한 ID 사용)
+            const safeId = modelNameToId(modelName);
+            let inputId;
+            if (tokenType === 'input') {
+                inputId = `input_tokens_${safeId}`;
+            } else if (tokenType === 'output') {
+                inputId = `output_tokens_${safeId}`;
+            } else if (tokenType === 'parent_chunk') {
+                inputId = `parent_chunk_tokens_${safeId}`;
+            } else {
+                showAlert('잘못된 토큰 타입입니다.', 'error');
+                return;
+            }
+            
+            const input = document.getElementById(inputId);
+            if (!input) {
+                console.error(`Input element not found: ${inputId}`);
+                showAlert('입력 필드를 찾을 수 없습니다. 페이지를 새로고침해주세요.', 'error');
+                return;
+            }
+            
+            const tokens = input.value.trim();
+            console.log(`[토큰 저장] 모델: ${modelName}, 타입: ${tokenType}, 값: ${tokens}`);
+            
+            // 빈 값이면 기본값으로 되돌리기 (설정 삭제)
+            if (!tokens) {
+                if (!confirm('입력값이 비어있습니다. 기본값으로 되돌리시겠습니까?')) {
+                    return;
+                }
+                
+                try {
+                    const response = await fetch('/api/admin/model-tokens', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        credentials: 'include',
+                        body: JSON.stringify({
+                            model_name: modelName,
+                            token_type: tokenType,
+                            tokens: null  // null을 보내면 삭제
+                        })
+                    });
+                    
+                    const data = await response.json();
+                    
+                    if (response.ok) {
+                        showAlert('기본값으로 되돌렸습니다.', 'success');
+                        loadModelTokens(); // 목록 새로고침
+                    } else {
+                        showAlert(data.error || '설정 삭제 중 오류가 발생했습니다.', 'error');
+                    }
+                } catch (error) {
+                    console.error('설정 삭제 오류:', error);
+                    showAlert(`오류: ${error.message}`, 'error');
+                }
+                return;
+            }
+            
+            try {
+                const tokensNum = parseInt(tokens);
+                if (isNaN(tokensNum) || tokensNum < 1) {
+                    showAlert('토큰 수는 1 이상의 정수여야 합니다.', 'error');
+                    return;
+                }
+                
+                const response = await fetch('/api/admin/model-tokens', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    credentials: 'include',
+                    body: JSON.stringify({
+                        model_name: modelName,
+                        token_type: tokenType,
+                        tokens: tokensNum
+                    })
+                });
+                
+                const data = await response.json();
+                console.log(`[토큰 저장 응답]`, data);
+                
+                if (response.ok) {
+                    showAlert(data.message || '토큰 수가 저장되었습니다.', 'success');
+                    // 약간의 지연 후 목록 새로고침 (서버 반영 시간 고려)
+                    setTimeout(() => {
+                        loadModelTokens(); // 목록 새로고침
+                    }, 300);
+                } else {
+                    console.error(`[토큰 저장 실패]`, data);
+                    showAlert(data.error || '토큰 수 저장 중 오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                console.error('토큰 수 저장 오류:', error);
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+        
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+        
+        // 모델명을 안전한 ID로 변환 (특수문자 처리)
+        function modelNameToId(modelName) {
+            // 특수문자를 언더스코어로 변환
+            return modelName.replace(/[^a-zA-Z0-9]/g, '_');
+        }
+        
+        // ID를 모델명으로 역변환 (언더스코어를 원래 특수문자로 복원)
+        // 주의: 이 방법은 완벽하지 않으므로, 대신 data 속성을 사용하는 것이 더 안전합니다
+        function idToModelName(id) {
+            // 이 함수는 사용하지 않음 - data 속성 사용
+            return id;
+        }
+
+        // 페이지 로드 시 API 키 상태 확인 및 토큰 수 설정 로드
+        window.addEventListener('load', () => {
+            loadGeminiApiKey();
+            loadModelTokens();
+        });
+    </script>
+</body>
+</html>
+

templates/admin_webnovels.html

@@ -17,6 +17,7 @@
             font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
             background: #f8f9fa;
             color: #202124;
+            overflow-x: hidden;
         }
 
         .header {
@@ -27,6 +28,7 @@
             align-items: center;
             justify-content: space-between;
             box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+            overflow-x: hidden;
         }
 
         .header-title {
@@ -41,6 +43,7 @@
             display: flex;
             gap: 12px;
             align-items: center;
+            flex-wrap: wrap;
         }
 
         .btn {
@@ -86,6 +89,7 @@
             max-width: 1200px;
             margin: 0 auto;
             padding: 24px;
+            overflow-x: hidden;
         }
 
         .page-header {
@@ -108,6 +112,7 @@
             box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
             padding: 24px;
             margin-bottom: 24px;
+            overflow-x: hidden;
         }
 
         .card-header {
@@ -125,6 +130,7 @@
         table {
             width: 100%;
             border-collapse: collapse;
+            table-layout: auto;
         }
 
         thead {
@@ -135,6 +141,8 @@
             padding: 12px;
             text-align: left;
             border-bottom: 1px solid #e8eaed;
+            word-break: break-word;
+            overflow-wrap: break-word;
         }
 
         th {
@@ -217,6 +225,8 @@
             font-size: 12px;
             margin-top: 8px;
             min-height: 16px;
+            word-break: break-word;
+            overflow-wrap: break-word;
         }
 
         .file-upload-status.success {
@@ -250,6 +260,7 @@
             justify-content: space-between;
             padding: 8px 0;
             border-bottom: 1px solid #e8eaed;
+            min-width: 0;
         }
 
         .progress-item:last-child {
@@ -264,6 +275,8 @@
             text-overflow: ellipsis;
             white-space: nowrap;
             margin-right: 12px;
+            min-width: 0;
+            max-width: 100%;
         }
 
         .progress-item-status {
@@ -597,13 +610,42 @@
 
         // 모델 목록 로드 (관리자용: 모든 모델 표시)
         async function loadModelsForFiles() {
+            if (!fileModelSelect) {
+                console.error('[모델 목록] fileModelSelect 요소를 찾을 수 없습니다.');
+                return;
+            }
+            
             try {
-                const response = await fetch('/api/admin/ollama/models');
+                console.log('[모델 목록] API 요청 시작: /api/admin/ollama/models');
+                const response = await fetch('/api/admin/ollama/models', {
+                    credentials: 'include',  // 쿠키 포함 (세션 인증)
+                    headers: {
+                        'Accept': 'application/json'
+                    }
+                });
+                
+                console.log('[모델 목록] 응답 상태:', response.status, response.statusText);
+                console.log('[모델 목록] 응답 헤더:', Object.fromEntries(response.headers.entries()));
+                
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    console.error('[모델 목록] 응답 오류:', errorText);
+                    try {
+                        const errorData = JSON.parse(errorText);
+                        fileModelSelect.innerHTML = `<option value="">모델을 불러올 수 없습니다: ${errorData.error || '서버 오류'}</option>`;
+                    } catch {
+                        fileModelSelect.innerHTML = `<option value="">모델을 불러올 수 없습니다 (${response.status} ${response.statusText})</option>`;
+                    }
+                    return;
+                }
+                
                 const data = await response.json();
+                console.log('[모델 목록] 응답 데이터:', data);
                 
                 fileModelSelect.innerHTML = '<option value="">모델을 선택하세요...</option>';
                 
                 if (data.models && data.models.length > 0) {
+                    console.log(`[모델 목록] ${data.models.length}개 모델 발견`);
                     data.models.forEach(model => {
                         const option = document.createElement('option');
                         option.value = model.name;
@@ -614,22 +656,55 @@
                             : model.name;
                         option.textContent = displayText;
                         fileModelSelect.appendChild(option);
+                        console.log(`[모델 목록] 모델 추가: ${model.name} (타입: ${model.type || 'unknown'})`);
                     });
+                    console.log(`[모델 목록] 총 ${data.models.length}개 모델 로드 완료`);
                 } else if (data.error) {
-                    console.error('모델 로드 오류:', data.error);
-                    fileModelSelect.innerHTML = '<option value="">모델을 불러올 수 없습니���</option>';
+                    console.error('[모델 목록] 오류:', data.error);
+                    fileModelSelect.innerHTML = `<option value="">${escapeHtml(data.error) || '모델을 불러올 수 없습니다'}</option>`;
+                } else {
+                    console.warn('[모델 목록] 모델이 없습니다');
+                    fileModelSelect.innerHTML = '<option value="">사용 가능한 모델이 없습니다</option>';
                 }
             } catch (error) {
-                console.error('모델 로드 오류:', error);
-                fileModelSelect.innerHTML = '<option value="">모델 로드 실패</option>';
+                console.error('[모델 목록] 로드 오류:', error);
+                fileModelSelect.innerHTML = `<option value="">모델 로드 실패: ${escapeHtml(error.message)}</option>`;
             }
         }
 
         // 파일 목록 로드
         async function loadFiles() {
+            if (!filesTableBody) {
+                console.error('[파일 목록] filesTableBody 요소를 찾을 수 없습니다.');
+                return;
+            }
+            
             try {
-                const response = await fetch('/api/files');
+                console.log('[파일 목록] API 요청 시작: /api/files');
+                const response = await fetch('/api/files', {
+                    credentials: 'include',  // 쿠키 포함 (세션 인증)
+                    headers: {
+                        'Accept': 'application/json'
+                    }
+                });
+                
+                console.log('[파일 목록] 응답 상태:', response.status, response.statusText);
+                console.log('[파일 목록] 응답 헤더:', Object.fromEntries(response.headers.entries()));
+                
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    console.error('[파일 목록] 응답 오류:', errorText);
+                    try {
+                        const errorData = JSON.parse(errorText);
+                        filesTableBody.innerHTML = `<tr><td colspan="5" style="text-align: center; padding: 20px; color: #c5221f;">파일 목록을 불러올 수 없습니다: ${escapeHtml(errorData.error || '서버 오류')}</td></tr>`;
+                    } catch {
+                        filesTableBody.innerHTML = `<tr><td colspan="5" style="text-align: center; padding: 20px; color: #c5221f;">파일 목록을 불러올 수 없습니다 (${response.status} ${response.statusText})</td></tr>`;
+                    }
+                    return;
+                }
+                
                 const data = await response.json();
+                console.log('[파일 목록] 응답 데이터:', data);
                 
                 filesTableBody.innerHTML = '';
                 
@@ -715,11 +790,12 @@
                         });
                     });
                 } else {
+                    console.log('[파일 목록] 업로드된 파일이 없습니다');
                     filesTableBody.innerHTML = '<tr><td colspan="5" style="text-align: center; padding: 20px; color: #5f6368;">업로드된 파일이 없습니다.</td></tr>';
                 }
             } catch (error) {
-                filesTableBody.innerHTML = '<tr><td colspan="5" style="text-align: center; padding: 20px; color: #c5221f;">파일 목록을 불러오는 중 오류가 발생했습니다.</td></tr>';
-                console.error('파일 목록 로드 오류:', error);
+                console.error('[파일 목록] 로드 오류:', error);
+                filesTableBody.innerHTML = `<tr><td colspan="5" style="text-align: center; padding: 20px; color: #c5221f;">파일 목록을 불러오는 중 오류가 발생했습니다.<br><small>${escapeHtml(error.message)}</small></td></tr>`;
             }
         }
 
@@ -813,32 +889,41 @@
                 progressMap.set(index, { file, item, status: 'waiting', step: 0 });
             });
 
-            // 업로드 단계 정의
+            // 업로드 단계 정의 (더 세분화)
             const uploadSteps = [
                 { name: '업로드 폴더 확인', step: 1 },
                 { name: '파일 수신', step: 2 },
                 { name: '파일 검증', step: 3 },
                 { name: '파일 저장', step: 4 },
                 { name: '데이터베이스 저장', step: 5 },
-                { name: '청크 생성', step: 6 },
-                { name: '완료', step: 7 }
+                { name: 'Parent Chunk 생성', step: 6, detail: 'AI 분석 중...' },
+                { name: 'Child Chunk 생성', step: 7, detail: '섹션 분할 중...' },
+                { name: '회차 분석', step: 8, detail: '회차 분석 준비 중...' },
+                { name: 'Graph Extraction', step: 9, detail: 'Graph Extraction 준비 중...' },
+                { name: '완료', step: 10 }
             ];
 
-            function updateProgressStatus(fileIndex, stepIndex, stepName) {
+            function updateProgressStatus(fileIndex, stepIndex, stepName, totalFiles, detail = null) {
                 const statusElement = document.getElementById(`progress-status-${fileIndex}`);
                 if (statusElement) {
                     const step = uploadSteps[stepIndex] || { name: stepName || '처리 중', step: stepIndex + 1 };
-                    statusElement.innerHTML = `<span class="spinner"></span>${step.name} (${step.step}/7)`;
+                    const currentFile = fileIndex + 1;
+                    const detailText = detail || step.detail || '';
+                    const detailDisplay = detailText ? ` - ${detailText}` : '';
+                    statusElement.innerHTML = `<span class="spinner"></span>파일 ${currentFile}/${totalFiles}: ${step.name} (${step.step}/10)${detailDisplay}`;
                 }
             }
 
-            function updateOverallStatus(currentFile, totalFiles, stepIndex) {
+            function updateOverallStatus(currentFile, totalFiles, stepIndex, detail = null) {
                 const step = uploadSteps[stepIndex] || { name: '처리 중', step: stepIndex + 1 };
-                fileUploadStatus.textContent = `[${currentFile}/${totalFiles}] ${step.name} 중... (${step.step}/7)`;
+                const progressPercent = Math.round((currentFile / totalFiles) * 100);
+                const detailText = detail || step.detail || '';
+                const detailDisplay = detailText ? ` - ${detailText}` : '';
+                fileUploadStatus.textContent = `[파일 ${currentFile}/${totalFiles}] ${step.name} 중... (${step.step}/10)${detailDisplay} - 전체 진행률: ${progressPercent}%`;
             }
 
             if (fileUploadStatus) {
-                fileUploadStatus.textContent = `[0/${files.length}] 업로드 준비 중...`;
+                fileUploadStatus.textContent = `[파일 0/${files.length}] 업로드 준비 중... - 전체 진행률: 0%`;
                 fileUploadStatus.className = 'file-upload-status progress';
             }
 
@@ -884,14 +969,14 @@
                         
                         // 단계 1: 업로드 폴더 확인
                         console.log(`[단계 1] 업로드 폴더 확인 시작`);
-                        updateProgressStatus(i, 0, '업로드 폴더 확인');
+                        updateProgressStatus(i, 0, '업로드 폴더 확인', files.length);
                         updateOverallStatus(i + 1, files.length, 0);
                         
                         console.log(`[단계 1] fetch 호출 시작: /api/upload`);
                         console.log(`[단계 1] FormData 항목:`, Array.from(formData.entries()).map(([k, v]) => [k, v instanceof File ? v.name : v]));
                         
-                        // 타임아웃이 있는 fetch 래퍼 (15분 타임아웃 - 큰 파일 처리 시간 고려)
-                        const fetchWithTimeout = (url, options, timeout = 900000) => { // 15분 타임아웃
+                        // 타임아웃이 있는 fetch 래퍼 (30분 타임아웃 - 큰 파일 처리 시간 고려)
+                        const fetchWithTimeout = (url, options, timeout = 1800000) => { // 30분 타임아웃
                             return Promise.race([
                                 fetch(url, options),
                                 new Promise((_, reject) =>
@@ -904,7 +989,7 @@
                             method: 'POST',
                             body: formData,
                             credentials: 'include'  // 쿠키 포함 (세션 인증)
-                        }, 900000); // 15분 타임아웃
+                        }, 1800000); // 30분 타임아웃
                         
                         console.log(`[단계 1] fetch 응답 수신: ${response.status} ${response.statusText}`);
                         
@@ -922,13 +1007,13 @@
                         }
                     
                     // 단계 2: 파일 수신
-                    updateProgressStatus(i, 1, '파일 수신');
+                    updateProgressStatus(i, 1, '파일 수신', files.length);
                     updateOverallStatus(i + 1, files.length, 1);
 
                     console.log(`[응답 수신] 상태: ${response.status} ${response.statusText}, Content-Type: ${response.headers.get('Content-Type')}`);
 
                     // 단계 3: 파일 검증
-                    updateProgressStatus(i, 2, '파일 검증');
+                    updateProgressStatus(i, 2, '파일 검증', files.length);
                     updateOverallStatus(i + 1, files.length, 2);
 
                     let data;
@@ -944,36 +1029,94 @@
                     }
 
                     // 단계 4: 파일 저장
-                    updateProgressStatus(i, 3, '파일 저장');
+                    updateProgressStatus(i, 3, '파일 저장', files.length);
                     updateOverallStatus(i + 1, files.length, 3);
 
                     if (response.ok) {
-                        // 단계 5: 데이터베이스 저장
-                        updateProgressStatus(i, 4, '데이터베��스 저장');
-                        updateOverallStatus(i + 1, files.length, 4);
-                        
-                        // 단계 6: 청크 생성
-                        updateProgressStatus(i, 5, '청크 생성');
-                        updateOverallStatus(i + 1, files.length, 5);
-                        
-                        successCount++;
-                        const modelName = data.model_name || '알 수 없음';
-                        const chunkCount = data.chunk_count || 0;
+                        const fileId = data.file_id;
+                        const episodeCount = data.episode_count || 0;
+                        const needsProcessing = data.needs_processing !== false; // 기본값 true
                         
-                        // 단계 7: 완료
-                        updateProgressStatus(i, 6, '완료');
-                        updateOverallStatus(i + 1, files.length, 6);
+                        // 텍스트 파일이 아니면 처리 단계 건너뛰기
+                        if (!needsProcessing) {
+                            successCount++;
+                            const modelName = data.model_name || '알 수 없음';
+                            updateProgressStatus(i, 9, '완료', files.length);
+                            updateOverallStatus(i + 1, files.length, 9);
+                            statusElement.className = 'progress-item-status success';
+                            statusElement.innerHTML = `✓ 완료 (파일 ${i + 1}/${files.length})`;
+                            statusElement.title = `모델: ${modelName}`;
+                            itemElement.style.opacity = '0.7';
+                            console.log(`[업로드 성공] ${file.name} → 모델: ${modelName}`);
+                        } else {
+                            // 단계별 처리 함수
+                            const processStep = async (stepName, stepNumber, url, timeout, detailText = '') => {
+                                updateProgressStatus(i, stepNumber, stepName, files.length, detailText);
+                                updateOverallStatus(i + 1, files.length, stepNumber, detailText);
+                                
+                                const stepResponse = await fetchWithTimeout(url, {
+                                    method: 'POST',
+                                    credentials: 'include'
+                                }, timeout);
+                                
+                                if (!stepResponse.ok) {
+                                    const stepError = await stepResponse.json().catch(() => ({ error: `HTTP ${stepResponse.status}` }));
+                                    throw new Error(`${stepName} 실패: ${stepError.error || '알 수 없는 오류'}`);
+                                }
+                                
+                                return await stepResponse.json();
+                            };
+                            
+                            try {
+                                // 단계 1: Parent Chunk 생성 (10분 타임아웃)
+                                await processStep('Parent Chunk 생성', 5, `/api/files/${fileId}/process/parent-chunk`, 600000, 'AI 분석 중...');
+                                
+                                // 단계 2: Chunk 생성 (5분 타임아웃)
+                                const chunksData = await processStep('Child Chunk 생성', 6, `/api/files/${fileId}/process/chunks`, 300000, '섹션 분할 중...');
+                                const chunkCount = chunksData.chunk_count || 0;
+                                
+                                // 단계 3: 회차 분석 (회차당 2분, 최대 30분)
+                                const episodeTimeout = episodeCount > 0 ? Math.min(episodeCount * 120000, 1800000) : 600000;
+                                const episodeDetail = episodeCount > 0 ? `총 ${episodeCount}회차 중 분석 중...` : '회차 분석 중...';
+                                await processStep('회차 분석', 7, `/api/files/${fileId}/process/episode-analysis`, episodeTimeout, episodeDetail);
+                                
+                                // 단계 4: Graph Extraction (회차당 1분, 최대 20분)
+                                const graphTimeout = episodeCount > 0 ? Math.min(episodeCount * 60000, 1200000) : 300000;
+                                const graphDetail = episodeCount > 0 ? `총 ${episodeCount}회차 중 추출 중...` : 'Graph Extraction 중...';
+                                await processStep('Graph Extraction', 8, `/api/files/${fileId}/process/graph`, graphTimeout, graphDetail);
+                                
+                                successCount++;
+                                const modelName = data.model_name || '알 수 없음';
+                                
+                                // 단계 10: 완료
+                                updateProgressStatus(i, 9, '완료', files.length);
+                                updateOverallStatus(i + 1, files.length, 9);
+                                
+                                statusElement.className = 'progress-item-status success';
+                                statusElement.innerHTML = `✓ 완료 (파일 ${i + 1}/${files.length})`;
+                                statusElement.title = `모델: ${modelName}${chunkCount > 0 ? `, 청크: ${chunkCount}개` : ''}`;
+                                itemElement.style.opacity = '0.7';
+                                console.log(`[업로드 성공] ${file.name} → 모델: ${modelName}, 청크: ${chunkCount}개`);
+                            } catch (stepError) {
+                                // 단계별 처리 실패
+                                throw stepError;
+                            }
+                        }
                         
-                        statusElement.className = 'progress-item-status success';
-                        statusElement.innerHTML = '✓ 완료';
-                        statusElement.title = `모델: ${modelName}${chunkCount > 0 ? `, 청크: ${chunkCount}개` : ''}`;
-                        itemElement.style.opacity = '0.7';
-                        console.log(`[업로드 성공] ${file.name} → 모델: ${modelName}, 청크: ${chunkCount}개`);
+                        // 성공한 경우 진행 상태 업데이트
+                        const progressPercent = Math.round(((i + 1) / files.length) * 100);
+                        if (fileUploadStatus) {
+                            if (i < files.length - 1) {
+                                fileUploadStatus.textContent = `[파일 ${i + 1}/${files.length}] 완료, 다음 파일 처리 중... - 전체 진행률: ${progressPercent}%`;
+                            } else {
+                                fileUploadStatus.textContent = `[파일 ${i + 1}/${files.length}] 모든 파일 처리 완료 - 전체 진행률: 100%`;
+                            }
+                        }
                     } else {
                         failCount++;
                         const errorMsg = data.error || data.message || `HTTP ${response.status} 오류`;
                         statusElement.className = 'progress-item-status error';
-                        statusElement.innerHTML = '✗ 실패';
+                        statusElement.innerHTML = `✗ 실패 (파일 ${i + 1}/${files.length})`;
                         statusElement.title = errorMsg; // 툴팁으로 상세 에러 표시
                         statusElement.style.cursor = 'help'; // 툴팁 표시를 위한 커서 변경
                         errors.push(`${file.name}: ${errorMsg}`);
@@ -984,26 +1127,41 @@
                             data: data,
                             responseText: responseText
                         });
+                        
+                        // 실패한 경우 진행 상태 업데이트
+                        const progressPercent = Math.round(((i + 1) / files.length) * 100);
+                        if (fileUploadStatus) {
+                            if (i < files.length - 1) {
+                                fileUploadStatus.textContent = `[파일 ${i + 1}/${files.length}] 실패, 다음 파일 처리 중... - 전체 진행률: ${progressPercent}%`;
+                            } else {
+                                fileUploadStatus.textContent = `[파일 ${i + 1}/${files.length}] 모든 파일 처리 완료 (일부 실패) - 전체 진행률: ${progressPercent}%`;
+                            }
+                            fileUploadStatus.className = 'file-upload-status error';
+                        }
+                        showAlert(`파일 업로드 실패: ${file.name}\n${errorMsg}`, 'error');
                     }
                 } catch (error) {
                     failCount++;
                     const errorMsg = error.message || '네트워크 오류';
+                    
+                    // statusElement가 있으면 실패 상태로 표시
                     if (statusElement) {
                         statusElement.className = 'progress-item-status error';
-                        statusElement.innerHTML = '✗ 실패';
+                        statusElement.innerHTML = `✗ 실패 (파일 ${i + 1}/${files.length})`;
                         statusElement.title = errorMsg; // 툴팁으로 상세 에러 표시
                         statusElement.style.cursor = 'help'; // 툴팁 표시를 위한 커서 변경
                     }
+                    
                     errors.push(`${file.name}: ${errorMsg}`);
                     console.error(`[업로드 예외] 파일: ${file.name}`, error);
                     console.error(`[업로드 예외 스택]`, error.stack);
                     
                     // 타임아웃 오류인 경우 사용자에게 명확한 메시지 표시
                     if (error.message && error.message.includes('타임아웃')) {
-                        const timeoutMsg = `파일 업로드 타임아웃: ${file.name}\n파일이 크��나 처리 시간이 오래 걸려 타임아웃이 발생했습니다.`;
+                        const timeoutMsg = `파일 업로드 타임아웃: ${file.name}\n\n파일이 크거나 처리 시간이 오래 걸려 타임아웃이 발생했습니다.\n서버에서는 파일 처리가 계속 진행 중일 수 있습니다.\n서버 로그를 확인하시거나 잠시 후 파일 목록을 새로고침해보세요.`;
                         console.error(`[타임아웃 오류] ${timeoutMsg}`);
                         if (fileUploadStatus) {
-                            fileUploadStatus.textContent = `[${i + 1}/${files.length}] 타임아웃: ${file.name}`;
+                            fileUploadStatus.textContent = `[${i + 1}/${files.length}] 타임아웃: ${file.name} - 서버 로그 확인 필요`;
                             fileUploadStatus.className = 'file-upload-status error';
                         }
                         // 사용자에게 알림 표시
@@ -1023,15 +1181,18 @@
                         showAlert(`파일 업로드 오류: ${file.name}\n${errorMsg}`, 'error');
                     }
                     console.error(`[스택 트레이스]`, error.stack);
-                }
-
-                    // 진행 상태 업데이트 (다음 파일로 넘어가기 전)
-                    if (i < files.length - 1) {
-                        fileUploadStatus.textContent = `[${i + 1}/${files.length}] 완료, 다음 파일 처리 중...`;
-                    } else {
-                        fileUploadStatus.textContent = `[${i + 1}/${files.length}] 모든 파일 처리 완료`;
+                    
+                    // 진행 상태 업데이트 (에러 발생 시에도)
+                    const progressPercent = Math.round(((i + 1) / files.length) * 100);
+                    if (fileUploadStatus) {
+                        if (i < files.length - 1) {
+                            fileUploadStatus.textContent = `[파일 ${i + 1}/${files.length}] 오류 발생, 다음 파일 처리 중... - 전체 진행률: ${progressPercent}%`;
+                        } else {
+                            fileUploadStatus.textContent = `[파일 ${i + 1}/${files.length}] 모든 파일 처리 완료 (일부 실패) - 전체 진행률: ${progressPercent}%`;
+                        }
                     }
                 }
+                } // for 루프 닫기
             } catch (uploadLoopError) {
                 console.error('[업로드 루프 오류]', uploadLoopError);
                 fileUploadStatus.textContent = `업로드 처리 중 오류 발생: ${uploadLoopError.message}`;
@@ -1044,12 +1205,12 @@
                 if (fileUploadStatus) {
                     fileUploadStatus.className = 'file-upload-status';
                     if (successCount > 0) {
-                        fileUploadStatus.textContent = `${successCount}개 파일 업로드 완료${failCount > 0 ? ` (${failCount}개 실패)` : ''}`;
+                        fileUploadStatus.textContent = `✅ ${successCount}개 파일 업로드 완료${failCount > 0 ? ` (${failCount}개 실패)` : ''} - 전체 진행률: 100%`;
                         fileUploadStatus.className = 'file-upload-status success';
                         showAlert(`${successCount}개 파일이 성공적으로 업로드되었습니다.${failCount > 0 ? ` (${failCount}개 실패)` : ''}`, 'success');
                         loadFiles();
                     } else {
-                        fileUploadStatus.textContent = '모든 파일 업로드 실패';
+                        fileUploadStatus.textContent = `❌ 모든 파일 업로드 실패 - 전체 진행률: 100%`;
                         fileUploadStatus.className = 'file-upload-status error';
                         const errorDetails = errors.length > 0 ? '\n\n오류 상세:\n' + errors.slice(0, 5).map((e, idx) => `${idx + 1}. ${e}`).join('\n') + (errors.length > 5 ? `\n... 외 ${errors.length - 5}개 오류` : '') : '';
                         showAlert(`파일 업로드에 실패했습니다.${errorDetails}`, 'error');
@@ -1067,15 +1228,9 @@
                 console.error('[handleFileUpload] 완료 처리 오류:', finalError);
             }
 
-            // 3초 후 진행 상태 숨기기
-            setTimeout(() => {
-                if (progressContainer) {
-                    progressContainer.classList.remove('active');
-                }
-                if (fileUploadStatus) {
-                    fileUploadStatus.textContent = '';
-                }
-            }, 3000);
+            // 업로드가 완전히 끝날 때까지 진행 상태 유지 (자동 숨김 제거)
+            // 사용자가 수동으로 닫을 수 있도록 버튼 추가는 선택사항
+            // 진행 상태는 업로드 완료 후에도 계속 표시됨
         }
 
         // 파일 삭제
@@ -1397,11 +1552,49 @@
             }
         });
 
-        // 페이지 로드 시 초기화
-        window.addEventListener('load', () => {
-            loadModelsForFiles();
-            loadFiles();
-        });
+        // 페이지 로드 시 초기화 (한 번만 실행)
+        let initialized = false;
+        function initializePage() {
+            if (initialized) {
+                console.log('[초기화] 이미 초기화되었습니다.');
+                return;
+            }
+            
+            // DOM 요소 존재 확인
+            if (!fileModelSelect || !filesTableBody) {
+                console.error('[초기화] 필수 DOM 요소가 없습니다:', {
+                    fileModelSelect: !!fileModelSelect,
+                    filesTableBody: !!filesTableBody
+                });
+                return;
+            }
+            
+            initialized = true;
+            console.log('[초기화] 페이지 초기화 시작');
+            
+            // 모델 목록 로드
+            loadModelsForFiles().catch(error => {
+                console.error('[초기화] 모델 목록 로드 실패:', error);
+                initialized = false; // 실패 시 재시도 가능하도록
+            });
+            
+            // 파일 목록 로드
+            loadFiles().catch(error => {
+                console.error('[초기화] 파일 목록 로드 실패:', error);
+                initialized = false; // 실패 시 재시도 가능하도록
+            });
+        }
+        
+        // DOMContentLoaded 또는 load 이벤트에서 초기화
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', initializePage);
+        } else {
+            // 이미 로드된 경우 즉시 실행
+            initializePage();
+        }
+        
+        // 추가 안전장치: load 이벤트에서도 시도 (이미 초기화되었으면 무시됨)
+        window.addEventListener('load', initializePage);
     </script>
 </body>
 </html>

templates/index.html

@@ -88,6 +88,7 @@
             padding: 12px;
         }
 
+        .sidebar.collapsed .available-models-list,
         .sidebar.collapsed .model-selector-label,
         .sidebar.collapsed .model-select,
         .sidebar.collapsed .model-status,
@@ -258,6 +259,21 @@
         }
 
         /* AI 모델 선택 영역 */
+        .available-models-list {
+            border-top: 1px solid var(--border);
+            padding: 16px;
+            background: var(--bg-primary);
+        }
+
+        .available-models-list .model-select {
+            margin-top: 8px;
+        }
+
+        .available-models-list .model-select:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+        }
+
         .model-selector {
             border-top: 1px solid var(--border);
             padding: 16px;
@@ -733,6 +749,11 @@
             flex-direction: row-reverse;
         }
 
+        .message.ai {
+            flex-direction: column;
+            align-items: flex-start;
+        }
+
         .message-avatar {
             width: 32px;
             height: 32px;
@@ -744,6 +765,13 @@
             flex-shrink: 0;
         }
 
+        .message.ai .message-avatar {
+            width: 24px;
+            height: 24px;
+            font-size: 14px;
+            margin-bottom: 8px;
+        }
+
         .message.user .message-avatar {
             background: var(--accent);
             color: white;
@@ -771,7 +799,7 @@
         }
         
         .message.ai .message-bubble {
-            white-space: normal;
+            white-space: pre-wrap; /* 줄바꿈 보존 */
         }
         
         .message.ai .message-bubble br {
@@ -1216,13 +1244,26 @@
             <!-- 대화 히스토리 항목들이 여기에 동적으로 추가됩니다 -->
         </div>
         
+        <!-- 사용 가능한 AI 목록 -->
+        <div class="available-models-list">
+            <div class="model-selector-label">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/>
+                </svg>
+                사용 가능한 AI 목록
+            </div>
+            <select class="model-select" id="availableModelsSelect">
+                <option value="">AI 목록을 불러오는 중...</option>
+            </select>
+        </div>
+        
         <!-- AI 모델 선택 영역 -->
         <div class="model-selector">
             <div class="model-selector-label">
                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                     <path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/>
                 </svg>
-                로컬 AI 모델
+                AI 모델 선택
             </div>
             <select class="model-select" id="modelSelect">
                 <option value="">모델을 선택하세요...</option>
@@ -1419,20 +1460,32 @@
         let currentChatId = null;
         let currentSessionId = null;
         let chatSessions = [];
-        let selectedModel = localStorage.getItem('selectedModel') || '';
+        let selectedModel = localStorage.getItem('selectedModel') || ''; // 질문 분석용 모델
+        let answerModel = localStorage.getItem('answerModel') || ''; // 최종 답변용 모델
         let selectedFileIds = JSON.parse(localStorage.getItem('selectedFileIds') || '[]');
         
         const novelList = document.getElementById('novelList');
         const selectedNovelsInfo = document.getElementById('selectedNovelsInfo');
         
-        // 모델 선택 이벤트
+        // 모델 선택 이벤트 (질문 분석용)
         modelSelect.addEventListener('change', function() {
             selectedModel = this.value;
             localStorage.setItem('selectedModel', selectedModel);
-            updateModelStatus();
+            updateModelStatus('connected');
             loadNovels(); // 모델 변경 시 웹소설 목록 로드
         });
         
+        // 사용 가능한 AI 목록 선택 이벤트 (최종 답변용)
+        const availableModelsSelect = document.getElementById('availableModelsSelect');
+        availableModelsSelect.addEventListener('change', function() {
+            answerModel = this.value;
+            localStorage.setItem('answerModel', answerModel);
+            // 선택된 모델이 있으면 콘솔에 로그 출력 (디버깅용)
+            if (answerModel) {
+                console.log('[답변 모델 선택]', answerModel);
+            }
+        });
+        
         // 웹소설 목록 로드
         async function loadNovels() {
             try {
@@ -1545,7 +1598,78 @@
             }
         }
         
-        // 모델 목록 로드
+        // 사용 가능한 AI 목록 로드 (모든 모델)
+        async function loadAvailableModels() {
+            const availableModelsSelect = document.getElementById('availableModelsSelect');
+            availableModelsSelect.disabled = true;
+            availableModelsSelect.innerHTML = '<option value="">AI 목록을 불러오는 중...</option>';
+            
+            try {
+                const response = await fetch('/api/ollama/models?all=true');
+                const data = await response.json();
+                
+                availableModelsSelect.innerHTML = '<option value="">답변 생성할 AI 모델을 선택하세요...</option>';
+                
+                if (data.models && data.models.length > 0) {
+                    // 모델을 타입별로 그룹화
+                    const ollamaModels = [];
+                    const geminiModels = [];
+                    
+                    data.models.forEach(model => {
+                        if (model.type === 'gemini') {
+                            geminiModels.push(model);
+                        } else {
+                            ollamaModels.push(model);
+                        }
+                    });
+                    
+                    // Ollama 모델 그룹
+                    if (ollamaModels.length > 0) {
+                        const optgroup = document.createElement('optgroup');
+                        optgroup.label = '🤖 Ollama 모델';
+                        ollamaModels.forEach(model => {
+                            const option = document.createElement('option');
+                            option.value = model.name;
+                            option.textContent = model.name;
+                            if (model.name === answerModel) {
+                                option.selected = true;
+                            }
+                            optgroup.appendChild(option);
+                        });
+                        availableModelsSelect.appendChild(optgroup);
+                    }
+                    
+                    // Gemini 모델 그룹
+                    if (geminiModels.length > 0) {
+                        const optgroup = document.createElement('optgroup');
+                        optgroup.label = '✨ Gemini 모델';
+                        geminiModels.forEach(model => {
+                            const option = document.createElement('option');
+                            option.value = model.name;
+                            // "gemini:" 접두사 제거하여 표시
+                            const displayName = model.name.startsWith('gemini:') 
+                                ? model.name.substring(7) 
+                                : model.name;
+                            option.textContent = displayName;
+                            if (model.name === answerModel) {
+                                option.selected = true;
+                            }
+                            optgroup.appendChild(option);
+                        });
+                        availableModelsSelect.appendChild(optgroup);
+                    }
+                    
+                    availableModelsSelect.disabled = false;
+                } else {
+                    availableModelsSelect.innerHTML = '<option value="">등록된 AI 모델이 없습니다</option>';
+                }
+            } catch (error) {
+                availableModelsSelect.innerHTML = '<option value="">모델 목록 로드 실패</option>';
+                console.error('사용 가능한 모델 로드 오류:', error);
+            }
+        }
+        
+        // 모델 목록 로드 (학습된 웹소설이 있는 모델만)
         async function loadModels() {
             refreshModelsBtn.disabled = true;
             refreshModelsBtn.innerHTML = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M23 4v6h-6M1 20v-6h6M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/></svg> 로딩 중...';
@@ -1557,21 +1681,61 @@
                 modelSelect.innerHTML = '<option value="">모델을 선택하세요...</option>';
                 
                 if (data.models && data.models.length > 0) {
+                    // 모델을 타입별로 그룹화
+                    const ollamaModels = [];
+                    const geminiModels = [];
+                    
                     data.models.forEach(model => {
-                        const option = document.createElement('option');
-                        option.value = model.name;
-                        option.textContent = model.name;
-                        if (model.name === selectedModel) {
-                            option.selected = true;
+                        if (model.type === 'gemini') {
+                            geminiModels.push(model);
+                        } else {
+                            ollamaModels.push(model);
                         }
-                        modelSelect.appendChild(option);
                     });
+                    
+                    // 드롭다운에 추가
+                    // Ollama 모델 그룹
+                    if (ollamaModels.length > 0) {
+                        const optgroup = document.createElement('optgroup');
+                        optgroup.label = '🤖 Ollama 모델';
+                        ollamaModels.forEach(model => {
+                            const option = document.createElement('option');
+                            option.value = model.name;
+                            option.textContent = model.name;
+                            if (model.name === selectedModel) {
+                                option.selected = true;
+                            }
+                            optgroup.appendChild(option);
+                        });
+                        modelSelect.appendChild(optgroup);
+                    }
+                    
+                    // Gemini 모델 그룹
+                    if (geminiModels.length > 0) {
+                        const optgroup = document.createElement('optgroup');
+                        optgroup.label = '✨ Gemini 모델';
+                        geminiModels.forEach(model => {
+                            const option = document.createElement('option');
+                            option.value = model.name;
+                            // "gemini:" 접두사 제거하여 표시
+                            const displayName = model.name.startsWith('gemini:') 
+                                ? model.name.substring(7) 
+                                : model.name;
+                            option.textContent = displayName;
+                            if (model.name === selectedModel) {
+                                option.selected = true;
+                            }
+                            optgroup.appendChild(option);
+                        });
+                        modelSelect.appendChild(optgroup);
+                    }
+                    
                     updateModelStatus('connected');
                 } else {
                     updateModelStatus('error', '사용 가능한 모델이 없습니다');
                 }
             } catch (error) {
-                updateModelStatus('error', 'Ollama 연결 실패');
+                updateModelStatus('error', '모델 목록 로드 실패');
                 console.error('모델 로드 오류:', error);
             } finally {
                 refreshModelsBtn.disabled = false;
@@ -1584,12 +1748,18 @@
             modelStatus.className = 'model-status';
             if (status === 'connected') {
                 modelStatus.classList.add('connected');
-                modelStatus.innerHTML = '<span class="model-status-dot"></span><span>연결됨</span>';
+                // 선택된 모델 타입에 따라 메시지 변경
+                if (selectedModel) {
+                    const modelType = selectedModel.toLowerCase().startsWith('gemini') ? 'Gemini' : 'Ollama';
+                    modelStatus.innerHTML = `<span class="model-status-dot"></span><span>${modelType} 모델 선택됨</span>`;
+                } else {
+                    modelStatus.innerHTML = '<span class="model-status-dot"></span><span>모델 선택 가능</span>';
+                }
             } else if (status === 'error') {
                 modelStatus.classList.add('error');
                 modelStatus.innerHTML = `<span class="model-status-dot"></span><span>${message || '오류'}</span>`;
             } else {
-                modelStatus.innerHTML = '<span class="model-status-dot"></span><span>연결 안 됨</span>';
+                modelStatus.innerHTML = '<span class="model-status-dot"></span><span>모델을 선택하세요</span>';
             }
         }
         
@@ -1639,8 +1809,18 @@
             
             try {
                 const response = await fetch('/api/chat/sessions');
+                
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({ error: '서버 오류' }));
+                    throw new Error(errorData.error || `HTTP ${response.status}`);
+                }
+                
                 const data = await response.json();
                 
+                if (data.error) {
+                    throw new Error(data.error);
+                }
+                
                 chatHistory.innerHTML = '';
                 chatSessions = data.sessions || [];
                 
@@ -1666,7 +1846,7 @@
                         <svg class="chat-item-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                             <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/>
                         </svg>
-                        <div class="chat-item-title">${session.title || '새 대화'}</div>
+                        <div class="chat-item-title">${escapeHtml(session.title || '새 대화')}</div>
                         <div class="chat-item-time">${formatTime(session.updated_at)}</div>
                     `;
                     
@@ -1675,7 +1855,7 @@
                 });
             } catch (error) {
                 console.error('대화 히스토리 로드 오류:', error);
-                chatHistory.innerHTML = '<div style="padding: 16px; text-align: center; color: var(--text-secondary); font-size: 14px;">대화 기록을 불러올 수 없습니다</div>';
+                chatHistory.innerHTML = `<div style="padding: 16px; text-align: center; color: #ea4335; font-size: 14px;">대화 기록을 불러올 수 없습니다<br><small>${error.message || '알 수 없는 오류'}</small></div>`;
             }
         }
         
@@ -1699,19 +1879,54 @@
         async function loadChat(sessionId) {
             try {
                 const response = await fetch(`/api/chat/sessions/${sessionId}`);
+                
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({ error: '서버 오류' }));
+                    if (response.status === 404) {
+                        console.warn('대화 세션을 찾을 수 없습니다:', sessionId);
+                        // 세션이 삭제되었을 수 있으므로 히스토리만 새로고침
+                        await loadChatHistory();
+                        return;
+                    }
+                    throw new Error(errorData.error || `HTTP ${response.status}`);
+                }
+                
                 const data = await response.json();
                 
-                if (!data.session) return;
+                if (!data.session) {
+                    console.warn('세션 데이터가 없습니다:', sessionId);
+                    await loadChatHistory();
+                    return;
+                }
                 
                 currentSessionId = sessionId;
                 currentChatId = sessionId;
                 chatContainer.innerHTML = '';
                 
+                console.log('[대화 로드] 세션 ID:', sessionId);
+                console.log('[대화 로드] 메시지 개수:', data.session.messages ? data.session.messages.length : 0);
+                
                 if (data.session.messages && data.session.messages.length > 0) {
-                    data.session.messages.forEach(msg => {
-                        addMessage(msg.role, msg.content, false);
-                    });
+                    console.log('[대화 로드] 메시지 목록:', data.session.messages.map(m => ({ id: m.id, role: m.role, content_preview: m.content ? m.content.substring(0, 50) : '' })));
+                    
+                    // 메시지를 순차적으로 추가
+                    for (let index = 0; index < data.session.messages.length; index++) {
+                        const msg = data.session.messages[index];
+                        console.log(`[대화 로드] 메시지 ${index + 1}/${data.session.messages.length} 추가 중:`, msg.id, msg.role, msg.content ? msg.content.substring(0, 50) : '');
+                        if (msg.content && msg.content.trim() !== '') {
+                            addMessage(msg.role, msg.content, false);
+                        } else {
+                            console.warn(`[대화 로드] 메시지 ${msg.id}의 내용이 비어있습니다.`);
+                        }
+                    }
+                    
+                    // 모든 메시지 추가 후 스크롤을 맨 아래로
+                    setTimeout(() => {
+                        chatContainer.scrollTop = chatContainer.scrollHeight;
+                        console.log('[대화 로드] 모든 메시지 추가 완료, 스크롤 위치:', chatContainer.scrollTop);
+                    }, 100);
                 } else {
+                    console.log('[대화 로드] 메시지가 없습니다.');
                     if (emptyState) {
                         emptyState.style.display = 'flex';
                     }
@@ -1723,7 +1938,11 @@
                 }
             } catch (error) {
                 console.error('대화 로드 오류:', error);
-                alert('대화를 불러올 수 없습니다.');
+                // 더 자세한 에러 메시지 표시
+                const errorMessage = error.message || '알 수 없는 오류';
+                console.error('에러 상세:', errorMessage);
+                // alert 대신 콘솔에만 표시하고 히스토리 새로고침
+                await loadChatHistory();
             }
         }
         
@@ -1737,7 +1956,9 @@
                     },
                     body: JSON.stringify({
                         title: '새 대화',
-                        model_name: selectedModel || null
+                        model_name: selectedModel || null,  // 하위 호환성
+                        analysis_model: selectedModel || null,  // 질문 분석용 모델
+                        answer_model: answerModel || null  // 최종 답변용 모델
                     })
                 });
                 
@@ -1879,8 +2100,27 @@
         function formatContentWithFootnotes(content) {
             if (!content) return { formattedContent: '', footnotes: [] };
             
+            // "[내용을 찾을 수 없습니다]" 관련 텍스트 제거
+            let cleanedContent = content;
+            // 줄바꿈은 보존하면서 제거 (줄바꿈 앞뒤 공백도 ���께 제거)
+            cleanedContent = cleanedContent.replace(/\s*\[내용을 찾을 수 없습니다\]\s*/g, ' ');
+            cleanedContent = cleanedContent.replace(/\s*내용을 찾을 수 없습니다\s*/g, ' ');
+            cleanedContent = cleanedContent.replace(/\s*\[근거:\s*내용을 찾을 수 없습니다\]\s*/g, ' ');
+            cleanedContent = cleanedContent.replace(/\s*\[근거:\s*"내용을 찾을 수 없습니다"\]\s*/g, ' ');
+            cleanedContent = cleanedContent.replace(/\s*\[근거:\s*'내용을 찾을 수 없습니다'\]\s*/g, ' ');
+            // 연속된 공백만 정리 (줄바꿈은 보존)
+            cleanedContent = cleanedContent.replace(/[ \t]{2,}/g, ' '); // 탭과 공백만 정리
+            // 줄바꿈 앞뒤의 불필요한 공백 제거 (줄바꿈은 유지)
+            cleanedContent = cleanedContent.replace(/[ \t]+\n/g, '\n');
+            cleanedContent = cleanedContent.replace(/\n[ \t]+/g, '\n');
+            
             // 먼저 마크다운을 HTML로 변환
-            let htmlContent = markdownToHtml(content);
+            let htmlContent = markdownToHtml(cleanedContent);
+            
+            // HTML에서도 "[내용을 찾을 수 없습니다]" 제거
+            htmlContent = htmlContent.replace(/\[내용을 찾을 수 없습니다\]/g, '');
+            htmlContent = htmlContent.replace(/내용을 찾을 수 없습니다/g, '');
+            htmlContent = htmlContent.replace(/<[^>]*>내용을 찾을 수 없습니다<\/[^>]*>/g, '');
             
             // [근거: 내용] 패턴 찾기 (마크다운 변환 후에 처리)
             const footnotePattern = /\[근거:\s*([^\]]+)\]/g;
@@ -1889,8 +2129,12 @@
             
             // HTML에서 [근거: ] 패턴을 찾아서 각주로 변환
             htmlContent = htmlContent.replace(footnotePattern, (match, footnoteText) => {
-                footnoteIndex++;
                 const cleanText = footnoteText.trim();
+                // "내용을 찾을 수 없습니다"는 각주에 추가하지 않음
+                if (cleanText.includes('내용을 찾을 수 없습니다')) {
+                    return '';
+                }
+                footnoteIndex++;
                 footnotes.push(cleanText);
                 // 직접 HTML로 변환 (플레이스홀더 사용하지 않음)
                 return `<sup class="footnote-ref" data-footnote="${footnoteIndex}">[${footnoteIndex}]<span class="footnote-tooltip">${escapeHtml(cleanText)}</span></sup>`;
@@ -1908,6 +2152,18 @@
 
         // 메시지 추가
         function addMessage(role, content, save = true) {
+            // 내용이 없으면 추가하지 않음 (단, AI 응답인 경우 기본 메시지 표시)
+            if (!content || (typeof content === 'string' && content.trim() === '')) {
+                if (role === 'ai') {
+                    // AI 응답이 비어있으면 기본 메시지 표시
+                    content = '응답을 생성할 수 없었습니다. 다시 시도해주세요.';
+                    console.warn('[addMessage] AI 응답이 비어있어 기본 메시지를 표시합니다.');
+                } else {
+                    console.warn('[addMessage] 내용이 비어있어 메시지를 추가하지 않습니다. role:', role);
+                    return;
+                }
+            }
+            
             // 빈 상태 숨기기
             if (emptyState) {
                 emptyState.style.display = 'none';
@@ -1923,11 +2179,30 @@
             const contentDiv = document.createElement('div');
             contentDiv.className = 'message-content';
 
+            // AI 응답인 경우 AI 정보 표시
+            if (role === 'ai') {
+                const aiInfoDiv = document.createElement('div');
+                aiInfoDiv.className = 'ai-info';
+                aiInfoDiv.style.cssText = 'font-size: 12px; color: var(--text-secondary); margin-bottom: 8px; display: flex; align-items: center; gap: 6px;';
+                
+                const modelType = answerModel ? (answerModel.startsWith('gemini:') ? 'Gemini' : 'Ollama') : 'AI';
+                const modelName = answerModel ? (answerModel.startsWith('gemini:') ? answerModel.replace('gemini:', '') : answerModel) : '모델 미선택';
+                
+                aiInfoDiv.innerHTML = `
+                    <span style="font-weight: 500;">${modelType} 모델:</span>
+                    <span>${escapeHtml(modelName)}</span>
+                `;
+                contentDiv.appendChild(aiInfoDiv);
+            }
+
             const bubble = document.createElement('div');
             bubble.className = 'message-bubble';
             
             // AI 응답인 경우 [근거: ] 형식을 각주로 변환
             if (role === 'ai') {
+                // "[내용을 찾을 수 없습니다]" 텍스트 제거는 formatContentWithFootnotes에서 처리
+                // 여기서는 원본 내용을 그대로 전달
+                
                 const { formattedContent, footnotes } = formatContentWithFootnotes(content);
                 bubble.innerHTML = formattedContent;
                 
@@ -1965,33 +2240,109 @@
             chatContainer.scrollTop = chatContainer.scrollHeight;
         }
 
-        // 타이핑 인디케이터 표시
-        function showTypingIndicator() {
-            const messageDiv = document.createElement('div');
-            messageDiv.className = 'message ai';
-            messageDiv.id = 'typingIndicator';
-
-            const avatar = document.createElement('div');
-            avatar.className = 'message-avatar';
-            avatar.textContent = '🤖';
-
-            const contentDiv = document.createElement('div');
-            contentDiv.className = 'message-content';
-
-            const typingDiv = document.createElement('div');
-            typingDiv.className = 'typing-indicator';
-            for (let i = 0; i < 3; i++) {
-                const dot = document.createElement('div');
-                dot.className = 'typing-dot';
-                typingDiv.appendChild(dot);
+        // AI 모델 정보 가져오기
+        function getAIModelInfo() {
+            const analysisModelType = selectedModel ? (selectedModel.startsWith('gemini:') ? 'Gemini' : 'Ollama') : null;
+            const analysisModelName = selectedModel ? (selectedModel.startsWith('gemini:') ? selectedModel.replace('gemini:', '') : selectedModel) : null;
+            
+            const answerModelType = answerModel ? (answerModel.startsWith('gemini:') ? 'Gemini' : 'Ollama') : null;
+            const answerModelName = answerModel ? (answerModel.startsWith('gemini:') ? answerModel.replace('gemini:', '') : answerModel) : null;
+            
+            let aiInfo = '';
+            if (analysisModelName && answerModelName) {
+                if (analysisModelName === answerModelName) {
+                    // 같은 모델인 경우
+                    aiInfo = `<div style="font-size: 11px; color: var(--text-secondary); margin-bottom: 6px; display: flex; align-items: center; gap: 6px;">
+                        <span style="font-weight: 500;">${analysisModelType} 모델:</span>
+                        <span>${escapeHtml(analysisModelName)}</span>
+                    </div>`;
+                } else {
+                    // 다른 모델인 경우
+                    aiInfo = `<div style="font-size: 11px; color: var(--text-secondary); margin-bottom: 6px; display: flex; flex-direction: column; gap: 2px;">
+                        <div style="display: flex; align-items: center; gap: 6px;">
+                            <span style="font-weight: 500;">분석 모델:</span>
+                            <span>${escapeHtml(analysisModelName)} (${analysisModelType})</span>
+                        </div>
+                        <div style="display: flex; align-items: center; gap: 6px;">
+                            <span style="font-weight: 500;">답변 모델:</span>
+                            <span>${escapeHtml(answerModelName)} (${answerModelType})</span>
+                        </div>
+                    </div>`;
+                }
+            } else if (answerModelName) {
+                aiInfo = `<div style="font-size: 11px; color: var(--text-secondary); margin-bottom: 6px; display: flex; align-items: center; gap: 6px;">
+                    <span style="font-weight: 500;">${answerModelType} 모델:</span>
+                    <span>${escapeHtml(answerModelName)}</span>
+                </div>`;
             }
-
-            contentDiv.appendChild(typingDiv);
-            messageDiv.appendChild(avatar);
-            messageDiv.appendChild(contentDiv);
-            chatContainer.appendChild(messageDiv);
+            
+            return aiInfo;
+        }
+        
+        // 진행 상황 표시
+        function showTypingIndicator(step = '질문 분석 중...') {
+            let messageDiv = document.getElementById('typingIndicator');
+            
+            if (!messageDiv) {
+                messageDiv = document.createElement('div');
+                messageDiv.className = 'message ai';
+                messageDiv.id = 'typingIndicator';
+
+                const avatar = document.createElement('div');
+                avatar.className = 'message-avatar';
+                avatar.textContent = '🤖';
+
+                const contentDiv = document.createElement('div');
+                contentDiv.className = 'message-content';
+                contentDiv.id = 'typingIndicatorContent';
+
+                messageDiv.appendChild(avatar);
+                messageDiv.appendChild(contentDiv);
+                chatContainer.appendChild(messageDiv);
+                chatContainer.scrollTop = chatContainer.scrollHeight;
+            }
+            
+            const aiInfo = getAIModelInfo();
+            const contentDiv = document.getElementById('typingIndicatorContent');
+            contentDiv.innerHTML = `
+                ${aiInfo}
+                <div style="display: flex; flex-direction: column; gap: 8px;">
+                    <div style="display: flex; align-items: center; gap: 8px;">
+                        <div class="typing-indicator" style="display: flex; gap: 4px;">
+                            <div class="typing-dot"></div>
+                            <div class="typing-dot"></div>
+                            <div class="typing-dot"></div>
+                        </div>
+                        <span style="color: var(--text-secondary); font-size: 13px;">${step}</span>
+                    </div>
+                </div>
+            `;
             chatContainer.scrollTop = chatContainer.scrollHeight;
         }
+        
+        // 진행 상황 업데이트
+        function updateTypingIndicator(step, details = '') {
+            const contentDiv = document.getElementById('typingIndicatorContent');
+            if (contentDiv) {
+                const aiInfo = getAIModelInfo();
+                const detailsHtml = details ? `<div style="font-size: 12px; color: var(--text-secondary); margin-left: 24px; margin-top: 4px;">${details}</div>` : '';
+                contentDiv.innerHTML = `
+                    ${aiInfo}
+                    <div style="display: flex; flex-direction: column; gap: 8px;">
+                        <div style="display: flex; align-items: center; gap: 8px;">
+                            <div class="typing-indicator" style="display: flex; gap: 4px;">
+                                <div class="typing-dot"></div>
+                                <div class="typing-dot"></div>
+                                <div class="typing-dot"></div>
+                            </div>
+                            <span style="color: var(--text-secondary); font-size: 13px;">${step}</span>
+                        </div>
+                        ${detailsHtml}
+                    </div>
+                `;
+                chatContainer.scrollTop = chatContainer.scrollHeight;
+            }
+        }
 
         // 타이핑 인디케이터 제거
         function removeTypingIndicator() {
@@ -2006,6 +2357,12 @@
             const message = messageInput.value.trim();
             if (!message) return;
 
+            // 답변용 모델이 선택되지 않았으면 경고
+            if (!answerModel) {
+                alert('답변을 생성할 AI 모델을 선택해주세요.\n\n"사용 가능한 AI 목록"에서 답변을 생성할 AI 모델을 선택하세요.');
+                return;
+            }
+
             // 세션이 없으면 새로 생성
             if (!currentSessionId) {
                 currentSessionId = await createNewSession();
@@ -2021,11 +2378,42 @@
             messageInput.disabled = true;
             sendButton.disabled = true;
 
-            // 타이핑 인디케이터 표시
-            showTypingIndicator();
+            // 진행 상황 표시 시작
+            showTypingIndicator('질문 분석 중...');
+            
+            // 진행 상황 단계별 표시
+            const progressSteps = [
+                { step: '질문 분석 중...', details: '질문 내용을 분석하고 있습니다' },
+                { step: '관련 정보 검색 중...', details: '웹소설 데이터베이스에서 관련 정보를 찾고 있습니다' },
+                { step: '회차별 분석 조회 중...', details: '회차별 요약 정보를 불러오고 있습니다' },
+                { step: 'GraphRAG 데이터 조회 중...', details: '캐릭터 관계 및 사건 정보를 조회하고 있습니다' },
+                { step: '벡터 검색 및 리랭킹 중...', details: '관련된 구체적인 내용을 검색하고 있습니다' },
+                { step: '컨텍스트 구성 중...', details: '참고할 정보를 정리하고 있습니다' },
+                { step: 'AI 답변 생성 중...', details: '답변을 생성하고 있습니다' }
+            ];
+            
+            let currentStepIndex = 0;
+            const startTime = Date.now();
+            
+            // 진행 상황 자동 업데이트 (백엔드 응답 대기 중)
+            const progressInterval = setInterval(() => {
+                if (currentStepIndex < progressSteps.length) {
+                    const currentStep = progressSteps[currentStepIndex];
+                    updateTypingIndicator(currentStep.step, currentStep.details);
+                    currentStepIndex++;
+                }
+            }, 1500); // 1.5초마다 다음 단계로
 
             try {
                 // API 호출
+                console.log('[sendMessage] 요청 전송:', {
+                    message: message.substring(0, 50) + '...',
+                    analysis_model: selectedModel,
+                    answer_model: answerModel,
+                    file_ids: selectedFileIds,
+                    session_id: currentSessionId
+                });
+                
                 const response = await fetch('/api/chat', {
                     method: 'POST',
                     headers: {
@@ -2033,18 +2421,38 @@
                     },
                     body: JSON.stringify({
                         message: message,
-                        model: selectedModel || null,
+                        analysis_model: selectedModel || null, // 질문 분석용 모델
+                        answer_model: answerModel || null, // 최종 답변용 모델
                         file_ids: selectedFileIds.length > 0 ? selectedFileIds : [],
                         session_id: currentSessionId
                     })
                 });
+                
+                console.log('[sendMessage] 응답 상태:', response.status, response.statusText);
 
-                removeTypingIndicator();
+                clearInterval(progressInterval);
+                const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(1);
+                updateTypingIndicator('답변 수신 완료', `총 ${elapsedTime}초 소요`);
+
+                // 잠시 후 인디케이터 제거
+                setTimeout(() => {
+                    removeTypingIndicator();
+                }, 300);
 
                 if (response.ok) {
                     const data = await response.json();
-                    const aiResponse = data.response || '응답을 생성하는 중 오류가 발생했습니다.';
-                    addMessage('ai', aiResponse, false);
+                    console.log('[sendMessage] 응답 데이터:', data);
+                    
+                    const aiResponse = data.response || data.message || '응답을 생성하는 중 오류가 발생했습니다.';
+                    console.log('[sendMessage] AI 응답:', aiResponse ? aiResponse.substring(0, 100) + '...' : '(비어있음)');
+                    
+                    // 응답이 비어있거나 공백만 있어도 메시지 표시
+                    if (!aiResponse || aiResponse.trim() === '') {
+                        console.warn('[sendMessage] 응답이 비어있습니다. 기본 메시지를 표시합니다.');
+                        addMessage('ai', '응답을 생성할 수 없었습니다. 다시 시도해주세요.', false);
+                    } else {
+                        addMessage('ai', aiResponse, false);
+                    }
                     
                     // DB에 AI 응답 저장 (이미 백엔드에서 저장됨)
                     // 세션 목록 새로고침 (제목 업데이트 반영)
@@ -2057,6 +2465,7 @@
                     }
                 } else {
                     const error = await response.json().catch(() => ({ error: '서버 오류' }));
+                    console.error('[sendMessage] 서버 오류:', error);
                     addMessage('ai', `오류: ${error.error || '알 수 없는 오류가 발생했습니다.'}`, false);
                 }
             } catch (error) {
@@ -2391,9 +2800,14 @@
         // 페이지 로드 시 초기화
         window.addEventListener('load', async () => {
             await loadChatHistory();
-            await loadModels();
+            await loadAvailableModels(); // 사용 가능한 AI 목록 로드 (모든 모델)
+            await loadModels(); // AI 모델 선택 로드 (학습된 웹소설이 있는 모델만)
             // 모델 선택 여부와 관계없이 웹소설 목록 로드 (모델이 선택되어 있으면 해당 모델의 파일만, 없으면 모든 파일)
             loadNovels();
+            // 초기 모델 상태 업데이트
+            if (selectedModel) {
+                updateModelStatus('connected');
+            }
             messageInput.focus();
         });
     </script>