init

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_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_revised.py

@@ -1,268 +0,0 @@
-"""
-RAG 검색 챗봇 웹 애플리케이션 (장치 관리 기능 통합)
-"""
-
-import os
-import logging
-import threading
-from datetime import datetime, timedelta
-from flask import Flask, send_from_directory, jsonify
-from dotenv import load_dotenv
-from functools import wraps
-from flask_cors import CORS
-
-# 로거 설정
-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', 'http://localhost:5050')
-
-logger.info(f"==== 환경 변수 로드 상태 ====")
-logger.info(f"ADMIN_USERNAME 설정 여부: {ADMIN_USERNAME is not None}")
-logger.info(f"ADMIN_PASSWORD 설정 여부: {ADMIN_PASSWORD is not None}")
-logger.info(f"DEVICE_SERVER_URL: {DEVICE_SERVER_URL}")
-
-# 환경 변수가 없으면 기본값 설정
-if not ADMIN_USERNAME:
-    ADMIN_USERNAME = 'admin'
-    logger.warning("ADMIN_USERNAME 환경변수가 없어 기본값 'admin'으로 설정합니다.")
-
-if not ADMIN_PASSWORD:
-    ADMIN_PASSWORD = 'rag12345'
-    logger.warning("ADMIN_PASSWORD 환경변수가 없어 기본값 'rag12345'로 설정합니다.")
-
-class MockComponent: pass
-
-# --- 로컬 모듈 임포트 ---
-try:
-    from utils.vito_stt import VitoSTT
-    from utils.llm_interface import LLMInterface
-    from utils.document_processor import DocumentProcessor
-    from retrieval.vector_retriever import VectorRetriever
-    from retrieval.reranker import ReRanker
-except ImportError as e:
-    logger.error(f"로컬 모듈 임포트 실패: {e}. utils 및 retrieval 패키지가 올바른 경로에 있는지 확인하세요.")
-    VitoSTT = LLMInterface = DocumentProcessor = VectorRetriever = ReRanker = MockComponent
-# --- 로컬 모듈 임포트 끝 ---
-
-
-# Flask 앱 초기화
-app = Flask(__name__)
-
-# CORS 설정 - 모든 도메인에서의 요청 허용
-CORS(app, supports_credentials=True)
-
-# 세션 설정
-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)
-# --- 세션 쿠키 설정 끝 ---
-
-# 최대 파일 크기 설정 (10MB)
-app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
-# 애플리케이션 파일 기준 상대 경로 설정
-APP_ROOT = os.path.dirname(os.path.abspath(__file__))
-app.config['UPLOAD_FOLDER'] = os.path.join(APP_ROOT, 'uploads')
-app.config['DATA_FOLDER'] = os.path.join(APP_ROOT, '..', 'data')
-app.config['INDEX_PATH'] = os.path.join(APP_ROOT, '..', 'data', 'index')
-
-# 필요한 폴더 생성
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-os.makedirs(app.config['DATA_FOLDER'], exist_ok=True)
-os.makedirs(app.config['INDEX_PATH'], exist_ok=True)
-
-# --- 전역 객체 초기화 ---
-try:
-    llm_interface = LLMInterface(default_llm="openai")
-    stt_client = VitoSTT()
-except NameError:
-    logger.warning("LLM 또는 STT 인터페이스 초기화 실패. Mock 객체를 사용합니다.")
-    llm_interface = MockComponent()
-    stt_client = MockComponent()
-
-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')}")
-
-        # API 요청이고 클라이언트에서 오는 경우 인증 무시 (임시 조치)
-        if request.path.startswith('/api/device/'):
-            logger.info(f"장치 API 요청: {request.path} - 인증 제외")
-            return f(*args, **kwargs)
-
-        # 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.errorhandler(404)
-def not_found(e):
-    # 클라이언트가 JSON을 기대하는 API 호출인 경우 JSON 응답
-    if request.path.startswith('/api/'):
-        return jsonify({"success": False, "error": "요청한 API 엔드포인트를 찾을 수 없습니다."}), 404
-    # 일반 웹 페이지 요청인 경우 HTML 응답
-    return "페이지를 찾을 수 없습니다.", 404
-
-@app.errorhandler(500)
-def internal_error(e):
-    # 클라이언트가 JSON을 기대하는 API 호출인 경우 JSON 응답
-    if request.path.startswith('/api/'):
-        return jsonify({"success": False, "error": "서버 내부 오류가 발생했습니다."}), 500
-    # 일반 웹 페이지 요청인 경우 HTML 응답
-    return "서버 오류가 발생했습니다.", 500
-# --- 오류 핸들러 끝 ---
-
-
-# --- 정적 파일 서빙 ---
-@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("앱 초기화 완료")
-
-
-# 앱 초기화 실행
-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)