reset

app/app.py

@@ -1,5 +1,5 @@
 """
-RAG 검색 챗봇 웹 애플리케이션 (장치 관리 기능 통합)
+RAG 검색 챗봇 웹 애플리케이션 (세션 설정 수정 적용)
 """
 
 import os
@@ -7,19 +7,16 @@ import json
 import logging
 import tempfile
 import threading
-import requests
-from datetime import datetime, timedelta
+import datetime
 from flask import Flask, request, jsonify, render_template, send_from_directory, session, redirect, url_for
 from werkzeug.utils import secure_filename
 from dotenv import load_dotenv
 from functools import wraps
-import pickle
-import gzip
 
 # 로거 설정
 logging.basicConfig(
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    level=logging.DEBUG
+    level=logging.DEBUG  # INFO에서 DEBUG로 변경하여 더 상세한 로그 확인
 )
 logger = logging.getLogger(__name__)
 
@@ -29,13 +26,11 @@ load_dotenv()
 # 환경 변수 로드 상태 확인 및 로깅
 ADMIN_USERNAME = os.getenv('ADMIN_USERNAME')
 ADMIN_PASSWORD = os.getenv('ADMIN_PASSWORD')
-DEVICE_SERVER_URL = os.getenv('DEVICE_SERVER_URL', 'http://localhost:5050')
 
 logger.info(f"==== 환경 변수 로드 상태 ====")
 logger.info(f"ADMIN_USERNAME 설정 여부: {ADMIN_USERNAME is not None}")
 # 비밀번호는 로드 여부만 기록 (보안)
 logger.info(f"ADMIN_PASSWORD 설정 여부: {ADMIN_PASSWORD is not None}")
-logger.info(f"DEVICE_SERVER_URL: {DEVICE_SERVER_URL}")
 
 # 환경 변수가 없으면 기본값 설정 (개발용, 배포 시 환경 변수 설정 권장)
 if not ADMIN_USERNAME:
@@ -45,10 +40,10 @@ if not ADMIN_USERNAME:
 if not ADMIN_PASSWORD:
     ADMIN_PASSWORD = 'rag12345'
     logger.warning("ADMIN_PASSWORD 환경변수가 없어 기본값 'rag12345'로 설정합니다.")
-
 class MockComponent: pass
 
 # --- 로컬 모듈 임포트 ---
+# 실제 경로에 맞게 utils, retrieval 폴더가 존재해야 합니다.
 try:
     from utils.vito_stt import VitoSTT
     from utils.llm_interface import LLMInterface
@@ -57,6 +52,8 @@ try:
     from retrieval.reranker import ReRanker
 except ImportError as e:
     logger.error(f"로컬 모듈 임포트 실패: {e}. utils 및 retrieval 패키지가 올바른 경로에 있는지 확인하세요.")
+    # 개발/테스트를 위해 임시 클래스 정의 (실제 사용 시 제거)
+    
     VitoSTT = LLMInterface = DocumentProcessor = VectorRetriever = ReRanker = MockComponent
 # --- 로컬 모듈 임포트 끝 ---
 
@@ -65,15 +62,20 @@ except ImportError as e:
 app = Flask(__name__)
 
 # 세션 설정 - 고정된 시크릿 키 사용 (실제 배포 시 환경 변수 등으로 관리 권장)
-app.secret_key = os.getenv('FLASK_SECRET_KEY', 'rag_chatbot_fixed_secret_key_12345')
+app.secret_key = os.getenv('FLASK_SECRET_KEY', 'rag_chatbot_fixed_secret_key_12345') # 환경 변수 우선 사용
 
-# --- 세션 쿠키 설정 ---
+# --- 세션 쿠키 설정 수정 (허깅페이스 환경 고려) ---
+# 허깅페이스 스페이스는 일반적으로 HTTPS로 서비스되므로 Secure=True 설정
 app.config['SESSION_COOKIE_SECURE'] = True
-app.config['SESSION_COOKIE_HTTPONLY'] = True
-app.config['SESSION_COOKIE_SAMESITE'] = 'None'
-app.config['SESSION_COOKIE_DOMAIN'] = None
-app.config['SESSION_COOKIE_PATH'] = '/'
-app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=1)
+app.config['SESSION_COOKIE_HTTPONLY'] = True  # JavaScript에서 쿠키 접근 방지 (보안 강화)
+# SameSite='Lax'가 대부분의 경우에 더 안전하고 호환성이 좋음.
+# 만약 앱이 다른 도메인의 iframe 내에서 실행되어야 한다면 'None'으로 설정해야 함.
+# (단, 'None'으로 설정 시 반드시 Secure=True여야 함)
+# 로그 분석 결과 iframe 환경으로 확인되어 'None'으로 변경
+app.config['SESSION_COOKIE_SAMESITE'] = 'None' # <--- 이렇게 변경합니다.
+app.config['SESSION_COOKIE_DOMAIN'] = None  # 특정 도메인 제한 없음
+app.config['SESSION_COOKIE_PATH'] = '/'  # 앱 전체 경로에 쿠키 적용
+app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=1)  # 세션 유효 시간 증가
 # --- 세션 쿠키 설정 끝 ---
 
 # 최대 파일 크기 설정 (10MB)
@@ -108,21 +110,827 @@ app_ready = False # 앱 초기화 상태 플래그
 # --- 전역 객체 초기화 끝 ---
 
 
-# --- 인증 데코레이터 ---
+# --- 인증 데코레이터 (수정됨) ---
 def login_required(f):
     @wraps(f)
     def decorated_function(*args, **kwargs):
         logger.info(f"----------- 인증 필요 페이지 접근 시도: {request.path} -----------")
         logger.info(f"현재 플라스크 세션 객체: {session}")
         logger.info(f"현재 세션 상태: logged_in={session.get('logged_in', False)}, username={session.get('username', 'None')}")
+        # 브라우저가 보낸 실제 쿠키 확인 (디버깅용)
         logger.info(f"요청의 세션 쿠키 값: {request.cookies.get('session', 'None')}")
 
         # Flask 세션에 'logged_in' 키가 있는지 직접 확인
         if 'logged_in' not in session:
             logger.warning(f"플라스크 세션에 'logged_in' 없음. 로그인 페���지로 리디렉션.")
-            return redirect(url_for('login', next=request.url))
+            # 수동 쿠키 확인 로직 제거됨
+            return redirect(url_for('login', next=request.url)) # 로그인 후 원래 페이지로 돌아가도록 next 파라미터 추가
 
         logger.info(f"인증 성공: {session.get('username', 'unknown')} 사용자가 {request.path} 접근")
         return f(*args, **kwargs)
     return decorated_function
 # --- 인증 데코레이터 끝 ---
+
+
+# --- 헬퍼 함수 ---
+def allowed_audio_file(filename):
+    """파일이 허용된 오디오 확장자를 가지는지 확인"""
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_AUDIO_EXTENSIONS
+
+def allowed_doc_file(filename):
+    """파일이 허용된 문서 확장자를 가지는지 확인"""
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_DOC_EXTENSIONS
+# --- 헬퍼 함수 끝 ---
+
+
+# init_retriever 함수 내부에 로깅 추가 예시
+# --- 검색기 초기화 관련 함수 ---
+def init_retriever():
+    """검색기 객체 초기화 또는 로드"""
+    global base_retriever, retriever
+
+    index_path = app.config['INDEX_PATH']
+    data_path = app.config['DATA_FOLDER'] # data_path 정의 확인
+    logger.info("--- init_retriever 시작 ---")
+
+    # 1. 기본 검색기 로드 또는 초기화
+    # ... (VectorRetriever 로드 또는 초기화 로직은 이전과 동일하게 유지) ...
+    # VectorRetriever 초기화/로드 실패 시 base_retriever = None 및 return None 처리 포함
+    if os.path.exists(os.path.join(index_path, "documents.json")):
+        try:
+            logger.info(f"인덱스 로드 시도: {index_path}")
+            base_retriever = VectorRetriever.load(index_path)
+            logger.info(f"인덱스 로드 성공. 문서 {len(getattr(base_retriever, 'documents', []))}개")
+        except Exception as e:
+            logger.error(f"인덱스 로드 실패: {e}", exc_info=True)
+            logger.info("새 VectorRetriever 초기화 시도...")
+            try:
+                base_retriever = VectorRetriever()
+                logger.info("새 VectorRetriever 초기화 성공.")
+            except Exception as e_init:
+                logger.error(f"새 VectorRetriever 초기화 실패: {e_init}", exc_info=True)
+                base_retriever = None
+    else:
+        logger.info("인덱스 파일 없음. 새 VectorRetriever 초기화 시도...")
+        try:
+            base_retriever = VectorRetriever()
+            logger.info("새 VectorRetriever 초기화 성공.")
+        except Exception as e_init:
+            logger.error(f"새 VectorRetriever 초기화 실패: {e_init}", exc_info=True)
+            base_retriever = None
+
+    if base_retriever is None:
+        logger.error("base_retriever 초기화/로드에 실패하여 init_retriever 중단.")
+        return None
+
+    # 2. 데이터 폴더 문서 로드 (기본 검색기가 비어있을 때)
+    needs_loading = (not hasattr(base_retriever, 'documents') or not getattr(base_retriever, 'documents', None)) # None 체크 추가
+    if needs_loading and os.path.exists(data_path):
+        logger.info(f"기본 검색기가 비어있어 {data_path}에서 문서 로드 시도...")
+        try:
+            # ================== 수정된 부분 1 시작 ==================
+            # DocumentProcessor.load_documents_from_directory 호출 시 올바른 인자 전달
+            docs = DocumentProcessor.load_documents_from_directory(
+                directory=data_path, # <-- 경로 변수 사용
+                extensions=[".txt", ".md", ".csv"], # <-- 필요한 확장자 전달
+                recursive=True # <-- 재귀 탐색 여부 전달
+            )
+            # ================== 수정된 부분 1 끝 ====================
+            logger.info(f"{len(docs)}개 문서 로드 성공.")
+            if docs and hasattr(base_retriever, 'add_documents'):
+                logger.info("검색기에 문서 추가 시도...")
+                base_retriever.add_documents(docs)
+                logger.info("문서 추가 완료.")
+
+                if hasattr(base_retriever, 'save'):
+                    logger.info(f"검색기 상태 저장 시도: {index_path}")
+                    try:
+                        base_retriever.save(index_path)
+                        logger.info("인덱스 저장 완료.")
+                    except Exception as e_save:
+                        logger.error(f"인덱스 저장 실패: {e_save}", exc_info=True)
+        except Exception as e_load_add:
+            # load_documents_from_directory 자체에서 오류가 날 수도 있음 (권한 등)
+            logger.error(f"DATA_FOLDER 문서 로드/추가 중 오류: {e_load_add}", exc_info=True)
+
+    # 3. 재순위화 검색기 초기화
+    logger.info("재순위화 검색기 초기화 시도...")
+    try:
+        # ================== 수정된 부분 2 시작 ==================
+        # custom_rerank_fn 함수를 ReRanker 초기�� 전에 정의
+        def custom_rerank_fn(query, results):
+            query_terms = set(query.lower().split())
+            for result in results:
+                if isinstance(result, dict) and "text" in result:
+                    text = result["text"].lower()
+                    term_freq = sum(1 for term in query_terms if term in text)
+                    normalized_score = term_freq / (len(text.split()) + 1) * 10
+                    result["rerank_score"] = result.get("score", 0) * 0.7 + normalized_score * 0.3
+                elif isinstance(result, dict):
+                        result["rerank_score"] = result.get("score", 0)
+            results.sort(key=lambda x: x.get("rerank_score", 0) if isinstance(x, dict) else 0, reverse=True)
+            return results
+        # ================== 수정된 부분 2 끝 ====================
+
+        # ReRanker 클래스 사용
+        retriever = ReRanker(
+            base_retriever=base_retriever,
+            rerank_fn=custom_rerank_fn, # 이제 함수가 정의되었으므로 사용 가능
+            rerank_field="text"
+        )
+        logger.info("재순위화 검색기 초기화 완료.")
+    except Exception as e_rerank:
+        logger.error(f"재순위화 검색기 초기화 실패: {e_rerank}", exc_info=True)
+        logger.warning("재순위화 실패, 기본 검색기를 retriever로 사용합니다.")
+        retriever = base_retriever # fallback
+
+    logger.info("--- init_retriever 종료 ---")
+    return retriever
+
+def background_init():
+    """백그라운드에서 검색기 초기화 수행"""
+    global app_ready, retriever, base_retriever, llm_interface, stt_client
+
+    temp_app_ready = False # 임시 상태 플래그
+    try:
+        logger.info("백그라운드 초기화 시작...")
+
+        # 1. LLM, STT 인터페이스 초기화 (필요 시)
+        if llm_interface is None or isinstance(llm_interface, MockComponent):
+             if 'LLMInterface' in globals() and LLMInterface != MockComponent:
+                 llm_interface = LLMInterface(default_llm="openai")
+                 logger.info("LLM 인터페이스 초기화 완료.")
+             else:
+                 logger.warning("LLMInterface 클래스 없음. Mock 사용.")
+                 llm_interface = MockComponent() # Mock 객체 보장
+        if stt_client is None or isinstance(stt_client, MockComponent):
+             if 'VitoSTT' in globals() and VitoSTT != MockComponent:
+                 stt_client = VitoSTT()
+                 logger.info("STT 클라이언트 초기화 완료.")
+             else:
+                 logger.warning("VitoSTT 클래스 없음. Mock 사용.")
+                 stt_client = MockComponent() # Mock 객체 보장
+
+
+        # 2. 검색기 초기화
+        if 'VectorRetriever' in globals() and VectorRetriever != MockComponent:
+            logger.info("실제 검색기 초기화 시도...")
+            # init_retriever가 base_retriever와 retriever를 모두 설정한다고 가정
+            retriever = init_retriever()
+            # init_retriever 내부에서 base_retriever가 설정되지 않았다면 여기서 설정
+            if hasattr(retriever, 'base_retriever') and base_retriever is None:
+                 base_retriever = retriever.base_retriever
+            elif base_retriever is None:
+                 # retriever가 base_retriever를 포함하지 않는 경우 또는 ReRanker가 아닌 경우
+                 # init_retriever에서 base_retriever를 직접 설정하도록 하거나, 여기서 별도 로직 필요
+                 # 예시: base_retriever = VectorRetriever.load(...) 또는 VectorRetriever()
+                 logger.warning("init_retriever 후 base_retriever가 설정되지 않음. 확인 필요.")
+                 # 임시로 retriever 자체를 base_retriever로 설정 (동일 객체일 경우)
+                 if isinstance(retriever, VectorRetriever):
+                      base_retriever = retriever
+
+            # 성공적으로 초기화 되었는지 확인 (None이 아닌지)
+            if retriever is not None and base_retriever is not None:
+                logger.info("검색기 (Retriever, Base Retriever) 초기화 성공")
+                temp_app_ready = True # 초기화 성공 시에만 True 설정
+            else:
+                logger.error("검색기 초기화 후에도 retriever 또는 base_retriever가 None입니다.")
+                # 실패 시 Mock 객체 할당 (최소한의 동작 보장)
+                if base_retriever is None: base_retriever = MockComponent()
+                if retriever is None: retriever = MockComponent()
+                if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
+                if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
+                # temp_app_ready = False 또는 True (정책에 따라 결정)
+                temp_app_ready = True # 일단 앱은 실행되도록 설정
+
+        else:
+            logger.warning("VectorRetriever 클���스 없음. Mock 검색기 사용.")
+            base_retriever = MockComponent()
+            retriever = MockComponent()
+            if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
+            if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
+            temp_app_ready = True # Mock이라도 준비는 된 것으로 간주
+
+        logger.info(f"백그라운드 초기화 완료. 최종 상태: {'Ready' if temp_app_ready else 'Not Ready (Error during init)'}")
+
+    except Exception as e:
+        logger.error(f"앱 백그라운드 초기화 중 심각한 오류 발생: {e}", exc_info=True)
+        # 오류 발생 시에도 Mock 객체 할당 시도
+        if base_retriever is None: base_retriever = MockComponent()
+        if retriever is None: retriever = MockComponent()
+        if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
+        if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
+        temp_app_ready = True # 오류 발생해도 앱은 응답하도록 설정 (정책에 따라 False 가능)
+        logger.warning("초기화 중 오류가 발생했지만 Mock 객체로 대체 후 앱 사용 가능 상태로 설정.")
+
+    finally:
+         # 최종적으로 app_ready 상태 업데이트
+         app_ready = temp_app_ready
+
+# 백그라운드 스레드 시작 부분은 그대로 유지
+init_thread = threading.Thread(target=background_init)
+init_thread.daemon = True
+init_thread.start()
+
+
+# --- Flask 라우트 정의 ---
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    error = None
+    next_url = request.args.get('next') # 리디렉션할 URL 가져오기
+    logger.info(f"-------------- 로그인 페이지 접속 (Next: {next_url}) --------------")
+    logger.info(f"Method: {request.method}")
+
+    # 헤더 로깅 (디버깅용)
+    # logger.debug("Request Headers:")
+    # for header, value in request.headers.items():
+    #     logger.debug(f"  {header}: {value}")
+
+    if request.method == 'POST':
+        logger.info("로그인 시도 받음")
+        username = request.form.get('username', '')
+        password = request.form.get('password', '')
+        logger.info(f"입력된 사용자명: {username}")
+        logger.info(f"비밀번호 입력 여부: {len(password) > 0}")
+
+        # 환경 변수 또는 기본값과 비교
+        valid_username = ADMIN_USERNAME
+        valid_password = ADMIN_PASSWORD
+        logger.info(f"검증용 사용자명: {valid_username}")
+        logger.info(f"검증용 비밀번호 존재 여부: {valid_password is not None and len(valid_password) > 0}")
+
+
+        if username == valid_username and password == valid_password:
+            logger.info(f"로그인 성공: {username}")
+            # 세션 설정 전 현재 세션 상태 로깅
+            logger.debug(f"세션 설정 전: {session}")
+
+            # 세션에 로그인 정보 저장
+            session.permanent = True # PERMANENT_SESSION_LIFETIME 설정 사용
+            session['logged_in'] = True
+            session['username'] = username
+            session.modified = True # 세션이 변경되었음을 명시 (필수는 아닐 수 있음)
+
+            logger.info(f"세션 설정 후: {session}")
+            logger.info("세션 설정 완료, 리디렉션 시도")
+
+            # 로그인 성공 후 리디렉션
+            # 'next' 파라미터가 있으면 해당 URL로, 없으면 메인 페이지로
+            redirect_to = next_url or url_for('index')
+            logger.info(f"리디렉션 대상: {redirect_to}")
+            response = redirect(redirect_to)
+
+            # 응답 헤더 로깅 (Set-Cookie 확인용)
+            # logger.debug(f"로그인 성공 응답 헤더: {response.headers}")
+            return response
+        else:
+            logger.warning("로그인 실패: 아이디 또는 비밀번호 불일치")
+            if username != valid_username: logger.warning("사용자명 불일치")
+            if password != valid_password: logger.warning("비밀번호 불일치")
+            error = '아이디 또는 비밀번호가 올바르지 않습니다.'
+    else: # GET 요청
+        logger.info("로그인 페이지 GET 요청")
+        if 'logged_in' in session:
+            logger.info("이미 로그인된 사용자, 메인 페이지로 리디렉션")
+            return redirect(url_for('index'))
+
+    logger.info("---------- 로그인 페이지 렌더링 ----------")
+    return render_template('login.html', error=error, next=next_url)
+
+
+@app.route('/logout')
+def logout():
+    logger.info("-------------- 로그아웃 요청 --------------")
+    logger.info(f"로그아웃 전 세션 상태: {session}")
+
+    if 'logged_in' in session:
+        username = session.get('username', 'unknown')
+        logger.info(f"사용자 {username} 로그아웃 처리 시작")
+        session.pop('logged_in', None)
+        session.pop('username', None)
+        session.modified = True # 세션 ���경 명시
+        logger.info(f"세션 정보 삭제 완료. 현재 세션: {session}")
+    else:
+        logger.warning("로그인되지 않은 상태에서 로그아웃 시도")
+
+    logger.info("로그인 페이지로 리디렉션")
+    response = redirect(url_for('login'))
+    # logger.debug(f"로그아웃 응답 헤더: {response.headers}") # 쿠키 삭제 확인용
+    return response
+
+
+@app.route('/')
+@login_required
+def index():
+    """메인 페이지"""
+    global app_ready
+    
+    # 앱 준비 상태 확인 - 30초 이상 지났으면 강제로 ready 상태로 변경
+    current_time = datetime.datetime.now()
+    start_time = datetime.datetime.fromtimestamp(os.path.getmtime(__file__))
+    time_diff = (current_time - start_time).total_seconds()
+    
+    if not app_ready and time_diff > 30:
+        logger.warning(f"앱이 30초 이상 초기화 중 상태입니다. 강제로 ready 상태로 변경합니다.")
+        app_ready = True
+    
+    if not app_ready:
+        logger.info("앱이 아직 준비되지 않아 로딩 페이지 표시")
+        return render_template('loading.html'), 503  # 서비스 준비 안됨 상태 코드
+    
+    logger.info("메인 페이지 요청")
+    return render_template('index.html')
+
+
+@app.route('/api/status')
+@login_required
+def app_status():
+    """앱 초기화 상태 확인 API"""
+    logger.info(f"앱 상태 확인 요청: {'Ready' if app_ready else 'Not Ready'}")
+    return jsonify({"ready": app_ready})
+
+
+@app.route('/api/llm', methods=['GET', 'POST'])
+@login_required
+def llm_api():
+    """사용 가능한 LLM 목록 및 선택 API"""
+    global llm_interface
+
+    if not app_ready:
+        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+
+    if request.method == 'GET':
+        logger.info("LLM 목록 요청")
+        try:
+            current_details = llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {"id": "unknown", "name": "Unknown"}
+            supported_llms_dict = llm_interface.SUPPORTED_LLMS if hasattr(llm_interface, 'SUPPORTED_LLMS') else {}
+            supported_list = [{
+                "name": name, "id": id, "current": id == current_details.get("id")
+            } for name, id in supported_llms_dict.items()]
+
+            return jsonify({
+                "supported_llms": supported_list,
+                "current_llm": current_details
+            })
+        except Exception as e:
+            logger.error(f"LLM 정보 조회 오류: {e}")
+            return jsonify({"error": "LLM 정보 조회 중 오류 발생"}), 500
+
+    elif request.method == 'POST':
+        data = request.get_json()
+        if not data or 'llm_id' not in data:
+            return jsonify({"error": "LLM ID가 제공되지 않았습니다."}), 400
+
+        llm_id = data['llm_id']
+        logger.info(f"LLM 변경 요청: {llm_id}")
+
+        try:
+            if not hasattr(llm_interface, 'set_llm') or not hasattr(llm_interface, 'llm_clients'):
+                raise NotImplementedError("LLM 인터페이스에 필요한 메소드/속성 없음")
+
+            if llm_id not in llm_interface.llm_clients:
+                return jsonify({"error": f"지원되지 않는 LLM ID: {llm_id}"}), 400
+
+            success = llm_interface.set_llm(llm_id)
+            if success:
+                new_details = llm_interface.get_current_llm_details()
+                logger.info(f"LLM이 '{new_details.get('name', llm_id)}'로 변경되었습니다.")
+                return jsonify({
+                    "success": True,
+                    "message": f"LLM이 '{new_details.get('name', llm_id)}'로 변경되었습니다.",
+                    "current_llm": new_details
+                })
+            else:
+                # set_llm 이 False를 반환하는 경우 (가능성은 낮지만)
+                logger.error(f"LLM 변경 실패 (ID: {llm_id})")
+                return jsonify({"error": "LLM 변경 중 내부 오류 발생"}), 500
+        except Exception as e:
+            logger.error(f"LLM 변경 처리 중 오류: {e}", exc_info=True)
+            return jsonify({"error": f"LLM 변경 중 오류 발생: {str(e)}"}), 500
+
+
+@app.route('/api/chat', methods=['POST'])
+@login_required
+def chat():
+    """텍스트 기반 챗봇 API"""
+    global retriever
+
+    if not app_ready or retriever is None:
+        return jsonify({"error": "앱/검색기가 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+
+    try:
+        data = request.get_json()
+        if not data or 'query' not in data:
+            return jsonify({"error": "쿼리가 제공되지 않았습니다."}), 400
+
+        query = data['query']
+        logger.info(f"텍스트 쿼리 수신: {query[:100]}...") # 너무 긴 쿼리 로그는 잘라서 표시
+
+        # RAG 검색 수행
+        if not hasattr(retriever, 'search'):
+            raise NotImplementedError("Retriever에 search 메소드가 없습니다.")
+        search_results = retriever.search(query, top_k=5, first_stage_k=6) # 재순위화 고려
+
+        # 컨텍스트 준비
+        if not hasattr(DocumentProcessor, 'prepare_rag_context'):
+            raise NotImplementedError("DocumentProcessor에 prepare_rag_context 메소드가 없습니다.")
+        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+
+        if not context:
+            logger.warning("검색 결과가 없어 컨텍스트를 생성하지 못함.")
+            # LLM 호출 없이 기본 응답 반환 또는 검색 결과 없음을 알리는 응답 생성
+            # answer = "죄송합니다. 관련 정보를 찾을 수 없습니다." (아래 LLM 호출 로직에서 처리)
+            pass
+
+        # LLM에 질의
+        llm_id = data.get('llm_id', None) # 클라이언트에서 특정 LLM 지정 가능
+        if not hasattr(llm_interface, 'rag_generate'):
+            raise NotImplementedError("LLMInterface에 rag_generate 메소드가 없습니다.")
+
+        if not context:
+            answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+            logger.info("컨텍스트 없이 기본 응답 생성")
+        else:
+            answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
+            logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+
+
+        # 소스 정보 추출 (CSV ID 추출 로직 포함)
+        sources = []
+        if search_results: # 검색 결과가 있을 때만 소스 처리
+            for result in search_results:
+                # 결과가 딕셔너리 형태인지 확인
+                if not isinstance(result, dict):
+                    logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
+                    continue
+
+                if "source" in result:
+                    source_info = {
+                        "source": result.get("source", "Unknown"),
+                        # 재순위화 점수가 있으면 사용, 없으면 원래 점수 사용
+                        "score": result.get("rerank_score", result.get("score", 0))
+                    }
+
+                    # CSV 파일 특정 처리
+                    if "text" in result and result.get("filetype") == "csv":
+                        try:
+                            text_lines = result["text"].strip().split('\n')
+                            if text_lines:
+                                first_line = text_lines[0].strip()
+                                if ',' in first_line:
+                                    first_column = first_line.split(',')[0].strip()
+                                    source_info["id"] = first_column # 예: CSV의 첫 컬럼 값을 ID로 추가
+                                    logger.debug(f"CSV 소스 ID 추출: {first_column} from {source_info['source']}")
+                        except Exception as e:
+                            logger.warning(f"CSV 소스 ID 추출 실패 ({result.get('source')}): {e}")
+
+                    sources.append(source_info)
+
+        # 최종 응답
+        response_data = {
+            "answer": answer,
+            "sources": sources,
+            "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
+        }
+        # logger.debug(f"최종 API 응답: {response_data}") # 너무 길 수 있으므로 필요한 경우에만 활성화
+        return jsonify(response_data)
+
+    except Exception as e:
+        logger.error(f"채팅 처리 중 오류 발생: {e}", exc_info=True)
+        return jsonify({"error": f"처리 중 오류가 발생했습니다: {str(e)}"}), 500
+
+
+@app.route('/api/voice', methods=['POST'])
+@login_required
+def voice_chat():
+    """음성 챗 API 엔드포인트"""
+    global retriever, stt_client
+
+
+    if not app_ready:
+        logger.warning("앱 초기화가 완료되지 않았지만 음성 API 요청 처리 시도")
+        # 여기서 바로 리턴하지 않고 계속 진행
+        # 사전 검사: retriever와 stt_client가 제대로 초기화되었는지 확인
+
+    if retriever is None:
+        logger.error("retriever가 아직 초기화되지 않았습니다")
+        return jsonify({
+            "transcription": "(음성을 텍스트로 변환했지만 검색 엔진이 아직 준비되지 않았습니다)",
+            "answer": "죄송합니다. 검색 엔진이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요.",
+            "sources": []
+        })
+    # 또는 필수 컴포넌트가 없을 때만 특별 응답 반환
+    if stt_client is None:
+        return jsonify({
+            "transcription": "(음성 인식 기능이 준비 중입니다)",
+            "answer": "죄송합니다. 현재 음성 인식 서비스가 초기화 중입니다. 잠시 후 다시 시도해주세요.",
+            "sources": []
+        })
+
+    logger.info("음성 챗 요청 수신")
+    
+    if 'audio' not in request.files:
+        logger.error("오디오 파일이 제공되지 않음")
+        return jsonify({"error": "오디오 파일이 제공되지 않았습니다."}), 400
+
+    audio_file = request.files['audio']
+    logger.info(f"수신된 오디오 파일: {audio_file.filename} ({audio_file.content_type})")
+
+    try:
+        # 오디오 파일 처리
+        # 임시 파일 사용 고려 (메모리 부담 줄이기 위해)
+        with tempfile.NamedTemporaryFile(delete=True) as temp_audio:
+            audio_file.save(temp_audio.name)
+            logger.info(f"오디오 파일을 임시 저장: {temp_audio.name}")
+            # VitoSTT.transcribe_audio 가 파일 경로 또는 바이트를 받을 수 있도록 구현되어야 함
+            # 여기서는 파일 경로를 사용한다고 가정
+            if not hasattr(stt_client, 'transcribe_audio'):
+                raise NotImplementedError("STT 클라이언트에 transcribe_audio 메소드가 없습니다.")
+
+            # 파일 경로로 전달 시
+            # stt_result = stt_client.transcribe_audio(temp_audio.name, language="ko")
+            # 바이트로 전달 시
+            with open(temp_audio.name, 'rb') as f_bytes:
+                audio_bytes = f_bytes.read()
+            stt_result = stt_client.transcribe_audio(audio_bytes, language="ko")
+
+
+        if not isinstance(stt_result, dict) or not stt_result.get("success"):
+            error_msg = stt_result.get("error", "알 수 없는 STT 오류") if isinstance(stt_result, dict) else "STT 결과 형식 오류"
+            logger.error(f"음성인식 실패: {error_msg}")
+            return jsonify({
+                "error": "음성인식 실패",
+                "details": error_msg
+            }), 500
+
+        transcription = stt_result.get("text", "")
+        if not transcription:
+            logger.warning("음성인식 결과가 비어있습니다.")
+            return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다.", "transcription": ""}), 400
+
+        logger.info(f"음성인식 성공: {transcription[:50]}...")
+        if retriever is None:
+            logger.error("STT 성공 후 검색 시도 중 retriever가 None임")
+            return jsonify({
+                "transcription": transcription,
+                "answer": "음성을 인식했지만, 현재 검색 시스템이 준비되지 않았습니다. 잠시 후 다시 시도해주세요.",
+                "sources": []
+            })
+        # --- 이후 로직은 /api/chat과 거의 동일 ---
+        # RAG 검색 수행
+        search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
+        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+
+        if not context:
+            logger.warning("음성 쿼리에 대한 검색 결과 없음.")
+            # answer = "죄송합니다. 관련 정보를 찾을 수 없습니다." (아래 LLM 호출 로직에서 처리)
+            pass
+
+        # LLM 호출
+        llm_id = request.form.get('llm_id', None) # 음성 요청은 form 데이터로 LLM ID 받을 수 있음
+        if not context:
+            answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+            logger.info("컨텍스트 없이 기본 응답 생성")
+        else:
+            answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
+            logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+
+
+        # 소스 정보 추출
+        enhanced_sources = []
+        if search_results:
+            for doc in search_results:
+                if not isinstance(doc, dict): continue # 형식 체크
+                if "source" in doc:
+                    source_info = {
+                        "source": doc.get("source", "Unknown"),
+                        "score": doc.get("rerank_score", doc.get("score", 0))
+                    }
+                    if "text" in doc and doc.get("filetype") == "csv":
+                        try:
+                            text_lines = doc["text"].strip().split('\n')
+                            if text_lines:
+                                first_line = text_lines[0].strip()
+                                if ',' in first_line:
+                                    first_column = first_line.split(',')[0].strip()
+                                    source_info["id"] = first_column
+                        except Exception as e:
+                            logger.warning(f"[음성챗] CSV 소스 ID 추출 실패 ({doc.get('source')}): {e}")
+                    enhanced_sources.append(source_info)
+
+        # 최종 응답
+        response_data = {
+            "transcription": transcription,
+            "answer": answer,
+            "sources": enhanced_sources,
+            "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
+        }
+        return jsonify(response_data)
+
+    except Exception as e:
+        logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
+        return jsonify({
+            "error": "음성 처리 중 내부 오류 발생",
+            "details": str(e)
+        }), 500
+
+
+@app.route('/api/upload', methods=['POST'])
+@login_required
+def upload_document():
+    """지식베이스 문서 업로드 API"""
+    global base_retriever, retriever
+
+    if not app_ready or base_retriever is None:
+        return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503
+
+    if 'document' not in request.files:
+        return jsonify({"error": "문서 파일이 제공되지 않았습니다."}), 400
+
+    doc_file = request.files['document']
+    if doc_file.filename == '':
+        return jsonify({"error": "선택된 파일이 없습니다."}), 400
+
+    if not allowed_doc_file(doc_file.filename):
+        logger.error(f"허용되지 않는 파일 형식: {doc_file.filename}")
+        return jsonify({"error": f"허용되지 않는 파일 형식입니다. 허용: {', '.join(ALLOWED_DOC_EXTENSIONS)}"}), 400
+
+    try:
+        filename = secure_filename(doc_file.filename)
+        filepath = os.path.join(app.config['DATA_FOLDER'], filename)
+        doc_file.save(filepath)
+        logger.info(f"문서 저장 완료: {filepath}")
+
+        # 문서 처리 (인코딩 처리 포함)
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except UnicodeDecodeError:
+            logger.info(f"UTF-8 디코딩 실패, CP949로 시도: {filename}")
+            try:
+                with open(filepath, 'r', encoding='cp949') as f:
+                    content = f.read()
+            except Exception as e_cp949:
+                logger.error(f"CP949 디코딩 실패 ({filename}): {e_cp949}")
+                return jsonify({"error": "파일 인코딩을 읽을 수 없습니다 (UTF-8, CP949 시도 실패)."}), 400
+        except Exception as e_read:
+            logger.error(f"파일 읽기 오류 ({filename}): {e_read}")
+            return jsonify({"error": f"파일 읽기 중 오류 발생: {str(e_read)}"}), 500
+
+
+        # 메타데이터 및 문서 분할/처리
+        metadata = {
+            "source": filename, "filename": filename,
+            "filetype": filename.rsplit('.', 1)[1].lower(),
+            "filepath": filepath
+        }
+        file_ext = metadata["filetype"]
+        docs = []
+
+        if not hasattr(DocumentProcessor, 'csv_to_documents') or not hasattr(DocumentProcessor, 'text_to_documents'):
+            raise NotImplementedError("DocumentProcessor에 필요한 메소드 없음")
+
+        if file_ext == 'csv':
+            logger.info(f"CSV 파일 처리 시작: {filename}")
+            docs = DocumentProcessor.csv_to_documents(content, metadata) # 행 단위 처리 가정
+        else: # 기타 텍스트 기반 문서
+            logger.info(f"일반 텍스트 문서 처리 시작: {filename}")
+            # PDF, DOCX 등은 별도 라이브러리(pypdf, python-docx) 필요
+            if file_ext in ['pdf', 'docx']:
+                logger.warning(f".{file_ext} 파일 처리는 현재 구현되지 않았습니다. 텍스트 추출 로직 추가 필요.")
+                # 여기에 pdf/docx 텍스트 추출 로직 추가
+                # 예: content = extract_text_from_pdf(filepath)
+                # content = extract_text_from_docx(filepath)
+                # 임시로 비워둠
+                content = ""
+
+            if content: # 텍스트 내용이 있을 때만 처리
+                docs = DocumentProcessor.text_to_documents(
+                    content, metadata=metadata,
+                    chunk_size=512, chunk_overlap=50
+                )
+
+        # 검색기에 문서 추가 및 인덱스 저장
+        if docs:
+            if not hasattr(base_retriever, 'add_documents') or not hasattr(base_retriever, 'save'):
+                raise NotImplementedError("기본 검색기에 add_documents 또는 save 메소드 없음")
+
+            logger.info(f"{len(docs)}개 문서 청크를 검색기에 추가합니다...")
+            base_retriever.add_documents(docs)
+
+            # 인덱스 저장 (업로드마다 저장 - 비효율적일 수 있음)
+            logger.info(f"검색기 상태를 저장합니다...")
+            index_path = app.config['INDEX_PATH']
+            try:
+                base_retriever.save(index_path)
+                logger.info("인덱스 저장 완료")
+                # 재순위화 검색기도 업데이트 필요 시 로직 추가
+                # 예: retriever.update_base_retriever(base_retriever)
+                return jsonify({
+                    "success": True,
+                    "message": f"파일 '{filename}' 업로드 및 처리 완료 ({len(docs)}개 청크 추가)."
+                })
+            except Exception as e_save:
+                logger.error(f"인덱스 저장 중 오류 발생: {e_save}")
+                return jsonify({"error": f"인덱스 저장 중 오류: {str(e_save)}"}), 500
+        else:
+            logger.warning(f"파일 '{filename}'에서 처리��� 내용이 없거나 지원되지 않는 형식입니다.")
+            # 파일은 저장되었으므로 성공으로 간주할지 결정 필요
+            return jsonify({
+                "warning": True,
+                "message": f"파일 '{filename}'이 저장되었지만 처리할 내용이 없습니다."
+            })
+
+    except Exception as e:
+        logger.error(f"파일 업로드 또는 처리 중 오류 발생: {e}", exc_info=True)
+        return jsonify({"error": f"파일 업로드 중 오류: {str(e)}"}), 500
+
+
+@app.route('/api/documents', methods=['GET'])
+@login_required
+def list_documents():
+    """지식베이스 문서 목록 API"""
+    global base_retriever
+
+    if not app_ready or base_retriever is None:
+        return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503
+
+    try:
+        sources = {}
+        total_chunks = 0
+        # base_retriever.documents 와 같은 속성이 실제 클래스에 있다고 가정
+        if hasattr(base_retriever, 'documents') and base_retriever.documents:
+            logger.info(f"총 {len(base_retriever.documents)}개 문서 청크에서 소스 목록 생성 중...")
+            for doc in base_retriever.documents:
+                # 문서 청크가 딕셔너리 형태라고 가정
+                if not isinstance(doc, dict): continue
+
+                source = doc.get("source", "unknown") # 메타데이터에서 source 가져오기
+                if source == "unknown" and "metadata" in doc and isinstance(doc["metadata"], dict):
+                    source = doc["metadata"].get("source", "unknown") # Langchain Document 구조 고려
+
+                if source != "unknown":
+                    if source in sources:
+                        sources[source]["chunks"] += 1
+                    else:
+                        # 메타데이터에서 추가 정보 가져오기
+                        filename = doc.get("filename", source)
+                        filetype = doc.get("filetype", "unknown")
+                        if "metadata" in doc and isinstance(doc["metadata"], dict):
+                            filename = doc["metadata"].get("filename", filename)
+                            filetype = doc["metadata"].get("filetype", filetype)
+
+                        sources[source] = {
+                            "filename": filename,
+                            "chunks": 1,
+                            "filetype": filetype
+                        }
+                total_chunks += 1
+        else:
+            logger.info("검색기에 문서가 없거나 documents 속성을 찾을 수 없습니다.")
+
+        # 목록 형식 변환 및 정렬
+        documents = [{"source": src, **info} for src, info in sources.items()]
+        documents.sort(key=lambda x: x["chunks"], reverse=True)
+
+        logger.info(f"문서 목록 조회 완료: {len(documents)}개 소스 파일, {total_chunks}개 청크")
+        return jsonify({
+            "documents": documents,
+            "total_documents": len(documents),
+            "total_chunks": total_chunks # sum(doc["chunks"] for doc in documents) 와 동일
+        })
+
+    except Exception as e:
+        logger.error(f"문서 목록 조회 중 오류 발생: {e}", exc_info=True)
+        return jsonify({"error": f"문서 목록 조회 중 오류: {str(e)}"}), 500
+
+
+# 정적 파일 서빙
+@app.route('/static/<path:path>')
+def send_static(path):
+    return send_from_directory('static', path)
+
+
+# --- 요청 처리 훅 ---
+
+# @app.before_request - 제거됨 (수동 쿠키 처리 로직 삭제)
+# def process_cookies(): ...
+
+@app.after_request
+def after_request_func(response):
+    """모든 응답에 대해 후처리 수행"""
+    # 세션이 수정되었는지 확인 후 로깅 (디버깅용)
+    # if session.modified: # session.modified 는 항상 정확하지 않을 수 있음
+    #     logger.debug(f"[After Request] 세션 수정 감지됨. 응답에 Set-Cookie 포함 여부 확인 필요.")
+    # logger.debug(f"[After Request] 응답 헤더: {response.headers}") # 디버깅 시 Set-Cookie 확인
+    return response # 응답 객체를 반드시 반환해야 합니다.
+
+# 앱 실행 (로컬 테스트용)
+if __name__ == '__main__':
+    logger.info("Flask 앱을 직접 실행합니다 (개발용 서버).")
+    # 디버그 모드는 실제 배포 시 False로 설정해야 합니다.
+    # port 번호는 환경 변수 또는 기본값을 사용합니다.
+    port = int(os.environ.get("PORT", 7860))
+    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
+    app.run(debug=True, host='0.0.0.0', port=port)

app/static/js/app.js

@@ -1,58 +1,636 @@
 /**
- * RAG 검색 챗봇 UI JavaScript 메인 파일
- * 이 파일은 모듈화된 JS 파일들을 로드하는 역할을 합니다.
+ * RAG 검색 챗봇 UI JavaScript
  */
 
-// 스크립트 동적 로드 함수
-function loadScript(url, callback = null) {
-    console.log(`스크립트 로드 중: ${url}`);
+// DOM 요소
+const chatTab = document.getElementById('chatTab');
+const docsTab = document.getElementById('docsTab');
+const chatSection = document.getElementById('chatSection');
+const docsSection = document.getElementById('docsSection');
+const chatMessages = document.getElementById('chatMessages');
+const userInput = document.getElementById('userInput');
+const sendButton = document.getElementById('sendButton');
+const micButton = document.getElementById('micButton');
+const stopRecordingButton = document.getElementById('stopRecordingButton');
+const recordingStatus = document.getElementById('recordingStatus');
+const uploadForm = document.getElementById('uploadForm');
+const documentFile = document.getElementById('documentFile');
+const fileName = document.getElementById('fileName');
+const uploadButton = document.getElementById('uploadButton');
+const uploadStatus = document.getElementById('uploadStatus');
+const refreshDocsButton = document.getElementById('refreshDocsButton');
+const docsList = document.getElementById('docsList');
+const docsLoading = document.getElementById('docsLoading');
+const noDocsMessage = document.getElementById('noDocsMessage');
+const llmSelect = document.getElementById('llmSelect');
+const currentLLMInfo = document.getElementById('currentLLMInfo');
+
+// LLM 관련 변수
+let currentLLM = 'openai';
+let supportedLLMs = [];
+
+// 녹음 관련 변수
+let mediaRecorder = null;
+let audioChunks = [];
+let isRecording = false;
+
+// 앱 초기화 상태 확인 함수
+async function checkAppStatus() {
+    try {
+        const response = await fetch('/api/status');
+        if (!response.ok) {
+            return false;
+        }
+        const data = await response.json();
+        return data.ready;
+    } catch (error) {
+        console.error('Status check failed:', error);
+        return false;
+    }
+}
+
+/**
+ * LLM 목록 로드 함수
+ */
+async function loadLLMs() {
+    try {
+        // API 요청
+        const response = await fetch('/api/llm');
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        supportedLLMs = data.supported_llms;
+        currentLLM = data.current_llm.id;
+        
+        // LLM 선택 드롭다운 업데이트
+        llmSelect.innerHTML = '';
+        supportedLLMs.forEach(llm => {
+            const option = document.createElement('option');
+            option.value = llm.id;
+            option.textContent = llm.name;
+            option.selected = llm.current;
+            llmSelect.appendChild(option);
+        });
+        
+        // 현재 LLM 표시
+        updateCurrentLLMInfo(data.current_llm);
+    } catch (error) {
+        console.error('LLM 목록 로드 실패:', error);
+    }
+}
+
+/**
+ * LLM 변경 함수
+ * @param {string} llmId - 변경할 LLM ID
+ */
+async function changeLLM(llmId) {
+    try {
+        // API 요청
+        const response = await fetch('/api/llm', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ llm_id: llmId })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            currentLLM = llmId;
+            updateCurrentLLMInfo(data.current_llm);
+            console.log(`LLM이 ${data.current_llm.name}(으)로 변경되었습니다.`);
+            
+            // 시스템 메시지 추가
+            const systemMessage = `LLM이 ${data.current_llm.name}(으)로 변경되었습니다. 모델: ${data.current_llm.model}`;
+            addSystemNotification(systemMessage);
+        } else if (data.error) {
+            console.error('LLM 변경 오류:', data.error);
+            alert(`LLM 변경 오류: ${data.error}`);
+        }
+    } catch (error) {
+        console.error('LLM 변경 실패:', error);
+        alert('LLM 변경 중 오류가 발생했습니다.');
+    }
+}
+
+/**
+ * 현재 LLM 정보 표시 업데이트
+ * @param {Object} llmInfo - LLM 정보 객체
+ */
+function updateCurrentLLMInfo(llmInfo) {
+    if (currentLLMInfo) {
+        currentLLMInfo.textContent = `${llmInfo.name} (${llmInfo.model})`;
+    }
+}
+
+/**
+ * 시스템 알림 메시지 추가
+ * @param {string} message - 알림 메시지
+ */
+function addSystemNotification(message) {
+    const messageDiv = document.createElement('div');
+    messageDiv.classList.add('message', 'system');
+    
+    const contentDiv = document.createElement('div');
+    contentDiv.classList.add('message-content');
+    
+    const messageP = document.createElement('p');
+    messageP.innerHTML = `<i class="fas fa-info-circle"></i> ${message}`;
+    contentDiv.appendChild(messageP);
+    
+    messageDiv.appendChild(contentDiv);
+    chatMessages.appendChild(messageDiv);
+    
+    // 스크롤을 가장 아래로 이동
+    chatMessages.scrollTop = chatMessages.scrollHeight;
+}
+
+// 페이지 로드 시 초기화
+document.addEventListener('DOMContentLoaded', () => {
+    // 앱 상태 확인 (로딩 페이지가 아닌 경우에만)
+    if (window.location.pathname === '/' && !document.getElementById('app-loading-indicator')) {
+        // 앱 상태 주기적으로 확인
+        const statusInterval = setInterval(async () => {
+            const isReady = await checkAppStatus();
+            if (isReady) {
+                clearInterval(statusInterval);
+                console.log('앱이 준비되었습니다.');
+                
+                // 앱이 준비되면 LLM 목록 로드
+                loadLLMs();
+            }
+        }, 5000);
+    }
+
+    // 탭 전환 이벤트 리스너
+    chatTab.addEventListener('click', () => {
+        switchTab('chat');
+    });
+    
+    docsTab.addEventListener('click', () => {
+        switchTab('docs');
+        loadDocuments();
+    });
+    
+    // LLM 선택 이벤트 리스너
+    llmSelect.addEventListener('change', (event) => {
+        changeLLM(event.target.value);
+    });
+    
+    // 메시지 전송 이벤트 리스너
+    sendButton.addEventListener('click', sendMessage);
+    userInput.addEventListener('keydown', (event) => {
+        if (event.key === 'Enter' && !event.shiftKey) {
+            event.preventDefault();
+            sendMessage();
+        }
+    });
+    
+    // 음성 인식 이벤트 리스너
+    micButton.addEventListener('click', startRecording);
+    stopRecordingButton.addEventListener('click', stopRecording);
+    
+    // 문서 업로드 이벤트 리스너
+    documentFile.addEventListener('change', (event) => {
+        if (event.target.files.length > 0) {
+            fileName.textContent = event.target.files[0].name;
+        } else {
+            fileName.textContent = '선택된 파일 없음';
+        }
+    });
+    
+    uploadForm.addEventListener('submit', (event) => {
+        event.preventDefault();
+        uploadDocument();
+    });
+    
+    // 문서 목록 새로고침 이벤트 리스너
+    refreshDocsButton.addEventListener('click', loadDocuments);
+    
+    // 자동 입력 필드 크기 조정
+    userInput.addEventListener('input', adjustTextareaHeight);
+    
+    // 초기 문서 목록 로드
+    if (docsSection.classList.contains('active')) {
+        loadDocuments();
+    }
+});
+
+/**
+ * 탭 전환 함수
+ * @param {string} tabName - 활성화할 탭 이름 ('chat' 또는 'docs')
+ */
+function switchTab(tabName) {
+    if (tabName === 'chat') {
+        chatTab.classList.add('active');
+        docsTab.classList.remove('active');
+        chatSection.classList.add('active');
+        docsSection.classList.remove('active');
+    } else if (tabName === 'docs') {
+        chatTab.classList.remove('active');
+        docsTab.classList.add('active');
+        chatSection.classList.remove('active');
+        docsSection.classList.add('active');
+    }
+}
+
+/**
+ * 채팅 메시지 전송 함수
+ */
+async function sendMessage() {
+    const message = userInput.value.trim();
+    if (!message) return;
+    
+    // UI 업데이트
+    addMessage(message, 'user');
+    userInput.value = '';
+    adjustTextareaHeight();
+    
+    // 로딩 메시지 추가
+    const loadingMessageId = addLoadingMessage();
     
-    const script = document.createElement('script');
-    script.type = 'text/javascript';
-    script.src = url;
+    try {
+        // API 요청
+        const response = await fetch('/api/chat', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ 
+                query: message,
+                llm_id: currentLLM  // 현재 선택된 LLM 전송
+            })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        
+        // 로딩 메시지 제거
+        removeLoadingMessage(loadingMessageId);
+        
+        // 응답 표시
+        if (data.error) {
+            addErrorMessage(data.error);
+        } else {
+            // LLM 정보 업데이트
+            if (data.llm) {
+                updateCurrentLLMInfo(data.llm);
+            }
+            addMessage(data.answer, 'bot', null, data.sources);
+        }
+    } catch (error) {
+        console.error('Error:', error);
+        removeLoadingMessage(loadingMessageId);
+        addErrorMessage('오류가 발생했습니다. 다시 시도해 주세요.');
+    }
+}
+
+/**
+ * 음성 녹음 시작 함수
+ */
+async function startRecording() {
+    if (isRecording) return;
     
-    // 콜백 함수 설정 (있는 경우)
-    if (callback) {
-        script.onload = callback;
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        isRecording = true;
+        audioChunks = [];
+        
+        mediaRecorder = new MediaRecorder(stream);
+        
+        mediaRecorder.addEventListener('dataavailable', (event) => {
+            if (event.data.size > 0) audioChunks.push(event.data);
+        });
+        
+        mediaRecorder.addEventListener('stop', sendAudioMessage);
+        
+        // 녹음 시작
+        mediaRecorder.start();
+        
+        // UI 업데이트
+        micButton.style.display = 'none';
+        recordingStatus.classList.remove('hidden');
+        
+        console.log('녹음 시작됨');
+    } catch (error) {
+        console.error('음성 녹음 권한을 얻을 수 없습니다:', error);
+        alert('마이크 접근 권한이 필요합니다.');
     }
+}
+
+/**
+ * 음성 녹음 중지 함수
+ */
+function stopRecording() {
+    if (!isRecording || !mediaRecorder) return;
+    
+    mediaRecorder.stop();
+    isRecording = false;
     
-    // 에러 핸들링
-    script.onerror = function() {
-        console.error(`스크립트 로드 실패: ${url}`);
-    };
+    // UI 업데이트
+    micButton.style.display = 'flex';
+    recordingStatus.classList.add('hidden');
     
-    // 페이지에 스크립트 추가
-    document.head.appendChild(script);
+    console.log('녹음 중지됨');
 }
 
-// 모듈 로드 순서 관리
-document.addEventListener('DOMContentLoaded', function() {
-    console.log('앱 초기화 시작: 모듈 로드');
+/**
+ * 녹음된 오디오 메시지 전송 함수
+ */
+async function sendAudioMessage() {
+    if (audioChunks.length === 0) return;
+    
+    // 오디오 Blob 생성
+    const audioBlob = new Blob(audioChunks, { type: 'audio/wav' });
     
-    // 모듈 파일 경로
-    const coreScriptPath = '/static/js/app-core.js';
-    const llmScriptPath = '/static/js/app-llm.js';
-    const docsScriptPath = '/static/js/app-docs.js';
-    const deviceScriptPath = '/static/js/app-device.js';
+    // 로딩 메시지 추가
+    const loadingMessageId = addLoadingMessage();
     
-    // 모듈 순차적 로드
-    loadScript(coreScriptPath, function() {
-        console.log('코어 모듈 로드 완료');
+    try {
+        // FormData에 오디오 추가
+        const formData = new FormData();
+        formData.append('audio', audioBlob, 'recording.wav');
+        // 현재 선택된 LLM 추가
+        formData.append('llm_id', currentLLM);
+        
+        // API 요청
+        const response = await fetch('/api/voice', {
+            method: 'POST',
+            body: formData
+        });
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        
+        // 로딩 메시지 제거
+        removeLoadingMessage(loadingMessageId);
         
-        // LLM 모듈 로드
-        loadScript(llmScriptPath, function() {
-            console.log('LLM 모듈 로드 완료');
+        // 응답 표시
+        if (data.error) {
+            addErrorMessage(data.error);
+        } else {
+            // LLM 정보 업데이트
+            if (data.llm) {
+                updateCurrentLLMInfo(data.llm);
+            }
             
-            // 문서 관리 모듈 로드
-            loadScript(docsScriptPath, function() {
-                console.log('문서 관리 모듈 로드 완료');
-                
-                // 장치 관리 모듈 로드
-                loadScript(deviceScriptPath, function() {
-                    console.log('장치 관리 모듈 로드 완료');
-                    console.log('모든 모듈 로드 완료');
-                });
-            });
+            // 사용자 메시지(음성 텍스트) 추가
+            if (data.transcription) {
+                addMessage(data.transcription, 'user');
+            }
+            
+            // 봇 응답 추가
+            addMessage(data.answer, 'bot', data.transcription, data.sources);
+        }
+    } catch (error) {
+        console.error('Error:', error);
+        removeLoadingMessage(loadingMessageId);
+        addErrorMessage('오디오 처리 중 오류가 발생했습니다. 다시 시도해 주세요.');
+    }
+}
+
+/**
+ * 문서 업로드 함수
+ */
+async function uploadDocument() {
+    if (documentFile.files.length === 0) {
+        alert('파일을 선택해 주세요.');
+        return;
+    }
+    
+    // UI 업데이트
+    uploadStatus.classList.remove('hidden');
+    uploadStatus.className = 'upload-status';
+    uploadStatus.innerHTML = '<div class="spinner"></div><p>업로드 중...</p>';
+    uploadButton.disabled = true;
+    
+    try {
+        const formData = new FormData();
+        formData.append('document', documentFile.files[0]);
+        
+        // API 요청
+        const response = await fetch('/api/upload', {
+            method: 'POST',
+            body: formData
         });
-    });
-});
+        
+        const data = await response.json();
+        
+        // 응답 처리
+        if (data.error) {
+            uploadStatus.className = 'upload-status error';
+            uploadStatus.textContent = `오류: ${data.error}`;
+        } else if (data.warning) {
+            uploadStatus.className = 'upload-status warning';
+            uploadStatus.textContent = data.message;
+        } else {
+            uploadStatus.className = 'upload-status success';
+            uploadStatus.textContent = data.message;
+            
+            // 문서 목록 새로고침
+            loadDocuments();
+            
+            // 입력 필드 초기화
+            documentFile.value = '';
+            fileName.textContent = '선택된 파일 없음';
+        }
+    } catch (error) {
+        console.error('Error:', error);
+        uploadStatus.className = 'upload-status error';
+        uploadStatus.textContent = '업로드 중 오류가 발생했습니다. 다시 시도해 주세요.';
+    } finally {
+        uploadButton.disabled = false;
+    }
+}
+
+/**
+ * 문서 목록 로드 함수
+ */
+async function loadDocuments() {
+    // UI 업데이트
+    docsList.querySelector('tbody').innerHTML = '';
+    docsLoading.classList.remove('hidden');
+    noDocsMessage.classList.add('hidden');
+    
+    try {
+        // API 요청
+        const response = await fetch('/api/documents');
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        
+        // 응답 처리
+        docsLoading.classList.add('hidden');
+        
+        if (!data.documents || data.documents.length === 0) {
+            noDocsMessage.classList.remove('hidden');
+            return;
+        }
+        
+        // 문서 목록 업데이트
+        const tbody = docsList.querySelector('tbody');
+        data.documents.forEach(doc => {
+            const row = document.createElement('tr');
+            
+            const fileNameCell = document.createElement('td');
+            fileNameCell.textContent = doc.filename || doc.source;
+            row.appendChild(fileNameCell);
+            
+            const chunksCell = document.createElement('td');
+            chunksCell.textContent = doc.chunks;
+            row.appendChild(chunksCell);
+            
+            const typeCell = document.createElement('td');
+            typeCell.textContent = doc.filetype || '-';
+            row.appendChild(typeCell);
+            
+            tbody.appendChild(row);
+        });
+    } catch (error) {
+        console.error('Error:', error);
+        docsLoading.classList.add('hidden');
+        noDocsMessage.classList.remove('hidden');
+        noDocsMessage.querySelector('p').textContent = '문서 목록을 불러오는 중 오류가 발생했습니다.';
+    }
+}
+
+/**
+ * 메시지 추가 함수
+ * @param {string} text - 메시지 내용
+ * @param {string} sender - 메시지 발신자 ('user' 또는 'bot' 또는 'system')
+ * @param {string|null} transcription - 음성 인식 텍스트 (선택 사항)
+ * @param {Array|null} sources - 소스 정보 배열 (선택 사항)
+ */
+function addMessage(text, sender, transcription = null, sources = null) {
+    const messageDiv = document.createElement('div');
+    messageDiv.classList.add('message', sender);
+    
+    const contentDiv = document.createElement('div');
+    contentDiv.classList.add('message-content');
+    
+    // 음성 인식 텍스트 추가 (있는 경우)
+    if (transcription && sender === 'bot') {
+        const transcriptionP = document.createElement('p');
+        transcriptionP.classList.add('transcription');
+        transcriptionP.textContent = `"${transcription}"`;
+        contentDiv.appendChild(transcriptionP);
+    }
+    
+    // 메시지 텍스트 추가
+    const textP = document.createElement('p');
+    textP.textContent = text;
+    contentDiv.appendChild(textP);
+    
+    // 소스 정보 추가 (있는 경우)
+    if (sources && sources.length > 0 && sender === 'bot') {
+        const sourcesDiv = document.createElement('div');
+        sourcesDiv.classList.add('sources');
+        
+        const sourcesTitle = document.createElement('strong');
+        sourcesTitle.textContent = '출처: ';
+        sourcesDiv.appendChild(sourcesTitle);
+        
+        sources.forEach((source, index) => {
+            if (index < 3) { // 최대 3개까지만 표시
+                const sourceSpan = document.createElement('span');
+                sourceSpan.classList.add('source-item');
+                sourceSpan.textContent = source.source;
+                sourcesDiv.appendChild(sourceSpan);
+            }
+        });
+        
+        contentDiv.appendChild(sourcesDiv);
+    }
+    
+    messageDiv.appendChild(contentDiv);
+    chatMessages.appendChild(messageDiv);
+    
+    // 스크롤을 ���장 아래로 이동
+    chatMessages.scrollTop = chatMessages.scrollHeight;
+}
+
+/**
+ * 로딩 메시지 추가 함수
+ * @returns {string} 로딩 메시지 ID
+ */
+function addLoadingMessage() {
+    const id = 'loading-' + Date.now();
+    const messageDiv = document.createElement('div');
+    messageDiv.classList.add('message', 'bot');
+    messageDiv.id = id;
+    
+    const contentDiv = document.createElement('div');
+    contentDiv.classList.add('message-content');
+    
+    const loadingP = document.createElement('p');
+    loadingP.innerHTML = '<div class="spinner" style="width: 20px; height: 20px; display: inline-block; margin-right: 10px;"></div> 생각 중...';
+    contentDiv.appendChild(loadingP);
+    
+    messageDiv.appendChild(contentDiv);
+    chatMessages.appendChild(messageDiv);
+    
+    // 스크롤을 가장 아래로 이동
+    chatMessages.scrollTop = chatMessages.scrollHeight;
+    
+    return id;
+}
+
+/**
+ * 로딩 메시지 제거 함수
+ * @param {string} id - 로딩 메시지 ID
+ */
+function removeLoadingMessage(id) {
+    const loadingMessage = document.getElementById(id);
+    if (loadingMessage) {
+        loadingMessage.remove();
+    }
+}
+
+/**
+ * 오류 메시지 추가 함수
+ * @param {string} errorText - 오류 메시지 내용
+ */
+function addErrorMessage(errorText) {
+    const messageDiv = document.createElement('div');
+    messageDiv.classList.add('message', 'system');
+    
+    const contentDiv = document.createElement('div');
+    contentDiv.classList.add('message-content');
+    contentDiv.style.backgroundColor = 'rgba(239, 68, 68, 0.1)';
+    contentDiv.style.color = 'var(--error-color)';
+    
+    const errorP = document.createElement('p');
+    errorP.innerHTML = `<i class="fas fa-exclamation-circle"></i> ${errorText}`;
+    contentDiv.appendChild(errorP);
+    
+    messageDiv.appendChild(contentDiv);
+    chatMessages.appendChild(messageDiv);
+    
+    // 스크롤을 가장 아래로 이동
+    chatMessages.scrollTop = chatMessages.scrollHeight;
+}
+
+/**
+ * textarea 높이 자동 조정 함수
+ */
+function adjustTextareaHeight() {
+    userInput.style.height = 'auto';
+    userInput.style.height = Math.min(userInput.scrollHeight, 100) + 'px';
+}

app/templates/index.html

@@ -6,7 +6,6 @@
     <title>RAG 검색 챗봇</title>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css">
     <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
-    <link rel="stylesheet" href="{{ url_for('static', filename='css/device-style.css') }}">
 </head>
 <body>
     <div class="container">
@@ -29,7 +28,6 @@
             <div class="tabs">
                 <button id="chatTab" class="tab active">대화</button>
                 <button id="docsTab" class="tab">문서관리</button>
-                <button id="deviceTab" class="tab">장치관리</button>
             </div>
         </header>
 
@@ -121,51 +119,6 @@
                     </div>
                 </div>
             </section>
-            
-            <!-- 장치관리 탭 -->
-            <section id="deviceSection" class="tab-content">
-                <div class="device-container">
-                    <div class="device-section">
-                        <div class="device-toolbar">
-                            <h2>장치 상태</h2>
-                            <button id="deviceRefreshButton" class="refresh-device-btn">
-                                <i class="fas fa-sync-alt"></i> 새로고침
-                            </button>
-                        </div>
-                        
-                        <div id="deviceStatus">
-                            <!-- 장치 서버 상태가 여기에 표시됩니다 -->
-                            <div class="loading-device">
-                                <div class="spinner"></div>
-                                <p>장치 상태 확인 중...</p>
-                            </div>
-                        </div>
-                        
-                        <div id="deviceList">
-                            <!-- 장치 목록이 여기에 표시됩니다 -->
-                        </div>
-                    </div>
-                    
-                    <div class="programs-section">
-                        <div class="device-toolbar">
-                            <h2>프로그램 실행</h2>
-                            <button id="loadProgramsButton" class="load-programs-btn">
-                                <i class="fas fa-list"></i> 프로그램 목록 로드
-                            </button>
-                        </div>
-                        
-                        <div id="programsContainer" class="programs-container">
-                            <div id="programsList">
-                                <!-- 프로그램 목록이 여기에 표시됩니다 -->
-                                <div class="loading-programs">
-                                    <div class="spinner"></div>
-                                    <p>프로그램 목록 로드 중...</p>
-                                </div>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </section>
         </main>
 
         <footer>