fix

app/app_routes.py

@@ -7,8 +7,8 @@ import json
 import logging
 import tempfile
 import requests
-import time # 앱 시작 시간 기록 위해 추가
-import threading # threading.Event 사용 위해 추가
+import time  # 앱 시작 시간 기록 위해 추가
+import threading  # threading.Event 사용 위해 추가
 from flask import request, jsonify, render_template, send_from_directory, session, redirect, url_for
 from datetime import datetime
 from werkzeug.utils import secure_filename
@@ -19,8 +19,7 @@ logger = logging.getLogger(__name__)
 # 앱 시작 시간 기록 (모듈 로드 시점)
 APP_START_TIME = time.time()
 
-# register_routes 함수 인자 목록에서 app_ready_flag 대신 app_ready_event 사용 가정
-def register_routes(app, login_required, llm_interface, retriever, stt_client, DocumentProcessor, base_retriever, app_ready_event, ADMIN_USERNAME, ADMIN_PASSWORD, DEVICE_SERVER_URL):
+def register_routes(app, login_required, llm_interface, retriever, stt_client, DocumentProcessor, base_retriever, app_ready_flag, ADMIN_USERNAME, ADMIN_PASSWORD, DEVICE_SERVER_URL):
     """Flask 애플리케이션에 기본 라우트 등록"""
 
     # 헬퍼 함수 (변경 없음)
@@ -34,7 +33,7 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
         ALLOWED_DOC_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'csv'}
         return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_DOC_EXTENSIONS
 
-    # --- 로그인/로그아웃 라우트 ---
+    # --- 로그인/로그아웃 라우트 (변경 없음) ---
     @app.route('/login', methods=['GET', 'POST'])
     def login():
         error = None
@@ -66,7 +65,7 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             else:
                 logger.warning("로그인 실패: 아이디 또는 비밀번호 불일치")
                 error = '아이디 또는 비밀번호가 올바르지 않습니다.'
-        else: # GET 요청
+        else:  # GET 요청
             logger.info("로그인 페이지 GET 요청")
             if session.get('logged_in'):
                 logger.info("이미 로그인된 사용자, 메인 페이지로 리디렉션")
@@ -75,65 +74,62 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
         logger.info("---------- 로그인 페이지 렌더링 ----------")
         return render_template('login.html', error=error, next=next_url)
 
-
     @app.route('/logout')
     def logout():
         """로그아웃 처리"""
         username = session.get('username', 'unknown')
         if session.pop('logged_in', None):
-             session.pop('username', None)
-             logger.info(f"사용자 {username} 로그아웃 처리 완료. 현재 세션: {session}")
+            session.pop('username', None)
+            logger.info(f"사용자 {username} 로그아웃 처리 완료. 현재 세션: {session}")
         else:
-             logger.warning("로그인되지 않은 상태에서 로그아웃 시도")
+            logger.warning("로그인되지 않은 상태에서 로그아웃 시도")
 
         logger.info("로그인 페이지로 리디렉션")
         response = redirect(url_for('login'))
         logger.debug(f"로그아웃 응답 헤더 (Set-Cookie 확인): {response.headers.getlist('Set-Cookie')}")
         return response
 
-    # --- 메인 페이지 및 상태 확인 (app_ready_event 사용) ---
+    # --- 메인 페이지 및 상태 확인 (app_ready_flag 사용) ---
     @app.route('/')
     @login_required
     def index():
         """메인 페이지"""
-        # app_ready_event가 Event 객체인지 확인하고 상태 가져오기
-        is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False # 기본값 False
+        # app_ready_flag가 Event 객체인지 bool인지 확인하고 상태 가져오기
+        is_ready = app_ready_flag.is_set() if isinstance(app_ready_flag, threading.Event) else app_ready_flag
 
         time_elapsed = time.time() - APP_START_TIME
 
         if not is_ready:
             logger.info(f"앱이 아직 준비되지 않아 로딩 페이지 표시 (경과 시간: {time_elapsed:.1f}초)")
-            # loading.html 템플릿이 있다고 가정
-            return render_template('loading.html') # 200 OK와 로딩 페이지
+            return render_template('loading.html')  # 200 OK와 로딩 페이지
 
         logger.info("메인 페이지 요청")
-        # index.html 템플릿이 있다고 가정
         return render_template('index.html')
 
-
     @app.route('/api/status')
     @login_required
     def app_status():
         """앱 초기화 상태 확인 API"""
-        is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
+        is_ready = app_ready_flag.is_set() if isinstance(app_ready_flag, threading.Event) else app_ready_flag
         logger.info(f"앱 상태 확인 요청: {'Ready' if is_ready else 'Not Ready'}")
         return jsonify({"ready": is_ready})
 
-    # --- LLM API ---
+    # --- LLM API (변경 없음) ---
     @app.route('/api/llm', methods=['GET', 'POST'])
     @login_required
     def llm_api():
         """사용 가능한 LLM 목록 및 선택 API"""
-        # is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-        # LLM 목록 조회는 초기화 중에도 가능하도록 허용
+        is_ready = app_ready_flag.is_set() if isinstance(app_ready_flag, threading.Event) else app_ready_flag
+        # 초기화 중에도 LLM 목록 조회는 가능하도록 허용
+        # if not is_ready:
+        #     return jsonify({"error": "앱 초기화 중..."}), 503
 
         if request.method == 'GET':
             logger.info("LLM 목록 요청")
             try:
-                # 객체 및 속성 확인 강화
                 if llm_interface is None or not hasattr(llm_interface, 'get_current_llm_details') or not hasattr(llm_interface, 'SUPPORTED_LLMS'):
-                     logger.error("LLM 인터페이스가 준비되지 않았거나 필요한 속성이 없습니다.")
-                     return jsonify({"error": "LLM 인터페이스 오류"}), 500
+                    logger.error("LLM 인터페이스가 준비되지 않았거나 필요한 속성이 없습니다.")
+                    return jsonify({"error": "LLM 인터페이스 오류"}), 500
 
                 current_details = llm_interface.get_current_llm_details()
                 supported_llms_dict = llm_interface.SUPPORTED_LLMS
@@ -150,10 +146,6 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                 return jsonify({"error": "LLM 정보 조회 중 오류 발생"}), 500
 
         elif request.method == 'POST':
-            is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-            if not is_ready: # LLM 변경은 앱 준비 완료 후 가능
-                 return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
-
             data = request.get_json()
             if not data or 'llm_id' not in data:
                 return jsonify({"error": "LLM ID가 제공되지 않았습니다."}), 400
@@ -162,10 +154,9 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             logger.info(f"LLM 변경 요청: {llm_id}")
 
             try:
-                # 객체 및 속성/메소드 확인 강화
                 if llm_interface is None or not hasattr(llm_interface, 'set_llm') or not hasattr(llm_interface, 'llm_clients') or not hasattr(llm_interface, 'get_current_llm_details'):
-                     logger.error("LLM 인터페이스가 준비되지 않았거나 필요한 속성/메소드가 없습니다.")
-                     return jsonify({"error": "LLM 인터페이스 오류"}), 500
+                    logger.error("LLM 인터페이스가 준비되지 않았거나 필요한 속성/메소드가 없습니다.")
+                    return jsonify({"error": "LLM 인터페이스 오류"}), 500
 
                 if llm_id not in llm_interface.llm_clients:
                     return jsonify({"error": f"지원되지 않는 LLM ID: {llm_id}"}), 400
@@ -186,23 +177,18 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                 logger.error(f"LLM 변경 처리 중 오류: {e}", exc_info=True)
                 return jsonify({"error": f"LLM 변경 중 오류 발생: {str(e)}"}), 500
 
-    # --- Chat API ---
+    # --- Chat API (변경 없음) ---
     @app.route('/api/chat', methods=['POST'])
     @login_required
     def chat():
         """텍스트 기반 채봇 API"""
-        is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-        if not is_ready:
-             return jsonify({"error": "앱 초기화 중...", "answer": "죄송합니다. 시스템이 아직 준비 중입니다.", "sources": []}), 503
-
-        # retriever 객체 및 필수 메소드 확인
         if retriever is None or not hasattr(retriever, 'search'):
             logger.warning("채팅 API 요청 시 retriever가 준비되지 않았거나 search 메소드가 없습니다.")
             return jsonify({
                 "answer": "죄송합니다. 검색 엔진이 아직 준비되지 않았습니다. 잠시 후 다시 시도해주세요.",
                 "sources": [],
                 "error": "Retriever not ready"
-            }), 503 # 서비스 불가 상태
+            }), 200  # 503 대신 200 OK
 
         try:
             data = request.get_json()
@@ -212,25 +198,21 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             query = data['query']
             logger.info(f"텍스트 쿼리 수신: {query[:100]}...")
 
-            # RAG 검색 수행
             search_results = retriever.search(query, top_k=5, first_stage_k=6)
 
-            # DocumentProcessor 객체 및 메소드 확인
             if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
-                 logger.error("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
-                 return jsonify({"error": "문서 처리기 오류"}), 500
+                logger.error("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
+                return jsonify({"error": "문서 처리기 오류"}), 500
             context = DocumentProcessor.prepare_rag_context(search_results, field="text")
 
             if not context:
                 logger.warning(f"쿼리 '{query[:50]}...'에 대한 검색 결과 없음.")
 
-            # LLM 인터페이스 객체 및 메소드 확인
             llm_id = data.get('llm_id', None)
             if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
-                 logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
-                 return jsonify({"error": "LLM 인터페이스 오류"}), 500
+                logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
+                return jsonify({"error": "LLM 인터페이스 오류"}), 500
 
-            # LLM 호출
             if not context:
                 answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
                 logger.info("컨텍스트 없이 기본 응답 생성")
@@ -238,7 +220,6 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                 answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
                 logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
 
-            # 소스 정보 추출
             sources = []
             if search_results:
                 for result in search_results:
@@ -267,7 +248,6 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                                 logger.warning(f"CSV 소스 ID 추출 실패 ({source_info.get('source')}): {e}")
                         sources.append(source_info)
 
-            # 최종 응답
             response_data = {
                 "answer": answer,
                 "sources": sources,
@@ -279,16 +259,11 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             logger.error(f"채팅 처리 중 오류 발생: {e}", exc_info=True)
             return jsonify({"error": f"처리 중 오류가 발생했습니다: {str(e)}"}), 500
 
-    # --- Voice Chat API ---
+    # --- Voice Chat API (변경 없음) ---
     @app.route('/api/voice', methods=['POST'])
     @login_required
     def voice_chat():
         """음성 챗 API 엔드포인트"""
-        is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-        if not is_ready:
-             return jsonify({"error": "앱 초기화 중..."}), 503
-
-        # 필수 컴포넌트 확인
         if retriever is None or not hasattr(retriever, 'search'):
             logger.error("음성 API 요청 시 retriever가 준비되지 않음")
             return jsonify({"error": "검색 엔진 준비 안됨"}), 503
@@ -296,11 +271,11 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             logger.error("음성 API 요청 시 STT 클라이언트가 준비되지 않음")
             return jsonify({"error": "음성 인식 서비스 준비 안됨"}), 503
         if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
-             logger.error("음성 API 요청 시 LLM 인터페이스가 준비되지 않음")
-             return jsonify({"error": "LLM 인터페이스 오류"}), 500
+            logger.error("음성 API 요청 시 LLM 인터페이스가 준비되지 않음")
+            return jsonify({"error": "LLM 인터페이스 오류"}), 500
         if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
-             logger.error("음성 API 요청 시 DocumentProcessor가 준비되지 않음")
-             return jsonify({"error": "문서 처리기 오류"}), 500
+            logger.error("음성 API 요청 시 DocumentProcessor가 준비되지 않음")
+            return jsonify({"error": "문서 처리기 오류"}), 500
 
         logger.info("음성 챗 요청 수신")
 
@@ -312,16 +287,13 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
         logger.info(f"수신된 오디오 파일: {audio_file.filename} ({audio_file.content_type})")
 
         try:
-            # 오디오 파일 임시 저장 및 처리
             with tempfile.NamedTemporaryFile(delete=True, suffix=os.path.splitext(audio_file.filename)[1]) as temp_audio:
                 audio_file.save(temp_audio.name)
                 logger.info(f"오디오 파일을 임시 저장: {temp_audio.name}")
-                # STT 수행 (바이트 전달 가정)
                 with open(temp_audio.name, 'rb') as f_bytes:
                     audio_bytes = f_bytes.read()
                 stt_result = stt_client.transcribe_audio(audio_bytes, language="ko")
 
-            # STT 결과 처리
             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}")
@@ -335,15 +307,14 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                     "answer": "음성에서 텍스트를 인식하지 못했습니다.",
                     "sources": [],
                     "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
-                }), 200 # 200 OK와 메시지
+                }), 200
 
             logger.info(f"음성인식 성공: {transcription[:50]}...")
 
-            # --- RAG 및 LLM 호출 (Chat API와 동일 로직) ---
             search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
             context = DocumentProcessor.prepare_rag_context(search_results, field="text")
 
-            llm_id = request.form.get('llm_id', None) # form 데이터에서 llm_id 가져오기
+            llm_id = request.form.get('llm_id', None)
             if not context:
                 answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
                 logger.info("컨텍스트 없이 기본 응답 생성")
@@ -351,34 +322,33 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                 answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
                 logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
 
-            # 소스 정보 추출 (Chat API와 동일 로직)
             sources = []
             if search_results:
-                 for result in search_results:
-                     if not isinstance(result, dict): continue
-                     source_info = {}
-                     source_key = result.get("source")
-                     if not source_key and "metadata" in result and isinstance(result["metadata"], dict):
-                         source_key = result["metadata"].get("source")
-                     if source_key:
-                         source_info["source"] = source_key
-                         source_info["score"] = result.get("rerank_score", result.get("score", 0))
-                         filetype = result.get("filetype")
-                         if not filetype and "metadata" in result and isinstance(result["metadata"], dict):
-                             filetype = result["metadata"].get("filetype")
-                         if "text" in result and 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
-                             except Exception as e:
-                                 logger.warning(f"[음성챗] CSV 소스 ID 추출 실패 ({source_info.get('source')}): {e}")
-                         sources.append(source_info)
-
-            # 최종 응답
+                for result in search_results:
+                    if not isinstance(result, dict):
+                        continue
+                    source_info = {}
+                    source_key = result.get("source")
+                    if not source_key and "metadata" in result and isinstance(result["metadata"], dict):
+                        source_key = result["metadata"].get("source")
+                    if source_key:
+                        source_info["source"] = source_key
+                        source_info["score"] = result.get("rerank_score", result.get("score", 0))
+                        filetype = result.get("filetype")
+                        if not filetype and "metadata" in result and isinstance(result["metadata"], dict):
+                            filetype = result["metadata"].get("filetype")
+                        if "text" in result and 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
+                            except Exception as e:
+                                logger.warning(f"[음성챗] CSV 소스 ID 추출 실패 ({source_info.get('source')}): {e}")
+                        sources.append(source_info)
+
             response_data = {
                 "transcription": transcription,
                 "answer": answer,
@@ -391,16 +361,11 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
             return jsonify({"error": "음성 처리 중 내부 오류 발생", "details": str(e)}), 500
 
-    # --- Document Upload API ---
+    # --- Document Upload API (변경 없음) ---
     @app.route('/api/upload', methods=['POST'])
     @login_required
     def upload_document():
         """지식베이스 문서 업로드 API"""
-        is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-        if not is_ready:
-             return jsonify({"error": "앱 초기화 중..."}), 503
-
-        # base_retriever 객체 및 필수 메소드 확인
         if base_retriever is None or not hasattr(base_retriever, 'add_documents') or not hasattr(base_retriever, 'save'):
             logger.error("문서 업로드 API 요청 시 base_retriever가 준비되지 않았거나 필수 메소드가 없습니다.")
             return jsonify({"error": "기본 검색기가 준비되지 않았습니다."}), 503
@@ -412,38 +377,33 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
         if not doc_file or not doc_file.filename:
             return jsonify({"error": "선택된 파일이 없습니다."}), 400
 
-        # ALLOWED_DOC_EXTENSIONS를 함수 내에서 다시 정의하거나 전역 상수로 사용
-        ALLOWED_DOC_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'csv'}
         if not allowed_doc_file(doc_file.filename):
+            ALLOWED_DOC_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'csv'}
             logger.warning(f"허용되지 않는 파일 형식: {doc_file.filename}")
             return jsonify({"error": f"허용되지 않는 파일 형식입니다. 허용: {', '.join(ALLOWED_DOC_EXTENSIONS)}"}), 400
 
         try:
             filename = secure_filename(doc_file.filename)
-            # app.config 사용 확인
-            if 'DATA_FOLDER' not in app.config:
-                 logger.error("Flask app.config에 DATA_FOLDER가 설정되지 않았습니다.")
-                 return jsonify({"error": "서버 설정 오류 (DATA_FOLDER)"}), 500
-            data_folder = app.config['DATA_FOLDER']
+            data_folder = app.config.get('DATA_FOLDER', os.path.join(os.path.dirname(__file__), '..', 'data'))
             os.makedirs(data_folder, exist_ok=True)
             filepath = os.path.join(data_folder, filename)
 
             doc_file.save(filepath)
             logger.info(f"문서 저장 완료: {filepath}")
 
-            # DocumentProcessor 객체 및 메소드 확인
             if DocumentProcessor is None or not hasattr(DocumentProcessor, 'csv_to_documents') or not hasattr(DocumentProcessor, 'text_to_documents'):
-                 logger.error("DocumentProcessor가 준비되지 않았거나 필요한 메소드가 없습니다.")
-                 try: os.remove(filepath) # 저장된 파일 삭제
-                 except OSError: pass
-                 return jsonify({"error": "문서 처리기 오류"}), 500
+                logger.error("DocumentProcessor가 준비되지 않았거나 필요한 메소드가 없습니다.")
+                try:
+                    os.remove(filepath)
+                except OSError:
+                    pass
+                return jsonify({"error": "문서 처리기 오류"}), 500
 
             content = None
             file_ext = filename.rsplit('.', 1)[1].lower()
             metadata = {"source": filename, "filename": filename, "filetype": file_ext, "filepath": filepath}
             docs = []
 
-            # 파일 읽기 및 내용 추출
             if file_ext in ['txt', 'md', 'csv']:
                 try:
                     with open(filepath, 'r', encoding='utf-8') as f:
@@ -460,115 +420,94 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                     logger.error(f"파일 읽기 오류 ({filename}): {e_read}")
                     return jsonify({"error": f"파일 읽기 중 오류 발생: {str(e_read)}"}), 500
             elif file_ext == 'pdf':
-                 logger.warning("PDF 처리는 구현되지 않았습니다.")
-                 # 여기에 PDF 텍스트 추출 로직 추가 (예: PyPDF2 사용)
-                 # content = extract_text_from_pdf(filepath)
+                logger.warning("PDF 처리는 구현되지 않았습니다.")
             elif file_ext == 'docx':
-                 logger.warning("DOCX 처리는 구현되지 않았습니다.")
-                 # 여기에 DOCX 텍스트 추출 로직 추가 (예: python-docx 사용)
-                 # content = extract_text_from_docx(filepath)
+                logger.warning("DOCX 처리는 구현되지 않았습니다.")
 
-            # 문서 분할/처리
-            if content is not None: # 내용이 성공적으로 읽혔거나 추출되었을 때만
+            if content is not None:
                 if file_ext == 'csv':
                     logger.info(f"CSV 파일 처리 시작: {filename}")
                     docs = DocumentProcessor.csv_to_documents(content, metadata)
-                elif file_ext in ['txt', 'md'] or (file_ext in ['pdf', 'docx'] and content): # 텍스트 기반 또는 추출된 내용
-                    logger.info(f"텍스트 기반 문서 처리 시작: {filename}")
-                    # text_to_documents 함수가 청크 분할 등을 수행한다고 가정
+                elif file_ext in ['txt', 'md']:
+                    logger.info(f"텍스트 문서 처리 시작: {filename}")
                     docs = DocumentProcessor.text_to_documents(
                         content, metadata=metadata,
-                        chunk_size=512, chunk_overlap=50 # 설정값 사용
+                        chunk_size=512, chunk_overlap=50
                     )
 
-            # 검색기에 추가 및 저장
             if docs:
                 logger.info(f"{len(docs)}개 문서 청크를 검색기에 추가합니다...")
                 base_retriever.add_documents(docs)
 
                 logger.info(f"검색기 상태를 저장합니다...")
-                # app.config 사용 확인
-                if 'INDEX_PATH' not in app.config:
-                     logger.error("Flask app.config에 INDEX_PATH가 설정되지 않았습니다.")
-                     return jsonify({"error": "서버 설정 오류 (INDEX_PATH)"}), 500
-                index_path = app.config['INDEX_PATH']
-                # 인덱스 저장 경로가 폴더인지 파일인지 확인 필요 (VectorRetriever.save 구현에 따라 다름)
-                # 여기서는 index_path가 디렉토리라고 가정하고 부모 디렉토리 생성
+                index_path = app.config.get('INDEX_PATH', os.path.join(data_folder, 'index'))
                 os.makedirs(os.path.dirname(index_path), exist_ok=True)
                 try:
                     base_retriever.save(index_path)
                     logger.info("인덱스 저장 완료")
-                    # TODO: 재순위화 검색기(retriever) 업데이트 로직 필요 시 추가
-                    # 예: if retriever and hasattr(retriever, 'update_base_retriever'): 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}", exc_info=True)
-                    # 저장 실패 시 추가된 문서 롤백 고려?
                     return jsonify({"error": f"인덱스 저장 중 오류: {str(e_save)}"}), 500
             else:
                 logger.warning(f"파일 '{filename}'에서 처리할 내용이 없거나 지원되지 않는 형식입니다.")
-                # 파일은 저장되었으므로 warning 반환
                 return jsonify({
-                    "warning": True, # 'success' 대신 'warning' 사용
+                    "warning": True,
                     "message": f"파일 '{filename}'이 저장되었지만 처리할 내용이 없거나 지원되지 않는 형식입니다."
                 })
 
         except Exception as e:
             logger.error(f"파일 업로드 또는 처리 중 오류 발생: {e}", exc_info=True)
-            # 오류 발생 시 저장된 파일 삭제
             if 'filepath' in locals() and os.path.exists(filepath):
-                try: os.remove(filepath)
-                except OSError as e_del: logger.error(f"업로드 실패 후 파일 삭제 오류: {e_del}")
+                try:
+                    os.remove(filepath)
+                except OSError:
+                    pass
             return jsonify({"error": f"파일 업로드 중 오류: {str(e)}"}), 500
 
-    # --- Document List API ---
+    # --- Document List API (SyntaxError 유발 주석 제거) ---
     @app.route('/api/documents', methods=['GET'])
     @login_required
     def list_documents():
         """지식베이스 문서 목록 API"""
+        # SyntaxError를 유발했던 설명 주석들을 제거했습니다.
         logger.info("문서 목록 API 요청 시작")
 
-        # base_retriever 상태 확인
         if base_retriever is None:
             logger.warning("문서 API 요청 시 base_retriever가 None입니다.")
             return jsonify({"documents": [], "total_documents": 0, "total_chunks": 0})
         elif not hasattr(base_retriever, 'documents'):
-             logger.warning("문서 API 요청 시 base_retriever에 'documents' 속성이 없습니다.")
-             return jsonify({"documents": [], "total_documents": 0, "total_chunks": 0})
+            logger.warning("문서 API 요청 시 base_retriever에 'documents' 속성이 없습니다.")
+            return jsonify({"documents": [], "total_documents": 0, "total_chunks": 0})
 
-        # 로깅 추가
         logger.info(f"base_retriever 객체 타입: {type(base_retriever)}")
         logger.info(f"base_retriever.documents 존재 여부: {hasattr(base_retriever, 'documents')}")
-        doc_list_attr = getattr(base_retriever, 'documents', None) # 안전하게 속성 가져오기
-        logger.info(f"base_retriever.documents 타입: {type(doc_list_attr)}")
-        logger.info(f"base_retriever.documents 길이: {len(doc_list_attr) if isinstance(doc_list_attr, list) else 'N/A'}")
+        if hasattr(base_retriever, 'documents'):
+            logger.info(f"base_retriever.documents 타입: {type(base_retriever.documents)}")
+            logger.info(f"base_retriever.documents 길이: {len(base_retriever.documents) if isinstance(base_retriever.documents, list) else 'N/A'}")
 
         try:
             sources = {}
             total_chunks = 0
-            doc_list = doc_list_attr # 위에서 가져온 속성 사용
+            doc_list = base_retriever.documents
 
-            # doc_list가 리스트인지 확인
             if not isinstance(doc_list, list):
-                 logger.error(f"base_retriever.documents가 리스트가 아님: {type(doc_list)}")
-                 return jsonify({"error": "내부 데이터 구조 오류"}), 500
+                logger.error(f"base_retriever.documents가 리스트가 아님: {type(doc_list)}")
+                return jsonify({"error": "내부 데이터 구조 오류"}), 500
 
             logger.info(f"총 {len(doc_list)}개 문서 청크에서 소스 목록 생성 중...")
             for i, doc in enumerate(doc_list):
-                # 각 청크가 딕셔너리 형태인지 확인 (Langchain Document 객체도 딕셔너리처럼 동작 가능)
-                if not hasattr(doc, 'get'): # 딕셔너리 또는 유사 객체인지 확인
-                     logger.warning(f"청크 {i}가 딕셔너리 타입이 아님: {type(doc)}")
-                     continue
+                if not isinstance(doc, dict):
+                    logger.warning(f"청크 {i}가 딕셔너리 타입이 아님: {type(doc)}")
+                    continue
 
-                # 소스 정보 추출 (metadata 우선)
                 source = "unknown"
                 metadata = doc.get("metadata")
                 if isinstance(metadata, dict):
                     source = metadata.get("source", "unknown")
-                # metadata에 없으면 doc 자체에서 찾기 (하위 호환성)
                 if source == "unknown":
                     source = doc.get("source", "unknown")
 
@@ -576,12 +515,12 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                     if source in sources:
                         sources[source]["chunks"] += 1
                     else:
-                        # filename, filetype 추출 (metadata 우선)
                         filename = metadata.get("filename", source) if isinstance(metadata, dict) else source
                         filetype = metadata.get("filetype", "unknown") if isinstance(metadata, dict) else "unknown"
-                        # metadata에 없으면 doc 자체에서 찾기
-                        if filename == source and doc.get("filename"): filename = doc["filename"]
-                        if filetype == "unknown" and doc.get("filetype"): filetype = doc["filetype"]
+                        if filename == source and "filename" in doc:
+                            filename = doc["filename"]
+                        if filetype == "unknown" and "filetype" in doc:
+                            filetype = doc["filetype"]
 
                         sources[source] = {
                             "filename": filename,
@@ -590,12 +529,10 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                         }
                     total_chunks += 1
                 else:
-                     # 소스 정보가 없는 청크 로깅 (너무 많으면 주석 처리)
-                     logger.warning(f"청크 {i}에서 소스 정보를 찾을 수 없음: {str(doc)[:200]}...") # 내용 일부 로깅
+                    logger.warning(f"청크 {i}에서 소스 정보를 찾을 수 없음: {doc}")
 
-            # 최종 목록 생성 및 정렬
             documents = [{"source": src, **info} for src, info in sources.items()]
-            documents.sort(key=lambda x: x.get("filename", ""), reverse=False) # 파일명 기준 오름차순 정렬
+            documents.sort(key=lambda x: x.get("filename", ""), reverse=False)
 
             logger.info(f"문서 목록 조회 완료: {len(documents)}개 소스 파일, {total_chunks}개 청크")
             return jsonify({
@@ -605,6 +542,9 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             })
 
         except Exception as e:
+            # 여기서 발생하는 예외가 503으로 이어질 수 있는지 확인
             logger.error(f"문서 목록 조회 중 심각한 오류 발생: {e}", exc_info=True)
-            # 503 대신 500 반환
             return jsonify({"error": f"문서 목록 조회 중 오류: {str(e)}"}), 500
+
+    # SyntaxError 수정: 누락된 '#' 추가
+    # * 제공된 `list_documents` 함수 코드 자체에는 `app_ready` 상태나 `base_retriever`가 `None`인 상태를 확인하여 503 오류를 반환하는 로직이 **없습니다.** 로그에서 503이 발생했다면, 원인은 다음 중 하나일 가능성이 높습니다: