Auto-deploy from GitHub Actions - 2025-12-11 09:26:27

Dockerfile

@@ -1,34 +1,34 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# 1. 시스템 패키지 설치
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    git \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# 2. Python 의존성 설치
-COPY requirements.txt .
-
-# 🔥 [용량 최적화] 무거운 PyTorch를 CPU 전용으로 먼저 설치합니다.
-RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
-
-# 나머지 라이브러리 설치 (--no-cache-dir 유지)
-RUN pip install --no-cache-dir -r requirements.txt
-
-# 3. 애플리케이션 코드 복사
-COPY . .
-
-# 필요한 디렉토리 생성
-RUN mkdir -p instance uploads vector_db knowledge_graphs logs static templates
-
-# 4. 포트 설정 및 환경 변수
-EXPOSE 7860
-ENV PORT=7860
-ENV HOST=0.0.0.0
-
-# 5. 애플리케이션 실행 (app.py 직접 실행)
-CMD ["python", "app.py"]
-
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# 1. 시스템 패키지 설치
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# 2. Python 의존성 설치
+COPY requirements.txt .
+
+# 🔥 [용량 최적화] 무거운 PyTorch를 CPU 전용으로 먼저 설치합니다.
+RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu
+
+# 나머지 라이브러리 설치 (--no-cache-dir 유지)
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 3. 애플리케이션 코드 복사
+COPY . .
+
+# 필요한 디렉토리 생성
+RUN mkdir -p instance uploads vector_db knowledge_graphs logs static templates
+
+# 4. 포트 설정 및 환경 변수
+EXPOSE 7860
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+# 5. 애플리케이션 실행 (app.py 직접 실행)
+CMD ["python", "app.py"]
+

app.py

@@ -1,79 +1,79 @@
-"""
-Hugging Face Spaces용 Flask 애플리케이션 진입점
-"""
-import sys
-import os
-import logging
-from logging.handlers import RotatingFileHandler
-
-# UTF-8 인코딩 강제 설정
-if sys.platform == 'win32':
-    sys.stdout.reconfigure(encoding='utf-8')
-    sys.stderr.reconfigure(encoding='utf-8')
-
-from app import create_app
-
-app = create_app()
-
-# Hugging Face Spaces 환경 변수 설정
-# Spaces는 자동으로 포트를 할당하므로 환경 변수에서 가져옴
-port = int(os.environ.get('PORT', 7860))
-host = os.environ.get('HOST', '0.0.0.0')
-
-# 로깅 설정
-if not os.path.exists('logs'):
-    os.mkdir('logs')
-
-# 파일 핸들러 설정
-file_handler = RotatingFileHandler('logs/server.log', maxBytes=10240000, backupCount=10)
-file_handler.setFormatter(logging.Formatter(
-    '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
-))
-file_handler.setLevel(logging.INFO)
-
-# 콘솔 핸들러 설정
-console_handler = logging.StreamHandler(sys.stdout)
-console_handler.setFormatter(logging.Formatter(
-    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-))
-console_handler.setLevel(logging.INFO)
-
-# Flask 앱 로거 설정
-app.logger.setLevel(logging.INFO)
-app.logger.addHandler(file_handler)
-app.logger.addHandler(console_handler)
-
-# 루트 로거 설정
-root_logger = logging.getLogger()
-root_logger.setLevel(logging.INFO)
-root_logger.addHandler(console_handler)
-
-# Werkzeug 로거 설정
-werkzeug_logger = logging.getLogger('werkzeug')
-werkzeug_logger.setLevel(logging.INFO)
-werkzeug_logger.handlers.clear()
-werkzeug_handler = logging.StreamHandler(sys.stdout)
-werkzeug_handler.setFormatter(logging.Formatter(
-    '%(asctime)s - %(levelname)s - %(message)s'
-))
-werkzeug_logger.addHandler(werkzeug_handler)
-
-app.logger.info(f'서버 시작 - Host: {host}, Port: {port}')
-
-if __name__ == '__main__':
-    try:
-        print(f"[{__name__}] 서버 시작: http://{host}:{port}")
-        print(f"[{__name__}] 로그는 콘솔과 logs/server.log 파일에 기록됩니다.")
-        app.run(host=host, port=port, debug=False, use_reloader=False)
-    except Exception as e:
-        print(f"서버 시작 오류: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-
-
-
-
-
-
+"""
+Hugging Face Spaces용 Flask 애플리케이션 진입점
+"""
+import sys
+import os
+import logging
+from logging.handlers import RotatingFileHandler
+
+# UTF-8 인코딩 강제 설정
+if sys.platform == 'win32':
+    sys.stdout.reconfigure(encoding='utf-8')
+    sys.stderr.reconfigure(encoding='utf-8')
+
+from app import create_app
+
+app = create_app()
+
+# Hugging Face Spaces 환경 변수 설정
+# Spaces는 자동으로 포트를 할당하므로 환경 변수에서 가져옴
+port = int(os.environ.get('PORT', 7860))
+host = os.environ.get('HOST', '0.0.0.0')
+
+# 로깅 설정
+if not os.path.exists('logs'):
+    os.mkdir('logs')
+
+# 파일 핸들러 설정
+file_handler = RotatingFileHandler('logs/server.log', maxBytes=10240000, backupCount=10)
+file_handler.setFormatter(logging.Formatter(
+    '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
+))
+file_handler.setLevel(logging.INFO)
+
+# 콘솔 핸들러 설정
+console_handler = logging.StreamHandler(sys.stdout)
+console_handler.setFormatter(logging.Formatter(
+    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+))
+console_handler.setLevel(logging.INFO)
+
+# Flask 앱 로거 설정
+app.logger.setLevel(logging.INFO)
+app.logger.addHandler(file_handler)
+app.logger.addHandler(console_handler)
+
+# 루트 로거 설정
+root_logger = logging.getLogger()
+root_logger.setLevel(logging.INFO)
+root_logger.addHandler(console_handler)
+
+# Werkzeug 로거 설정
+werkzeug_logger = logging.getLogger('werkzeug')
+werkzeug_logger.setLevel(logging.INFO)
+werkzeug_logger.handlers.clear()
+werkzeug_handler = logging.StreamHandler(sys.stdout)
+werkzeug_handler.setFormatter(logging.Formatter(
+    '%(asctime)s - %(levelname)s - %(message)s'
+))
+werkzeug_logger.addHandler(werkzeug_handler)
+
+app.logger.info(f'서버 시작 - Host: {host}, Port: {port}')
+
+if __name__ == '__main__':
+    try:
+        print(f"[{__name__}] 서버 시작: http://{host}:{port}")
+        print(f"[{__name__}] 로그는 콘솔과 logs/server.log 파일에 기록됩니다.")
+        app.run(host=host, port=port, debug=False, use_reloader=False)
+    except Exception as e:
+        print(f"서버 시작 오류: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+
+
+
+
+
+

app/__init__.py

@@ -73,6 +73,14 @@ def create_app() -> Flask:
     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = config.SQLALCHEMY_TRACK_MODIFICATIONS
     app.config['MAX_CONTENT_LENGTH'] = config.MAX_CONTENT_LENGTH
     
+    # SQLAlchemy 연결 풀 설정 (클라우드 환경에서 유휴 연결 끊김 방지)
+    # pool_pre_ping: 연결 사용 전에 살아있는지 확인 (ping)
+    # pool_recycle: 연결을 재사용하기 전 최대 시간(초) - 300초(5분)
+    app.config['SQLALCHEMY_ENGINE_OPTIONS'] = {
+        'pool_pre_ping': True,
+        'pool_recycle': 300
+    }
+    
     # 세션 쿠키 설정 (브라우저 호환성 개선)
     app.config['SESSION_COOKIE_SECURE'] = True  # HTTPS에서만 전송
     app.config['SESSION_COOKIE_HTTPONLY'] = True  # JavaScript 접근 방지
@@ -163,7 +171,11 @@ def create_app() -> Flask:
             logger.info(f"[데이터베이스] PostgreSQL 연결 시도: {masked_uri}")
             # 연결 테스트
             try:
-                engine = create_engine(db_uri)
+                engine = create_engine(
+                    db_uri,
+                    pool_pre_ping=True,
+                    pool_recycle=300
+                )
                 with engine.connect() as conn:
                     result = conn.execute(text("SELECT version()"))
                     version = result.fetchone()[0]

app/database.py

@@ -98,10 +98,15 @@ class ChatSession(db.Model):
 # 대화 메시지 모델
 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)
+    session_id = db.Column(db.Integer, db.ForeignKey('chat_session.id'), nullable=True)  # 시스템 사용은 NULL 허용
     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)
+    # 토큰 사용량 정보 (AI 응답 메시지에만 저장)
+    input_tokens = db.Column(db.Integer, nullable=True)  # 입력 토큰 수
+    output_tokens = db.Column(db.Integer, nullable=True)  # 출력 토큰 수
+    model_name = db.Column(db.String(100), nullable=True)  # 사용된 AI 모델명
+    usage_type = db.Column(db.String(20), nullable=True, default='user')  # 'user' or 'system' (시스템 사용 구분)
     
     def to_dict(self):
         return {
@@ -109,7 +114,11 @@ class ChatMessage(db.Model):
             'session_id': self.session_id,
             'role': self.role,
             'content': self.content,
-            'created_at': self.created_at.isoformat() if self.created_at else None
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'input_tokens': self.input_tokens,
+            'output_tokens': self.output_tokens,
+            'model_name': self.model_name,
+            'usage_type': self.usage_type
         }
 
 # 문서 청크 모델 (RAG용)

app/gemini_client.py

@@ -486,6 +486,16 @@ class GeminiClient:
                         # REST API 응답 파싱
                         response_data = rest_response.json()
                         
+                        # 토큰 사용량 정보 추출
+                        input_tokens = None
+                        output_tokens = None
+                        if 'usageMetadata' in response_data:
+                            usage = response_data['usageMetadata']
+                            input_tokens = usage.get('promptTokenCount')
+                            output_tokens = usage.get('candidatesTokenCount')
+                            total_tokens = usage.get('totalTokenCount')
+                            print(f"[Gemini] 토큰 사용량: 입력={input_tokens}, 출력={output_tokens}, 총={total_tokens}")
+                        
                         # 응답에서 텍스트 추출
                         if 'candidates' in response_data and len(response_data['candidates']) > 0:
                             candidate = response_data['candidates'][0]
@@ -497,10 +507,12 @@ class GeminiClient:
                                     
                                     # genai 라이브러리 형식으로 변환 (호환성을 위해)
                                     class MockResponse:
-                                        def __init__(self, text):
+                                        def __init__(self, text, input_tokens=None, output_tokens=None):
                                             self.text = text
+                                            self.input_tokens = input_tokens
+                                            self.output_tokens = output_tokens
                                     
-                                    response = MockResponse(response_text)
+                                    response = MockResponse(response_text, input_tokens, output_tokens)
                                     break
                                 else:
                                     raise Exception("REST API 응답에 텍스트가 없습니다.")
@@ -559,10 +571,16 @@ class GeminiClient:
             # 응답 텍스트 추출
             response_text = response.text if hasattr(response, 'text') else str(response)
             
-            print(f"[Gemini] 응답 생성 완료: {len(response_text)}자")
+            # 토큰 정보 추출
+            input_tokens = getattr(response, 'input_tokens', None)
+            output_tokens = getattr(response, 'output_tokens', None)
+            
+            print(f"[Gemini] 응답 생성 완료: {len(response_text)}자, 입력 토큰: {input_tokens}, 출력 토큰: {output_tokens}")
             return {
                 'response': response_text,
-                'error': None
+                'error': None,
+                'input_tokens': input_tokens,
+                'output_tokens': output_tokens
             }
             
         except Exception as e:

app/huggingface_client.py

@@ -46,3 +46,7 @@ def reset_huggingface_token():
 
 
 
+
+
+
+

app/routes.py

@@ -1,4 +1,4 @@
-from flask import Blueprint, render_template, request, jsonify, send_from_directory, redirect, url_for, flash
+from flask import Blueprint, render_template, request, jsonify, send_from_directory, redirect, url_for, flash, send_file
 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, ParentChunk, SystemConfig, EpisodeAnalysis, GraphEntity, GraphRelationship, GraphEvent
@@ -112,6 +112,37 @@ def get_model_token_limit_by_type(model_name, default_tokens=2000, token_type='o
 
 # 업로드 설정
 UPLOAD_FOLDER = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'uploads')
+
+def save_system_token_usage(model_name, input_tokens=None, output_tokens=None, task_type='file_processing'):
+    """시스템 사용 토큰 저장 (파일 업로드, 분석 등)
+    
+    Args:
+        model_name: 사용된 AI 모델명
+        input_tokens: 입력 토큰 수
+        output_tokens: 출력 토큰 수
+        task_type: 작업 유형 ('parent_chunk', 'episode_analysis', 'graph_extraction', 'metadata_extraction', 'file_processing')
+    """
+    try:
+        # 토큰이 모두 None이거나 0이어도 저장 (통계 목적)
+        print(f"[시스템 토큰 저장] 호출됨 - 작업: {task_type}, 모델: {model_name}, 입력: {input_tokens}, 출력: {output_tokens}")
+        
+        system_message = ChatMessage(
+            session_id=None,  # 시스템 사용은 세션이 없음
+            role='ai',
+            content=f'시스템 작업: {task_type}',
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            model_name=model_name,
+            usage_type='system'
+        )
+        db.session.add(system_message)
+        db.session.commit()
+        print(f"[시스템 토큰 저장] 성공 - {task_type} - 모델: {model_name}, 입력: {input_tokens}, 출력: {output_tokens}, 메시지 ID: {system_message.id}")
+    except Exception as e:
+        print(f"[시스템 토큰 저장] 오류: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        db.session.rollback()
 ALLOWED_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'epub'}
 
 # 업로드 폴더 경로 출력 (디버깅용)
@@ -635,6 +666,14 @@ def analyze_episode(episode_content, episode_title, full_content=None, parent_ch
                         max_output_tokens=get_model_token_limit("gemini-1.5-flash", 3000)  # 저장된 토큰 수 사용
                     )
                     if not result['error'] and result.get('response'):
+                        # 시스템 사용 토큰 저장 (토큰이 None이어도 저장)
+                        print(f"[회차 분석] 토큰 정보 확인 - 입력: {result.get('input_tokens')}, 출력: {result.get('output_tokens')}")
+                        save_system_token_usage(
+                            model_name="gemini-1.5-flash",
+                            input_tokens=result.get('input_tokens'),
+                            output_tokens=result.get('output_tokens'),
+                            task_type='episode_analysis'
+                        )
                         return result['response'].strip()
             except Exception as e:
                 print(f"[회차 분석] Gemini 기본 모델 오류: {str(e)}")
@@ -658,6 +697,14 @@ def analyze_episode(episode_content, episode_title, full_content=None, parent_ch
                         max_output_tokens=get_model_token_limit(model_name, 3000)  # 저장된 토큰 수 사용
                     )
                     if not result['error'] and result.get('response'):
+                        # 시스템 사용 토큰 저장 (토큰이 None이어도 저장)
+                        print(f"[회차 분석] 토큰 정보 확인 - 입력: {result.get('input_tokens')}, 출력: {result.get('output_tokens')}")
+                        save_system_token_usage(
+                            model_name=gemini_model_name,
+                            input_tokens=result.get('input_tokens'),
+                            output_tokens=result.get('output_tokens'),
+                            task_type='episode_analysis'
+                        )
                         return result['response'].strip()
             else:
                 # Ollama API 호출
@@ -680,6 +727,16 @@ def analyze_episode(episode_content, episode_title, full_content=None, parent_ch
                     )
                     if ollama_response.status_code == 200:
                         response_data = ollama_response.json()
+                        # 시스템 사용 토큰 저장 (토큰이 None이어도 저장)
+                        ollama_input_tokens = response_data.get('prompt_eval_count')
+                        ollama_output_tokens = response_data.get('eval_count')
+                        print(f"[회차 분석] 토큰 정보 확인 - 입력: {ollama_input_tokens}, 출력: {ollama_output_tokens}")
+                        save_system_token_usage(
+                            model_name=model_name,
+                            input_tokens=ollama_input_tokens,
+                            output_tokens=ollama_output_tokens,
+                            task_type='episode_analysis'
+                        )
                         return response_data.get('response', '').strip()
                 except requests.exceptions.Timeout:
                     print(f"[회차 분석] Ollama 타임아웃: 요청 시간이 초과되었습니다. (5분)")
@@ -750,6 +807,14 @@ def extract_graph_from_episode(episode_content, episode_title, file_id, full_con
                     )
                     if not result['error'] and result.get('response'):
                         response_text = result['response'].strip()
+                        # 시스템 사용 토큰 저장 (토큰이 None이어도 저장)
+                        print(f"[Graph Extraction] 토큰 정보 확인 - 입력: {result.get('input_tokens')}, 출력: {result.get('output_tokens')}")
+                        save_system_token_usage(
+                            model_name="gemini-1.5-flash",
+                            input_tokens=result.get('input_tokens'),
+                            output_tokens=result.get('output_tokens'),
+                            task_type='graph_extraction'
+                        )
             except Exception as e:
                 print(f"[Graph Extraction] Gemini 기본 모델 오류: {str(e)}")
         
@@ -773,6 +838,14 @@ def extract_graph_from_episode(episode_content, episode_title, file_id, full_con
                     )
                     if not result['error'] and result.get('response'):
                         response_text = result['response'].strip()
+                        # 시스템 사용 토큰 저장 (토큰이 None이어도 저장)
+                        print(f"[Graph Extraction] 토큰 정보 확인 - 입력: {result.get('input_tokens')}, 출력: {result.get('output_tokens')}")
+                        save_system_token_usage(
+                            model_name=gemini_model_name,
+                            input_tokens=result.get('input_tokens'),
+                            output_tokens=result.get('output_tokens'),
+                            task_type='graph_extraction'
+                        )
             else:
                 # Ollama API 호출
                 try:
@@ -795,6 +868,16 @@ def extract_graph_from_episode(episode_content, episode_title, file_id, full_con
                     if ollama_response.status_code == 200:
                         response_data = ollama_response.json()
                         response_text = response_data.get('response', '').strip()
+                        # 시스템 사용 토큰 저장 (토큰이 None이어도 저장)
+                        ollama_input_tokens = response_data.get('prompt_eval_count')
+                        ollama_output_tokens = response_data.get('eval_count')
+                        print(f"[Graph Extraction] 토큰 정보 확인 - 입력: {ollama_input_tokens}, 출력: {ollama_output_tokens}")
+                        save_system_token_usage(
+                            model_name=model_name,
+                            input_tokens=ollama_input_tokens,
+                            output_tokens=ollama_output_tokens,
+                            task_type='graph_extraction'
+                        )
                 except requests.exceptions.Timeout:
                     print(f"[Graph Extraction] Ollama 타임아웃: 요청 시간이 초과되었습니다. (5분)")
                 except requests.exceptions.ConnectionError:
@@ -1217,6 +1300,17 @@ def create_parent_chunk_with_ai(file_id, content, model_name):
             
             analysis_result = result['response']
             print(f"[Parent Chunk 생성] Gemini API 응답 수신 성공: {len(analysis_result)}자")
+            
+            # 시스템 사용 토큰 저장 (토큰이 None이어도 저장)
+            gemini_input_tokens = result.get('input_tokens')
+            gemini_output_tokens = result.get('output_tokens')
+            print(f"[Parent Chunk 생성] 토큰 정보 확인 - 입력: {gemini_input_tokens}, 출력: {gemini_output_tokens}")
+            save_system_token_usage(
+                model_name=gemini_model_name,
+                input_tokens=gemini_input_tokens,
+                output_tokens=gemini_output_tokens,
+                task_type='parent_chunk'
+            )
         else:
             # Ollama API 호출
             print(f"[Parent Chunk 생성] Ollama API에 분석 요청 전송 중... (모델: {model_name})")
@@ -1256,6 +1350,17 @@ def create_parent_chunk_with_ai(file_id, content, model_name):
                 response_data = ollama_response.json()
                 analysis_result = response_data.get('message', {}).get('content', '')
                 print(f"[Parent Chunk 생성] Ollama API 응답 수신 성공: {len(analysis_result)}자")
+                
+                # 시스템 사용 토큰 저장 (토큰이 None이어도 저장)
+                ollama_input_tokens = response_data.get('prompt_eval_count')
+                ollama_output_tokens = response_data.get('eval_count')
+                print(f"[Parent Chunk 생성] 토큰 정보 확인 - 입력: {ollama_input_tokens}, 출력: {ollama_output_tokens}")
+                save_system_token_usage(
+                    model_name=model_name,
+                    input_tokens=ollama_input_tokens,
+                    output_tokens=ollama_output_tokens,
+                    task_type='parent_chunk'
+                )
             except requests.exceptions.Timeout:
                 print(f"[Parent Chunk 생성] ❌ Ollama 타임아웃: 요청 시간이 초과되었습니다. (5분)")
                 print(f"[Parent Chunk 생성] 파일이 너무 크거나 모델 응답이 느릴 수 있습니다.")
@@ -1791,6 +1896,457 @@ def admin_files():
     """파일 목록 관리 페이지"""
     return render_template('admin_files.html')
 
+@main_bp.route('/admin/utils')
+@admin_required
+def admin_utils():
+    """유틸리티 관리 페이지"""
+    return render_template('admin_utils.html')
+
+@main_bp.route('/admin/tokens')
+@admin_required
+def admin_tokens():
+    """토큰 사용량 통계 페이지"""
+    return render_template('admin_tokens.html')
+
+def convert_episode_format(content):
+    """다양한 회차 구분 방식을 #n화 형식으로 변환
+    
+    지원하는 패턴:
+    - @1, @2, @10 -> #1화, #2화, #10화
+    - @ 1, @ 2 -> #1화, #2화
+    - @1화, @2화 -> #1화, #2화
+    - @ 1화, @ 2화 -> #1화, #2화
+    - 1화, 2화, 10화 -> #1화, #2화, #10화 (앞에 기호 없이)
+    - #01화, #010화 -> #1화, #10화 (앞의 0 제거)
+    - 기타 유사한 패턴들
+    
+    Args:
+        content: 변환할 웹소설 내용
+        
+    Returns:
+        변환된 내용
+    """
+    if not content:
+        return content
+    
+    lines = content.split('\n')
+    converted_lines = []
+    
+    # 다양한 회차 패턴을 #n화 형식으로 변환
+    # 패턴: @숫자, @ 숫자, @숫자화, @ 숫자화, 숫자화 등
+    # 줄 시작 부분에서만 매칭하도록 ^ 사용
+    for line in lines:
+        converted_line = line
+        
+        # 프롤로그 처리 (@프롤로그, #프롤로그 -> #0화 프롤로그)
+        converted_line = re.sub(r'^[@#]\s*프롤로그\s*', '#0화 프롤로그', converted_line)
+        
+        # @숫자화 패턴 (공백 포함/미포함)
+        converted_line = re.sub(r'^@\s*(\d+)\s*화\s*', r'#\1화', converted_line)
+        
+        # @숫자 패턴 (공백 포함/미포함) - 화가 없는 경우만
+        # 이미 화가 있는 경우는 위에서 처리되었으므로, 화가 없는 경우만 처리
+        if not re.search(r'^#\d+화', converted_line):
+            converted_line = re.sub(r'^@\s*(\d+)(?!화)\s*', r'#\1화', converted_line)
+        
+        # 숫자화 패턴 (앞에 기호 없이) - 이미 #이 있는 경우는 제외
+        # 줄 시작에서 숫자로 시작하고 바로 "화"가 오는 경우
+        if not re.search(r'^#\d+화', converted_line):
+            converted_line = re.sub(r'^(\d+)\s*화\s*', r'#\1화', converted_line)
+            
+        # #숫자 패턴 (화가 없는 경우) - #n -> #n화
+        if not re.search(r'^#\d+화', converted_line):
+            converted_line = re.sub(r'^#\s*(\d+)(?!화)\s*', r'#\1화', converted_line)
+        
+        # #0n화 패턴에서 앞의 0 제거 (#01화 -> #1화, #010화 -> #10화)
+        # 단, #0화는 그대로 유지
+        converted_line = re.sub(r'^#0+(\d+)화', r'#\1화', converted_line)
+        
+        converted_lines.append(converted_line)
+    
+    return '\n'.join(converted_lines)
+
+@main_bp.route('/api/admin/utils/detect-encoding', methods=['POST'])
+@admin_required
+def detect_file_encoding():
+    """파일 인코딩 감지 API"""
+    try:
+        if 'file' not in request.files:
+            return jsonify({'error': '파일이 필요합니다.'}), 400
+        
+        file = request.files['file']
+        if not file or not file.filename:
+            return jsonify({'error': '파일이 필요합니다.'}), 400
+        
+        file_content = file.read()
+        file.seek(0)  # 파일 포인터 리셋
+        
+        # 여러 인코딩 시도하여 감지
+        encodings_to_try = ['utf-8', 'cp949', 'euc-kr', 'latin-1', 'utf-16', 'utf-16-le', 'utf-16-be']
+        detected_encoding = None
+        detected_content = None
+        
+        for encoding in encodings_to_try:
+            try:
+                content = file_content.decode(encoding)
+                detected_encoding = encoding
+                detected_content = content
+                break
+            except (UnicodeDecodeError, UnicodeError):
+                continue
+        
+        if not detected_encoding:
+            return jsonify({
+                'error': '파일 인코딩을 감지할 수 없습니다.',
+                'detected_encoding': None,
+                'confidence': 0
+            }), 400
+        
+        # ��단한 신뢰도 계산 (UTF-8 BOM 확인, 일반적인 문자 범위 확인 등)
+        confidence = 0.8
+        if detected_encoding == 'utf-8':
+            # UTF-8 BOM 확인
+            if file_content.startswith(b'\xef\xbb\xbf'):
+                confidence = 0.95
+            # 한글 문자 포함 여부 확인
+            if any(ord(char) >= 0xAC00 and ord(char) <= 0xD7A3 for char in detected_content[:1000]):
+                confidence = 0.9
+        
+        return jsonify({
+            'success': True,
+            'detected_encoding': detected_encoding,
+            'confidence': confidence,
+            'preview': detected_content[:200] if detected_content else ''
+        }), 200
+        
+    except Exception as e:
+        import traceback
+        print(f"[인코딩 감지] 오류: {str(e)}")
+        print(traceback.format_exc())
+        return jsonify({'error': f'인코딩 감지 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/utils/convert-episode-format', methods=['POST'])
+@admin_required
+def convert_episode_format_api():
+    """회차 구분 방식 변환 API (파일 업로드 또는 텍스트 입력)"""
+    try:
+        content = None
+        original_filename = 'converted_file.txt'
+        specified_encoding = None
+        
+        # 파일 업로드 확인
+        if 'file' in request.files:
+            file = request.files['file']
+            if file and file.filename and file.filename != '':
+                # 파일 읽기
+                try:
+                    # 요청에서 인코딩 정보 가져오기
+                    specified_encoding = request.form.get('encoding', 'utf-8')
+                    
+                    file_content = file.read()
+                    file.seek(0)  # 파일 포인터 리셋 (다시 읽을 수 있도록)
+                    
+                    # 지정된 인코딩으로 시도
+                    try:
+                        content = file_content.decode(specified_encoding)
+                    except (UnicodeDecodeError, UnicodeError):
+                        # 지정된 인코딩 실패 시 자동 감지 시도
+                        encodings_to_try = ['utf-8', 'cp949', 'euc-kr', 'latin-1']
+                        for encoding in encodings_to_try:
+                            if encoding == specified_encoding:
+                                continue
+                            try:
+                                content = file_content.decode(encoding)
+                                specified_encoding = encoding  # 성공한 인코딩으로 업데이트
+                                break
+                            except (UnicodeDecodeError, UnicodeError):
+                                continue
+                        
+                        if not content:
+                            return jsonify({'error': f'파일 인코딩 오류: {specified_encoding} 및 자동 감지 실패'}), 500
+                    
+                    original_filename = file.filename
+                except Exception as e:
+                    import traceback
+                    print(f"[회차 변환] 파일 읽기 오류: {str(e)}")
+                    print(traceback.format_exc())
+                    return jsonify({'error': f'파일 읽기 오류: {str(e)}'}), 500
+        
+        # JSON 데이터에서 내용 가져오기 (파일이 없는 경우)
+        if not content:
+            try:
+                data = request.get_json(silent=True) or {}
+                content = data.get('content', '')
+                original_filename = data.get('filename', 'converted_file.txt')
+            except Exception as e:
+                print(f"[회차 변환] JSON 파싱 오류: {str(e)}")
+                return jsonify({'error': f'요청 데이터 파싱 오류: {str(e)}'}), 400
+        
+        if not content or not content.strip():
+            return jsonify({'error': '파일을 업로드하거나 내용을 입력해주세요.'}), 400
+        
+        # 변환 실행
+        try:
+            converted_content = convert_episode_format(content)
+        except Exception as e:
+            import traceback
+            print(f"[회차 변환] 변환 함수 오류: {str(e)}")
+            print(traceback.format_exc())
+            return jsonify({'error': f'변환 실행 오류: {str(e)}'}), 500
+        
+        # 임시 파일로 저장
+        try:
+            temp_dir = os.path.join(os.getcwd(), 'uploads', 'temp')
+            os.makedirs(temp_dir, exist_ok=True)
+            
+            # 원본 파일명에서 확장자 추출
+            if '.' in original_filename:
+                name, ext = os.path.splitext(original_filename)
+                converted_filename = f"{name}_converted{ext}"
+            else:
+                converted_filename = f"{original_filename}_converted.txt"
+            
+            # 안전한 파일명 생성
+            safe_filename = secure_filename(converted_filename)
+            if not safe_filename:
+                safe_filename = 'converted_file.txt'
+            
+            temp_file_path = os.path.join(temp_dir, f"{uuid.uuid4().hex}_{safe_filename}")
+            
+            # 변환된 내용을 임시 파일에 저장
+            with open(temp_file_path, 'w', encoding='utf-8') as f:
+                f.write(converted_content)
+            
+            # 상대 경로 반환 (다운로드용)
+            relative_path = os.path.relpath(temp_file_path, os.getcwd())
+            # Windows 경로를 URL 인코딩
+            relative_path = relative_path.replace('\\', '/')
+            
+            return jsonify({
+                'success': True,
+                'message': '회차 구분 방식이 변환되었습니다.',
+                'converted_content': converted_content[:500] + '...' if len(converted_content) > 500 else converted_content,
+                'download_url': f'/api/admin/utils/download-converted-file?path={relative_path}',
+                'filename': safe_filename
+            }), 200
+        except Exception as e:
+            import traceback
+            print(f"[회차 변환] 파일 저장 오류: {str(e)}")
+            print(traceback.format_exc())
+            return jsonify({'error': f'파일 저장 오류: {str(e)}'}), 500
+        
+    except Exception as e:
+        import traceback
+        print(f"[회차 변환] 전체 오류: {str(e)}")
+        print(traceback.format_exc())
+        return jsonify({'error': f'변환 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/utils/download-converted-file', methods=['GET'])
+@admin_required
+def download_converted_file():
+    """변환된 파일 다운로드"""
+    try:
+        file_path = request.args.get('path')
+        if not file_path:
+            return jsonify({'error': '파일 경로가 필요합니다.'}), 400
+        
+        # 보안: 상대 경로만 허용
+        if os.path.isabs(file_path) or '..' in file_path:
+            return jsonify({'error': '잘못된 파일 경로입니다.'}), 400
+        
+        full_path = os.path.join(os.getcwd(), file_path)
+        
+        # 파일 존재 확인
+        if not os.path.exists(full_path):
+            return jsonify({'error': '파일을 찾을 수 없습니다.'}), 404
+        
+        # 파일명 추출
+        filename = os.path.basename(full_path)
+        # UUID 접두사 제거
+        if '_' in filename:
+            filename = '_'.join(filename.split('_')[1:])
+        
+        return send_file(
+            full_path,
+            as_attachment=True,
+            download_name=filename,
+            mimetype='text/plain; charset=utf-8'
+        )
+    except Exception as e:
+        return jsonify({'error': f'파일 다운로드 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/token-usage', methods=['GET'])
+@admin_required
+def get_token_usage():
+    """토큰 사용량 통계 API (날짜 범위, 모델별 필터링 지원)"""
+    try:
+        from datetime import datetime, timedelta
+        from sqlalchemy import func, and_
+        
+        # 필터 파라미터 가져오기
+        start_date = request.args.get('start_date')
+        end_date = request.args.get('end_date')
+        model_name = request.args.get('model_name')  # 특정 모델 필터링
+        group_by = request.args.get('group_by', 'day')  # 'day', 'week', 'month', 'model'
+        
+        # 기본 날짜 범위 설정 (최근 30일)
+        if not end_date:
+            end_date = datetime.utcnow()
+        else:
+            try:
+                # ISO 형식 또는 YYYY-MM-DD 형식 파싱
+                if 'T' in end_date:
+                    end_date = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+                else:
+                    # YYYY-MM-DD 형식인 경우 시간을 23:59:59로 설정
+                    end_date = datetime.strptime(end_date, '%Y-%m-%d')
+                    end_date = end_date.replace(hour=23, minute=59, second=59)
+            except Exception as e:
+                print(f"[토큰 통계] 종료 날짜 파싱 오류: {end_date}, {str(e)}")
+                end_date = datetime.utcnow()
+        
+        if not start_date:
+            start_date = end_date - timedelta(days=30)
+        else:
+            try:
+                # ISO 형식 또는 YYYY-MM-DD 형식 파싱
+                if 'T' in start_date:
+                    start_date = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+                else:
+                    # YYYY-MM-DD 형식인 경우 시간을 00:00:00으로 설정
+                    start_date = datetime.strptime(start_date, '%Y-%m-%d')
+                    start_date = start_date.replace(hour=0, minute=0, second=0)
+            except Exception as e:
+                print(f"[토큰 통계] 시작 날짜 파싱 오류: {start_date}, {str(e)}")
+                start_date = end_date - timedelta(days=30)
+        
+        # 쿼리 구성
+        query = ChatMessage.query.filter(
+            ChatMessage.role == 'ai',
+            ChatMessage.created_at >= start_date,
+            ChatMessage.created_at <= end_date
+        )
+        
+        # 모델 필터링
+        if model_name:
+            query = query.filter(ChatMessage.model_name == model_name)
+        
+        # 토큰 정보가 있는 메시지만 조회 (선택적 필터)
+        # 토큰 정보가 없는 메시지도 포함하려면 이 필터를 제거할 수 있음
+        # 하지만 통계 목적상 토큰 정보가 있는 메시지만 조회하는 것이 맞음
+        query = query.filter(
+            db.or_(
+                ChatMessage.input_tokens.isnot(None),
+                ChatMessage.output_tokens.isnot(None)
+            )
+        )
+        
+        messages = query.all()
+        print(f"[토큰 통계] 조회된 메시지 수: {len(messages)} (날짜 범위: {start_date} ~ {end_date})")
+        
+        # 사용자 사용과 시스템 사용 구분
+        user_messages = [msg for msg in messages if not msg.usage_type or msg.usage_type == 'user']
+        system_messages = [msg for msg in messages if msg.usage_type == 'system']
+        print(f"[토큰 통계] 사용자 사용: {len(user_messages)}개, 시스템 사용: {len(system_messages)}개")
+        
+        # 그룹별 집계
+        if group_by == 'day':
+            # 일별 집계
+            daily_stats = {}
+            for msg in messages:
+                date_key = msg.created_at.date().isoformat()
+                if date_key not in daily_stats:
+                    daily_stats[date_key] = {
+                        'date': date_key,
+                        'input_tokens': 0,
+                        'output_tokens': 0,
+                        'total_tokens': 0,
+                        'count': 0
+                    }
+                daily_stats[date_key]['input_tokens'] += msg.input_tokens or 0
+                daily_stats[date_key]['output_tokens'] += msg.output_tokens or 0
+                daily_stats[date_key]['total_tokens'] += (msg.input_tokens or 0) + (msg.output_tokens or 0)
+                daily_stats[date_key]['count'] += 1
+            
+            stats = sorted(daily_stats.values(), key=lambda x: x['date'])
+        elif group_by == 'model':
+            # 모델별 집계 (시스템 사용 포함)
+            model_stats = {}
+            for msg in messages:
+                # 시스템 사용은 '시스템 사용'으로 표시
+                if msg.usage_type == 'system':
+                    model_key = '시스템 사용'
+                else:
+                    model_key = msg.model_name or 'Unknown'
+                
+                if model_key not in model_stats:
+                    model_stats[model_key] = {
+                        'model': model_key,
+                        'input_tokens': 0,
+                        'output_tokens': 0,
+                        'total_tokens': 0,
+                        'count': 0
+                    }
+                model_stats[model_key]['input_tokens'] += msg.input_tokens or 0
+                model_stats[model_key]['output_tokens'] += msg.output_tokens or 0
+                model_stats[model_key]['total_tokens'] += (msg.input_tokens or 0) + (msg.output_tokens or 0)
+                model_stats[model_key]['count'] += 1
+            
+            stats = list(model_stats.values())
+        else:
+            # 전체 집계
+            total_input = sum(msg.input_tokens or 0 for msg in messages)
+            total_output = sum(msg.output_tokens or 0 for msg in messages)
+            stats = [{
+                'input_tokens': total_input,
+                'output_tokens': total_output,
+                'total_tokens': total_input + total_output,
+                'count': len(messages)
+            }]
+        
+        # 사용 가능한 모델 목록
+        available_models = db.session.query(
+            ChatMessage.model_name
+        ).filter(
+            ChatMessage.role == 'ai',
+            ChatMessage.model_name.isnot(None)
+        ).distinct().all()
+        
+        models = [m[0] for m in available_models if m[0]]
+        
+        # 사용자 사용과 시스템 사용 통계
+        user_total_input = sum(msg.input_tokens or 0 for msg in user_messages)
+        user_total_output = sum(msg.output_tokens or 0 for msg in user_messages)
+        system_total_input = sum(msg.input_tokens or 0 for msg in system_messages)
+        system_total_output = sum(msg.output_tokens or 0 for msg in system_messages)
+        
+        return jsonify({
+            'success': True,
+            'stats': stats,
+            'models': models,
+            'start_date': start_date.isoformat(),
+            'end_date': end_date.isoformat(),
+            'total_messages': len(messages),
+            'user_usage': {
+                'input_tokens': user_total_input,
+                'output_tokens': user_total_output,
+                'total_tokens': user_total_input + user_total_output,
+                'count': len(user_messages)
+            },
+            'system_usage': {
+                'input_tokens': system_total_input,
+                'output_tokens': system_total_output,
+                'total_tokens': system_total_input + system_total_output,
+                'count': len(system_messages)
+            }
+        }), 200
+        
+    except Exception as e:
+        import traceback
+        print(f"[토큰 통계] 오류: {str(e)}")
+        print(traceback.format_exc())
+        return jsonify({'error': f'토큰 통계 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
 @main_bp.route('/api/admin/users', methods=['GET'])
 @admin_required
 def get_users():
@@ -1887,10 +2443,14 @@ def get_all_messages():
         page = request.args.get('page', 1, type=int)
         per_page = request.args.get('per_page', 50, type=int)
         
-        query = ChatMessage.query.join(ChatSession)
-        
+        # user_id가 있는 경우에만 join 사용, 그 외에는 직접 조회
         if user_id:
-            query = query.filter(ChatSession.user_id == user_id)
+            # user_id로 필터링할 때는 join 필요
+            query = ChatMessage.query.join(ChatSession).filter(ChatSession.user_id == user_id)
+        else:
+            # user_id가 없으면 join 없이 직접 조회
+            query = ChatMessage.query
+        
         if session_id:
             query = query.filter(ChatMessage.session_id == session_id)
         if message_id:
@@ -1907,6 +2467,10 @@ def get_all_messages():
         }), 200
         
     except Exception as e:
+        import traceback
+        error_trace = traceback.format_exc()
+        print(f"[메시지 조회] 오류: {str(e)}")
+        print(error_trace)
         return jsonify({'error': f'메시지 조회 중 오류가 발생했습니다: {str(e)}'}), 500
 
 @main_bp.route('/api/admin/sessions', methods=['GET'])
@@ -1928,10 +2492,33 @@ def get_all_sessions():
         
         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)
+            try:
+                session_dict = session.to_dict()
+                # 사용자 정보 안전하게 가져오기
+                try:
+                    if session.user:
+                        session_dict['username'] = session.user.username if hasattr(session.user, 'username') else 'Unknown'
+                        session_dict['nickname'] = session.user.nickname if hasattr(session.user, 'nickname') else None
+                    else:
+                        # user_id로 직접 조회 시도
+                        user = User.query.get(session.user_id) if session.user_id else None
+                        if user:
+                            session_dict['username'] = user.username
+                            session_dict['nickname'] = user.nickname
+                        else:
+                            session_dict['username'] = 'Unknown'
+                            session_dict['nickname'] = None
+                except Exception as user_error:
+                    print(f"[세션 조회] 사용자 정보 조회 오류 (세션 ID: {session.id}): {str(user_error)}")
+                    session_dict['username'] = 'Unknown'
+                    session_dict['nickname'] = None
+                
+                sessions_data.append(session_dict)
+            except Exception as session_error:
+                print(f"[세션 조회] 세션 처리 오류 (세션 ID: {session.id if hasattr(session, 'id') else 'Unknown'}): {str(session_error)}")
+                import traceback
+                traceback.print_exc()
+                continue  # 문제가 있는 세션은 건너뛰고 계속 진행
         
         return jsonify({
             'sessions': sessions_data,
@@ -1941,6 +2528,10 @@ def get_all_sessions():
         }), 200
         
     except Exception as e:
+        import traceback
+        error_trace = traceback.format_exc()
+        print(f"[세션 조회] 전체 오류: {str(e)}")
+        print(error_trace)
         return jsonify({'error': f'대화 세션 조회 중 오류가 발생했습니다: {str(e)}'}), 500
 
 @main_bp.route('/api/admin/users/<int:user_id>', methods=['DELETE'])
@@ -2465,7 +3056,11 @@ def get_database_status():
         try:
             if is_postgresql:
                 # PostgreSQL 연결 테스트
-                engine = create_engine(db_uri)
+                engine = create_engine(
+                    db_uri,
+                    pool_pre_ping=True,
+                    pool_recycle=300
+                )
                 with engine.connect() as conn:
                     # 버전 확인
                     result = conn.execute(text("SELECT version()"))
@@ -2603,6 +3198,76 @@ def get_all_ollama_models():
     except Exception as e:
         return jsonify({'error': f'모델 목록을 가져오는 중 오류가 발생했습니다: {str(e)}', 'models': []}), 500
 
+@main_bp.route('/api/admin/default-models', methods=['GET'])
+@admin_required
+def get_default_models():
+    """기본 AI 모델 설정 조회"""
+    try:
+        default_analysis_model = SystemConfig.get_config('default_analysis_model', '')
+        default_answer_model = SystemConfig.get_config('default_answer_model', '')
+        
+        return jsonify({
+            'success': True,
+            'default_analysis_model': default_analysis_model,
+            'default_answer_model': default_answer_model
+        }), 200
+    except Exception as e:
+        return jsonify({'error': f'기본 모델 설정 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/admin/default-models', methods=['POST'])
+@admin_required
+def set_default_models():
+    """기본 AI 모델 설정 저장"""
+    try:
+        data = request.json
+        default_analysis_model = data.get('default_analysis_model', '').strip()
+        default_answer_model = data.get('default_answer_model', '').strip()
+        
+        # 빈 문자열이면 설정 삭제
+        if default_analysis_model:
+            SystemConfig.set_config('default_analysis_model', default_analysis_model, '기본 질문 분석용 AI 모델')
+        else:
+            # 설정 삭제
+            config = SystemConfig.query.filter_by(key='default_analysis_model').first()
+            if config:
+                db.session.delete(config)
+                db.session.commit()
+        
+        if default_answer_model:
+            SystemConfig.set_config('default_answer_model', default_answer_model, '기본 답변 생성용 AI 모델')
+        else:
+            # 설정 삭제
+            config = SystemConfig.query.filter_by(key='default_answer_model').first()
+            if config:
+                db.session.delete(config)
+                db.session.commit()
+        
+        return jsonify({
+            'success': True,
+            'message': '기본 AI 모델이 설정되었습니다.',
+            'default_analysis_model': default_analysis_model or None,
+            'default_answer_model': default_answer_model or None
+        }), 200
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': f'기본 모델 설정 저장 중 오류가 발생했습니다: {str(e)}'}), 500
+
+@main_bp.route('/api/default-models', methods=['GET'])
+@login_required
+def get_user_default_models():
+    """사용자용: 기본 AI 모델 설정 조회 (공개 API)"""
+    try:
+        default_analysis_model = SystemConfig.get_config('default_analysis_model', '')
+        default_answer_model = SystemConfig.get_config('default_answer_model', '')
+        
+        return jsonify({
+            'success': True,
+            'default_analysis_model': default_analysis_model,
+            'default_answer_model': default_answer_model
+        }), 200
+    except Exception as e:
+        return jsonify({'error': f'기본 모델 설정 조회 중 오류가 발생했습니다: {str(e)}'}), 500
+
 @main_bp.route('/api/chat', methods=['POST'])
 @login_required
 def chat():
@@ -3032,6 +3697,14 @@ def chat():
                 # 모델 타입 확인 (Gemini 또는 Ollama)
                 is_gemini = answer_model.startswith('gemini:')
                 
+                # 토큰 정보 변수 초기화
+                gemini_input_tokens = None
+                gemini_output_tokens = None
+                gemini_model_used = None
+                ollama_input_tokens = None
+                ollama_output_tokens = None
+                ollama_model_used = None
+                
                 print(f"[최종 답변 생성] 답변 모델: {answer_model}, 프롬프트 길이: {len(full_prompt)}자")
                 
                 if is_gemini:
@@ -3057,6 +3730,11 @@ def chat():
                     if not response_text:
                         print(f"[채팅] Gemini 응답이 비어있습니다. result: {result}")
                         response_text = '응답을 생성할 수 없었습니다. 다시 시도해주세요.'
+                    
+                    # 토큰 정보 추출
+                    gemini_input_tokens = result.get('input_tokens')
+                    gemini_output_tokens = result.get('output_tokens')
+                    gemini_model_used = gemini_model_name
                 else:
                     # Ollama API 호출
                     # Ollama 서버 연결 확인
@@ -3105,6 +3783,18 @@ def chat():
                     if not response_text:
                         print(f"[채팅] Ollama 응답이 비어있습니다. ollama_data: {ollama_data}")
                         response_text = '응답을 생성할 수 없었습니다. 다시 시도해주세요.'
+                    
+                    # Ollama 토큰 정보 추출
+                    ollama_input_tokens = None
+                    ollama_output_tokens = None
+                    if 'prompt_eval_count' in ollama_data:
+                        ollama_input_tokens = ollama_data.get('prompt_eval_count')
+                    if 'eval_count' in ollama_data:
+                        ollama_output_tokens = ollama_data.get('eval_count')
+                    ollama_model_used = answer_model
+                    
+                    if ollama_input_tokens or ollama_output_tokens:
+                        print(f"[Ollama] 토큰 사용량: 입력={ollama_input_tokens}, 출력={ollama_output_tokens}")
                 
                 # 대화 세션에 메시지 저장 (Gemini와 Ollama 공통)
                 session_id = data.get('session_id')
@@ -3160,14 +3850,25 @@ def chat():
                             else:
                                 print(f"[메시지 저장] 중복 메시지로 인해 저장을 건너뜁니다.")
                             
-                            # AI 응답 저장
+                            # AI 응답 저장 (토큰 정보 포함)
+                            # 토큰 정보 설정 (Gemini 또는 Ollama)
+                            input_tokens = gemini_input_tokens if is_gemini else ollama_input_tokens
+                            output_tokens = gemini_output_tokens if is_gemini else ollama_output_tokens
+                            model_used = gemini_model_used if is_gemini else ollama_model_used
+                            
                             ai_msg = ChatMessage(
                                 session_id=session_id,
                                 role='ai',
-                                content=response_text
+                                content=response_text,
+                                input_tokens=input_tokens,
+                                output_tokens=output_tokens,
+                                model_name=model_used
                             )
                             db.session.add(ai_msg)
                             
+                            if input_tokens or output_tokens:
+                                print(f"[메시지 저장] AI 메시지 저장 (모델: {model_used}, 입력 토큰: {input_tokens}, 출력 토큰: {output_tokens})")
+                            
                             # 세션 모델 정보 업데이트 (첫 메시지인 경우 또는 변경된 경우)
                             if not session.analysis_model or session.analysis_model != analysis_model:
                                 session.analysis_model = analysis_model

app/vector_db.py

@@ -5,12 +5,19 @@ Chroma DB를 사용한 벡터 검색 및 Re-ranking 시스템
 
 import os
 import json
+import logging
 import chromadb
 from chromadb.config import Settings
 from sentence_transformers import SentenceTransformer, CrossEncoder
 from pathlib import Path
 import numpy as np
 
+# ChromaDB 텔레메트리 오류 억제
+logging.getLogger('chromadb.telemetry.product.posthog').setLevel(logging.CRITICAL)
+
+# 환경 변수로 텔레메트리 비활성화 (ChromaDB가 지원하는 경우)
+os.environ.setdefault('CHROMA_TELEMETRY_DISABLED', '1')
+
 # 벡터 DB 경로
 VECTOR_DB_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'vector_db')
 

requirements.txt

@@ -1,17 +1,17 @@
-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
-chromadb==0.4.22
-sentence-transformers==2.3.1
-numpy==1.24.3
-google-generativeai==0.3.2
-pydantic==2.5.0
-pydantic-settings==2.1.0
-# Database drivers
-psycopg2-binary  # PostgreSQL support for external database
-# Ollama와 파이썬을 연결하려면 아래 패키지가 보통 필요합니다.
-ollama
-
+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
+chromadb==0.4.22
+sentence-transformers==2.3.1
+numpy==1.24.3
+google-generativeai==0.3.2
+pydantic==2.5.0
+pydantic-settings==2.1.0
+# Database drivers
+psycopg2-binary  # PostgreSQL support for external database
+# Ollama와 파이썬을 연결하려면 아래 패키지가 보통 필요합니다.
+ollama
+

templates/admin.html

@@ -571,6 +571,8 @@
             <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
             <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
             <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
+            <a href="{{ url_for('main.admin_utils') }}" class="btn btn-secondary">유틸</a>
+            <a href="{{ url_for('main.admin_tokens') }}" 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>
@@ -590,6 +592,8 @@
                 <a href="{{ url_for('main.admin_messages') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메시지 확인</a>
                 <a href="{{ url_for('main.admin_prompts') }}" class="mobile-menu-item" onclick="closeMobileMenu()">프롬프트 관리</a>
                 <a href="{{ url_for('main.admin_settings') }}" class="mobile-menu-item" onclick="closeMobileMenu()">AI 설정</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
+                <a href="{{ url_for('main.admin_tokens') }}" class="mobile-menu-item" onclick="closeMobileMenu()">토큰 통계</a>
                 <a href="{{ url_for('main.index') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메인으로</a>
                 <a href="{{ url_for('main.logout') }}" class="mobile-menu-item" onclick="closeMobileMenu()">로그아웃</a>
             </div>

templates/admin_files.html

@@ -473,6 +473,9 @@
             <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
             <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
             <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
+            <a href="{{ url_for('main.admin_utils') }}" class="btn btn-secondary">유틸</a>
+            <a href="{{ url_for('main.admin_tokens') }}" class="btn btn-secondary">토큰 통계</a>
+            <a href="{{ url_for('main.admin_utils') }}" 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>
@@ -492,6 +495,9 @@
                 <a href="{{ url_for('main.admin_messages') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메시지 확인</a>
                 <a href="{{ url_for('main.admin_prompts') }}" class="mobile-menu-item" onclick="closeMobileMenu()">프롬프트 관리</a>
                 <a href="{{ url_for('main.admin_settings') }}" class="mobile-menu-item" onclick="closeMobileMenu()">AI 설정</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
+                <a href="{{ url_for('main.admin_tokens') }}" class="mobile-menu-item" onclick="closeMobileMenu()">토큰 통계</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
                 <a href="{{ url_for('main.index') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메인으로</a>
                 <a href="{{ url_for('main.logout') }}" class="mobile-menu-item" onclick="closeMobileMenu()">로그아웃</a>
             </div>

templates/admin_messages.html

@@ -474,6 +474,9 @@
             <a href="{{ url_for('main.admin_files') }}" class="btn btn-secondary">파일 목록</a>
             <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
             <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
+            <a href="{{ url_for('main.admin_utils') }}" class="btn btn-secondary">유틸</a>
+            <a href="{{ url_for('main.admin_tokens') }}" class="btn btn-secondary">토큰 통계</a>
+            <a href="{{ url_for('main.admin_utils') }}" 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>
@@ -493,6 +496,9 @@
                 <a href="{{ url_for('main.admin_files') }}" class="mobile-menu-item" onclick="closeMobileMenu()">파일 목록</a>
                 <a href="{{ url_for('main.admin_prompts') }}" class="mobile-menu-item" onclick="closeMobileMenu()">프롬프트 관리</a>
                 <a href="{{ url_for('main.admin_settings') }}" class="mobile-menu-item" onclick="closeMobileMenu()">AI 설정</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
+                <a href="{{ url_for('main.admin_tokens') }}" class="mobile-menu-item" onclick="closeMobileMenu()">토큰 통계</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
                 <a href="{{ url_for('main.index') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메인으로</a>
                 <a href="{{ url_for('main.logout') }}" class="mobile-menu-item" onclick="closeMobileMenu()">로그아웃</a>
             </div>
@@ -576,13 +582,16 @@
                         <th>세션 ID</th>
                         <th>역할</th>
                         <th>내용</th>
+                        <th>모델</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>
+                        <td colspan="9" style="text-align: center; padding: 20px; color: #5f6368;">로딩 중...</td>
                     </tr>
                 </tbody>
             </table>
@@ -718,7 +727,7 @@
         // 메시지 목록 로드
         async function loadMessages(page = 1) {
             const tbody = document.getElementById('messagesTableBody');
-            tbody.innerHTML = '<tr><td colspan="6" style="text-align: center; padding: 20px; color: #5f6368;">로딩 중...</td></tr>';
+            tbody.innerHTML = '<tr><td colspan="9" style="text-align: center; padding: 20px; color: #5f6368;">로딩 중...</td></tr>';
             
             try {
                 const sessionId = document.getElementById('sessionIdFilter').value;
@@ -749,12 +758,18 @@
                         const row = document.createElement('tr');
                         const date = new Date(msg.created_at).toLocaleString('ko-KR');
                         const contentPreview = msg.content && msg.content.length > 100 ? msg.content.substring(0, 100) + '...' : (msg.content || '');
+                        const modelName = msg.model_name || '-';
+                        const inputTokens = msg.input_tokens !== null && msg.input_tokens !== undefined ? msg.input_tokens.toLocaleString() : '-';
+                        const outputTokens = msg.output_tokens !== null && msg.output_tokens !== undefined ? msg.output_tokens.toLocaleString() : '-';
                         
                         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>${modelName}</td>
+                            <td style="text-align: right;">${inputTokens}</td>
+                            <td style="text-align: right;">${outputTokens}</td>
                             <td>${date}</td>
                             <td>
                                 <button class="btn btn-secondary" onclick="viewMessageById(${msg.id})" style="padding: 4px 8px; font-size: 12px;">상세 보기</button>
@@ -764,11 +779,14 @@
                         row.setAttribute('data-message-id', msg.id);
                         row.setAttribute('data-message-role', msg.role);
                         row.setAttribute('data-message-content', escapeHtml(msg.content || ''));
+                        row.setAttribute('data-message-model', modelName);
+                        row.setAttribute('data-message-input-tokens', msg.input_tokens || '');
+                        row.setAttribute('data-message-output-tokens', msg.output_tokens || '');
                         tbody.appendChild(row);
                     });
                 } else {
                     console.log('[메시지 목록] 메시지가 없습니다');
-                    tbody.innerHTML = '<tr><td colspan="6" style="text-align: center; padding: 20px; color: #5f6368;">메시지가 없습니다.</td></tr>';
+                    tbody.innerHTML = '<tr><td colspan="9" style="text-align: center; padding: 20px; color: #5f6368;">메시지가 없습니다.</td></tr>';
                 }
                 
                 // 페이지네이션
@@ -783,7 +801,7 @@
             } catch (error) {
                 console.error('[메시지 목록] 조회 오류:', error);
                 showAlert(`메시지 조회 오류: ${error.message}`, 'error');
-                tbody.innerHTML = `<tr><td colspan="6" style="text-align: center; padding: 20px; color: #ea4335;">메시지 조회 중 오류가 발생했습니다.<br><small>${error.message || '알 수 없는 오류'}</small></td></tr>`;
+                tbody.innerHTML = `<tr><td colspan="9" style="text-align: center; padding: 20px; color: #ea4335;">메시지 조회 중 오류가 발생했습니다.<br><small>${error.message || '알 수 없는 오류'}</small></td></tr>`;
             }
         }
 
@@ -802,7 +820,51 @@
                 
                 if (data.messages && data.messages.length > 0) {
                     const msg = data.messages[0];
-                    viewMessage(msg.id, msg.role, msg.content);
+                    const modelName = msg.model_name || '-';
+                    const inputTokens = msg.input_tokens;
+                    const outputTokens = msg.output_tokens;
+                    
+                    // 메시지 상세 보기 (토큰 정보 포함)
+                    const modal = document.getElementById('messageModal');
+                    const modalContent = document.getElementById('messageModalContent');
+                    
+                    let tokenInfo = '';
+                    if (msg.role === 'ai' && (inputTokens || outputTokens)) {
+                        tokenInfo = `
+                            <div style="margin-top: 16px; padding: 12px; background: #f8f9fa; border-radius: 6px;">
+                                <div style="font-size: 14px; font-weight: 500; margin-bottom: 8px; color: #5f6368;">토큰 사용량</div>
+                                <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px;">
+                                    <div>
+                                        <div style="font-size: 12px; color: #5f6368; margin-bottom: 4px;">모델</div>
+                                        <div style="font-size: 16px; font-weight: 500;">${modelName}</div>
+                                    </div>
+                                    <div>
+                                        <div style="font-size: 12px; color: #5f6368; margin-bottom: 4px;">입력 토큰</div>
+                                        <div style="font-size: 16px; font-weight: 500;">${inputTokens ? parseInt(inputTokens).toLocaleString() : '-'}</div>
+                                    </div>
+                                    <div>
+                                        <div style="font-size: 12px; color: #5f6368; margin-bottom: 4px;">출력 토큰</div>
+                                        <div style="font-size: 16px; font-weight: 500;">${outputTokens ? parseInt(outputTokens).toLocaleString() : '-'}</div>
+                                    </div>
+                                </div>
+                            </div>
+                        `;
+                    }
+                    
+                    modalContent.innerHTML = `
+                        <div class="message-view">
+                            <div class="message-item ${msg.role}">
+                                <div class="message-item-header">
+                                    <span class="message-item-role role-badge role-${msg.role}">${msg.role === 'user' ? '사용자' : 'AI'}</span>
+                                    <span class="message-item-time">메시지 ID: ${msg.id}</span>
+                                </div>
+                                <div class="message-item-content">${escapeHtml(msg.content || '')}</div>
+                                ${tokenInfo}
+                            </div>
+                        </div>
+                    `;
+                    
+                    modal.classList.add('active');
                 } else {
                     // 데이터 속성에서 가져오기 (fallback)
                     const row = document.querySelector(`tr[data-message-id="${messageId}"]`);
@@ -833,6 +895,35 @@
             const modal = document.getElementById('messageModal');
             const modalContent = document.getElementById('messageModalContent');
             
+            // 데이터 속성에서 토큰 정보 가져오기
+            const row = document.querySelector(`tr[data-message-id="${messageId}"]`);
+            const modelName = row ? row.getAttribute('data-message-model') : '-';
+            const inputTokens = row ? row.getAttribute('data-message-input-tokens') : '';
+            const outputTokens = row ? row.getAttribute('data-message-output-tokens') : '';
+            
+            let tokenInfo = '';
+            if (role === 'ai' && (inputTokens || outputTokens)) {
+                tokenInfo = `
+                    <div style="margin-top: 16px; padding: 12px; background: #f8f9fa; border-radius: 6px;">
+                        <div style="font-size: 14px; font-weight: 500; margin-bottom: 8px; color: #5f6368;">토큰 사용량</div>
+                        <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px;">
+                            <div>
+                                <div style="font-size: 12px; color: #5f6368; margin-bottom: 4px;">모델</div>
+                                <div style="font-size: 16px; font-weight: 500;">${modelName}</div>
+                            </div>
+                            <div>
+                                <div style="font-size: 12px; color: #5f6368; margin-bottom: 4px;">입력 토큰</div>
+                                <div style="font-size: 16px; font-weight: 500;">${inputTokens ? parseInt(inputTokens).toLocaleString() : '-'}</div>
+                            </div>
+                            <div>
+                                <div style="font-size: 12px; color: #5f6368; margin-bottom: 4px;">출력 토큰</div>
+                                <div style="font-size: 16px; font-weight: 500;">${outputTokens ? parseInt(outputTokens).toLocaleString() : '-'}</div>
+                            </div>
+                        </div>
+                    </div>
+                `;
+            }
+            
             modalContent.innerHTML = `
                 <div class="message-view">
                     <div class="message-item ${role}">
@@ -841,6 +932,7 @@
                             <span class="message-item-time">메시지 ID: ${messageId}</span>
                         </div>
                         <div class="message-item-content">${content}</div>
+                        ${tokenInfo}
                     </div>
                 </div>
             `;
@@ -912,6 +1004,8 @@
         window.addEventListener('load', () => {
             loadUsers();
             loadSessions();
+            // 세션 ID가 없어도 전체 메시지 로드
+            loadMessages(1);
         });
     </script>
 </body>

templates/admin_prompts.html

@@ -328,6 +328,9 @@
             <a href="{{ url_for('main.admin_files') }}" class="btn btn-secondary">파일 목록</a>
             <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
             <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
+            <a href="{{ url_for('main.admin_utils') }}" class="btn btn-secondary">유틸</a>
+            <a href="{{ url_for('main.admin_tokens') }}" class="btn btn-secondary">토큰 통계</a>
+            <a href="{{ url_for('main.admin_utils') }}" 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>
@@ -347,6 +350,9 @@
                 <a href="{{ url_for('main.admin_files') }}" class="mobile-menu-item" onclick="closeMobileMenu()">파일 목록</a>
                 <a href="{{ url_for('main.admin_messages') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메시지 확인</a>
                 <a href="{{ url_for('main.admin_settings') }}" class="mobile-menu-item" onclick="closeMobileMenu()">AI 설정</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
+                <a href="{{ url_for('main.admin_tokens') }}" class="mobile-menu-item" onclick="closeMobileMenu()">토큰 통계</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
                 <a href="{{ url_for('main.index') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메인으로</a>
                 <a href="{{ url_for('main.logout') }}" class="mobile-menu-item" onclick="closeMobileMenu()">로그아웃</a>
             </div>

templates/admin_settings.html

@@ -291,6 +291,10 @@
             <a href="{{ url_for('main.admin_files') }}" class="btn btn-secondary">파일 목록</a>
             <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
             <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
+            <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
+            <a href="{{ url_for('main.admin_utils') }}" class="btn btn-secondary">유틸</a>
+            <a href="{{ url_for('main.admin_tokens') }}" class="btn btn-secondary">토큰 통계</a>
+            <a href="{{ url_for('main.admin_utils') }}" 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>
@@ -310,6 +314,10 @@
                 <a href="{{ url_for('main.admin_files') }}" class="mobile-menu-item" onclick="closeMobileMenu()">파일 목록</a>
                 <a href="{{ url_for('main.admin_messages') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메시지 확인</a>
                 <a href="{{ url_for('main.admin_prompts') }}" class="mobile-menu-item" onclick="closeMobileMenu()">프롬프트 관리</a>
+                <a href="{{ url_for('main.admin_settings') }}" class="mobile-menu-item" onclick="closeMobileMenu()">AI 설정</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
+                <a href="{{ url_for('main.admin_tokens') }}" class="mobile-menu-item" onclick="closeMobileMenu()">토큰 통계</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
                 <a href="{{ url_for('main.index') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메인으로</a>
                 <a href="{{ url_for('main.logout') }}" class="mobile-menu-item" onclick="closeMobileMenu()">로그아웃</a>
             </div>
@@ -366,6 +374,43 @@
             </div>
         </div>
 
+        <!-- 기본 AI 모델 설정 섹션 -->
+        <div class="card">
+            <div class="card-header">
+                <div class="card-title">기본 AI 모델 설정</div>
+                <button class="btn btn-secondary" onclick="loadDefaultModels()">새로고침</button>
+            </div>
+            <div style="padding: 16px 0;">
+                <div id="defaultModelsStatus" style="margin-bottom: 16px; font-size: 13px;"></div>
+                <div style="display: grid; gap: 16px;">
+                    <div class="form-group">
+                        <label for="defaultAnalysisModel">기본 질문 분석용 AI 모델 (AI 모델 선택)</label>
+                        <div style="display: flex; gap: 8px;">
+                            <select id="defaultAnalysisModel" style="flex: 1; padding: 8px 12px; border: 1px solid #dadce0; border-radius: 4px; font-size: 14px;">
+                                <option value="">기본값 없음</option>
+                            </select>
+                            <button class="btn btn-primary" onclick="saveDefaultModels()">저장</button>
+                        </div>
+                        <small style="color: #5f6368; font-size: 12px; display: block; margin-top: 4px;">
+                            사용자 화면의 "AI 모델 선택" 드롭다운에서 기본으로 선택될 모델입니다.
+                        </small>
+                    </div>
+                    <div class="form-group">
+                        <label for="defaultAnswerModel">기본 답변 생성용 AI 모델 (사용 가능한 AI 목록)</label>
+                        <div style="display: flex; gap: 8px;">
+                            <select id="defaultAnswerModel" style="flex: 1; padding: 8px 12px; border: 1px solid #dadce0; border-radius: 4px; font-size: 14px;">
+                                <option value="">기본값 없음</option>
+                            </select>
+                            <button class="btn btn-primary" onclick="saveDefaultModels()">저장</button>
+                        </div>
+                        <small style="color: #5f6368; font-size: 12px; display: block; margin-top: 4px;">
+                            사용자 화면의 "사용 가능한 AI 목록" 드롭다운에서 기본으로 선택될 모델입니다.
+                        </small>
+                    </div>
+                </div>
+            </div>
+        </div>
+
         <!-- AI 모델별 토큰 수 관리 섹션 -->
         <div class="card">
             <div class="card-header">
@@ -845,11 +890,158 @@
             return id;
         }
 
+        // 기본 AI 모델 설정 관련 함수
+        async function loadDefaultModels() {
+            const statusDiv = document.getElementById('defaultModelsStatus');
+            const analysisSelect = document.getElementById('defaultAnalysisModel');
+            const answerSelect = document.getElementById('defaultAnswerModel');
+            
+            try {
+                statusDiv.innerHTML = '<span style="color: #1a73e8;">기본 모델 설정을 불러오는 중...</span>';
+                
+                // 모델 목록 가져오기
+                const modelsResponse = await fetch('/api/admin/ollama/models', {
+                    credentials: 'include'
+                });
+                
+                if (!modelsResponse.ok) {
+                    throw new Error('모델 목록을 불러올 수 없습니다.');
+                }
+                
+                const modelsData = await modelsResponse.json();
+                
+                // 드롭다운 초기화
+                analysisSelect.innerHTML = '<option value="">기본값 없음</option>';
+                answerSelect.innerHTML = '<option value="">기본값 없음</option>';
+                
+                // 모델을 타입별로 그룹화
+                const ollamaModels = [];
+                const geminiModels = [];
+                
+                if (modelsData.models && modelsData.models.length > 0) {
+                    modelsData.models.forEach(model => {
+                        if (model.type === 'ollama') {
+                            ollamaModels.push(model);
+                        } else if (model.type === 'gemini') {
+                            geminiModels.push(model);
+                        }
+                    });
+                }
+                
+                // Ollama 모델 추가
+                if (ollamaModels.length > 0) {
+                    const optgroup1 = document.createElement('optgroup');
+                    optgroup1.label = 'Ollama 모델';
+                    ollamaModels.forEach(model => {
+                        const option = document.createElement('option');
+                        option.value = model.name;
+                        option.textContent = model.name;
+                        optgroup1.appendChild(option);
+                    });
+                    analysisSelect.appendChild(optgroup1);
+                    
+                    const optgroup2 = document.createElement('optgroup');
+                    optgroup2.label = 'Ollama 모델';
+                    ollamaModels.forEach(model => {
+                        const option = document.createElement('option');
+                        option.value = model.name;
+                        option.textContent = model.name;
+                        optgroup2.appendChild(option);
+                    });
+                    answerSelect.appendChild(optgroup2);
+                }
+                
+                // Gemini 모델 추가
+                if (geminiModels.length > 0) {
+                    const optgroup1 = document.createElement('optgroup');
+                    optgroup1.label = 'Gemini 모델';
+                    geminiModels.forEach(model => {
+                        const option = document.createElement('option');
+                        option.value = model.name;
+                        option.textContent = model.name.replace('gemini:', '');
+                        optgroup1.appendChild(option);
+                    });
+                    analysisSelect.appendChild(optgroup1);
+                    
+                    const optgroup2 = document.createElement('optgroup');
+                    optgroup2.label = 'Gemini 모델';
+                    geminiModels.forEach(model => {
+                        const option = document.createElement('option');
+                        option.value = model.name;
+                        option.textContent = model.name.replace('gemini:', '');
+                        optgroup2.appendChild(option);
+                    });
+                    answerSelect.appendChild(optgroup2);
+                }
+                
+                // 현재 설정된 기본 모델 가져오기
+                const defaultResponse = await fetch('/api/admin/default-models', {
+                    credentials: 'include'
+                });
+                
+                if (defaultResponse.ok) {
+                    const defaultData = await defaultResponse.json();
+                    if (defaultData.default_analysis_model) {
+                        analysisSelect.value = defaultData.default_analysis_model;
+                    }
+                    if (defaultData.default_answer_model) {
+                        answerSelect.value = defaultData.default_answer_model;
+                    }
+                    statusDiv.innerHTML = '<span style="color: #137333;">✓ 기본 모델 설정을 불러왔습니다.</span>';
+                } else {
+                    statusDiv.innerHTML = '<span style="color: #ea4335;">기본 모델 설정을 불러올 수 없습니다.</span>';
+                }
+            } catch (error) {
+                console.error('기본 모델 설정 로드 오류:', error);
+                statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${error.message}</span>`;
+            }
+        }
+        
+        async function saveDefaultModels() {
+            const analysisSelect = document.getElementById('defaultAnalysisModel');
+            const answerSelect = document.getElementById('defaultAnswerModel');
+            const statusDiv = document.getElementById('defaultModelsStatus');
+            
+            const defaultAnalysisModel = analysisSelect.value;
+            const defaultAnswerModel = answerSelect.value;
+            
+            try {
+                statusDiv.innerHTML = '<span style="color: #1a73e8;">저장 중...</span>';
+                
+                const response = await fetch('/api/admin/default-models', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    credentials: 'include',
+                    body: JSON.stringify({
+                        default_analysis_model: defaultAnalysisModel,
+                        default_answer_model: defaultAnswerModel
+                    })
+                });
+                
+                const data = await response.json();
+                
+                if (response.ok) {
+                    showAlert(data.message || '기본 AI 모델이 저장되었습니다.', 'success');
+                    statusDiv.innerHTML = '<span style="color: #137333;">✓ 기본 모델 설정이 저장되었습니다.</span>';
+                } else {
+                    showAlert(data.error || '기본 모델 설정 저장 중 오류가 발생했습니다.', 'error');
+                    statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${data.error || '알 수 없는 오류'}</span>`;
+                }
+            } catch (error) {
+                console.error('기본 모델 설정 저장 오류:', error);
+                showAlert(`오류: ${error.message}`, 'error');
+                statusDiv.innerHTML = `<span style="color: #ea4335;">오류: ${error.message}</span>`;
+            }
+        }
+
         // 페이지 로드 시 API 키 상태 확인 및 토큰 수 설정 로드
         window.addEventListener('load', () => {
             loadGeminiApiKey();
             loadHuggingFaceToken();
             loadModelTokens();
+            loadDefaultModels();
         });
     </script>
 </body>

templates/admin_tokens.html

@@ -0,0 +1,711 @@
+<!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">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
+    <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;
+        }
+
+        .menu-toggle {
+            display: none;
+            background: none;
+            border: none;
+            font-size: 24px;
+            cursor: pointer;
+            padding: 8px;
+            color: #202124;
+        }
+
+        .mobile-menu {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: rgba(0, 0, 0, 0.5);
+            z-index: 1000;
+        }
+
+        .mobile-menu.active {
+            display: block;
+        }
+
+        .mobile-menu-content {
+            position: fixed;
+            top: 0;
+            right: -100%;
+            width: 280px;
+            max-width: 80%;
+            height: 100%;
+            background: white;
+            box-shadow: -2px 0 8px rgba(0, 0, 0, 0.1);
+            transition: right 0.3s ease;
+            overflow-y: auto;
+            z-index: 1001;
+        }
+
+        .mobile-menu.active .mobile-menu-content {
+            right: 0;
+        }
+
+        .mobile-menu-header {
+            padding: 16px 20px;
+            border-bottom: 1px solid #dadce0;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            background: white;
+            position: sticky;
+            top: 0;
+            z-index: 10;
+        }
+
+        .mobile-menu-title {
+            font-size: 18px;
+            font-weight: 500;
+        }
+
+        .mobile-menu-close {
+            background: none;
+            border: none;
+            font-size: 28px;
+            cursor: pointer;
+            color: #202124;
+            padding: 0;
+            width: 32px;
+            height: 32px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .mobile-menu-user {
+            padding: 12px 20px;
+            background: #f8f9fa;
+            border-bottom: 1px solid #dadce0;
+            font-size: 14px;
+            color: #5f6368;
+        }
+
+        .mobile-menu-items {
+            padding: 8px 0;
+        }
+
+        .mobile-menu-item {
+            display: block;
+            padding: 12px 20px;
+            color: #202124;
+            text-decoration: none;
+            font-size: 14px;
+            transition: background 0.2s;
+        }
+
+        .mobile-menu-item:hover {
+            background: #f8f9fa;
+        }
+
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            text-decoration: none;
+            display: inline-block;
+            transition: all 0.2s;
+        }
+
+        .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;
+            flex-wrap: wrap;
+            margin-bottom: 20px;
+        }
+
+        .filter-group {
+            display: flex;
+            flex-direction: column;
+            gap: 4px;
+        }
+
+        .filter-group label {
+            font-size: 12px;
+            color: #5f6368;
+            font-weight: 500;
+        }
+
+        .filter-group input,
+        .filter-group select {
+            padding: 8px 12px;
+            border: 1px solid #dadce0;
+            border-radius: 6px;
+            font-size: 14px;
+            font-family: inherit;
+        }
+
+        .filter-group input:focus,
+        .filter-group select:focus {
+            outline: none;
+            border-color: #1a73e8;
+            box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.1);
+        }
+
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 16px;
+            margin-bottom: 24px;
+        }
+
+        .stat-card {
+            background: white;
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+        }
+
+        .stat-label {
+            font-size: 14px;
+            color: #5f6368;
+            margin-bottom: 8px;
+        }
+
+        .stat-value {
+            font-size: 24px;
+            font-weight: 600;
+            color: #202124;
+        }
+
+        .chart-container {
+            position: relative;
+            height: 400px;
+            margin-bottom: 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;
+        }
+
+        @media (max-width: 768px) {
+            .header {
+                padding: 12px 16px;
+            }
+
+            .header-title {
+                font-size: 18px;
+            }
+
+            .menu-toggle {
+                display: block;
+            }
+
+            .header-actions {
+                display: none;
+            }
+
+            .container {
+                padding: 16px;
+            }
+
+            .filters {
+                flex-direction: column;
+            }
+
+            .filter-group {
+                width: 100%;
+            }
+
+            .chart-container {
+                height: 300px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <div class="header-title">
+            <span>📊</span>
+            <span>토큰 사용량 통계</span>
+        </div>
+        <button class="menu-toggle" onclick="toggleMobileMenu()" aria-label="메뉴 열기">☰</button>
+        <div class="header-actions">
+            <span style="margin-right: 12px; color: #5f6368;">{{ current_user.nickname or current_user.username }}</span>
+            <a href="{{ url_for('main.admin') }}" class="btn btn-secondary">사용자 관리</a>
+            <a href="{{ url_for('main.admin_webnovels') }}" class="btn btn-secondary">웹소설 관리</a>
+            <a href="{{ url_for('main.admin_files') }}" class="btn btn-secondary">파일 목록</a>
+            <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
+            <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
+            <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
+            <a href="{{ url_for('main.admin_utils') }}" class="btn btn-secondary">유틸</a>
+            <a href="{{ url_for('main.admin_tokens') }}" 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="mobile-menu" id="mobileMenu" onclick="closeMobileMenuOnBackdrop(event)">
+        <div class="mobile-menu-content" onclick="event.stopPropagation()">
+            <div class="mobile-menu-header">
+                <div class="mobile-menu-title">메뉴</div>
+                <button class="mobile-menu-close" onclick="toggleMobileMenu()" aria-label="메뉴 닫기">&times;</button>
+            </div>
+            <div class="mobile-menu-user">{{ current_user.nickname or current_user.username }}</div>
+            <div class="mobile-menu-items">
+                <a href="{{ url_for('main.admin') }}" class="mobile-menu-item" onclick="closeMobileMenu()">사용자 관리</a>
+                <a href="{{ url_for('main.admin_webnovels') }}" class="mobile-menu-item" onclick="closeMobileMenu()">웹소설 관리</a>
+                <a href="{{ url_for('main.admin_files') }}" class="mobile-menu-item" onclick="closeMobileMenu()">파일 목록</a>
+                <a href="{{ url_for('main.admin_messages') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메시지 확인</a>
+                <a href="{{ url_for('main.admin_prompts') }}" class="mobile-menu-item" onclick="closeMobileMenu()">프롬프트 관리</a>
+                <a href="{{ url_for('main.admin_settings') }}" class="mobile-menu-item" onclick="closeMobileMenu()">AI 설정</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
+                <a href="{{ url_for('main.admin_tokens') }}" class="mobile-menu-item" onclick="closeMobileMenu()">토큰 통계</a>
+                <a href="{{ url_for('main.index') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메인으로</a>
+                <a href="{{ url_for('main.logout') }}" class="mobile-menu-item" onclick="closeMobileMenu()">로그아웃</a>
+            </div>
+        </div>
+    </div>
+
+    <div class="container">
+        <div class="page-header">
+            <h1>토큰 사용량 통계</h1>
+            <p>AI 모델별 토큰 사용량을 시각화하여 확인할 수 있습니다.</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 for="startDate">시작 날짜</label>
+                    <input type="date" id="startDate">
+                </div>
+                <div class="filter-group">
+                    <label for="endDate">종료 날짜</label>
+                    <input type="date" id="endDate">
+                </div>
+                <div class="filter-group">
+                    <label for="modelFilter">AI 모델</label>
+                    <select id="modelFilter">
+                        <option value="">전체</option>
+                    </select>
+                </div>
+                <div class="filter-group">
+                    <label for="groupBy">그룹화</label>
+                    <select id="groupBy">
+                        <option value="day">일별</option>
+                        <option value="model">모델별</option>
+                    </select>
+                </div>
+                <div class="filter-group" style="justify-content: flex-end;">
+                    <label>&nbsp;</label>
+                    <button class="btn btn-primary" onclick="loadTokenUsage()">조회</button>
+                </div>
+            </div>
+        </div>
+
+        <!-- 통계 요약 -->
+        <div class="stats-grid" id="statsGrid">
+            <!-- 동적으로 생성됨 -->
+        </div>
+
+        <!-- 그래프 -->
+        <div class="card">
+            <div class="card-header">
+                <div class="card-title">토큰 사용량 그래프</div>
+            </div>
+            <div class="chart-container">
+                <canvas id="tokenChart"></canvas>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let tokenChart = null;
+
+        function toggleMobileMenu() {
+            const menu = document.getElementById('mobileMenu');
+            menu.classList.toggle('active');
+            document.body.style.overflow = menu.classList.contains('active') ? 'hidden' : '';
+        }
+
+        function closeMobileMenu() {
+            const menu = document.getElementById('mobileMenu');
+            menu.classList.remove('active');
+            document.body.style.overflow = '';
+        }
+
+        function closeMobileMenuOnBackdrop(event) {
+            if (event.target.id === 'mobileMenu') {
+                closeMobileMenu();
+            }
+        }
+
+        function showAlert(message, type = 'success') {
+            const container = document.getElementById('alertContainer');
+            container.innerHTML = `<div class="alert ${type}">${message}</div>`;
+            setTimeout(() => {
+                container.innerHTML = '';
+            }, 5000);
+        }
+
+        // 날짜 기본값 설정 (최근 30일)
+        function setDefaultDates() {
+            const endDate = new Date();
+            const startDate = new Date();
+            startDate.setDate(startDate.getDate() - 30);
+
+            document.getElementById('endDate').value = endDate.toISOString().split('T')[0];
+            document.getElementById('startDate').value = startDate.toISOString().split('T')[0];
+        }
+
+        // 토큰 사용량 조회
+        async function loadTokenUsage() {
+            try {
+                const startDate = document.getElementById('startDate').value;
+                const endDate = document.getElementById('endDate').value;
+                const modelName = document.getElementById('modelFilter').value;
+                const groupBy = document.getElementById('groupBy').value;
+
+                if (!startDate || !endDate) {
+                    showAlert('시작 날짜와 종료 날짜를 모두 선택해주세요.', 'error');
+                    return;
+                }
+
+                const params = new URLSearchParams({
+                    start_date: startDate,
+                    end_date: endDate,
+                    group_by: groupBy
+                });
+
+                if (modelName) {
+                    params.append('model_name', modelName);
+                }
+
+                console.log('[토큰 통계] 요청 URL:', `/api/admin/token-usage?${params}`);
+                const response = await fetch(`/api/admin/token-usage?${params}`, {
+                    method: 'GET',
+                    credentials: 'include'
+                });
+
+                const data = await response.json();
+                console.log('[토큰 통계] 응답 데이터:', data);
+
+                if (response.ok && data.success) {
+                    if (data.stats && data.stats.length > 0) {
+                        updateStats(data.stats, data.total_messages, data.user_usage, data.system_usage);
+                        updateChart(data.stats, groupBy);
+                    } else {
+                        showAlert('선택한 기간에 토큰 정보가 있는 메시지가 없습니다.', 'error');
+                        // 빈 통계 표시
+                        updateStats([], 0, null, null);
+                        updateChart([], groupBy);
+                    }
+                } else {
+                    console.error('[토큰 통계] API 오류:', data);
+                    showAlert(data.error || '토큰 사용량 조회 중 오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                console.error('토큰 사용량 조회 오류:', error);
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+
+        // 통계 요약 업데이트
+        function updateStats(stats, totalMessages, userUsage, systemUsage) {
+            const statsGrid = document.getElementById('statsGrid');
+            
+            let totalInput = 0;
+            let totalOutput = 0;
+            let totalTokens = 0;
+
+            if (stats && stats.length > 0) {
+                stats.forEach(stat => {
+                    totalInput += stat.input_tokens || 0;
+                    totalOutput += stat.output_tokens || 0;
+                    totalTokens += stat.total_tokens || 0;
+                });
+            }
+
+            // 시스템 사용 통계
+            let systemInput = 0;
+            let systemOutput = 0;
+            let systemTotal = 0;
+            if (systemUsage) {
+                systemInput = systemUsage.input_tokens || 0;
+                systemOutput = systemUsage.output_tokens || 0;
+                systemTotal = systemUsage.total_tokens || 0;
+            }
+
+            statsGrid.innerHTML = `
+                <div class="stat-card">
+                    <div class="stat-label">총 입력 토큰</div>
+                    <div class="stat-value">${totalInput.toLocaleString()}</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-label">총 출력 토큰</div>
+                    <div class="stat-value">${totalOutput.toLocaleString()}</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-label">총 토큰</div>
+                    <div class="stat-value">${totalTokens.toLocaleString()}</div>
+                </div>
+                <div class="stat-card">
+                    <div class="stat-label">총 메시지 수</div>
+                    <div class="stat-value">${totalMessages.toLocaleString()}</div>
+                </div>
+                <div class="stat-card" style="border-left: 4px solid #34a853;">
+                    <div class="stat-label">시스템 사용 (입력)</div>
+                    <div class="stat-value">${systemInput.toLocaleString()}</div>
+                </div>
+                <div class="stat-card" style="border-left: 4px solid #34a853;">
+                    <div class="stat-label">시스템 사용 (출력)</div>
+                    <div class="stat-value">${systemOutput.toLocaleString()}</div>
+                </div>
+                <div class="stat-card" style="border-left: 4px solid #34a853;">
+                    <div class="stat-label">시스템 사용 (총)</div>
+                    <div class="stat-value">${systemTotal.toLocaleString()}</div>
+                </div>
+            `;
+        }
+
+        // 그래프 업데이트
+        function updateChart(stats, groupBy) {
+            const ctx = document.getElementById('tokenChart').getContext('2d');
+
+            if (tokenChart) {
+                tokenChart.destroy();
+            }
+
+            let labels, inputData, outputData;
+
+            if (!stats || stats.length === 0) {
+                // 데이터가 없을 때 빈 그래프 표시
+                labels = ['데이터 없음'];
+                inputData = [0];
+                outputData = [0];
+            } else if (groupBy === 'day') {
+                labels = stats.map(s => s.date);
+                inputData = stats.map(s => s.input_tokens || 0);
+                outputData = stats.map(s => s.output_tokens || 0);
+            } else if (groupBy === 'model') {
+                labels = stats.map(s => s.model || 'Unknown');
+                inputData = stats.map(s => s.input_tokens || 0);
+                outputData = stats.map(s => s.output_tokens || 0);
+            } else {
+                labels = ['전체'];
+                inputData = [stats[0]?.input_tokens || 0];
+                outputData = [stats[0]?.output_tokens || 0];
+            }
+
+            tokenChart = new Chart(ctx, {
+                type: 'line',
+                data: {
+                    labels: labels,
+                    datasets: [
+                        {
+                            label: '입력 토큰',
+                            data: inputData,
+                            borderColor: 'rgb(26, 115, 232)',
+                            backgroundColor: 'rgba(26, 115, 232, 0.1)',
+                            tension: 0.4
+                        },
+                        {
+                            label: '출력 토큰',
+                            data: outputData,
+                            borderColor: 'rgb(234, 67, 53)',
+                            backgroundColor: 'rgba(234, 67, 53, 0.1)',
+                            tension: 0.4
+                        }
+                    ]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    plugins: {
+                        legend: {
+                            position: 'top',
+                        },
+                        title: {
+                            display: true,
+                            text: '토큰 사용량 추이'
+                        }
+                    },
+                    scales: {
+                        y: {
+                            beginAtZero: true,
+                            ticks: {
+                                callback: function(value) {
+                                    return value.toLocaleString();
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+        }
+
+        // 모델 목록 로드
+        async function loadModels() {
+            try {
+                // 날짜 범위를 넓게 설정하여 모든 모델 조회
+                const endDate = new Date();
+                const startDate = new Date();
+                startDate.setFullYear(startDate.getFullYear() - 1); // 1년 전부터
+                
+                const params = new URLSearchParams({
+                    start_date: startDate.toISOString().split('T')[0],
+                    end_date: endDate.toISOString().split('T')[0],
+                    group_by: 'model'
+                });
+                
+                const response = await fetch(`/api/admin/token-usage?${params}`, {
+                    method: 'GET',
+                    credentials: 'include'
+                });
+
+                const data = await response.json();
+
+                if (response.ok && data.success && data.models) {
+                    const modelFilter = document.getElementById('modelFilter');
+                    // 기존 옵션 유지 (전체 옵션)
+                    const existingOptions = Array.from(modelFilter.options).map(opt => opt.value);
+                    data.models.forEach(model => {
+                        if (!existingOptions.includes(model)) {
+                            const option = document.createElement('option');
+                            option.value = model;
+                            option.textContent = model;
+                            modelFilter.appendChild(option);
+                        }
+                    });
+                }
+            } catch (error) {
+                console.error('모델 목록 로드 오류:', error);
+            }
+        }
+
+        // 페이지 로드 시 초기화
+        document.addEventListener('DOMContentLoaded', function() {
+            setDefaultDates();
+            loadModels();
+            loadTokenUsage();
+        });
+    </script>
+</body>
+</html>
+

templates/admin_utils.html

@@ -0,0 +1,770 @@
+<!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;
+        }
+
+        .menu-toggle {
+            display: none;
+            background: none;
+            border: none;
+            font-size: 24px;
+            cursor: pointer;
+            padding: 8px;
+            color: #202124;
+        }
+
+        .mobile-menu {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: rgba(0, 0, 0, 0.5);
+            z-index: 1000;
+        }
+
+        .mobile-menu.active {
+            display: block;
+        }
+
+        .mobile-menu-content {
+            position: fixed;
+            top: 0;
+            right: -100%;
+            width: 280px;
+            max-width: 80%;
+            height: 100%;
+            background: white;
+            box-shadow: -2px 0 8px rgba(0, 0, 0, 0.1);
+            transition: right 0.3s ease;
+            overflow-y: auto;
+            z-index: 1001;
+        }
+
+        .mobile-menu.active .mobile-menu-content {
+            right: 0;
+        }
+
+        .mobile-menu-header {
+            padding: 16px 20px;
+            border-bottom: 1px solid #dadce0;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            background: white;
+            position: sticky;
+            top: 0;
+            z-index: 10;
+        }
+
+        .mobile-menu-title {
+            font-size: 18px;
+            font-weight: 500;
+        }
+
+        .mobile-menu-close {
+            background: none;
+            border: none;
+            font-size: 28px;
+            cursor: pointer;
+            color: #202124;
+            padding: 0;
+            width: 32px;
+            height: 32px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .mobile-menu-user {
+            padding: 12px 20px;
+            background: #f8f9fa;
+            border-bottom: 1px solid #dadce0;
+            font-size: 14px;
+            color: #5f6368;
+        }
+
+        .mobile-menu-items {
+            padding: 8px 0;
+        }
+
+        .mobile-menu-item {
+            display: block;
+            padding: 12px 20px;
+            color: #202124;
+            text-decoration: none;
+            font-size: 14px;
+            transition: background 0.2s;
+        }
+
+        .mobile-menu-item:hover {
+            background: #f8f9fa;
+        }
+
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            text-decoration: none;
+            display: inline-block;
+            transition: all 0.2s;
+        }
+
+        .btn-primary {
+            background: #1a73e8;
+            color: white;
+        }
+
+        .btn-primary:hover {
+            background: #1557b0;
+        }
+
+        .btn-secondary {
+            background: #f1f3f4;
+            color: #202124;
+        }
+
+        .btn-secondary:hover {
+            background: #e8eaed;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 24px;
+        }
+
+        .page-header {
+            margin-bottom: 24px;
+        }
+
+        .page-header h1 {
+            font-size: 28px;
+            font-weight: 600;
+            margin-bottom: 8px;
+        }
+
+        .page-header p {
+            color: #5f6368;
+        }
+
+        .card {
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+            padding: 24px;
+            margin-bottom: 24px;
+        }
+
+        .card-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+
+        .card-title {
+            font-size: 18px;
+            font-weight: 500;
+        }
+
+        .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;
+        }
+
+        .utils-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 20px;
+            margin-top: 20px;
+        }
+
+        .util-card {
+            background: white;
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+            transition: box-shadow 0.2s;
+        }
+
+        .util-card:hover {
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+        }
+
+        .util-card-title {
+            font-size: 16px;
+            font-weight: 500;
+            margin-bottom: 8px;
+        }
+
+        .util-card-description {
+            font-size: 14px;
+            color: #5f6368;
+            margin-bottom: 12px;
+        }
+
+        .form-group {
+            margin-bottom: 16px;
+        }
+
+        .form-group label {
+            display: block;
+            font-size: 14px;
+            font-weight: 500;
+            margin-bottom: 8px;
+        }
+
+        .form-group select,
+        .form-group textarea {
+            width: 100%;
+            padding: 10px 12px;
+            border: 1px solid #dadce0;
+            border-radius: 6px;
+            font-size: 14px;
+            font-family: inherit;
+        }
+
+        .form-group textarea {
+            min-height: 200px;
+            resize: vertical;
+        }
+
+        .form-group select:focus,
+        .form-group textarea: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;
+            margin-top: 12px;
+        }
+
+        .form-group-checkbox input {
+            width: auto;
+        }
+
+        .preview-box {
+            background: #f8f9fa;
+            border: 1px solid #dadce0;
+            border-radius: 6px;
+            padding: 12px;
+            margin-top: 12px;
+            max-height: 300px;
+            overflow-y: auto;
+            font-size: 13px;
+            font-family: 'Courier New', monospace;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+
+        .preview-box.empty {
+            color: #5f6368;
+            font-style: italic;
+        }
+
+        input[type="file"] {
+            cursor: pointer;
+        }
+
+        input[type="file"]:focus {
+            outline: none;
+            border-color: #1a73e8;
+            box-shadow: 0 0 0 3px rgba(26, 115, 232, 0.1);
+        }
+
+        @media (max-width: 768px) {
+            .header {
+                padding: 12px 16px;
+            }
+
+            .header-title {
+                font-size: 18px;
+            }
+
+            .menu-toggle {
+                display: block;
+            }
+
+            .header-actions {
+                display: none;
+            }
+
+            .container {
+                padding: 16px;
+            }
+
+            .utils-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <div class="header-title">
+            <span>🔧</span>
+            <span>유틸리티</span>
+        </div>
+        <button class="menu-toggle" onclick="toggleMobileMenu()" aria-label="메뉴 열기">☰</button>
+        <div class="header-actions">
+            <span style="margin-right: 12px; color: #5f6368;">{{ current_user.nickname or current_user.username }}</span>
+            <a href="{{ url_for('main.admin') }}" class="btn btn-secondary">사용자 관리</a>
+            <a href="{{ url_for('main.admin_webnovels') }}" class="btn btn-secondary">웹소설 관리</a>
+            <a href="{{ url_for('main.admin_files') }}" class="btn btn-secondary">파일 목록</a>
+            <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
+            <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
+            <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
+            <a href="{{ url_for('main.admin_utils') }}" class="btn btn-secondary">유틸</a>
+            <a href="{{ url_for('main.admin_tokens') }}" 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="mobile-menu" id="mobileMenu" onclick="closeMobileMenuOnBackdrop(event)">
+        <div class="mobile-menu-content" onclick="event.stopPropagation()">
+            <div class="mobile-menu-header">
+                <div class="mobile-menu-title">메뉴</div>
+                <button class="mobile-menu-close" onclick="toggleMobileMenu()" aria-label="메뉴 닫기">&times;</button>
+            </div>
+            <div class="mobile-menu-user">{{ current_user.nickname or current_user.username }}</div>
+            <div class="mobile-menu-items">
+                <a href="{{ url_for('main.admin') }}" class="mobile-menu-item" onclick="closeMobileMenu()">사용자 관리</a>
+                <a href="{{ url_for('main.admin_webnovels') }}" class="mobile-menu-item" onclick="closeMobileMenu()">웹소설 관리</a>
+                <a href="{{ url_for('main.admin_files') }}" class="mobile-menu-item" onclick="closeMobileMenu()">파일 목록</a>
+                <a href="{{ url_for('main.admin_messages') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메시지 확인</a>
+                <a href="{{ url_for('main.admin_prompts') }}" class="mobile-menu-item" onclick="closeMobileMenu()">프롬프트 관리</a>
+                <a href="{{ url_for('main.admin_settings') }}" class="mobile-menu-item" onclick="closeMobileMenu()">AI 설정</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
+                <a href="{{ url_for('main.admin_tokens') }}" class="mobile-menu-item" onclick="closeMobileMenu()">토큰 통계</a>
+                <a href="{{ url_for('main.index') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메인으로</a>
+                <a href="{{ url_for('main.logout') }}" class="mobile-menu-item" onclick="closeMobileMenu()">로그아웃</a>
+            </div>
+        </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 style="padding: 16px 0;">
+                <p style="margin-bottom: 16px; color: #5f6368; font-size: 14px;">
+                    다양한 회차 구분 방식(@n, #n, @프롤로그 등)을 #n화 형식으로 변환합니다. 파일을 업로드하거나 직접 내용을 입력할 수 있습니다.
+                </p>
+                
+                <div class="form-group">
+                    <label for="episodeFileUpload">파일 업로드</label>
+                    <input type="file" id="episodeFileUpload" accept=".txt,.md" onchange="handleFileUpload(event)" style="width: 100%; padding: 8px; border: 1px solid #dadce0; border-radius: 6px; font-size: 14px;">
+                    <small style="color: #5f6368; font-size: 12px; display: block; margin-top: 4px;">
+                        텍스트 파일(.txt, .md)을 업로드하세요
+                    </small>
+                </div>
+
+                <div class="form-group" id="encodingGroup" style="display: none;">
+                    <label for="fileEncoding">파일 인코딩</label>
+                    <div style="display: flex; gap: 8px; align-items: center;">
+                        <select id="fileEncoding" style="flex: 1; padding: 8px 12px; border: 1px solid #dadce0; border-radius: 6px; font-size: 14px;">
+                            <option value="utf-8">UTF-8</option>
+                            <option value="cp949">CP949 (EUC-KR)</option>
+                            <option value="euc-kr">EUC-KR</option>
+                            <option value="latin-1">Latin-1 (ISO-8859-1)</option>
+                            <option value="utf-16">UTF-16</option>
+                            <option value="utf-16-le">UTF-16 LE</option>
+                            <option value="utf-16-be">UTF-16 BE</option>
+                        </select>
+                        <button class="btn btn-secondary" onclick="reloadFileWithEncoding()" style="padding: 8px 16px;">인코딩 적용</button>
+                    </div>
+                    <div id="encodingInfo" style="margin-top: 8px; padding: 8px; background: #f8f9fa; border-radius: 4px; font-size: 12px; color: #5f6368; display: none;">
+                        <span id="encodingStatus"></span>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label for="episodeContentInput">또는 직접 내용 입력</label>
+                    <textarea id="episodeContentInput" placeholder="@1&#10;@2화&#10;3화&#10;... 형식의 내용을 입��하세요"></textarea>
+                </div>
+
+                <div style="display: flex; gap: 8px; margin-top: 16px;">
+                    <button class="btn btn-primary" onclick="convertEpisodeFormat()">변환 실행</button>
+                    <button class="btn btn-secondary" onclick="previewConversion()">미리보기</button>
+                    <button class="btn btn-secondary" onclick="clearEpisodeForm()">초기화</button>
+                    <button class="btn btn-secondary" id="downloadBtn" onclick="downloadConvertedFile()" style="display: none;">다운로드</button>
+                </div>
+
+                <div id="episodePreview" class="preview-box empty" style="display: none;">
+                    변환 결과가 여기에 표시됩니다.
+                </div>
+                
+                <div id="conversionInfo" style="margin-top: 12px; padding: 12px; background: #e8f0fe; border-radius: 6px; display: none;">
+                    <div style="font-size: 14px; color: #1967d2;">
+                        <strong>변환 완료!</strong> 위의 "다운로드" 버튼을 클릭하여 변환된 파일을 다운로드하세요.
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        function toggleMobileMenu() {
+            const menu = document.getElementById('mobileMenu');
+            menu.classList.toggle('active');
+            document.body.style.overflow = menu.classList.contains('active') ? 'hidden' : '';
+        }
+
+        function closeMobileMenu() {
+            const menu = document.getElementById('mobileMenu');
+            menu.classList.remove('active');
+            document.body.style.overflow = '';
+        }
+
+        function closeMobileMenuOnBackdrop(event) {
+            if (event.target.id === 'mobileMenu') {
+                closeMobileMenu();
+            }
+        }
+
+        function showAlert(message, type = 'success') {
+            const container = document.getElementById('alertContainer');
+            container.innerHTML = `<div class="alert ${type}">${message}</div>`;
+            setTimeout(() => {
+                container.innerHTML = '';
+            }, 5000);
+        }
+
+        // 현재 선택된 파일 저장
+        let currentFile = null;
+
+        // 파일 업로드 처리
+        async function handleFileUpload(event) {
+            const file = event.target.files[0];
+            if (!file) {
+                currentFile = null;
+                document.getElementById('encodingGroup').style.display = 'none';
+                return;
+            }
+
+            currentFile = file;
+
+            // 인코딩 감지 API 호출
+            try {
+                const formData = new FormData();
+                formData.append('file', file);
+
+                const response = await fetch('/api/admin/utils/detect-encoding', {
+                    method: 'POST',
+                    credentials: 'include',
+                    body: formData
+                });
+
+                const data = await response.json();
+
+                if (response.ok && data.detected_encoding) {
+                    // 인코딩 정보 표시
+                    document.getElementById('fileEncoding').value = data.detected_encoding;
+                    const encodingInfo = document.getElementById('encodingInfo');
+                    const encodingStatus = document.getElementById('encodingStatus');
+                    encodingStatus.innerHTML = `감지된 인코딩: <strong>${data.detected_encoding}</strong> (신뢰도: ${Math.round(data.confidence * 100)}%)`;
+                    encodingInfo.style.display = 'block';
+                    document.getElementById('encodingGroup').style.display = 'block';
+
+                    // 감지된 인코딩으로 파일 읽기
+                    await loadFileWithEncoding(data.detected_encoding);
+                } else {
+                    // 인코딩 감지 실패 시 기본값(UTF-8)으로 시도
+                    document.getElementById('fileEncoding').value = 'utf-8';
+                    document.getElementById('encodingInfo').style.display = 'none';
+                    document.getElementById('encodingGroup').style.display = 'block';
+                    await loadFileWithEncoding('utf-8');
+                }
+            } catch (error) {
+                console.error('인코딩 감지 오류:', error);
+                // 오류 발생 시 기본값으로 시도
+                document.getElementById('fileEncoding').value = 'utf-8';
+                document.getElementById('encodingGroup').style.display = 'block';
+                await loadFileWithEncoding('utf-8');
+            }
+        }
+
+        // 지정된 인코딩으로 파일 읽기
+        async function loadFileWithEncoding(encoding) {
+            if (!currentFile) {
+                return;
+            }
+
+            try {
+                const reader = new FileReader();
+                reader.onload = function(e) {
+                    document.getElementById('episodeContentInput').value = e.target.result;
+                    showAlert(`파일이 ${encoding} 인코딩으로 로드되었습니다.`, 'success');
+                };
+                reader.onerror = function() {
+                    showAlert('파일 읽기 중 오류가 발생했습니다.', 'error');
+                };
+                reader.readAsText(currentFile, encoding);
+            } catch (error) {
+                console.error('파일 읽기 오류:', error);
+                showAlert(`파일 읽기 중 오류가 발생했습니다: ${error.message}`, 'error');
+            }
+        }
+
+        // 인코딩 변경 후 파일 다시 읽기
+        function reloadFileWithEncoding() {
+            const encoding = document.getElementById('fileEncoding').value;
+            if (!currentFile) {
+                showAlert('파일을 먼저 업로드해주세요.', 'error');
+                return;
+            }
+            loadFileWithEncoding(encoding);
+        }
+
+        // 다운로드 URL 저장
+        let downloadUrl = null;
+        let downloadFilename = null;
+
+        // 회차 형식 변환
+        async function convertEpisodeFormat() {
+            const fileInput = document.getElementById('episodeFileUpload');
+            const content = document.getElementById('episodeContentInput').value.trim();
+            const file = fileInput.files[0];
+
+            if (!file && !content) {
+                showAlert('파일을 업로드하거나 내용을 입력해주세요.', 'error');
+                return;
+            }
+
+            try {
+                const formData = new FormData();
+                
+                if (file) {
+                    formData.append('file', file);
+                    // 선택된 인코딩 정보 추가
+                    const encoding = document.getElementById('fileEncoding').value || 'utf-8';
+                    formData.append('encoding', encoding);
+                } else if (content) {
+                    // JSON으로 전송
+                    const response = await fetch('/api/admin/utils/convert-episode-format', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        credentials: 'include',
+                        body: JSON.stringify({
+                            content: content,
+                            filename: file ? file.name : 'converted_file.txt'
+                        })
+                    });
+
+                    const data = await response.json();
+
+                    if (response.ok) {
+                        showAlert(data.message, 'success');
+                        if (data.converted_content) {
+                            document.getElementById('episodePreview').textContent = data.converted_content;
+                            document.getElementById('episodePreview').style.display = 'block';
+                            document.getElementById('episodePreview').classList.remove('empty');
+                        }
+                        if (data.download_url) {
+                            downloadUrl = data.download_url;
+                            downloadFilename = data.filename;
+                            document.getElementById('downloadBtn').style.display = 'inline-block';
+                            document.getElementById('conversionInfo').style.display = 'block';
+                        }
+                    } else {
+                        showAlert(data.error || '변환 중 오류가 발생했습니다.', 'error');
+                    }
+                    return;
+                }
+
+                // 파일 업로드인 경우
+                const response = await fetch('/api/admin/utils/convert-episode-format', {
+                    method: 'POST',
+                    credentials: 'include',
+                    body: formData
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    showAlert(data.message, 'success');
+                    if (data.converted_content) {
+                        document.getElementById('episodePreview').textContent = data.converted_content;
+                        document.getElementById('episodePreview').style.display = 'block';
+                        document.getElementById('episodePreview').classList.remove('empty');
+                    }
+                    if (data.download_url) {
+                        downloadUrl = data.download_url;
+                        downloadFilename = data.filename;
+                        document.getElementById('downloadBtn').style.display = 'inline-block';
+                        document.getElementById('conversionInfo').style.display = 'block';
+                    }
+                } else {
+                    showAlert(data.error || '변환 중 오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                console.error('변환 오류:', error);
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+
+        // 변환된 파일 다운로드
+        function downloadConvertedFile() {
+            if (!downloadUrl) {
+                showAlert('다운로드할 파일이 없습니다.', 'error');
+                return;
+            }
+
+            // 새 창에서 다운로드 링크 열기
+            window.location.href = downloadUrl;
+        }
+
+        // 미리보기
+        async function previewConversion() {
+            const fileInput = document.getElementById('episodeFileUpload');
+            const content = document.getElementById('episodeContentInput').value.trim();
+            const file = fileInput.files[0];
+
+            if (!file && !content) {
+                showAlert('파일을 업로드하거나 내용을 입력해주세요.', 'error');
+                return;
+            }
+
+            try {
+                let response;
+                
+                if (file) {
+                    const formData = new FormData();
+                    formData.append('file', file);
+                    // 선택된 인코딩 정보 추가
+                    const encoding = document.getElementById('fileEncoding').value || 'utf-8';
+                    formData.append('encoding', encoding);
+                    response = await fetch('/api/admin/utils/convert-episode-format', {
+                        method: 'POST',
+                        credentials: 'include',
+                        body: formData
+                    });
+                } else {
+                    response = await fetch('/api/admin/utils/convert-episode-format', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        credentials: 'include',
+                        body: JSON.stringify({
+                            content: content,
+                            filename: 'preview.txt'
+                        })
+                    });
+                }
+
+                const data = await response.json();
+
+                if (response.ok && data.converted_content) {
+                    const previewBox = document.getElementById('episodePreview');
+                    previewBox.textContent = data.converted_content.substring(0, 2000) + (data.converted_content.length > 2000 ? '\n... (더 많은 내용이 있습니다)' : '');
+                    previewBox.style.display = 'block';
+                    previewBox.classList.remove('empty');
+                } else {
+                    showAlert(data.error || '미리보기 중 오류가 발생했습니다.', 'error');
+                }
+            } catch (error) {
+                console.error('미리보기 오류:', error);
+                showAlert(`오류: ${error.message}`, 'error');
+            }
+        }
+
+        // 폼 초기화
+        function clearEpisodeForm() {
+            document.getElementById('episodeFileUpload').value = '';
+            document.getElementById('episodeContentInput').value = '';
+            document.getElementById('episodePreview').style.display = 'none';
+            document.getElementById('episodePreview').textContent = '변환 결과가 여기에 표시됩니다.';
+            document.getElementById('episodePreview').classList.add('empty');
+            document.getElementById('downloadBtn').style.display = 'none';
+            document.getElementById('conversionInfo').style.display = 'none';
+            document.getElementById('encodingGroup').style.display = 'none';
+            document.getElementById('encodingInfo').style.display = 'none';
+            document.getElementById('fileEncoding').value = 'utf-8';
+            currentFile = null;
+            downloadUrl = null;
+            downloadFilename = null;
+        }
+
+        // 페이지 로드 시 초기화
+        document.addEventListener('DOMContentLoaded', function() {
+            console.log('유틸리티 페이지 로드 완료');
+        });
+    </script>
+</body>
+</html>
+

templates/admin_webnovels.html

@@ -617,6 +617,9 @@
             <a href="{{ url_for('main.admin_messages') }}" class="btn btn-secondary">메시지 확인</a>
             <a href="{{ url_for('main.admin_prompts') }}" class="btn btn-secondary">프롬프트 관리</a>
             <a href="{{ url_for('main.admin_settings') }}" class="btn btn-secondary">AI 설정</a>
+            <a href="{{ url_for('main.admin_utils') }}" class="btn btn-secondary">유틸</a>
+            <a href="{{ url_for('main.admin_tokens') }}" class="btn btn-secondary">토큰 통계</a>
+            <a href="{{ url_for('main.admin_utils') }}" 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>
@@ -636,6 +639,9 @@
                 <a href="{{ url_for('main.admin_messages') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메시지 확인</a>
                 <a href="{{ url_for('main.admin_prompts') }}" class="mobile-menu-item" onclick="closeMobileMenu()">프롬프트 관리</a>
                 <a href="{{ url_for('main.admin_settings') }}" class="mobile-menu-item" onclick="closeMobileMenu()">AI 설정</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
+                <a href="{{ url_for('main.admin_tokens') }}" class="mobile-menu-item" onclick="closeMobileMenu()">토큰 통계</a>
+                <a href="{{ url_for('main.admin_utils') }}" class="mobile-menu-item" onclick="closeMobileMenu()">유틸</a>
                 <a href="{{ url_for('main.index') }}" class="mobile-menu-item" onclick="closeMobileMenu()">메인으로</a>
                 <a href="{{ url_for('main.logout') }}" class="mobile-menu-item" onclick="closeMobileMenu()">로그아웃</a>
             </div>

templates/index.html

@@ -1794,6 +1794,24 @@
                 
                 availableModelsSelect.innerHTML = '<option value="">답변 생성할 AI 모델을 선택하세요...</option>';
                 
+                // 기본 모델 설정 가져오기 (localStorage에 선택된 모델이 없을 때만 사용)
+                let defaultAnswerModel = null;
+                if (!answerModel) {
+                    try {
+                        const defaultResponse = await fetch('/api/default-models');
+                        if (defaultResponse.ok) {
+                            const defaultData = await defaultResponse.json();
+                            defaultAnswerModel = defaultData.default_answer_model || null;
+                            if (defaultAnswerModel) {
+                                answerModel = defaultAnswerModel;
+                                localStorage.setItem('answerModel', answerModel);
+                            }
+                        }
+                    } catch (e) {
+                        console.log('기본 모델 설정 로드 실패:', e);
+                    }
+                }
+                
                 if (data.models && data.models.length > 0) {
                     // 모델을 타입별로 그룹화
                     const ollamaModels = [];
@@ -1843,6 +1861,11 @@
                         availableModelsSelect.appendChild(optgroup);
                     }
                     
+                    // 기본 모델이 설정되어 있고 선택되었으면 모델 선택 이벤트 트리거
+                    if (defaultAnswerModel && availableModelsSelect.value === defaultAnswerModel) {
+                        availableModelsSelect.dispatchEvent(new Event('change'));
+                    }
+                    
                     availableModelsSelect.disabled = false;
                 } else {
                     availableModelsSelect.innerHTML = '<option value="">등록된 AI 모델이 없습니다</option>';
@@ -1864,6 +1887,24 @@
                 
                 modelSelect.innerHTML = '<option value="">모델을 선택하세요...</option>';
                 
+                // 기본 모델 설정 가져오기 (localStorage에 선택된 모델이 없을 때만 사용)
+                let defaultAnalysisModel = null;
+                if (!selectedModel) {
+                    try {
+                        const defaultResponse = await fetch('/api/default-models');
+                        if (defaultResponse.ok) {
+                            const defaultData = await defaultResponse.json();
+                            defaultAnalysisModel = defaultData.default_analysis_model || null;
+                            if (defaultAnalysisModel) {
+                                selectedModel = defaultAnalysisModel;
+                                localStorage.setItem('selectedModel', selectedModel);
+                            }
+                        }
+                    } catch (e) {
+                        console.log('기본 모델 설정 로드 실패:', e);
+                    }
+                }
+                
                 if (data.models && data.models.length > 0) {
                     // 모델을 타입별로 그룹화
                     const ollamaModels = [];
@@ -1914,6 +1955,11 @@
                         modelSelect.appendChild(optgroup);
                     }
                     
+                    // 기본 모델이 설정되어 있고 선택되었으면 모델 선택 이벤트 트리거
+                    if (defaultAnalysisModel && modelSelect.value === defaultAnalysisModel) {
+                        modelSelect.dispatchEvent(new Event('change'));
+                    }
+                    
                     updateModelStatus('connected');
                 } else {
                     updateModelStatus('error', '사용 가능한 모델이 없습니다');