RAG 리트리버 초기화 실패 문제 해결

README.md

@@ -10,4 +10,63 @@ pinned: false
 license: mit
 ---
 
+# RAG6 AgenticAI - 개선된 RAG 검색 챗봇
+
+RAG(Retrieval-Augmented Generation) 기반의 문서 검색 및 질의응답 챗봇 시스템입니다.
+
+## 주요 기능
+
+- 텍스트 기반 챗봇 (RAG)
+- 음성 인식 기반 대화
+- 문서 파일 업로드 및 인덱싱
+- 다양한 LLM 모델 지원
+- 관리자 인증 기능
+
+## 시스템 아키텍처
+
+이 시스템은 다음과 같은 주요 구성 요소로 이루어져 있습니다:
+
+1. **Flask 웹 서버**: 프론트엔드 및 API 제공
+2. **VectorRetriever**: 문서 인덱싱 및 벡터 검색
+3. **ReRanker**: 검색 결과 재순위화
+4. **LLM 인터페이스**: 다양한 LLM API 연결
+5. **STT(Speech-to-Text)**: 음성 인식 지원
+
+## 개선된 기능
+
+이번 버전에서는 다음과 같은 개선 사항이 적용되었습니다:
+
+- **안정성 향상**: 리트리버 초기화 실패 문제 해결
+- **오류 처리 강화**: 초기화 실패 원인 추적 및 명확한 피드백 제공
+- **모듈화 개선**: 코드 분할 및 기능별 모듈화로 유지보수성 향상
+- **상태 관리**: 앱 준비 상태와 초기화 성공 여부 분리 관리
+- **사용자 경험**: 오류 발생 시에도 앱 접근성 유지와 명확한 피드백
+
+## 설치 및 실행
+
+```bash
+# 가상환경 생성 및 활성화
+python -m venv venv
+source venv/bin/activate  # 또는 Windows: venv\Scripts\activate
+
+# 의존성 설치
+pip install -r requirements.txt
+
+# 앱 실행
+python app.py
+```
+
+## 환경 변수
+
+필요한 환경 변수는 다음과 같습니다:
+
+- `ADMIN_USERNAME`: 관리자 사용자명 (기본값: "admin")
+- `ADMIN_PASSWORD`: 관리자 비밀번호 (기본값: "rag12345")
+- `FLASK_SECRET_KEY`: Flask 세션 암호화 키
+- `PORT`: 서버 포트 (기본값: 7860)
+
+## 라이센스
+
+MIT License
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -4,10 +4,24 @@ RAG 검색 챗봇 메인 실행 파일
 
 # os 모듈 임포트
 import os
+import logging
+
+# 로깅 설정
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.DEBUG
+)
+logger = logging.getLogger(__name__)
 
 # 앱 모듈에서 Flask 앱 가져오기
-from app.app import app
+try:
+    from app.app_main import app
+    logger.info("Flask 앱을 성공적으로 로드했습니다.")
+except ImportError as e:
+    logger.critical(f"앱 임포트 실패: {e}")
+    raise
 
 if __name__ == '__main__':
     port = int(os.environ.get("PORT", 7860))
-    app.run(debug=False, host='0.0.0.0', port=port)
+    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
+    app.run(debug=False, host='0.0.0.0', port=port, use_reloader=False)

app/__init__.py

@@ -1 +1,17 @@
-# 애플리케이션 패키지
+"""
+RAG 검색 챗봇 애플리케이션 패키지
+"""
+
+# 이 파일은 app 디렉토리를 파이썬 패키지로 만듭니다.
+# 주요 모듈:
+# - app_revised.py: 앱 초기화 및 설정
+# - app_main.py: 앱 메인 로직 및 서버 실행
+# - background_init.py: 백그라운드 초기화 관리
+# - init_retriever_improved.py: 개선된 검색기 초기화 로직
+# - app_routes_improved.py: 메인 라우트 등록
+# - chat_routes.py: 챗봇 API 엔드포인트
+# - document_routes.py: 문서 관리 API 엔드포인트
+# - voice_routes.py: 음성 처리 API 엔드포인트
+
+# 버전 정보
+__version__ = '1.1.0'

app/app.py

@@ -1,365 +0,0 @@
-"""
-RAG 검색 챗봇 웹 애플리케이션 (세션 설정 수정 적용 및 TypeError 해결)
-"""
-
-import os
-import json
-import logging
-import tempfile
-import threading
-import datetime
-import time # 추가
-from flask import Flask, request, jsonify, render_template, send_from_directory, session, redirect, url_for
-from werkzeug.utils import secure_filename
-from dotenv import load_dotenv
-from functools import wraps
-
-# 로거 설정
-logging.basicConfig(
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    level=logging.DEBUG
-)
-logger = logging.getLogger(__name__)
-
-# 환경 변수 로드
-load_dotenv()
-
-# 환경 변수 로드 상태 확인 및 로깅
-ADMIN_USERNAME = os.getenv('ADMIN_USERNAME')
-ADMIN_PASSWORD = os.getenv('ADMIN_PASSWORD')
-DEVICE_SERVER_URL = os.getenv('DEVICE_SERVER_URL', '')
-
-logger.info(f"==== 환경 변수 로드 상태 ====")
-logger.info(f"ADMIN_USERNAME 설정 여부: {ADMIN_USERNAME is not None}")
-logger.info(f"ADMIN_PASSWORD 설정 여부: {ADMIN_PASSWORD is not None}")
-logger.info(f"DEVICE_SERVER_URL: {DEVICE_SERVER_URL or '설정되지 않음 (프론트엔드에서 자동 설정)'}")
-
-# 환경 변수가 없으면 기본값 설정
-if not ADMIN_USERNAME:
-    ADMIN_USERNAME = 'admin'
-    logger.warning("ADMIN_USERNAME 환경변수가 없어 기본값 'admin'으로 설정합니다.")
-
-if not ADMIN_PASSWORD:
-    ADMIN_PASSWORD = 'rag12345'
-    logger.warning("ADMIN_PASSWORD 환경변수가 없어 기본값 'rag12345'로 설정합니다.")
-
-# --- 로컬 모듈 임포트 ---
-# MockComponent 정의 (임포트 실패 시 대체)
-class MockComponent:
-    def __init__(self):
-        self.is_mock = True
-    
-    def search(self, query, top_k=5, first_stage_k=None):
-        """빈 검색 결과를 반환합니다."""
-        logger.warning(f"MockComponent.search 호출됨 (쿼리: {query[:30]}...)")
-        return []
-    
-    def __getattr__(self, name):
-        # Mock 객체의 어떤 속성이나 메소드 호출 시 경고 로그 출력 및 기본값 반환
-        logger.warning(f"MockComponent에서 '{name}' 접근 시도됨 (실제 모듈 로드 실패)")
-        # 메소드 호출 시에는 아무것도 안 하는 함수 반환
-        if name in ['add_documents', 'save', 'transcribe_audio', 'rag_generate', 'set_llm', 'get_current_llm_details', 'prepare_rag_context', 'csv_to_documents', 'text_to_documents', 'load_documents_from_directory']:
-            return lambda *args, **kwargs: logger.warning(f"Mocked method '{name}' called") or None
-        # 속성 접근 시에는 None 반환
-        return None
-
-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
-    from app.app_routes import register_routes
-    from app.app_device_routes import register_device_routes
-    MODULE_LOAD_SUCCESS = True
-except ImportError as e:
-    logger.error(f"로컬 모듈 임포트 실패: {e}. Mock 객체를 사용합니다.")
-    VitoSTT = LLMInterface = DocumentProcessor = VectorRetriever = ReRanker = MockComponent
-    # register_routes, register_device_routes는 임포트 실패 시 정의되지 않으므로 아래에서 처리
-    MODULE_LOAD_SUCCESS = False
-    # 임시로 빈 함수 정의 (앱 실행은 되도록)
-    def register_routes(*args, **kwargs): logger.error("register_routes 임포트 실패")
-    def register_device_routes(*args, **kwargs): logger.error("register_device_routes 임포트 실패")
-# --- 로컬 모듈 임포트 끝 ---
-
-
-# Flask 앱 초기화
-app = Flask(__name__)
-
-# 세션 설정
-app.secret_key = os.getenv('FLASK_SECRET_KEY', 'rag_chatbot_fixed_secret_key_12345')
-app.config['SESSION_COOKIE_SECURE'] = True
-app.config['SESSION_COOKIE_HTTPONLY'] = True
-app.config['SESSION_COOKIE_SAMESITE'] = 'None'
-app.config['SESSION_COOKIE_DOMAIN'] = None
-app.config['SESSION_COOKIE_PATH'] = '/'
-app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=1)
-
-# 최대 파일 크기 설정 (10MB)
-app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
-# 애플리케이션 파일 기준 상대 경로 설정
-APP_ROOT = os.path.dirname(os.path.abspath(__file__))
-# static 폴더 경로 수정 (app 폴더 내부의 static)
-app.config['STATIC_FOLDER'] = os.path.join(APP_ROOT, 'static')
-app.config['UPLOAD_FOLDER'] = os.path.join(APP_ROOT, 'uploads')
-# data 및 index 경로는 app 폴더 외부로 설정 (프로젝트 루트 기준)
-app.config['DATA_FOLDER'] = os.path.join(os.path.dirname(APP_ROOT), 'data')
-app.config['INDEX_PATH'] = os.path.join(os.path.dirname(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_interface = None
-stt_client = None
-base_retriever = None
-retriever = None
-# app_ready 플래그 대신 threading.Event 사용
-app_ready_event = threading.Event() # 초기 상태: False (set() 호출 전까지)
-
-# --- 전역 객체 초기화 (try-except로 감싸기) ---
-try:
-    if MODULE_LOAD_SUCCESS: # 모듈 로드 성공 시에만 실제 초기화 시도
-        llm_interface = LLMInterface(default_llm="openai")
-        stt_client = VitoSTT()
-    else: # 실패 시 Mock 객체 사용
-        llm_interface = LLMInterface() # MockComponent
-        stt_client = VitoSTT() # MockComponent
-except Exception as e:
-    logger.error(f"LLM 또는 STT 인터페이스 초기화 중 오류 발생: {e}", exc_info=True)
-    llm_interface = MockComponent() # 오류 시 Mock 객체 할당
-    stt_client = MockComponent() # 오류 시 Mock 객체 할당
-
-# --- 인증 데코레이터 ---
-def login_required(f):
-    @wraps(f)
-    def decorated_function(*args, **kwargs):
-        logger.info(f"----------- 인증 필요 페이지 접근 시도: {request.path} -----------")
-        logger.debug(f"현재 플라스크 세션 객체: {session}") # DEBUG 레벨로 변경
-        logger.info(f"현재 세션 상태: logged_in={session.get('logged_in', False)}, username={session.get('username', 'None')}")
-        logger.debug(f"요청의 세션 쿠키 값: {request.cookies.get('session', 'None')}") # DEBUG 레벨로 변경
-
-        if not session.get('logged_in'): # .get() 사용하는 것이 더 안전
-            logger.warning(f"세션에 'logged_in' 없음 또는 False. 로그인 페이지로 리디렉션.")
-            return redirect(url_for('login', next=request.url))
-
-        logger.info(f"인증 성공: {session.get('username', 'unknown')} 사용자가 {request.path} 접근")
-        return f(*args, **kwargs)
-    return decorated_function
-# --- 인증 데코레이터 끝 ---
-
-
-# --- 헬퍼 함수 (app_routes.py에도 있지만 여기서도 필요할 수 있음) ---
-def allowed_audio_file(filename):
-    """파일이 허용된 오디오 확장자를 가지는지 확인"""
-    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_AUDIO_EXTENSIONS
-
-def allowed_doc_file(filename):
-    """파일이 허용된 문서 확장자를 가지는지 확인"""
-    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_DOC_EXTENSIONS
-# --- 헬퍼 함수 끝 ---
-
-
-# --- 검색기 초기화 관련 함수 ---
-def init_retriever():
-    """검색기 객체 초기화 또는 로드"""
-    global base_retriever, retriever
-
-    # 모듈 로드 실패 시 Mock 객체 반환
-    if not MODULE_LOAD_SUCCESS:
-        logger.warning("필수 모듈 로드 실패로 Mock 검색기 반환")
-        base_retriever = VectorRetriever() # MockComponent
-        retriever = ReRanker() # MockComponent
-        return retriever
-
-    index_path = app.config['INDEX_PATH']
-    data_path = app.config['DATA_FOLDER']
-    logger.info("--- init_retriever 시작 ---")
-
-    # 1. 기본 검색기 로드 또는 초기화
-    try:
-        if os.path.exists(os.path.join(index_path, "documents.json")): # 저장 방식에 따라 확인 파일 변경 필요
-            logger.info(f"인덱스 로드 시도: {index_path}")
-            base_retriever = VectorRetriever.load(index_path)
-            logger.info(f"인덱스 로드 성공. 문서 {len(getattr(base_retriever, 'documents', []))}개")
-        else:
-            logger.info("인덱스 파일 없음. 새 VectorRetriever 초기화 시도...")
-            base_retriever = VectorRetriever()
-            logger.info("새 VectorRetriever 초기화 성공.")
-    except Exception as e:
-        logger.error(f"기본 검색기 초기화/로드 실패: {e}", exc_info=True)
-        base_retriever = MockComponent() # 실패 시 Mock 사용
-        retriever = MockComponent()
-        logger.info("Mock 검색기를 대체로 사용합니다.")
-        return retriever # 초기화 실패해도 Mock 검색기 반환 (None 대신)
-
-    # 2. 데이터 폴더 문서 로드 (기본 검색기가 비어있을 때)
-    needs_loading = not hasattr(base_retriever, 'documents') or not getattr(base_retriever, 'documents', [])
-    if needs_loading and os.path.exists(data_path):
-        logger.info(f"기본 검색기가 비어있어 {data_path}에서 문서 로드 시도...")
-        try:
-            # DocumentProcessor.load_documents_from_directory 호출 확인
-            if hasattr(DocumentProcessor, 'load_documents_from_directory'):
-                docs = DocumentProcessor.load_documents_from_directory(
-                    directory=data_path,
-                    extensions=[".txt", ".md", ".csv"],
-                    recursive=True
-                )
-                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)
-            else:
-                 logger.warning("DocumentProcessor에 load_documents_from_directory 메소드가 없습니다.")
-        except Exception as e_load_add:
-            logger.error(f"DATA_FOLDER 문서 로드/추가 중 오류: {e_load_add}", exc_info=True)
-
-    # 3. 재순위화 검색기 초기화
-    logger.info("재순위화 검색기 초기화 시도...")
-    try:
-        # custom_rerank_fn 정의
-        def custom_rerank_fn(query, results):
-            # 이 함수는 실제 재순위화 로직에 맞게 구현 필요
-            # 예시: 단순히 score 기준으로 정렬
-            results.sort(key=lambda x: x.get("score", 0) if isinstance(x, dict) else 0, reverse=True)
-            return results
-
-        # ReRanker 클래스 사용
-        retriever = ReRanker(
-            base_retriever=base_retriever,
-            rerank_fn=custom_rerank_fn,
-            rerank_field="text" # 재순위화에 사용할 필드 (필요시)
-        )
-        logger.info("재순위화 검색기 초기화 완료.")
-    except Exception as e_rerank:
-        logger.error(f"재순위화 검색기 초기화 실패: {e_rerank}", exc_info=True)
-        logger.warning("재순위화 실패, 기본 검색기를 retriever로 사용합니다.")
-        retriever = base_retriever # fallback
-
-    logger.info("--- init_retriever 종료 ---")
-    return retriever
-
-# --- 백그라운드 초기화 ---
-def background_init():
-    """백그라운드에서 검색기 및 기타 컴포넌트 초기화 수행"""
-    global retriever, base_retriever, llm_interface, stt_client, app_ready_event
-
-    logger.info("백그라운드 초기화 시작...")
-    start_init_time = time.time()
-
-    try:
-        # 1. LLM, STT 인터페이스 재확인 (이미 초기화 시도됨)
-        if llm_interface is None or isinstance(llm_interface, MockComponent):
-             logger.warning("LLM 인터페이스가 초기화되지 않았거나 Mock 객체입니다.")
-             # 필요시 여기서 다시 초기화 시도 가능
-        if stt_client is None or isinstance(stt_client, MockComponent):
-             logger.warning("STT 클라이언트가 초기화되지 않았거나 Mock 객체입니다.")
-
-        # 2. 검색기 초기화
-        logger.info("검색기 초기화 시도 (background)...")
-        retriever = init_retriever() # init_retriever가 base_retriever도 설정
-
-        # 성공 여부 확인 - retriever가 None이 아니면 성공으로 간주
-        if retriever is not None:
-            if not isinstance(retriever, MockComponent):
-                logger.info("검색기 초기화 성공 (background)")
-            else:
-                logger.warning("Mock 검색기를 사용합니다. 일부 기능이 제한될 수 있습니다.")
-            # 중요: 검색기가 Mock 객체이더라도 app_ready_event.set()을 호출하여 로딩 상태를 종료합니다.
-            app_ready_event.set()
-            logger.info("app_ready_event가 True로 설정됨.")
-        else:
-            logger.error("검색기 초기화 실패 (background)")
-            # 중요 수정: 실패 시에도 app_ready_event를 설정하여 로딩 페이지에서 벗어날 수 있도록 함
-            # 이렇게 하면 앱 자체는 실행되어 사용 가능한 상태가 됨
-            app_ready_event.set()
-            logger.warning("검색기 초기화 실패했지만 app_ready_event를 True로 설정하여 앱을 사용 가능한 상태로 만듭니다.")
-
-    except Exception as e:
-        logger.error(f"백그라운드 초기화 중 심각한 오류 발생: {e}", exc_info=True)
-        # 오류 발생 시에도 Mock 객체 할당 및 상태 설정 고려
-        if base_retriever is None: base_retriever = MockComponent()
-        if retriever is None: retriever = MockComponent()
-        # 중요 수정: 오류 발생 시에도 app_ready_event를 설정하여 로딩 페이지에서 벗어날 수 있도록 함
-        app_ready_event.set()
-        logger.warning("초기화 오류가 발생했지만 app_ready_event를 True로 설정하여 앱을 사용 가능한 상태로 만듭니다.")
-
-    finally:
-        end_init_time = time.time()
-        logger.info(f"백그라운드 초기화 완료. 소요 시간: {end_init_time - start_init_time:.2f}초")
-        logger.info(f"최종 앱 준비 상태 (app_ready_event.is_set()): {app_ready_event.is_set()}")
-
-# 백그라운드 스레드 시작
-init_thread = threading.Thread(target=background_init)
-init_thread.daemon = True
-init_thread.start()
-
-# --- 라우트 등록 ---
-try:
-    # 기본 RAG 챗봇 라우트 등록
-    register_routes(
-        app=app,
-        login_required=login_required,
-        llm_interface=llm_interface,
-        retriever=retriever,
-        stt_client=stt_client,
-        DocumentProcessor=DocumentProcessor,
-        base_retriever=base_retriever,
-        app_ready_event=app_ready_event,
-        ADMIN_USERNAME=ADMIN_USERNAME,
-        ADMIN_PASSWORD=ADMIN_PASSWORD,
-        DEVICE_SERVER_URL=DEVICE_SERVER_URL
-    )
-    logger.info("기본 챗봇 라우트 등록 완료")
-
-    # 장치 관리 라우트 등록
-    register_device_routes(
-        app=app,
-        login_required=login_required,
-        DEVICE_SERVER_URL=DEVICE_SERVER_URL
-    )
-    logger.info("장치 관리 라우트 등록 완료")
-except Exception as e:
-    # 라우트 등록 실패는 심각한 문제이므로 Critical 레벨 사용 고려
-    logger.critical(f"라우트 등록 중 치명적 오류 발생: {e}", exc_info=True)
-    # 앱 실행을 중단하거나 최소한의 오류 페이지를 제공하는 로직 추가 가능
-
-# --- 정적 파일 서빙 ---
-# STATIC_FOLDER 설정을 사용하여 static 폴더 경로 지정
-@app.route('/static/<path:path>')
-def send_static(path):
-    static_folder = app.config.get('STATIC_FOLDER', 'static') # 설정값 또는 기본값 사용
-    # logger.debug(f"Serving static file: {path} from {static_folder}") # 디버깅 시 주석 해제
-    return send_from_directory(static_folder, path)
-
-
-# --- 요청 처리 훅 ---
-@app.after_request
-def after_request_func(response):
-    """모든 응답에 대해 후처리 수행 (예: 보안 헤더 추가)"""
-    # 예시: response.headers['X-Content-Type-Options'] = 'nosniff'
-    return response
-
-# 앱 실행 (로컬 테스트용)
-if __name__ == '__main__':
-    logger.info("Flask 앱을 직접 실행합니다 (개발용 서버).")
-    # port 번호는 환경 변수 또는 기본값을 사용합니다.
-    port = int(os.environ.get("PORT", 7860)) # 기본 포트 7860 사용
-    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
-    # debug=True는 개발 중에만 사용하고, 배포 시에는 False로 변경하거나 제거
-    # use_reloader=False 추가하여 자동 리로드 비활성화 (백그라운드 스레드 문제 방지)
-    app.run(debug=False, host='0.0.0.0', port=port, use_reloader=False)

app/app_device_routes.py

@@ -1,220 +0,0 @@
-"""
-RAG 검색 챗봇 웹 애플리케이션 - 장치 관리 API 라우트 정의
-"""
-
-import os
-import logging
-import requests
-import json
-from flask import request, jsonify
-
-# 로거 가져오기
-logger = logging.getLogger(__name__)
-
-def register_device_routes(app, login_required, DEVICE_SERVER_URL):
-    """Flask 애플리케이션에 장치 관리 관련 라우트 등록"""
-    
-    @app.route('/api/device/settings', methods=['GET'])
-    @login_required
-    def get_device_settings():
-        """장치 관리 서버 설정 API - 프론트엔드에서 사용"""
-        logger.info("장치 관리 서버 설정 요청")
-        
-        return jsonify({
-            "server_url": DEVICE_SERVER_URL
-        })
-    
-    @app.route('/api/device/status', methods=['GET'])
-    @login_required
-    def device_status():
-        """장치 관리 서버 상태 확인 API"""
-        logger.info("장치 관리 서버 상태 확인 요청")
-        
-        # 직접 접속 모드를 사용하는 경우 프록시 처리
-        if not DEVICE_SERVER_URL:
-            logger.info("직접 접속 모드 사용 중 - 프론트엔드에서 처리")
-            return jsonify({
-                "info": "직접 접속 모드 사용 중. 프론트엔드에서 장치 서버에 직접 연결합니다."
-            })
-        
-        try:
-            # 장치 관리 서버 상태 확인
-            response = requests.get(f"{DEVICE_SERVER_URL}/api/status", timeout=5)
-            
-            if response.status_code == 200:
-                data = response.json()
-                logger.info(f"장치 관리 서버 상태: {data.get('status', 'unknown')}")
-                return jsonify({
-                    "success": True,
-                    "server_status": data.get("status", "unknown")
-                })
-            else:
-                logger.warning(f"장치 관리 서버 응답 코드: {response.status_code}")
-                return jsonify({
-                    "success": False,
-                    "error": f"장치 관리 서버가 비정상 응답 코드를 반환했습니다: {response.status_code}"
-                }), 502
-                
-        except requests.exceptions.Timeout:
-            logger.error("장치 관리 서버 연결 시간 초과")
-            return jsonify({
-                "success": False,
-                "error": "장치 관리 서버 연결 시간이 초과되었습니다."
-            }), 504
-            
-        except requests.exceptions.ConnectionError:
-            logger.error("장치 관리 서버 연결 실패")
-            return jsonify({
-                "success": False,
-                "error": "장치 관리 서버에 연결할 수 없습니다. 서버가 실행 중인지 확인해주세요."
-            }), 503
-            
-        except Exception as e:
-            logger.error(f"장치 관리 서버 상태 확인 중 오류 발생: {e}")
-            return jsonify({
-                "success": False,
-                "error": f"장치 관리 서버 상태 확인 중 오류 발생: {str(e)}"
-            }), 500
-    
-    
-    @app.route('/api/device/list', methods=['GET'])
-    @login_required
-    def device_list():
-        """장치 목록 조회 API"""
-        logger.info("장치 목록 조회 요청")
-        
-        try:
-            # 장치 목록 조회
-            response = requests.get(f"{DEVICE_SERVER_URL}/api/devices", timeout=5)
-            
-            if response.status_code == 200:
-                data = response.json()
-                devices = data.get("devices", [])
-                logger.info(f"장치 목록 조회 성공: {len(devices)}개 장치")
-                return jsonify({
-                    "success": True,
-                    "devices": devices
-                })
-            else:
-                logger.warning(f"장치 목록 조회 실패: {response.status_code}")
-                return jsonify({
-                    "success": False,
-                    "error": f"장치 목록 조회 실패: {response.status_code}"
-                }), 502
-                
-        except requests.exceptions.Timeout:
-            logger.error("장치 목록 조회 시간 초과")
-            return jsonify({
-                "success": False,
-                "error": "장치 목록 조회 시간이 초과되었습니다."
-            }), 504
-            
-        except requests.exceptions.ConnectionError:
-            logger.error("장치 관리 서버 연결 실패")
-            return jsonify({
-                "success": False,
-                "error": "장치 관리 서버에 연결할 수 없습니다. 서버가 실행 중인지 확인해주세요."
-            }), 503
-            
-        except Exception as e:
-            logger.error(f"장치 목록 조회 중 오류 발생: {e}")
-            return jsonify({
-                "success": False,
-                "error": f"장치 목록 조회 중 오류 발생: {str(e)}"
-            }), 500
-    
-    
-    @app.route('/api/device/programs', methods=['GET'])
-    @login_required
-    def device_programs():
-        """실행 가능한 프로그램 목록 조회 API"""
-        logger.info("프로그램 목록 조회 요청")
-        
-        try:
-            # 프로그램 목록 조회
-            response = requests.get(f"{DEVICE_SERVER_URL}/api/programs", timeout=5)
-            
-            if response.status_code == 200:
-                data = response.json()
-                programs = data.get("programs", [])
-                logger.info(f"프로그램 목록 조회 성공: {len(programs)}개 프로그램")
-                return jsonify({
-                    "success": True,
-                    "programs": programs
-                })
-            else:
-                logger.warning(f"프로그램 목록 조회 실패: {response.status_code}")
-                return jsonify({
-                    "success": False,
-                    "error": f"프로그램 목록 조회 실패: {response.status_code}"
-                }), 502
-                
-        except requests.exceptions.Timeout:
-            logger.error("프로그램 목록 조회 시간 초과")
-            return jsonify({
-                "success": False,
-                "error": "프로그램 목록 조회 시간이 초과되었습니다."
-            }), 504
-            
-        except requests.exceptions.ConnectionError:
-            logger.error("장치 관리 서버 연결 실패")
-            return jsonify({
-                "success": False,
-                "error": "장치 관리 서버에 연결할 수 없습니다. 서버가 실행 중인지 확인해주세요."
-            }), 503
-            
-        except Exception as e:
-            logger.error(f"프로그램 목록 조회 중 오류 발생: {e}")
-            return jsonify({
-                "success": False,
-                "error": f"프로그램 목록 조회 중 오류 발생: {str(e)}"
-            }), 500
-    
-    
-    @app.route('/api/device/programs/<program_id>/execute', methods=['POST'])
-    @login_required
-    def execute_program(program_id):
-        """프로그램 실행 API"""
-        logger.info(f"프로그램 실행 요청: {program_id}")
-        
-        try:
-            # 프로그램 실행
-            response = requests.post(
-                f"{DEVICE_SERVER_URL}/api/programs/{program_id}/execute",
-                json={},
-                timeout=10  # 프로그램 실행에는 더 긴 시간 부여
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                success = data.get("success", False)
-                message = data.get("message", "")
-                logger.info(f"프로그램 실행 응답: {success}, {message}")
-                return jsonify(data)
-            else:
-                logger.warning(f"프로그램 실행 실패: {response.status_code}")
-                return jsonify({
-                    "success": False,
-                    "error": f"프로그램 실행 요청 실패: {response.status_code}"
-                }), 502
-                
-        except requests.exceptions.Timeout:
-            logger.error("프로그램 실행 요청 시간 초과")
-            return jsonify({
-                "success": False,
-                "error": "프로그램 실행 요청 시간이 초과되었습니다."
-            }), 504
-            
-        except requests.exceptions.ConnectionError:
-            logger.error("장치 관리 서버 연결 실패")
-            return jsonify({
-                "success": False,
-                "error": "장치 관리 서버에 연결할 수 없습니다. 서버가 실행 중인지 확인해주세요."
-            }), 503
-            
-        except Exception as e:
-            logger.error(f"프로그램 실행 중 오류 발생: {e}")
-            return jsonify({
-                "success": False,
-                "error": f"프로그램 실행 중 오류 발생: {str(e)}"
-            }), 500

app/app_main.py

@@ -0,0 +1,138 @@
+"""
+RAG 검색 챗봇 웹 애플리케이션 - 메인 파일
+"""
+
+import os
+import json
+import logging
+import threading
+import datetime
+from flask import Flask, request, jsonify, render_template, send_from_directory, session, redirect, url_for
+from werkzeug.utils import secure_filename
+from dotenv import load_dotenv
+from functools import wraps
+
+# 로거 설정
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.DEBUG
+)
+logger = logging.getLogger(__name__)
+
+# 앱 초기화 관련 모듈 임포트
+from app.app_revised import (app, app_ready_event, init_success_event, 
+                            llm_interface, stt_client, base_retriever, retriever,
+                            MockComponent, initialization_error, login_required,
+                            ADMIN_USERNAME, ADMIN_PASSWORD, DEVICE_SERVER_URL,
+                            DocumentProcessor)
+
+# 백그라운드 초기화 함수 임포트
+from app.background_init import background_init
+
+# 백그라운드 초기화 스레드 함수
+def init_thread_func():
+    global base_retriever, retriever, initialization_error
+    
+    # 백그라운드 초기화 함수 호출
+    updated_base_retriever, updated_retriever, updated_error = background_init(
+        app, llm_interface, stt_client, base_retriever, retriever, 
+        app_ready_event, init_success_event, MockComponent, initialization_error
+    )
+    
+    # 전역 변수 업데이트
+    base_retriever = updated_base_retriever
+    retriever = updated_retriever
+    
+    # 오류 메시지가 있으면 업데이트
+    if updated_error:
+        initialization_error = updated_error
+        logger.warning(f"초기화 오류 메시지 업데이트: {initialization_error}")
+
+# 백그라운드 초기화 스레드 시작
+init_thread = threading.Thread(target=init_thread_func)
+init_thread.daemon = True
+init_thread.start()
+
+# 모듈 임포트
+try:
+    from app.app_routes_improved import register_routes
+    logger.info("라우트 등록 모듈 임포트 성공")
+except ImportError as e:
+    logger.critical(f"라우트 등록 모듈 임포트 실패: {e}", exc_info=True)
+    
+    # 기본 라우트 정의 (오류 시)
+    @app.route('/')
+    def error_index():
+        return render_template('error.html', 
+                            error="앱 초기화 중 심각한 오류가 발생했습니다. 관리자에게 문의하세요.",
+                            details=f"라우트 모듈 임포트 실패: {str(e)}")
+
+# --- 라우트 등록 ---
+try:
+    # app_routes_improved.py의 register_routes 함수 호출
+    register_routes(
+        app=app,
+        login_required=login_required,
+        llm_interface=llm_interface,
+        retriever=retriever,
+        stt_client=stt_client,
+        DocumentProcessor=DocumentProcessor,
+        base_retriever=base_retriever,
+        app_ready_event=app_ready_event,
+        init_success_event=init_success_event,
+        initialization_error=initialization_error,
+        ADMIN_USERNAME=ADMIN_USERNAME,
+        ADMIN_PASSWORD=ADMIN_PASSWORD,
+        DEVICE_SERVER_URL=DEVICE_SERVER_URL
+    )
+    logger.info("모든 라우트 등록 완료")
+except Exception as e:
+    # 라우트 등록 실패는 심각한 문제이므로 Critical 레벨 사용
+    logger.critical(f"라우트 등록 중 치명적 오류 발생: {e}", exc_info=True)
+    
+    # 최소한의 오류 페이지를 제공하는 기본 라우트 등록
+    @app.route('/')
+    def error_index():
+        return render_template('error.html', 
+                              error="앱 초기화 중 심각한 오류가 발생했습니다. 관리자에게 문의하세요.",
+                              details=str(e))
+
+# --- 추가 시스템 상태 API ---
+@app.route('/api/system/status')
+def system_status():
+    """시스템 상태 정보를 반환"""
+    status = {
+        "app_ready": app_ready_event.is_set(),
+        "init_success": init_success_event.is_set(),
+        "retriever_type": type(retriever).__name__ if retriever else "None",
+        "base_retriever_type": type(base_retriever).__name__ if base_retriever else "None",
+        "has_error": initialization_error is not None,
+        "error_message": initialization_error if initialization_error else None,
+        "document_count": len(getattr(base_retriever, 'documents', [])) 
+                          if hasattr(base_retriever, 'documents') else 0,
+        "server_time": datetime.datetime.now().isoformat(),
+    }
+    return jsonify(status)
+
+# --- 정적 파일 서빙 ---
+@app.route('/static/<path:path>')
+def send_static(path):
+    static_folder = app.config.get('STATIC_FOLDER', 'static')
+    return send_from_directory(static_folder, path)
+
+# --- 요청 처리 훅 ---
+@app.after_request
+def after_request_func(response):
+    """모든 응답에 대해 후처리 수행 (예: 보안 헤더 추가)"""
+    # 보안 헤더 설정 예시
+    response.headers['X-Content-Type-Options'] = 'nosniff'
+    return response
+
+# 앱 실행 (로컬 테스트용)
+if __name__ == '__main__':
+    logger.info("Flask 앱을 직접 실행합니다 (개발용 서버).")
+    port = int(os.environ.get("PORT", 7860))  # 기본 포트 7860 사용
+    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
+    # debug=True는 개발 중에만 사용하고, 배포 시에는 False로 변경하거나 제거
+    # use_reloader=False 추가하여 자동 리로드 비활성화 (백그라운드 스레드 문제 방지)
+    app.run(debug=False, host='0.0.0.0', port=port, use_reloader=False)

app/app_part2.py

@@ -1,209 +0,0 @@
-# --- 임베딩 관련 헬퍼 함수 ---
-def save_embeddings(base_retriever, file_path):
-    """임베딩 데이터를 압축하여 파일에 저장"""
-    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):
-    """저장된 임베딩 데이터를 파일에서 로드"""
-    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
-
-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")):
-            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("기존 인덱스를 찾을 수 없어 새 검색기를 초기화합니다...")
-            base_retriever = VectorRetriever()
-
-        # 데이터 폴더의 문서 로드
-        data_path = app.config['DATA_FOLDER']
-        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"],
-                    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}")
-
-    # 재순위화 검색기 초기화
-    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,
-            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, base_retriever
-    
-    # 즉시 앱 사용 가능 상태로 설정
-    app_ready = True
-    logger.info("앱을 즉시 사용 가능 상태로 설정 (app_ready=True)")
-    
-    try:
-        # 기본 검색기 초기화 (보험)
-        if base_retriever is None:
-            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("앱 초기화 완료 (모든 컴포넌트 준비됨)")
-    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("초기화 중 오류가 있지만 앱은 계속 사용 가능합니다.")
-
-# 백그라운드 스레드 시작
-init_thread = threading.Thread(target=background_init)
-init_thread.daemon = True
-init_thread.start()
-

app/app_part3.py

@@ -1,163 +0,0 @@
-# --- Flask 라우트 정의 ---
-
-@app.route('/login', methods=['GET', 'POST'])
-def login():
-    error = None
-    next_url = request.args.get('next')
-    logger.info(f"-------------- 로그인 페이지 접속 (Next: {next_url}) --------------")
-    logger.info(f"Method: {request.method}")
-
-    if request.method == 'POST':
-        logger.info("로그인 시도 받음")
-        username = request.form.get('username', '')
-        password = request.form.get('password', '')
-        logger.info(f"입력된 사용자명: {username}")
-        logger.info(f"비밀번호 입력 여부: {len(password) > 0}")
-
-        # 환경 변수 또는 기본값과 비교
-        valid_username = ADMIN_USERNAME
-        valid_password = ADMIN_PASSWORD
-        logger.info(f"검증용 사용자명: {valid_username}")
-        logger.info(f"검증용 비밀번호 존재 여부: {valid_password is not None and len(valid_password) > 0}")
-
-        if username == valid_username and password == valid_password:
-            logger.info(f"로그인 성공: {username}")
-            # 세션 설정 전 현재 세션 상태 로깅
-            logger.debug(f"세션 설정 전: {session}")
-
-            # 세션에 로그인 정보 저장
-            session.permanent = True
-            session['logged_in'] = True
-            session['username'] = username
-            session.modified = True
-
-            logger.info(f"세션 설정 후: {session}")
-            logger.info("세션 설정 완료, 리디렉션 시도")
-
-            # 로그인 성공 후 리디렉션
-            redirect_to = next_url or url_for('index')
-            logger.info(f"리디렉션 대상: {redirect_to}")
-            response = redirect(redirect_to)
-            return response
-        else:
-            logger.warning("로그인 실패: 아이디 또는 비밀번호 불일치")
-            if username != valid_username: logger.warning("사용자명 불일치")
-            if password != valid_password: logger.warning("비밀번호 불일치")
-            error = '아이디 또는 비밀번호가 올바르지 않습니다.'
-    else:
-        logger.info("로그인 페이지 GET 요청")
-        if 'logged_in' in session:
-            logger.info("이미 로그인된 사용자, 메인 페이지로 리디렉션")
-            return redirect(url_for('index'))
-
-    logger.info("---------- 로그인 페이지 렌더링 ----------")
-    return render_template('login.html', error=error, next=next_url)
-
-
-@app.route('/logout')
-def logout():
-    logger.info("-------------- 로그아웃 요청 --------------")
-    logger.info(f"로그아웃 전 세션 상태: {session}")
-
-    if 'logged_in' in session:
-        username = session.get('username', 'unknown')
-        logger.info(f"사용자 {username} 로그아웃 처리 시작")
-        session.pop('logged_in', None)
-        session.pop('username', None)
-        session.modified = True
-        logger.info(f"세션 정보 삭제 완료. 현재 세션: {session}")
-    else:
-        logger.warning("로그인되지 않은 상태에서 로그아웃 시도")
-
-    logger.info("로그인 페이지로 리디렉션")
-    response = redirect(url_for('login'))
-    return response
-
-
-@app.route('/')
-@login_required
-def index():
-    """메인 페이지"""
-    global app_ready
-    
-    # 앱 준비 상태 확인 - 30초 이상 지났으면 강제로 ready 상태로 변경
-    current_time = datetime.now()
-    start_time = datetime.fromtimestamp(os.path.getmtime(__file__))
-    time_diff = (current_time - start_time).total_seconds()
-    
-    if not app_ready and time_diff > 30:
-        logger.warning(f"앱이 30초 이상 초기화 중 상태입니다. 강제로 ready 상태로 변경합니다.")
-        app_ready = True
-    
-    if not app_ready:
-        logger.info("앱이 아직 준비되지 않아 로딩 페이지 표시")
-        return render_template('loading.html'), 503  # 서비스 준비 안됨 상태 코드
-    
-    logger.info("메인 페이지 요청")
-    return render_template('index.html')
-
-
-@app.route('/api/status')
-@login_required
-def app_status():
-    """앱 초기화 상태 확인 API"""
-    logger.info(f"앱 상태 확인 요청: {'Ready' if app_ready else 'Not Ready'}")
-    return jsonify({"ready": app_ready})
-
-
-@app.route('/api/llm', methods=['GET', 'POST'])
-@login_required
-def llm_api():
-    """사용 가능한 LLM 목록 및 선택 API"""
-    global llm_interface
-
-    if not app_ready:
-        return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
-
-    if request.method == 'GET':
-        logger.info("LLM 목록 요청")
-        try:
-            current_details = llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {"id": "unknown", "name": "Unknown"}
-            supported_llms_dict = llm_interface.SUPPORTED_LLMS if hasattr(llm_interface, 'SUPPORTED_LLMS') else {}
-            supported_list = [{
-                "name": name, "id": id, "current": id == current_details.get("id")
-            } for name, id in supported_llms_dict.items()]
-
-            return jsonify({
-                "supported_llms": supported_list,
-                "current_llm": current_details
-            })
-        except Exception as e:
-            logger.error(f"LLM 정보 조회 오류: {e}")
-            return jsonify({"error": "LLM 정보 조회 중 오류 발생"}), 500
-
-    elif request.method == 'POST':
-        data = request.get_json()
-        if not data or 'llm_id' not in data:
-            return jsonify({"error": "LLM ID가 제공되지 않았습니다."}), 400
-
-        llm_id = data['llm_id']
-        logger.info(f"LLM 변경 요청: {llm_id}")
-
-        try:
-            if not hasattr(llm_interface, 'set_llm') or not hasattr(llm_interface, 'llm_clients'):
-                raise NotImplementedError("LLM 인터페이스에 필요한 메소드/속성 없음")
-
-            if llm_id not in llm_interface.llm_clients:
-                return jsonify({"error": f"지원되지 않는 LLM ID: {llm_id}"}), 400
-
-            success = llm_interface.set_llm(llm_id)
-            if success:
-                new_details = llm_interface.get_current_llm_details()
-                logger.info(f"LLM이 '{new_details.get('name', llm_id)}'로 변경되었습니다.")
-                return jsonify({
-                    "success": True,
-                    "message": f"LLM이 '{new_details.get('name', llm_id)}'로 변경되었습니다.",
-                    "current_llm": new_details
-                })
-            else:
-                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/app_revised.py

@@ -1,12 +1,16 @@
 """
-RAG 검색 챗봇 웹 애플리케이션 (장치 관리 기능 통합)
+RAG 검색 챗봇 웹 애플리케이션 (초기화 로직 개선)
 """
 
 import os
+import json
 import logging
+import tempfile
 import threading
-from datetime import datetime, timedelta
-from flask import Flask, send_from_directory
+import datetime
+import time
+from flask import Flask, request, jsonify, render_template, send_from_directory, session, redirect, url_for
+from werkzeug.utils import secure_filename
 from dotenv import load_dotenv
 from functools import wraps
 
@@ -23,12 +27,12 @@ load_dotenv()
 # 환경 변수 로드 상태 확인 및 로깅
 ADMIN_USERNAME = os.getenv('ADMIN_USERNAME')
 ADMIN_PASSWORD = os.getenv('ADMIN_PASSWORD')
-DEVICE_SERVER_URL = os.getenv('DEVICE_SERVER_URL', 'http://localhost:5050')
+DEVICE_SERVER_URL = os.getenv('DEVICE_SERVER_URL', '')
 
 logger.info(f"==== 환경 변수 로드 상태 ====")
 logger.info(f"ADMIN_USERNAME 설정 여부: {ADMIN_USERNAME is not None}")
 logger.info(f"ADMIN_PASSWORD 설정 여부: {ADMIN_PASSWORD is not None}")
-logger.info(f"DEVICE_SERVER_URL: {DEVICE_SERVER_URL}")
+logger.info(f"DEVICE_SERVER_URL: {DEVICE_SERVER_URL or '설정되지 않음 (프론트엔드에서 자동 설정)'}")
 
 # 환경 변수가 없으면 기본값 설정
 if not ADMIN_USERNAME:
@@ -39,203 +43,114 @@ if not ADMIN_PASSWORD:
     ADMIN_PASSWORD = 'rag12345'
     logger.warning("ADMIN_PASSWORD 환경변수가 없어 기본값 'rag12345'로 설정합니다.")
 
-class MockComponent: pass
+# --- 로컬 모듈 임포트 시작 ---
+# MockComponent 정의 (임포트 실패 시 대체)
+class MockComponent:
+    def __init__(self):
+        self.is_mock = True
+        logger.warning("MockComponent 인스턴스 생성됨")
+    
+    def search(self, query, top_k=5, first_stage_k=None):
+        """빈 검색 결과를 반환합니다."""
+        logger.warning(f"MockComponent.search 호출됨 (쿼리: {query[:30]}...)")
+        return []
+    
+    def __getattr__(self, name):
+        # Mock 객체의 어떤 속성이나 메소드 호출 시 경고 로그 출력 및 기본값 반환
+        logger.warning(f"MockComponent에서 '{name}' 접근 시도됨 (실제 모듈 로드 실패)")
+        # 메소드 호출 시에는 아무것도 안 하는 함수 반환
+        if name in ['add_documents', 'save', 'transcribe_audio', 'rag_generate', 'set_llm', 
+                   'get_current_llm_details', 'prepare_rag_context', 'csv_to_documents', 
+                   'text_to_documents', 'load_documents_from_directory']:
+            return lambda *args, **kwargs: logger.warning(f"Mocked method '{name}' called") or None
+        # 속성 접근 시에는 None 반환
+        return None
+
+# 초기화 상태 및 에러 정보를 저장할 전역 변수
+initialization_error = None
 
-# --- 로컬 모듈 임포트 ---
 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
+    from app.app_routes import register_routes
+    from app.app_device_routes import register_device_routes
+    MODULE_LOAD_SUCCESS = True
+    logger.info("모든 필수 모듈을 성공적으로 임포트했습니다.")
 except ImportError as e:
-    logger.error(f"로컬 모듈 임포트 실패: {e}. utils 및 retrieval 패키지가 올바른 경로에 있는지 확인하세요.")
+    logger.error(f"로컬 모듈 임포트 실패: {e}. Mock 객체를 사용합니다.")
+    initialization_error = f"모듈 임포트 실패: {str(e)}"
     VitoSTT = LLMInterface = DocumentProcessor = VectorRetriever = ReRanker = MockComponent
+    MODULE_LOAD_SUCCESS = False
+    # 임시로 빈 함수 정의 (앱 실행은 되도록)
+    def register_routes(*args, **kwargs): 
+        logger.error("register_routes 임포트 실패")
+    def register_device_routes(*args, **kwargs): 
+        logger.error("register_device_routes 임포트 실패")
 # --- 로컬 모듈 임포트 끝 ---
 
-
 # Flask 앱 초기화
 app = Flask(__name__)
 
 # 세션 설정
 app.secret_key = os.getenv('FLASK_SECRET_KEY', 'rag_chatbot_fixed_secret_key_12345')
-
-# --- 세션 쿠키 설정 ---
 app.config['SESSION_COOKIE_SECURE'] = True
 app.config['SESSION_COOKIE_HTTPONLY'] = True
 app.config['SESSION_COOKIE_SAMESITE'] = 'None'
 app.config['SESSION_COOKIE_DOMAIN'] = None
 app.config['SESSION_COOKIE_PATH'] = '/'
-app.config['PERMANENT_SESSION_LIFETIME'] = timedelta(days=1)
-# --- 세션 쿠키 설정 끝 ---
+app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=1)
 
 # 최대 파일 크기 설정 (10MB)
 app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
 # 애플리케이션 파일 기준 상대 경로 설정
 APP_ROOT = os.path.dirname(os.path.abspath(__file__))
+# static 폴더 경로 설정 (app 폴더 내부의 static)
+app.config['STATIC_FOLDER'] = os.path.join(APP_ROOT, 'static')
 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')
+# data 및 index 경로는 app 폴더 외부로 설정 (프로젝트 루트 기준)
+app.config['DATA_FOLDER'] = os.path.join(os.path.dirname(APP_ROOT), 'data')
+app.config['INDEX_PATH'] = os.path.join(os.path.dirname(APP_ROOT), 'data', 'index')
+
+# 로그에 설정값 출력
+logger.info(f"애플리케이션 경로: {APP_ROOT}")
+logger.info(f"Static 폴더 경로: {app.config['STATIC_FOLDER']}")
+logger.info(f"데이터 폴더 경로: {app.config['DATA_FOLDER']}")
+logger.info(f"인덱스 경로: {app.config['INDEX_PATH']}")
 
 # 필요한 폴더 생성
 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)
 
-# --- 전역 객체 초기화 ---
-try:
-    llm_interface = LLMInterface(default_llm="openai")
-    stt_client = VitoSTT()
-except NameError:
-    logger.warning("LLM 또는 STT 인터페이스 초기화 실패. Mock 객체를 사용합니다.")
-    llm_interface = MockComponent()
-    stt_client = MockComponent()
+# 허용되는 오디오/문서 파일 확장자
+ALLOWED_AUDIO_EXTENSIONS = {'mp3', 'wav', 'ogg', 'm4a'}
+ALLOWED_DOC_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'csv'}
 
+# --- 전역 객체 초기화 ---
+llm_interface = None
+stt_client = None
 base_retriever = None
 retriever = None
-app_ready = False # 앱 초기화 상태 플래그
-# --- 전역 객체 초기화 끝 ---
-
-
-# --- 인증 데코레이터 ---
-def login_required(f):
-    @wraps(f)
-    def decorated_function(*args, **kwargs):
-        from flask import request, session, redirect, url_for
-        
-        logger.info(f"----------- 인증 필요 페이지 접근 시도: {request.path} -----------")
-        logger.info(f"현재 플라스크 세션 객체: {session}")
-        logger.info(f"현재 세션 상태: logged_in={session.get('logged_in', False)}, username={session.get('username', 'None')}")
-        logger.info(f"요청의 세션 쿠키 값: {request.cookies.get('session', 'None')}")
-
-        # Flask 세션에 'logged_in' 키가 있는지 직접 확인
-        if 'logged_in' not in session:
-            logger.warning(f"플라스크 세션에 'logged_in' 없음. 로그인 페이지로 리디렉션.")
-            return redirect(url_for('login', next=request.url))
-
-        logger.info(f"인증 성공: {session.get('username', 'unknown')} 사용자가 {request.path} 접근")
-        return f(*args, **kwargs)
-    return decorated_function
-# --- 인증 데코레이터 끝 ---
-
-
-# --- 정적 파일 서빙 ---
-@app.route('/static/<path:path>')
-def send_static(path):
-    return send_from_directory('static', path)
-
-
-# --- 백그라운드 초기화 함수 ---
-def background_init():
-    """백그라운드에서 검색기 초기화 수행"""
-    global app_ready, retriever, base_retriever
-    
-    # 즉시 앱 사용 가능 상태로 설정
-    app_ready = True
-    logger.info("앱을 즉시 사용 가능 상태로 설정 (app_ready=True)")
-    
-    try:
-        from app.init_retriever import init_retriever
-        
-        # 기본 검색기 초기화 (보험)
-        if base_retriever is None:
-            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")
-        
-        # 캐시된 임베딩 로드 시도
-        try:
-            from app.init_retriever import load_embeddings
-            cached_retriever = load_embeddings(cache_path)
-            
-            if cached_retriever:
-                # 캐시된 데이터가 있으면 바로 사용
-                base_retriever = cached_retriever
-                
-                # 재순위화 검색기 초기화
-                retriever = ReRanker(
-                    base_retriever=base_retriever,
-                    rerank_fn=lambda query, results: results,
-                    rerank_field="text"
-                )
-                
-                logger.info("캐시된 임베딩으로 검색기 초기화 완료 (빠른 시작)")
-            else:
-                # 캐시된 데이터가 없으면 전체 초기화 진행
-                logger.info("캐시된 임베딩이 없어 전체 초기화 시작")
-                retriever = init_retriever(app, base_retriever, retriever, ReRanker)
-                logger.info("전체 초기화 완료")
-        except ImportError:
-            logger.warning("임베딩 캐시 모듈을 찾을 수 없습니다. 전체 초기화를 진행합니다.")
-            retriever = init_retriever(app, base_retriever, retriever, ReRanker)
-        
-        logger.info("앱 초기화 완료 (모든 컴포넌트 준비됨)")
-    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("초기화 중 오류가 있지만 앱은 계속 사용 가능합니다.")
-
-
-# --- 라우트 등록 ---
-def register_all_routes():
-    try:
-        # 기본 라우트 등록
-        from app.app_routes import register_routes
-        register_routes(
-            app, login_required, llm_interface, retriever, stt_client, 
-            DocumentProcessor, base_retriever, app_ready, 
-            ADMIN_USERNAME, ADMIN_PASSWORD, DEVICE_SERVER_URL
-        )
-        
-        # 장치 관리 라우트 등록
-        from app.app_device_routes import register_device_routes
-        register_device_routes(app, login_required, DEVICE_SERVER_URL)
-        
-        logger.info("모든 라우트 등록 완료")
-    except ImportError as e:
-        logger.error(f"라우트 모듈 임포트 실패: {e}")
-    except Exception as e:
-        logger.error(f"라우트 등록 중 오류 발생: {e}", exc_info=True)
-
-
-# --- 앱 초기화 및 실행 ---
-def initialize_app():
-    # 백그라운드 초기화 스레드 시작
-    init_thread = threading.Thread(target=background_init)
-    init_thread.daemon = True
-    init_thread.start()
-    
-    # 라우트 등록
-    register_all_routes()
-    
-    logger.info("앱 초기화 완료")
+# app_ready 플래그 대신 threading.Event 사용
+app_ready_event = threading.Event() # 초기 상태: False (set() 호출 전까지)
+init_success_event = threading.Event() # 초기화 성공 여부를 추적하는 이벤트
 
-
-# 앱 초기화 실행
-initialize_app()
-
-
-# --- 앱 실행 (직접 실행 시) ---
-if __name__ == '__main__':
-    logger.info("Flask 앱을 직접 실행합니다 (개발용 서버).")
-    port = int(os.environ.get("PORT", 7860))
-    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
-    app.run(debug=True, host='0.0.0.0', port=port)
+# --- 전역 객체 초기화 (try-except로 감싸기) ---
+try:
+    if MODULE_LOAD_SUCCESS: # 모듈 로드 성공 시에만 실제 초기화 시도
+        logger.info("LLM 및 STT 인터페이스 초기화 시도...")
+        llm_interface = LLMInterface(default_llm="openai")
+        stt_client = VitoSTT()
+        logger.info("LLM 및 STT 인터페이스 초기화 성공")
+    else: # 실패 시 Mock 객체 사용
+        logger.warning("모듈 로드 실패로 LLM 및 STT를 Mock 객체로 초기화")
+        llm_interface = MockComponent()
+        stt_client = MockComponent()
+except Exception as e:
+    logger.error(f"LLM 또는 STT 인터페이스 초기화 중 오류 발생: {e}", exc_info=True)
+    initialization_error = f"인터페이스 초기화 실패: {str(e)}"
+    llm_interface = MockComponent() # 오류 시 Mock 객체 할당
+    stt_client = MockComponent() # 오류 시 Mock 객체 할당

app/app_routes.py

@@ -1,774 +0,0 @@
-"""
-RAG 검색 챗봇 웹 애플리케이션 - API 라우트 정의 (TypeError 재수정)
-"""
-
-import os
-import json
-import logging
-import tempfile
-import requests
-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
-
-# 로거 가져오기
-logger = logging.getLogger(__name__)
-
-# 앱 시작 시간 기록 (모듈 로드 시점)
-APP_START_TIME = time.time()
-
-# !! 중요: 함수 정의에서 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):
-    """Flask 애플리케이션에 기본 라우트 등록"""
-
-    # 헬퍼 함수 (변경 없음)
-    def allowed_audio_file(filename):
-        """파일이 허용된 오디오 확장자를 가지는지 확인"""
-        ALLOWED_AUDIO_EXTENSIONS = {'mp3', 'wav', 'ogg', 'm4a'}
-        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_AUDIO_EXTENSIONS
-
-    def allowed_doc_file(filename):
-        """파일이 허용된 문서 확장자를 가지는지 확인"""
-        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
-        next_url = request.args.get('next')
-        logger.info(f"-------------- 로그인 페이지 접속 (Next: {next_url}) --------------")
-        logger.info(f"Method: {request.method}")
-
-        if request.method == 'POST':
-            logger.info("로그인 시도 받음")
-            username = request.form.get('username', '')
-            password = request.form.get('password', '')
-            logger.info(f"입력된 사용자명: {username}")
-
-            valid_username = ADMIN_USERNAME
-            valid_password = ADMIN_PASSWORD
-            logger.info(f"검증용 사용자명: {valid_username}")
-
-            if username == valid_username and password == valid_password:
-                logger.info(f"로그인 성공: {username}")
-                session.permanent = True
-                session['logged_in'] = True
-                session['username'] = username
-                logger.info(f"세션 설정 완료: {session}")
-                redirect_to = next_url or url_for('index')
-                logger.info(f"리디렉션 대상: {redirect_to}")
-                response = redirect(redirect_to)
-                logger.debug(f"로그인 응답 헤더 (Set-Cookie 확인): {response.headers.getlist('Set-Cookie')}")
-                return response
-            else:
-                logger.warning("로그인 실패: 아이디 또는 비밀번호 불일치")
-                error = '아이디 또는 비밀번호가 올바르지 않습니다.'
-        else: # GET 요청
-            logger.info("로그인 페이지 GET 요청")
-            if session.get('logged_in'):
-                logger.info("이미 로그인된 사용자, 메인 페이지로 리디렉션")
-                return redirect(url_for('index'))
-
-        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}")
-        else:
-             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.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
-
-        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와 로딩 페이지
-
-        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
-        logger.info(f"앱 상태 확인 요청: {'Ready' if is_ready else 'Not Ready'}")
-        return jsonify({"ready": is_ready})
-
-    # --- 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 목록 조회는 초기화 중에도 가능하도록 허용
-
-        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
-
-                current_details = llm_interface.get_current_llm_details()
-                supported_llms_dict = llm_interface.SUPPORTED_LLMS
-                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}", exc_info=True)
-                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
-
-            llm_id = data['llm_id']
-            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
-
-                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:
-                    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
-
-    # --- Chat API ---
-    @app.route('/api/chat', methods=['POST'])
-    @login_required
-    def chat():
-        """텍스트 기반 채봇 API"""
-        # 함수 내에서는 전역 retriever 변수를 직접 사용하고 수정하지 않음
-        # nonlocal 키워드를 사용하여 외부 스코프의 retriever 변수를 참조
-        nonlocal retriever
-        
-        try:
-            # 앱이 준비되었는지 확인
-            is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-            if not is_ready:
-                logger.warning("앱이 아직 초기화 중입니다.")
-                return jsonify({
-                    "error": "앱 초기화 중...", 
-                    "answer": "죄송합니다. 시스템이 아직 준비 중입니다.", 
-                    "sources": []
-                }), 200  # 503 대신 200으로 변���하여 앱이 정상 응답하도록 함
-
-            data = request.get_json()
-            if not data or 'query' not in data:
-                return jsonify({"error": "쿼리가 제공되지 않았습니다."}), 400
-
-            query = data['query']
-            logger.info(f"텍스트 쿼리 수신: {query[:100]}...")
-            
-            # 검색 엔진 처리 부분 수정
-            search_results = []
-            search_warning = None
-            try:
-                # retriever 상태 검증 - 여기서 retriever 변수를 수정하지 않도록 주의
-                if retriever is None:
-                    logger.warning("Retriever가 초기화되지 않았습니다.")
-                    # retriever가 None인 경우 경고만 기록하고 수정하지 않음
-                    search_warning = "검색 기능이 아직 준비되지 않았습니다."
-                elif hasattr(retriever, 'is_mock') and retriever.is_mock:
-                    logger.info("Mock Retriever 사용 중 - 검색 결과 없음.")
-                    # 상태 기록만 하고 수정하지 않음
-                    search_warning = "검색 인덱스가 아직 구축 중입니다. 기본 응답만 제공됩니다."
-                elif not hasattr(retriever, 'search'):
-                    logger.warning("Retriever에 search 메소드가 없습니다.")
-                    # 상태 기록만 하고 수정하지 않음
-                    search_warning = "검색 기능이 현재 제한되어 있습니다."
-                else:
-                    try:
-                        logger.info(f"검색 수행: {query[:50]}...")
-                        # 오류 시 빈 결과를 반환하는 추가 try-except 블록
-                        # retriever가 유효하고 search 메소드가 있는 경우에만 검색 실행
-                        if retriever is not None and hasattr(retriever, 'search'):
-                            try:
-                                search_results = retriever.search(query, top_k=5, first_stage_k=6)
-                            except Exception as search_err:
-                                logger.error(f"retriever.search() 호출 중 오류 발생: {search_err}", exc_info=True)
-                                search_results = []
-                                search_warning = f"검색 중 오류 발생: {str(search_err)}"
-                        else:
-                            logger.warning("검색을 실행할 수 없습니다: retriever가 None이거나 search 메소드가 없습니다.")
-                            search_results = []
-                            search_warning = "검색 기능이 현재 제한되어 있습니다."
-                        # except Exception as search_err:
-                        #     logger.error(f"retriever.search() 호출 중 오류 발생: {search_err}", exc_info=True)
-                        #     search_results = []
-                        #     search_warning = f"검색 중 오류 발생: {str(search_err)}"
-                            
-                        if not search_results:
-                            logger.info("검색 결과가 없습니다.")
-                        else:
-                            logger.info(f"검색 결과: {len(search_results)}개 항목")
-                    except Exception as e:
-                        logger.error(f"검색 처리 중 예상치 못한 오류: {e}", exc_info=True)
-                        search_results = []
-                        search_warning = f"검색 처리 중 오류 발생: {str(e)}"
-            except Exception as e:
-                logger.error(f"검색 중 오류 발생: {str(e)}", exc_info=True)
-                search_results = []
-                search_warning = f"검색 중 오류 발생: {str(e)}"
-            
-            # LLM 응답 생성
-            try:
-                # DocumentProcessor 객체 및 메소드 확인
-                context = ""
-                if search_results:
-                    if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
-                        logger.warning("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
-                    else:
-                        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
-                        logger.info(f"컨텍스트 준비 완료 (길이: {len(context) if context else 0}자)")
-
-                # LLM 인터페이스 객체 및 메소드 확인
-                llm_id = data.get('llm_id', None)
-                
-                if not context:
-                    if search_warning:
-                        logger.info(f"컨텍스트 없음, 검색 경고: {search_warning}")
-                        answer = f"죄송합니다. 질문에 대한 답변을 찾을 수 없습니다. ({search_warning})"
-                    else:
-                        logger.info("컨텍스트 없이 기본 응답 생성")
-                        answer = "죄송���니다. 관련 정보를 찾을 수 없습니다."
-                else:
-                    if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
-                        logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
-                        answer = "죄송합니다. 현재 LLM 서비스를 사용할 수 없습니다."
-                    else:
-                        # LLM 호출 시 검색 경고 처리 추가
-                        if search_warning:
-                            # 경고 메시지를 쿼리에 추가하는 대신 내부적으로 처리 (콘텐츠만 전달)
-                            logger.info(f"검색 경고 있음: {search_warning}")
-                            # 원래 쿼리만 사용
-                            modified_query = query
-                        else:
-                            modified_query = query
-                        
-                        try:
-                            answer = llm_interface.rag_generate(modified_query, context, llm_id=llm_id)
-                            logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
-                            
-                            # 검색 경고가 있을 경우, 응답 앞에 경고 메시지 추가 없이 그대로 반환
-                        except Exception as llm_err:
-                            logger.error(f"LLM 호출 중 오류: {llm_err}", exc_info=True)
-                            answer = f"죄송합니다. 응답 생성 중 오류가 발생했습니다: {str(llm_err)}"
-
-                # 소스 정보 추출
-                sources = []
-                if search_results:
-                    for result in search_results:
-                        if not isinstance(result, dict):
-                            logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
-                            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["name"] = os.path.basename(source_key)
-                            source_info["path"] = source_key
-                        else:
-                            source_info["name"] = "알 수 없는 소스"
-                        
-                        if "score" in result:
-                            source_info["score"] = result["score"]
-                        if "rerank_score" in result:
-                            source_info["rerank_score"] = result["rerank_score"]
-                            
-                        sources.append(source_info)
-
-                return jsonify({
-                    "answer": answer,
-                    "sources": sources,
-                    "search_warning": search_warning
-                })
-                
-            except Exception as e:
-                logger.error(f"LLM 응답 생성 중 오류 발생: {str(e)}", exc_info=True)
-                return jsonify({
-                    "answer": f"죄송합니다. 응답 생성 중 오류가 발생했습니다: {str(e)}",
-                    "sources": [],
-                    "error": str(e)
-                })
-                
-        except Exception as e:
-            logger.error(f"채팅 API에서 예상치 못한 오류 발생: {str(e)}", exc_info=True)
-            return jsonify({
-                "error": f"예상치 못한 오류 발생: {str(e)}",
-                "answer": "죄송합니다. 서버에서 오류가 발생했습니다.",
-                "sources": []
-            }), 500
-
-    # --- Voice Chat API ---
-    @app.route('/api/voice', methods=['POST'])
-    @login_required
-    def voice_chat():
-        """음성 챗 API 엔드포인트"""
-        # 함수 내에서는 전역 retriever 변수를 직접 사용하고 수정하지 않음
-        nonlocal retriever
-        
-        try:
-            # 앱이 준비되었는지 확인
-            is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
-            if not is_ready:
-                logger.warning("앱이 아직 초기화 중입니다.")
-                return jsonify({"error": "앱 초기화 중...", "answer": "죄송합니다. 시스템이 아직 준비 중입니다."}), 200  # 503 대신 200으로 변경
-            
-            # STT 클라이언트 확인
-            if stt_client is None or not hasattr(stt_client, 'transcribe_audio'):
-                logger.error("음성 API 요청 시 STT 클라이언트가 준비되지 않음")
-                return jsonify({"error": "음성 인식 서비스 준비 안됨"}), 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} ({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}")
-                    return jsonify({"error": "음성인식 실패", "details": error_msg}), 500
-                
-                transcription = stt_result.get("text", "")
-                if not transcription:
-                    logger.warning("음성인식 결과가 비어있습니다.")
-                    return jsonify({
-                        "transcription": "",
-                        "answer": "음성에서 텍스트를 인식하지 못했습니다.",
-                        "sources": []
-                    }), 200 # 200 OK와 메시지
-                
-                logger.info(f"음성인식 성공: {transcription[:50]}...")
-                
-                # --- RAG 및 LLM 호출 (Chat API와 동일 로직) ---
-                # 검색 엔진 처리 부분
-                search_results = []
-                search_warning = None
-                try:
-                    # retriever 상태 검증 - 여기서 retriever 변수를 수정하지 않도록 주의
-                    if retriever is None:
-                        logger.warning("Retriever가 초기화되지 않았습니다.")
-                        # 상태 기록만 하고 수정하지 않음
-                        search_warning = "검색 기능이 아직 준비되지 않았습니다."
-                    elif hasattr(retriever, 'is_mock') and retriever.is_mock:
-                        logger.info("Mock Retriever 사용 중 - 검색 결과 없음.")
-                        # 상태 기록만 하고 수정하지 않음
-                        search_warning = "검색 인덱스가 아직 구축 중입니다. 기본 응답만 제공됩니다."
-                    elif not hasattr(retriever, 'search'):
-                        logger.warning("Retriever에 search 메소드가 없습니다.")
-                        # 상태 기록만 하고 수정하지 않음
-                        search_warning = "검색 기능이 현재 제한되어 있습니다."
-                    else:
-                        try:
-                            logger.info(f"검색 수행: {transcription[:50]}...")
-                            # retriever가 유효하고 search 메소드가 있는 경우에만 검색 실행
-                            if retriever is not None and hasattr(retriever, 'search'):
-                                try:
-                                    search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
-                                except Exception as search_err:
-                                    logger.error(f"retriever.search() 호출 중 오류 발생: {search_err}", exc_info=True)
-                                    search_results = []
-                                    search_warning = f"검색 중 오류 발생: {str(search_err)}"
-                            else:
-                                logger.warning("검색을 실행할 수 없습니다: retriever가 None이거나 search 메소드가 없습니다.")
-                                search_results = []
-                                search_warning = "검색 기능이 현재 제한되어 있습니다."
-                            # except Exception as search_err:
-                            #     logger.error(f"retriever.search() 호출 중 오류 발생: {search_err}", exc_info=True)
-                            #     search_results = []
-                            #     search_warning = f"검색 중 오류 발생: {str(search_err)}"
-                            
-                            if not search_results:
-                                logger.info("검색 결과가 없습니다.")
-                            else:
-                                logger.info(f"검색 결과: {len(search_results)}개 항목")
-                        except Exception as e:
-                            logger.error(f"검색 처리 중 예상치 못한 오류: {e}", exc_info=True)
-                            search_results = []
-                            search_warning = f"검색 처리 중 오류 발생: {str(e)}"
-                except Exception as e:
-                    logger.error(f"검색 엔진 접근 중 오류 발생: {str(e)}", exc_info=True)
-                    search_results = []
-                    search_warning = f"검색 엔진 접근 중 오류 발생: {str(e)}"
-                
-                # LLM 응답 생성
-                context = ""
-                if search_results:
-                    if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
-                        logger.warning("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
-                    else:
-                        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
-                        logger.info(f"컨텍스트 준비 완료 (길이: {len(context) if context else 0}자)")
-                
-                # LLM 인터페이스 호출
-                llm_id = request.form.get('llm_id', None) # form 데이터에서 llm_id 가져오기
-                
-                if not context:
-                    if search_warning:
-                        logger.info(f"컨텍스트 없음, 검색 경고: {search_warning}")
-                        answer = f"죄송합니다. 질문에 대한 답변을 찾을 수 없습니다. ({search_warning})"
-                    else:
-                        logger.info("컨텍스트 없이 기본 응답 생성")
-                        answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
-                else:
-                    if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
-                        logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
-                        answer = "죄송합니다. 현재 LLM 서비스를 사용할 수 없습니다."
-                    else:
-                        # LLM 호출 시 검색 경고 처리 추가
-                        if search_warning:
-                            logger.info(f"검색 경고 있음: {search_warning}")
-                            # 원래 쿼리만 사용
-                            modified_query = transcription
-                        else:
-                            modified_query = transcription
-                        
-                        try:
-                            answer = llm_interface.rag_generate(modified_query, context, llm_id=llm_id)
-                            logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
-                        except Exception as llm_err:
-                            logger.error(f"LLM 호출 중 오류: {llm_err}", exc_info=True)
-                            answer = f"죄송합니다. 응답 생성 중 오류가 발생했습니다: {str(llm_err)}"
-                
-                # 소스 정보 추출
-                sources = []
-                if search_results:
-                    for result in search_results:
-                        if not isinstance(result, dict):
-                            logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
-                            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["name"] = os.path.basename(source_key)
-                            source_info["path"] = source_key
-                        else:
-                            source_info["name"] = "알 수 없는 소스"
-                        
-                        if "score" in result:
-                            source_info["score"] = result["score"]
-                        if "rerank_score" in result:
-                            source_info["rerank_score"] = result["rerank_score"]
-                        
-                        sources.append(source_info)
-                
-                # 최종 응답
-                response_data = {
-                    "transcription": transcription,
-                    "answer": answer,
-                    "sources": sources,
-                    "search_warning": search_warning
-                }
-                
-                # LLM 정보 추가 (옵션)
-                if hasattr(llm_interface, 'get_current_llm_details'):
-                    response_data["llm"] = llm_interface.get_current_llm_details()
-                
-                return jsonify(response_data)
-            
-            except Exception as e:
-                logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
-                return jsonify({
-                    "error": "음성 처리 중 내부 오류 발생", 
-                    "details": str(e),
-                    "answer": "죄송합니다. 오디오 처리 중 오류가 발생했습니다."
-                }), 500
-                
-        except Exception as e:
-            logger.error(f"음성 API에서 예상치 못한 오류 발생: {str(e)}", exc_info=True)
-            return jsonify({
-                "error": f"예상치 못한 오류 발생: {str(e)}",
-                "answer": "죄송합니다. 서버에서 오류가 발생했습니다."
-            }), 500
-
-    # --- 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
-
-        if 'document' not in request.files:
-            return jsonify({"error": "문서 파일이 제공되지 않았습니다."}), 400
-
-        doc_file = request.files['document']
-        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):
-            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']
-            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
-
-            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:
-                        content = f.read()
-                except UnicodeDecodeError:
-                    logger.info(f"UTF-8 디코딩 실패, CP949로 시도: {filename}")
-                    try:
-                        with open(filepath, 'r', encoding='cp949') as f:
-                            content = f.read()
-                    except Exception as e_cp949:
-                        logger.error(f"CP949 디코딩 실패 ({filename}): {e_cp949}")
-                        return jsonify({"error": "파일 인코딩을 읽을 수 없습니다 (UTF-8, CP949 시도 실패)."}), 400
-                except Exception as e_read:
-                    logger.error(f"파일 읽기 오류 ({filename}): {e_read}")
-                    return jsonify({"error": f"파일 읽기 중 오류 발생: {str(e_read)}"}), 500
-            elif file_ext == 'pdf':
-                 logger.warning("PDF 처리는 구현되지 않았습니다.")
-                 # 여기에 PDF 텍스트 추출 로직 추가 (예: PyPDF2 사용)
-                 # content = extract_text_from_pdf(filepath)
-            elif file_ext == 'docx':
-                 logger.warning("DOCX 처리는 구현되지 않았습니다.")
-                 # 여기에 DOCX 텍스트 추출 로직 추가 (예: python-docx 사용)
-                 # content = extract_text_from_docx(filepath)
-
-            # 문서 분할/처리
-            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 함수가 청크 분할 등을 수행한다고 가정
-                    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"검색기 상태를 저장합니다...")
-                # 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가 디렉토리라고 가정하고 부모 디렉토리 생성
-                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' 사용
-                    "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}")
-            return jsonify({"error": f"파일 업로드 중 오류: {str(e)}"}), 500
-
-    # --- Document List API ---
-    @app.route('/api/documents', methods=['GET'])
-    @login_required
-    def list_documents():
-        """지식베이스 문서 목록 API"""
-        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.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'}")
-
-        try:
-            sources = {}
-            total_chunks = 0
-            doc_list = doc_list_attr # 위에서 가져온 속성 사용
-
-            # doc_list가 리스트인지 확인
-            if not isinstance(doc_list, list):
-                 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
-
-                # 소스 정보 추출 (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")
-
-                if source != "unknown":
-                    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"]
-
-                        sources[source] = {
-                            "filename": filename,
-                            "chunks": 1,
-                            "filetype": filetype
-                        }
-                    total_chunks += 1
-                else:
-                     # 소스 정보가 없는 청크 로깅 (너무 많으면 주석 처리)
-                     logger.warning(f"청크 {i}에서 소스 정보를 찾을 수 없음: {str(doc)[:200]}...") # 내용 일부 로깅
-
-            # 최종 목록 생성 및 정렬
-            documents = [{"source": src, **info} for src, info in sources.items()]
-            documents.sort(key=lambda x: x.get("filename", ""), reverse=False) # 파일명 기준 오름차순 정렬
-
-            logger.info(f"문서 목록 조회 완료: {len(documents)}개 소스 파일, {total_chunks}개 청크")
-            return jsonify({
-                "documents": documents,
-                "total_documents": len(documents),
-                "total_chunks": total_chunks
-            })
-
-        except Exception as e:
-            logger.error(f"문서 목록 조회 중 심각한 오류 발생: {e}", exc_info=True)
-            # 503 대신 500 반환
-            return jsonify({"error": f"문서 목록 조회 중 오류: {str(e)}"}), 500

app/app_routes_improved.py

@@ -0,0 +1,156 @@
+"""
+RAG 검색 챗봇 웹 애플리케이션 - 개선된 API 라우트 정의
+"""
+
+import os
+import json
+import logging
+import tempfile
+import threading
+import time
+from flask import request, jsonify, render_template, send_from_directory, session, redirect, url_for
+from datetime import datetime
+from werkzeug.utils import secure_filename
+
+# 로거 가져오기
+logger = logging.getLogger(__name__)
+
+# 앱 시작 시간 기록
+APP_START_TIME = time.time()
+
+def register_routes(app, login_required, llm_interface, retriever, stt_client, 
+                   DocumentProcessor, base_retriever, app_ready_event, 
+                   init_success_event, initialization_error, ADMIN_USERNAME, 
+                   ADMIN_PASSWORD, DEVICE_SERVER_URL):
+    """
+    Flask 애플리케이션에 기본 라우트 등록 (개선된 버전)
+    """
+    # 헬퍼 함수 
+    def allowed_audio_file(filename):
+        """파일이 허용된 오디오 확장자를 가지는지 확인"""
+        ALLOWED_AUDIO_EXTENSIONS = {'mp3', 'wav', 'ogg', 'm4a'}
+        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_AUDIO_EXTENSIONS
+
+    def allowed_doc_file(filename):
+        """파일이 허용된 문서 확장자를 가지는지 확인"""
+        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
+        next_url = request.args.get('next')
+        logger.info(f"-------------- 로그인 페이지 접속 (Next: {next_url}) --------------")
+        
+        if request.method == 'POST':
+            logger.info("로그인 시도 받음")
+            username = request.form.get('username', '')
+            password = request.form.get('password', '')
+            
+            if username == ADMIN_USERNAME and password == ADMIN_PASSWORD:
+                logger.info(f"로그인 성공: {username}")
+                session.permanent = True
+                session['logged_in'] = True
+                session['username'] = username
+                redirect_to = next_url or url_for('index')
+                return redirect(redirect_to)
+            else:
+                logger.warning("로그인 실패: 아이디 또는 비밀번호 불일치")
+                error = '아이디 또는 비밀번호가 올바르지 않습니다.'
+        else: # GET 요청
+            if session.get('logged_in'):
+                logger.info("이미 로그인된 사용자, 메인 페이지로 리디렉션")
+                return redirect(url_for('index'))
+
+        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)
+        
+        return redirect(url_for('login'))
+
+    # --- 메인 페이지 및 상태 확인 ---
+    @app.route('/')
+    @login_required
+    def index():
+        """메인 페이지"""
+        # 앱이 준비되었는지 확인
+        is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
+        
+        if not is_ready:
+            logger.info("앱이 아직 준비되지 않아 로딩 페이지 표시")
+            return render_template('loading.html')
+
+        # 초기화는 완료되었지만 오류가 발생한 경우 오류 페이지 표시
+        is_success = init_success_event.is_set() if isinstance(init_success_event, threading.Event) else False
+        if not is_success and initialization_error:
+            logger.warning(f"초기화 실패로 오류 페이지 표시. 오류: {initialization_error}")
+            return render_template('error.html', 
+                                  error="RAG 검색기 초기화 중 오류가 발생했습니다.",
+                                  details=initialization_error)
+
+        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_success = init_success_event.is_set() if isinstance(init_success_event, threading.Event) else False
+        
+        # 검색기 상태 확인
+        retriever_type = type(retriever).__name__ if retriever else "None"
+        is_mock_retriever = hasattr(retriever, 'is_mock') and retriever.is_mock if retriever else False
+        
+        # 데이터 수 확인
+        doc_count = 0
+        if base_retriever and hasattr(base_retriever, 'documents'):
+            doc_count = len(base_retriever.documents)
+        
+        status_data = {
+            "ready": is_ready,
+            "success": is_success,
+            "error": initialization_error if initialization_error else None, 
+            "retriever_type": retriever_type,
+            "is_mock_retriever": is_mock_retriever,
+            "document_count": doc_count,
+            "uptime_seconds": time.time() - APP_START_TIME
+        }
+        
+        return jsonify(status_data)
+
+    # --- 나머지 API 엔드포인트들 ---
+    # 기존의 app_routes_after.py에서 가져온 엔드포인트들로 여기에 통합
+    # (chat, voice_chat, document 관련 API 등)
+    
+    # LLM API와 Chat API는 chat_routes.py 파일로 분리
+    # Document Upload/List API는 document_routes.py 파일로 분리
+    # Voice API는 voice_routes.py 파일로 분리
+
+    # 기본 라우트만 여기서 처리하고 나머지는 분리된 파일에서 임포트
+    from app.chat_routes import register_chat_routes
+    from app.document_routes import register_document_routes
+    from app.voice_routes import register_voice_routes
+    
+    # 각 서브모듈의 라우트 등록
+    register_chat_routes(app, login_required, llm_interface, retriever, DocumentProcessor,
+                        app_ready_event, init_success_event, initialization_error)
+    
+    register_document_routes(app, login_required, base_retriever, retriever, DocumentProcessor,
+                           app_ready_event, init_success_event, initialization_error)
+    
+    register_voice_routes(app, login_required, llm_interface, retriever, stt_client, DocumentProcessor,
+                         app_ready_event, init_success_event, initialization_error)
+    
+    # --- 정적 파일 서빙 ---
+    @app.route('/static/<path:path>')
+    def send_static(path):
+        static_folder = app.config.get('STATIC_FOLDER', 'static')
+        return send_from_directory(static_folder, path)
+    
+    return app  # 설정이 완료된 앱 반환

app/background_init.py

@@ -0,0 +1,113 @@
+"""
+RAG 검색 챗봇 - 백그라운드 초기화 모듈
+"""
+
+import time
+import logging
+
+# 로거 가져오기
+logger = logging.getLogger(__name__)
+
+def background_init(app, llm_interface, stt_client, base_retriever, retriever, 
+                   app_ready_event, init_success_event, MockComponent, initialization_error=None):
+    """
+    백그라운드에서 검색기 및 기타 컴포넌트 초기화 수행
+    
+    Args:
+        app: Flask 앱 객체
+        llm_interface: LLM 인터페이스 참조
+        stt_client: STT 클라이언트 참조
+        base_retriever: 기본 검색기 참조
+        retriever: 재순위화 검색기 참조
+        app_ready_event: 앱 준비 완료 이벤트 (threading.Event)
+        init_success_event: 초기화 성공 이벤트 (threading.Event)
+        MockComponent: Mock 클래스
+        initialization_error: 초기화 오류 정보 저장용 변수
+    """
+    from app.init_retriever_improved import init_retriever
+
+    logger.info("백그라운드 초기화 시작...")
+    start_init_time = time.time()
+    
+    # 전역 변수 참조 - 이 함수 내에서 업데이트된 값을 호출자에게 반환하기 위해 사용
+    # nonlocal 키워드는 함수 외부에서는 사용할 수 없으므로 리턴 값으로 처리
+    updated_base_retriever = base_retriever
+    updated_retriever = retriever
+    error_message = None if initialization_error is None else initialization_error
+    
+    try:
+        # 1. LLM, STT 인터페이스 재확인 및 초기화
+        if llm_interface is None or hasattr(llm_interface, 'is_mock') and llm_interface.is_mock:
+            logger.warning("LLM 인터페이스가 초기화되지 않았거나 Mock 객체입니다.")
+            # 필요 시 여기서 다시 초기화 시도 가능
+
+        if stt_client is None or hasattr(stt_client, 'is_mock') and stt_client.is_mock:
+            logger.warning("STT 클라이언트가 초기화되지 않았거나 Mock 객체입니다.")
+            # 필요 시 여기서 다시 초기화 시도 가능
+            
+        # 2. 검색기 초기화 (개선된 버전 사용)
+        logger.info("개선된 검색기 초기화 함수 호출...")
+        base_retriever_new, retriever_new, success, error_msg = init_retriever(
+            app=app,
+            base_retriever=updated_base_retriever,
+            retriever=updated_retriever,
+            MockComponent=MockComponent,
+            initialization_error=error_message
+        )
+        
+        # 지역 변수에 업데이트된 값 저장
+        updated_base_retriever = base_retriever_new
+        updated_retriever = retriever_new
+        
+        # 초기화 결과에 따른 처리
+        if success:
+            logger.info("검색기 초기화 성공")
+            init_success_event.set()  # 성공 이벤트 설정
+            
+            # 검색기가 Mock이 아닌지 추가 확인
+            if not isinstance(updated_retriever, MockComponent) and not isinstance(updated_base_retriever, MockComponent):
+                logger.info("실제 검색기(non-Mock) 초기화 완료")
+            else:
+                # Mock인 경우 경고 로그 남기고 오류 메시지 설정
+                logger.warning("Mock 검색기를 사용합니다. 일부 기능이 제한될 수 있습니다.")
+                error_message = "검색기 초기화는 완료되었으나 Mock 객체를 사용 중입니다."
+        else:
+            logger.error(f"검색기 초기화 실패: {error_msg}")
+            error_message = error_msg
+        
+        # 중요: 성공 여부와 관계없이 app_ready_event 설정
+        # 이렇게 하면 앱은 어떤 상태이든 로딩 화면에서 벗어남
+        app_ready_event.set()
+        logger.info("app_ready_event가 설정됨 (앱이 준비 완료 상태로 전환)")
+            
+    except Exception as e:
+        logger.error(f"백그라운드 초기화 중 심각한 오류 발생: {e}", exc_info=True)
+        
+        # 오류 발생 시 Mock 객체 할당
+        if updated_base_retriever is None: 
+            updated_base_retriever = MockComponent()
+        
+        if updated_retriever is None: 
+            updated_retriever = MockComponent()
+        
+        # 오류 메시지 설정
+        error_message = f"백그라운드 초기화 중 오류: {str(e)}"
+        
+        # 앱은 여전히 사용 가능하도록 ready 이벤트 설정
+        app_ready_event.set()
+        logger.warning("초기화 오류가 발생했지만 app_ready_event를 설정하여 앱을 사용 가능 상태로 만듭니다.")
+    
+    finally:
+        # 초기화 완료 시간 기록
+        end_init_time = time.time()
+        logger.info(f"백그라운드 초기화 완료. 소요 시간: {end_init_time - start_init_time:.2f}초")
+        
+        # 최종 상태 기록
+        logger.info(f"앱 준비 상태: {app_ready_event.is_set()}")
+        logger.info(f"초기화 성공 상태: {init_success_event.is_set()}")
+        
+        if error_message:
+            logger.error(f"초기화 오류 메시지: {error_message}")
+        
+        # 업데이트된 객체와 오류 메시지 반환
+        return updated_base_retriever, updated_retriever, error_message

app/chat_routes.py

@@ -0,0 +1,223 @@
+"""
+RAG 검색 챗봇 - 채팅 관련 API 라우트
+"""
+
+import os
+import logging
+import threading
+from flask import request, jsonify
+
+# 로거 가져오기
+logger = logging.getLogger(__name__)
+
+def register_chat_routes(app, login_required, llm_interface, retriever, DocumentProcessor,
+                        app_ready_event, init_success_event, initialization_error):
+    """
+    채팅 관련 API 라우트 등록
+    """
+    
+    # --- LLM API ---
+    @app.route('/api/llm', methods=['GET', 'POST'])
+    @login_required
+    def llm_api():
+        """사용 가능한 LLM 목록 및 선택 API"""
+        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
+
+                current_details = llm_interface.get_current_llm_details()
+                supported_llms_dict = llm_interface.SUPPORTED_LLMS
+                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}", exc_info=True)
+                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:
+                 return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+
+            data = request.get_json()
+            if not data or 'llm_id' not in data:
+                return jsonify({"error": "LLM ID가 제공되지 않았습니다."}), 400
+
+            llm_id = data['llm_id']
+            logger.info(f"LLM 변경 요청: {llm_id}")
+
+            try:
+                if llm_interface is None or not hasattr(llm_interface, 'set_llm'):
+                     logger.error("LLM 인터페이스가 준비되지 않았거나 필요한 메소드가 없습니다.")
+                     return jsonify({"error": "LLM 인터페이스 오류"}), 500
+
+                if hasattr(llm_interface, 'llm_clients') and 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:
+                    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
+
+    # --- Chat API ---
+    @app.route('/api/chat', methods=['POST'])
+    @login_required
+    def chat():
+        """텍스트 기반 챗봇 API"""
+        try:
+            # 앱이 준비되었는지 확인
+            is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
+            if not is_ready:
+                logger.warning("앱이 아직 초기화 중입니다.")
+                return jsonify({
+                    "error": "앱 초기화 중...", 
+                    "answer": "죄송합니다. 시스템이 아직 준비 중입니다.", 
+                    "sources": []
+                }), 200  # 사용자에게 알림 메시지
+
+            # 초기화 성공 여부 확인
+            is_success = init_success_event.is_set() if isinstance(init_success_event, threading.Event) else False
+            if not is_success and initialization_error:
+                logger.warning(f"초기화 실패 상태에서 API 요청: {initialization_error}")
+                return jsonify({
+                    "error": "검색기 초기화 실패", 
+                    "answer": f"죄송합니다. 검색 시스템 초기화에 실패했습니다. 관리자에게 문의하세요. (오류: {initialization_error})", 
+                    "sources": []
+                }), 200
+
+            data = request.get_json()
+            if not data or 'query' not in data:
+                return jsonify({"error": "쿼리가 제공되지 않았습니다."}), 400
+
+            query = data['query']
+            logger.info(f"텍스트 쿼리 수신: {query[:100]}...")
+            
+            # 검색 처리
+            search_results = []
+            search_warning = None
+            
+            # 검색기 상태 확인 및 검색 수행
+            if retriever is None:
+                logger.warning("Retriever가 초기화되지 않았습니다.")
+                search_warning = "검색 기능이 아직 준비되지 않았습니다."
+            elif hasattr(retriever, 'is_mock') and retriever.is_mock:
+                logger.info("Mock Retriever 사용 중 - 검색 결과 없음.")
+                search_warning = "검색 인덱스가 아직 구축 중입니다. 기본 응답만 제공됩니다."
+            elif not hasattr(retriever, 'search'):
+                logger.warning("Retriever에 search 메소드가 없습니다.")
+                search_warning = "검색 기능이 현재 제한되어 있습니다."
+            else:
+                try:
+                    logger.info(f"검색 수행: {query[:50]}...")
+                    search_results = retriever.search(query, top_k=5, first_stage_k=6)
+                    
+                    if not search_results:
+                        logger.info("검색 결과가 없습니다.")
+                    else:
+                        logger.info(f"검색 결과: {len(search_results)}개 항목")
+                except Exception as e:
+                    logger.error(f"검색 처리 중 오류: {e}", exc_info=True)
+                    search_results = []
+                    search_warning = f"검색 중 오류 발생: {str(e)}"
+            
+            # LLM 응답 생성
+            try:
+                # 컨텍스트 준비
+                context = ""
+                if search_results:
+                    if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
+                        logger.warning("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
+                    else:
+                        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+                        logger.info(f"컨텍스트 준비 완료 (길이: {len(context) if context else 0}자)")
+
+                # LLM 인터페이스 사용
+                llm_id = data.get('llm_id', None)
+                
+                if not context:
+                    if search_warning:
+                        logger.info(f"컨텍스트 없음, 검색 경고: {search_warning}")
+                        answer = f"죄송합니다. 질문에 대한 답변을 찾을 수 없습니다. ({search_warning})"
+                    else:
+                        logger.info("컨텍스트 없이 기본 응답 생성")
+                        answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+                else:
+                    if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
+                        logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
+                        answer = "죄송합니다. 현재 LLM 서비스를 사용할 수 없습니다."
+                    else:
+                        try:
+                            # LLM을 통한 응답 생성
+                            answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
+                            logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+                        except Exception as llm_err:
+                            logger.error(f"LLM 호출 중 오류: {llm_err}", exc_info=True)
+                            answer = f"죄송합니다. 응답 생성 중 오류가 발생했습니다: {str(llm_err)}"
+
+                # 소스 정보 추출
+                sources = []
+                if search_results:
+                    for result in search_results:
+                        if not isinstance(result, dict):
+                            logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
+                            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["name"] = os.path.basename(source_key)
+                            source_info["path"] = source_key
+                        else:
+                            source_info["name"] = "알 수 없는 소스"
+                        
+                        if "score" in result:
+                            source_info["score"] = result["score"]
+                        if "rerank_score" in result:
+                            source_info["rerank_score"] = result["rerank_score"]
+                            
+                        sources.append(source_info)
+
+                return jsonify({
+                    "answer": answer,
+                    "sources": sources,
+                    "search_warning": search_warning
+                })
+                
+            except Exception as e:
+                logger.error(f"LLM 응답 생성 중 오류 발생: {str(e)}", exc_info=True)
+                return jsonify({
+                    "answer": f"죄송합니다. 응답 생성 중 오류가 발생했습니다: {str(e)}",
+                    "sources": [],
+                    "error": str(e)
+                })
+                
+        except Exception as e:
+            logger.error(f"채팅 API에서 예상치 못한 오류 발생: {str(e)}", exc_info=True)
+            return jsonify({
+                "error": f"예상치 못한 오류 발생: {str(e)}",
+                "answer": "죄송합니다. 서버에서 오류가 발생했습니다.",
+                "sources": []
+            }), 500

app/init_retriever.py

@@ -1,149 +0,0 @@
-"""
-RAG 검색 챗봇 - 검색기 초기화 모듈
-"""
-
-import os
-import logging
-import pickle
-import gzip
-from datetime import datetime
-
-# 로거 가져오기
-logger = logging.getLogger(__name__)
-
-def save_embeddings(base_retriever, file_path):
-    """임베딩 데이터를 압축하여 파일에 저장"""
-    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):
-    """저장된 임베딩 데이터를 파일에서 로드"""
-    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
-
-def init_retriever(app, base_retriever, retriever, ReRanker):
-    """검색기 객체 초기화 또는 로드"""
-    from utils.document_processor import DocumentProcessor
-    from retrieval.vector_retriever import VectorRetriever
-    
-    # 임베딩 캐시 파일 경로
-    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")):
-            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("기존 인덱스를 찾을 수 없어 새 검색기를 초기화합니다...")
-            base_retriever = VectorRetriever()
-
-        # 데이터 폴더의 문서 로드
-        data_path = app.config['DATA_FOLDER']
-        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"],
-                    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}")
-
-    # 재순위화 검색기 초기화
-    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,
-            rerank_field="text"
-        )
-        logger.info("재순위화 검색기 초기화 완료")
-    except Exception as e:
-        logger.error(f"재순위화 검색기 초기화 실패: {e}")
-        retriever = base_retriever # 실패 시 기본 검색기 사용
-
-    return retriever

app/init_retriever_improved.py

@@ -0,0 +1,218 @@
+"""
+RAG 검색 챗봇 - 개선된 검색기 초기화 모듈
+"""
+
+import os
+import logging
+import pickle
+import gzip
+from datetime import datetime
+
+# 로거 가져오기
+logger = logging.getLogger(__name__)
+
+def init_retriever(app, base_retriever=None, retriever=None, MockComponent=None, initialization_error=None):
+    """
+    검색기 객체 초기화 또는 로드 - 개선된 버전
+    
+    Args:
+        app: Flask 앱 객체 (설정값 가져오기용)
+        base_retriever: 기존 기본 검색기 객체 (None인 경우 새로 생성)
+        retriever: 기존 재순위화 검색기 객체 (None인 경우 새로 생성)
+        MockComponent: 모듈 로드 실패 시 사용할 Mock 클래스
+        initialization_error: 초기화 오류 정보를 저장할 변수 참조
+        
+    Returns:
+        tuple: (base_retriever, retriever, success, error_message)
+    """
+    try:
+        # 필요한 모듈 임포트
+        from utils.document_processor import DocumentProcessor
+        from retrieval.vector_retriever import VectorRetriever
+        from retrieval.reranker import ReRanker
+        
+        index_path = app.config['INDEX_PATH']
+        data_path = app.config['DATA_FOLDER']
+        
+        logger.info("=== 검색기 초기화 시작 ===")
+        logger.info(f"인덱스 경로: {index_path}")
+        logger.info(f"데이터 경로: {data_path}")
+        
+        # 경로 접근 가능 여부 확인
+        if not os.path.exists(index_path):
+            logger.warning(f"인덱스 경로({index_path})가 존재하지 않습니다. 생성을 시도합니다.")
+            try:
+                os.makedirs(index_path, exist_ok=True)
+                logger.info(f"인덱스 경로({index_path}) 생성 성공")
+            except Exception as e:
+                error_msg = f"인덱스 디렉토리 생성 실패: {str(e)}"
+                logger.error(error_msg)
+                return None, None, False, error_msg
+        
+        if not os.path.exists(data_path):
+            logger.warning(f"데이터 경로({data_path})가 존재하지 않습니다. 생성을 시도합니다.")
+            try:
+                os.makedirs(data_path, exist_ok=True)
+                logger.info(f"데이터 경로({data_path}) 생성 성공")
+            except Exception as e:
+                error_msg = f"데이터 디렉토리 생성 실패: {str(e)}"
+                logger.error(error_msg)
+                return None, None, False, error_msg
+        
+        # 1. 기본 검색기(VectorRetriever) 로드 또는 초기화
+        logger.info("기본 검색기(VectorRetriever) 초기화/로드 시도...")
+        
+        # 저장된 인덱스 파일 확인
+        docs_json_path = os.path.join(index_path, "documents.json")
+        index_exists = os.path.exists(docs_json_path)
+        logger.info(f"인덱스 파일 존재 여부: {index_exists} (경로: {docs_json_path})")
+        
+        # 기존 인덱스 로드 또는 새 검색기 초기화
+        if base_retriever is None:  # 기존 검색기가 없는 경우에만 시도
+            try:
+                if index_exists:
+                    logger.info(f"기존 인덱스 파일에서 검색기 로드 시도...")
+                    base_retriever = VectorRetriever.load(index_path)
+                    docs_count = len(getattr(base_retriever, 'documents', []))
+                    logger.info(f"인덱스 로드 성공. 문서 {docs_count}개 로드됨")
+                else:
+                    logger.info("인덱스 파일이 없어 새 VectorRetriever 초기화...")
+                    base_retriever = VectorRetriever()
+                    logger.info("새 VectorRetriever 초기화 성공")
+            except Exception as e:
+                error_msg = f"VectorRetriever 초기화/로드 실패: {str(e)}"
+                logger.error(error_msg, exc_info=True)
+                # 실패 시 MockComponent 반환을 준비하되, 바로 반환하지 않고 계속 진행
+                if MockComponent:
+                    base_retriever = MockComponent()
+                    logger.warning("MockComponent를 base_retriever로 사용합니다.")
+        else:
+            logger.info(f"기존 검색기 사용 (base_retriever가 이미 초기화됨)")
+            
+        # 2. 데이터 폴더 문서 로드 (기본 검색기가 비어있을 때)
+        if not isinstance(base_retriever, MockComponent):  # Mock이 아닌 경우에만 시도
+            needs_loading = not hasattr(base_retriever, 'documents') or not getattr(base_retriever, 'documents', [])
+            
+            if needs_loading and os.path.exists(data_path):
+                logger.info(f"검색기가 비어있어 {data_path}에서 문서 로드 시도...")
+                try:
+                    # DocumentProcessor 메소드 존재 여부 확인
+                    if hasattr(DocumentProcessor, 'load_documents_from_directory'):
+                        docs = DocumentProcessor.load_documents_from_directory(
+                            directory=data_path,
+                            extensions=[".txt", ".md", ".csv"],
+                            recursive=True
+                        )
+                        
+                        if docs:
+                            logger.info(f"{len(docs)}개 문서 로드 성공")
+                            
+                            # 검색기에 문서 추가
+                            if 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)
+                                        # 저장 실패는 치명적 오류가 아니므로 계속 진행
+                            else:
+                                logger.warning("base_retriever에 add_documents 메소드가 없습니다")
+                        else:
+                            logger.info(f"{data_path}에서 로드할 문서가 없습니다")
+                    else:
+                        logger.warning("DocumentProcessor에 load_documents_from_directory 메소드가 없습니다")
+                except Exception as e_load:
+                    logger.error(f"문서 로드/추가 중 오류: {e_load}", exc_info=True)
+                    # 문서 로드 실패는 치명적 오류가 아니므로 계속 진행
+        
+        # 3. 재순위화 검색기(ReRanker) 초기화
+        logger.info("재순위화 검색기(ReRanker) 초기화 시도...")
+        
+        if retriever is None:  # 기존 retriever가 없는 경우에만 시도
+            try:
+                # custom_rerank_fn 함수 정의
+                def custom_rerank_fn(query, results):
+                    """쿼리 용어 빈도에 기반한 재순위화 함수"""
+                    logger.debug(f"재순위화 함수 호출됨: 쿼리='{query}', 결과 수={len(results)}")
+                    
+                    # 빈 결과 처리
+                    if not results:
+                        logger.debug("재순위화할 결과가 없습니다")
+                        return 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):
+                            # text 필드가 없는 경우 원래 점수 사용
+                            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)
+                    logger.debug(f"재순위화 완료: 상위 점수={results[0].get('rerank_score', 0) if results else 'N/A'}")
+                    return results
+                
+                # base_retriever가 유효한지 확인
+                if base_retriever is None or isinstance(base_retriever, MockComponent):
+                    raise ValueError("유효한 base_retriever가 없어 ReRanker를 초기화할 수 없습니다")
+                
+                # ReRanker 초기화
+                retriever = ReRanker(
+                    base_retriever=base_retriever,
+                    rerank_fn=custom_rerank_fn,
+                    rerank_field="text"
+                )
+                logger.info("재순위화 검색기(ReRanker) 초기화 성공")
+            except Exception as e_rerank:
+                logger.error(f"재순위화 검색기 초기화 실패: {e_rerank}", exc_info=True)
+                
+                # 실패 시 기본 검색기로 fallback
+                if not isinstance(base_retriever, MockComponent):
+                    logger.warning("fallback: 재순위화 실패, 기본 검색기를 retriever로 사용")
+                    retriever = base_retriever
+                else:
+                    if MockComponent:
+                        logger.warning("MockComponent를 retriever로 사용합니다")
+                        retriever = MockComponent()
+        else:
+            logger.info(f"기존 retriever 사용 (이미 초기화됨)")
+        
+        # 최종 상태 확인
+        if retriever is None or isinstance(retriever, MockComponent):
+            if base_retriever is None or isinstance(base_retriever, MockComponent):
+                error_msg = "검색기 초기화 실패: base_retriever와 retriever 모두 초기화 실패"
+                logger.error(error_msg)
+                return base_retriever, retriever, False, error_msg
+            else:
+                # base_retriever가 유효하면 retriever로 설정
+                retriever = base_retriever
+                logger.warning("retriever 초기화 실패, base_retriever를 retriever로 사용")
+        
+        logger.info("=== 검색기 초기화 성공적으로 완료 ===")
+        return base_retriever, retriever, True, None
+        
+    except Exception as e:
+        error_msg = f"검색기 초기화 중 예상치 못한 오류 발생: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        
+        # 완전히 실패한 경우 MockComponent 반환
+        if MockComponent:
+            base_retriever = MockComponent()
+            retriever = MockComponent()
+            
+        return base_retriever, retriever, False, error_msg

app/static/css/device-style.css

@@ -11,6 +11,128 @@
     padding: 20px;
 }
 
+/* 서버 설정 섹션 스타일 */
+.server-settings-section {
+    margin-bottom: 25px;
+    padding-bottom: 15px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.server-settings-section h2 {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 15px;
+    color: var(--primary-color);
+}
+
+.toggle-button {
+    background: none;
+    border: none;
+    color: var(--primary-color);
+    cursor: pointer;
+    font-size: 18px;
+    padding: 5px;
+    transition: transform 0.3s ease;
+}
+
+.toggle-button:hover {
+    transform: rotate(90deg);
+}
+
+.server-settings-panel {
+    background-color: #f8f9fa;
+    border-radius: 6px;
+    padding: 15px;
+    margin-bottom: 15px;
+    border: 1px solid var(--border-color);
+    transition: max-height 0.3s ease, opacity 0.3s ease, padding 0.3s ease;
+}
+
+.server-settings-panel.closed {
+    max-height: 0;
+    padding: 0 15px;
+    opacity: 0;
+    overflow: hidden;
+    margin: 0;
+}
+
+.settings-row {
+    margin-bottom: 12px;
+}
+
+.settings-row label {
+    display: block;
+    margin-bottom: 5px;
+    font-weight: 500;
+    font-size: 14px;
+}
+
+.input-with-button {
+    display: flex;
+    gap: 8px;
+}
+
+#serverUrlInput {
+    flex-grow: 1;
+    padding: 8px 12px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-size: 14px;
+}
+
+.save-button {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    padding: 8px 15px;
+    cursor: pointer;
+    font-size: 14px;
+    transition: background-color 0.2s;
+}
+
+.save-button:hover {
+    background-color: var(--primary-dark);
+}
+
+.connection-status {
+    margin-top: 10px;
+    padding: 8px;
+    border-radius: 4px;
+    font-size: 14px;
+    font-weight: 500;
+}
+
+.connection-status.connected {
+    color: var(--success-color);
+    background-color: rgba(16, 185, 129, 0.1);
+}
+
+.connection-status.error {
+    color: var(--error-color);
+    background-color: rgba(239, 68, 68, 0.1);
+}
+
+.connection-status.pending {
+    color: var(--secondary-color);
+    background-color: rgba(245, 158, 11, 0.1);
+}
+
+.server-hint {
+    margin-top: 10px;
+    font-size: 13px;
+    color: var(--light-text);
+    display: flex;
+    align-items: flex-start;
+    gap: 5px;
+}
+
+.server-hint i {
+    margin-top: 3px;
+    color: var(--secondary-color);
+}
+
 /* 서버 상태 표시 */
 .server-status {
     padding: 12px 15px;
@@ -293,6 +415,64 @@
     margin-right: 5px;
 }
 
+/* 알림 메시지 */
+.notification {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    background-color: white;
+    border-radius: 6px;
+    padding: 15px 20px 15px 15px;
+    box-shadow: 0 3px 10px rgba(0, 0, 0, 0.2);
+    min-width: 250px;
+    max-width: 350px;
+    z-index: 1000;
+    animation: slideIn 0.3s ease-out;
+    border-left: 4px solid var(--primary-color);
+}
+
+.notification.success {
+    border-left-color: var(--success-color);
+}
+
+.notification.error {
+    border-left-color: var(--error-color);
+}
+
+.notification.info {
+    border-left-color: var(--primary-color);
+}
+
+.notification.warning {
+    border-left-color: var(--secondary-color);
+}
+
+.notification-close {
+    position: absolute;
+    top: 5px;
+    right: 5px;
+    background: none;
+    border: none;
+    font-size: 16px;
+    cursor: pointer;
+    color: #888;
+}
+
+.notification-close:hover {
+    color: #333;
+}
+
+@keyframes slideIn {
+    from {
+        transform: translateX(100%);
+        opacity: 0;
+    }
+    to {
+        transform: translateX(0);
+        opacity: 1;
+    }
+}
+
 /* 반응형 */
 @media (max-width: 768px) {
     .device-details {
@@ -303,4 +483,20 @@
         flex-direction: column;
         gap: 10px;
     }
+    
+    .server-settings-panel {
+        padding: 10px;
+    }
+    
+    .input-with-button {
+        flex-direction: column;
+    }
+    
+    #serverUrlInput {
+        width: 100%;
+    }
+    
+    .save-button {
+        width: 100%;
+    }
 }

app/static/js/app-device.js

@@ -18,10 +18,13 @@ const loadProgramsButton = document.getElementById('loadProgramsButton');
 const programsLoading = document.getElementById('programsLoading');
 const programsList = document.getElementById('programsList');
 const noProgramsMessage = document.getElementById('noProgramsMessage');
+const serverUrlInput = document.getElementById('serverUrlInput'); // 서버 URL 입력
+const saveServerUrlButton = document.getElementById('saveServerUrlButton'); // 서버 URL 저장 버튼
+const connectionStatus = document.getElementById('connectionStatus'); // 연결 상태 표시
 
 // 장치 서버 URL 설정
-// 직접 접근 설정: 빈 문자열이면 현재 호스트의 5050 포트를 사용
-let DEVICE_SERVER_URL = ''; // 서버에서 전달된 URL이 있으면 초기화 시 설정됨
+// 로컬스토리지에서 서버 URL 로드 또는 기본값 사용
+let DEVICE_SERVER_URL = localStorage.getItem('device_server_url') || ''; 
 
 /**
  * 장치 서버 API 경로 생성 함수
@@ -43,34 +46,97 @@ function getDeviceApiUrl(endpoint) {
  */
 function initDeviceServerSettings() {
     console.log("장치 서버 설정 초기화 시작");
-    // 서버 URL 설정 (웹 서버로부터 설정 불러오기)
-    fetch('/api/device/settings')
-        .then(response => {
-            if (!response.ok) {
-                throw new Error('설정을 가져올 수 없습니다');
-            }
-            return response.json();
-        })
-        .then(data => {
-            if (data.server_url) {
-                console.log(`장치 서버 URL 설정됨: ${data.server_url}`);
-                DEVICE_SERVER_URL = data.server_url;
-            } else {
-                // 설정 없음 - 자동 생성 (현재 호스트 + 포트 5050)
-                const currentHost = window.location.hostname;
-                const protocol = window.location.protocol;
-                DEVICE_SERVER_URL = `${protocol}//${currentHost}:5051`;
-                console.log(`장치 서버 URL 자동 설정: ${DEVICE_SERVER_URL}`);
-            }
-        })
-        .catch(error => {
-            console.error('장치 서버 설정 초기화 오류:', error);
-            // 기본값으로 설정 (현재 호스트 + 포트 5051)
-            const currentHost = window.location.hostname;
-            const protocol = window.location.protocol;
-            DEVICE_SERVER_URL = `${protocol}//${currentHost}:5051`;
-            console.log(`장치 서버 URL 기본값 설정: ${DEVICE_SERVER_URL}`);
+    
+    // 로컬스토리지에서 URL 로드
+    const savedUrl = localStorage.getItem('device_server_url');
+    
+    if (savedUrl) {
+        // 저장된 URL이 있으면 사용
+        console.log(`저장된 장치 서버 URL 로드: ${savedUrl}`);
+        DEVICE_SERVER_URL = savedUrl;
+        if (serverUrlInput) {
+            serverUrlInput.value = savedUrl;
+        }
+    } else {
+        // 설정 없음 - 자동 생성 (현재 호스트 + 포트 8000)
+        const currentHost = window.location.hostname;
+        const protocol = window.location.protocol;
+        const defaultUrl = `${protocol}//${currentHost}:8000`;
+        DEVICE_SERVER_URL = defaultUrl;
+        console.log(`장치 서버 URL 자동 설정: ${DEVICE_SERVER_URL}`);
+        
+        if (serverUrlInput) {
+            serverUrlInput.value = defaultUrl;
+        }
+        
+        // 자동 생성된 URL 저장
+        localStorage.setItem('device_server_url', defaultUrl);
+    }
+    
+    // 서버 연결 상태 초기 확인
+    updateConnectionStatus();
+}
+
+/**
+ * 서버 URL 저장 함수
+ */
+function saveServerUrl() {
+    if (!serverUrlInput) return;
+    
+    const newUrl = serverUrlInput.value.trim();
+    
+    if (!newUrl) {
+        showNotification('서버 URL을 입력해주세요.', 'error');
+        return;
+    }
+    
+    try {
+        // URL 유효성 검사
+        new URL(newUrl);
+        
+        // 로컬스토리지에 저장
+        localStorage.setItem('device_server_url', newUrl);
+        DEVICE_SERVER_URL = newUrl;
+        console.log(`장치 서버 URL 변경됨: ${newUrl}`);
+        
+        // 알림 표시
+        showNotification('서버 URL이 저장되었습니다.', 'success');
+        
+        // 연결 상태 업데이트
+        updateConnectionStatus();
+    } catch (error) {
+        console.error(`URL 유효성 검사 실패: ${error}`);
+        showNotification('유효한 URL 형식이 아닙니다.', 'error');
+    }
+}
+
+/**
+ * 서버 연결 상태 업데이트 함수
+ */
+async function updateConnectionStatus() {
+    if (!connectionStatus) return;
+    
+    connectionStatus.textContent = '연결 상태: 확인 중...';
+    connectionStatus.className = 'connection-status pending';
+    
+    try {
+        const response = await fetch(getDeviceApiUrl('/api/status'), {
+            signal: AbortSignal.timeout(3000) // 3초 타임아웃
         });
+        
+        if (response.ok) {
+            const data = await response.json();
+            connectionStatus.textContent = '연결 상태: 연결됨 ✓';
+            connectionStatus.className = 'connection-status connected';
+        } else {
+            connectionStatus.textContent = '연결 상태: 연결 실패 (응답 오류) ✗';
+            connectionStatus.className = 'connection-status error';
+        }
+    } catch (error) {
+        console.error(`서버 연결 확인 실패: ${error}`);
+        connectionStatus.textContent = '연결 상태: 연결 실패 ✗';
+        connectionStatus.className = 'connection-status error';
+    }
 }
 
 // 페이지 로드 시 초기화
@@ -89,22 +155,57 @@ document.addEventListener('DOMContentLoaded', () => {
     }
     
     // 장치 상태 확인 버튼 이벤트 리스너
-    checkDeviceStatusButton.addEventListener('click', () => {
-        console.log("장치 상태 확인 버튼 클릭");
-        checkDeviceStatus();
-    });
+    if (checkDeviceStatusButton) {
+        checkDeviceStatusButton.addEventListener('click', () => {
+            console.log("장치 상태 확인 버튼 클릭");
+            checkDeviceStatus();
+        });
+    }
     
     // 장치 목록 새로고침 버튼 이벤트 리스너
-    refreshDevicesButton.addEventListener('click', () => {
-        console.log("장치 목록 새로고침 버튼 클릭");
-        loadDevices();
-    });
+    if (refreshDevicesButton) {
+        refreshDevicesButton.addEventListener('click', () => {
+            console.log("장치 목록 새로고침 버튼 클릭");
+            loadDevices();
+        });
+    }
     
     // 프로그램 목록 로드 버튼 이벤트 리스너
-    loadProgramsButton.addEventListener('click', () => {
-        console.log("프로그램 목록 로드 버튼 클릭");
-        loadPrograms();
-    });
+    if (loadProgramsButton) {
+        loadProgramsButton.addEventListener('click', () => {
+            console.log("프로그램 목록 로드 버튼 클릭");
+            loadPrograms();
+        });
+    }
+    
+    // 서버 URL 저장 버튼 이벤트 리스너
+    if (saveServerUrlButton) {
+        saveServerUrlButton.addEventListener('click', () => {
+            console.log("서버 URL 저장 버튼 클릭");
+            saveServerUrl();
+        });
+    }
+    
+    // 서버 URL 입력 필드 엔터 키 이벤트 리스너
+    if (serverUrlInput) {
+        serverUrlInput.addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') {
+                console.log("서버 URL 입력 필드 엔터 키 입력");
+                saveServerUrl();
+            }
+        });
+    }
+    
+    // 설정 패널 토글 이벤트 리스너 (id가 'toggleSettings'인 요소가 있다면)
+    const toggleSettings = document.getElementById('toggleSettings');
+    if (toggleSettings) {
+        toggleSettings.addEventListener('click', () => {
+            const settingsPanel = document.getElementById('serverSettingsPanel');
+            if (settingsPanel) {
+                settingsPanel.classList.toggle('open');
+            }
+        });
+    }
 });
 
 /**
@@ -148,8 +249,8 @@ async function checkDeviceStatus() {
     console.log("장치 상태 확인 중...");
     
     // UI 업데이트
-    deviceStatusResult.classList.add('hidden');
-    deviceStatusLoading.classList.remove('hidden');
+    if (deviceStatusResult) deviceStatusResult.classList.add('hidden');
+    if (deviceStatusLoading) deviceStatusLoading.classList.remove('hidden');
     
     try {
         // 타임아웃 설정을 위한 컨트롤러
@@ -172,30 +273,30 @@ async function checkDeviceStatus() {
         console.log("장치 상태 응답:", data);
         
         // UI 업데이트
-        deviceStatusLoading.classList.add('hidden');
-        deviceStatusResult.classList.remove('hidden');
+        if (deviceStatusLoading) deviceStatusLoading.classList.add('hidden');
+        if (deviceStatusResult) deviceStatusResult.classList.remove('hidden');
         
-        if (data.status === "online") {
+        if (data.status === "online" || data.status === "running") {
             // 온라인 상태인 경우
-            statusIcon.innerHTML = '<i class="fas fa-circle online"></i>';
-            statusText.textContent = `서버 상태: ${data.status || '정상'}`;
+            if (statusIcon) statusIcon.innerHTML = '<i class="fas fa-circle online"></i>';
+            if (statusText) statusText.textContent = `서버 상태: ${data.status || '정상'}`;
             
             // 자동으로 장치 목록 로드
             loadDevices();
         } else {
             // 오프라인 또는 오류 상태인 경우
-            statusIcon.innerHTML = '<i class="fas fa-circle offline"></i>';
-            statusText.textContent = `서버 오류: ${data.error || '알 수 없는 오류'}`;
+            if (statusIcon) statusIcon.innerHTML = '<i class="fas fa-circle offline"></i>';
+            if (statusText) statusText.textContent = `서버 오류: ${data.error || '알 수 없는 오류'}`;
         }
     } catch (error) {
         console.error("장치 상태 확인 오류:", error);
         
         // UI 업데이트
-        deviceStatusLoading.classList.add('hidden');
-        deviceStatusResult.classList.remove('hidden');
+        if (deviceStatusLoading) deviceStatusLoading.classList.add('hidden');
+        if (deviceStatusResult) deviceStatusResult.classList.remove('hidden');
         
-        statusIcon.innerHTML = '<i class="fas fa-circle offline"></i>';
-        statusText.textContent = handleError(error);
+        if (statusIcon) statusIcon.innerHTML = '<i class="fas fa-circle offline"></i>';
+        if (statusText) statusText.textContent = handleError(error);
     }
 }
 
@@ -206,9 +307,9 @@ async function loadDevices() {
     console.log("장치 목록 로드 중...");
     
     // UI 업데이트
-    deviceList.innerHTML = '';
-    noDevicesMessage.classList.add('hidden');
-    devicesLoading.classList.remove('hidden');
+    if (deviceList) deviceList.innerHTML = '';
+    if (noDevicesMessage) noDevicesMessage.classList.add('hidden');
+    if (devicesLoading) devicesLoading.classList.remove('hidden');
     
     try {
         // 타임아웃 설정을 위한 컨트롤러
@@ -231,25 +332,27 @@ async function loadDevices() {
         console.log("장치 목록 응답:", data);
         
         // UI 업데이트
-        devicesLoading.classList.add('hidden');
+        if (devicesLoading) devicesLoading.classList.add('hidden');
         
         if (data.devices && data.devices.length > 0) {
             // 장치 목록 표시
             data.devices.forEach(device => {
                 const deviceElement = createDeviceItem(device);
-                deviceList.appendChild(deviceElement);
+                if (deviceList) deviceList.appendChild(deviceElement);
             });
         } else {
             // 장치 없음 메시지 표시
-            noDevicesMessage.classList.remove('hidden');
+            if (noDevicesMessage) noDevicesMessage.classList.remove('hidden');
         }
     } catch (error) {
         console.error("장치 목록 로드 오류:", error);
         
         // UI 업데이트
-        devicesLoading.classList.add('hidden');
-        noDevicesMessage.classList.remove('hidden');
-        noDevicesMessage.textContent = handleError(error);
+        if (devicesLoading) devicesLoading.classList.add('hidden');
+        if (noDevicesMessage) {
+            noDevicesMessage.classList.remove('hidden');
+            noDevicesMessage.textContent = handleError(error);
+        }
     }
 }
 
@@ -263,7 +366,7 @@ function createDeviceItem(device) {
     deviceItem.classList.add('device-item');
     
     // 상태에 따른 클래스 추가
-    if (device.status === 'online' || device.status === '온라인') {
+    if (device.status === 'online' || device.status === '온라인' || device.status === 'Connected') {
         deviceItem.classList.add('online');
     } else if (device.status === 'offline' || device.status === '오프라인') {
         deviceItem.classList.add('offline');
@@ -283,7 +386,7 @@ function createDeviceItem(device) {
     deviceStatusBadge.classList.add('device-status-badge');
     
     // 상태에 따른 배지 설정
-    if (device.status === 'online' || device.status === '온라인') {
+    if (device.status === 'online' || device.status === '온라인' || device.status === 'Connected') {
         deviceStatusBadge.classList.add('online');
         deviceStatusBadge.textContent = '온라인';
     } else if (device.status === 'offline' || device.status === '오프라인') {
@@ -337,9 +440,9 @@ async function loadPrograms() {
     console.log("프로그램 목록 로드 중...");
     
     // UI 업데이트
-    programsList.innerHTML = '';
-    noProgramsMessage.classList.add('hidden');
-    programsLoading.classList.remove('hidden');
+    if (programsList) programsList.innerHTML = '';
+    if (noProgramsMessage) noProgramsMessage.classList.add('hidden');
+    if (programsLoading) programsLoading.classList.remove('hidden');
     
     try {
         // 타임아웃 설정을 위한 컨트롤러
@@ -362,25 +465,27 @@ async function loadPrograms() {
         console.log("프로그램 목록 응답:", data);
         
         // UI 업데이트
-        programsLoading.classList.add('hidden');
+        if (programsLoading) programsLoading.classList.add('hidden');
         
         if (data.programs && data.programs.length > 0) {
             // 프로그램 목록 표시
             data.programs.forEach(program => {
                 const programElement = createProgramItem(program);
-                programsList.appendChild(programElement);
+                if (programsList) programsList.appendChild(programElement);
             });
         } else {
             // 프로그램 없음 메시지 표시
-            noProgramsMessage.classList.remove('hidden');
+            if (noProgramsMessage) noProgramsMessage.classList.remove('hidden');
         }
     } catch (error) {
         console.error("프로그램 목록 로드 오류:", error);
         
         // UI 업데이트
-        programsLoading.classList.add('hidden');
-        noProgramsMessage.classList.remove('hidden');
-        noProgramsMessage.textContent = handleError(error);
+        if (programsLoading) programsLoading.classList.add('hidden');
+        if (noProgramsMessage) {
+            noProgramsMessage.classList.remove('hidden');
+            noProgramsMessage.textContent = handleError(error);
+        }
     }
 }
 
@@ -478,7 +583,7 @@ async function executeProgram(programId, programName) {
 /**
  * 알림 표시 함수
  * @param {string} message - 알림 메시지
- * @param {string} type - 알림 유형 ('success', 'error', 'warning')
+ * @param {string} type - 알림 유형 ('success', 'error', 'warning', 'info')
  */
 function showNotification(message, type = 'info') {
     // 기존 알림이 있으면 제거

app/templates/error.html

@@ -0,0 +1,88 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RAG 챗봇 - 오류</title>
+    <link rel="stylesheet" href="/static/css/styles.css">
+    <style>
+        .error-container {
+            max-width: 800px;
+            margin: 100px auto;
+            padding: 30px;
+            background-color: #fff;
+            border-radius: 10px;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+            text-align: center;
+        }
+        
+        .error-icon {
+            font-size: 64px;
+            color: #e74c3c;
+            margin-bottom: 20px;
+        }
+        
+        .error-title {
+            font-size: 24px;
+            font-weight: bold;
+            margin-bottom: 15px;
+            color: #e74c3c;
+        }
+        
+        .error-message {
+            font-size: 18px;
+            margin-bottom: 25px;
+            color: #555;
+        }
+        
+        .error-details {
+            background-color: #f8f9fa;
+            padding: 15px;
+            border-radius: 5px;
+            margin-bottom: 25px;
+            text-align: left;
+            font-family: monospace;
+            white-space: pre-wrap;
+            font-size: 14px;
+        }
+        
+        .home-button {
+            display: inline-block;
+            padding: 10px 20px;
+            background-color: #3498db;
+            color: white;
+            text-decoration: none;
+            border-radius: 5px;
+            font-weight: bold;
+            transition: background-color 0.3s;
+        }
+        
+        .home-button:hover {
+            background-color: #2980b9;
+        }
+    </style>
+</head>
+<body>
+    <div class="error-container">
+        <div class="error-icon">⚠️</div>
+        <div class="error-title">오류가 발생했습니다</div>
+        <div class="error-message">{{ error }}</div>
+        
+        {% if details %}
+        <div class="error-details">{{ details }}</div>
+        {% endif %}
+        
+        <div class="error-actions">
+            <a href="/" class="home-button">홈으로 돌아가기</a>
+        </div>
+    </div>
+
+    <script>
+        // 오류 발생 로그 출력
+        console.error("페이지 오류:", "{{ error }}");
+        {% if details %}
+        console.error("오류 상세:", "{{ details }}");
+        {% endif %}
+    </script>
+</body>
+</html>

app/templates/index.html

@@ -6,6 +6,7 @@
     <title>RAG 검색 챗봇</title>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0-beta3/css/all.min.css">
     <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/device-style.css') }}">
 </head>
 <body>
     <div class="container">
@@ -124,6 +125,31 @@
             <!-- 장치관리 탭 -->
             <section id="deviceSection" class="tab-content">
                 <div class="device-container">
+                    <!-- 서버 설정 섹션 (새로 추가) -->
+                    <div class="server-settings-section">
+                        <h2>
+                            서버 설정
+                            <button id="toggleSettings" class="toggle-button" title="설정 토글">
+                                <i class="fas fa-cog"></i>
+                            </button>
+                        </h2>
+                        
+                        <div id="serverSettingsPanel" class="server-settings-panel">
+                            <div class="settings-row">
+                                <label for="serverUrlInput">서버 URL:</label>
+                                <div class="input-with-button">
+                                    <input type="text" id="serverUrlInput" placeholder="http://localhost:8000 또는 ngrok URL">
+                                    <button id="saveServerUrlButton" class="save-button">저장</button>
+                                </div>
+                            </div>
+                            <div id="connectionStatus" class="connection-status">연결 상태: 확인 중...</div>
+                            <div class="server-hint">
+                                <i class="fas fa-info-circle"></i>
+                                <span>ngrok 터널링을 사용하는 경우 URL을 입력하세요. (예: https://xxxx-xxx-xxx.ngrok.io)</span>
+                            </div>
+                        </div>
+                    </div>
+                    
                     <div class="device-status-section">
                         <h2>장치 상태</h2>
                         <button id="checkDeviceStatusButton" class="refresh-button">

app/voice_routes.py

@@ -0,0 +1,203 @@
+"""
+RAG 검색 챗봇 - 음성 관련 API 라우트
+"""
+
+import os
+import logging
+import tempfile
+import threading
+from flask import request, jsonify
+
+# 로거 가져오기
+logger = logging.getLogger(__name__)
+
+def register_voice_routes(app, login_required, llm_interface, retriever, stt_client, DocumentProcessor,
+                         app_ready_event, init_success_event, initialization_error):
+    """
+    음성 관련 API 라우트 등록
+    """
+    
+    def allowed_audio_file(filename):
+        """파일이 허용된 오디오 확장자를 가지는지 확인"""
+        ALLOWED_AUDIO_EXTENSIONS = {'mp3', 'wav', 'ogg', 'm4a'}
+        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_AUDIO_EXTENSIONS
+
+    # --- Voice Chat API ---
+    @app.route('/api/voice', methods=['POST'])
+    @login_required
+    def voice_chat():
+        """음성 챗 API 엔드포인트"""
+        try:
+            # 앱이 준비되었는지 확인
+            is_ready = app_ready_event.is_set() if isinstance(app_ready_event, threading.Event) else False
+            if not is_ready:
+                logger.warning("앱이 아직 초기화 중입니다.")
+                return jsonify({
+                    "error": "앱 초기화 중...", 
+                    "answer": "죄송합니다. 시스템이 아직 준비 중입니다."
+                }), 200
+            
+            # 초기화 성공 여부 확인
+            is_success = init_success_event.is_set() if isinstance(init_success_event, threading.Event) else False
+            if not is_success and initialization_error:
+                logger.warning(f"초기화 실패 상태에서 음성 API 요청: {initialization_error}")
+                return jsonify({
+                    "error": "검색기 초기화 실패", 
+                    "answer": f"죄송합니다. 검색 시스템이 초기화되지 않았습니다. (오류: {initialization_error})"
+                }), 200
+            
+            # STT 클라이언트 확인
+            if stt_client is None or not hasattr(stt_client, 'transcribe_audio'):
+                logger.error("음성 API 요청 시 STT 클라이언트가 준비되지 않음")
+                return jsonify({"error": "음성 인식 서비스 준비 안됨"}), 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} ({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}")
+                    return jsonify({"error": "음성인식 실패", "details": error_msg}), 500
+                
+                transcription = stt_result.get("text", "")
+                if not transcription:
+                    logger.warning("음성인식 결과가 비어있습니다.")
+                    return jsonify({
+                        "transcription": "",
+                        "answer": "음성에서 텍스트를 인식하지 못했습니다.",
+                        "sources": []
+                    }), 200
+                
+                logger.info(f"음성인식 성공: {transcription[:50]}...")
+                
+                # 검색 수행
+                search_results = []
+                search_warning = None
+                
+                # 검색기 상태 확인 및 검색 수행
+                if retriever is None:
+                    logger.warning("Retriever가 초기화되지 않았습니다.")
+                    search_warning = "검색 기능이 아직 준비되지 않았습니다."
+                elif hasattr(retriever, 'is_mock') and retriever.is_mock:
+                    logger.info("Mock Retriever 사용 중 - 검색 결과 없음.")
+                    search_warning = "검색 인덱스가 아직 구축 중입니다. 기본 응답만 제공됩니다."
+                elif not hasattr(retriever, 'search'):
+                    logger.warning("Retriever에 search 메소드가 없습니다.")
+                    search_warning = "검색 기능이 현재 제한되어 있습니다."
+                else:
+                    try:
+                        logger.info(f"검색 수행: {transcription[:50]}...")
+                        search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
+                        
+                        if not search_results:
+                            logger.info("검색 결과가 없습니다.")
+                        else:
+                            logger.info(f"검색 결과: {len(search_results)}개 항목")
+                    except Exception as e:
+                        logger.error(f"검색 처리 중 오류: {e}", exc_info=True)
+                        search_results = []
+                        search_warning = f"검색 중 오류 발생: {str(e)}"
+                
+                # 컨텍스트 준비
+                context = ""
+                if search_results:
+                    if DocumentProcessor is None or not hasattr(DocumentProcessor, 'prepare_rag_context'):
+                        logger.warning("DocumentProcessor가 준비되지 않았거나 prepare_rag_context 메소드가 없습니다.")
+                    else:
+                        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+                        logger.info(f"컨텍스트 준비 완료 (길이: {len(context) if context else 0}자)")
+                
+                # LLM 인터페이스 호출
+                llm_id = request.form.get('llm_id', None)
+                
+                if not context:
+                    if search_warning:
+                        logger.info(f"컨텍스트 없음, 검색 경고: {search_warning}")
+                        answer = f"죄송합니다. 질문에 대한 답변을 찾을 수 없습니다. ({search_warning})"
+                    else:
+                        logger.info("컨텍스트 없이 기본 응답 생성")
+                        answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+                else:
+                    if llm_interface is None or not hasattr(llm_interface, 'rag_generate'):
+                        logger.error("LLM 인터페이스가 준비되지 않았거나 rag_generate 메소드가 없습니다.")
+                        answer = "죄송합니다. 현재 LLM 서비스를 사용할 수 없습니다."
+                    else:
+                        try:
+                            # LLM을 통한 응답 생성
+                            answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
+                            logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+                        except Exception as llm_err:
+                            logger.error(f"LLM 호출 중 오류: {llm_err}", exc_info=True)
+                            answer = f"죄송합니다. 응답 생성 중 오류가 발생했습니다: {str(llm_err)}"
+                
+                # 소스 정보 추출
+                sources = []
+                if search_results:
+                    for result in search_results:
+                        if not isinstance(result, dict):
+                            logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
+                            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["name"] = os.path.basename(source_key)
+                            source_info["path"] = source_key
+                        else:
+                            source_info["name"] = "알 수 없는 소스"
+                        
+                        if "score" in result:
+                            source_info["score"] = result["score"]
+                        if "rerank_score" in result:
+                            source_info["rerank_score"] = result["rerank_score"]
+                        
+                        sources.append(source_info)
+                
+                # 최종 응답
+                response_data = {
+                    "transcription": transcription,
+                    "answer": answer,
+                    "sources": sources,
+                    "search_warning": search_warning
+                }
+                
+                # LLM 정보 추가 (옵션)
+                if hasattr(llm_interface, 'get_current_llm_details'):
+                    response_data["llm"] = llm_interface.get_current_llm_details()
+                
+                return jsonify(response_data)
+            
+            except Exception as e:
+                logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
+                return jsonify({
+                    "error": "음성 처리 중 내부 오류 발생", 
+                    "details": str(e),
+                    "answer": "죄송합니다. 오디오 처리 중 오류가 발생했습니다."
+                }), 500
+                
+        except Exception as e:
+            logger.error(f"음성 API에서 예상치 못한 오류 발생: {str(e)}", exc_info=True)
+            return jsonify({
+                "error": f"예상치 못한 오류 발생: {str(e)}",
+                "answer": "죄송합니다. 서버에서 오류가 발생했습니다."
+            }), 500

app_gradio.py

@@ -1,206 +0,0 @@
-import os
-import gradio as gr
-import json
-import logging
-from app.app import app as flask_app  # Flask 앱 가져오기
-from flask import json as flask_json
-from retrying import retry
-
-# 로거 설정
-logging.basicConfig(
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    level=logging.DEBUG  # INFO에서 DEBUG로 변경하여 더 상세한 로그 확인
-)
-logger = logging.getLogger(__name__)
-
-# Flask 테스트 클라이언트 초기화
-@retry(tries=5, delay=1, backoff=2)
-def init_flask_client():
-    """백그라운드 실행 Flask 서버에 연결하는 클라이언트 초기화"""
-    try:
-        test_client = flask_app.test_client()
-        logger.info("Flask 테스트 클라이언트 초기화 성공")
-        return test_client
-    except Exception as e:
-        logger.error(f"Flask 테스트 클라이언트 초기화 실패: {e}")
-        raise e
-
-# 소스 정보 포맷팅 헤루퍼 함수
-def format_source_info(sources, prefix=""):
-    """검색 결과 소스 정보를 형식화
-    
-    Args:
-        sources: 소스 정보 리스트
-        prefix: 로그 메시지 접두사 (기본값: "")
-        
-    Returns:
-        형식화된 소스 정보 문자열
-    """
-    source_info = ""
-    if sources and len(sources) > 0:
-        logger.debug(f"{prefix}소스 정보 포맷팅: {len(sources)}개 소스: {json.dumps(sources, ensure_ascii=False, indent=2)}")
-        
-        source_list = []
-        for src in sources:
-            source_text = src["source"]
-            # id 필드가 있으면 함께 표시
-            if "id" in src:
-                logger.debug(f"{prefix}ID 필드 발견: {src['id']}")
-                source_text += f" (ID: {src['id']})"  
-            source_list.append(source_text)
-        
-        if source_list:
-            source_info = "\n\n참조 소스:\n" + "\n".join(source_list)
-            logger.debug(f"{prefix}최종 소스 정보 형식: {source_info}")
-    
-    return source_info
-
-# Flask 테스트 클라이언트 초기화
-flask_client = init_flask_client()
-
-# Gradio 버전 확인 메시지
-logger.info(f"Gradio 버전: {gr.__version__}")
-
-# Gradio 인터페이스 생성
-with gr.Blocks(title="RAG 검색 챗봇 with 음성인식") as demo:
-    gr.HTML("""
-    <div style="text-align: center; max-width: 800px; margin: 0 auto;">
-        <h1>RAG 검색 챗봇 with 음성인식</h1>
-        <p>텍스트 또는 음성으로 질문을 입력하세요.</p>
-    </div>
-    """)
-
-    with gr.Tab("텍스트 챗"):
-        text_input = gr.Textbox(label="질문 입력", placeholder="여기에 질문을 입력하세요...")
-        text_output = gr.Textbox(label="응답", interactive=False)
-        text_button = gr.Button("질문 제출")
-
-    with gr.Tab("음성 챗"):
-        with gr.Row():
-            # 녹음 UI 개선: 마이크로폰으로 소스 지정 및 음파 표시 활성화
-            audio_input = gr.Audio(
-                label="음성 입력", 
-                type="filepath",                
-                sources=["microphone"],
-                show_label=True,
-                waveform_options={"show_controls": True, "normalize": True},
-                interactive=True
-            )
-            
-        audio_transcription = gr.Textbox(label="인식된 텍스트", interactive=False)
-        audio_output = gr.Textbox(label="응답", interactive=False)
-        gr.Markdown("""
-        <div style="text-align: center; margin: 10px 0;">
-            <p>녹음 정지 버튼을 누르면 자동으로 음성이 전송됩니다.</p>
-        </div>
-        """)
-
-    with gr.Tab("문서 업로드"):
-        doc_input = gr.File(label="문서 업로드", file_types=[".txt", ".md", ".pdf", ".docx", ".csv"])
-        doc_output = gr.Textbox(label="업로드 결과", interactive=False)
-        doc_button = gr.Button("문서 업로드")
-
-    # 텍스트 챗 기능
-    def handle_text_chat(query):
-        if not query:
-            return "질문을 입력하세요."
-        try:
-            logger.info("텍스트 챗 요청: /api/chat")
-            response = flask_client.post("/api/chat", json={"query": query})
-            data = flask_json.loads(response.data)
-            
-            # 디버깅을 위한 API 응답 로그
-            logger.info(f"API 응답 구조: {json.dumps(data, ensure_ascii=False, indent=2)[:500]}...")
-            
-            if "error" in data:
-                logger.error(f"텍스트 챗 오류: {data['error']}")
-                return data["error"]
-            
-            # 소스 정보 추출 및 포맷팅
-            source_info = ""
-            if "sources" in data and data["sources"]:
-                source_info = format_source_info(data["sources"])
-            
-            # 응답과 소스 정보를 함께 반환
-            return data["answer"] + source_info
-        except Exception as e:
-            logger.error(f"텍스트 챗 처리 실패: {str(e)}")
-            return f"처리 중 오류 발생: {str(e)}"
-
-    # 음성 챗 기능
-    def handle_voice_chat(audio_file):
-        if not audio_file:
-            return "", "음성을 업로드하세요."
-        try:
-            logger.info("음성 챗 요청: /api/voice")
-            with open(audio_file, "rb") as f:
-                # Flask 테스트 클라이언트는 files 직접 지원 안 하므로, 데이터를 읽어 전달
-                response = flask_client.post(
-                    "/api/voice",
-                    data={"audio": (f, "audio_file")}
-                )
-            data = flask_json.loads(response.data)
-            
-            # 디버깅을 위한 API 응답 로그
-            logger.info(f"[음성챗] API 응답 구조: {json.dumps(data, ensure_ascii=False, indent=2)[:500]}...")
-            
-            if "error" in data:
-                logger.error(f"음성 챗 오류: {data['error']}")
-                return "", data["error"]
-            
-            # 소스 정보 추출 및 포맷팅
-            source_info = ""
-            if "sources" in data and data["sources"]:
-                source_info = format_source_info(data["sources"], prefix="[음성챗] ")
-            
-            # 인식된 텍스트와 소스 정보가 포함된 응답 반환
-            return data["transcription"], data["answer"] + source_info
-        except Exception as e:
-            logger.error(f"음성 챗 처리 실패: {str(e)}")
-            return "", f"처리 중 오류 발생: {str(e)}"
-
-    # 문서 업로드 기능
-    def handle_doc_upload(doc_file):
-        if not doc_file:
-            return "문서를 업로드하세요."
-        try:
-            logger.info(f"문서 업로드 요청: /api/upload, 파일명: {doc_file.name}")
-            file_extension = os.path.splitext(doc_file.name)[1].lower()
-            logger.info(f"파일 확장자: {file_extension}")
-            
-            with open(doc_file, "rb") as f:
-                response = flask_client.post(
-                    "/api/upload",
-                    data={"document": (f, doc_file.name)}
-                )
-            data = flask_json.loads(response.data)
-            if "error" in data:
-                logger.error(f"문서 업로드 오류: {data['error']}")
-                return data["error"]
-            return data["message"]
-        except Exception as e:
-            logger.error(f"문서 업로드 처리 실패: {str(e)}")
-            return f"처리 중 오류 발생: {str(e)}"
-
-    # 이벤트 핸들러 연결
-    text_button.click(
-        fn=handle_text_chat,
-        inputs=text_input,
-        outputs=text_output
-    )
-    
-    # 음성 입력 값이 변경될 때 자동으로 전송
-    audio_input.change(
-        fn=handle_voice_chat,
-        inputs=audio_input,
-        outputs=[audio_transcription, audio_output]
-    )
-    
-    doc_button.click(
-        fn=handle_doc_upload,
-        inputs=doc_input,
-        outputs=doc_output
-    )
-
-if __name__ == "__main__":
-    demo.launch(server_port=7860)

docs/project_plan.md

@@ -1,139 +1,78 @@
-# RAG5_2_ChooseLLM 프로젝트 계획서
+# RAG 챗봇 프로젝트 계획서
 
 ## 프로젝트 개요
-이 프로젝트는 RAG(Retrieval-Augmented Generation) 기반 검색 챗봇으로, 지식베이스에서 관련 정보를 검색하여 사용자 질의에 답변합니다. 주요 특징으로는 OpenAI와 DeepSeek 등 다양한 LLM을 선택하여 사용할 수 있는 기능과 장치 관리 기능을 제공합니다.
-
-## 주요 기능
-1. 지식베이스 관리
-   - 문서 업로드 (.txt, .md, .csv 등)
-   - 문서 청크 분할 및 벡터 인덱싱
-   - 지식베이스 문서 목록 조회
-
-2. LLM 선택
-   - OpenAI, DeepSeek 등 다양한 LLM 선택 가능
-   - LLM 변경 시 실시간 전환
-   - 현재 사용 중인 LLM 정보 표시
-
-3. 챗봇 기능
-   - 텍스트 기반 질의응답
-   - 음성 인식 및 질의응답 (VITO STT 활용)
-   - 검색 결과 정보 출처 표시
-
-4. 장치 관리 기능
-   - 로컬 PC와 통신하는 기능
-   - 장치 상태 확인 및 장치 목록 조회
-   - 프로그램 목록 조회 및 실행
-
-## 기술 스택
-- **백엔드:** Flask (Python)
-- **프론트엔드:** HTML, CSS, JavaScript
-- **LLM 통합:** OpenAI API, DeepSeek API
-- **검색 기능:** 벡터 검색, 재순위화
-- **STT 서비스:** VITO API
-- **통신 프로토콜:** RESTful API
-
-## 완료된 작업
-- [X] 프로젝트 기본 구조 설정
-- [X] Flask 웹 서버 구현
-- [X] 다중 LLM 인터페이스 구현 (OpenAI, DeepSeek)
-- [X] 사용자 인증 기능 구현
-- [X] 벡터 검색 및 재순위화 기능 구현
-- [X] 문서 처리 및 관리 기능 구현
-- [X] 웹 인터페이스 구현
-- [X] 장치 관리 기능 통합
-- [X] 장치 관리 UI 구현
-- [X] 장치관리 탭 클릭 이벤트 버그 수정
-
-## 진행해야 할 작업
-- [ ] 문서관리&장치관리 탭 로딩지속 현상 해결결
-- [ ] LLM 선택 UI 개선
-  - 드롭다운에 아이콘 추가
-  - 각 LLM별 상세 모델 정보 표시
-- [ ] 응답 내 소스 링크 클릭 시 원문 표시 기능
-- [ ] 응답 속도 개선
-- [ ] 오류 처리 강화
-- [ ] 테스트 케이스 작성 및 유닛 테스트 구현
-- [ ] 사용자 가이드 문서 작성
-
-## 통합 구현 내용
-
-### 1. 웹앱 통합
-- 단일 웹 애플리케이션에 RAG 검색 챗봇과 장치 관리 기능 통합
-- 탭 기반 인터페이스로 기능 분리 (대화, 문서관리, 장치관리)
-- Flask를 통한 중앙 집중식 서버 관리
-
-### 2. 장치 관리 기능
-- 장치 상태 확인 기능
-- 연결된 장치 목록 조회
-- 실행 가능한 프로그램 목록 조회 및 실행
-- 서버와의 RESTful API 통신
-
-### 3. 프론트엔드 구현
-- 직관적인 사용자 인터페이스
-- 실시간 상태 업데이트
-- 에러 처리 및 사용자 피드백 제공
-- 반응형 디자인 적용
-
-## 최근 버그 수정
-
-### 장치관리 탭 작동 문제 해결
-**문제 상황:** UI에서 장치관리 버튼이 전혀 작동하지 않는 문제 발생
-
-**원인 분석:**
-1. HTML 문제: 
-   - `device-style.css` 파일이 HTML에 링크되어 있지 않음
-2. JavaScript 문제:
-   - `app.js`에서 deviceTab 이벤트 리스너가 제대로 등록되지 않음
-   - `app-device.js`와 `app.js` 간의 함수 공유에 문제 발생
-
-**해결 방법:**
-1. HTML 수정:
-   - `device-style.css` 파일을 HTML의 head 섹션에 링크 추가
-   - 장치관리 탭을 위한 직접적인 이벤트 핸들러를 HTML 내부 스크립트로 추가
-2. 이벤트 핸들링 개선:
-   - 장치관리 탭에 직접 onclick 이벤트 핸들러 추가하여 기존 문제 우회
-   - 디버깅용 콘솔 로그 추가로 문제 추적 가능하게 함
-
-**수정 파일:**
-- `app/templates/index.html`: CSS 링크 및 직접 이벤트 핸들러 추가
-- `docs/project_plan.md`: 문제 해결 과정 문서화
+이 프로젝트는 RAG(Retrieval-Augmented Generation) 기반의 검색 챗봇을 개발하는 것입니다. 
+현재 리트리버 초기화 실패 문제가 발생하고 있으며, 이를 해결하는 것이 주요 목표입니다.
+
+## 문제 상황
+- RAG 리트리버 초기화 과정에서 실패가 발생하고 있음
+- app.py 파일의 백그라운드 초기화 로직에 문제가 있음
+- 초기화 실패 시에도 앱이 '준비 완료' 상태로 전환되어 API 호출 시점에 오류 발생
+
+## 해결 방안
+1. `init_retriever` 함수 디버깅 및 개선
+   - 상세 로깅 추가하여 실패 지점 파악
+   - 오류 처리 로직 강화
+   - 모든 잠재적 오류 상황에 대한 처리 추가
+
+2. 초기화 상태 관리 개선
+   - 초기화 상태를 세분화하여 '준비 완료'와 '초기화 성공'을 별도로 관리
+   - 초기화 실패 시 사용자에게 명확한 오류 메시지 제공
+   - Mock 컴포넌트 강화 및 오류 처리 개선
+
+3. 앱 구조 정리
+   - 파일 크기 제한(10KB)을 고려한 코드 분할
+   - 기능별 모듈화로 유지보수성 향상
+   - 명확한 파일 구조 설계
 
 ## 파일 구조
-```
-RAG5_2_ChooseLLM/
-├── app/
-│   ├── app.py                   # 메인 Flask 애플리케이션
-│   ├── app_routes.py            # 기본 라우트 정의
-│   ├── app_device_routes.py     # 장치 관리 관련 라우트
-│   ├── static/
-│   │   ├── css/
-│   │   │   ├── style.css        # 기본 스타일시트
-│   │   │   └── device-style.css # 장치 관리 스타일시트
-│   │   └── js/
-│   │       ├── app.js           # 메인 JavaScript
-│   │       └── app-device.js    # 장치 관리 JavaScript
-│   └── templates/
-│       ├── index.html           # 메인 페이지 템플릿 (수정됨)
-│       └── login.html           # 로그인 페이지 템플릿
-├── data/                        # 업로드된 문서 저장
-├── docs/                        # 프로젝트 문서
-├── retrieval/                   # 검색 관련 모듈
-└── utils/                       # 유틸리티 모듈
-```
-
-## 환경 변수 설정
-- `ADMIN_USERNAME`: 관리자 사용자명 (기본값: admin)
-- `ADMIN_PASSWORD`: 관리자 비밀번호 (기본값: rag12345)
-- `DEVICE_SERVER_URL`: 장치 관리 서버 URL (기본값: http://localhost:5050)
-- `OPENAI_API_KEY`: OpenAI API 키
-- `DEEPSEEK_API_KEY`: DeepSeek API 키
-- `VITO_API_KEY`: VITO STT API 키
-
-## 참고 사항
-- 장치 관리 서버는 별도로 실행되어야 함 (포트 5050)
-- OpenAI, DeepSeek 및 VITO API 키는 .env 파일에 설정해야 함
-- 초기 로그인 계정 정보는 환경 변수에 설정하거나 기본값 사용
-- 장치관리 탭 클릭 시 콘솔 로그를 확인하여 이벤트 처리 상태 검증 가능
-
-## 현재 문제 사항
-- 문서관리 & 장치관리에서 로딩현상상 지속
+- `app.py`: 메인 진입점
+- `app/app_main.py`: 메인 앱 로직 
+- `app/app_revised.py`: 개선된 앱 초기화 로직
+- `app/init_retriever_improved.py`: 개선된 리트리버 초기화 로직
+- `app/background_init.py`: 백그라운드 초기화 관리
+- `app/app_routes_improved.py`: 개선된 라우트 등록 로직 (핵심 라우트만 포함)
+- `app/chat_routes.py`: 챗봇 관련 API 엔드포인트
+- `app/document_routes.py`: 문서 관리 관련 API 엔드포인트
+- `app/voice_routes.py`: 음성 관련 API 엔드포인트
+- `app/templates/error.html`: 오류 표시 템플릿
+
+## 핵심 개선 사항
+
+### 1. 초기화 과정 개선
+- `app_ready_event`와 `init_success_event` 분리하여 앱 로딩과 초기화 성공 여부를 독립적으로 관리
+- 초기화 실패 시에도 앱은 로딩되지만, 실패 상태를 명확히 사용자에게 표시
+- `initialization_error` 변수를 통해 오류 정보 추적 및 표시
+
+### 2. 오류 처리 강화
+- 초기화 실패 원인 세분화 (모듈 로드, 파일 접근, 인덱스 로드 등)
+- Mock 컴포넌트 확장으로 실패 시에도 최소한의 기능 유지
+- 모든 주요 작업에 상세 로깅 추가로 디버깅 용이성 향상
+
+### 3. 사용자 경험 개선
+- 오류 발생 시 명확한 피드백 제공
+- API 상태 코드 조정으로 유효한 응답 유지
+- 시스템 상태 모니터링 API 확장
+
+## 작업 상황
+### 완료된 작업
+- 프로젝트 초기 분석 
+- 문제 원인 파악 (app.py의 백그라운드 초기화 로직)
+- 프로젝트 계획 수립
+- 코드베이스 분석 및 구조 이해
+- 개선된 init_retriever 함수 구현
+- 백그라운드 초기화 로직 재구성
+- API 라우트 로직 개선 및 모듈화
+- 오류 처리 및 상태 관리 강화
+- 초기화 실패 시 사용자 피드백 개선
+- 모듈 구조 최적화 및 코드 분할
+
+### 진행 중인 작업
+- 추가 오류 상황 처리 개선
+- 로깅 강화
+
+### 해야 할 작업
+- 실제 환경에서 검증
+- 성능 테스트
+- 추가 문서화
+- UI 측 오류 처리 개선 (클라이언트 JavaScript)

docs/technical_improvements.md

@@ -0,0 +1,167 @@
+# RAG 챗봇 - 기술적 개선 사항 문서
+
+## 개요
+이 문서는 RAG 챗봇 시스템의 리트리버 초기화 실패 문제를 해결하기 위한 기술적 개선 사항을 설명합니다.
+
+## 핵심 문제 및 해결책
+
+### 문제 1: 리트리버 초기화 실패
+**문제**: 백그라운드 스레드에서 리트리버 초기화가 실패해도 앱이 '준비 완료' 상태로 전환됨
+
+**해결책**:
+1. 상태 관리 세분화:
+   - `app_ready_event`: 앱 UI 로딩 완료 상태
+   - `init_success_event`: 리트리버 초기화 성공 여부
+   - `initialization_error`: 초기화 실패 시 오류 메시지 저장
+
+2. 오류 처리 개선:
+   ```python
+   # 이전 코드
+   if retriever is None:
+       logger.error("검색기 초기화 실패")
+       app_ready_event.set()  # 실패해도 앱은 '준비 완료'로 설정
+   
+   # 개선된 코드
+   if retriever is None:
+       logger.error("검색기 초기화 실패")
+       initialization_error = "검색기 초기화 실패"
+       app_ready_event.set()  # 앱 로딩은 완료
+       # init_success_event는 설정하지 않음 (초기화 실패)
+   ```
+
+### 문제 2: 불충분한 오류 정보
+**문제**: 초기화 실패 시 원인에 대한 정보가 불충분하여 디버깅이 어려움
+
+**해결책**:
+1. 상세 로깅 추가:
+   - 각 초기화 단계별 로그 기록
+   - 오류 발생 지점 명확히 식별
+
+2. 세부 오류 추적:
+   ```python
+   try:
+       # 초기화 코드
+   except Exception as e:
+       error_msg = f"검색기 초기화 중 오류: {str(e)}"
+       logger.error(error_msg, exc_info=True)
+       return None, None, False, error_msg  # 오류 메시지 반환
+   ```
+
+### 문제 3: 파일 크기 및 코드 유지보수성
+**문제**: 단일 파일에 모든 코드가 있어 크기 제한(10KB) 초과 및 유지보수 어려움
+
+**해결책**:
+1. 모듈화된 구조:
+   - `app_main.py`: 메인 앱 로직
+   - `background_init.py`: 백그라운드 초기화 처리
+   - `init_retriever_improved.py`: 리트리버 초기화 로직
+   - `app_routes_improved.py`: 기본 라우트 등록
+   - 기능별 모듈: `chat_routes.py`, `document_routes.py`, `voice_routes.py`
+
+2. 명확한 책임 분리:
+   - 각 모듈은 단일 책임 원칙 준수
+   - 의존성 명확히 문서화
+
+## 기술적 개선의 핵심 포인트
+
+### 1. 강화된 오류 복원력
+- Mock 컴포넌트 구현:
+  ```python
+  class MockComponent:
+      def __init__(self):
+          self.is_mock = True
+          logger.warning("MockComponent 인스턴스 생성됨")
+      
+      def search(self, query, **kwargs):
+          logger.warning(f"MockComponent.search 호출됨: {query[:30]}...")
+          return []
+      
+      def __getattr__(self, name):
+          logger.warning(f"MockComponent에서 '{name}' 접근 시도")
+          if name in ['add_documents', 'save', 'rag_generate', 'prepare_rag_context']:
+              return lambda *args, **kwargs: None
+          return None
+  ```
+
+- 컴포넌트 존재 및 속성 확인 강화:
+  ```python
+  # 안전한 검색 수행
+  if retriever is None:
+      search_warning = "검색기가 초기화되지 않았습니다."
+  elif hasattr(retriever, 'is_mock') and retriever.is_mock:
+      search_warning = "검색 인덱스가 아직 구축 중입니다."
+  elif not hasattr(retriever, 'search'):
+      search_warning = "검색 기능이 현재 제한되어 있습니다."
+  else:
+      try:
+          search_results = retriever.search(query, top_k=5)
+      except Exception as e:
+          search_warning = f"검색 중 오류 발생: {str(e)}"
+  ```
+
+### 2. 사용자 경험 개선
+- 초기화 실패 시에도 앱 접근성 유지
+- API 응답에 명확한 오류 메시지 포함:
+  ```python
+  if not is_success and initialization_error:
+      return jsonify({
+          "error": "검색기 초기화 실패", 
+          "answer": f"죄송합니다. 검색 시스템 초기화에 실패했습니다. (오류: {initialization_error})"
+      })
+  ```
+
+- 오류 페이지 템플릿 추가:
+  ```html
+  <div class="error-container">
+      <div class="error-title">오류가 발생했습니다</div>
+      <div class="error-message">{{ error }}</div>
+      {% if details %}
+      <div class="error-details">{{ details }}</div>
+      {% endif %}
+  </div>
+  ```
+
+### 3. 시스템 상태 모니터링 강화
+- 상세 상태 정보 API 추가:
+  ```python
+  @app.route('/api/system/status')
+  def system_status():
+      status = {
+          "app_ready": app_ready_event.is_set(),
+          "init_success": init_success_event.is_set(),
+          "retriever_type": type(retriever).__name__,
+          "is_mock_retriever": hasattr(retriever, 'is_mock') and retriever.is_mock,
+          "error_message": initialization_error,
+          "document_count": len(getattr(base_retriever, 'documents', [])),
+          "server_time": datetime.datetime.now().isoformat()
+      }
+      return jsonify(status)
+  ```
+
+## 데이터 ��름 개선
+
+### 이전 데이터 흐름
+1. Flask 앱 초기화
+2. 백그라운드 스레드에서 retriever 초기화
+3. 초기화 성공/실패와 관계없이 app_ready 설정
+4. API 호출 시점에 retriever 객체 존재 확인 없이 사용 시도
+5. 실패 시 사용자에게 "정보를 찾을 수 없습니다" 같은 모호한 메시지 표시
+
+### 개선된 데이터 흐름
+1. Flask 앱 초기화
+2. 백그라운드 스레드에서 retriever 초기화 시도
+3. 초기화 성공 여부 별도 관리 (init_success_event)
+4. 초기화 실패 시 상세 오류 정보 저장 (initialization_error)
+5. API 호출 시 초기화 성공 여부 및 오류 정보 확인
+6. 사용자에게 구체적인 문제 상황과 해결 방안 안내
+
+## 결론
+이번 개선 작업은 RAG 챗봇 시스템의 안정성과 유지보수성을 크게 향상시켰습니다. 특히 다음과 같은 이점을 얻었습니다:
+
+1. **안정성 향상**: 초기화 실패 상황에서도 최소한의 기능 유지
+2. **디버깅 용이성**: 상세한 오류 로깅과 추적 지원
+3. **코드 가독성**: 모듈화된 구조로 유지보수 용이
+4. **사용자 경험**: 오류 상황에서도 명확한 피드백 제공
+5. **확장성**: 새로운 기능 추가가 용이해진 모듈식 구조
+
+이러한 개선 사항은 시스템의 장기적인 유지보수와 확장에 큰 도움이 될 것입니다.