Initial commit: SOY NV AI - Web novel training system with RAG functionality

.gitignore

@@ -35,3 +35,4 @@ Thumbs.db
 uploads/*
 !uploads/.gitkeep
 
+

README.md

@@ -37,3 +37,4 @@ SOY NV AI/
 └── README.md
 ```
 
+

README_SERVER.md

@@ -0,0 +1,68 @@
+# 서버 실행 가이드
+
+## 서버 시작 방법
+
+### 방법 1: 자동 재시작 스크립트 (권장)
+
+**PowerShell 사용:**
+```powershell
+.\start_server_background.ps1
+```
+
+**배치 파일 사용:**
+```cmd
+start_server.bat
+```
+
+이 스크립트들은 서버가 종료되면 자동으로 재시작합니다.
+
+### 방법 2: 직접 실행
+
+```bash
+python run.py
+```
+
+## 서버 상태 확인
+
+포트 5001이 열려있는지 확인:
+```powershell
+netstat -ano | Select-String ":5001" | Select-String "LISTENING"
+```
+
+## 문제 해결
+
+### 서버가 시작되지 않는 경우
+
+1. Python이 설치되어 있는지 확인:
+   ```bash
+   python --version
+   ```
+
+2. 필요한 라이브러리가 설치되어 있는지 확인:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. 포트 5001이 다른 프로그램에서 사용 중인지 확인:
+   ```powershell
+   netstat -ano | Select-String ":5001"
+   ```
+
+### 서버가 자주 종료되는 경우
+
+- `start_server_background.ps1` 스크립트를 사용하면 자동으로 재시작됩니다.
+- 로그는 `server.log` 파일에 저장됩니다.
+
+## 백그라운드 실행
+
+PowerShell에서 백그라운드로 실행하려면:
+```powershell
+Start-Process powershell -ArgumentList "-File", "start_server_background.ps1" -WindowStyle Hidden
+```
+
+## 서버 중지
+
+서버를 중지하려면:
+1. PowerShell 창에서 `Ctrl+C` 누르기
+2. 또는 작업 관리자에서 Python 프로세스 종료
+

app/__init__.py

@@ -1,6 +1,18 @@
 from flask import Flask
-from app.database import db
+from flask_login import LoginManager
+from app.database import db, User
 import os
+import sqlite3
+from pathlib import Path
+
+login_manager = LoginManager()
+login_manager.login_view = 'main.login'
+login_manager.login_message = '로그인이 필요합니다.'
+login_manager.login_message_category = 'info'
+
+@login_manager.user_loader
+def load_user(user_id):
+    return User.query.get(int(user_id))
 
 def create_app():
     # 템플릿 폴더 경로 명시적 설정
@@ -11,12 +23,60 @@ def create_app():
     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
     
     db.init_app(app)
+    login_manager.init_app(app)
     
     from app.routes import main_bp
     app.register_blueprint(main_bp)
     
     with app.app_context():
         db.create_all()
+        # 데이터베이스 마이그레이션 (nickname 컬럼 추가)
+        migrate_database(app)
+        # 초기 관리자 계정 생성
+        create_admin_user()
     
     return app
 
+def migrate_database(app):
+    """데이터베이스 마이그레이션 - nickname 컬럼 추가"""
+    try:
+        # 데이터베이스 URI에서 경로 추출
+        db_uri = app.config['SQLALCHEMY_DATABASE_URI']
+        if db_uri.startswith('sqlite:///'):
+            db_path = db_uri.replace('sqlite:///', '')
+            # 상대 경로인 경우 instance 폴더 기준으로 처리
+            if not os.path.isabs(db_path):
+                db_path = os.path.join(app.instance_path, db_path)
+            
+            if not os.path.exists(db_path):
+                return
+            
+            conn = sqlite3.connect(db_path)
+            cursor = conn.cursor()
+            
+            # user 테이블에 nickname 컬럼이 있는지 확인
+            cursor.execute("PRAGMA table_info(user)")
+            columns = [column[1] for column in cursor.fetchall()]
+            
+            if 'nickname' not in columns:
+                cursor.execute("ALTER TABLE user ADD COLUMN nickname VARCHAR(80)")
+                conn.commit()
+            
+            conn.close()
+    except Exception as e:
+        print(f"마이그레이션 오류 (무시 가능): {e}")
+
+def create_admin_user():
+    """초기 관리자 계정 생성"""
+    admin_username = 'soymedia'
+    admin_password = 's0ymedi@1@34'
+    
+    admin = User.query.filter_by(username=admin_username).first()
+    if not admin:
+        admin = User(username=admin_username, is_admin=True, is_active=True)
+        admin.set_password(admin_password)
+        db.session.add(admin)
+        db.session.commit()
+        print(f'관리자 계정이 생성되었습니다: {admin_username}')
+
+

app/database.py

@@ -1,6 +1,120 @@
 from flask_sqlalchemy import SQLAlchemy
+from flask_login import UserMixin
+from datetime import datetime
+from werkzeug.security import generate_password_hash, check_password_hash
 
 db = SQLAlchemy()
 
-# 데이터베이스 모델은 여기에 추가
+# 사용자 모델
+class User(UserMixin, db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(80), unique=True, nullable=False)
+    nickname = db.Column(db.String(80), nullable=True)  # 닉네임 필드 추가
+    password_hash = db.Column(db.String(255), nullable=False)
+    is_admin = db.Column(db.Boolean, default=False, nullable=False)
+    is_active = db.Column(db.Boolean, default=True, nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    last_login = db.Column(db.DateTime, nullable=True)
+    
+    def set_password(self, password):
+        self.password_hash = generate_password_hash(password)
+    
+    def check_password(self, password):
+        return check_password_hash(self.password_hash, password)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'username': self.username,
+            'nickname': self.nickname,
+            'is_admin': self.is_admin,
+            'is_active': self.is_active,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'last_login': self.last_login.isoformat() if self.last_login else None
+        }
+
+# 업로드된 파일 정보 모델
+class UploadedFile(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    filename = db.Column(db.String(255), nullable=False)
+    original_filename = db.Column(db.String(255), nullable=False)
+    file_path = db.Column(db.String(500), nullable=False)
+    file_size = db.Column(db.Integer, nullable=False)
+    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)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'filename': self.filename,
+            'original_filename': self.original_filename,
+            '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
+        }
+
+# 대화 세션 모델
+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)
+    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)
+    
+    # 관계
+    user = db.relationship('User', backref='chat_sessions')
+    messages = db.relationship('ChatMessage', backref='session', lazy=True, cascade='all, delete-orphan', order_by='ChatMessage.created_at')
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'title': self.title,
+            'model_name': self.model_name,
+            '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)
+        }
+
+# 대화 메시지 모델
+class ChatMessage(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    session_id = db.Column(db.Integer, db.ForeignKey('chat_session.id'), nullable=False)
+    role = db.Column(db.String(20), nullable=False)  # 'user' or 'ai'
+    content = db.Column(db.Text, nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'session_id': self.session_id,
+            'role': self.role,
+            'content': self.content,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }
+
+# 문서 청크 모델 (RAG용)
+class DocumentChunk(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    file_id = db.Column(db.Integer, db.ForeignKey('uploaded_file.id'), nullable=False)
+    chunk_index = db.Column(db.Integer, nullable=False)  # 청크 순서
+    content = db.Column(db.Text, nullable=False)  # 청크 내용
+    embedding = db.Column(db.Text, nullable=True)  # 임베딩 벡터 (JSON 문자열로 저장)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
+    
+    # 관계
+    file = db.relationship('UploadedFile', backref='chunks')
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'file_id': self.file_id,
+            'chunk_index': self.chunk_index,
+            'content': self.content,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }
+
 

app/routes.py

@@ -1,8 +1,804 @@
-from flask import Blueprint, render_template
+from flask import Blueprint, render_template, request, jsonify, send_from_directory, redirect, url_for, flash
+from flask_login import login_user, logout_user, login_required, current_user
+from werkzeug.utils import secure_filename
+from app.database import db, UploadedFile, User, ChatSession, ChatMessage, DocumentChunk
+import requests
+import os
+from datetime import datetime
+import uuid
+import re
+import json
 
 main_bp = Blueprint('main', __name__)
 
+def admin_required(f):
+    """관리자 권한이 필요한 데코레이터"""
+    from functools import wraps
+    @wraps(f)
+    @login_required
+    def decorated_function(*args, **kwargs):
+        if not current_user.is_admin:
+            flash('관리자 권한이 필요합니다.', 'error')
+            return redirect(url_for('main.index'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+# Ollama 기본 URL (환경 변수로 설정 가능)
+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'}
+
+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)
+
+def split_text_into_chunks(text, chunk_size=500, overlap=50):
+    """텍스트를 청크로 분할"""
+    chunks = []
+    start = 0
+    while start < len(text):
+        end = start + chunk_size
+        chunk = text[start:end]
+        chunks.append(chunk)
+        start = end - overlap  # 오버랩으로 문맥 유지
+    return chunks
+
+def create_chunks_for_file(file_id, content):
+    """파일 내용을 청크로 분할하여 저장"""
+    try:
+        # 기존 청크 삭제
+        DocumentChunk.query.filter_by(file_id=file_id).delete()
+        
+        # 텍스트를 청크로 분할
+        chunks = split_text_into_chunks(content, chunk_size=500, overlap=50)
+        
+        # 각 청크를 데이터베이스에 저장
+        for idx, chunk_content in enumerate(chunks):
+            chunk = DocumentChunk(
+                file_id=file_id,
+                chunk_index=idx,
+                content=chunk_content
+            )
+            db.session.add(chunk)
+        
+        db.session.commit()
+        return len(chunks)
+    except Exception as e:
+        db.session.rollback()
+        print(f"청크 생성 오류: {str(e)}")
+        return 0
+
+def search_relevant_chunks(query, file_ids=None, model_name=None, top_k=5):
+    """질문과 관련된 청크 검색 (키워드 기반)"""
+    try:
+        # 검색 쿼리 준비
+        query_words = set(re.findall(r'\w+', query.lower()))
+        
+        # 청크 조회
+        query_obj = DocumentChunk.query.join(UploadedFile)
+        
+        if file_ids:
+            query_obj = query_obj.filter(UploadedFile.id.in_(file_ids))
+        
+        if model_name:
+            query_obj = query_obj.filter(UploadedFile.model_name == model_name)
+        
+        all_chunks = query_obj.all()
+        
+        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))
+        
+        # 점수 순으로 정렬하고 상위 k개 선택
+        scored_chunks.sort(key=lambda x: x[0], reverse=True)
+        top_chunks = [chunk for _, chunk in scored_chunks[:top_k]]
+        
+        return top_chunks
+    except Exception as e:
+        print(f"청크 검색 오류: {str(e)}")
+        return []
+
+@main_bp.route('/login', methods=['GET', 'POST'])
+def login():
+    """로그인 페이지"""
+    if current_user.is_authenticated:
+        # 관리자인 경우 관리자 페이지로 리다이렉트
+        if current_user.is_admin:
+            return redirect(url_for('main.admin'))
+        return redirect(url_for('main.index'))
+    
+    if request.method == 'POST':
+        username = request.form.get('username', '').strip()
+        password = request.form.get('password', '')
+        
+        if not username or not password:
+            flash('사용자명과 비밀번호를 입력해주세요.', 'error')
+            return render_template('login.html')
+        
+        user = User.query.filter_by(username=username).first()
+        
+        if user and user.check_password(password) and user.is_active:
+            login_user(user)
+            user.last_login = datetime.utcnow()
+            db.session.commit()
+            next_page = request.args.get('next')
+            # 관리자인 경우 관리자 페이지로 리다이렉트
+            if user.is_admin:
+                return redirect(next_page) if next_page else redirect(url_for('main.admin'))
+            return redirect(next_page) if next_page else redirect(url_for('main.index'))
+        else:
+            flash('사용자명 또는 비밀번호가 올바르지 않습니다.', 'error')
+    
+    return render_template('login.html')
+
+@main_bp.route('/logout')
+@login_required
+def logout():
+    """로그아웃"""
+    logout_user()
+    flash('로그아웃되었습니다.', 'info')
+    return redirect(url_for('main.login'))
+
 @main_bp.route('/')
+@login_required
 def index():
     return render_template('index.html')
 
+@main_bp.route('/admin')
+@admin_required
+def admin():
+    """관리자 페이지"""
+    users = User.query.order_by(User.created_at.desc()).all()
+    return render_template('admin.html', users=users)
+
+@main_bp.route('/admin/messages')
+@admin_required
+def admin_messages():
+    """관리자 메시지 확인 페이지"""
+    return render_template('admin_messages.html')
+
+@main_bp.route('/api/admin/users', methods=['GET'])
+@admin_required
+def get_users():
+    """사용자 목록 API"""
+    try:
+        users = User.query.order_by(User.created_at.desc()).all()
+        return jsonify({
+            'users': [user.to_dict() for user in users]
+        }), 200
+    except Exception as e:
+        return jsonify({'error': f'사용자 목록 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/users', methods=['POST'])
+@admin_required
+def create_user():
+    """사용자 생성 API"""
+    try:
+        data = request.json
+        username = data.get('username', '').strip()
+        nickname = data.get('nickname', '').strip()
+        password = data.get('password', '')
+        is_admin = data.get('is_admin', False)
+        
+        if not username or not password:
+            return jsonify({'error': '사용자명과 비밀번호를 입력해주세요.'}), 400
+        
+        if User.query.filter_by(username=username).first():
+            return jsonify({'error': '이미 존재하는 사용자명입니다.'}), 400
+        
+        user = User(username=username, nickname=nickname if nickname else None, is_admin=is_admin, is_active=True)
+        user.set_password(password)
+        db.session.add(user)
+        db.session.commit()
+        
+        return jsonify({
+            'message': '사용자가 성공적으로 생성되었습니다.',
+            'user': user.to_dict()
+        }), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'사용자 생성 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/users/<int:user_id>', methods=['PUT'])
+@admin_required
+def update_user(user_id):
+    """사용자 정보 수정 API"""
+    try:
+        user = User.query.get_or_404(user_id)
+        data = request.json
+        
+        # 자기 자신의 관리자 권한을 제거하는 것은 방지
+        if user_id == current_user.id and data.get('is_admin') == False:
+            return jsonify({'error': '자기 자신의 관리자 권한을 제거할 수 없습니다.'}), 400
+        
+        if 'username' in data:
+            new_username = data['username'].strip()
+            if new_username != user.username:
+                if User.query.filter_by(username=new_username).first():
+                    return jsonify({'error': '이미 존재하는 사용자명입니다.'}), 400
+                user.username = new_username
+        
+        if 'nickname' in data:
+            user.nickname = data['nickname'].strip() if data['nickname'] else None
+        
+        if 'password' in data and data['password']:
+            user.set_password(data['password'])
+        
+        if 'is_admin' in data:
+            user.is_admin = data['is_admin']
+        
+        if 'is_active' in data:
+            user.is_active = data['is_active']
+        
+        db.session.commit()
+        
+        return jsonify({
+            'message': '사용자 정보가 성공적으로 수정되었습니다.',
+            'user': user.to_dict()
+        }), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'사용자 정보 수정 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/messages', methods=['GET'])
+@admin_required
+def get_all_messages():
+    """전체 메시지 조회 (관리자용)"""
+    try:
+        user_id = request.args.get('user_id', type=int)
+        session_id = request.args.get('session_id', type=int)
+        page = request.args.get('page', 1, type=int)
+        per_page = request.args.get('per_page', 50, type=int)
+        
+        query = ChatMessage.query.join(ChatSession)
+        
+        if user_id:
+            query = query.filter(ChatSession.user_id == user_id)
+        if session_id:
+            query = query.filter(ChatMessage.session_id == session_id)
+        
+        messages = query.order_by(ChatMessage.created_at.desc())\
+            .paginate(page=page, per_page=per_page, error_out=False)
+        
+        return jsonify({
+            'messages': [msg.to_dict() for msg in messages.items],
+            'total': messages.total,
+            'pages': messages.pages,
+            'current_page': page
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'메시지 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/sessions', methods=['GET'])
+@admin_required
+def get_all_sessions():
+    """전체 대화 세션 조회 (관리자용)"""
+    try:
+        user_id = request.args.get('user_id', type=int)
+        page = request.args.get('page', 1, type=int)
+        per_page = request.args.get('per_page', 50, type=int)
+        
+        query = ChatSession.query
+        
+        if user_id:
+            query = query.filter(ChatSession.user_id == user_id)
+        
+        sessions = query.order_by(ChatSession.updated_at.desc())\
+            .paginate(page=page, per_page=per_page, error_out=False)
+        
+        sessions_data = []
+        for session in sessions.items:
+            session_dict = session.to_dict()
+            session_dict['username'] = session.user.username if session.user else 'Unknown'
+            session_dict['nickname'] = session.user.nickname if session.user else None
+            sessions_data.append(session_dict)
+        
+        return jsonify({
+            'sessions': sessions_data,
+            'total': sessions.total,
+            'pages': sessions.pages,
+            'current_page': page
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'대화 세션 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/users/<int:user_id>', methods=['DELETE'])
+@admin_required
+def delete_user(user_id):
+    """사용자 삭제 API"""
+    try:
+        user = User.query.get_or_404(user_id)
+        
+        # 자기 자신을 삭제하는 것은 방지
+        if user_id == current_user.id:
+            return jsonify({'error': '자기 자신을 삭제할 수 없습니다.'}), 400
+        
+        db.session.delete(user)
+        db.session.commit()
+        
+        return jsonify({'message': '사용자가 성공적으로 삭제되었습니다.'}), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'사용자 삭제 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/ollama/models', methods=['GET'])
+@login_required
+def get_ollama_models():
+    """Ollama에서 사용 가능한 모델 목록 가져오기"""
+    try:
+        response = requests.get(f'{OLLAMA_BASE_URL}/api/tags', timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            models = [{'name': model['name']} for model in data.get('models', [])]
+            return jsonify({'models': models})
+        else:
+            return jsonify({'error': 'Ollama 서버에 연결할 수 없습니다.', 'models': []}), 500
+    except requests.exceptions.ConnectionError:
+        return jsonify({'error': 'Ollama 서버에 연결할 수 없습니다. Ollama가 실행 중인지 확인하세요.', 'models': []}), 503
+    except requests.exceptions.Timeout:
+        return jsonify({'error': 'Ollama 서버 응답 시간이 초과되었습니다.', 'models': []}), 504
+    except Exception as e:
+        return jsonify({'error': f'모델 목록을 가져오는 중 오류가 발생했습니다: {str(e)}', 'models': []}), 500
+
+@main_bp.route('/api/chat', methods=['POST'])
+@login_required
+def chat():
+    """채팅 API 엔드포인트"""
+    try:
+        data = request.json
+        message = data.get('message', '')
+        model = data.get('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:
+            try:
+                # RAG: 질문과 관련된 청크 검색
+                context = ""
+                use_rag = True  # RAG 사용 여부
+                
+                if use_rag:
+                    # 관련 청크 검색
+                    relevant_chunks = search_relevant_chunks(
+                        query=message,
+                        file_ids=file_ids if file_ids else None,
+                        model_name=model,
+                        top_k=5
+                    )
+                    
+                    if relevant_chunks:
+                        context_parts = []
+                        seen_files = set()
+                        
+                        for chunk in relevant_chunks:
+                            file = chunk.file
+                            if file.original_filename not in seen_files:
+                                seen_files.add(file.original_filename)
+                            
+                            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"
+                    else:
+                        # RAG 검색 결과가 없으면 기존 방식 사용
+                        use_rag = False
+                
+                # RAG 검색 결과가 없거나 비활성화된 경우 기존 방식 사용
+                if not context and not use_rag:
+                    if file_ids:
+                        # 선택한 파일 ID들로 파일 조회
+                        uploaded_files = UploadedFile.query.filter(
+                            UploadedFile.id.in_(file_ids),
+                            UploadedFile.model_name == model
+                        ).all()
+                    else:
+                        # 파일 ID가 없으면 해당 모델의 모든 파일 사용 (기존 동작)
+                        uploaded_files = UploadedFile.query.filter_by(model_name=model).all()
+                    
+                    if uploaded_files:
+                        context_parts = []
+                        for file in uploaded_files:
+                            try:
+                                if os.path.exists(file.file_path):
+                                    encoding = 'utf-8'
+                                    try:
+                                        with open(file.file_path, 'r', encoding=encoding) as f:
+                                            file_content = f.read()
+                                    except UnicodeDecodeError:
+                                        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] + "..."
+                                    
+                                    context_parts.append(f"[{file.original_filename}]\n{file_content}")
+                            except Exception as e:
+                                print(f"파일 읽기 오류 ({file.original_filename}): {str(e)}")
+                                continue
+                        
+                        if context_parts:
+                            context = "\n\n".join(context_parts)
+                            context = f"다음은 학습된 웹소설 내용입니다:\n\n{context}\n\n위 내용을 참고하여 다음 질문에 답변해주세요:\n\n"
+                
+                # 프롬프트 구성
+                full_prompt = context + message if context else message
+                
+                # Ollama API 호출
+                ollama_response = requests.post(
+                    f'{OLLAMA_BASE_URL}/api/generate',
+                    json={
+                        'model': model,
+                        'prompt': full_prompt,
+                        'stream': False
+                    },
+                    timeout=120  # 파일이 많을 수 있으므로 타임아웃 증가
+                )
+                
+                if ollama_response.status_code == 200:
+                    ollama_data = ollama_response.json()
+                    response_text = ollama_data.get('response', '응답을 생성할 수 없습니다.')
+                    
+                    # 대화 세션에 메시지 저장
+                    session_id = data.get('session_id')
+                    if session_id:
+                        try:
+                            session = ChatSession.query.filter_by(
+                                id=session_id,
+                                user_id=current_user.id
+                            ).first()
+                            
+                            if session:
+                                # 사용자 메시지 저장
+                                user_msg = ChatMessage(
+                                    session_id=session_id,
+                                    role='user',
+                                    content=message
+                                )
+                                db.session.add(user_msg)
+                                
+                                # AI 응답 저장
+                                ai_msg = ChatMessage(
+                                    session_id=session_id,
+                                    role='ai',
+                                    content=response_text
+                                )
+                                db.session.add(ai_msg)
+                                
+                                session.updated_at = datetime.utcnow()
+                                db.session.commit()
+                        except Exception as e:
+                            print(f"메시지 저장 오류: {str(e)}")
+                            db.session.rollback()
+                    
+                    return jsonify({'response': response_text, 'session_id': session_id})
+                else:
+                    error_msg = f'Ollama 서버 오류: {ollama_response.status_code}'
+                    return jsonify({'error': error_msg}), ollama_response.status_code
+                    
+            except requests.exceptions.ConnectionError:
+                return jsonify({'error': 'Ollama 서버에 연결할 수 없습니다. Ollama가 실행 중인지 확인하세요.'}), 503
+            except requests.exceptions.Timeout:
+                return jsonify({'error': '응답 시간이 초과되었습니다. 더 짧은 메시지를 시도해보세요.'}), 504
+            except Exception as e:
+                return jsonify({'error': f'Ollama 통신 중 오류가 발생했습니다: {str(e)}'}), 500
+        else:
+            # 모델이 선택되지 않은 경우 기본 응답
+            response_text = f"안녕하세요! '{message}'에 대한 답변을 준비 중입니다.\n\n좌측 하단에서 로컬 AI 모델을 선택하면 더 정확한 답변을 제공할 수 있습니다."
+            return jsonify({'response': response_text})
+            
+    except Exception as e:
+        return jsonify({'error': f'채팅 처리 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/upload', methods=['POST'])
+@login_required
+def upload_file():
+    """웹소설 파일 업로드"""
+    try:
+        ensure_upload_folder()
+        
+        if 'file' not in request.files:
+            return jsonify({'error': '파일이 없습니다.'}), 400
+        
+        file = request.files['file']
+        model_name = request.form.get('model_name', '')
+        
+        if file.filename == '':
+            return jsonify({'error': '파일명이 없습니다.'}), 400
+        
+        if not allowed_file(file.filename):
+            return jsonify({'error': f'허용되지 않은 파일 형식입니다. 허용 형식: {", ".join(ALLOWED_EXTENSIONS)}'}), 400
+        
+        # 안전한 파일명 생성
+        original_filename = file.filename
+        filename = secure_filename(original_filename)
+        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)
+        
+        # 데이터베이스에 저장
+        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:
+                    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)}")
+        
+        db.session.commit()
+        
+        return jsonify({
+            'message': '파일이 성공적으로 업로드되었습니다.',
+            'file': uploaded_file.to_dict()
+        }), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'파일 업로드 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/files', methods=['GET'])
+@login_required
+def get_files():
+    """업로드된 파일 목록 조회"""
+    try:
+        model_name = request.args.get('model_name', None)
+        
+        query = UploadedFile.query
+        if model_name:
+            query = query.filter_by(model_name=model_name)
+        
+        files = query.order_by(UploadedFile.uploaded_at.desc()).all()
+        
+        return jsonify({
+            'files': [file.to_dict() for file in files]
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'파일 목록 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@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)
+        
+        # 관련 청크도 삭제 (CASCADE로 자동 삭제되지만 명시적으로 처리)
+        DocumentChunk.query.filter_by(file_id=file_id).delete()
+        
+        # 데이터베이스에서 삭제
+        db.session.delete(file)
+        db.session.commit()
+        
+        return jsonify({'message': '파일이 성공적으로 삭제되었습니다.'}), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'파일 삭제 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/files/<int:file_id>/content', methods=['GET'])
+@login_required
+def get_file_content(file_id):
+    """업로드된 파일 내용 조회"""
+    try:
+        file = UploadedFile.query.get_or_404(file_id)
+        
+        if not os.path.exists(file.file_path):
+            return jsonify({'error': '파일을 찾을 수 없습니다.'}), 404
+        
+        # 텍스트 파일 읽기
+        encoding = 'utf-8'
+        try:
+            with open(file.file_path, 'r', encoding=encoding) as f:
+                content = f.read()
+        except UnicodeDecodeError:
+            # UTF-8로 읽을 수 없으면 다른 인코딩 시도
+            with open(file.file_path, 'r', encoding='cp949') as f:
+                content = f.read()
+        
+        return jsonify({
+            'content': content,
+            'filename': file.original_filename
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'파일 내용 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/chat/sessions', methods=['GET'])
+@login_required
+def get_chat_sessions():
+    """사용자의 대화 세션 목록 조회 (최근 20개만 표시)"""
+    try:
+        sessions = ChatSession.query.filter_by(user_id=current_user.id)\
+            .order_by(ChatSession.updated_at.desc())\
+            .limit(20).all()
+        
+        return jsonify({
+            'sessions': [session.to_dict() for session in sessions]
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'대화 세션 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/chat/sessions', methods=['POST'])
+@login_required
+def create_chat_session():
+    """새 대화 세션 생성"""
+    try:
+        data = request.json
+        title = data.get('title', '새 대화')
+        model_name = data.get('model_name', None)
+        
+        session = ChatSession(
+            user_id=current_user.id,
+            title=title,
+            model_name=model_name
+        )
+        db.session.add(session)
+        db.session.commit()
+        
+        return jsonify({
+            'message': '대화 세션이 생성되었습니다.',
+            'session': session.to_dict()
+        }), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'대화 세션 생성 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/chat/sessions/<int:session_id>', methods=['GET'])
+@login_required
+def get_chat_session(session_id):
+    """대화 세션 상세 조회 (메시지 포함)"""
+    try:
+        session = ChatSession.query.filter_by(
+            id=session_id,
+            user_id=current_user.id
+        ).first_or_404()
+        
+        session_dict = session.to_dict()
+        session_dict['messages'] = [msg.to_dict() for msg in session.messages]
+        
+        return jsonify({'session': session_dict}), 200
+        
+    except Exception as e:
+        return jsonify({'error': f'대화 세션 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/chat/sessions/<int:session_id>', methods=['PUT'])
+@login_required
+def update_chat_session(session_id):
+    """대화 세션 수정 (제목 등)"""
+    try:
+        session = ChatSession.query.filter_by(
+            id=session_id,
+            user_id=current_user.id
+        ).first_or_404()
+        
+        data = request.json
+        if 'title' in data:
+            session.title = data['title']
+        
+        session.updated_at = datetime.utcnow()
+        db.session.commit()
+        
+        return jsonify({
+            'message': '대화 세션이 수정되었습니다.',
+            'session': session.to_dict()
+        }), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'대화 세션 수정 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/chat/sessions/<int:session_id>', methods=['DELETE'])
+@login_required
+def delete_chat_session(session_id):
+    """대화 세션 삭제"""
+    try:
+        session = ChatSession.query.filter_by(
+            id=session_id,
+            user_id=current_user.id
+        ).first_or_404()
+        
+        db.session.delete(session)
+        db.session.commit()
+        
+        return jsonify({'message': '대화 세션이 삭제되었습니다.'}), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'대화 세션 삭제 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/chat/sessions/<int:session_id>/messages', methods=['POST'])
+@login_required
+def add_chat_message(session_id):
+    """대화 메시지 추가"""
+    try:
+        session = ChatSession.query.filter_by(
+            id=session_id,
+            user_id=current_user.id
+        ).first_or_404()
+        
+        data = request.json
+        role = data.get('role', 'user')
+        content = data.get('content', '')
+        
+        if not content:
+            return jsonify({'error': '메시지 내용이 필요합니다.'}), 400
+        
+        message = ChatMessage(
+            session_id=session_id,
+            role=role,
+            content=content
+        )
+        db.session.add(message)
+        
+        # 세션 제목 업데이트 (첫 사용자 메시지인 경우)
+        if not session.title or session.title == '새 대화':
+            if role == 'user':
+                title = content[:30] + '...' if len(content) > 30 else content
+                session.title = title
+        
+        session.updated_at = datetime.utcnow()
+        db.session.commit()
+        
+        return jsonify({
+            'message': '메시지가 추가되었습니다.',
+            'chat_message': message.to_dict()
+        }), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'메시지 추가 중 오류가 발생했습니다: {str(e)}'}), 500
+

migrate_db.py

@@ -0,0 +1,54 @@
+"""
+데이터베이스 마이그레이션 스크립트
+nickname 컬럼을 추가합니다.
+"""
+import sqlite3
+import os
+from pathlib import Path
+
+# 데이터베이스 경로
+db_path = Path(__file__).parent / 'instance' / 'finance_analysis.db'
+
+def migrate_database():
+    """데이터베이스에 nickname 컬럼 추가"""
+    if not db_path.exists():
+        print(f"데이터베이스 파일이 없습니다: {db_path}")
+        print("앱을 실행하면 자동으로 생성됩니다.")
+        return
+    
+    try:
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        
+        # user 테이블에 nickname 컬럼이 있는지 확인
+        cursor.execute("PRAGMA table_info(user)")
+        columns = [column[1] for column in cursor.fetchall()]
+        
+        if 'nickname' in columns:
+            print("nickname 컬럼이 이미 존재합니다.")
+            conn.close()
+            return
+        
+        # nickname 컬럼 추가
+        print("nickname 컬럼을 추가하는 중...")
+        cursor.execute("ALTER TABLE user ADD COLUMN nickname VARCHAR(80)")
+        conn.commit()
+        print("nickname 컬럼이 성공적으로 추가되었습니다.")
+        
+        conn.close()
+        
+    except sqlite3.OperationalError as e:
+        print(f"오류 발생: {e}")
+        if "duplicate column name" in str(e).lower():
+            print("nickname 컬럼이 이미 존재합니다.")
+        else:
+            raise
+    except Exception as e:
+        print(f"예상치 못한 오류: {e}")
+        raise
+
+if __name__ == '__main__':
+    print("데이터베이스 마이그레이션 시작...")
+    migrate_database()
+    print("마이그레이션 완료!")
+

requirements.txt

@@ -1,4 +1,8 @@
 Flask==3.0.0
 flask-sqlalchemy==3.1.1
+flask-login==0.6.3
 python-dotenv==1.0.0
+requests==2.31.0
+werkzeug==3.0.1
+
 

run.py

@@ -11,5 +11,11 @@ from app import create_app
 app = create_app()
 
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5000, debug=True)
+    try:
+        print(f"[{__name__}] 서버 시작: http://0.0.0.0:5001")
+        app.run(host='0.0.0.0', port=5001, debug=True, use_reloader=False)
+    except Exception as e:
+        print(f"서버 시작 오류: {e}")
+        import traceback
+        traceback.print_exc()
 

start_server.bat

@@ -0,0 +1,10 @@
+@echo off
+chcp 65001 >nul
+cd /d "%~dp0"
+:start
+echo [%date% %time%] 서버 시작 중...
+python run.py
+echo [%date% %time%] 서버가 종료되었습니다. 5초 후 재시작합니다...
+timeout /t 5 /nobreak >nul
+goto start
+

start_server.ps1

@@ -0,0 +1,29 @@
+# 서버 자동 재시작 스크립트
+$ErrorActionPreference = "Continue"
+$scriptPath = Split-Path -Parent $MyInvocation.MyCommand.Path
+Set-Location $scriptPath
+
+function Start-Server {
+    Write-Host "[$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')] 서버 시작 중..." -ForegroundColor Green
+    
+    $process = Start-Process -FilePath "python" -ArgumentList "run.py" -PassThru -NoNewWindow -Wait
+    
+    if ($process.ExitCode -ne 0) {
+        Write-Host "[$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')] 서버가 종료되었습니다. 5초 후 재시작합니다..." -ForegroundColor Yellow
+        Start-Sleep -Seconds 5
+        Start-Server
+    }
+}
+
+# 무한 루프로 서버 실행
+while ($true) {
+    try {
+        Start-Server
+    }
+    catch {
+        Write-Host "[$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')] 오류 발생: $_" -ForegroundColor Red
+        Write-Host "5초 후 재시작합니다..." -ForegroundColor Yellow
+        Start-Sleep -Seconds 5
+    }
+}
+

start_server_background.ps1

@@ -0,0 +1,87 @@
+# 백그라운드에서 서버를 계속 실행하는 스크립트
+$ErrorActionPreference = "Continue"
+$scriptPath = Split-Path -Parent $MyInvocation.MyCommand.Path
+Set-Location $scriptPath
+
+# 로그 파일 경로
+$logFile = Join-Path $scriptPath "server.log"
+
+function Write-Log {
+    param([string]$Message)
+    $timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
+    $logMessage = "[$timestamp] $Message"
+    Write-Host $logMessage
+    Add-Content -Path $logFile -Value $logMessage
+}
+
+function Start-ServerProcess {
+    Write-Log "서버 프로세스 시작 중..."
+    
+    $processInfo = New-Object System.Diagnostics.ProcessStartInfo
+    $processInfo.FileName = "python"
+    $processInfo.Arguments = "run.py"
+    $processInfo.WorkingDirectory = $scriptPath
+    $processInfo.UseShellExecute = $false
+    $processInfo.RedirectStandardOutput = $true
+    $processInfo.RedirectStandardError = $true
+    $processInfo.CreateNoWindow = $true
+    
+    $process = New-Object System.Diagnostics.Process
+    $process.StartInfo = $processInfo
+    
+    # 출력 리다이렉션
+    $process.add_OutputDataReceived({
+        param($sender, $e)
+        if ($e.Data) {
+            Write-Log $e.Data
+        }
+    })
+    
+    $process.add_ErrorDataReceived({
+        param($sender, $e)
+        if ($e.Data) {
+            Write-Log "ERROR: $($e.Data)"
+        }
+    })
+    
+    $process.Start() | Out-Null
+    $process.BeginOutputReadLine()
+    $process.BeginErrorReadLine()
+    
+    return $process
+}
+
+# 메인 루프
+Write-Log "=== 서버 자동 재시작 스크립트 시작 ==="
+
+while ($true) {
+    $process = $null
+    try {
+        $process = Start-ServerProcess
+        Write-Log "서버 프로세스 시작됨 (PID: $($process.Id))"
+        
+        # 프로세스가 종료될 때까지 대기
+        $process.WaitForExit()
+        
+        $exitCode = $process.ExitCode
+        Write-Log "서버 프로세스 종료됨 (Exit Code: $exitCode)"
+        
+        # 프로세스 정리
+        if (!$process.HasExited) {
+            $process.Kill()
+        }
+        $process.Dispose()
+    }
+    catch {
+        Write-Log "오류 발생: $_"
+        if ($process -and !$process.HasExited) {
+            try {
+                $process.Kill()
+            } catch {}
+        }
+    }
+    
+    Write-Log "5초 후 서버를 재시작합니다..."
+    Start-Sleep -Seconds 5
+}
+

templates/admin.html

@@ -0,0 +1,857 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>관리자 페이지 - 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;
+        }
+
+        .btn-danger {
+            background: #ea4335;
+            color: white;
+        }
+
+        .btn-danger:hover {
+            background: #c5221f;
+        }
+
+        .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;
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+
+        thead {
+            background: #f8f9fa;
+        }
+
+        th, td {
+            padding: 12px;
+            text-align: left;
+            border-bottom: 1px solid #e8eaed;
+        }
+
+        th {
+            font-weight: 500;
+            font-size: 14px;
+            color: #5f6368;
+        }
+
+        td {
+            font-size: 14px;
+        }
+
+        .badge {
+            display: inline-block;
+            padding: 4px 8px;
+            border-radius: 4px;
+            font-size: 12px;
+            font-weight: 500;
+        }
+
+        .badge-admin {
+            background: #e8f0fe;
+            color: #1967d2;
+        }
+
+        .badge-user {
+            background: #e8f5e9;
+            color: #137333;
+        }
+
+        .badge-inactive {
+            background: #fce8e6;
+            color: #c5221f;
+        }
+
+        .modal {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.5);
+            z-index: 1000;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .modal.active {
+            display: flex;
+        }
+
+        .modal-content {
+            background: white;
+            border-radius: 8px;
+            padding: 24px;
+            width: 90%;
+            max-width: 500px;
+            max-height: 90vh;
+            overflow-y: auto;
+        }
+
+        .modal-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+
+        .modal-title {
+            font-size: 20px;
+            font-weight: 500;
+        }
+
+        .modal-close {
+            background: none;
+            border: none;
+            font-size: 24px;
+            cursor: pointer;
+            color: #5f6368;
+        }
+
+        .form-group {
+            margin-bottom: 16px;
+        }
+
+        .form-group label {
+            display: block;
+            font-size: 14px;
+            font-weight: 500;
+            margin-bottom: 8px;
+        }
+
+        .form-group input,
+        .form-group select {
+            width: 100%;
+            padding: 10px 12px;
+            border: 1px solid #dadce0;
+            border-radius: 6px;
+            font-size: 14px;
+            font-family: inherit;
+        }
+
+        .form-group input:focus,
+        .form-group select:focus {
+            outline: none;
+            border-color: #1a73e8;
+            box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.1);
+        }
+
+        .form-group-checkbox {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .form-group-checkbox input {
+            width: auto;
+        }
+
+        .modal-actions {
+            display: flex;
+            gap: 8px;
+            justify-content: flex-end;
+            margin-top: 24px;
+        }
+
+        .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;
+        }
+
+        /* 파일 업로드 영역 */
+        .file-upload-section {
+            margin-top: 24px;
+        }
+
+        .file-upload-input-wrapper {
+            position: relative;
+            margin-bottom: 12px;
+            border: 2px dashed #dadce0;
+            border-radius: 8px;
+            padding: 20px;
+            text-align: center;
+            background: #f8f9fa;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+
+        .file-upload-input-wrapper:hover {
+            border-color: #1a73e8;
+            background: #e8f0fe;
+        }
+
+        .file-upload-input-wrapper.dragover {
+            border-color: #1a73e8;
+            background: #e8f0fe;
+        }
+
+        .file-upload-input-wrapper input[type="file"] {
+            position: absolute;
+            opacity: 0;
+            width: 100%;
+            height: 100%;
+            cursor: pointer;
+        }
+
+        .file-upload-label {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 8px;
+            color: #5f6368;
+            font-size: 14px;
+        }
+
+        .file-upload-label svg {
+            width: 32px;
+            height: 32px;
+        }
+
+        .file-upload-status {
+            font-size: 12px;
+            margin-top: 8px;
+            min-height: 16px;
+        }
+
+        .file-upload-status.success {
+            color: #137333;
+        }
+
+        .file-upload-status.error {
+            color: #c5221f;
+        }
+
+        .files-table {
+            margin-top: 16px;
+        }
+
+        .file-size {
+            color: #5f6368;
+            font-size: 12px;
+        }
+
+        .file-actions {
+            display: flex;
+            gap: 4px;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <div class="header-title">
+            <span>🤖</span>
+            <span>SOY NV 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_messages') }}" 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>사용자 관리</h1>
+            <p>시스템 사용자를 관리할 수 있습니다.</p>
+        </div>
+
+        <div id="alertContainer"></div>
+
+        <div class="card">
+            <div class="card-header">
+                <div class="card-title">사용자 목록</div>
+                <button class="btn btn-primary" onclick="openCreateModal()">새 사용자 추가</button>
+            </div>
+
+            <table>
+                <thead>
+                    <tr>
+                        <th>ID</th>
+                        <th>사용자명</th>
+                        <th>닉네임</th>
+                        <th>권한</th>
+                        <th>상태</th>
+                        <th>생성일</th>
+                        <th>마지막 로그인</th>
+                        <th>작업</th>
+                    </tr>
+                </thead>
+                <tbody id="usersTableBody">
+                    {% for user in users %}
+                    <tr data-user-id="{{ user.id }}">
+                        <td>{{ user.id }}</td>
+                        <td>{{ user.username }}</td>
+                        <td>{{ user.nickname or '-' }}</td>
+                        <td>
+                            {% if user.is_admin %}
+                                <span class="badge badge-admin">관리자</span>
+                            {% else %}
+                                <span class="badge badge-user">일반 사용자</span>
+                            {% endif %}
+                        </td>
+                        <td>
+                            {% if user.is_active %}
+                                <span class="badge badge-user">활성</span>
+                            {% else %}
+                                <span class="badge badge-inactive">비활성</span>
+                            {% endif %}
+                        </td>
+                        <td>{{ user.created_at.strftime('%Y-%m-%d %H:%M') if user.created_at else '-' }}</td>
+                        <td>{{ user.last_login.strftime('%Y-%m-%d %H:%M') if user.last_login else '-' }}</td>
+                        <td>
+                            <button class="btn btn-secondary" onclick="openEditModal({{ user.id }}, '{{ user.username }}', '{{ user.nickname or '' }}', {{ user.is_admin|lower }}, {{ user.is_active|lower }})" style="padding: 4px 8px; font-size: 12px;">수정</button>
+                            {% if user.id != current_user.id %}
+                            <button class="btn btn-danger" onclick="deleteUser({{ user.id }})" style="padding: 4px 8px; font-size: 12px;">삭제</button>
+                            {% endif %}
+                        </td>
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+
+        <!-- 파일 관리 섹션 -->
+        <div class="card file-upload-section">
+            <div class="card-header">
+                <div class="card-title">웹소설 학습 파일 관리</div>
+            </div>
+
+            <!-- 파일 업로드 -->
+            <div class="file-upload-input-wrapper" id="fileUploadWrapper">
+                <input type="file" id="fileInput" accept=".txt,.md,.pdf,.docx,.epub" multiple>
+                <label class="file-upload-label">
+                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4M17 8l-5-5-5 5M12 3v12"/>
+                    </svg>
+                    <span>파일을 선택하거나 드래그하세요</span>
+                    <small style="color: #5f6368;">(여러 파일 선택 가능)</small>
+                </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>
+
+            <!-- 업로드 규칙 안내 -->
+            <div style="margin-top: 20px; padding: 16px; background: #f8f9fa; border-radius: 8px; border-left: 4px solid #1a73e8;">
+                <div style="font-size: 14px; font-weight: 500; margin-bottom: 12px; color: #202124;">
+                    📋 파일 업로드 규칙
+                </div>
+                <div style="font-size: 13px; color: #5f6368; line-height: 1.8;">
+                    <div style="margin-bottom: 8px;">
+                        <strong>허용 파일 형식:</strong> .txt, .md, .pdf, .docx, .epub
+                    </div>
+                    <div style="margin-bottom: 8px;">
+                        <strong>파일 인코딩:</strong> UTF-8 또는 CP949 (한글 파일의 경우)
+                    </div>
+                    <div style="margin-bottom: 8px;">
+                        <strong>권장 사항:</strong>
+                        <ul style="margin: 8px 0 0 20px; padding: 0;">
+                            <li>텍스트 파일(.txt, .md)은 UTF-8 인코딩을 권장합니다</li>
+                            <li>파일명에 특수문자 사용을 자제해주세요</li>
+                            <li>업로드 전에 AI 모델을 먼저 선택해주세요</li>
+                            <li>여러 파일을 한 번에 업로드할 수 있습니다</li>
+                        </ul>
+                    </div>
+                    <div style="margin-top: 12px; padding-top: 12px; border-top: 1px solid #dadce0; font-size: 12px; color: #80868b;">
+                        ⚠️ 업로드된 파일은 선택한 AI 모델과 연결되어 학습 데이터로 사용됩니다.
+                    </div>
+                </div>
+            </div>
+
+            <!-- 파일 목록 -->
+            <div class="files-table">
+                <table style="margin-top: 16px;">
+                    <thead>
+                        <tr>
+                            <th>파일명</th>
+                            <th>모델</th>
+                            <th>크기</th>
+                            <th>업로드일</th>
+                            <th>작업</th>
+                        </tr>
+                    </thead>
+                    <tbody id="filesTableBody">
+                        <tr>
+                            <td colspan="5" style="text-align: center; padding: 20px; color: #5f6368;">파일 목록을 불러오는 중...</td>
+                        </tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+
+    <!-- 사용자 생성/수정 모달 -->
+    <div id="userModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <div class="modal-title" id="modalTitle">새 사용자 추가</div>
+                <button class="modal-close" onclick="closeModal()">&times;</button>
+            </div>
+            <form id="userForm" onsubmit="saveUser(event)">
+                <input type="hidden" id="userId" name="user_id">
+                <div class="form-group">
+                    <label for="username">사용자명</label>
+                    <input type="text" id="username" name="username" required>
+                </div>
+                <div class="form-group">
+                    <label for="nickname">닉네임</label>
+                    <input type="text" id="nickname" name="nickname" placeholder="선택사항">
+                </div>
+                <div class="form-group">
+                    <label for="password">비밀번호</label>
+                    <input type="password" id="password" name="password" id="passwordInput">
+                    <small style="color: #5f6368; font-size: 12px;">수정 시 비밀번호를 변경하지 않으려면 비워두세요.</small>
+                </div>
+                <div class="form-group-checkbox">
+                    <input type="checkbox" id="isAdmin" name="is_admin">
+                    <label for="isAdmin">관리자 권한</label>
+                </div>
+                <div class="form-group-checkbox">
+                    <input type="checkbox" id="isActive" name="is_active" checked>
+                    <label for="isActive">활성 상태</label>
+                </div>
+                <div class="modal-actions">
+                    <button type="button" class="btn btn-secondary" onclick="closeModal()">취소</button>
+                    <button type="submit" class="btn btn-primary">저장</button>
+                </div>
+            </form>
+        </div>
+    </div>
+
+    <script>
+        let currentEditUserId = null;
+
+        function showAlert(message, type = 'success') {
+            const container = document.getElementById('alertContainer');
+            container.innerHTML = `<div class="alert ${type}">${message}</div>`;
+            setTimeout(() => {
+                container.innerHTML = '';
+            }, 5000);
+        }
+
+        function openCreateModal() {
+            currentEditUserId = null;
+            document.getElementById('modalTitle').textContent = '새 사용자 추가';
+            document.getElementById('userForm').reset();
+            document.getElementById('userId').value = '';
+            document.getElementById('password').required = true;
+            document.getElementById('isActive').checked = true;
+            document.getElementById('userModal').classList.add('active');
+        }
+
+        function openEditModal(userId, username, nickname, isAdmin, isActive) {
+            currentEditUserId = userId;
+            document.getElementById('modalTitle').textContent = '사용자 수정';
+            document.getElementById('userId').value = userId;
+            document.getElementById('username').value = username;
+            document.getElementById('nickname').value = nickname || '';
+            document.getElementById('password').value = '';
+            document.getElementById('password').required = false;
+            document.getElementById('isAdmin').checked = isAdmin;
+            document.getElementById('isActive').checked = isActive;
+            document.getElementById('userModal').classList.add('active');
+        }
+
+        function closeModal() {
+            document.getElementById('userModal').classList.remove('active');
+            currentEditUserId = null;
+        }
+
+        async function saveUser(event) {
+            event.preventDefault();
+            
+            const formData = {
+                username: document.getElementById('username').value.trim(),
+                nickname: document.getElementById('nickname').value.trim(),
+                password: document.getElementById('password').value,
+                is_admin: document.getElementById('isAdmin').checked,
+                is_active: document.getElementById('isActive').checked
+            };
+
+            const userId = document.getElementById('userId').value;
+            const url = userId ? `/api/admin/users/${userId}` : '/api/admin/users';
+            const method = userId ? 'PUT' : 'POST';
+
+            if (!userId && !formData.password) {
+                showAlert('비밀번호를 입력해주세요.', 'error');
+                return;
+            }
+
+            try {
+                const response = await fetch(url, {
+                    method: method,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(formData)
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    showAlert(data.message, 'success');
+                    closeModal();
+                    setTimeout(() => {
+                        location.reload();
+                    }, 1000);
+                } else {
+                    showAlert(data.error || '오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+
+        async function deleteUser(userId) {
+            if (!confirm('정말 이 사용자를 삭제하시겠습니까?')) {
+                return;
+            }
+
+            try {
+                const response = await fetch(`/api/admin/users/${userId}`, {
+                    method: 'DELETE'
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    showAlert(data.message, 'success');
+                    setTimeout(() => {
+                        location.reload();
+                    }, 1000);
+                } else {
+                    showAlert(data.error || '삭제 중 오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+
+        // 모달 외부 클릭 시 닫기
+        document.getElementById('userModal').addEventListener('click', function(e) {
+            if (e.target === this) {
+                closeModal();
+            }
+        });
+
+        // 파일 업로드 관련
+        const fileInput = document.getElementById('fileInput');
+        const fileUploadWrapper = document.getElementById('fileUploadWrapper');
+        const fileUploadStatus = document.getElementById('fileUploadStatus');
+        const fileModelSelect = document.getElementById('fileModelSelect');
+        const filesTableBody = document.getElementById('filesTableBody');
+
+        // 모델 목록 로드
+        async function loadModelsForFiles() {
+            try {
+                const response = await fetch('/api/ollama/models');
+                const data = await response.json();
+                
+                fileModelSelect.innerHTML = '<option value="">모델을 선택하세요...</option>';
+                
+                if (data.models && data.models.length > 0) {
+                    data.models.forEach(model => {
+                        const option = document.createElement('option');
+                        option.value = model.name;
+                        option.textContent = model.name;
+                        fileModelSelect.appendChild(option);
+                    });
+                }
+            } catch (error) {
+                console.error('모델 로드 오류:', error);
+            }
+        }
+
+        // 파일 목록 로드
+        async function loadFiles() {
+            try {
+                const response = await fetch('/api/files');
+                const data = await response.json();
+                
+                filesTableBody.innerHTML = '';
+                
+                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');
+                        
+                        row.innerHTML = `
+                            <td>${escapeHtml(file.original_filename)}</td>
+                            <td>${file.model_name || '-'}</td>
+                            <td class="file-size">${fileSize}</td>
+                            <td>${uploadDate}</td>
+                            <td>
+                                <div class="file-actions">
+                                    <button class="btn btn-secondary" onclick="deleteFile(${file.id})" style="padding: 4px 8px; font-size: 12px;">삭제</button>
+                                </div>
+                            </td>
+                        `;
+                        filesTableBody.appendChild(row);
+                    });
+                } else {
+                    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);
+            }
+        }
+
+        // 파일 크기 포맷
+        function formatFileSize(bytes) {
+            if (bytes === 0) return '0 Bytes';
+            const k = 1024;
+            const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+        }
+
+        // HTML 이스케이프
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+
+        // 파일 업로드 처리
+        async function handleFileUpload(files) {
+            if (!files || files.length === 0) return;
+
+            const modelName = fileModelSelect.value;
+            if (!modelName) {
+                showAlert('먼저 AI 모델을 선택해주세요.', 'error');
+                return;
+            }
+
+            fileUploadStatus.textContent = `${files.length}개 파일 업로드 중...`;
+            fileUploadStatus.className = 'file-upload-status';
+
+            let successCount = 0;
+            let failCount = 0;
+
+            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);
+
+                try {
+                    const response = await fetch('/api/upload', {
+                        method: 'POST',
+                        body: formData
+                    });
+
+                    const data = await response.json();
+
+                    if (response.ok) {
+                        successCount++;
+                    } else {
+                        failCount++;
+                        console.error(`파일 업로드 실패 (${file.name}):`, data.error);
+                    }
+                } catch (error) {
+                    failCount++;
+                    console.error(`파일 업로드 오류 (${file.name}):`, error);
+                }
+            }
+
+            if (successCount > 0) {
+                showAlert(`${successCount}개 파일이 성공적으로 업로드되었습니다.${failCount > 0 ? ` (${failCount}개 실패)` : ''}`, 'success');
+                loadFiles();
+            } else {
+                showAlert('파일 업로드에 실패했습니다.', 'error');
+            }
+
+            fileUploadStatus.textContent = '';
+            fileInput.value = '';
+        }
+
+        // 파일 삭제
+        async function deleteFile(fileId) {
+            if (!confirm('이 파일을 삭제하시겠습니까?')) {
+                return;
+            }
+
+            try {
+                const response = await fetch(`/api/files/${fileId}`, {
+                    method: 'DELETE'
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    showAlert(data.message, 'success');
+                    loadFiles();
+                } else {
+                    showAlert(data.error || '삭제 중 오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+
+        // 파일 입력 이벤트
+        fileInput.addEventListener('change', function(e) {
+            if (e.target.files.length > 0) {
+                handleFileUpload(Array.from(e.target.files));
+            }
+        });
+
+        // 드래그 앤 드롭
+        fileUploadWrapper.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            fileUploadWrapper.classList.add('dragover');
+        });
+
+        fileUploadWrapper.addEventListener('dragleave', () => {
+            fileUploadWrapper.classList.remove('dragover');
+        });
+
+        fileUploadWrapper.addEventListener('drop', (e) => {
+            e.preventDefault();
+            fileUploadWrapper.classList.remove('dragover');
+            
+            const files = Array.from(e.dataTransfer.files);
+            if (files.length > 0) {
+                handleFileUpload(files);
+            }
+        });
+
+        // 페이지 로드 시 초기화
+        window.addEventListener('load', () => {
+            loadModelsForFiles();
+            loadFiles();
+        });
+    </script>
+</body>
+</html>
+

templates/admin_messages.html

@@ -0,0 +1,695 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>메시지 확인 - 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: 1400px;
+            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;
+        }
+
+        .filters {
+            display: flex;
+            gap: 12px;
+            margin-bottom: 20px;
+            flex-wrap: wrap;
+        }
+
+        .filter-group {
+            display: flex;
+            flex-direction: column;
+            gap: 4px;
+        }
+
+        .filter-group label {
+            font-size: 12px;
+            font-weight: 500;
+            color: #5f6368;
+        }
+
+        .filter-group select,
+        .filter-group input {
+            padding: 8px 12px;
+            border: 1px solid #dadce0;
+            border-radius: 6px;
+            font-size: 14px;
+            font-family: inherit;
+        }
+
+        .filter-group select:focus,
+        .filter-group input:focus {
+            outline: none;
+            border-color: #1a73e8;
+            box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.1);
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+
+        thead {
+            background: #f8f9fa;
+        }
+
+        th, td {
+            padding: 12px;
+            text-align: left;
+            border-bottom: 1px solid #e8eaed;
+        }
+
+        th {
+            font-weight: 500;
+            font-size: 14px;
+            color: #5f6368;
+        }
+
+        td {
+            font-size: 14px;
+        }
+
+        .message-content {
+            max-width: 500px;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+
+        .message-content-full {
+            max-width: none;
+            white-space: normal;
+            word-wrap: break-word;
+        }
+
+        .role-badge {
+            display: inline-block;
+            padding: 4px 8px;
+            border-radius: 4px;
+            font-size: 12px;
+            font-weight: 500;
+        }
+
+        .role-user {
+            background: #e8f0fe;
+            color: #1967d2;
+        }
+
+        .role-ai {
+            background: #e8f5e9;
+            color: #137333;
+        }
+
+        .pagination {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            gap: 8px;
+            margin-top: 20px;
+        }
+
+        .pagination button {
+            padding: 8px 12px;
+            border: 1px solid #dadce0;
+            background: white;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 14px;
+        }
+
+        .pagination button:hover:not(:disabled) {
+            background: #f1f3f4;
+        }
+
+        .pagination button:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        .pagination .page-info {
+            padding: 8px 12px;
+            color: #5f6368;
+        }
+
+        .modal {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.5);
+            z-index: 1000;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .modal.active {
+            display: flex;
+        }
+
+        .modal-content {
+            background: white;
+            border-radius: 8px;
+            padding: 24px;
+            width: 90%;
+            max-width: 800px;
+            max-height: 90vh;
+            overflow-y: auto;
+        }
+
+        .modal-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+
+        .modal-title {
+            font-size: 20px;
+            font-weight: 500;
+        }
+
+        .modal-close {
+            background: none;
+            border: none;
+            font-size: 24px;
+            cursor: pointer;
+            color: #5f6368;
+        }
+
+        .message-view {
+            display: flex;
+            flex-direction: column;
+            gap: 16px;
+        }
+
+        .message-item {
+            padding: 12px;
+            border-radius: 8px;
+            border-left: 4px solid;
+        }
+
+        .message-item.user {
+            background: #e8f0fe;
+            border-color: #1a73e8;
+        }
+
+        .message-item.ai {
+            background: #e8f5e9;
+            border-color: #34a853;
+        }
+
+        .message-item-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 8px;
+        }
+
+        .message-item-role {
+            font-weight: 500;
+            font-size: 14px;
+        }
+
+        .message-item-time {
+            font-size: 12px;
+            color: #5f6368;
+        }
+
+        .message-item-content {
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            line-height: 1.6;
+        }
+
+        .alert {
+            padding: 12px 16px;
+            border-radius: 6px;
+            margin-bottom: 16px;
+            font-size: 14px;
+        }
+
+        .alert.error {
+            background: #fce8e6;
+            color: #c5221f;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <div class="header-title">
+            <span>🤖</span>
+            <span>SOY NV 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.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>전체 메시지 확인</h1>
+            <p>모든 사용자의 대화 메시지를 확인할 수 있습니다.</p>
+        </div>
+
+        <div id="alertContainer"></div>
+
+        <!-- 대화 세션 목록 -->
+        <div class="card">
+            <div class="card-header">
+                <div class="card-title">대화 세션 목록</div>
+            </div>
+
+            <div class="filters">
+                <div class="filter-group">
+                    <label>사용자 필터</label>
+                    <select id="userFilter">
+                        <option value="">전체 사용자</option>
+                    </select>
+                </div>
+                <div class="filter-group">
+                    <label>검색</label>
+                    <input type="text" id="searchInput" placeholder="세션 제목 검색...">
+                </div>
+                <div class="filter-group" style="align-items: flex-end;">
+                    <button class="btn btn-primary" onclick="loadSessions()">조회</button>
+                </div>
+            </div>
+
+            <table>
+                <thead>
+                    <tr>
+                        <th>ID</th>
+                        <th>사용자</th>
+                        <th>제목</th>
+                        <th>모델</th>
+                        <th>메시지 수</th>
+                        <th>생성일</th>
+                        <th>수정일</th>
+                        <th>작업</th>
+                    </tr>
+                </thead>
+                <tbody id="sessionsTableBody">
+                    <tr>
+                        <td colspan="8" style="text-align: center; padding: 20px; color: #5f6368;">로딩 중...</td>
+                    </tr>
+                </tbody>
+            </table>
+
+            <div class="pagination" id="sessionsPagination"></div>
+        </div>
+
+        <!-- 메시지 목록 -->
+        <div class="card">
+            <div class="card-header">
+                <div class="card-title">메시지 목록</div>
+            </div>
+
+            <div class="filters">
+                <div class="filter-group">
+                    <label>세션 ID</label>
+                    <input type="number" id="sessionIdFilter" placeholder="세션 ID">
+                </div>
+                <div class="filter-group" style="align-items: flex-end;">
+                    <button class="btn btn-primary" onclick="loadMessages()">조회</button>
+                </div>
+            </div>
+
+            <table>
+                <thead>
+                    <tr>
+                        <th>ID</th>
+                        <th>세션 ID</th>
+                        <th>역할</th>
+                        <th>내용</th>
+                        <th>시간</th>
+                        <th>작업</th>
+                    </tr>
+                </thead>
+                <tbody id="messagesTableBody">
+                    <tr>
+                        <td colspan="6" style="text-align: center; padding: 20px; color: #5f6368;">세션을 선택하거나 필터를 사용하세요</td>
+                    </tr>
+                </tbody>
+            </table>
+
+            <div class="pagination" id="messagesPagination"></div>
+        </div>
+    </div>
+
+    <!-- 메시지 상세 보기 모달 -->
+    <div id="messageModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <div class="modal-title">메시지 상세</div>
+                <button class="modal-close" onclick="closeMessageModal()">&times;</button>
+            </div>
+            <div id="messageModalContent"></div>
+        </div>
+    </div>
+
+    <script>
+        let currentSessionsPage = 1;
+        let currentMessagesPage = 1;
+        let selectedSessionId = null;
+
+        function showAlert(message, type = 'error') {
+            const container = document.getElementById('alertContainer');
+            container.innerHTML = `<div class="alert ${type}">${message}</div>`;
+            setTimeout(() => {
+                container.innerHTML = '';
+            }, 5000);
+        }
+
+        // 사용자 목록 로드
+        async function loadUsers() {
+            try {
+                const response = await fetch('/api/admin/users');
+                const data = await response.json();
+                
+                const userFilter = document.getElementById('userFilter');
+                userFilter.innerHTML = '<option value="">전체 사용자</option>';
+                
+                if (data.users) {
+                    data.users.forEach(user => {
+                        const option = document.createElement('option');
+                        option.value = user.id;
+                        option.textContent = `${user.nickname || user.username} (${user.username})`;
+                        userFilter.appendChild(option);
+                    });
+                }
+            } catch (error) {
+                console.error('사용자 목록 로드 오류:', error);
+            }
+        }
+
+        // 대화 세션 목록 로드
+        async function loadSessions(page = 1) {
+            try {
+                const userId = document.getElementById('userFilter').value;
+                const search = document.getElementById('searchInput').value;
+                
+                let url = `/api/admin/sessions?page=${page}&per_page=20`;
+                if (userId) {
+                    url += `&user_id=${userId}`;
+                }
+                
+                const response = await fetch(url);
+                const data = await response.json();
+                
+                const tbody = document.getElementById('sessionsTableBody');
+                tbody.innerHTML = '';
+                
+                if (data.sessions && data.sessions.length > 0) {
+                    data.sessions.forEach(session => {
+                        const row = document.createElement('tr');
+                        const createdDate = new Date(session.created_at).toLocaleString('ko-KR');
+                        const updatedDate = new Date(session.updated_at).toLocaleString('ko-KR');
+                        
+                        // 검색 필터 적용
+                        if (search && !session.title.toLowerCase().includes(search.toLowerCase())) {
+                            return;
+                        }
+                        
+                        row.innerHTML = `
+                            <td>${session.id}</td>
+                            <td>${session.nickname || session.username || 'Unknown'}</td>
+                            <td>${session.title || '-'}</td>
+                            <td>${session.model_name || '-'}</td>
+                            <td>${session.message_count || 0}</td>
+                            <td>${createdDate}</td>
+                            <td>${updatedDate}</td>
+                            <td>
+                                <button class="btn btn-secondary" onclick="viewSessionMessages(${session.id})" style="padding: 4px 8px; font-size: 12px;">메시지 보기</button>
+                            </td>
+                        `;
+                        tbody.appendChild(row);
+                    });
+                } else {
+                    tbody.innerHTML = '<tr><td colspan="8" style="text-align: center; padding: 20px; color: #5f6368;">대화 세션이 없습니다.</td></tr>';
+                }
+                
+                // 페이지네이션
+                updateSessionsPagination(data.current_page, data.pages);
+                currentSessionsPage = data.current_page;
+                
+            } catch (error) {
+                showAlert(`대화 세션 조회 오류: ${error.message}`, 'error');
+                console.error('대화 세션 조회 오류:', error);
+            }
+        }
+
+        // 메시지 목록 로드
+        async function loadMessages(page = 1) {
+            try {
+                const sessionId = document.getElementById('sessionIdFilter').value;
+                
+                let url = `/api/admin/messages?page=${page}&per_page=50`;
+                if (sessionId) {
+                    url += `&session_id=${sessionId}`;
+                } else if (selectedSessionId) {
+                    url += `&session_id=${selectedSessionId}`;
+                }
+                
+                const response = await fetch(url);
+                const data = await response.json();
+                
+                const tbody = document.getElementById('messagesTableBody');
+                tbody.innerHTML = '';
+                
+                if (data.messages && data.messages.length > 0) {
+                    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;
+                        
+                        row.innerHTML = `
+                            <td>${msg.id}</td>
+                            <td>${msg.session_id}</td>
+                            <td><span class="role-badge role-${msg.role}">${msg.role === 'user' ? '사용자' : 'AI'}</span></td>
+                            <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>
+                            </td>
+                        `;
+                        tbody.appendChild(row);
+                    });
+                } else {
+                    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;
+                
+            } catch (error) {
+                showAlert(`메시지 조회 오류: ${error.message}`, 'error');
+                console.error('메시지 조회 오류:', error);
+            }
+        }
+
+        // 세션 메시지 보기
+        function viewSessionMessages(sessionId) {
+            selectedSessionId = sessionId;
+            document.getElementById('sessionIdFilter').value = sessionId;
+            loadMessages(1);
+        }
+
+        // 메시지 상세 보기
+        function viewMessage(messageId, role, content) {
+            const modal = document.getElementById('messageModal');
+            const modalContent = document.getElementById('messageModalContent');
+            
+            modalContent.innerHTML = `
+                <div class="message-view">
+                    <div class="message-item ${role}">
+                        <div class="message-item-header">
+                            <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>
+                </div>
+            `;
+            
+            modal.classList.add('active');
+        }
+
+        function closeMessageModal() {
+            document.getElementById('messageModal').classList.remove('active');
+        }
+
+        // 페이지네이션 업데이트
+        function updateSessionsPagination(currentPage, totalPages) {
+            const pagination = document.getElementById('sessionsPagination');
+            pagination.innerHTML = '';
+            
+            pagination.appendChild(createPaginationButton('이전', currentPage > 1, () => loadSessions(currentPage - 1)));
+            pagination.appendChild(createPaginationInfo(`${currentPage} / ${totalPages}`));
+            pagination.appendChild(createPaginationButton('다음', currentPage < totalPages, () => loadSessions(currentPage + 1)));
+        }
+
+        function updateMessagesPagination(currentPage, totalPages) {
+            const pagination = document.getElementById('messagesPagination');
+            pagination.innerHTML = '';
+            
+            pagination.appendChild(createPaginationButton('이전', currentPage > 1, () => loadMessages(currentPage - 1)));
+            pagination.appendChild(createPaginationInfo(`${currentPage} / ${totalPages}`));
+            pagination.appendChild(createPaginationButton('다음', currentPage < totalPages, () => loadMessages(currentPage + 1)));
+        }
+
+        function createPaginationButton(text, enabled, onClick) {
+            const button = document.createElement('button');
+            button.textContent = text;
+            button.disabled = !enabled;
+            if (enabled) {
+                button.onclick = onClick;
+            }
+            return button;
+        }
+
+        function createPaginationInfo(text) {
+            const span = document.createElement('span');
+            span.className = 'page-info';
+            span.textContent = text;
+            return span;
+        }
+
+        function escapeHtml(text) {
+            const div = document.createElement('div');
+            div.textContent = text;
+            return div.innerHTML;
+        }
+
+        // 모달 외부 클릭 시 닫기
+        document.getElementById('messageModal').addEventListener('click', function(e) {
+            if (e.target === this) {
+                closeMessageModal();
+            }
+        });
+
+        // 검색 엔터 키
+        document.getElementById('searchInput').addEventListener('keypress', function(e) {
+            if (e.key === 'Enter') {
+                loadSessions(1);
+            }
+        });
+
+        // 페이지 로드 시 초기화
+        window.addEventListener('load', () => {
+            loadUsers();
+            loadSessions();
+        });
+    </script>
+</body>
+</html>
+

templates/index.html

@@ -4,60 +4,1391 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>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;
         }
-        
+
+        :root {
+            --bg-primary: #ffffff;
+            --bg-secondary: #f8f9fa;
+            --bg-tertiary: #f1f3f4;
+            --text-primary: #202124;
+            --text-secondary: #5f6368;
+            --accent: #1a73e8;
+            --accent-hover: #1557b0;
+            --border: #dadce0;
+            --user-bg: #e8f0fe;
+            --ai-bg: #f1f3f4;
+            --shadow: rgba(0, 0, 0, 0.1);
+        }
+
         body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
-            background-color: #f5f5f5;
-            color: #333;
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            height: 100vh;
+            overflow: hidden;
+            display: flex;
+            flex-direction: row;
         }
-        
-        .container {
-            max-width: 1200px;
-            margin: 0 auto;
-            padding: 20px;
+
+        /* 사이드바 */
+        .sidebar {
+            width: 280px;
+            background: var(--bg-secondary);
+            border-right: 1px solid var(--border);
+            display: flex;
+            flex-direction: column;
+            height: 100vh;
+            transition: width 0.3s ease;
+            flex-shrink: 0;
         }
-        
+
+        .sidebar.collapsed {
+            width: 0;
+            overflow: hidden;
+            border-right: none;
+        }
+
+        .sidebar-header {
+            padding: 16px;
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            min-height: 64px;
+        }
+
+        .sidebar-title {
+            font-size: 18px;
+            font-weight: 500;
+            color: var(--text-primary);
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+
+        .sidebar-toggle {
+            background: none;
+            border: none;
+            padding: 8px;
+            cursor: pointer;
+            border-radius: 50%;
+            color: var(--text-secondary);
+            transition: background 0.2s;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .sidebar-toggle:hover {
+            background: var(--bg-tertiary);
+        }
+
+        .new-chat-button {
+            margin: 12px 16px;
+            padding: 12px 16px;
+            background: var(--accent);
+            color: white;
+            border: none;
+            border-radius: 24px;
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            transition: background 0.2s;
+        }
+
+        .new-chat-button:hover {
+            background: var(--accent-hover);
+        }
+
+        .new-chat-button svg {
+            width: 18px;
+            height: 18px;
+        }
+
+        .chat-history {
+            flex: 1;
+            overflow-y: auto;
+            padding: 8px;
+        }
+
+        .chat-history::-webkit-scrollbar {
+            width: 6px;
+        }
+
+        .chat-history::-webkit-scrollbar-track {
+            background: transparent;
+        }
+
+        .chat-history::-webkit-scrollbar-thumb {
+            background: var(--border);
+            border-radius: 3px;
+        }
+
+        .chat-history::-webkit-scrollbar-thumb:hover {
+            background: var(--text-secondary);
+        }
+
+        .chat-item {
+            padding: 12px 16px;
+            margin: 4px 0;
+            border-radius: 12px;
+            cursor: pointer;
+            transition: background 0.2s;
+            display: flex;
+            align-items: center;
+            gap: 12px;
+            color: var(--text-primary);
+            text-decoration: none;
+        }
+
+        .chat-item:hover {
+            background: var(--bg-tertiary);
+        }
+
+        .chat-item.active {
+            background: var(--accent);
+            color: white;
+        }
+
+        .chat-item-icon {
+            width: 20px;
+            height: 20px;
+            flex-shrink: 0;
+        }
+
+        .chat-item-title {
+            flex: 1;
+            font-size: 14px;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+
+        .chat-item-time {
+            font-size: 12px;
+            opacity: 0.7;
+            flex-shrink: 0;
+        }
+
+        .chat-item.active .chat-item-time {
+            opacity: 0.9;
+        }
+
+        /* AI 모델 선택 영역 */
+        .model-selector {
+            border-top: 1px solid var(--border);
+            padding: 16px;
+            background: var(--bg-primary);
+        }
+
+        .model-selector-label {
+            font-size: 12px;
+            font-weight: 500;
+            color: var(--text-secondary);
+            margin-bottom: 8px;
+            display: flex;
+            align-items: center;
+            gap: 6px;
+        }
+
+        .model-selector-label svg {
+            width: 16px;
+            height: 16px;
+        }
+
+        .model-select {
+            width: 100%;
+            padding: 10px 12px;
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            font-size: 14px;
+            font-family: inherit;
+            cursor: pointer;
+            transition: border-color 0.2s, box-shadow 0.2s;
+        }
+
+        .model-select:focus {
+            outline: none;
+            border-color: var(--accent);
+            box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.1);
+        }
+
+        .model-status {
+            margin-top: 8px;
+            font-size: 11px;
+            color: var(--text-secondary);
+            display: flex;
+            align-items: center;
+            gap: 4px;
+        }
+
+        .model-status.connected {
+            color: #34a853;
+        }
+
+        .model-status.error {
+            color: #ea4335;
+        }
+
+        .model-status-dot {
+            width: 6px;
+            height: 6px;
+            border-radius: 50%;
+            background: currentColor;
+        }
+
+        .refresh-models-btn {
+            margin-top: 8px;
+            width: 100%;
+            padding: 8px;
+            background: var(--bg-tertiary);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            color: var(--text-primary);
+            font-size: 12px;
+            cursor: pointer;
+            transition: background 0.2s;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 6px;
+        }
+
+        .refresh-models-btn:hover {
+            background: var(--border);
+        }
+
+        .refresh-models-btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        .refresh-models-btn svg {
+            width: 14px;
+            height: 14px;
+        }
+
+        /* 웹소설 선택 영역 */
+        .novel-selector {
+            border-top: 1px solid var(--border);
+            padding: 16px;
+            background: var(--bg-primary);
+            max-height: 300px;
+            display: flex;
+            flex-direction: column;
+        }
+
+        .novel-selector-label {
+            font-size: 12px;
+            font-weight: 500;
+            color: var(--text-secondary);
+            margin-bottom: 12px;
+            display: flex;
+            align-items: center;
+            gap: 6px;
+        }
+
+        .novel-selector-label svg {
+            width: 16px;
+            height: 16px;
+        }
+
+        .novel-list {
+            max-height: 200px;
+            overflow-y: auto;
+            display: flex;
+            flex-direction: column;
+            gap: 8px;
+        }
+
+        .novel-list::-webkit-scrollbar {
+            width: 4px;
+        }
+
+        .novel-list::-webkit-scrollbar-thumb {
+            background: var(--border);
+            border-radius: 2px;
+        }
+
+        .novel-item {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 8px;
+            background: var(--bg-secondary);
+            border-radius: 6px;
+            cursor: pointer;
+            transition: background 0.2s;
+        }
+
+        .novel-item:hover {
+            background: var(--bg-tertiary);
+        }
+
+        .novel-item input[type="checkbox"] {
+            width: 16px;
+            height: 16px;
+            cursor: pointer;
+            flex-shrink: 0;
+        }
+
+        .novel-item-name {
+            flex: 1;
+            font-size: 12px;
+            color: var(--text-primary);
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+
+        .novel-item-empty {
+            padding: 16px;
+            text-align: center;
+            color: var(--text-secondary);
+            font-size: 12px;
+        }
+
+        .selected-novels-info {
+            margin-top: 8px;
+            font-size: 11px;
+            color: var(--text-secondary);
+        }
+
+        .selected-novels-info.has-selection {
+            color: var(--accent);
+        }
+
+        /* 로그아웃 버튼 */
+        .sidebar-footer {
+            border-top: 1px solid var(--border);
+            padding: 16px;
+            background: var(--bg-primary);
+            margin-top: auto;
+        }
+
+        .logout-button {
+            width: 100%;
+            padding: 12px 16px;
+            background: var(--bg-secondary);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            color: var(--text-primary);
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            transition: background 0.2s, border-color 0.2s;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 8px;
+            text-decoration: none;
+        }
+
+        .logout-button:hover {
+            background: var(--bg-tertiary);
+            border-color: var(--accent);
+        }
+
+        .logout-button svg {
+            width: 18px;
+            height: 18px;
+        }
+
+        /* 메인 콘텐츠 영역 */
+        .main-content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            height: 100vh;
+            overflow: hidden;
+        }
+
+        /* 헤더 */
         .header {
-            background: white;
-            padding: 30px;
-            border-radius: 10px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-            margin-bottom: 30px;
+            background: var(--bg-primary);
+            border-bottom: 1px solid var(--border);
+            padding: 16px 24px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            box-shadow: 0 1px 2px var(--shadow);
+            z-index: 10;
+        }
+
+        .header-title {
+            font-size: 20px;
+            font-weight: 500;
+            color: var(--text-primary);
+            display: flex;
+            align-items: center;
+            gap: 12px;
+        }
+
+        .header-title::before {
+            content: '🤖';
+            font-size: 24px;
+        }
+
+        .header-actions {
+            display: flex;
+            gap: 12px;
+            align-items: center;
+        }
+
+        .btn-icon {
+            background: none;
+            border: none;
+            padding: 8px;
+            cursor: pointer;
+            border-radius: 50%;
+            color: var(--text-secondary);
+            transition: background 0.2s;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .btn-icon:hover {
+            background: var(--bg-tertiary);
+        }
+
+        /* 채팅 영역 */
+        .chat-container {
+            flex: 1;
+            overflow-y: auto;
+            padding: 24px;
+            display: flex;
+            flex-direction: column;
+            gap: 16px;
+            background: var(--bg-primary);
+        }
+
+        .chat-container::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        .chat-container::-webkit-scrollbar-track {
+            background: transparent;
+        }
+
+        .chat-container::-webkit-scrollbar-thumb {
+            background: var(--border);
+            border-radius: 4px;
+        }
+
+        .chat-container::-webkit-scrollbar-thumb:hover {
+            background: var(--text-secondary);
+        }
+
+        /* 메시지 */
+        .message {
+            display: flex;
+            gap: 12px;
+            max-width: 800px;
+            animation: fadeIn 0.3s ease-in;
+        }
+
+        @keyframes fadeIn {
+            from {
+                opacity: 0;
+                transform: translateY(10px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .message.user {
+            align-self: flex-end;
+            flex-direction: row-reverse;
+        }
+
+        .message-avatar {
+            width: 32px;
+            height: 32px;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 16px;
+            flex-shrink: 0;
+        }
+
+        .message.user .message-avatar {
+            background: var(--accent);
+            color: white;
+        }
+
+        .message.ai .message-avatar {
+            background: var(--bg-tertiary);
+            color: var(--text-primary);
+        }
+
+        .message-content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            gap: 4px;
+        }
+
+        .message-bubble {
+            padding: 12px 16px;
+            border-radius: 18px;
+            line-height: 1.5;
+            font-size: 15px;
+            word-wrap: break-word;
+            white-space: pre-wrap;
+        }
+
+        .message.user .message-bubble {
+            background: var(--accent);
+            color: white;
+            border-bottom-right-radius: 4px;
+        }
+
+        .message.ai .message-bubble {
+            background: var(--ai-bg);
+            color: var(--text-primary);
+            border-bottom-left-radius: 4px;
+        }
+
+        .message-time {
+            font-size: 12px;
+            color: var(--text-secondary);
+            padding: 0 4px;
+        }
+
+        .message.user .message-time {
+            text-align: right;
+        }
+
+        /* 입력 영역 */
+        .input-container {
+            background: var(--bg-primary);
+            border-top: 1px solid var(--border);
+            padding: 16px 24px;
+            display: flex;
+            align-items: flex-end;
+            gap: 12px;
+        }
+
+        .input-wrapper {
+            flex: 1;
+            position: relative;
+            background: var(--bg-secondary);
+            border: 1px solid var(--border);
+            border-radius: 24px;
+            padding: 12px 16px;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            transition: border-color 0.2s, box-shadow 0.2s;
+        }
+
+        .input-wrapper:focus-within {
+            border-color: var(--accent);
+            box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.1);
+        }
+
+        #messageInput {
+            flex: 1;
+            border: none;
+            outline: none;
+            background: transparent;
+            font-size: 15px;
+            font-family: inherit;
+            color: var(--text-primary);
+            resize: none;
+            max-height: 200px;
+            min-height: 24px;
+            line-height: 1.5;
+        }
+
+        #messageInput::placeholder {
+            color: var(--text-secondary);
+        }
+
+        .send-button {
+            background: var(--accent);
+            color: white;
+            border: none;
+            border-radius: 50%;
+            width: 40px;
+            height: 40px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            transition: background 0.2s, transform 0.1s;
+            flex-shrink: 0;
+        }
+
+        .send-button:hover:not(:disabled) {
+            background: var(--accent-hover);
+            transform: scale(1.05);
+        }
+
+        .send-button:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        .send-button svg {
+            width: 20px;
+            height: 20px;
+        }
+
+        /* 로딩 인디케이터 */
+        .typing-indicator {
+            display: flex;
+            gap: 4px;
+            padding: 12px 16px;
+            background: var(--ai-bg);
+            border-radius: 18px;
+            border-bottom-left-radius: 4px;
+            width: fit-content;
+        }
+
+        .typing-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: var(--text-secondary);
+            animation: typing 1.4s infinite;
+        }
+
+        .typing-dot:nth-child(2) {
+            animation-delay: 0.2s;
+        }
+
+        .typing-dot:nth-child(3) {
+            animation-delay: 0.4s;
+        }
+
+        @keyframes typing {
+            0%, 60%, 100% {
+                transform: translateY(0);
+                opacity: 0.7;
+            }
+            30% {
+                transform: translateY(-10px);
+                opacity: 1;
+            }
+        }
+
+        /* 빈 상태 */
+        .empty-state {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
             text-align: center;
+            padding: 48px 24px;
+            color: var(--text-secondary);
         }
-        
-        .header h1 {
-            color: #2563eb;
-            font-size: 2.5em;
-            margin-bottom: 10px;
+
+        .empty-state-icon {
+            font-size: 64px;
+            margin-bottom: 16px;
+            opacity: 0.5;
         }
-        
-        .content {
-            background: white;
-            padding: 40px;
-            border-radius: 10px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+
+        .empty-state-title {
+            font-size: 24px;
+            font-weight: 500;
+            color: var(--text-primary);
+            margin-bottom: 8px;
+        }
+
+        .empty-state-description {
+            font-size: 15px;
+            max-width: 500px;
+        }
+
+        /* 반응형 */
+        @media (max-width: 768px) {
+            .sidebar {
+                position: fixed;
+                left: 0;
+                top: 0;
+                z-index: 1000;
+                box-shadow: 2px 0 8px var(--shadow);
+            }
+
+            .sidebar.collapsed {
+                width: 0;
+            }
+
+            .main-content {
+                width: 100%;
+            }
+
+            .header {
+                padding: 12px 16px;
+            }
+
+            .header-title {
+                font-size: 18px;
+            }
+
+            .chat-container {
+                padding: 16px;
+            }
+
+            .message {
+                max-width: 100%;
+            }
+
+            .input-container {
+                padding: 12px 16px;
+            }
         }
     </style>
 </head>
 <body>
-    <div class="container">
-        <div class="header">
-            <h1>SOY NV AI</h1>
-            <p>신규 프로젝트</p>
+    <!-- 사이드바 -->
+    <div class="sidebar" id="sidebar">
+        <div class="sidebar-header">
+            <div class="sidebar-title">
+                <span>🤖</span>
+                <span>SOY NV AI</span>
+            </div>
+            <button class="sidebar-toggle" onclick="toggleSidebar()" title="사이드바 접기">
+                <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <path d="M9 18l-6-6 6-6M21 18l-6-6 6-6"/>
+                </svg>
+            </button>
+        </div>
+        <button class="new-chat-button" onclick="startNewChat()">
+            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <path d="M12 5v14M5 12h14"/>
+            </svg>
+            새 대화
+        </button>
+        <div class="chat-history" id="chatHistory">
+            <!-- 대화 히스토리 항목들이 여기에 동적으로 추가됩니다 -->
+        </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 모델
+            </div>
+            <select class="model-select" id="modelSelect">
+                <option value="">모델을 선택하세요...</option>
+            </select>
+            <div class="model-status" id="modelStatus">
+                <span class="model-status-dot"></span>
+                <span>연결 안 됨</span>
+            </div>
+            <button class="refresh-models-btn" id="refreshModelsBtn" onclick="loadModels()">
+                <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>
+                모델 새로고침
+            </button>
+        </div>
+        
+        <!-- 웹소설 선택 영역 -->
+        <div class="novel-selector">
+            <div class="novel-selector-label">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8zM14 2v6h6M16 13H8M16 17H8M10 9H8"/>
+                </svg>
+                학습할 웹소설 선택
+            </div>
+            <div class="novel-list" id="novelList">
+                <div class="novel-item-empty">모델을 선택하면 웹소설 목록이 표시됩니다</div>
+            </div>
+            <div class="selected-novels-info" id="selectedNovelsInfo"></div>
         </div>
         
-        <div class="content">
-            <h2>환영합니다!</h2>
-            <p>이 프로젝트는 SOY NV AI입니다.</p>
+        <!-- 로그아웃 버튼 -->
+        <div class="sidebar-footer">
+            <a href="{{ url_for('main.logout') }}" class="logout-button" title="로그아웃">
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/>
+                </svg>
+                <span>로그아웃</span>
+            </a>
         </div>
     </div>
+
+    <!-- 메인 콘텐츠 -->
+    <div class="main-content">
+        <!-- 헤더 -->
+        <div class="header">
+            <div class="header-title">
+                <button class="btn-icon" onclick="toggleSidebar()" title="사이드바 열기" id="sidebarToggleBtn" style="display: none;">
+                    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <path d="M3 12h18M3 6h18M3 18h18"/>
+                    </svg>
+                </button>
+                <span>SOY NV AI</span>
+            </div>
+            <div class="header-actions">
+                {% if current_user.is_admin %}
+                <a href="{{ url_for('main.admin') }}" class="btn-icon" title="관리자 페이지" style="text-decoration: none; color: var(--text-secondary);">
+                    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <path d="M12 15v2m-6 4h12a2 2 0 0 0 2-2v-6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2zm10-10V7a4 4 0 0 0-8 0v4h8z"/>
+                    </svg>
+                </a>
+                {% endif %}
+                <span style="margin-right: 8px; font-size: 14px; color: var(--text-secondary);">{{ current_user.nickname or current_user.username }}</span>
+                <a href="{{ url_for('main.logout') }}" class="btn-icon" title="로그아웃" style="text-decoration: none; color: var(--text-secondary);">
+                    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9"/>
+                    </svg>
+                </a>
+                <button class="btn-icon" onclick="clearChat()" title="대화 초기화">
+                    <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <path d="M3 6h18M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2m3 0v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6h14z"/>
+                    </svg>
+                </button>
+            </div>
+        </div>
+
+        <!-- 채팅 영역 -->
+        <div class="chat-container" id="chatContainer">
+            <div class="empty-state" id="emptyState">
+                <div class="empty-state-icon">💬</div>
+                <div class="empty-state-title">SOY NV AI에 오신 것을 환영합니다</div>
+                <div class="empty-state-description">
+                    무엇이든 물어보세요. AI가 도와드리겠습니다.
+                </div>
+            </div>
+        </div>
+
+        <!-- 입력 영역 -->
+        <div class="input-container">
+            <div class="input-wrapper">
+                <textarea 
+                    id="messageInput" 
+                    placeholder="메시지를 입력하세요..."
+                    rows="1"
+                ></textarea>
+                <button class="send-button" id="sendButton" onclick="sendMessage()">
+                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <path d="M22 2L11 13M22 2l-7 20-4-9-9-4 20-7z"/>
+                    </svg>
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const chatContainer = document.getElementById('chatContainer');
+        const messageInput = document.getElementById('messageInput');
+        const sendButton = document.getElementById('sendButton');
+        const emptyState = document.getElementById('emptyState');
+        const sidebar = document.getElementById('sidebar');
+        const chatHistory = document.getElementById('chatHistory');
+        const sidebarToggleBtn = document.getElementById('sidebarToggleBtn');
+        const modelSelect = document.getElementById('modelSelect');
+        const modelStatus = document.getElementById('modelStatus');
+        const refreshModelsBtn = document.getElementById('refreshModelsBtn');
+        
+        let currentChatId = null;
+        let currentSessionId = null;
+        let chatSessions = [];
+        let selectedModel = localStorage.getItem('selectedModel') || '';
+        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();
+            loadNovels(); // 모델 변경 시 웹소설 목록 로드
+        });
+        
+        // 웹소설 목록 로드
+        async function loadNovels() {
+            if (!selectedModel) {
+                novelList.innerHTML = '<div class="novel-item-empty">모델을 선택하면 웹소설 목록이 표시됩니다</div>';
+                selectedNovelsInfo.textContent = '';
+                return;
+            }
+            
+            try {
+                const response = await fetch(`/api/files?model_name=${encodeURIComponent(selectedModel)}`);
+                const data = await response.json();
+                
+                novelList.innerHTML = '';
+                
+                if (data.files && data.files.length > 0) {
+                    data.files.forEach(file => {
+                        const novelItem = document.createElement('div');
+                        novelItem.className = 'novel-item';
+                        
+                        const checkbox = document.createElement('input');
+                        checkbox.type = 'checkbox';
+                        checkbox.id = `novel-${file.id}`;
+                        checkbox.value = file.id;
+                        checkbox.checked = selectedFileIds.includes(file.id);
+                        checkbox.addEventListener('change', updateSelectedNovels);
+                        
+                        const label = document.createElement('label');
+                        label.className = 'novel-item-name';
+                        label.htmlFor = `novel-${file.id}`;
+                        label.textContent = file.original_filename;
+                        label.title = file.original_filename;
+                        
+                        novelItem.appendChild(checkbox);
+                        novelItem.appendChild(label);
+                        novelList.appendChild(novelItem);
+                    });
+                    updateSelectedNovelsInfo();
+                } else {
+                    novelList.innerHTML = '<div class="novel-item-empty">업로드된 웹소설이 없습니다</div>';
+                    selectedNovelsInfo.textContent = '';
+                }
+            } catch (error) {
+                console.error('웹소설 목록 로드 오류:', error);
+                novelList.innerHTML = '<div class="novel-item-empty">웹소설 목록을 불러올 수 없습니다</div>';
+            }
+        }
+        
+        // 선택된 웹소설 업데이트
+        function updateSelectedNovels() {
+            const checkboxes = novelList.querySelectorAll('input[type="checkbox"]');
+            selectedFileIds = Array.from(checkboxes)
+                .filter(cb => cb.checked)
+                .map(cb => parseInt(cb.value));
+            
+            localStorage.setItem('selectedFileIds', JSON.stringify(selectedFileIds));
+            updateSelectedNovelsInfo();
+        }
+        
+        // 선택된 웹소설 정보 표시
+        function updateSelectedNovelsInfo() {
+            if (selectedFileIds.length === 0) {
+                selectedNovelsInfo.textContent = '선택된 웹소설 없음 (모든 웹소설 사용)';
+                selectedNovelsInfo.className = 'selected-novels-info';
+            } else {
+                const count = selectedFileIds.length;
+                selectedNovelsInfo.textContent = `${count}개 웹소설 선택됨`;
+                selectedNovelsInfo.className = 'selected-novels-info has-selection';
+            }
+        }
+        
+        // 모델 목록 로드
+        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> 로딩 중...';
+            
+            try {
+                const response = await fetch('/api/ollama/models');
+                const data = await response.json();
+                
+                modelSelect.innerHTML = '<option value="">모델을 선택하세요...</option>';
+                
+                if (data.models && data.models.length > 0) {
+                    data.models.forEach(model => {
+                        const option = document.createElement('option');
+                        option.value = model.name;
+                        option.textContent = model.name;
+                        if (model.name === selectedModel) {
+                            option.selected = true;
+                        }
+                        modelSelect.appendChild(option);
+                    });
+                    updateModelStatus('connected');
+                } else {
+                    updateModelStatus('error', '사용 가능한 모델이 없습니다');
+                }
+            } catch (error) {
+                updateModelStatus('error', 'Ollama 연결 실패');
+                console.error('모델 로드 오류:', error);
+            } finally {
+                refreshModelsBtn.disabled = false;
+                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> 모델 새로고침';
+            }
+        }
+        
+        // 모델 상태 업데이트
+        function updateModelStatus(status = 'disconnected', message = '') {
+            modelStatus.className = 'model-status';
+            if (status === 'connected') {
+                modelStatus.classList.add('connected');
+                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>';
+            }
+        }
+        
+        // 사이드바 토글
+        function toggleSidebar() {
+            sidebar.classList.toggle('collapsed');
+            const isCollapsed = sidebar.classList.contains('collapsed');
+            if (window.innerWidth <= 768) {
+                sidebarToggleBtn.style.display = isCollapsed ? 'flex' : 'none';
+            }
+            // 사이드바 내부 토글 버튼 아이콘 업데이트
+            const sidebarToggle = sidebar.querySelector('.sidebar-toggle');
+            if (sidebarToggle) {
+                sidebarToggle.innerHTML = isCollapsed ? 
+                    '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 12h18M3 6h18M3 18h18"/></svg>' :
+                    '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M9 18l-6-6 6-6M21 18l-6-6 6-6"/></svg>';
+            }
+        }
+        
+        // 반응형 사이드바 처리
+        function handleResize() {
+            if (window.innerWidth <= 768) {
+                sidebar.classList.add('collapsed');
+                sidebarToggleBtn.style.display = 'flex';
+            } else {
+                sidebar.classList.remove('collapsed');
+                sidebarToggleBtn.style.display = 'none';
+            }
+        }
+        
+        window.addEventListener('resize', handleResize);
+        handleResize();
+        
+        // 새 대화 시작
+        async function startNewChat() {
+            if (confirm('새 대화를 시작하시겠습니까? 현재 대화는 저장됩니다.')) {
+                clearChat();
+                currentChatId = null;
+                currentSessionId = null;
+                await loadChatHistory();
+            }
+        }
+        
+        // 대화 히스토리 로드 (DB에서 최근 20개만)
+        async function loadChatHistory() {
+            chatHistory.innerHTML = '<div style="padding: 16px; text-align: center; color: var(--text-secondary); font-size: 14px;">로딩 중...</div>';
+            
+            try {
+                const response = await fetch('/api/chat/sessions');
+                const data = await response.json();
+                
+                chatHistory.innerHTML = '';
+                chatSessions = data.sessions || [];
+                
+                if (chatSessions.length === 0) {
+                    const emptyMsg = document.createElement('div');
+                    emptyMsg.style.padding = '16px';
+                    emptyMsg.style.textAlign = 'center';
+                    emptyMsg.style.color = 'var(--text-secondary)';
+                    emptyMsg.style.fontSize = '14px';
+                    emptyMsg.textContent = '대화 기록이 없습니다';
+                    chatHistory.appendChild(emptyMsg);
+                    return;
+                }
+                
+                chatSessions.forEach((session) => {
+                    const chatItem = document.createElement('div');
+                    chatItem.className = 'chat-item';
+                    if (session.id === currentSessionId) {
+                        chatItem.classList.add('active');
+                    }
+                    
+                    chatItem.innerHTML = `
+                        <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-time">${formatTime(session.updated_at)}</div>
+                    `;
+                    
+                    chatItem.onclick = () => loadChat(session.id);
+                    chatHistory.appendChild(chatItem);
+                });
+            } catch (error) {
+                console.error('대화 히스토리 로드 오류:', error);
+                chatHistory.innerHTML = '<div style="padding: 16px; text-align: center; color: var(--text-secondary); font-size: 14px;">대화 기록을 불러올 수 없습니다</div>';
+            }
+        }
+        
+        // 시간 포맷
+        function formatTime(timestamp) {
+            const date = new Date(timestamp);
+            const now = new Date();
+            const diff = now - date;
+            const minutes = Math.floor(diff / 60000);
+            const hours = Math.floor(diff / 3600000);
+            const days = Math.floor(diff / 86400000);
+            
+            if (minutes < 1) return '방금';
+            if (minutes < 60) return `${minutes}분 전`;
+            if (hours < 24) return `${hours}시간 전`;
+            if (days < 7) return `${days}일 전`;
+            return date.toLocaleDateString('ko-KR', { month: 'short', day: 'numeric' });
+        }
+        
+        // 대화 로드
+        async function loadChat(sessionId) {
+            try {
+                const response = await fetch(`/api/chat/sessions/${sessionId}`);
+                const data = await response.json();
+                
+                if (!data.session) return;
+                
+                currentSessionId = sessionId;
+                currentChatId = sessionId;
+                chatContainer.innerHTML = '';
+                
+                if (data.session.messages && data.session.messages.length > 0) {
+                    data.session.messages.forEach(msg => {
+                        addMessage(msg.role, msg.content, false);
+                    });
+                } else {
+                    if (emptyState) {
+                        emptyState.style.display = 'flex';
+                    }
+                }
+                
+                await loadChatHistory();
+                if (window.innerWidth <= 768) {
+                    sidebar.classList.add('collapsed');
+                }
+            } catch (error) {
+                console.error('대화 로드 오류:', error);
+                alert('대화를 불러올 수 없습니다.');
+            }
+        }
+        
+        // 새 대화 세션 생성
+        async function createNewSession() {
+            try {
+                const response = await fetch('/api/chat/sessions', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        title: '새 대화',
+                        model_name: selectedModel || null
+                    })
+                });
+                
+                const data = await response.json();
+                if (response.ok && data.session) {
+                    currentSessionId = data.session.id;
+                    currentChatId = data.session.id;
+                    await loadChatHistory();
+                    return data.session.id;
+                }
+            } catch (error) {
+                console.error('세션 생성 오류:', error);
+            }
+            return null;
+        }
+
+        // 자동 높이 조절
+        messageInput.addEventListener('input', function() {
+            this.style.height = 'auto';
+            this.style.height = Math.min(this.scrollHeight, 200) + 'px';
+        });
+
+        // Enter 키 처리
+        messageInput.addEventListener('keydown', function(e) {
+            if (e.key === 'Enter' && !e.shiftKey) {
+                e.preventDefault();
+                sendMessage();
+            }
+        });
+
+        // 메시지 추가
+        function addMessage(role, content, save = true) {
+            // 빈 상태 숨기기
+            if (emptyState) {
+                emptyState.style.display = 'none';
+            }
+
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${role}`;
+
+            const avatar = document.createElement('div');
+            avatar.className = 'message-avatar';
+            avatar.textContent = role === 'user' ? '👤' : '🤖';
+
+            const contentDiv = document.createElement('div');
+            contentDiv.className = 'message-content';
+
+            const bubble = document.createElement('div');
+            bubble.className = 'message-bubble';
+            bubble.textContent = content;
+
+            const time = document.createElement('div');
+            time.className = 'message-time';
+            time.textContent = new Date().toLocaleTimeString('ko-KR', { 
+                hour: '2-digit', 
+                minute: '2-digit' 
+            });
+
+            contentDiv.appendChild(bubble);
+            contentDiv.appendChild(time);
+            messageDiv.appendChild(avatar);
+            messageDiv.appendChild(contentDiv);
+            chatContainer.appendChild(messageDiv);
+
+            // 스크롤을 맨 아래로
+            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);
+            }
+
+            contentDiv.appendChild(typingDiv);
+            messageDiv.appendChild(avatar);
+            messageDiv.appendChild(contentDiv);
+            chatContainer.appendChild(messageDiv);
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+        }
+
+        // 타이핑 인디케이터 제거
+        function removeTypingIndicator() {
+            const indicator = document.getElementById('typingIndicator');
+            if (indicator) {
+                indicator.remove();
+            }
+        }
+
+        // 메시지 전송
+        async function sendMessage() {
+            const message = messageInput.value.trim();
+            if (!message) return;
+
+            // 세션이 없으면 새로 생성
+            if (!currentSessionId) {
+                currentSessionId = await createNewSession();
+            }
+
+            // 사용자 메시지 표���
+            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';
+
+            // 입력 비활성화
+            messageInput.disabled = true;
+            sendButton.disabled = true;
+
+            // 타이핑 인디케이터 표시
+            showTypingIndicator();
+
+            try {
+                // API 호출
+                const response = await fetch('/api/chat', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        message: message,
+                        model: selectedModel || null,
+                        file_ids: selectedFileIds.length > 0 ? selectedFileIds : [],
+                        session_id: currentSessionId
+                    })
+                });
+
+                removeTypingIndicator();
+
+                if (response.ok) {
+                    const data = await response.json();
+                    const aiResponse = data.response || '응답을 생성하는 중 오류가 발생했습니다.';
+                    addMessage('ai', aiResponse, false);
+                    
+                    // DB에 AI 응답 저장 (이미 백엔드에서 저장됨)
+                    // 세션 목록 새로고침
+                    await loadChatHistory();
+                } else {
+                    const error = await response.json().catch(() => ({ error: '서버 오류' }));
+                    addMessage('ai', `오류: ${error.error || '알 수 없는 오류가 발생했습니다.'}`, false);
+                }
+            } catch (error) {
+                removeTypingIndicator();
+                addMessage('ai', `연결 오류: ${error.message}`, false);
+            } finally {
+                // 입력 활성화
+                messageInput.disabled = false;
+                sendButton.disabled = false;
+                messageInput.focus();
+            }
+        }
+
+        // 대화 초기화
+        function clearChat() {
+            chatContainer.innerHTML = '';
+            currentChatId = null;
+            currentSessionId = null;
+            if (emptyState) {
+                emptyState.style.display = 'flex';
+            }
+        }
+        
+        // 페이지 로드 시 초기화
+        window.addEventListener('load', async () => {
+            await loadChatHistory();
+            await loadModels();
+            if (selectedModel) {
+                loadNovels();
+            }
+            messageInput.focus();
+        });
+    </script>
 </body>
 </html>
-

templates/login.html

@@ -0,0 +1,161 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>로그인 - 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: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+        }
+
+        .login-container {
+            background: white;
+            border-radius: 16px;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+            padding: 40px;
+            width: 100%;
+            max-width: 400px;
+        }
+
+        .login-header {
+            text-align: center;
+            margin-bottom: 32px;
+        }
+
+        .login-header h1 {
+            font-size: 28px;
+            font-weight: 600;
+            color: #202124;
+            margin-bottom: 8px;
+        }
+
+        .login-header p {
+            font-size: 14px;
+            color: #5f6368;
+        }
+
+        .login-icon {
+            font-size: 48px;
+            margin-bottom: 16px;
+        }
+
+        .form-group {
+            margin-bottom: 20px;
+        }
+
+        .form-group label {
+            display: block;
+            font-size: 14px;
+            font-weight: 500;
+            color: #202124;
+            margin-bottom: 8px;
+        }
+
+        .form-group input {
+            width: 100%;
+            padding: 12px 16px;
+            border: 1px solid #dadce0;
+            border-radius: 8px;
+            font-size: 15px;
+            font-family: inherit;
+            transition: border-color 0.2s, box-shadow 0.2s;
+        }
+
+        .form-group input:focus {
+            outline: none;
+            border-color: #1a73e8;
+            box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.1);
+        }
+
+        .login-button {
+            width: 100%;
+            padding: 12px;
+            background: #1a73e8;
+            color: white;
+            border: none;
+            border-radius: 8px;
+            font-size: 15px;
+            font-weight: 500;
+            cursor: pointer;
+            transition: background 0.2s;
+            margin-top: 8px;
+        }
+
+        .login-button:hover {
+            background: #1557b0;
+        }
+
+        .login-button:active {
+            transform: scale(0.98);
+        }
+
+        .alert {
+            padding: 12px 16px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            font-size: 14px;
+        }
+
+        .alert.error {
+            background: #fce8e6;
+            color: #c5221f;
+            border: 1px solid #f28b82;
+        }
+
+        .alert.info {
+            background: #e8f0fe;
+            color: #1967d2;
+            border: 1px solid #aecbfa;
+        }
+    </style>
+</head>
+<body>
+    <div class="login-container">
+        <div class="login-header">
+            <div class="login-icon">🤖</div>
+            <h1>SOY NV AI</h1>
+            <p>로그인이 필요합니다</p>
+        </div>
+
+        {% with messages = get_flashed_messages(with_categories=true) %}
+            {% if messages %}
+                {% for category, message in messages %}
+                    <div class="alert {{ category }}">
+                        {{ message }}
+                    </div>
+                {% endfor %}
+            {% endif %}
+        {% endwith %}
+
+        <form method="POST" action="{{ url_for('main.login') }}">
+            <div class="form-group">
+                <label for="username">사용자명</label>
+                <input type="text" id="username" name="username" required autofocus>
+            </div>
+
+            <div class="form-group">
+                <label for="password">비밀번호</label>
+                <input type="password" id="password" name="password" required>
+            </div>
+
+            <button type="submit" class="login-button">로그인</button>
+        </form>
+    </div>
+</body>
+</html>
+