feat: Add webnovel continue upload feature and improve RAG

- Add parent_file_id field to UploadedFile model for series management
- Implement continue upload functionality for webnovels
- Auto-delete related episodes when parent file is deleted
- Display hierarchical file structure in admin page
- Include child files automatically in RAG search
- Auto-migrate database schema (add parent_file_id column)
- Set Chunk Overlap to 250
- Improve admin page UI with continue upload button
- Enhance chat session title auto-update
- Prevent duplicate message saving

GIT_SETUP.md

@@ -0,0 +1,69 @@
+# Git 원격 저장소 설정 가이드
+
+## 현재 상태
+- ✅ 로컬 Git 저장소 초기화 완료
+- ✅ 모든 파일 커밋 완료
+- ✅ master 브랜치 준비 완료
+
+## 원격 저장소 설정 방법
+
+### 1. GitHub에 새 저장소 만들기
+
+1. GitHub에 로그인: https://github.com
+2. 우측 상단의 **+** 버튼 클릭 → **New repository** 선택
+3. 저장소 정보 입력:
+   - Repository name: `soy-nv-ai` (또는 원하는 이름)
+   - Description: `SOY NV AI - Web novel training system with RAG functionality`
+   - Public 또는 Private 선택
+   - **⚠️ 중요: "Initialize this repository with a README" 체크하지 마세요!**
+4. **Create repository** 클릭
+
+### 2. 원격 저장소 연결 및 푸시
+
+#### 방법 1: PowerShell 스크립트 사용 (권장)
+```powershell
+.\setup_remote.ps1
+```
+스크립트가 원격 저장소 URL을 입력받고 자동으로 설정합니다.
+
+#### 방법 2: 수동으로 설정
+```powershell
+# 원격 저장소 추가 (GitHub 저장소 URL로 변경)
+git remote add origin https://github.com/사용자명/저장소명.git
+
+# 원격 저장소 확인
+git remote -v
+
+# 마스터 브랜치 푸시
+git push -u origin master
+```
+
+### 3. GitHub CLI 사용 (선택사항)
+
+GitHub CLI가 설치되어 있다면:
+```powershell
+# 새 저장소 생성 및 푸시
+gh repo create soy-nv-ai --public --source=. --remote=origin --push
+```
+
+## 주의사항
+
+- `.gitignore` 파일에 다음이 포함되어 있습니다:
+  - `venv/` - 가상환경
+  - `instance/` - 데이터베이스 파일
+  - `uploads/*` - 업로드된 파일
+  - `__pycache__/` - Python 캐시
+
+- 민감한 정보는 커밋하지 마세요:
+  - 비밀번호
+  - API 키
+  - 데이터베이스 파일
+
+## 다음 단계
+
+원격 저장소 설정 후:
+1. GitHub에서 저장소 확인
+2. 필요시 `.env` 파일을 추가하여 환경 변수 관리
+3. README.md 업데이트 (프로젝트 설명 추가)
+
+

README_SERVER.md

@@ -66,3 +66,4 @@ Start-Process powershell -ArgumentList "-File", "start_server_background.ps1" -W
 1. PowerShell 창에서 `Ctrl+C` 누르기
 2. 또는 작업 관리자에서 Python 프로세스 종료
 
+

app/__init__.py

@@ -21,6 +21,7 @@ def create_app():
     app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
     app.config['SQLALCHEMY_DATABASE_URI'] = os.getenv('DATABASE_URL', 'sqlite:///finance_analysis.db')
     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+    app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100MB 파일 크기 제한
     
     db.init_app(app)
     login_manager.init_app(app)
@@ -38,7 +39,7 @@ def create_app():
     return app
 
 def migrate_database(app):
-    """데이터베이스 마이그레이션 - nickname 컬럼 추가"""
+    """데이터베이스 마이그레이션"""
     try:
         # 데이터베이스 URI에서 경로 추출
         db_uri = app.config['SQLALCHEMY_DATABASE_URI']
@@ -49,6 +50,7 @@ def migrate_database(app):
                 db_path = os.path.join(app.instance_path, db_path)
             
             if not os.path.exists(db_path):
+                print(f"[마이그레이션] 데이터베이스 파일이 없습니다: {db_path}")
                 return
             
             conn = sqlite3.connect(db_path)
@@ -56,15 +58,40 @@ def migrate_database(app):
             
             # user 테이블에 nickname 컬럼이 있는지 확인
             cursor.execute("PRAGMA table_info(user)")
-            columns = [column[1] for column in cursor.fetchall()]
+            user_columns = [column[1] for column in cursor.fetchall()]
             
-            if 'nickname' not in columns:
+            if 'nickname' not in user_columns:
+                print("[마이그레이션] user 테이블에 nickname 컬럼 추가 중...")
                 cursor.execute("ALTER TABLE user ADD COLUMN nickname VARCHAR(80)")
                 conn.commit()
+                print("[마이그레이션] user.nickname 컬럼 추가 완료")
+            
+            # uploaded_file 테이블이 존재하는지 확인
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='uploaded_file'")
+            if cursor.fetchone():
+                # uploaded_file 테이블에 uploaded_by 컬럼이 있는지 확인
+                cursor.execute("PRAGMA table_info(uploaded_file)")
+                uploaded_file_columns = [column[1] for column in cursor.fetchall()]
+                
+                if 'uploaded_by' not in uploaded_file_columns:
+                    print("[마이그레이션] uploaded_file 테이블에 uploaded_by 컬럼 추가 중...")
+                    cursor.execute("ALTER TABLE uploaded_file ADD COLUMN uploaded_by INTEGER")
+                    conn.commit()
+                    print("[마이그레이션] uploaded_file.uploaded_by 컬럼 추가 완료")
+                
+                # uploaded_file 테이블에 parent_file_id 컬럼이 있는지 확인
+                if 'parent_file_id' not in uploaded_file_columns:
+                    print("[마이그레이션] uploaded_file 테이블에 parent_file_id 컬럼 추가 중...")
+                    cursor.execute("ALTER TABLE uploaded_file ADD COLUMN parent_file_id INTEGER")
+                    conn.commit()
+                    print("[마이그레이션] uploaded_file.parent_file_id 컬럼 추가 완료")
             
             conn.close()
+            print("[마이그레이션] 데이터베이스 마이그레이션 완료")
     except Exception as e:
-        print(f"마이그레이션 오류 (무시 가능): {e}")
+        print(f"[마이그레이션] 오류 발생: {e}")
+        import traceback
+        traceback.print_exc()
 
 def create_admin_user():
     """초기 관리자 계정 생성"""

app/database.py

@@ -43,6 +43,10 @@ class UploadedFile(db.Model):
     model_name = db.Column(db.String(100), nullable=True)  # 연결된 모델 이름
     uploaded_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     uploaded_by = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
+    parent_file_id = db.Column(db.Integer, db.ForeignKey('uploaded_file.id'), nullable=True)  # 이어서 업로드한 경우 원본 파일 ID
+    
+    # 관계
+    parent_file = db.relationship('UploadedFile', remote_side=[id], backref='child_files')
     
     def to_dict(self):
         return {
@@ -52,7 +56,9 @@ class UploadedFile(db.Model):
             'file_size': self.file_size,
             'model_name': self.model_name,
             'uploaded_at': self.uploaded_at.isoformat() if self.uploaded_at else None,
-            'uploaded_by': self.uploaded_by
+            'uploaded_by': self.uploaded_by,
+            'parent_file_id': self.parent_file_id,
+            'child_count': len(self.child_files) if self.child_files else 0
         }
 
 # 대화 세션 모델

app/routes.py

@@ -30,16 +30,42 @@ OLLAMA_BASE_URL = os.getenv('OLLAMA_BASE_URL', 'http://localhost:11434')
 UPLOAD_FOLDER = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'uploads')
 ALLOWED_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'epub'}
 
+# 업로드 폴더 경로 출력 (디버깅용)
+print(f"[업로드 설정] 업로드 폴더 경로: {UPLOAD_FOLDER}")
+print(f"[업로드 설정] 업로드 폴더 존재 여부: {os.path.exists(UPLOAD_FOLDER)}")
+
 def allowed_file(filename):
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
 def ensure_upload_folder():
     """업로드 폴더가 없으면 생성"""
-    if not os.path.exists(UPLOAD_FOLDER):
-        os.makedirs(UPLOAD_FOLDER)
+    try:
+        if not os.path.exists(UPLOAD_FOLDER):
+            print(f"업로드 폴더 생성 중: {UPLOAD_FOLDER}")
+            os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+        
+        if not os.path.exists(UPLOAD_FOLDER):
+            raise Exception(f'업로드 폴더를 생성할 수 없습니다: {UPLOAD_FOLDER}')
+        
+        # 폴더 쓰기 권한 확인
+        test_file = os.path.join(UPLOAD_FOLDER, '.write_test')
+        try:
+            with open(test_file, 'w') as f:
+                f.write('test')
+            os.remove(test_file)
+            print(f"업로드 폴더 쓰기 권한 확인 완료: {UPLOAD_FOLDER}")
+        except PermissionError as e:
+            raise Exception(f'업로드 폴더에 쓰기 권한이 없습니다: {UPLOAD_FOLDER} - {str(e)}')
+        except Exception as e:
+            raise Exception(f'업로드 폴더 쓰기 테스트 실패: {UPLOAD_FOLDER} - {str(e)}')
+    except Exception as e:
+        print(f"업로드 폴더 생성 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        raise
 
-def split_text_into_chunks(text, chunk_size=500, overlap=50):
-    """텍스트를 청크로 분할"""
+def split_text_into_chunks(text, chunk_size=1000, overlap=150):
+    """텍스트를 청크로 분할 (더 큰 청크와 오버랩으로 문맥 유지)"""
     chunks = []
     start = 0
     while start < len(text):
@@ -55,8 +81,8 @@ def create_chunks_for_file(file_id, content):
         # 기존 청크 삭제
         DocumentChunk.query.filter_by(file_id=file_id).delete()
         
-        # 텍스트를 청크로 분할
-        chunks = split_text_into_chunks(content, chunk_size=500, overlap=50)
+        # 텍스트를 청크로 분할 (더 큰 청크로 더 많은 컨텍스트 제공)
+        chunks = split_text_into_chunks(content, chunk_size=1000, overlap=150)
         
         # 각 청크를 데이터베이스에 저장
         for idx, chunk_content in enumerate(chunks):
@@ -74,17 +100,33 @@ def create_chunks_for_file(file_id, content):
         print(f"청크 생성 오류: {str(e)}")
         return 0
 
-def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=5):
-    """질문과 관련된 청크 검색 (키워드 기반)"""
+def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=25, min_score=1):
+    """질문과 관련된 청크 검색 (개선된 키워드 기반 검색)"""
     try:
-        # 검색 쿼리 준비
-        query_words = set(re.findall(r'\w+', query.lower()))
+        # 검색 쿼리 준비 - 한글과 영문 단어 모두 추출
+        query_words = set(re.findall(r'[가-힣]+|\w+', query.lower()))
+        
+        if not query_words:
+            return []
         
         # 청크 조회
         query_obj = DocumentChunk.query.join(UploadedFile)
         
         if file_ids:
-            query_obj = query_obj.filter(UploadedFile.id.in_(file_ids))
+            # 선택된 파일 ID와 그 파일에 이어서 업로드된 모든 파일 ID 포함
+            expanded_file_ids = list(file_ids)
+            for file_id in file_ids:
+                # 원본 파일인 경우 이어서 업로드된 파일들도 포함
+                child_files = UploadedFile.query.filter_by(parent_file_id=file_id).all()
+                expanded_file_ids.extend([child.id for child in child_files])
+            
+            # 원본 파일이 선택된 경우, 이어서 업로드된 파일들도 포함
+            parent_files = UploadedFile.query.filter(UploadedFile.id.in_(file_ids), UploadedFile.parent_file_id.is_(None)).all()
+            for parent_file in parent_files:
+                child_files = UploadedFile.query.filter_by(parent_file_id=parent_file.id).all()
+                expanded_file_ids.extend([child.id for child in child_files])
+            
+            query_obj = query_obj.filter(UploadedFile.id.in_(expanded_file_ids))
         
         if model_name:
             query_obj = query_obj.filter(UploadedFile.model_name == model_name)
@@ -94,22 +136,54 @@ def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=5):
         if not all_chunks:
             return []
         
-        # 각 청크의 관련도 점수 계산 (키워드 매칭)
+        # 각 청크의 관련도 점수 계산 (개선된 알고리즘)
         scored_chunks = []
         for chunk in all_chunks:
-            chunk_words = set(re.findall(r'\w+', chunk.content.lower()))
-            # 공통 단어 수로 점수 계산
-            score = len(query_words & chunk_words)
-            if score > 0:
-                scored_chunks.append((score, chunk))
+            chunk_content_lower = chunk.content.lower()
+            chunk_words = set(re.findall(r'[가-힣]+|\w+', chunk_content_lower))
+            
+            # 1. 공통 단어 수 (기본 점수)
+            common_words = query_words & chunk_words
+            base_score = len(common_words)
+            
+            # 2. 쿼리 단어의 빈도 가중치 (중요한 단어가 더 많이 나타날수록 높은 점수)
+            frequency_score = 0
+            for word in query_words:
+                frequency_score += chunk_content_lower.count(word)
+            
+            # 3. 쿼리 단어 비율 (청크에서 쿼리 단어가 차지하는 비율)
+            if len(chunk_words) > 0:
+                ratio_score = len(common_words) / len(chunk_words) * 10
+            else:
+                ratio_score = 0
+            
+            # 최종 점수 계산 (가중치 적용)
+            final_score = base_score * 2 + frequency_score * 0.5 + ratio_score
+            
+            # 최소 점수 이상인 청크만 포함
+            if final_score >= min_score:
+                scored_chunks.append((final_score, chunk))
         
         # 점수 순으로 정렬하고 상위 k개 선택
         scored_chunks.sort(key=lambda x: x[0], reverse=True)
-        top_chunks = [chunk for _, chunk in scored_chunks[:top_k]]
+        
+        # top_k개 선택하되, 점수가 비슷한 청크도 포함 (점수 차이가 30% 이내면 포함)
+        top_chunks = []
+        if scored_chunks:
+            max_score = scored_chunks[0][0]
+            threshold = max_score * 0.7  # 최고 점수의 70% 이상인 청크도 포함
+            
+            for score, chunk in scored_chunks:
+                if len(top_chunks) < top_k or score >= threshold:
+                    top_chunks.append(chunk)
+                else:
+                    break
         
         return top_chunks
     except Exception as e:
         print(f"청크 검색 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
         return []
 
 @main_bp.route('/login', methods=['GET', 'POST'])
@@ -382,13 +456,20 @@ def chat():
                 
                 if use_rag:
                     # 관련 청크 검색
+                    print(f"\n[RAG 검색] 모델: {model}, 질문: {message[:50]}...")
+                    print(f"[RAG 검색] 선택된 파일 ID: {file_ids if file_ids else '없음 (모든 파일 검색)'}")
+                    
+                    # 더 많은 청크를 검색하도록 top_k 증가 (기본 25개)
                     relevant_chunks = search_relevant_chunks(
                         query=message,
                         file_ids=file_ids if file_ids else None,
                         model_name=model,
-                        top_k=5
+                        top_k=25,  # 5개에서 25개로 증가
+                        min_score=0.5  # 최소 점수 임계값 낮춤 (더 많은 청크 포함)
                     )
                     
+                    print(f"[RAG 검색] 검색된 청크 수: {len(relevant_chunks)}")
+                    
                     if relevant_chunks:
                         context_parts = []
                         seen_files = set()
@@ -397,29 +478,61 @@ def chat():
                             file = chunk.file
                             if file.original_filename not in seen_files:
                                 seen_files.add(file.original_filename)
+                                print(f"[RAG 검색] 사용된 파일: {file.original_filename} (모델: {file.model_name})")
                             
                             context_parts.append(f"[{file.original_filename} - 청크 {chunk.chunk_index + 1}]\n{chunk.content}")
                         
                         if context_parts:
-                            context = "\n\n".join(context_parts)
-                            context = f"다음은 질문과 관련된 웹소설 내용입니다 (RAG 검색 결과):\n\n{context}\n\n위 내용을 참고하여 다음 질문에 정확하게 답변해주세요:\n\n"
+                            # 컨텍스트 길이 확인 및 최적화
+                            full_context = "\n\n".join(context_parts)
+                            context_length = len(full_context)
+                            
+                            # 컨텍스트가 너무 길면 일부만 사용 (최대 15000자)
+                            if context_length > 15000:
+                                # 상위 점수 청크 우선 유지하면서 길이 조절
+                                truncated_parts = []
+                                current_length = 0
+                                for part in context_parts:
+                                    if current_length + len(part) > 15000:
+                                        break
+                                    truncated_parts.append(part)
+                                    current_length += len(part)
+                                full_context = "\n\n".join(truncated_parts)
+                                print(f"[RAG 검색] 컨텍스트 길이 조절: {context_length}자 → {len(full_context)}자")
+                            
+                            context = f"다음은 질문과 관련된 웹소설 내용입니다 (RAG 검색 결과, 총 {len(relevant_chunks)}개 청크):\n\n{full_context}\n\n위 내용을 충분히 참고하여 다음 질문에 정확하고 상세하게 답변해주세요. 웹소설의 맥락과 스토리를 고려하여 답변해주세요:\n\n"
+                            print(f"[RAG 검색] 컨텍스트 생성 완료 ({len(seen_files)}개 파일, {len(relevant_chunks)}개 청크, {len(full_context)}자)")
                     else:
                         # RAG 검색 결과가 없으면 기존 방식 사용
+                        print(f"[RAG 검색] 관련 청크를 찾지 못했습니다. 전체 파일 내용 사용")
                         use_rag = False
                 
                 # RAG 검색 결과가 없거나 비활성화된 경우 기존 방식 사용
                 if not context and not use_rag:
                     if file_ids:
-                        # 선택한 파일 ID들로 파일 조회
+                        # 선택한 파일 ID와 이어서 업로드된 파일들도 포함
+                        expanded_file_ids = list(file_ids)
+                        for file_id in file_ids:
+                            # 원본 파일인 경우 이어서 업로드된 파일들도 포함
+                            child_files = UploadedFile.query.filter_by(parent_file_id=file_id).all()
+                            expanded_file_ids.extend([child.id for child in child_files])
+                        
                         uploaded_files = UploadedFile.query.filter(
-                            UploadedFile.id.in_(file_ids),
+                            UploadedFile.id.in_(expanded_file_ids),
                             UploadedFile.model_name == model
                         ).all()
+                        print(f"[파일 사용] 선택된 파일 ID로 조회 (이어서 업로드 포함): {len(uploaded_files)}개 파일")
                     else:
-                        # 파일 ID가 없으면 해당 모델의 모든 파일 사용 (기존 동작)
+                        # 파일 ID가 없으면 해당 모델의 모든 파일 사용 (원본 및 이어서 업로드 포함)
                         uploaded_files = UploadedFile.query.filter_by(model_name=model).all()
+                        print(f"[파일 사용] 모델 '{model}'의 모든 파일 사용: {len(uploaded_files)}개 파일")
                     
                     if uploaded_files:
+                        print(f"[파일 사용] 사용되는 파일 목록:")
+                        for f in uploaded_files:
+                            is_child = f.parent_file_id is not None
+                            prefix = "  └─ " if is_child else "  - "
+                            print(f"{prefix}{f.original_filename} (모델: {f.model_name})")
                         context_parts = []
                         for file in uploaded_files:
                             try:
@@ -432,9 +545,9 @@ def chat():
                                         with open(file.file_path, 'r', encoding='cp949') as f:
                                             file_content = f.read()
                                     
-                                    # 파일 내용이 너무 길면 일부만 사용 (최대 10000자로 증가)
-                                    if len(file_content) > 10000:
-                                        file_content = file_content[:10000] + "..."
+                                    # 파일 내용이 너무 길면 일부만 사용 (최대 20000자로 증가)
+                                    if len(file_content) > 20000:
+                                        file_content = file_content[:20000] + "..."
                                     
                                     context_parts.append(f"[{file.original_filename}]\n{file_content}")
                             except Exception as e:
@@ -473,13 +586,48 @@ def chat():
                             ).first()
                             
                             if session:
-                                # 사용자 메시지 저장
-                                user_msg = ChatMessage(
+                                # 사용자 메시지가 이미 저장되어 있는지 확인 (중복 방지)
+                                # 가장 최근 메시지를 확인하여 중복 저장 방지
+                                latest_user_msg = ChatMessage.query.filter_by(
                                     session_id=session_id,
-                                    role='user',
-                                    content=message
-                                )
-                                db.session.add(user_msg)
+                                    role='user'
+                                ).order_by(ChatMessage.created_at.desc()).first()
+                                
+                                # 최근 10초 이내에 같은 내용의 메시지가 없으면 저장
+                                should_save = True
+                                if latest_user_msg:
+                                    time_diff = (datetime.utcnow() - latest_user_msg.created_at).total_seconds()
+                                    if latest_user_msg.content == message and time_diff < 10:
+                                        should_save = False
+                                        print(f"[중복 방지] 최근 {time_diff:.2f}초 전에 같은 메시지가 저장되어 있습니다. 저장을 건너뜁니다.")
+                                
+                                if should_save:
+                                    user_msg = ChatMessage(
+                                        session_id=session_id,
+                                        role='user',
+                                        content=message
+                                    )
+                                    db.session.add(user_msg)
+                                    print(f"[메시지 저장] 사용자 메시지 저장: {message[:50]}...")
+                                    
+                                    # 세션 제목 업데이트 (첫 사용자 메시지인 경우)
+                                    title_needs_update = (
+                                        not session.title or 
+                                        session.title.strip() == '' or 
+                                        session.title == '새 대화'
+                                    )
+                                    
+                                    if title_needs_update and message.strip():
+                                        # 메시지 내용을 제목으로 사용 (최대 30자)
+                                        title = message.strip()[:30]
+                                        if len(message.strip()) > 30:
+                                            title += '...'
+                                        session.title = title
+                                        print(f"[세션 제목] 업데이트: '{title}' (원본 길이: {len(message.strip())}자)")
+                                    elif title_needs_update:
+                                        print(f"[세션 제목] 메시지가 비어있어 제목을 업데이트하지 않습니다.")
+                                else:
+                                    print(f"[메시지 저장] 중복 메시지로 인해 저장을 건너뜁니다.")
                                 
                                 # AI 응답 저장
                                 ai_msg = ChatMessage(
@@ -491,11 +639,19 @@ def chat():
                                 
                                 session.updated_at = datetime.utcnow()
                                 db.session.commit()
+                                
+                                # 세션 정보를 응답에 포함 (제목 업데이트 반영)
+                                session_dict = session.to_dict()
                         except Exception as e:
                             print(f"메시지 저장 오류: {str(e)}")
                             db.session.rollback()
+                            session_dict = None
                     
-                    return jsonify({'response': response_text, 'session_id': session_id})
+                    response_data = {'response': response_text, 'session_id': session_id}
+                    if session_dict:
+                        response_data['session'] = session_dict
+                    
+                    return jsonify(response_data)
                 else:
                     error_msg = f'Ollama 서버 오류: {ollama_response.status_code}'
                     return jsonify({'error': error_msg}), ollama_response.status_code
@@ -518,70 +674,260 @@ def chat():
 @login_required
 def upload_file():
     """웹소설 파일 업로드"""
+    import sys
+    import traceback
+    
+    # 모든 출력을 즉시 플러시하여 로그가 바로 보이도록
+    def log_print(*args, **kwargs):
+        print(*args, **kwargs)
+        sys.stdout.flush()
+    
     try:
-        ensure_upload_folder()
+        log_print(f"\n{'='*60}")
+        log_print(f"=== 파일 업로드 요청 시작 ===")
+        log_print(f"요청 메서드: {request.method}")
+        log_print(f"Content-Type: {request.content_type}")
+        log_print(f"Content-Length: {request.content_length}")
+        log_print(f"Form 데이터 키: {list(request.form.keys())}")
+        log_print(f"Files 키: {list(request.files.keys())}")
+        log_print(f"사용자: {current_user.username if current_user else 'None'}")
+        log_print(f"{'='*60}\n")
+        
+        # 업로드 폴더 확인 및 생성
+        try:
+            ensure_upload_folder()
+            log_print(f"[1/8] 업로드 폴더 확인 완료: {UPLOAD_FOLDER}")
+        except Exception as e:
+            error_msg = f'업로드 폴더를 준비할 수 없습니다: {str(e)}'
+            log_print(f"[ERROR] {error_msg}")
+            traceback.print_exc()
+            return jsonify({'error': error_msg, 'step': 'folder_check'}), 500
         
         if 'file' not in request.files:
-            return jsonify({'error': '파일이 없습니다.'}), 400
+            error_msg = '파일이 없습니다.'
+            log_print(f"[ERROR] {error_msg}")
+            log_print(f"사용 가능한 키: {list(request.files.keys())}")
+            return jsonify({'error': error_msg, 'step': 'file_check'}), 400
         
         file = request.files['file']
-        model_name = request.form.get('model_name', '')
+        model_name = request.form.get('model_name', '').strip()
+        parent_file_id = request.form.get('parent_file_id', None)  # 이어서 업로드할 경우 원본 파일 ID
+        
+        log_print(f"[2/8] 파일 수신: {file.filename if file else 'None'}")
+        log_print(f"[2/8] 모델명: {model_name if model_name else 'None (비어있음)'}")
+        log_print(f"[2/8] 이어서 업로드: {parent_file_id if parent_file_id else '아니오'}")
         
         if file.filename == '':
-            return jsonify({'error': '파일명이 없습니다.'}), 400
+            error_msg = '파일명이 없습니다.'
+            log_print(f"[ERROR] {error_msg}")
+            return jsonify({'error': error_msg, 'step': 'filename_check'}), 400
+        
+        # 모델명 검증
+        if not model_name:
+            error_msg = 'AI 모델을 선택해주세요.'
+            log_print(f"[ERROR] {error_msg}")
+            return jsonify({'error': error_msg, 'step': 'model_check'}), 400
+        
+        # parent_file_id 검증 (이어서 업로드인 경우)
+        parent_file = None
+        if parent_file_id:
+            try:
+                parent_file_id = int(parent_file_id)
+                parent_file = UploadedFile.query.filter_by(
+                    id=parent_file_id,
+                    uploaded_by=current_user.id
+                ).first()
+                
+                if not parent_file:
+                    error_msg = '원본 파일을 찾을 수 없습니다.'
+                    log_print(f"[ERROR] {error_msg}")
+                    return jsonify({'error': error_msg, 'step': 'parent_file_check'}), 404
+                
+                # 같은 모델인지 확인
+                if parent_file.model_name != model_name:
+                    error_msg = '같은 모델의 파일에만 이어서 업로드할 수 있습니다.'
+                    log_print(f"[ERROR] {error_msg}")
+                    return jsonify({'error': error_msg, 'step': 'model_mismatch'}), 400
+                
+                log_print(f"[이어서 업로드] 원본 파일: {parent_file.original_filename} (ID: {parent_file_id})")
+            except (ValueError, TypeError):
+                parent_file_id = None
+                log_print(f"[경고] 잘못된 parent_file_id: {parent_file_id}")
+        
+        log_print(f"[3/8] 업로드 시도: {file.filename}, 모델: {model_name}")
         
         if not allowed_file(file.filename):
-            return jsonify({'error': f'허용되지 않은 파일 형식입니다. 허용 형식: {", ".join(ALLOWED_EXTENSIONS)}'}), 400
+            error_msg = f'허용되지 않은 파일 형식입니다. 허용 형식: {", ".join(ALLOWED_EXTENSIONS)}'
+            log_print(f"[ERROR] {error_msg}")
+            return jsonify({'error': error_msg, 'step': 'file_type_check'}), 400
+        
+        log_print(f"[4/8] 파일 형식 확인 완료: {file.filename}")
+        
+        # 파일 크기 확인 (Content-Length 헤더 사용)
+        file_size = 0
+        try:
+            # Content-Length 헤더 확인
+            if request.content_length:
+                file_size = request.content_length
+                print(f"Content-Length로 파일 크기 확인: {file_size} bytes")
+            else:
+                # Content-Length가 없으면 파일 스트림에서 크기 확인 시도
+                try:
+                    # 파일 스트림의 현재 위치 저장
+                    current_pos = file.tell()
+                    # 파일 끝으로 이동
+                    file.seek(0, os.SEEK_END)
+                    file_size = file.tell()
+                    # 원래 위치로 복원
+                    file.seek(current_pos, os.SEEK_SET)
+                    print(f"파일 스트림으로 크기 확인: {file_size} bytes")
+                except (AttributeError, IOError, OSError) as e:
+                    print(f"파일 크기 확인 실패 (저장 후 확인): {str(e)}")
+                    file_size = 0  # 저장 후 확인하도록 0으로 설정
+        except Exception as e:
+            print(f"파일 크기 확인 오류: {str(e)}")
+            file_size = 0  # 저장 후 확인하도록 0으로 설정
+        
+        # 파일 크기 사전 체크 (가능한 경우에만)
+        if file_size > 0:
+            if file_size > 100 * 1024 * 1024:  # 100MB
+                print(f"파일 크기 초과: {file_size} bytes")
+                return jsonify({'error': '파일 크기가 너무 큽니다. 최대 100MB까지 업로드 가능합니다.'}), 400
+            if file_size == 0:
+                print("빈 파일 업로드 시도")
+                return jsonify({'error': '빈 파일은 업로드할 수 없습니다.'}), 400
         
         # 안전한 파일명 생성
         original_filename = file.filename
         filename = secure_filename(original_filename)
+        if not filename:
+            return jsonify({'error': '유효하지 않은 파일명입니다.'}), 400
+        
         unique_filename = f"{uuid.uuid4().hex}_{filename}"
         file_path = os.path.join(UPLOAD_FOLDER, unique_filename)
         
         # 파일 저장
-        file.save(file_path)
-        file_size = os.path.getsize(file_path)
+        try:
+            log_print(f"[6/8] 파일 저장 시도: {file_path}")
+            file.save(file_path)
+            log_print(f"[6/8] 파일 저장 완료: {file_path}")
+        except IOError as e:
+            error_msg = f'파일 저장 중 오류가 발생했습니다: {str(e)}'
+            log_print(f"[ERROR] 파일 저장 IOError: {error_msg}")
+            traceback.print_exc()
+            return jsonify({'error': error_msg, 'step': 'file_save'}), 500
+        except PermissionError as e:
+            error_msg = f'파일 저장 권한 오류: {str(e)}'
+            log_print(f"[ERROR] 파일 저장 PermissionError: {error_msg}")
+            traceback.print_exc()
+            return jsonify({'error': error_msg, 'step': 'file_save_permission'}), 500
+        except Exception as e:
+            error_msg = f'파일 저장 실패: {str(e)}'
+            log_print(f"[ERROR] 파일 저장 Exception: {error_msg}")
+            traceback.print_exc()
+            return jsonify({'error': error_msg, 'step': 'file_save'}), 500
+        
+        # 저장된 파일 크기 확인
+        if not os.path.exists(file_path):
+            error_msg = '파일이 저장되지 않았습니다.'
+            print(f"파일 존재 확인 실패: {file_path}")
+            return jsonify({'error': error_msg}), 500
+        
+        saved_file_size = os.path.getsize(file_path)
+        if saved_file_size == 0:
+            os.remove(file_path)  # 빈 파일 삭제
+            error_msg = '파일이 제대로 저장되지 않았습니다.'
+            print(f"빈 파일 삭제: {file_path}")
+            return jsonify({'error': error_msg}), 500
+        
+        print(f"저장된 파일 크기: {saved_file_size} bytes")
         
         # 데이터베이스에 저장
-        uploaded_file = UploadedFile(
-            filename=unique_filename,
-            original_filename=original_filename,
-            file_path=file_path,
-            file_size=file_size,
-            model_name=model_name if model_name else None,
-            uploaded_by=current_user.id
-        )
-        db.session.add(uploaded_file)
-        db.session.flush()  # ID를 얻기 위해 flush
-        
-        # 텍스트 파일인 경우 청크로 분할하여 저장 (RAG용)
-        if original_filename.lower().endswith(('.txt', '.md')):
-            try:
-                encoding = 'utf-8'
+        try:
+            log_print(f"[7/8] 데이터베이스 저장 시도: {original_filename}")
+            uploaded_file = UploadedFile(
+                filename=unique_filename,
+                original_filename=original_filename,
+                file_path=file_path,
+                file_size=saved_file_size,
+                model_name=model_name,  # 이미 검증됨
+                uploaded_by=current_user.id,
+                parent_file_id=parent_file_id if parent_file else None  # 이어서 업로드인 경우
+            )
+            db.session.add(uploaded_file)
+            db.session.flush()  # ID를 얻기 위해 flush
+            log_print(f"[7/8] 데이터베이스 flush 완료, 파일 ID: {uploaded_file.id}")
+            
+            # 텍스트 파일인 경우 청크로 분할하여 저장 (RAG용)
+            if original_filename.lower().endswith(('.txt', '.md')):
                 try:
-                    with open(file_path, 'r', encoding=encoding) as f:
-                        content = f.read()
-                except UnicodeDecodeError:
-                    with open(file_path, 'r', encoding='cp949') as f:
-                        content = f.read()
-                
-                chunk_count = create_chunks_for_file(uploaded_file.id, content)
-                if chunk_count > 0:
-                    print(f"파일 {original_filename}을 {chunk_count}개의 청크로 분할했습니다.")
-            except Exception as e:
-                print(f"청크 생성 중 오류 (무시): {str(e)}")
+                    print(f"텍스트 파일 청크 분할 시작: {original_filename}")
+                    encoding = 'utf-8'
+                    try:
+                        with open(file_path, 'r', encoding=encoding) as f:
+                            content = f.read()
+                    except UnicodeDecodeError:
+                        print(f"UTF-8 인코딩 실패, CP949 시도: {original_filename}")
+                        with open(file_path, 'r', encoding='cp949') as f:
+                            content = f.read()
+                    
+                    chunk_count = create_chunks_for_file(uploaded_file.id, content)
+                    if chunk_count > 0:
+                        print(f"파일 {original_filename}을 {chunk_count}개의 청크로 분할했습니다.")
+                except Exception as e:
+                    print(f"청크 생성 중 오류 (무시): {str(e)}")
+                    import traceback
+                    traceback.print_exc()
+            
+            # 청크 개수 저장
+            chunk_count = 0
+            if original_filename.lower().endswith(('.txt', '.md')):
+                chunk_count = DocumentChunk.query.filter_by(file_id=uploaded_file.id).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}")
+            log_print(f"{'='*60}")
+            log_print(f"=== 파일 업로드 성공 ===")
+            log_print(f"{'='*60}\n")
+        except Exception as e:
+            db.session.rollback()
+            error_msg = f'데이터베이스 저장 중 오류가 발생했습니다: {str(e)}'
+            log_print(f"[ERROR] 데이터베이스 저장 오류: {error_msg}")
+            traceback.print_exc()
+            # 데이터베이스 저장 실패 시 파일도 삭제
+            if os.path.exists(file_path):
+                try:
+                    os.remove(file_path)
+                    log_print(f"오류로 인한 파일 삭제: {file_path}")
+                except Exception as del_e:
+                    log_print(f"파일 삭제 실패: {str(del_e)}")
+            return jsonify({'error': error_msg, 'step': 'database_save'}), 500
         
-        db.session.commit()
+        log_print(f"[8/8] 업로드 완료 - 파일: {original_filename}, 모델: {model_name}, 크기: {saved_file_size} bytes")
         
         return jsonify({
-            'message': '파일이 성공적으로 업로드되었습니다.',
-            'file': uploaded_file.to_dict()
+            'message': f'파일이 성공적으로 업로드되었습니다. (모델: {model_name})',
+            'file': uploaded_file.to_dict(),
+            'model_name': model_name,
+            'chunk_count': chunk_count if 'chunk_count' in locals() else 0
         }), 200
         
     except Exception as e:
         db.session.rollback()
-        return jsonify({'error': f'파일 업로드 중 오류가 발생했습니다: {str(e)}'}), 500
+        error_msg = str(e)
+        error_type = type(e).__name__
+        log_print(f"\n{'='*60}")
+        log_print(f"=== 업로드 처리 중 예외 발생 ===")
+        log_print(f"예외 타입: {error_type}")
+        log_print(f"에러 메시지: {error_msg}")
+        traceback.print_exc()
+        log_print(f"{'='*60}\n")
+        # 파일 크기 초과 오류 처리
+        if '413' in error_msg or 'Request Entity Too Large' in error_msg or error_type == 'RequestEntityTooLarge':
+            return jsonify({'error': '파일 크기가 너무 큽니다. 최대 100MB까지 업로드 가능합니다.', 'step': 'file_size'}), 413
+        return jsonify({'error': f'파일 업로드 중 오류가 발생했습니다: {error_type}: {error_msg}', 'step': 'exception'}), 500
 
 @main_bp.route('/api/files', methods=['GET'])
 @login_required
@@ -590,14 +936,47 @@ def get_files():
     try:
         model_name = request.args.get('model_name', None)
         
-        query = UploadedFile.query
+        # 원본 파일만 조회 (parent_file_id가 None인 파일)
+        query = UploadedFile.query.filter_by(parent_file_id=None)
         if model_name:
             query = query.filter_by(model_name=model_name)
+            print(f"[파일 조회] 모델 '{model_name}' 필터링")
         
         files = query.order_by(UploadedFile.uploaded_at.desc()).all()
         
+        # 각 원본 파일에 대해 이어서 업로드된 파일도 포함
+        files_with_children = []
+        for file in files:
+            file_dict = file.to_dict()
+            # 이어서 업로드된 파일들도 조회
+            child_files = UploadedFile.query.filter_by(parent_file_id=file.id).order_by(UploadedFile.uploaded_at.asc()).all()
+            file_dict['child_files'] = [child.to_dict() for child in child_files]
+            files_with_children.append(file_dict)
+        
+        # 모델별 통계 정보 추가 (원본 파일만 카운트)
+        model_stats = {}
+        if not model_name:
+            # 모든 모델의 통계 (원본 파일만)
+            all_files = UploadedFile.query.filter_by(parent_file_id=None).all()
+            for file in all_files:
+                model = file.model_name or '미지정'
+                if model not in model_stats:
+                    model_stats[model] = {'count': 0, 'total_size': 0}
+                model_stats[model]['count'] += 1
+                model_stats[model]['total_size'] += file.file_size
+        else:
+            # 특정 모델의 통계
+            model_stats[model_name] = {
+                'count': len(files),
+                'total_size': sum(f.file_size for f in files)
+            }
+        
+        print(f"[파일 조회] 조회된 원본 파일 수: {len(files)}개")
+        
         return jsonify({
-            'files': [file.to_dict() for file in files]
+            'files': files_with_children,
+            'model_stats': model_stats,
+            'filtered_model': model_name
         }), 200
         
     except Exception as e:
@@ -606,22 +985,59 @@ def get_files():
 @main_bp.route('/api/files/<int:file_id>', methods=['DELETE'])
 @login_required
 def delete_file(file_id):
-    """업로드된 파일 삭제"""
+    """업로드된 파일 삭제 (연관된 모든 파일도 함께 삭제)"""
     try:
         file = UploadedFile.query.get_or_404(file_id)
         
-        # 파일 시스템에서 삭제
-        if os.path.exists(file.file_path):
-            os.remove(file.file_path)
+        # 원본 파일인 경우 (parent_file_id가 None인 경우)
+        # 이어서 업로드된 모든 파일도 함께 삭제
+        files_to_delete = []
         
-        # 관련 청크도 삭제 (CASCADE로 자동 삭제되지만 명시적으로 처리)
-        DocumentChunk.query.filter_by(file_id=file_id).delete()
+        if file.parent_file_id is None:
+            # 원본 파일이면, 이어서 업로드된 모든 파일도 찾아서 삭제
+            child_files = UploadedFile.query.filter_by(parent_file_id=file_id).all()
+            files_to_delete = [file] + child_files
+            print(f"[파일 삭제] 원본 파일 삭제: {file.original_filename}, 연관 파일 {len(child_files)}개도 함께 삭제")
+        else:
+            # 이어서 업로드된 파일이면 원본 파일도 함께 삭제
+            parent_file = UploadedFile.query.get(file.parent_file_id)
+            if parent_file:
+                # 원본 파일과 모든 연관 파일 삭제
+                all_child_files = UploadedFile.query.filter_by(parent_file_id=file.parent_file_id).all()
+                files_to_delete = [parent_file] + all_child_files
+                print(f"[파일 삭제] 이어서 업로드된 파일 삭제: {file.original_filename}, 원본 및 연관 파일 {len(all_child_files)}개도 함께 삭제")
+            else:
+                files_to_delete = [file]
+        
+        deleted_count = 0
+        deleted_files = []
+        
+        for file_to_delete in files_to_delete:
+            try:
+                # 파일 시스템에서 삭제
+                if os.path.exists(file_to_delete.file_path):
+                    os.remove(file_to_delete.file_path)
+                
+                # 관련 청크도 삭제
+                DocumentChunk.query.filter_by(file_id=file_to_delete.id).delete()
+                
+                deleted_files.append(file_to_delete.original_filename)
+                db.session.delete(file_to_delete)
+                deleted_count += 1
+            except Exception as e:
+                print(f"[파일 삭제 오류] {file_to_delete.original_filename}: {str(e)}")
         
-        # 데이터베이스에서 삭제
-        db.session.delete(file)
         db.session.commit()
         
-        return jsonify({'message': '파일이 성공적으로 삭제되었습니다.'}), 200
+        message = f'파일이 성공적으로 삭제되었습니다.'
+        if deleted_count > 1:
+            message = f'파일 {deleted_count}개가 성공적으로 삭제되었습니다. (원본 및 연관 파일 포함)'
+        
+        return jsonify({
+            'message': message,
+            'deleted_count': deleted_count,
+            'deleted_files': deleted_files
+        }), 200
         
     except Exception as e:
         db.session.rollback()

reset_upload_data.py

@@ -0,0 +1,133 @@
+"""
+업로드된 파일과 데이터베이스 정보를 삭제하는 스크립트
+"""
+import os
+import sys
+import sqlite3
+from pathlib import Path
+
+# UTF-8 인코딩 설정
+if sys.platform == 'win32':
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+
+def reset_upload_data():
+    """업로드된 파일과 DB 데이터 삭제"""
+    try:
+        # 1. 데이터베이스 경로 확인
+        db_path = os.path.join('instance', 'finance_analysis.db')
+        if not os.path.exists(db_path):
+            # 상대 경로로도 시도
+            db_path = 'finance_analysis.db'
+            if not os.path.exists(db_path):
+                print(f"데이터베이스 파일을 찾을 수 없습니다: {db_path}")
+                return False
+        
+        print(f"데이터베이스 경로: {db_path}")
+        
+        # 2. 데이터베이스 연결
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # 3. 업로드된 파일 목록 조회 (삭제 전에 파일 경로 저장)
+        cursor.execute("SELECT id, file_path FROM uploaded_file")
+        files_to_delete = cursor.fetchall()
+        
+        print(f"\n삭제할 파일 수: {len(files_to_delete)}개")
+        
+        # 4. 파일 시스템에서 파일 삭제
+        deleted_files = 0
+        failed_files = []
+        
+        for file_id, file_path in files_to_delete:
+            if file_path and os.path.exists(file_path):
+                try:
+                    os.remove(file_path)
+                    deleted_files += 1
+                    print(f"  ✓ 파일 삭제: {os.path.basename(file_path)}")
+                except Exception as e:
+                    failed_files.append((file_path, str(e)))
+                    print(f"  ✗ 파일 삭제 실패: {os.path.basename(file_path)} - {str(e)}")
+        
+        # 5. 데이터베이스에서 데이터 삭제
+        print(f"\n데이터베이스 데이터 삭제 중...")
+        
+        # document_chunk 테이블 삭제 (RAG용 청크)
+        cursor.execute("DELETE FROM document_chunk")
+        chunk_count = cursor.rowcount
+        print(f"  ✓ document_chunk: {chunk_count}개 청크 삭제")
+        
+        # uploaded_file 테이블 삭제
+        cursor.execute("DELETE FROM uploaded_file")
+        file_count = cursor.rowcount
+        print(f"  ✓ uploaded_file: {file_count}개 파일 정보 삭제")
+        
+        # chat_message 테이블 삭제 (선택사항 - 채팅 기록도 삭제)
+        cursor.execute("DELETE FROM chat_message")
+        message_count = cursor.rowcount
+        print(f"  ✓ chat_message: {message_count}개 메시지 삭제")
+        
+        # chat_session 테이블 삭제 (선택사항 - 채팅 세션도 삭제)
+        cursor.execute("DELETE FROM chat_session")
+        session_count = cursor.rowcount
+        print(f"  ✓ chat_session: {session_count}개 세션 삭제")
+        
+        # 변경사항 커밋
+        conn.commit()
+        conn.close()
+        
+        print(f"\n{'='*60}")
+        print(f"삭제 완료!")
+        print(f"  - 파일 시스템: {deleted_files}개 파일 삭제")
+        print(f"  - 데이터베이스: {file_count}개 파일 정보, {chunk_count}개 청크 삭제")
+        if failed_files:
+            print(f"\n삭제 실패한 파일 ({len(failed_files)}개):")
+            for file_path, error in failed_files:
+                print(f"  - {file_path}: {error}")
+        print(f"{'='*60}\n")
+        
+        return True
+        
+    except Exception as e:
+        print(f"\n오류 발생: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == '__main__':
+    import sys
+    
+    print("="*60)
+    print("업로드 데이터 초기화 스크립트")
+    print("="*60)
+    print("\n다음 데이터가 삭제됩니다:")
+    print("  - 업로드된 모든 파일 (uploads 폴더)")
+    print("  - 데이터베이스의 uploaded_file 테이블")
+    print("  - 데이터베이스의 document_chunk 테이블 (RAG 청크)")
+    print("  - 데이터베이스의 chat_message 테이블 (채팅 기록)")
+    print("  - 데이터베이스의 chat_session 테이블 (채팅 세션)")
+    print("\n사용자 정보는 유지됩니다.")
+    print("="*60)
+    
+    # 명령줄 인자로 --yes가 있으면 확인 없이 실행
+    auto_confirm = '--yes' in sys.argv or '-y' in sys.argv
+    
+    if not auto_confirm:
+        try:
+            confirm = input("\n정말 삭제하시겠습니까? (yes/no): ")
+        except (EOFError, KeyboardInterrupt):
+            print("\n입력이 취소되었습니다. 자동 실행 모드로 진행합니다.")
+            confirm = 'yes'
+    else:
+        confirm = 'yes'
+        print("\n자동 실행 모드: 확인 없이 삭제를 진행합니다.")
+    
+    if confirm.lower() in ['yes', 'y', '예', 'ㅇ']:
+        success = reset_upload_data()
+        if success:
+            print("\n초기��가 완료되었습니다. 이제 새로 파일을 업로드할 수 있습니다.")
+        else:
+            print("\n초기화 중 오류가 발생했습니다.")
+    else:
+        print("\n취소되었습니다.")
+

run.py

@@ -1,5 +1,7 @@
 import sys
 import os
+import logging
+from logging.handlers import RotatingFileHandler
 
 # UTF-8 인코딩 강제 설정 (Windows cp949 오류 방지)
 if sys.platform == 'win32':
@@ -10,9 +12,33 @@ from app import create_app
 
 app = create_app()
 
+# 로깅 설정
+if not app.debug:
+    # 프로덕션 환경에서는 파일로 로깅
+    if not os.path.exists('logs'):
+        os.mkdir('logs')
+    file_handler = RotatingFileHandler('logs/server.log', maxBytes=10240000, backupCount=10)
+    file_handler.setFormatter(logging.Formatter(
+        '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
+    ))
+    file_handler.setLevel(logging.INFO)
+    app.logger.addHandler(file_handler)
+    app.logger.setLevel(logging.INFO)
+    app.logger.info('서버 시작')
+
+# 디버그 모드에서도 콘솔에 모든 로그 출력
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
 if __name__ == '__main__':
     try:
         print(f"[{__name__}] 서버 시작: http://0.0.0.0:5001")
+        print(f"[{__name__}] 로그는 콘솔과 logs/server.log 파일에 기록됩니다.")
         app.run(host='0.0.0.0', port=5001, debug=True, use_reloader=False)
     except Exception as e:
         print(f"서버 시작 오류: {e}")

setup_remote.ps1

@@ -0,0 +1,62 @@
+# Git 원격 저장소 설정 스크립트
+# 사용법: .\setup_remote.ps1
+
+Write-Host "=== Git 원격 저장소 설정 ===" -ForegroundColor Cyan
+Write-Host ""
+
+# 현재 원격 저장소 확인
+$currentRemote = git remote -v
+if ($currentRemote) {
+    Write-Host "현재 원격 저장소:" -ForegroundColor Yellow
+    Write-Host $currentRemote
+    Write-Host ""
+    $overwrite = Read-Host "원격 저장소가 이미 있습니다. 덮어쓰시겠습니까? (y/n)"
+    if ($overwrite -ne "y") {
+        Write-Host "취소되었습니다." -ForegroundColor Red
+        exit
+    }
+    git remote remove origin
+}
+
+# 원격 저장소 URL 입력
+Write-Host ""
+Write-Host "원격 저장소 URL을 입력하세요:" -ForegroundColor Green
+Write-Host "예시: https://github.com/username/soy-nv-ai.git" -ForegroundColor Gray
+Write-Host "     git@github.com:username/soy-nv-ai.git" -ForegroundColor Gray
+Write-Host ""
+$remoteUrl = Read-Host "원격 저장소 URL"
+
+if ([string]::IsNullOrWhiteSpace($remoteUrl)) {
+    Write-Host "URL이 입력되지 않았습니다. 취소합니다." -ForegroundColor Red
+    exit
+}
+
+# 원격 저장소 추가
+Write-Host ""
+Write-Host "원격 저장소를 추가하는 중..." -ForegroundColor Yellow
+git remote add origin $remoteUrl
+
+# 원격 저장소 확인
+Write-Host ""
+Write-Host "원격 저장소가 추가되었습니다:" -ForegroundColor Green
+git remote -v
+
+# 푸시 여부 확인
+Write-Host ""
+$push = Read-Host "마스터 브랜치를 원격 저장소에 푸시하시겠습니까? (y/n)"
+if ($push -eq "y") {
+    Write-Host ""
+    Write-Host "푸시하는 중..." -ForegroundColor Yellow
+    git push -u origin master
+    Write-Host ""
+    Write-Host "푸시가 완료되었습니다!" -ForegroundColor Green
+} else {
+    Write-Host ""
+    Write-Host "푸시를 건너뛰었습니다. 나중에 다음 명령으로 푸시할 수 있습니다:" -ForegroundColor Yellow
+    Write-Host "  git push -u origin master" -ForegroundColor Cyan
+}
+
+Write-Host ""
+Write-Host "=== 완료 ===" -ForegroundColor Green
+
+

start_server.bat

@@ -8,3 +8,4 @@ echo [%date% %time%] 서버가 종료되었습니다. 5초 후 재시작합니
 timeout /t 5 /nobreak >nul
 goto start
 
+

start_server.ps1

@@ -27,3 +27,4 @@ while ($true) {
     }
 }
 
+

start_server_background.ps1

@@ -85,3 +85,4 @@ while ($true) {
     Start-Sleep -Seconds 5
 }
 
+

templates/admin.html

@@ -342,6 +342,86 @@
             color: #c5221f;
         }
 
+        .file-upload-status.progress {
+            color: #1a73e8;
+            font-weight: 500;
+        }
+
+        .file-upload-progress {
+            margin-top: 12px;
+            padding: 12px;
+            background: #f8f9fa;
+            border-radius: 6px;
+            display: none;
+        }
+
+        .file-upload-progress.active {
+            display: block;
+        }
+
+        .progress-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 8px 0;
+            border-bottom: 1px solid #e8eaed;
+        }
+
+        .progress-item:last-child {
+            border-bottom: none;
+        }
+
+        .progress-item-name {
+            flex: 1;
+            font-size: 13px;
+            color: #202124;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            margin-right: 12px;
+        }
+
+        .progress-item-status {
+            font-size: 12px;
+            font-weight: 500;
+            min-width: 80px;
+            text-align: right;
+        }
+
+        .progress-item-status.uploading {
+            color: #1a73e8;
+        }
+
+        .progress-item-status.success {
+            color: #137333;
+        }
+
+        .progress-item-status.error {
+            color: #c5221f;
+        }
+
+        .file-upload-input-wrapper.disabled {
+            opacity: 0.6;
+            pointer-events: none;
+            cursor: not-allowed;
+        }
+
+        .spinner {
+            display: inline-block;
+            width: 12px;
+            height: 12px;
+            border: 2px solid #e8eaed;
+            border-top-color: #1a73e8;
+            border-radius: 50%;
+            animation: spin 0.8s linear infinite;
+            margin-right: 6px;
+            vertical-align: middle;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
         .files-table {
             margin-top: 16px;
         }
@@ -438,6 +518,14 @@
                 <div class="card-title">웹소설 학습 파일 관리</div>
             </div>
 
+            <!-- 모델 선택 -->
+            <div style="margin-bottom: 16px;">
+                <label style="display: block; font-size: 14px; font-weight: 500; margin-bottom: 8px;">AI 모델 선택</label>
+                <select id="fileModelSelect" style="width: 100%; padding: 10px 12px; border: 1px solid #dadce0; border-radius: 6px; font-size: 14px;">
+                    <option value="">모델을 선택하세요...</option>
+                </select>
+            </div>
+
             <!-- 파일 업로드 -->
             <div class="file-upload-input-wrapper" id="fileUploadWrapper">
                 <input type="file" id="fileInput" accept=".txt,.md,.pdf,.docx,.epub" multiple>
@@ -450,13 +538,8 @@
                 </label>
             </div>
             <div class="file-upload-status" id="fileUploadStatus"></div>
-
-            <!-- 모델 선택 -->
-            <div style="margin-top: 16px;">
-                <label style="display: block; font-size: 14px; font-weight: 500; margin-bottom: 8px;">AI 모델 선택</label>
-                <select id="fileModelSelect" style="width: 100%; padding: 10px 12px; border: 1px solid #dadce0; border-radius: 6px; font-size: 14px;">
-                    <option value="">모델을 선택하세요...</option>
-                </select>
+            <div class="file-upload-progress" id="fileUploadProgress">
+                <div id="progressItems"></div>
             </div>
 
             <!-- 업로드 규칙 안내 -->
@@ -486,13 +569,19 @@
                 </div>
             </div>
 
+            <!-- 모델별 통계 -->
+            <div id="modelStats" style="margin-top: 20px; padding: 16px; background: #e8f0fe; border-radius: 8px; display: none;">
+                <div style="font-size: 14px; font-weight: 500; margin-bottom: 12px; color: #1967d2;">📊 모델별 학습 파일 통계</div>
+                <div id="modelStatsContent"></div>
+            </div>
+
             <!-- 파일 목록 -->
             <div class="files-table">
                 <table style="margin-top: 16px;">
                     <thead>
                         <tr>
                             <th>파일명</th>
-                            <th>모델</th>
+                            <th>연결된 모델</th>
                             <th>크기</th>
                             <th>업로드일</th>
                             <th>작업</th>
@@ -698,24 +787,81 @@
                 
                 filesTableBody.innerHTML = '';
                 
+                // 모델별 통계 표시
+                if (data.model_stats && Object.keys(data.model_stats).length > 0) {
+                    const statsContainer = document.getElementById('modelStats');
+                    const statsContent = document.getElementById('modelStatsContent');
+                    statsContainer.style.display = 'block';
+                    
+                    let statsHtml = '<div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 12px;">';
+                    for (const [model, stats] of Object.entries(data.model_stats)) {
+                        const totalSize = formatFileSize(stats.total_size);
+                        statsHtml += `
+                            <div style="background: white; padding: 12px; border-radius: 6px; border-left: 4px solid #1a73e8;">
+                                <div style="font-weight: 500; margin-bottom: 4px; color: #202124;">${escapeHtml(model || '미지정')}</div>
+                                <div style="font-size: 12px; color: #5f6368;">
+                                    파일: <strong>${stats.count}개</strong><br>
+                                    총 크기: <strong>${totalSize}</strong>
+                                </div>
+                            </div>
+                        `;
+                    }
+                    statsHtml += '</div>';
+                    statsContent.innerHTML = statsHtml;
+                } else {
+                    document.getElementById('modelStats').style.display = 'none';
+                }
+                
                 if (data.files && data.files.length > 0) {
                     data.files.forEach(file => {
                         const row = document.createElement('tr');
                         const fileSize = formatFileSize(file.file_size);
                         const uploadDate = new Date(file.uploaded_at).toLocaleString('ko-KR');
+                        const modelName = file.model_name || '<span style="color: #c5221f;">미지정</span>';
+                        const childFiles = file.child_files || [];
+                        const childCount = childFiles.length;
+                        
+                        // 원본 파일 행
+                        let fileNameDisplay = escapeHtml(file.original_filename);
+                        if (childCount > 0) {
+                            fileNameDisplay += ` <span style="color: #1a73e8; font-size: 12px;">(${childCount}개 회차)</span>`;
+                        }
                         
                         row.innerHTML = `
-                            <td>${escapeHtml(file.original_filename)}</td>
-                            <td>${file.model_name || '-'}</td>
+                            <td>${fileNameDisplay}</td>
+                            <td>${modelName}</td>
                             <td class="file-size">${fileSize}</td>
                             <td>${uploadDate}</td>
                             <td>
                                 <div class="file-actions">
+                                    <button class="btn btn-primary" onclick="continueUpload(${file.id})" style="padding: 4px 8px; font-size: 12px; margin-right: 4px;">이어서 업로드</button>
                                     <button class="btn btn-secondary" onclick="deleteFile(${file.id})" style="padding: 4px 8px; font-size: 12px;">삭제</button>
                                 </div>
                             </td>
                         `;
                         filesTableBody.appendChild(row);
+                        
+                        // 이어서 업로드된 파일들 표시
+                        childFiles.forEach((childFile, index) => {
+                            const childRow = document.createElement('tr');
+                            const childFileSize = formatFileSize(childFile.file_size);
+                            const childUploadDate = new Date(childFile.uploaded_at).toLocaleString('ko-KR');
+                            
+                            childRow.innerHTML = `
+                                <td style="padding-left: 32px; color: #5f6368;">
+                                    <span style="margin-right: 8px;">└─</span>${escapeHtml(childFile.original_filename)}
+                                </td>
+                                <td>${modelName}</td>
+                                <td class="file-size">${childFileSize}</td>
+                                <td>${childUploadDate}</td>
+                                <td>
+                                    <div class="file-actions">
+                                        <button class="btn btn-secondary" onclick="deleteFile(${childFile.id})" style="padding: 4px 8px; font-size: 12px;">삭제</button>
+                                    </div>
+                                </td>
+                            `;
+                            filesTableBody.appendChild(childRow);
+                        });
                     });
                 } else {
                     filesTableBody.innerHTML = '<tr><td colspan="5" style="text-align: center; padding: 20px; color: #5f6368;">업로드된 파일이 없습니다.</td></tr>';
@@ -752,52 +898,148 @@
                 return;
             }
 
-            fileUploadStatus.textContent = `${files.length}개 파일 업로드 중...`;
-            fileUploadStatus.className = 'file-upload-status';
+            // 업로드 중 UI 비활성화
+            fileUploadWrapper.classList.add('disabled');
+            fileModelSelect.disabled = true;
+            fileInput.disabled = true;
+
+            // 진행 상태 초기화
+            const progressContainer = document.getElementById('fileUploadProgress');
+            const progressItems = document.getElementById('progressItems');
+            progressContainer.classList.add('active');
+            progressItems.innerHTML = '';
+
+            // 각 파일에 대한 진행 항목 생성
+            const progressMap = new Map();
+            files.forEach((file, index) => {
+                const item = document.createElement('div');
+                item.className = 'progress-item';
+                item.id = `progress-item-${index}`;
+                item.innerHTML = `
+                    <span class="progress-item-name">${escapeHtml(file.name)}</span>
+                    <span class="progress-item-status uploading" id="progress-status-${index}">
+                        <span class="spinner"></span>업로드 중...
+                    </span>
+                `;
+                progressItems.appendChild(item);
+                progressMap.set(index, { file, item, status: 'uploading' });
+            });
+
+            fileUploadStatus.textContent = `총 ${files.length}개 파일 업로드 중...`;
+            fileUploadStatus.className = 'file-upload-status progress';
 
             let successCount = 0;
             let failCount = 0;
+            const errors = [];
 
+            // 파일을 순차적으로 업로드
             for (let i = 0; i < files.length; i++) {
                 const file = files[i];
                 const formData = new FormData();
                 formData.append('file', file);
                 formData.append('model_name', modelName);
+                
+                // 이어서 업로드인 경우 parent_file_id 추가
+                if (continueUploadFileId) {
+                    formData.append('parent_file_id', continueUploadFileId);
+                }
+
+                const statusElement = document.getElementById(`progress-status-${i}`);
+                const itemElement = document.getElementById(`progress-item-${i}`);
 
                 try {
+                    console.log(`[업로드 시작] 파일: ${file.name}, 크기: ${file.size} bytes, 모델: ${modelName}`);
+                    
                     const response = await fetch('/api/upload', {
                         method: 'POST',
                         body: formData
                     });
 
-                    const data = await response.json();
+                    console.log(`[응답 수신] 상태: ${response.status} ${response.statusText}, Content-Type: ${response.headers.get('Content-Type')}`);
+
+                    let data;
+                    let responseText = '';
+                    try {
+                        responseText = await response.text();
+                        console.log(`[응답 본문] ${responseText.substring(0, 500)}`);
+                        data = JSON.parse(responseText);
+                    } catch (jsonError) {
+                        // JSON 파싱 실패 시 응답 텍스트 사용
+                        console.error(`[JSON 파싱 실패]`, jsonError, `응답 텍스트:`, responseText);
+                        throw new Error(`서버 응답 오류 (${response.status}): ${responseText.substring(0, 200)}`);
+                    }
 
                     if (response.ok) {
                         successCount++;
+                        const modelName = data.model_name || '알 수 없음';
+                        const chunkCount = data.chunk_count || 0;
+                        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}개`);
                     } else {
                         failCount++;
-                        console.error(`파일 업로드 실패 (${file.name}):`, data.error);
+                        const errorMsg = data.error || data.message || `HTTP ${response.status} 오류`;
+                        statusElement.className = 'progress-item-status error';
+                        statusElement.innerHTML = '✗ 실패';
+                        statusElement.title = errorMsg; // 툴팁으로 상세 에러 표시
+                        statusElement.style.cursor = 'help'; // 툴팁 표시를 위한 커서 변경
+                        errors.push(`${file.name}: ${errorMsg}`);
+                        console.error(`[업로드 실패] 파일: ${file.name}`, {
+                            status: response.status,
+                            statusText: response.statusText,
+                            error: errorMsg,
+                            data: data,
+                            responseText: responseText
+                        });
                     }
                 } catch (error) {
                     failCount++;
-                    console.error(`파일 업로드 오류 (${file.name}):`, error);
+                    const errorMsg = error.message || '네트워크 오류';
+                    statusElement.className = 'progress-item-status error';
+                    statusElement.innerHTML = '✗ 실패';
+                    statusElement.title = errorMsg; // 툴팁으로 상세 에러 표시
+                    statusElement.style.cursor = 'help'; // 툴팁 표시를 위한 커서 변경
+                    errors.push(`${file.name}: ${errorMsg}`);
+                    console.error(`[업로드 예외] 파일: ${file.name}`, error);
+                    console.error(`[스택 트레이스]`, error.stack);
                 }
+
+                // 진행 상태 업데이트
+                fileUploadStatus.textContent = `업로드 중... (${i + 1}/${files.length})`;
             }
 
+            // 업로드 완료 처리
+            fileUploadStatus.className = 'file-upload-status';
             if (successCount > 0) {
+                fileUploadStatus.textContent = `${successCount}개 파일 업로드 완료${failCount > 0 ? ` (${failCount}개 실패)` : ''}`;
+                fileUploadStatus.className = 'file-upload-status success';
                 showAlert(`${successCount}개 파일이 성공적으로 업로드되었습니다.${failCount > 0 ? ` (${failCount}개 실패)` : ''}`, 'success');
                 loadFiles();
             } else {
-                showAlert('파일 업로드에 실패했습니다.', 'error');
+                fileUploadStatus.textContent = '모든 파일 업로드 실패';
+                fileUploadStatus.className = 'file-upload-status error';
+                const errorDetails = errors.length > 0 ? '\n' + errors.slice(0, 3).join('\n') + (errors.length > 3 ? `\n... 외 ${errors.length - 3}개 오류` : '') : '';
+                showAlert(`파일 업로드에 실패했습니다.${errorDetails}`, 'error');
             }
 
-            fileUploadStatus.textContent = '';
+            // UI 활성화
+            fileUploadWrapper.classList.remove('disabled');
+            fileModelSelect.disabled = false;
+            fileInput.disabled = false;
             fileInput.value = '';
+
+            // 3초 후 진행 상태 숨기기
+            setTimeout(() => {
+                progressContainer.classList.remove('active');
+                fileUploadStatus.textContent = '';
+            }, 3000);
         }
 
         // 파일 삭제
         async function deleteFile(fileId) {
-            if (!confirm('이 파일을 삭제하시겠습니까?')) {
+            if (!confirm('이 파일을 삭제하시겠습니까?\n원본 파일인 경우 이어서 업로드한 모든 회차도 함께 삭제됩니다.')) {
                 return;
             }
 
@@ -809,7 +1051,11 @@
                 const data = await response.json();
 
                 if (response.ok) {
-                    showAlert(data.message, 'success');
+                    if (data.deleted_count > 1) {
+                        showAlert(`${data.message} (삭제된 파일: ${data.deleted_files.join(', ')})`, 'success');
+                    } else {
+                        showAlert(data.message, 'success');
+                    }
                     loadFiles();
                 } else {
                     showAlert(data.error || '삭제 중 오류가 발생했습니다.', 'error');
@@ -819,11 +1065,28 @@
             }
         }
 
+        // 이어서 업로드
+        let continueUploadFileId = null;
+        
+        function continueUpload(fileId) {
+            continueUploadFileId = fileId;
+            // 모델 선택 확인
+            const modelName = fileModelSelect.value;
+            if (!modelName) {
+                showAlert('먼저 AI 모델을 선택해주세요.', 'error');
+                continueUploadFileId = null;
+                return;
+            }
+            fileInput.click(); // 파일 선택 다이얼로그 열기
+        }
+
         // 파일 입력 이벤트
         fileInput.addEventListener('change', function(e) {
             if (e.target.files.length > 0) {
                 handleFileUpload(Array.from(e.target.files));
             }
+            // 이어서 업로드 모드 초기화
+            continueUploadFileId = null;
         });
 
         // 드래그 앤 드롭

templates/admin_messages.html

@@ -693,3 +693,4 @@
 </body>
 </html>
 
+

templates/index.html

@@ -1299,27 +1299,9 @@
                 currentSessionId = await createNewSession();
             }
 
-            // 사용자 메시지 표시
+            // 사용자 메시지 표시 (DB 저장은 /api/chat에서 처리)
             addMessage('user', message, false);
             
-            // DB에 사용자 메시지 저장
-            if (currentSessionId) {
-                try {
-                    await fetch(`/api/chat/sessions/${currentSessionId}/messages`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            role: 'user',
-                            content: message
-                        })
-                    });
-                } catch (error) {
-                    console.error('메시지 저장 오류:', error);
-                }
-            }
-            
             messageInput.value = '';
             messageInput.style.height = 'auto';
 
@@ -1353,8 +1335,14 @@
                     addMessage('ai', aiResponse, false);
                     
                     // DB에 AI 응답 저장 (이미 백엔드에서 저장됨)
-                    // 세션 목록 새로고침
-                    await loadChatHistory();
+                    // 세션 목록 새로고침 (제목 업데이트 반영)
+                    if (data.session && data.session.title) {
+                        // 세션 제목이 업데이트되었으면 목록 새로고침
+                        await loadChatHistory();
+                    } else {
+                        // 세션 정보가 없어도 목록 새로고침
+                        await loadChatHistory();
+                    }
                 } else {
                     const error = await response.json().catch(() => ({ error: '서버 오류' }));
                     addMessage('ai', `오류: ${error.error || '알 수 없는 오류가 발생했습니다.'}`, false);
@@ -1363,6 +1351,8 @@
                 removeTypingIndicator();
                 addMessage('ai', `연결 오류: ${error.message}`, false);
             } finally {
+                // 전송 상태 해제
+                isSending = false;
                 // 입력 활성화
                 messageInput.disabled = false;
                 sendButton.disabled = false;

templates/login.html

@@ -159,3 +159,4 @@
 </body>
 </html>
 
+