fix

app/app.py

@@ -7,15 +7,11 @@ import json
 import logging
 import tempfile
 import threading
-from datetime import datetime, timedelta  # datetime 대신 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 wrap
-import pickle
-import os
-import gzip
-from datetime import datetime
+from functools import wraps
 
 # 로거 설정
 logging.basicConfig(
@@ -147,133 +143,81 @@ def allowed_doc_file(filename):
 # --- 헬퍼 함수 끝 ---
 
 
-def save_embeddings(base_retriever, file_path):
-    """임베딩 데이터를 압축하여 파일에 저장
-    
-    Args:
-        base_retriever: 저장할 검색기 객체
-        file_path: 저장할 파일 경로
-        
-    Returns:
-        bool: 저장 성공 여부
-    """
-    try:
-        # 저장 디렉토리가 없으면 생성
-        os.makedirs(os.path.dirname(file_path), exist_ok=True)
-        
-        # 타임스탬프 추가
-        save_data = {
-            'timestamp': datetime.now().isoformat(),
-            'retriever': base_retriever
-        }
-        
-        # 압축하여 저장 (용량 줄이기)
-        with gzip.open(file_path, 'wb') as f:
-            pickle.dump(save_data, f)
-        
-        logger.info(f"임베딩 데이터를 {file_path}에 압축하여 저장했습니다.")
-        return True
-    except Exception as e:
-        logger.error(f"임베딩 저장 중 오류 발생: {e}")
-        return False
-
-def load_embeddings(file_path, max_age_days=30):
-    """저장된 임베딩 데이터를 파일에서 로드
-    
-    Args:
-        file_path: 로드할 파일 경로
-        max_age_days: 최대 허용 경과 일수 (기본값: 30일)
-        
-    Returns:
-        object or None: 로드된 검색기 객체 또는 실패 시 None
-    """
-    try:
-        if not os.path.exists(file_path):
-            logger.info(f"저장된 임베딩 파일({file_path})이 없습니다.")
-            return None
-        
-        # 압축 파일 로드
-        with gzip.open(file_path, 'rb') as f:
-            data = pickle.load(f)
-        
-        # 타임스탬프 확인 (너무 오래된 데이터는 사용하지 않음)
-        saved_time = datetime.fromisoformat(data['timestamp'])
-        age = (datetime.now() - saved_time).days
-        
-        if age > max_age_days:
-            logger.info(f"저장된 임베딩이 {age}일로 너무 오래되었습니다. 새로 생성합니다.")
-            return None
-        
-        logger.info(f"{file_path}에서 임베딩 데이터를 로드했습니다. (생성일: {saved_time})")
-        return data['retriever']
-    except Exception as e:
-        logger.error(f"임베딩 로드 중 오류 발생: {e}")
-        return None
-
+# init_retriever 함수 내부에 로깅 추가 예시
+# --- 검색기 초기화 관련 함수 ---
 def init_retriever():
     """검색기 객체 초기화 또는 로드"""
     global base_retriever, retriever
 
-    # 임베딩 캐시 파일 경로
-    cache_path = os.path.join(app.config['INDEX_PATH'], "cached_embeddings.gz")
-    
-    # 먼저 저장된 임베딩 데이터 로드 시도
-    cached_retriever = load_embeddings(cache_path)
-    
-    if cached_retriever:
-        logger.info("캐시된 임베딩 데이터를 성공적으로 로드했습니다.")
-        base_retriever = cached_retriever
-    else:
-        # 캐시된 데이터가 없으면 기존 방식으로 초기화
-        index_path = app.config['INDEX_PATH']
-        
-        # VectorRetriever 로드 또는 초기화 (실제 클래스 사용 가정)
-        if os.path.exists(os.path.join(index_path, "documents.json")): # 간단한 존재 확인 예시
+    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:
-                logger.info(f"기존 벡터 인덱스를 '{index_path}'에서 로드합니다...")
-                base_retriever = VectorRetriever.load(index_path)
-                logger.info(f"{len(base_retriever.documents) if hasattr(base_retriever, 'documents') else 0}개 문서가 로드되었습니다.")
-            except Exception as e:
-                logger.error(f"인덱스 로드 중 오류 발생: {e}. 새 검색기를 초기화합니다.")
                 base_retriever = VectorRetriever()
-        else:
-            logger.info("기존 인덱스를 찾을 수 없어 새 검색기를 초기화합니다...")
+                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
 
-        # 데이터 폴더의 문서 로드 (예시: base_retriever가 비어있을 때)
-        data_path = app.config['DATA_FOLDER']
-        # 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}에서 문서를 로드합니다...")
-            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("인덱스 저장 완료")
-                            
-                            # 새로 생성된 검색기 캐싱
-                            if hasattr(base_retriever, 'documents') and base_retriever.documents:
-                                save_embeddings(base_retriever, cache_path)
-                                logger.info(f"검색기를 캐시 파일 {cache_path}에 저장 완료")
-                        except Exception as e:
-                            logger.error(f"인덱스 저장 중 오류 발생: {e}")
-            except Exception as e:
-                logger.error(f"DATA_FOLDER에서 문서 로드 중 오류: {e}")
+    if base_retriever is None:
+        logger.error("base_retriever 초기화/로드에 실패하여 init_retriever 중단.")
+        return None
 
-    # 재순위화 검색기 초기화
-    logger.info("재순위화 검색기를 초기화합니다...")
+    # 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:
@@ -283,94 +227,105 @@ def init_retriever():
                     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)
-                # 결과 형식이 다를 경우 처리 필요
+                        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, # 또는 실제 CrossEncoder 모델 사용
-            rerank_field="text" # 재순위화에 사용할 텍스트 필드 지정
+            rerank_fn=custom_rerank_fn, # 이제 함수가 정의되었으므로 사용 가능
+            rerank_field="text"
         )
-        logger.info("재순위화 검색기 초기화 완료")
-    except Exception as e:
-        logger.error(f"재순위화 검색기 초기화 실패: {e}")
-        retriever = base_retriever # 실패 시 기본 검색기 사용
+        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
-    
-    # 즉시 앱 사용 가능 상태로 설정 (중요!)
-    app_ready = True
-    logger.info("앱을 즉시 사용 가능 상태로 설정 (app_ready=True)")
-    
+    global app_ready, retriever, base_retriever, llm_interface, stt_client
+
+    temp_app_ready = False # 임시 상태 플래그
     try:
-        # 기본 검색기 초기화 (보험)
-        if base_retriever is None:
+        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()
-            if hasattr(base_retriever, 'documents'):
-                base_retriever.documents = []
-        
-        # 임시 retriever 설정 (빠른 시작을 위해)
-        if retriever is None:
             retriever = MockComponent()
-            if not hasattr(retriever, 'search'):
-                retriever.search = lambda query, **kwargs: []
-        
-        # 임베딩 캐시 파일 경로
-        cache_path = os.path.join(app.config['INDEX_PATH'], "cached_embeddings.gz")
-        
-        # 캐시된 임베딩 로드 시도 (빠른 시작을 위해)
-        cached_retriever = load_embeddings(cache_path)
-        
-        if cached_retriever:
-            # 캐시된 데이터가 있으면 바로 사용
-            base_retriever = cached_retriever
-            
-            # 간단한 재순위화 함수
-            def simple_rerank(query, results):
-                # 결과 점수 유지하면서 정렬
-                if results:
-                    for result in results:
-                        if 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
-            
-            # 재순위화 검색기 초기화
-            retriever = ReRanker(
-                base_retriever=base_retriever,
-                rerank_fn=simple_rerank,
-                rerank_field="text"
-            )
-            
-            logger.info("캐시된 임베딩으로 검색기 초기화 완료 (빠른 시작)")
-        else:
-            # 캐시된 데이터가 없으면 전체 초기화 진행
-            logger.info("캐시된 임베딩이 없어 전체 초기화 시작")
-            # 시간이 오래 걸릴 수 있는 작업이므로 별도 스레드로 실행할 수도 있음
-            retriever = init_retriever()
-            logger.info("전체 초기화 완료")
-        
-        logger.info("앱 초기화 완료 (모든 컴포넌트 준비됨)")
+            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)
-        # 초기화 실패 시 기본 객체 생성 (앱 실행을 위한 보험)
-        if base_retriever is None:
-            base_retriever = MockComponent()
-            if hasattr(base_retriever, 'documents'):
-                base_retriever.documents = []
-        if retriever is None:
-            retriever = MockComponent()
-            if not hasattr(retriever, 'search'):
-                retriever.search = lambda query, **kwargs: []
-        
-        logger.warning("초기화 중 오류가 있지만 앱은 계속 사용 가능합니다.")
+        # 오류 발생 시에도 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)
@@ -780,7 +735,7 @@ def voice_chat():
             "details": str(e)
         }), 500
 
-# 문서 업로드 API 엔드포인트에서 캐시 업데이트 코드 추가
+
 @app.route('/api/upload', methods=['POST'])
 @login_required
 def upload_document():
@@ -823,6 +778,7 @@ def upload_document():
             logger.error(f"파일 읽기 오류 ({filename}): {e_read}")
             return jsonify({"error": f"파일 읽기 중 오류 발생: {str(e_read)}"}), 500
 
+
         # 메타데이터 및 문서 분할/처리
         metadata = {
             "source": filename, "filename": filename,
@@ -863,30 +819,20 @@ def upload_document():
             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("인덱스 저장 완료")
-                
-                # 임베딩 캐시 업데이트
-                cache_path = os.path.join(app.config['INDEX_PATH'], "cached_embeddings.gz")
-                if save_embeddings(base_retriever, cache_path):
-                    logger.info("임베딩 캐시 업데이트 완료")
-                
-                # 재순위화 검색기도 업데이트 필요 시 (기본 검색기가 변경되었으므로)
-                if hasattr(retriever, 'base_retriever'):
-                    retriever.base_retriever = base_retriever
-                    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}")
+                logger.error(f"인덱스 저장 중 오류 발생: {e_save}")
                 return jsonify({"error": f"인덱스 저장 중 오류: {str(e_save)}"}), 500
         else:
             logger.warning(f"파일 '{filename}'에서 처리할 내용이 없거나 지원되지 않는 형식입니다.")