기본 AI 모델 선택 기능 추가 및 DB 연결 풀 설정 개선

- 관리 페이지에 기본 AI 모델 선택 기능 추가 (질문 분석용/답변 생성용)
- 사용자 화면에서 기본 AI 모델 자동 선택 기능 구현
- SQLAlchemy 연결 풀에 pool_pre_ping과 pool_recycle 옵션 추가 (클라우드 환경 대응)
- 시스템 토큰 사용량 추적 기능 개선
- ChromaDB 텔레메트리 오류 억제 설정 추가

.github/workflows/README.md

@@ -86,3 +86,5 @@ GitHub 저장소의 Settings > Secrets and variables > Actions에서 다음 secr
 
 
 
+
+

.github/workflows/deploy-to-hf.yml

@@ -74,3 +74,5 @@ jobs:
 
 
 
+
+

.github/workflows/test.yml

@@ -62,3 +62,5 @@ jobs:
 
 
 
+
+

DB_CONNECTION_CHECK.md

@@ -266,3 +266,5 @@ if db_status.get('error'):
 
 
 
+
+

EXAONE_설치_가이드.md

@@ -170,6 +170,10 @@ tokenizer = AutoTokenizer.from_pretrained("LGAI-EXAONE/EXAONE-3.0-7.8B-Instruct"
 
 
 
+
+
+
+
 
 
 

HF_UPLOAD_GUIDE.md

@@ -147,3 +147,5 @@ Write-Host "파일 복사 완료!"
 
 
 
+
+

POSTGRESQL_SETUP_GUIDE.md

@@ -171,3 +171,5 @@ PostgreSQL 전환 후 다음을 확인하세요:
 
 
 
+
+

README_HF.md

@@ -59,3 +59,5 @@ MIT License
 
 
 
+
+

add_exaone_model.py

@@ -165,6 +165,10 @@ if __name__ == "__main__":
 
 
 
+
+
+
+
 
 
 

app.py

@@ -75,3 +75,5 @@ if __name__ == '__main__':
 
 
 
+
+

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

@@ -48,3 +48,5 @@ def reset_huggingface_token():
 
 
 
+
+

app/routes.py

@@ -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 생성] 파일이 너무 크거나 모델 응답이 느릴 수 있습니다.")
@@ -1797,6 +1902,12 @@ 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화 형식으로 변환
     
@@ -1805,6 +1916,7 @@ def convert_episode_format(content):
     - @ 1, @ 2 -> #1화, #2화
     - @1화, @2화 -> #1화, #2화
     - @ 1화, @ 2화 -> #1화, #2화
+    - 1화, 2화, 10화 -> #1화, #2화, #10화 (앞에 기호 없이)
     - #01화, #010화 -> #1화, #10화 (앞의 0 제거)
     - 기타 유사한 패턴들
     
@@ -1821,7 +1933,7 @@ def convert_episode_format(content):
     converted_lines = []
     
     # 다양한 회차 패턴을 #n화 형식으로 변환
-    # 패턴: @숫자, @ 숫자, @숫자화, @ 숫자화 등
+    # 패턴: @숫자, @ 숫자, @숫자화, @ 숫자화, 숫자화 등
     # 줄 시작 부분에서만 매칭하도록 ^ 사용
     for line in lines:
         converted_line = line
@@ -1834,6 +1946,11 @@ def convert_episode_format(content):
         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)
+        
         # #0n화 패턴에서 앞의 0 제거 (#01화 -> #1화, #010화 -> #10화)
         # 단, #0화는 그대로 유지
         converted_line = re.sub(r'^#0+(\d+)화', r'#\1화', converted_line)
@@ -1842,6 +1959,65 @@ def convert_episode_format(content):
     
     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():
@@ -1849,6 +2025,7 @@ def convert_episode_format_api():
     try:
         content = None
         original_filename = 'converted_file.txt'
+        specified_encoding = None
         
         # 파일 업로드 확인
         if 'file' in request.files:
@@ -1856,20 +2033,30 @@ def convert_episode_format_api():
             if file and file.filename and file.filename != '':
                 # 파일 읽기
                 try:
-                    encoding = 'utf-8'
+                    # 요청에서 인코딩 정보 가져오기
+                    specified_encoding = request.form.get('encoding', 'utf-8')
+                    
                     file_content = file.read()
                     file.seek(0)  # 파일 포인터 리셋 (다시 읽을 수 있도록)
                     
+                    # 지정된 인코딩으로 시도
                     try:
-                        content = file_content.decode(encoding)
-                    except UnicodeDecodeError:
-                        try:
-                            content = file_content.decode('cp949')
-                        except:
+                        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('latin-1')
-                            except Exception as decode_error:
-                                return jsonify({'error': f'파일 인코딩 오류: 지원하지 않는 인코딩입니다. (UTF-8, CP949, Latin-1 시도 실패)'}), 500
+                                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:
@@ -1981,6 +2168,178 @@ def download_converted_file():
     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():
@@ -2077,10 +2436,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:
@@ -2097,6 +2460,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'])
@@ -2118,10 +2485,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,
@@ -2131,6 +2521,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'])
@@ -2655,7 +3049,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()"))
@@ -2793,6 +3191,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():
@@ -3222,6 +3690,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:
@@ -3247,6 +3723,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 서버 연결 확인
@@ -3295,6 +3776,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')
@@ -3350,14 +3843,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')
 

migrate_add_is_public.py

@@ -64,3 +64,5 @@ if __name__ == '__main__':
 
 
 
+
+

migrate_add_token_fields.py

@@ -0,0 +1,77 @@
+import sqlite3
+import os
+from pathlib import Path
+
+# 데이터베이스 경로 (app/core/config.py와 동일하게 설정)
+PROJECT_ROOT = Path(__file__).parent
+db_path = PROJECT_ROOT / 'instance' / 'finance_analysis.db'
+
+def migrate_database():
+    if not db_path.exists():
+        print(f"데이터베이스 파일이 없습니다: {db_path}")
+        print("앱을 실행하면 자동으로 생성됩니다.")
+        return
+    
+    conn = None
+    try:
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        
+        # chat_message 테이블에 토큰 정보 컬럼이 있는지 확인
+        cursor.execute("PRAGMA table_info(chat_message)")
+        columns = [column[1] for column in cursor.fetchall()]
+        
+        changes_made = False
+        
+        # input_tokens 컬럼 추가
+        if 'input_tokens' not in columns:
+            print("input_tokens 컬럼을 추가하는 중...")
+            cursor.execute("ALTER TABLE chat_message ADD COLUMN input_tokens INTEGER")
+            changes_made = True
+        else:
+            print("input_tokens 컬럼이 이미 존재합니다.")
+        
+        # output_tokens 컬럼 추가
+        if 'output_tokens' not in columns:
+            print("output_tokens 컬럼을 추가하는 중...")
+            cursor.execute("ALTER TABLE chat_message ADD COLUMN output_tokens INTEGER")
+            changes_made = True
+        else:
+            print("output_tokens 컬럼이 이미 존재합니다.")
+        
+        # model_name 컬럼 추가
+        if 'model_name' not in columns:
+            print("model_name 컬럼을 추가하는 중...")
+            cursor.execute("ALTER TABLE chat_message ADD COLUMN model_name VARCHAR(100)")
+            changes_made = True
+        else:
+            print("model_name 컬럼이 이미 존재합니다.")
+        
+        if changes_made:
+            conn.commit()
+            print("토큰 정보 컬럼이 성공적으로 추가되었습니다.")
+        else:
+            print("모든 컬럼이 이미 존재합니다. 마이그레이션이 필요하지 않습니다.")
+        
+        conn.close()
+        
+    except sqlite3.OperationalError as e:
+        print(f"오류 발생: {e}")
+        if "duplicate column name" in str(e).lower():
+            print("일부 컬럼이 이미 존재합니다.")
+        else:
+            raise
+    except Exception as e:
+        print(f"예상치 못한 오류: {e}")
+        raise
+    finally:
+        if conn:
+            conn.close()
+
+if __name__ == '__main__':
+    print("=" * 60)
+    print("데이터베이스 마이그레이션: 토큰 정보 컬럼 추가")
+    print("=" * 60)
+    migrate_database()
+    print("마이그레이션이 완료되었습니다.")
+

migrate_add_usage_type.py

@@ -0,0 +1,65 @@
+import sqlite3
+import os
+from pathlib import Path
+
+# 데이터베이스 경로 (app/core/config.py와 동일하게 설정)
+PROJECT_ROOT = Path(__file__).parent
+db_path = PROJECT_ROOT / 'instance' / 'finance_analysis.db'
+
+def migrate_database():
+    if not db_path.exists():
+        print(f"데이터베이스 파일이 없습니다: {db_path}")
+        print("앱을 실행하면 자동으로 생성됩니다.")
+        return
+    
+    conn = None
+    try:
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        
+        # chat_message 테이블에 usage_type 컬럼이 있는지 확인
+        cursor.execute("PRAGMA table_info(chat_message)")
+        columns = [column[1] for column in cursor.fetchall()]
+        
+        changes_made = False
+        
+        # usage_type 컬럼 추가
+        if 'usage_type' not in columns:
+            print("usage_type 컬럼을 추가하는 중...")
+            cursor.execute("ALTER TABLE chat_message ADD COLUMN usage_type VARCHAR(20) DEFAULT 'user'")
+            changes_made = True
+        else:
+            print("usage_type 컬럼이 이미 존재합니다.")
+        
+        # session_id를 nullable로 변경 (시스템 사용은 세션이 없을 수 있음)
+        # SQLite는 ALTER COLUMN을 직접 지원하지 않으므로, 테이블 재생성이 필요할 수 있음
+        # 하지만 기존 데이터가 있으면 복잡하므로, 일단 nullable 체크는 애플리케이션 레벨에서 처리
+        
+        if changes_made:
+            conn.commit()
+            print("usage_type 컬럼이 성공적으로 추가되었습니다.")
+        else:
+            print("모든 컬럼이 이미 존재합니다. 마이그레이션이 필요하지 않습니다.")
+        
+        conn.close()
+        
+    except sqlite3.OperationalError as e:
+        print(f"오류 발생: {e}")
+        if "duplicate column name" in str(e).lower():
+            print("일부 컬럼이 이미 존재합니다.")
+        else:
+            raise
+    except Exception as e:
+        print(f"예상치 못한 오류: {e}")
+        raise
+    finally:
+        if conn:
+            conn.close()
+
+if __name__ == '__main__':
+    print("=" * 60)
+    print("데이터베이스 마이그레이션: usage_type 컬럼 추가")
+    print("=" * 60)
+    migrate_database()
+    print("마이그레이션이 완료되었습니다.")
+

migrate_session_id_nullable.py

@@ -0,0 +1,115 @@
+import sqlite3
+import os
+from pathlib import Path
+
+# 데이터베이스 경로
+PROJECT_ROOT = Path(__file__).parent
+db_path = PROJECT_ROOT / 'instance' / 'finance_analysis.db'
+
+def migrate_database():
+    if not db_path.exists():
+        print(f"데이터베이스 파일이 없습니다: {db_path}")
+        print("앱을 실행하면 자동으로 생성됩니다.")
+        return
+    
+    conn = None
+    try:
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        
+        # SQLite는 ALTER COLUMN을 직접 지원하지 않으므로 테이블 재생성이 필요
+        # 하지만 기존 데이터를 보존해야 하므로 다음 방법을 사용:
+        # 1. 새 테이블 생성 (nullable=True)
+        # 2. 기존 데이터 복사
+        # 3. 기존 테이블 삭제
+        # 4. 새 테이블 이름 변경
+        
+        print("chat_message 테이블의 session_id 컬럼을 nullable로 변경하는 중...")
+        
+        # 기존 테이블 구조 확인
+        cursor.execute("PRAGMA table_info(chat_message)")
+        columns = cursor.fetchall()
+        
+        # session_id 컬럼 정보 확인
+        session_id_col = None
+        for col in columns:
+            if col[1] == 'session_id':
+                session_id_col = col
+                break
+        
+        if not session_id_col:
+            print("session_id 컬럼을 찾을 수 없습니다.")
+            return
+        
+        # 이미 nullable인지 확인 (SQLite에서는 NOT NULL이 없으면 nullable)
+        # 하지만 실제로는 제약조건을 확인하기 어려우므로, 테이블 재생성으로 해결
+        
+        # 1. 새 테이블 생성 (nullable=True)
+        print("새 테이블 생성 중...")
+        cursor.execute("""
+            CREATE TABLE chat_message_new (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id INTEGER,
+                role VARCHAR(20) NOT NULL,
+                content TEXT NOT NULL,
+                created_at DATETIME NOT NULL,
+                input_tokens INTEGER,
+                output_tokens INTEGER,
+                model_name VARCHAR(100),
+                usage_type VARCHAR(20) DEFAULT 'user',
+                FOREIGN KEY (session_id) REFERENCES chat_session(id)
+            )
+        """)
+        
+        # 2. 기존 데이터 복사
+        print("기존 데이터 복사 중...")
+        cursor.execute("""
+            INSERT INTO chat_message_new 
+            (id, session_id, role, content, created_at, input_tokens, output_tokens, model_name, usage_type)
+            SELECT 
+                id, session_id, role, content, created_at, input_tokens, output_tokens, model_name, usage_type
+            FROM chat_message
+        """)
+        
+        # 3. 기존 테이블 삭제
+        print("기존 테이블 삭제 중...")
+        cursor.execute("DROP TABLE chat_message")
+        
+        # 4. 새 테이블 이름 변경
+        print("새 테이블 이름 변경 중...")
+        cursor.execute("ALTER TABLE chat_message_new RENAME TO chat_message")
+        
+        # 인덱스 재생성 (필요한 경우)
+        try:
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_chat_message_session_id ON chat_message(session_id)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_chat_message_created_at ON chat_message(created_at)")
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_chat_message_usage_type ON chat_message(usage_type)")
+        except:
+            pass
+        
+        conn.commit()
+        print("session_id 컬럼이 성공적으로 nullable로 변경되었습니다.")
+        
+        conn.close()
+        
+    except sqlite3.OperationalError as e:
+        print(f"오류 발생: {e}")
+        if conn:
+            conn.rollback()
+        raise
+    except Exception as e:
+        print(f"예상치 못한 오류: {e}")
+        if conn:
+            conn.rollback()
+        raise
+    finally:
+        if conn:
+            conn.close()
+
+if __name__ == '__main__':
+    print("=" * 60)
+    print("데이터베이스 마이그레이션: session_id nullable 변경")
+    print("=" * 60)
+    migrate_database()
+    print("마이그레이션이 완료되었습니다.")
+

run.py

@@ -51,6 +51,10 @@ werkzeug_handler.setFormatter(logging.Formatter(
 ))
 werkzeug_logger.addHandler(werkzeug_handler)
 
+# ChromaDB 텔레메트리 오류 억제
+chromadb_telemetry_logger = logging.getLogger('chromadb.telemetry.product.posthog')
+chromadb_telemetry_logger.setLevel(logging.CRITICAL)
+
 app.logger.info('서버 시작')
 
 if __name__ == '__main__':

templates/admin.html

@@ -572,6 +572,7 @@
             <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>
@@ -592,6 +593,7 @@
                 <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_messages.html

@@ -578,13 +578,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>
@@ -720,7 +723,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;
@@ -751,12 +754,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>
@@ -766,11 +775,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>';
                 }
                 
                 // 페이지네이션
@@ -785,7 +797,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>`;
             }
         }
 
@@ -804,7 +816,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}"]`);
@@ -835,6 +891,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}">
@@ -843,6 +928,7 @@
                             <span class="message-item-time">메시지 ID: ${messageId}</span>
                         </div>
                         <div class="message-item-content">${content}</div>
+                        ${tokenInfo}
                     </div>
                 </div>
             `;
@@ -914,6 +1000,8 @@
         window.addEventListener('load', () => {
             loadUsers();
             loadSessions();
+            // 세션 ID가 없어도 전체 메시지 로드
+            loadMessages(1);
         });
     </script>
 </body>

templates/admin_settings.html

@@ -370,6 +370,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">
@@ -849,11 +886,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,710 @@
+<!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.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

@@ -417,7 +417,7 @@
             </div>
             <div style="padding: 16px 0;">
                 <p style="margin-bottom: 16px; color: #5f6368; font-size: 14px;">
-                    다양한 회차 구분 방식(@n, @n화 등)을 #n화 형식으로 변환합니다. 파일을 업로드하거나 직접 내용을 입력할 수 있습니다.
+                    다양한 회차 구분 방식(@n, @n화, n화 등)을 #n화 형식으로 변환합니다. 파일을 업로드하거나 직접 내용을 입력할 수 있습니다.
                 </p>
                 
                 <div class="form-group">
@@ -428,9 +428,28 @@
                     </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>
+                    <textarea id="episodeContentInput" placeholder="@1&#10;@2화&#10;3화&#10;... 형식의 내용을 입력하세요"></textarea>
                 </div>
 
                 <div style="display: flex; gap: 8px; margin-top: 16px;">
@@ -480,22 +499,90 @@
             }, 5000);
         }
 
+        // 현재 선택된 파일 저장
+        let currentFile = null;
+
         // 파일 업로드 처리
-        function handleFileUpload(event) {
+        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;
             }
 
-            const reader = new FileReader();
-            reader.onload = function(e) {
-                document.getElementById('episodeContentInput').value = e.target.result;
-                showAlert('파일이 로드되었습니다.', 'success');
-            };
-            reader.onerror = function() {
-                showAlert('파일 읽기 중 오류가 발생했습니다.', 'error');
-            };
-            reader.readAsText(file, 'UTF-8');
+            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 저장
@@ -518,6 +605,9 @@
                 
                 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', {
@@ -612,6 +702,9 @@
                 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',
@@ -656,6 +749,10 @@
             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;
         }

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', '사용 가능한 모델이 없습니다');

upload_to_hf.ps1

@@ -117,3 +117,5 @@ try {
 
 
 
+
+