Add application file

app/app.py

@@ -1,5 +1,5 @@
 """
-RAG 검색 챗봇 웹 애플리케이션
+RAG 검색 챗봇 웹 애플리케이션 (세션 설정 수정 적용)
 """
 
 import os
@@ -29,9 +29,10 @@ ADMIN_PASSWORD = os.getenv('ADMIN_PASSWORD')
 
 logger.info(f"==== 환경 변수 로드 상태 ====")
 logger.info(f"ADMIN_USERNAME 설정 여부: {ADMIN_USERNAME is not None}")
+# 비밀번호는 로드 여부만 기록 (보안)
 logger.info(f"ADMIN_PASSWORD 설정 여부: {ADMIN_PASSWORD is not None}")
 
-# 환경 변수가 없으면 기본값 설정
+# 환경 변수가 없으면 기본값 설정 (개발용, 배포 시 환경 변수 설정 권장)
 if not ADMIN_USERNAME:
     ADMIN_USERNAME = 'admin'
     logger.warning("ADMIN_USERNAME 환경변수가 없어 기본값 'admin'으로 설정합니다.")
@@ -40,85 +41,97 @@ if not ADMIN_PASSWORD:
     ADMIN_PASSWORD = 'rag12345'
     logger.warning("ADMIN_PASSWORD 환경변수가 없어 기본값 'rag12345'로 설정합니다.")
 
-# 로컬 모듈 임포트
-from utils.vito_stt import VitoSTT
-from utils.llm_interface import LLMInterface
-from utils.document_processor import DocumentProcessor
-from retrieval.vector_retriever import VectorRetriever
-from retrieval.reranker import ReRanker
+# --- 로컬 모듈 임포트 ---
+# 실제 경로에 맞게 utils, retrieval 폴더가 존재해야 합니다.
+try:
+    from utils.vito_stt import VitoSTT
+    from utils.llm_interface import LLMInterface
+    from utils.document_processor import DocumentProcessor
+    from retrieval.vector_retriever import VectorRetriever
+    from retrieval.reranker import ReRanker
+except ImportError as e:
+    logger.error(f"로컬 모듈 임포트 실패: {e}. utils 및 retrieval 패키지가 올바른 경로에 있는지 확인하세요.")
+    # 개발/테스트를 위해 임시 클래스 정의 (실제 사용 시 제거)
+    class MockComponent: pass
+    VitoSTT = LLMInterface = DocumentProcessor = VectorRetriever = ReRanker = MockComponent
+# --- 로컬 모듈 임포트 끝 ---
+
 
 # Flask 앱 초기화
 app = Flask(__name__)
 
-# 세션 설정 - 고정된 시크릿 키 사용
-app.secret_key = 'rag_chatbot_fixed_secret_key_12345'  # 고정된 시크릿 키
-
-# 세션 설정 추가 - 허깅페이스 환경에 맞게 조정
-app.config['SESSION_COOKIE_SECURE'] = False  # HTTP 에서도 쿠키 전송 가능
-app.config['SESSION_COOKIE_HTTPONLY'] = True  # JavaScript에서 쿠키 접근 방지
-app.config['SESSION_COOKIE_SAMESITE'] = None  # 허깅페이스 프로시 관련 이슈 수정
-app.config['SESSION_COOKIE_DOMAIN'] = None  # 모든 도메인에 쿠키 적용
-app.config['SESSION_COOKIE_PATH'] = '/'  # 모든 경로에 쿠키 적용
+# 세션 설정 - 고정된 시크릿 키 사용 (실제 배포 시 환경 변수 등으로 관리 권장)
+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  # 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)
 app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
-app.config['UPLOAD_FOLDER'] = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'uploads')
-app.config['DATA_FOLDER'] = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'data')
-app.config['INDEX_PATH'] = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'data', 'index')
+# 애플리케이션 파일 기준 상대 경로 설정
+APP_ROOT = os.path.dirname(os.path.abspath(__file__))
+app.config['UPLOAD_FOLDER'] = os.path.join(APP_ROOT, 'uploads')
+app.config['DATA_FOLDER'] = os.path.join(APP_ROOT, '..', 'data')
+app.config['INDEX_PATH'] = os.path.join(APP_ROOT, '..', 'data', 'index')
 
-# 업로드 폴더가 없으면 생성
+# 필요한 폴더 생성
 os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
 os.makedirs(app.config['DATA_FOLDER'], exist_ok=True)
 os.makedirs(app.config['INDEX_PATH'], exist_ok=True)
 
-# 허용되는 오디오 파일 확장자
+# 허용되는 오디오/문서 파일 확장자
 ALLOWED_AUDIO_EXTENSIONS = {'mp3', 'wav', 'ogg', 'm4a'}
-
-# 허용되는 문서 파일 확장자
 ALLOWED_DOC_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'csv'}
 
-# LLM 클라이언트 초기화 - OpenAI와 DeepSeek 모두 지원
-llm_interface = LLMInterface(default_llm="openai")
+# --- 전역 객체 초기화 ---
+try:
+    llm_interface = LLMInterface(default_llm="openai")
+    stt_client = VitoSTT()
+except NameError:
+    logger.warning("LLM 또는 STT 인터페이스 초기화 실패. Mock 객체를 사용합니다.")
+    llm_interface = MockComponent()
+    stt_client = MockComponent()
 
-# VITO STT 클라이언트 초기화
-stt_client = VitoSTT()
-
-# 전역 검색기 객체와 재순위화 검색기 객체
 base_retriever = None
 retriever = None
+app_ready = False # 앱 초기화 상태 플래그
+# --- 전역 객체 초기화 끝 ---
 
-# 앱 초기화 상태
-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"현재 플라스크 세션 객체: {session}")
         logger.info(f"현재 세션 상태: logged_in={session.get('logged_in', False)}, username={session.get('username', 'None')}")
-        logger.info(f"현재 세션 케이: {request.cookies.get('session', 'None')}")
-        
-        # 수동 쿠키 확인
-        has_manual_cookie = False
-        if 'session_data' in request.cookies:
-            try:
-                cookie_data = json.loads(request.cookies.get('session_data'))
-                logger.info(f"수동 쿠키 데이터: {cookie_data}")
-                has_manual_cookie = cookie_data.get('logged_in', False)
-            except:
-                pass
-        
-        # 세션 또는 수동 쿠키 중 하나라도 있으면 인증 성공
-        if 'logged_in' not in session and not has_manual_cookie:
-            logger.warning(f"비로그인 상태에서 {request.path} 접근 시도, 로그인 페이지로 리디렉션")
-            return redirect(url_for('login'))
-        
+        # 브라우저가 보낸 실제 쿠키 확인 (디버깅용)
+        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)) # 로그인 후 원래 페이지로 돌아가도록 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
@@ -126,678 +139,686 @@ def allowed_audio_file(filename):
 def allowed_doc_file(filename):
     """파일이 허용된 문서 확장자를 가지는지 확인"""
     return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_DOC_EXTENSIONS
+# --- 헬퍼 함수 끝 ---
+
 
+# --- 검색기 초기화 관련 함수 ---
 def init_retriever():
     """검색기 객체 초기화 또는 로드"""
     global base_retriever, retriever
-    
+
     index_path = app.config['INDEX_PATH']
-    
-    # 기존 인덱스가 있는지 확인
-    if os.path.exists(os.path.join(index_path, "documents.json")):
+
+    # VectorRetriever 로드 또는 초기화 (실제 클래스 사용 가정)
+    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(base_retriever.documents)}개 문서가 로드되었습니다.")
+            logger.info(f"{len(base_retriever.documents) if hasattr(base_retriever, 'documents') else 0}개 문서가 로드되었습니다.")
         except Exception as e:
-            logger.error(f"인덱스 로드 중 오류 발생: {e}")
-            logger.info("새 검색기를 초기화합니다...")
+            logger.error(f"인덱스 로드 중 오류 발생: {e}. 새 검색기를 초기화합니다.")
             base_retriever = VectorRetriever()
     else:
         logger.info("기존 인덱스를 찾을 수 없어 새 검색기를 초기화합니다...")
         base_retriever = VectorRetriever()
-    
-    # 데이터 폴더의 문서 로드
+
+    # 데이터 폴더의 문서 로드 (예시: base_retriever가 비어있을 때)
     data_path = app.config['DATA_FOLDER']
-    if not base_retriever.documents and os.path.exists(data_path):
+    # base_retriever.documents 와 같은 속성이 실제 클래스에 있다고 가정
+    if (not hasattr(base_retriever, 'documents') or not base_retriever.documents) and os.path.exists(data_path):
         logger.info(f"{data_path}에서 문서를 로드합니다...")
-        docs = DocumentProcessor.load_documents_from_directory(
-            data_path,
-            extensions=[".txt", ".md", ".csv"],
-            recursive=True
-        )
-        
-        if docs:
-            logger.info(f"{len(docs)}개 문서를 검색기에 추가합니다...")
-            base_retriever.add_documents(docs)
-            
-            # 인덱스 저장
-            logger.info(f"검색기 상태를 '{index_path}'에 저장합니다...")
-            try:
-                base_retriever.save(index_path)
-                logger.info("인덱스 저장 완료")
-            except Exception as e:
-                logger.error(f"인덱스 저장 중 오류 발생: {e}")
-    
+        try:
+            docs = DocumentProcessor.load_documents_from_directory(
+                data_path,
+                extensions=[".txt", ".md", ".csv"], # .pdf, .docx 등은 별도 처리 필요
+                recursive=True
+            )
+            if docs and hasattr(base_retriever, 'add_documents'):
+                logger.info(f"{len(docs)}개 문서를 검색기에 추가합니다...")
+                base_retriever.add_documents(docs)
+
+                if hasattr(base_retriever, 'save'):
+                    logger.info(f"검색기 상태를 '{index_path}'에 저장합니다...")
+                    try:
+                        base_retriever.save(index_path)
+                        logger.info("인덱스 저장 완료")
+                    except Exception as e:
+                        logger.error(f"인덱스 저장 중 오류 발생: {e}")
+        except Exception as e:
+             logger.error(f"DATA_FOLDER에서 문서 로드 중 오류: {e}")
+
     # 재순위화 검색기 초기화
     logger.info("재순위화 검색기를 초기화합니다...")
-    
-    # 자체 구현된 재순위화 함수 - 간단한 TF-IDF 기반 점수 재계산
-    def custom_rerank_fn(query, results):
-        """간단한 자체 구현 재순위화 함수"""
-        # 쿼리 단어 분석
-        query_terms = set(query.lower().split())
-        
-        # 결과 재점수화
-        for result in results:
-            if "text" in result:
-                text = result["text"].lower()
-                
-                # 간단한 TF 기반 점수 계산
-                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
-            else:
-                # 텍스트가 없는 경우 원래 점수 유지
-                result["rerank_score"] = result.get("score", 0)
-        
-        # 재점수화된 결과 정렬
-        results.sort(key=lambda x: x.get("rerank_score", 0), reverse=True)
-        return results
-    
-    # 재순위화 검색기 객체 생성 (CrossEncoder 대신 사용자 정의 함수 사용)
-    retriever = ReRanker(
-        base_retriever=base_retriever,
-        rerank_fn=custom_rerank_fn,
-        rerank_field="text"
-    )
-    
-    logger.info("재순위화 검색기 초기화 완료")
-    
+    try:
+        # 자체 구현된 재순위화 함수
+        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
+
+        # ReRanker 클래스 사용
+        retriever = ReRanker(
+            base_retriever=base_retriever,
+            rerank_fn=custom_rerank_fn, # 또는 실제 CrossEncoder 모델 사용
+            rerank_field="text" # 재순위화에 사용할 텍스트 필드 지정
+        )
+        logger.info("재순위화 검색기 초기화 완료")
+    except Exception as e:
+        logger.error(f"재순위화 검색기 초기화 실패: {e}")
+        retriever = base_retriever # 실패 시 기본 검색기 사용
+
     return retriever
 
-# 비동기 초기화 함수
 def background_init():
     """백그라운드에서 검색기 초기화 수행"""
     global app_ready, retriever
     try:
         logger.info("백그라운드 초기화 시작")
-        retriever = init_retriever()
+        # init_retriever() 호출 시 실제 클래스가 임포트되었다고 가정
+        if 'VectorRetriever' in globals() and VectorRetriever != MockComponent:
+             retriever = init_retriever()
+        else:
+             logger.warning("Retriever 관련 클래스가 없어 초기화를 건너<0xEB><0x87>니다.")
+             # retriever = None # 또는 기본 Mock 객체 할당
         app_ready = True
-        logger.info("앱 초기화 완료")
+        logger.info("앱 초기화 완료 (app_ready=True)")
     except Exception as e:
-        logger.error(f"앱 초기화 중 오류 발생: {e}", exc_info=True)
-        app_ready = False
+        logger.error(f"앱 백그라운드 초기화 중 심각한 오류 발생: {e}", exc_info=True)
+        app_ready = False # 오류 발생 시 준비 안됨 상태 유지
 
 # 백그라운드 스레드에서 초기화 시작
 init_thread = threading.Thread(target=background_init)
-init_thread.daemon = True
+init_thread.daemon = True # 메인 스레드 종료 시 함께 종료
 init_thread.start()
+# --- 검색기 초기화 관련 함수 끝 ---
+
+
+# --- Flask 라우트 정의 ---
 
-# 로그인 페이지
 @app.route('/login', methods=['GET', 'POST'])
 def login():
     error = None
-    logger.info("-------------- 로그인 페이지 접속 --------------")
+    next_url = request.args.get('next') # 리디렉션할 URL 가져오기
+    logger.info(f"-------------- 로그인 페이지 접속 (Next: {next_url}) --------------")
     logger.info(f"Method: {request.method}")
-    
-    # 경로 로그 추가
-    logger.info(f"Request Path: {request.path}")
-    logger.info(f"Request Host: {request.host}")
-    logger.info(f"Request URL: {request.url}")
-    
-    # 모든 헤더 로그
-    logger.info("Request Headers:")
-    for header, value in request.headers.items():
-        logger.info(f"  {header}: {value}")
-    
+
+    # 헤더 로깅 (디버깅용)
+    # 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}")
-        
-        # 허깅페이스 환경변수 직접 확인
-        # .env에서 가져오기
-        valid_username = os.environ.get('ADMIN_USERNAME') or os.getenv('ADMIN_USERNAME')
-        valid_password = os.environ.get('ADMIN_PASSWORD') or os.getenv('ADMIN_PASSWORD')
-        
-        # 환경변수 디버깅
-        logger.info("\n[Environment Variables]")
-        logger.info(f"ADMIN_USERNAME from os.environ: {os.environ.get('ADMIN_USERNAME')}")
-        logger.info(f"ADMIN_PASSWORD from os.environ: {os.environ.get('ADMIN_PASSWORD') is not None}")
-        logger.info(f"ADMIN_USERNAME from os.getenv: {os.getenv('ADMIN_USERNAME')}")
-        logger.info(f"ADMIN_PASSWORD from os.getenv: {os.getenv('ADMIN_PASSWORD') is not None}")
-        
-        logger.info(f"환경변수에서 가져온 사용자명: {valid_username if valid_username else '정의되지 않음'}")
-        logger.info(f"환경변수에서 비밀번호 가져온 여부: {len(valid_password) > 0 if valid_password else False}")
-        
-        # 허깅페이스에서 환경변수가 로드되지 않을 경우 기본값 사용
-        if not valid_username or not valid_password:
-            logger.warning("환경변수에서 사용자 자격증명을 찾을 수 없어 기본값 사용")
-            valid_username = "admin"
-            valid_password = "rag12345"
-        
+
+        # 환경 변수 또는 기본값과 비교
+        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.info(f"세션 설정 전 현재 세션 상태: {session}")
-            
-            # 영구 세션으로 설정
-            session.permanent = True
+            # 세션 설정 전 현재 세션 상태 로깅
+            logger.debug(f"세션 설정 전: {session}")
+
+            # 세션에 로그인 정보 저장
+            session.permanent = True # PERMANENT_SESSION_LIFETIME 설정 사용
             session['logged_in'] = True
             session['username'] = username
-            
-            # 세션 설정 후 로깅
-            logger.info(f"세션 설정 후 세션 상태: {session}")
+            session.modified = True # 세션이 변경되었음을 명시 (필수는 아닐 수 있음)
+
+            logger.info(f"세션 설정 후: {session}")
             logger.info("세션 설정 완료, 리디렉션 시도")
-            
-            # 세션 쿠키 설정 확인
-            response = redirect(url_for('index'))
-            logger.info(f"Response Headers: {response.headers}")
+
+            # 로그인 성공 후 리디렉션
+            # '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("비밀번호 불일치")
+            if username != valid_username: logger.warning("사용자명 불일치")
+            if password != valid_password: logger.warning("비밀번호 불일치")
             error = '아이디 또는 비밀번호가 올바르지 않습니다.'
-    else:
+    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)
+    return render_template('login.html', error=error, next=next_url)
+
 
-# 로그아웃 라우트
 @app.route('/logout')
 def logout():
     logger.info("-------------- 로그아웃 요청 --------------")
-    # 세션 정보 로깅
-    logger.info(f"현재 세션 상태: logged_in={session.get('logged_in', False)}, username={session.get('username', 'None')}")
-    
+    logger.info(f"로그아웃 전 세션 상태: {session}")
+
     if 'logged_in' in session:
-        logger.info(f"사용자 {session.get('username', 'unknown')} 로그아웃 처리 시작")
-        # 세션에서 정보 삭제
+        username = session.get('username', 'unknown')
+        logger.info(f"사용자 {username} 로그아웃 처리 시작")
         session.pop('logged_in', None)
         session.pop('username', None)
-        logger.info("세션 정보 삭제 완료")
+        session.modified = True # 세션 변경 명시
+        logger.info(f"세션 정보 삭제 완료. 현재 세션: {session}")
     else:
         logger.warning("로그인되지 않은 상태에서 로그아웃 시도")
-    
+
     logger.info("로그인 페이지로 리디렉션")
-    return redirect(url_for('login'))
+    response = redirect(url_for('login'))
+    # logger.debug(f"로그아웃 응답 헤더: {response.headers}") # 쿠키 삭제 확인용
+    return response
+
 
 @app.route('/')
 @login_required
 def index():
     """메인 페이지"""
     if not app_ready:
-        return render_template('loading.html')
+        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, app_ready
-    
-    # 앱 준비 상태 확인
+    global llm_interface
+
     if not app_ready:
         return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
-    
+
     if request.method == 'GET':
-        # 지원되는 LLM 목록 및 현재 LLM 정보 반환
-        return jsonify({
-            "supported_llms": [{
-                "name": name,
-                "id": id,
-                "current": id == llm_interface.current_llm
-            } for name, id in llm_interface.SUPPORTED_LLMS.items()],
-            "current_llm": llm_interface.get_current_llm_details()
-        })
+        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':
-        # LLM 선택 변경
         data = request.get_json()
         if not data or 'llm_id' not in data:
             return jsonify({"error": "LLM ID가 제공되지 않았습니다."}), 400
-        
+
         llm_id = data['llm_id']
-        if llm_id not in llm_interface.llm_clients:
-            return jsonify({"error": f"지원되지 않는 LLM ID: {llm_id}"}), 400
-        
-        # 현재 LLM 변경
-        success = llm_interface.set_llm(llm_id)
-        if success:
-            logger.info(f"LLM이 '{llm_id}'로 변경되었습니다.")
-            return jsonify({
-                "success": True,
-                "message": f"LLM이 '{llm_interface.get_current_llm_name()}'로 변경되었습니다.",
-                "current_llm": llm_interface.get_current_llm_details()
-            })
-        else:
-            return jsonify({"error": "LLM 변경 중 오류가 발생했습니다."}), 500
+        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, app_ready
-    
-    # 앱 준비 상태 확인
-    if not app_ready:
-        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
-    
+    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}")
-        
-        # RAG 검색 수행 (재순위화 적용)
-        search_results = retriever.search(query, top_k=5, first_stage_k=6)
-        
-        # 검색 결과에서 컨텍스트 추출
+        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("검색 결과가 없습니다.")
-            return jsonify({
-                "answer": "죄송합니다. 관련 정보를 찾을 수 없습니다.",
-                "sources": []
-            })
-        
+            logger.warning("검색 결과가 없어 컨텍스트를 생성하지 못함.")
+            # LLM 호출 없이 기본 응답 반환 또는 검색 결과 없음을 알리는 응답 생성
+            # answer = "죄송합니다. 관련 정보를 찾을 수 없습니다." (아래 LLM 호출 로직에서 처리)
+            pass
+
         # LLM에 질의
-        llm_id = data.get('llm_id', None)  # 클라이언트에서 LLM 선택이 제공되면 사용
-        answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
-        
-        # 소스 정보 추출
+        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 = []
-        for result in search_results:
-            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 "filetype" in result and result["filetype"] == "csv":
-                    # 디버깅 로그 추가
-                    logger.info(f"CSV 파일 처리: {result['source']}")
-                    logger.info(f"CSV 내용 처음 부분: {result['text'][:100]}...")
-
-                    # 첫 번째 라인이나 내용에서 컬럼 값 추출 시도
-                    try:
-                        # 텍스트의 처음 부분을 추출
-                        text_lines = result["text"].strip().split('\n')
-                        logger.info(f"CSV 라인 개수: {len(text_lines)}")
-                        
-                        if len(text_lines) > 0:
-                            first_line = text_lines[0].strip()
-                            logger.info(f"CSV 첫 줄: {first_line}")
-                            
-                            if ',' in first_line:  # CSV 형식이면
-                                first_columns = first_line.split(',')
-                                logger.info(f"CSV 컬럼 개수: {len(first_columns)}")
-                                
-                                first_column = first_columns[0].strip()
-                                logger.info(f"CSV 첫 번째 컬럼 값: '{first_column}'")
-                                source_info["id"] = first_column
-                                logger.info(f"source_info에 id 추가: {source_info}")
-                            else:
-                                logger.warning(f"CSV 파일이지만 코마가 없음: {first_line}")
-                        else:
-                            logger.warning(f"CSV 파일이지만 라인이 없음: {result['source']}")
-                    except Exception as e:
-                        logger.warning(f"CSV 첫 번째 컬럼 추출 실패: {e}")
-                
-                sources.append(source_info)
-        
-        # 최종 응답 구조 로깅
+        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()
+            "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
         }
-        logger.debug(f"최종 API 응답 구조: {json.dumps(response_data, ensure_ascii=False, indent=2)[:500]}...")
-        
+        # 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 엔드포인트: 오디오 파일을 받아 텍스트로 변환하고, 질문에 대한 응답과 소스를 반환
-
-    Returns:
-        JSON 응답:
-        - transcription: 인식된 텍스트
-        - answer: LLM에서 생성한 응답
-        - sources: 검색된 문서 소스 (리스트)
-        - error: 오류 발생 시 오류 메시지
-        - details: 오류 상세 정보 (선택적)
-    """
+    """음성 챗 API 엔드포인트"""
+    global retriever, stt_client
+
+    if not app_ready or retriever is None or stt_client is None:
+        return jsonify({"error": "앱/검색기/STT가 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+
     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}")
-    
+    logger.info(f"수신된 오디오 파일: {audio_file.filename} ({audio_file.content_type})")
+
     try:
-        # 오디오 파일 읽기
-        with audio_file.stream as f:
-            audio_bytes = f.read()
-        
-        # 음성인식 (VitoSTT)
-        stt = VitoSTT()
-        stt_result = stt.transcribe_audio(audio_bytes, language="ko")
-        
-        if not stt_result["success"]:
-            logger.error(f"음성인식 실패: {stt_result['error']}")
+        # 오디오 파일 처리
+        # 임시 파일 사용 고려 (메모리 부담 줄이기 위해)
+        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": stt_result["error"],
-                "details": stt_result.get("details", "")
+                "error": "음성인식 실패",
+                "details": error_msg
             }), 500
-        
-        transcription = stt_result["text"]
+
+        transcription = stt_result.get("text", "")
         if not transcription:
             logger.warning("음성인식 결과가 비어있습니다.")
-            return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다."}), 400
-        
+            return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다.", "transcription": ""}), 400
+
         logger.info(f"음성인식 성공: {transcription[:50]}...")
-        
-        # 검색기 호출: 인식된 텍스트를 쿼리로 사용
-        sources = retriever.search(transcription, top_k=5, first_stage_k=6)
-        if not sources:
-            logger.warning("검색된 소스가 없습니다.")
-            sources = []
-        
-        # 소스 문서 내용을 컨텍스트로 준비
-        context = DocumentProcessor.prepare_rag_context(sources, field="text")
-        logger.info(f"검색된 소스 수: {len(sources)}")
-        
-        # LLM 호출: 질문과 컨텍스트를 바탕으로 응답 생성
-        llm_id = request.form.get('llm_id', None)  # 클라이언트에서 LLM 선택이 제공되면 사용
-        answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
-        
+
+        # --- 이후 로직은 /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 = []
-        for doc in sources:
-            if "source" in doc:
-                source_info = {
-                    "source": doc.get("source", "Unknown"),
-                    "score": doc.get("rerank_score", doc.get("score", 0))
-                }
-                
-                # CSV 파일인 경우 첫 번째 컨텐츠 데이터를 추출하여 표시
-                if "text" in doc and "filetype" in doc and doc["filetype"] == "csv":
-                    # 디버깅 로그 추가
-                    logger.info(f"[음성챗] CSV 파일 처리: {doc['source']}")
-                    logger.info(f"[음성챗] CSV 내용 처음 부분: {doc['text'][:100]}...")
-
-                    # 첫 번째 라인이나 내용에서 컬럼 값 추출 시도
-                    try:
-                        # 텍스트의 처음 부분을 추출
-                        text_lines = doc["text"].strip().split('\n')
-                        logger.info(f"[음성챗] CSV 라인 개수: {len(text_lines)}")
-                        
-                        if len(text_lines) > 0:
-                            first_line = text_lines[0].strip()
-                            logger.info(f"[음성챗] CSV 첫 줄: {first_line}")
-                            
-                            if ',' in first_line:  # CSV 형식이면
-                                first_columns = first_line.split(',')
-                                logger.info(f"[음성챗] CSV 컬럼 개수: {len(first_columns)}")
-                                
-                                first_column = first_columns[0].strip()
-                                logger.info(f"[음성챗] CSV 첫 번째 컬럼 값: '{first_column}'")
-                                source_info["id"] = first_column
-                                logger.info(f"[음성챗] source_info에 id 추가: {source_info}")
-                            else:
-                                logger.warning(f"[음성챗] CSV 파일이지만 코마가 없음: {first_line}")
-                        else:
-                            logger.warning(f"[음성챗] CSV 파일이지만 라인이 없음: {doc['source']}")
-                    except Exception as e:
-                        logger.warning(f"[음성챗] CSV 첫 번째 컬럼 추출 실패: {e}")
-                
-                enhanced_sources.append(source_info)
-        
-        # 최종 응답 구조 로깅
+        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()
+            "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
         }
-        logger.debug(f"[음성챗] 최종 API 응답 구조: {json.dumps(response_data, ensure_ascii=False, indent=2)[:500]}...")
-        
         return jsonify(response_data)
-    
+
     except Exception as e:
-        logger.error(f"음성 챗 처리 중 오류 발생: {str(e)}", exc_info=True)
+        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, app_ready
-    
-    # 앱 준비 상태 확인
-    if not app_ready:
-        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
-    
+    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:
-        # 파일이 요청에 포함되어 있는지 확인
-        if 'document' not in request.files:
-            return jsonify({"error": "문서 파일이 제공되지 않았습니다."}), 400
-        
-        doc_file = request.files['document']
-        logger.info(f"받은 파일명: {doc_file.filename}")
-        
-        # 파일명이 비어있는지 확인
-        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": "허용되지 않는 파일 형식입니다. 현재 허용된 파일 형식: {}".format(', '.join(ALLOWED_DOC_EXTENSIONS))}), 400
-        
-        # 파일명 보안 처리
         filename = secure_filename(doc_file.filename)
-        
-        # 데이터 폴더에 저장
         filepath = os.path.join(app.config['DATA_FOLDER'], filename)
         doc_file.save(filepath)
-        
-        logger.info(f"문서가 저장되었습니다: {filepath}")
-        
-        # 문서 처리
+        logger.info(f"문서 저장 완료: {filepath}")
+
+        # 문서 처리 (인코딩 처리 포함)
         try:
-            # 먼저 UTF-8로 시도
+            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='utf-8') as f:
-                    content = f.read()
-            except UnicodeDecodeError:
-                # UTF-8로 실패하면 CP949(한국어 Windows 기본 인코딩)로 시도
-                logger.info(f"UTF-8 디코딩 실패, CP949로 시도: {filename}")
                 with open(filepath, 'r', encoding='cp949') as f:
                     content = f.read()
-            
-            # 메타데이터 생성
-            metadata = {
-                "source": filename,
-                "filename": filename,
-                "filetype": filename.rsplit('.', 1)[1].lower(),
-                "filepath": filepath
-            }
-            
-            # 파일 형식에 따라 다른 처리 적용
-            file_ext = filename.rsplit('.', 1)[1].lower()
-            
-            # CSV 파일은 행 단위로 처리
-            if file_ext == 'csv':
-                logger.info(f"CSV 파일 업로드 감지, 행 단위로 분할 처리: {filename}")
-                docs = DocumentProcessor.csv_to_documents(content, metadata)
-            else:
-                # 일반 텍스트 문서 처리
-                docs = DocumentProcessor.text_to_documents(
-                    content,
-                    metadata=metadata,
-                    chunk_size=512,
-                    chunk_overlap=50
-                )
-            
-            if docs:
-                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("인덱스 저장 완료")
-                except Exception as e:
-                    logger.error(f"인덱스 저장 중 오류 발생: {e}")
-                    return jsonify({"error": f"인덱스 저장 중 오류: {str(e)}"}), 500
-                
+            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)}개 청크가 추가되었습니다."
+                    "message": f"파일 '{filename}' 업로드 및 처리 완료 ({len(docs)}개 청크 추가)."
                 })
-            else:
-                logger.warning(f"파일 '{filename}'에서 처리할 문서가 없습니다.")
-                return jsonify({
-                    "warning": True,
-                    "message": f"파일 '{filename}'이 저장되었지만 처리할 내용이 없습니다."
-                })
-                
-        except Exception as e:
-            logger.error(f"문서 '{filename}' 처리 중 오류 발생: {e}", exc_info=True)
-            return jsonify({"error": f"문서 처리 중 오류: {str(e)}"}), 500
-        
+            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)
+        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, retriever, app_ready
-    
-    # 앱 준비 상태 확인
-    if not app_ready:
-        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
-    
+    global base_retriever
+
+    if not app_ready or base_retriever is None:
+         return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503
+
     try:
-        # 문서 소스 목록 생성
         sources = {}
-        
-        if base_retriever and base_retriever.documents:
-            for doc in base_retriever.documents:
-                source = doc.get("source", "unknown")
-                if source in sources:
-                    sources[source]["chunks"] += 1
-                else:
-                    sources[source] = {
-                        "filename": doc.get("filename", source),
-                        "chunks": 1,
-                        "filetype": doc.get("filetype", "unknown")
-                    }
-        
-        # 목록 형식으로 변환
-        documents = []
-        for source, info in sources.items():
-            documents.append({
-                "source": source,
-                "filename": info["filename"],
-                "chunks": info["chunks"],
-                "filetype": info["filetype"]
-            })
-        
-        # 청크 수로 정렬
+        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": sum(doc["chunks"] for doc in 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():
-    # 수동 쿠키 처리 확인
-    if 'session_data' in request.cookies and 'logged_in' not in session:
-        try:
-            cookie_data = json.loads(request.cookies.get('session_data'))
-            logger.info(f"\n[Before Request] 수동 쿠키 값 발견: {cookie_data}")
-            if cookie_data.get('logged_in'):
-                # 세션 재구성
-                session['logged_in'] = True
-                session['username'] = cookie_data.get('username')
-                logger.info(f"\n[Before Request] 수동 쿠키에서 세션 복원: {session}")
-        except Exception as e:
-            logger.error(f"\n[Before Request] 쿠키 처리 오류: {e}")
 
-# 허깅페이스 환경을 위한 세션 처리 향상
+# --- 요청 처리 훅 ---
+
+# @app.before_request - 제거됨 (수동 쿠키 처리 로직 삭제)
+# def process_cookies(): ...
+
 @app.after_request
 def after_request_func(response):
-    # 세션이 수정되었는지 확인
-    if session.modified:
-        logger.info("\n[After Request] 세션이 수정되었습니다.")
-        logger.info(f"현재 세션 내용: {session}")
-        
-    # 응답 헤더 로깅
-    logger.info("\n[Response Headers]")
-    for header, value in response.headers:
-        logger.info(f"  {header}: {value}")
-    
-    # 쿠키 설정
+    """모든 응답에 대해 후처리 수행"""
+    # 세션이 수정되었는지 확인 후 로깅 (디버깅용)
+    # if session.modified: # session.modified 는 항상 정확하지 않을 수 있음
+    #     logger.debug(f"[After Request] 세션 수정 감지. 현재 세션: {session}")
+
+    # 응답 헤더 로깅 (디버깅용)
+    # logger.debug("[Response Headers]")
+    # for header, value in response.headers:
+    #     logger.debug(f"  {header}: {value}")
+
+    # Set-Cookie 헤더 확인 (디버깅용)
     if 'Set-Cookie' in response.headers:
-        logger.info(f"Set-Cookie 헤더 있음: {response.headers['Set-Cookie']}")
-    else:
-        # 로그인 후 세션 쿠키가 없으면 세션 값을 확인
-        if 'logged_in' in session and request.path != '/login':
-            logger.info("세션에 logged_in이 있지만 쿠키가 설정되지 않았습니다.")
-    
-    # 허깅페이스 프록시 관련 헤더 처리
+        logger.debug(f"응답에 Set-Cookie 헤더 포함: {response.headers['Set-Cookie']}")
+    # elif 'logged_in' in session and request.path != '/login': # 로그인 상태인데 쿠키가 안나가는 경우
+    #     logger.warning("세션에 logged_in=True 이지만 응답에 Set-Cookie 헤더가 없습니다.")
+
+    # 허깅페이스 프록시 등 캐싱 방지 헤더 설정 (필요시)
     response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
     response.headers['Pragma'] = 'no-cache'
     response.headers['Expires'] = '0'
-    
-    return response
+
+    return response
+
+# --- 요청 처리 훅 끝 ---
+
+# 앱 실행 (로컬 테스트용)
+if __name__ == '__main__':
+    logger.info("Flask 앱을 직접 실행합니다 (개발용 서버).")
+    # host='0.0.0.0' 으로 설정하면 외부에서 접근 가능
+    app.run(debug=True, host='0.0.0.0', port=int(os.environ.get("PORT", 7860)))
+    # Hugging Face Spaces는 보통 PORT 환경 변수를 사용