Initial setup

.gitignore

@@ -0,0 +1,38 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# 프로젝트 특화
+.env
+*.log
+data/index/
+data/*.json
+app/uploads/

Procfile

@@ -0,0 +1,5 @@
+<<<<<<< HEAD
+web: gunicorn -b 0.0.0.0:$PORT app:app
+=======
+web: gunicorn app:app
+>>>>>>> 342cb1bea06d143718684d40b8f294967c3bbcae

app.py

@@ -0,0 +1,74 @@
+"""
+RAG 검색 챗봇 메인 실행 파일
+"""
+
+# os 모듈 임포트
+import os
+import logging
+
+# 로깅 설정
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+try:
+    # 앱 모듈에서 Flask 앱 가져오기
+    from app.app import app
+    
+    # 장치 라우트 등록 코드 추가
+    try:
+        from flask_cors import CORS
+        from app.app_device_routes import register_device_routes
+        
+        # CORS 설정
+        CORS(app, supports_credentials=True)
+        
+        # 장치 서버 URL 환경 변수 (대문자로 변경)
+        DEVICE_SERVER_URL = os.getenv('DEVICE_SERVER_URL', 'http://localhost:5050')
+        logger.info(f"장치 서버 URL: {DEVICE_SERVER_URL}")
+        
+        # 인증 데코레이터 가져오기
+        from app.app import login_required
+        
+        # 인증 데코레이터 오버라이드 (장치 API 인증 우회)
+        from functools import wraps
+        from flask import request, session, redirect, url_for
+        
+        def device_login_required(f):
+            @wraps(f)
+            def decorated_function(*args, **kwargs):
+                # API 요청이고 클라이언트에서 오는 경우 인증 무시 (임시 조치)
+                if request.path.startswith('/api/device/'):
+                    logger.info(f"장치 API 요청: {request.path} - 인증 제외")
+                    return f(*args, **kwargs)
+                
+                # 그 외에는 기존 login_required 사용
+                return login_required(f)(*args, **kwargs)
+            return decorated_function
+        
+        # 장치 라우트 등록 (대문자 변수명 사용)
+        register_device_routes(app, device_login_required, DEVICE_SERVER_URL)
+        logger.info("장치 라우트 직접 등록 성공")
+        
+        # 404 오류 핸들러 등록
+        @app.errorhandler(404)
+        def not_found(e):
+            # 클라이언트가 JSON을 기대하는 API 호출인 경우 JSON 응답
+            from flask import request, jsonify
+            if request.path.startswith('/api/'):
+                return jsonify({"success": False, "error": "요청한 API 엔드포인트를 찾을 수 없습니다."}), 404
+            # 일반 웹 페이지 요청인 경우 HTML 응답
+            return "페이지를 찾을 수 없습니다.", 404
+    except Exception as e:
+        logger.error(f"장치 라우트 등록 실패: {e}", exc_info=True)
+    
+except ImportError as e:
+    logger.error(f"앱 모듈 가져오기 실패: {e}")
+    raise
+
+if __name__ == '__main__':
+    port = int(os.environ.get("PORT", 7860))
+    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
+    app.run(debug=False, host='0.0.0.0', port=port)

app/__init__.py

@@ -0,0 +1 @@
+# 애플리케이션 패키지

app/app.py

@@ -0,0 +1,919 @@
+"""
+RAG 검색 챗봇 웹 애플리케이션 (세션 설정 수정 적용 및 중복 라우트 등록 방지)
+"""
+
+import os
+import json
+import logging
+import tempfile
+import threading
+import datetime
+from flask import Flask, request, jsonify, render_template, send_from_directory, session, redirect, url_for
+from flask_cors import CORS
+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  # INFO에서 DEBUG로 변경하여 더 상세한 로그 확인
+)
+logger = logging.getLogger(__name__)
+
+# 환경 변수 로드
+load_dotenv()
+
+# 환경 변수 로드 상태 확인 및 로깅
+ADMIN_USERNAME = os.getenv('ADMIN_USERNAME')
+ADMIN_PASSWORD = os.getenv('ADMIN_PASSWORD')
+
+# 장치 서버 URL 환경 변수 추가
+DEVICE_SERVER_URL = os.getenv('DEVICE_SERVER_URL', 'http://localhost:5050')
+logger.info(f"장치 서버 URL: {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}")
+
+# 환경 변수가 없으면 기본값 설정 (개발용, 배포 시 환경 변수 설정 권장)
+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
+
+# --- 로컬 모듈 임포트 ---
+# 실제 경로에 맞게 utils, retrieval 폴더가 존재해야 합니다.
+try:
+    from utils.vito_stt import VitoSTT
+    from utils.llm_interface import LLMInterface
+    from utils.document_processor import DocumentProcessor
+    from retrieval.vector_retriever import VectorRetriever
+    from retrieval.reranker import ReRanker
+    # 장치 라우트 등록 함수 임포트
+    from app.app_device_routes import register_device_routes
+except ImportError as e:
+    logger.error(f"로컬 모듈 임포트 실패: {e}. utils, retrieval, app 패키지가 올바른 경로에 있는지 확인하세요.")
+    # 개발/테스트를 위해 임시 클래스/함수 정의 (실제 사용 시 제거)
+
+    VitoSTT = LLMInterface = DocumentProcessor = VectorRetriever = ReRanker = MockComponent
+    def register_device_routes(*args, **kwargs):
+        logger.warning("Mock register_device_routes 함수 호출됨.")
+        pass
+# --- 로컬 모듈 임포트 끝 ---
+
+
+# Flask 앱 초기화
+app = Flask(__name__)
+
+# CORS 설정 - 모든 도메인에서의 요청 허용
+CORS(app, supports_credentials=True)
+
+# 세션 설정 - 고정된 시크릿 키 사용 (실제 배포 시 환경 변수 등으로 관리 권장)
+app.secret_key = os.getenv('FLASK_SECRET_KEY', 'rag_chatbot_fixed_secret_key_12345') # 환경 변수 우선 사용
+
+# --- 세션 쿠키 설정 수정 (허깅페이스 환경 고려) ---
+# 허깅페이스 스페이스는 일반적으로 HTTPS로 서비스되므로 Secure=True 설정
+app.config['SESSION_COOKIE_SECURE'] = True
+app.config['SESSION_COOKIE_HTTPONLY'] = True  # JavaScript에서 쿠키 접근 방지 (보안 강화)
+# SameSite='Lax'가 대부분의 경우에 더 안전하고 호환성이 좋음.
+# 만약 앱이 다른 도메인의 iframe 내에서 실행되어야 한다면 'None'으로 설정해야 함.
+# (단, 'None'으로 설정 시 반드시 Secure=True여야 함)
+# 로그 분석 결과 iframe 환경으로 확인되어 'None'으로 변경
+app.config['SESSION_COOKIE_SAMESITE'] = 'None' # <--- 이렇게 변경합니다.
+app.config['SESSION_COOKIE_DOMAIN'] = None  # 특정 도메인 제한 없음
+app.config['SESSION_COOKIE_PATH'] = '/'  # 앱 전체 경로에 쿠키 적용
+app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=1)  # 세션 유효 시간 증가
+# --- 세션 쿠키 설정 끝 ---
+
+# 최대 파일 크기 설정 (10MB)
+app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
+# 애플리케이션 파일 기준 상대 경로 설정
+APP_ROOT = os.path.dirname(os.path.abspath(__file__))
+app.config['UPLOAD_FOLDER'] = os.path.join(APP_ROOT, 'uploads')
+app.config['DATA_FOLDER'] = os.path.join(APP_ROOT, '..', 'data')
+app.config['INDEX_PATH'] = os.path.join(APP_ROOT, '..', 'data', 'index')
+
+# 필요한 폴더 생성
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+os.makedirs(app.config['DATA_FOLDER'], exist_ok=True)
+os.makedirs(app.config['INDEX_PATH'], exist_ok=True)
+
+# 허용되는 오디오/문서 파일 확장자
+ALLOWED_AUDIO_EXTENSIONS = {'mp3', 'wav', 'ogg', 'm4a'}
+ALLOWED_DOC_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'csv'}
+
+# --- 전역 객체 초기화 ---
+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 # 앱 초기화 상태 플래그
+DEVICE_ROUTES_REGISTERED = False # 장치 라우트 등록 상태 플래그
+# --- 전역 객체 초기화 끝 ---
+
+
+# --- 인증 데코레이터 (수정됨) ---
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        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)) # 로그인 후 원래 페이지로 돌아가도록 next 파라미터 추가
+
+        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
+# --- 오류 핸들러 끝 ---
+
+# --- 장치 관련 라우트 등록 (수정됨: 중복 방지) ---
+# 전역 플래그를 사용하여 한 번만 등록되도록 함
+if not DEVICE_ROUTES_REGISTERED:
+    try:
+        # 임포트된 register_device_routes 함수 사용
+        # 인증 데코레이터(login_required)와 서버 URL 전달
+        register_device_routes(app, login_required, DEVICE_SERVER_URL)
+        DEVICE_ROUTES_REGISTERED = True # 등록 성공 시 플래그 설정
+        logger.info("장치 관련 라우트 등록 완료")
+    except NameError:
+        logger.error("register_device_routes 함수를 찾을 수 없습니다. app.app_device_routes 모듈 확인 필요.")
+    except Exception as e:
+        logger.error(f"장치 관련 라우트 등록 실패: {e}", exc_info=True)
+else:
+    logger.info("장치 관련 라우트가 이미 등록되어 있어 건너<0xEB>뜁니다.")
+# --- 장치 관련 라우트 등록 끝 ---
+
+
+# --- 헬퍼 함수 ---
+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
+# --- 헬퍼 함수 끝 ---
+
+
+# init_retriever 함수 내부에 로깅 추가 예시
+# --- 검색기 초기화 관련 함수 ---
+def init_retriever():
+    """검색기 객체 초기화 또는 로드"""
+    global base_retriever, retriever
+
+    index_path = app.config['INDEX_PATH']
+    data_path = app.config['DATA_FOLDER'] # data_path 정의 확인
+    logger.info("--- init_retriever 시작 ---")
+
+    # 1. 기본 검색기 로드 또는 초기화
+    if os.path.exists(os.path.join(index_path, "documents.json")):
+        try:
+            logger.info(f"인덱스 로드 시도: {index_path}")
+            base_retriever = VectorRetriever.load(index_path)
+            logger.info(f"인덱스 로드 성공. 문서 {len(getattr(base_retriever, 'documents', []))}개")
+        except Exception as e:
+            logger.error(f"인덱스 로드 실패: {e}", exc_info=True)
+            logger.info("새 VectorRetriever 초기화 시도...")
+            try:
+                base_retriever = VectorRetriever()
+                logger.info("새 VectorRetriever 초기화 성공.")
+            except Exception as e_init:
+                logger.error(f"새 VectorRetriever 초기화 실패: {e_init}", exc_info=True)
+                base_retriever = None
+    else:
+        logger.info("인덱스 파일 없음. 새 VectorRetriever 초기화 시도...")
+        try:
+            base_retriever = VectorRetriever()
+            logger.info("새 VectorRetriever 초기화 성공.")
+        except Exception as e_init:
+            logger.error(f"새 VectorRetriever 초기화 실패: {e_init}", exc_info=True)
+            base_retriever = None
+
+    if base_retriever is None:
+        logger.error("base_retriever 초기화/로드에 실패하여 init_retriever 중단.")
+        return None
+
+    # 2. 데이터 폴더 문서 로드 (기본 검색기가 비어있을 때)
+    needs_loading = (not hasattr(base_retriever, 'documents') or not getattr(base_retriever, 'documents', None)) # None 체크 추가
+    if needs_loading and os.path.exists(data_path):
+        logger.info(f"기본 검색기가 비어있어 {data_path}에서 문서 로드 시도...")
+        try:
+            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)
+        except Exception as e_load_add:
+            logger.error(f"DATA_FOLDER 문서 로드/추가 중 오류: {e_load_add}", exc_info=True)
+
+    # 3. 재순위화 검색기 초기화
+    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_rerank:
+        logger.error(f"재순위화 검색기 초기화 실패: {e_rerank}", exc_info=True)
+        logger.warning("재순위화 실패, 기본 검색기를 retriever로 사용합니다.")
+        retriever = base_retriever # fallback
+
+    logger.info("--- init_retriever 종료 ---")
+    return retriever
+
+def background_init():
+    """백그라운드에서 검색기 초기화 수행"""
+    global app_ready, retriever, base_retriever, llm_interface, stt_client
+
+    temp_app_ready = False # 임시 상태 플래그
+    try:
+        logger.info("백그라운드 초기화 시작...")
+
+        # 1. LLM, STT 인터페이스 초기화 (필요 시)
+        if llm_interface is None or isinstance(llm_interface, MockComponent):
+             if 'LLMInterface' in globals() and LLMInterface != MockComponent:
+                 llm_interface = LLMInterface(default_llm="openai")
+                 logger.info("LLM 인터페이스 초기화 완료.")
+             else:
+                 logger.warning("LLMInterface 클래스 없음. Mock 사용.")
+                 llm_interface = MockComponent() # Mock 객체 보장
+        if stt_client is None or isinstance(stt_client, MockComponent):
+             if 'VitoSTT' in globals() and VitoSTT != MockComponent:
+                 stt_client = VitoSTT()
+                 logger.info("STT 클라이언트 초기화 완료.")
+             else:
+                 logger.warning("VitoSTT ��래스 없음. Mock 사용.")
+                 stt_client = MockComponent() # Mock 객체 보장
+
+
+        # 2. 검색기 초기화
+        if 'VectorRetriever' in globals() and VectorRetriever != MockComponent:
+            logger.info("실제 검색기 초기화 시도...")
+            retriever = init_retriever()
+            if hasattr(retriever, 'base_retriever') and base_retriever is None:
+                 base_retriever = retriever.base_retriever
+            elif base_retriever is None:
+                 logger.warning("init_retriever 후 base_retriever가 설정되지 않음. 확인 필요.")
+                 if isinstance(retriever, VectorRetriever):
+                      base_retriever = retriever
+
+            if retriever is not None and base_retriever is not None:
+                logger.info("검색기 (Retriever, Base Retriever) 초기화 성공")
+                temp_app_ready = True
+            else:
+                logger.error("검색기 초기화 후에도 retriever 또는 base_retriever가 None입니다.")
+                if base_retriever is None: base_retriever = MockComponent()
+                if retriever is None: retriever = MockComponent()
+                if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
+                if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
+                temp_app_ready = True
+
+        else:
+            logger.warning("VectorRetriever 클래스 없음. Mock 검색기 사용.")
+            base_retriever = MockComponent()
+            retriever = MockComponent()
+            if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
+            if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
+            temp_app_ready = True
+
+        logger.info(f"백그라운드 초기화 완료. 최종 상태: {'Ready' if temp_app_ready else 'Not Ready (Error during init)'}")
+
+    except Exception as e:
+        logger.error(f"앱 백그라운드 초기화 중 심각한 오류 발생: {e}", exc_info=True)
+        if base_retriever is None: base_retriever = MockComponent()
+        if retriever is None: retriever = MockComponent()
+        if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
+        if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
+        temp_app_ready = True
+        logger.warning("초기화 중 오류가 발생했지만 Mock 객체로 대체 후 앱 사용 가능 상태로 설정.")
+
+    finally:
+        # 최종적으로 app_ready 상태 업데이트
+        app_ready = temp_app_ready
+        # 장치 라우트 등록 호출은 여기서 제거됨 (메인 레벨에서 처리)
+
+# 백그라운드 스레드 시작 부분은 그대로 유지
+init_thread = threading.Thread(target=background_init)
+init_thread.daemon = True
+init_thread.start()
+
+
+# --- Flask 라우트 정의 ---
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    error = None
+    next_url = request.args.get('next') # 리디렉션할 URL 가져오기
+    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
+
+    current_time = datetime.datetime.now()
+    try:
+        start_time = datetime.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
+    except FileNotFoundError:
+        logger.warning("__file__ 경로를 찾을 수 없어 시간 비교 로직을 건너<0xEB>뜁니다.")
+        if not app_ready: # 기본 타임아웃 대신 간단한 로직 추가 가능
+             logger.warning("앱 준비 상태 확인 (시간 비교 불가)")
+             # 필요시 다른 준비 상태 확인 로직 추가
+             pass # 임시로 통과
+
+    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.route('/api/chat', methods=['POST'])
+@login_required
+def chat():
+    """텍스트 기반 챗봇 API"""
+    global retriever
+
+    if not app_ready or retriever is None:
+        return jsonify({"error": "앱/검색기가 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+
+    try:
+        data = request.get_json()
+        if not data or 'query' not in data:
+            return jsonify({"error": "쿼리가 제공되지 않았습니다."}), 400
+
+        query = data['query']
+        logger.info(f"텍스트 쿼리 수신: {query[:100]}...")
+
+        if not hasattr(retriever, 'search'):
+            raise NotImplementedError("Retriever에 search 메소드가 없습니다.")
+        search_results = retriever.search(query, top_k=5, first_stage_k=6)
+
+        if not hasattr(DocumentProcessor, 'prepare_rag_context'):
+            raise NotImplementedError("DocumentProcessor에 prepare_rag_context 메소드가 없습니다.")
+        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+
+        if not context:
+            logger.warning("검색 결과가 없어 컨텍스트를 생성하지 못함.")
+            pass
+
+        llm_id = data.get('llm_id', None)
+        if not hasattr(llm_interface, 'rag_generate'):
+            raise NotImplementedError("LLMInterface에 rag_generate 메소드가 없습니다.")
+
+        if not context:
+            answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+            logger.info("컨텍스트 없이 기본 응답 생성")
+        else:
+            answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
+            logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+
+
+        sources = []
+        if search_results:
+            for result in search_results:
+                if not isinstance(result, dict):
+                    logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
+                    continue
+
+                if "source" in result:
+                    source_info = {
+                        "source": result.get("source", "Unknown"),
+                        "score": result.get("rerank_score", result.get("score", 0))
+                    }
+
+                    if "text" in result and result.get("filetype") == "csv":
+                        try:
+                            text_lines = result["text"].strip().split('\n')
+                            if text_lines:
+                                first_line = text_lines[0].strip()
+                                if ',' in first_line:
+                                    first_column = first_line.split(',')[0].strip()
+                                    source_info["id"] = first_column
+                                    logger.debug(f"CSV 소스 ID 추출: {first_column} from {source_info['source']}")
+                        except Exception as e:
+                            logger.warning(f"CSV 소스 ID 추출 실패 ({result.get('source')}): {e}")
+
+                    sources.append(source_info)
+
+        response_data = {
+            "answer": answer,
+            "sources": sources,
+            "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
+        }
+        return jsonify(response_data)
+
+    except Exception as e:
+        logger.error(f"채팅 처리 중 오류 발생: {e}", exc_info=True)
+        return jsonify({"error": f"처리 중 오류가 발생했습니다: {str(e)}"}), 500
+
+
+@app.route('/api/voice', methods=['POST'])
+@login_required
+def voice_chat():
+    """음성 챗 API 엔드포인트"""
+    global retriever, stt_client
+
+    if not app_ready:
+        logger.warning("앱 초기화가 완료되지 않았지만 음성 API 요청 처리 시도")
+
+    if retriever is None:
+        logger.error("retriever가 아직 초기화되지 않았습니다")
+        return jsonify({
+            "transcription": "(음성을 텍스트로 변환했지만 검색 엔진이 아직 준비되지 않았습니다)",
+            "answer": "죄송합니다. 검색 엔진이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요.",
+            "sources": []
+        })
+    if stt_client is None:
+        return jsonify({
+            "transcription": "(음성 인식 기능이 준비 중입니다)",
+            "answer": "죄송합니다. 현재 음성 인식 서비스가 초기화 중입니다. 잠시 후 다시 시도해주세요.",
+            "sources": []
+        })
+
+    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) as temp_audio:
+            audio_file.save(temp_audio.name)
+            logger.info(f"오디오 파일을 임시 저장: {temp_audio.name}")
+
+            if not hasattr(stt_client, 'transcribe_audio'):
+                raise NotImplementedError("STT 클라이언트에 transcribe_audio 메소드가 없습니다.")
+
+            with open(temp_audio.name, 'rb') as f_bytes:
+                audio_bytes = f_bytes.read()
+            stt_result = stt_client.transcribe_audio(audio_bytes, language="ko")
+
+
+        if not isinstance(stt_result, dict) or not stt_result.get("success"):
+            error_msg = stt_result.get("error", "알 수 없는 STT 오류") if isinstance(stt_result, dict) else "STT 결과 형식 오류"
+            logger.error(f"음성인식 실패: {error_msg}")
+            return jsonify({
+                "error": "음성인식 실패",
+                "details": error_msg
+            }), 500
+
+        transcription = stt_result.get("text", "")
+        if not transcription:
+            logger.warning("음성인식 결과가 비어있습니다.")
+            return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다.", "transcription": ""}), 400
+
+        logger.info(f"음성인식 성공: {transcription[:50]}...")
+        if retriever is None:
+            logger.error("STT 성공 후 검색 시도 중 retriever가 None임")
+            return jsonify({
+                "transcription": transcription,
+                "answer": "음성을 인식했지만, 현재 검색 시스템이 준비되지 않았습니다. 잠시 후 다시 시도해주세요.",
+                "sources": []
+            })
+
+        search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
+        context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+
+        if not context:
+            logger.warning("음성 쿼리에 대한 검색 결과 없음.")
+            pass
+
+        llm_id = request.form.get('llm_id', None)
+        if not context:
+            answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+            logger.info("컨텍스트 없이 기본 응답 생성")
+        else:
+            answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
+            logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+
+        enhanced_sources = []
+        if search_results:
+            for doc in search_results:
+                if not isinstance(doc, dict): continue
+                if "source" in doc:
+                    source_info = {
+                        "source": doc.get("source", "Unknown"),
+                        "score": doc.get("rerank_score", doc.get("score", 0))
+                    }
+                    if "text" in doc and doc.get("filetype") == "csv":
+                        try:
+                            text_lines = doc["text"].strip().split('\n')
+                            if text_lines:
+                                first_line = text_lines[0].strip()
+                                if ',' in first_line:
+                                    first_column = first_line.split(',')[0].strip()
+                                    source_info["id"] = first_column
+                        except Exception as e:
+                            logger.warning(f"[음성챗] CSV 소스 ID 추출 실패 ({doc.get('source')}): {e}")
+                    enhanced_sources.append(source_info)
+
+        response_data = {
+            "transcription": transcription,
+            "answer": answer,
+            "sources": enhanced_sources,
+            "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
+        }
+        return jsonify(response_data)
+
+    except Exception as e:
+        logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
+        return jsonify({
+            "error": "음성 처리 중 내부 오류 발생",
+            "details": str(e)
+        }), 500
+
+
+@app.route('/api/upload', methods=['POST'])
+@login_required
+def upload_document():
+    """지식베이스 문서 업로드 API"""
+    global base_retriever, retriever
+
+    if not app_ready or base_retriever is None:
+        return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503
+
+    if 'document' not in request.files:
+        return jsonify({"error": "문서 파일이 제공되지 않았습니다."}), 400
+
+    doc_file = request.files['document']
+    if doc_file.filename == '':
+        return jsonify({"error": "선택된 파일이 없습니다."}), 400
+
+    if not allowed_doc_file(doc_file.filename):
+        logger.error(f"허용되지 않는 파일 형식: {doc_file.filename}")
+        return jsonify({"error": f"허용되지 않는 파일 형식입니다. 허용: {', '.join(ALLOWED_DOC_EXTENSIONS)}"}), 400
+
+    try:
+        filename = secure_filename(doc_file.filename)
+        filepath = os.path.join(app.config['DATA_FOLDER'], filename)
+        doc_file.save(filepath)
+        logger.info(f"문서 저장 완료: {filepath}")
+
+        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
+
+        metadata = {
+            "source": filename, "filename": filename,
+            "filetype": filename.rsplit('.', 1)[1].lower(),
+            "filepath": filepath
+        }
+        file_ext = metadata["filetype"]
+        docs = []
+
+        if not hasattr(DocumentProcessor, 'csv_to_documents') or not hasattr(DocumentProcessor, 'text_to_documents'):
+            raise NotImplementedError("DocumentProcessor에 필요한 메소드 없음")
+
+        if file_ext == 'csv':
+            logger.info(f"CSV 파일 처리 시작: {filename}")
+            docs = DocumentProcessor.csv_to_documents(content, metadata)
+        else:
+            logger.info(f"일반 텍스트 문서 처리 시작: {filename}")
+            if file_ext in ['pdf', 'docx']:
+                logger.warning(f".{file_ext} 파일 처리는 현재 구현되지 않았습니다. 텍스트 추출 로직 추가 필요.")
+                content = ""
+
+            if content:
+                docs = DocumentProcessor.text_to_documents(
+                    content, metadata=metadata,
+                    chunk_size=512, chunk_overlap=50
+                )
+
+        if docs:
+            if not hasattr(base_retriever, 'add_documents') or not hasattr(base_retriever, 'save'):
+                raise NotImplementedError("기본 검색기에 add_documents 또는 save 메소드 없음")
+
+            logger.info(f"{len(docs)}개 문서 청크를 검색기에 추가합니다...")
+            base_retriever.add_documents(docs)
+
+            logger.info(f"검색기 상태를 저장합니다...")
+            index_path = app.config['INDEX_PATH']
+            try:
+                base_retriever.save(index_path)
+                logger.info("인덱스 저장 완료")
+                # 재순위화 검색기 업데이트 로직 필요 시 추가
+                # 예: if retriever != base_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}")
+                return jsonify({"error": f"인덱스 저장 중 오류: {str(e_save)}"}), 500
+        else:
+            logger.warning(f"파일 '{filename}'에서 처리할 내용이 없거나 지원되지 않는 형식입니다.")
+            return jsonify({
+                "warning": True,
+                "message": f"파일 '{filename}'이 저장되었지만 처리할 내용이 없습니다."
+            })
+
+    except Exception as e:
+        logger.error(f"파일 업로드 또는 처리 중 오류 발생: {e}", exc_info=True)
+        return jsonify({"error": f"파일 업로드 중 오류: {str(e)}"}), 500
+
+
+@app.route('/api/documents', methods=['GET'])
+@login_required
+def list_documents():
+    """지식베이스 문서 목록 API"""
+    global base_retriever
+
+    if not app_ready or base_retriever is None:
+        return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503
+
+    try:
+        sources = {}
+        total_chunks = 0
+        if hasattr(base_retriever, 'documents') and base_retriever.documents:
+            logger.info(f"총 {len(base_retriever.documents)}개 문서 청크에서 소스 목록 생성 중...")
+            for doc in base_retriever.documents:
+                if not isinstance(doc, dict): continue
+
+                source = doc.get("source", "unknown")
+                if source == "unknown" and "metadata" in doc and isinstance(doc["metadata"], dict):
+                    source = doc["metadata"].get("source", "unknown")
+
+                if source != "unknown":
+                    if source in sources:
+                        sources[source]["chunks"] += 1
+                    else:
+                        filename = doc.get("filename", source)
+                        filetype = doc.get("filetype", "unknown")
+                        if "metadata" in doc and isinstance(doc["metadata"], dict):
+                            filename = doc["metadata"].get("filename", filename)
+                            filetype = doc["metadata"].get("filetype", filetype)
+
+                        sources[source] = {
+                            "filename": filename,
+                            "chunks": 1,
+                            "filetype": filetype
+                        }
+                total_chunks += 1
+        else:
+            logger.info("검색기에 문서가 없거나 documents 속성을 찾을 수 없습니다.")
+
+        documents = [{"source": src, **info} for src, info in sources.items()]
+        documents.sort(key=lambda x: x["chunks"], reverse=True)
+
+        logger.info(f"문서 목록 조회 완료: {len(documents)}개 소스 파일, {total_chunks}개 청크")
+        return jsonify({
+            "documents": documents,
+            "total_documents": len(documents),
+            "total_chunks": total_chunks
+        })
+
+    except Exception as e:
+        logger.error(f"문서 목록 조회 중 오류 발생: {e}", exc_info=True)
+        return jsonify({"error": f"문서 목록 조회 중 오류: {str(e)}"}), 500
+
+
+# 정적 파일 서빙
+@app.route('/static/<path:path>')
+def send_static(path):
+    return send_from_directory('static', path)
+
+
+# --- 요청 처리 훅 ---
+
+@app.after_request
+def after_request_func(response):
+    """모든 응답에 대해 후처리 수행"""
+    # logger.debug(f"[After Request] 응답 헤더: {response.headers}") # 디버깅 시 Set-Cookie 확인
+    return response
+
+
+# 앱 실행 (로컬 테스트용)
+if __name__ == '__main__':
+    logger.info("Flask 앱을 직접 실행합니다 (개발용 서버).")
+    # 디버그 모드는 개발 중에만 True로 설정하고, 실제 배포 시에는 False로 설정해야 합니다.
+    # host='0.0.0.0' 은 모든 네트워크 인터페이스에서 접속 가능하게 합니다.
+    port = int(os.environ.get("PORT", 7860))
+    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
+    # debug=True 사용 시 werkzeug reloader가 활성화되어 코드가 변경될 때 서버가 재시작될 수 있으며,
+    # 이 과정에서 전역 초기화 코드가 다시 실행될 수 있습니다.
+    # DEVICE_ROUTES_REGISTERED 플래그가 이를 방지합니다.
+    app.run(debug=True, host='0.0.0.0', port=port)

app/app_device_routes.py

@@ -0,0 +1,378 @@
+"""
+RAG 검색 챗봇 웹 애플리케이션 - 장치 관리 API 라우트 정의 (API 경로 수정됨)
+"""
+
+import logging
+import requests
+from flask import request, jsonify
+
+# 로거 가져오기
+logger = logging.getLogger(__name__)
+
+def register_device_routes(app, login_required, DEVICE_SERVER_URL):
+    """Flask 애플리케이션에 장치 관리 관련 라우트 등록"""
+    
+    # 사용자 지정 장치 서버 URL 변수
+    custom_device_url = None
+    
+    # URL 설정 함수
+    def get_device_url():
+        # 사용자 지정 URL이 있으면 사용, 없으면 환경변수 값 사용
+        return custom_device_url or DEVICE_SERVER_URL
+    
+    @app.route('/api/device/connect', methods=['POST'])
+    @login_required
+    def connect_device_server():
+        """사용자 지정 장치 서버 URL 연결 API"""
+        nonlocal custom_device_url  # 상위 스코프의 변수 참조
+        
+        try:
+            # 요청에서 URL 가져오기
+            request_data = request.get_json()
+            if not request_data or 'url' not in request_data:
+                logger.error("URL이 제공되지 않았습니다.")
+                return jsonify({
+                    "success": False,
+                    "error": "URL이 제공되지 않았습니다."
+                }), 400  # Bad Request
+            
+            new_url = request_data['url'].strip()
+            if not new_url:
+                logger.error("URL이 비어 있습니다.")
+                return jsonify({
+                    "success": False, 
+                    "error": "URL이 비어 있습니다."
+                }), 400  # Bad Request
+            
+            # URL 설정
+            logger.info(f"사용자 지정 장치 서버 URL 설정: {new_url}")
+            custom_device_url = new_url
+            
+            # 설정된 URL로 상태 확인 시도
+            try:
+                api_path = "/api/status"
+                logger.info(f"장치 서버 상태 확인 요청: {custom_device_url}{api_path}")
+                response = requests.get(f"{custom_device_url}{api_path}", timeout=5)
+                
+                if response.status_code == 200:
+                    try:
+                        data = response.json()
+                        logger.info(f"사용자 지정 장치 서버 연결 성공. 응답 데이터: {data}")
+                        return jsonify({
+                            "success": True,
+                            "message": "장치 서버 연결에 성공했습니다.",
+                            "server_status": data.get("status", "정상")
+                        })
+                    except requests.exceptions.JSONDecodeError:
+                        logger.error("장치 서버 응답 JSON 파싱 실패")
+                        return jsonify({
+                            "success": False,
+                            "error": "장치 서버로부터 유효하지 않은 JSON 응답을 받았습니다."
+                        }), 502  # Bad Gateway
+                else:
+                    error_message = f"장치 서버 응답 오류: {response.status_code}"
+                    try:
+                        error_detail = response.json().get("error", response.text)
+                        error_message += f" - {error_detail}"
+                    except Exception:
+                        error_message += f" - {response.text}"
+                    
+                    logger.warning(error_message)
+                    custom_device_url = None  # 연결 실패 시 URL 초기화
+                    return jsonify({
+                        "success": False,
+                        "error": error_message
+                    }), 502  # Bad Gateway
+            
+            except requests.exceptions.Timeout:
+                logger.error(f"장치 서버 연결 타임아웃 ({custom_device_url})")
+                custom_device_url = None  # 연결 실패 시 URL 초기화
+                return jsonify({
+                    "success": False,
+                    "error": "장치 서버 연결 타임아웃. 서버 응답이 너무 느립니다."
+                }), 504  # Gateway Timeout
+            
+            except requests.exceptions.ConnectionError:
+                logger.error(f"장치 관리 서버 연결 실패 ({custom_device_url})")
+                custom_device_url = None  # 연결 실패 시 URL 초기화
+                return jsonify({
+                    "success": False,
+                    "error": "장치 관리 서버에 연결할 수 없습니다. 서버가 실행 중인지, URL이 정확한지 확인해주세요."
+                }), 502  # Bad Gateway
+            
+            except Exception as e:
+                logger.error(f"장치 서버 연결 중 예상치 못한 오류 발생: {e}", exc_info=True)
+                custom_device_url = None  # 연결 실패 시 URL 초기화
+                return jsonify({
+                    "success": False,
+                    "error": f"장치 서버 연결 중 오류 발생: {str(e)}"
+                }), 500  # Internal Server Error
+        
+        except Exception as e:
+            logger.error(f"/api/device/connect 처리 중 내부 서버 오류: {e}", exc_info=True)
+            return jsonify({
+                "success": False,
+                "error": f"내부 서버 오류 발생: {str(e)}"
+            }), 500  # Internal Server Error
+
+    @app.route('/api/device/status', methods=['GET'])
+    @login_required
+    def device_status():
+        """장치 관리 서버의 상태를 확인하는 API 엔드포인트"""
+        try:
+            # requests 라이브러리는 함수 내에서 임포트할 필요 없음 (상단 임포트 사용)
+            # json, jsonify도 Flask에서 이미 임포트됨 (상단 임포트 사용)
+
+            # 연결 타임아웃 설정
+            timeout = 5  # 5초로 타임아웃 설정
+
+            try:
+                # 장치 서버 상태 확인 - 경로: /api/status
+                current_device_url = get_device_url()
+                api_path = "/api/status"
+                logger.info(f"장치 서버 상태 확인 요청: {current_device_url}{api_path}")
+                response = requests.get(f"{current_device_url}{api_path}", timeout=timeout)
+
+                # 응답 상태 코드 및 내용 로깅 (디버깅 강화)
+                logger.debug(f"장치 서버 응답 상태 코드: {response.status_code}")
+                try:
+                    logger.debug(f"장치 서버 응답 내용: {response.text[:200]}...") # 너무 길면 잘라서 로깅
+                except Exception:
+                     logger.debug("장치 서버 응답 내용 로깅 실패 (텍스트 형식 아님?)")
+
+
+                if response.status_code == 200:
+                    # 성공 시 응답 데이터 구조 확인 및 로깅
+                    try:
+                        data = response.json()
+                        logger.info(f"장치 서버 상태 확인 성공. 응답 데이터: {data}")
+                        return jsonify({"success": True, "status": "connected", "data": data})
+                    except requests.exceptions.JSONDecodeError:
+                        logger.error("장치 서버 응답 JSON 파싱 실패")
+                        return jsonify({
+                            "success": False,
+                            "error": "장치 서버로부터 유효하지 않은 JSON 응답을 받았습니다."
+                        }), 502 # Bad Gateway (업스트림 서버 오류)
+                else:
+                    # 실패 시 오류 메시지 포함 로깅
+                    error_message = f"장치 서버 응답 오류: {response.status_code}"
+                    try:
+                         # 서버에서 오류 메시지를 json으로 보내는 경우 포함
+                         error_detail = response.json().get("error", response.text)
+                         error_message += f" - {error_detail}"
+                    except Exception:
+                         error_message += f" - {response.text}" # JSON 파싱 실패 시 원본 텍스트
+
+                    logger.warning(error_message) # 경고 레벨로 로깅
+                    return jsonify({
+                        "success": False,
+                        "error": error_message
+                    }), 502  # Bad Gateway
+
+            except requests.exceptions.Timeout:
+                logger.error(f"장치 서버 연결 타임아웃 ({DEVICE_SERVER_URL})")
+                return jsonify({
+                    "success": False,
+                    "error": "장치 서버 연결 타임아웃. 서버 응답이 너무 느립니다."
+                }), 504  # Gateway Timeout
+
+            except requests.exceptions.ConnectionError:
+                current_device_url = get_device_url()
+                logger.error(f"장치 관리 서버 연결 실패 ({current_device_url})")
+                return jsonify({
+                    "success": False,
+                    "error": "장치 관리 서버에 연결할 수 없습니다. 서버가 실행 중인지, URL이 정확한지 확인해주세요."
+                }), 502  # Bad Gateway (연결 실패도 업스트림 문제로 간주)
+
+            except Exception as e:
+                logger.error(f"장치 서버 연결 중 예상치 못한 오류 발생: {e}", exc_info=True) # 상세 스택 트레이스 로깅
+                return jsonify({
+                    "success": False,
+                    "error": f"장치 서버 연결 중 오류 발생: {str(e)}"
+                }), 500  # Internal Server Error (Flask 앱 내부 또는 requests 라이브러리 문제 가능성)
+
+        except Exception as e:
+            # 이 try-except 블록은 /api/device/status 라우트 자체의 내부 오류 처리
+            logger.error(f"/api/device/status 처리 중 내부 서버 오류: {e}", exc_info=True)
+            return jsonify({
+                "success": False,
+                "error": f"��부 서버 오류 발생: {str(e)}"
+            }), 500  # Internal Server Error
+
+    @app.route('/api/device/list', methods=['GET'])
+    @login_required
+    def device_list():
+        """장치 목록 조회 API"""
+        logger.info("장치 목록 조회 요청")
+
+        try:
+            current_device_url = get_device_url()
+            api_path = "/api/devices"
+            logger.info(f"장치 목록 조회 요청: {current_device_url}{api_path}")
+            response = requests.get(f"{current_device_url}{api_path}", timeout=5)
+            logger.debug(f"장치 목록 응답 상태 코드: {response.status_code}")
+
+            if response.status_code == 200:
+                try:
+                    data = response.json()
+                    devices = data.get("devices", [])
+                    logger.info(f"장치 목록 조회 성공: {len(devices)}개 장치")
+                    return jsonify({
+                        "success": True,
+                        "devices": devices
+                    })
+                except requests.exceptions.JSONDecodeError:
+                     logger.error("장치 목록 응답 JSON 파싱 실패")
+                     return jsonify({"success": False, "error": "장치 서버로부터 유효하지 않은 JSON 응답"}), 502
+            else:
+                error_message = f"장치 목록 조회 실패: {response.status_code}"
+                try: error_message += f" - {response.json().get('error', response.text)}"
+                except Exception: error_message += f" - {response.text}"
+                logger.warning(error_message)
+                return jsonify({
+                    "success": False,
+                    "error": error_message
+                }), 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 # Service Unavailable
+
+        except Exception as e:
+            logger.error(f"장치 목록 조회 중 오류 발생: {e}", exc_info=True)
+            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:
+            current_device_url = get_device_url()
+            api_path = "/api/programs"
+            logger.info(f"프로그램 목록 조회 요청: {current_device_url}{api_path}")
+            response = requests.get(f"{current_device_url}{api_path}", timeout=5)
+            logger.debug(f"프로그램 목록 응답 상태 코드: {response.status_code}")
+
+
+            if response.status_code == 200:
+                try:
+                    data = response.json()
+                    programs = data.get("programs", [])
+                    logger.info(f"프로그램 목록 조회 성공: {len(programs)}개 프로그램")
+                    return jsonify({
+                        "success": True,
+                        "programs": programs
+                    })
+                except requests.exceptions.JSONDecodeError:
+                     logger.error("프로그램 목록 응답 JSON 파싱 실패")
+                     return jsonify({"success": False, "error": "장치 서버로부터 유효하지 않은 JSON 응답"}), 502
+            else:
+                error_message = f"프로그램 목록 조회 실패: {response.status_code}"
+                try: error_message += f" - {response.json().get('error', response.text)}"
+                except Exception: error_message += f" - {response.text}"
+                logger.warning(error_message)
+                return jsonify({
+                    "success": False,
+                    "error": error_message
+                }), 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}", exc_info=True)
+            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:
+            current_device_url = get_device_url()
+            api_path = f"/api/programs/{program_id}/execute"
+            logger.info(f"프로그램 실행 요청: {current_device_url}{api_path}")
+            response = requests.post(
+                f"{current_device_url}{api_path}",
+                json={}, # 필요시 여기에 파라미터 추가 가능
+                timeout=10  # 프로그램 실행에는 더 긴 시간 부여
+            )
+            logger.debug(f"프로그램 실행 응답 상태 코드: {response.status_code}")
+
+
+            if response.status_code == 200:
+                try:
+                    data = response.json()
+                    success = data.get("success", False)
+                    message = data.get("message", "")
+                    logger.info(f"프로그램 실행 응답: {success}, {message}")
+                    return jsonify(data) # 서버 응답 그대로 반환
+                except requests.exceptions.JSONDecodeError:
+                    logger.error("프로그램 실행 응답 JSON 파싱 실패")
+                    # 성공(200)했지만 응답이 비정상적인 경우
+                    return jsonify({
+                        "success": False, # 파싱 실패했으므로 False로 간주
+                        "error": "프로그램 실행 서버로부터 유효하지 않은 JSON 응답"
+                        }), 502
+            else:
+                error_message = f"프로그램 실행 요청 실패: {response.status_code}"
+                try: error_message += f" - {response.json().get('error', response.text)}"
+                except Exception: error_message += f" - {response.text}"
+                logger.warning(error_message)
+                return jsonify({
+                    "success": False,
+                    "error": error_message
+                }), 502 # 또는 response.status_code 를 그대로 반환하는 것도 고려
+
+        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}", exc_info=True)
+            return jsonify({
+                "success": False,
+                "error": f"프로그램 실행 중 오류 발생: {str(e)}"
+            }), 500

app/app_part2.py

@@ -0,0 +1,209 @@
+# --- 임베딩 관련 헬퍼 함수 ---
+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

@@ -0,0 +1,163 @@
+# --- 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

@@ -0,0 +1,268 @@
+"""
+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)

app/app_routes.py

@@ -0,0 +1,297 @@
+"""
+RAG 검색 챗봇 웹 애플리케이션 - API 라우트 정의
+"""
+
+import os
+import json
+import logging
+import tempfile
+import requests
+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__)
+
+def register_routes(app, login_required, llm_interface, retriever, stt_client, DocumentProcessor, base_retriever, app_ready, 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
+
+    # 임베딩 저장 함수
+    def save_embeddings(base_retriever, file_path):
+        """임베딩 데이터를 압축하여 파일에 저장"""
+        import pickle
+        import gzip
+        
+        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
+
+    @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():
+        """메인 페이지"""
+        nonlocal 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"""
+        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.route('/api/chat', methods=['POST'])
+    @login_required
+    def chat():
+        """텍스트 기반 챗봇 API"""
+        if not app_ready or retriever is None:
+            return jsonify({"error": "앱/검색기가 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+
+        try:
+            data = request.get_json()
+            if not data or 'query' not in data:
+                return jsonify({"error": "쿼리가 제공���지 않았습니다."}), 400
+
+            query = data['query']
+            logger.info(f"텍스트 쿼리 수신: {query[:100]}...")
+
+            # RAG 검색 수행
+            if not hasattr(retriever, 'search'):
+                raise NotImplementedError("Retriever에 search 메소드가 없습니다.")
+            search_results = retriever.search(query, top_k=5, first_stage_k=6)
+
+            # 컨텍스트 준비
+            if not hasattr(DocumentProcessor, 'prepare_rag_context'):
+                raise NotImplementedError("DocumentProcessor에 prepare_rag_context 메소드가 없습니다.")
+            context = DocumentProcessor.prepare_rag_context(search_results, field="text")
+
+            if not context:
+                logger.warning("검색 결과가 없어 컨텍스트를 생성하지 못함.")
+
+            # LLM에 질의
+            llm_id = data.get('llm_id', None)
+            if not hasattr(llm_interface, 'rag_generate'):
+                raise NotImplementedError("LLMInterface에 rag_generate 메소드가 없습니다.")
+
+            if not context:
+                answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
+                logger.info("컨텍스트 없이 기본 응답 생성")
+            else:
+                answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
+                logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+
+            # 소스 정보 추출 (CSV ID 추출 로직 포함)
+            sources = []
+            if search_results:
+                for result in search_results:
+                    if not isinstance(result, dict):
+                        logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
+                        continue
+
+                    if "source" in result:
+                        source_info = {
+                            "source": result.get("source", "Unknown"),
+                            "score": result.get("rerank_score", result.get("score", 0))
+                        }
+
+                        # CSV 파일 특정 처리
+                        if "text" in result and result.get("filetype") == "csv":
+                            try:
+                                text_lines = result["text"].strip().split('\n')
+                                if text_lines:
+                                    first_line = text_lines[0].strip()
+                                    if ',' in first_line:
+                                        first_column = first_line.split(',')[0].strip()
+                                        source_info["id"] = first_column
+                                        logger.debug(f"CSV 소스 ID 추출: {first_column} from {source_info['source']}")
+                            except Exception as e:
+                                logger.warning(f"CSV 소스 ID 추출 실패 ({result.get('source')}): {e}")
+
+                        sources.append(source_info)
+
+            # 최종 응답
+            response_data = {
+                "answer": answer,
+                "sources": sources,
+                "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
+            }
+            return jsonify(response_data)
+
+        except Exception as e:
+            logger.error(f"채팅 처리 중 오류 발생: {e}", exc_info=True)
+            return jsonify({"error": f"처리 중 오류가 발생했습니다: {str(e)}"}), 500

app/docs/project_plan.md

@@ -0,0 +1,44 @@
+# RAG 챗봇 + LocalPCAgent 통합 프로젝트 계획
+
+## 프로젝트 개요
+
+이 프로젝트는 RAG 챗봇 백엔드(Flask 기반)와 LocalPCAgent 제어 인터페이스를 통합하는 것을 목표로 합니다. 사용자는 RAG 챗봇 인터페이스 내에서 LocalPCAgent를 통해 원격으로 PC를 제어할 수 있게 됩니다.
+
+## 완료된 작업
+
+### 1. 장치 서버 연결 기능 개선 (2025-05-02)
+
+- `app-device.js` 파일에서 `connectServer()` 함수 수정:
+  - 환경변수에 저장된 URL을 우선적으로 사용하도록 수정
+  - 텍스트박스에 입력된 URL 주소는 환경변수 URL 연결 실패 시 백업으로 사용
+  - 연결 상태 및 오류 메시지 개선
+
+- `app_device_routes.py` 파일에 새로운 기능 추가:
+  - 사용자 지정 URL 저장을 위한 `custom_device_url` 변수 추가
+  - URL 관리를 위한 `get_device_url()` 함수 구현
+  - `/api/device/connect` 엔드포인트 추가하여 사용자 지정 URL 설정 기능 구현
+  - 모든 API 엔드포인트에서 `get_device_url()` 함수를 사용하도록 업데이트
+
+## 예정된 작업
+
+### 1. 추가 UI 개선
+
+- 장치 서버 URL 입력 필드에 기본 텍스트 추가 (예: "환경변수에 저장된 URL 사용, 또는 직접 입력")
+- 연결 성공/실패 시 UI 피드백 개선
+
+### 2. 오류 처리 강화
+
+- 오류 메시지 개선 및 더 구체적인 가이드 제공
+- 네트워크 오류 발생 시 자동 재시도 기능
+
+### 3. 테스트
+
+- 환경변수 URL 및 사용자 지정 URL 전환 테스트
+- 다양한 오류 상황 시뮬레이션 및 복구 테스트
+
+## 기술 스택
+
+- 프론트엔드: JavaScript, HTML, CSS
+- 백엔드: Flask (Python)
+- 통신: RESTful API
+- 장치 제어: LocalPCAgent API

app/init_retriever.py

@@ -0,0 +1,149 @@
+"""
+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/static/css/device-style.css

@@ -0,0 +1,316 @@
+/* 장치 제어 관련 스타일 */
+
+/* 장치 제어 섹션 */
+#deviceSection {
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+    max-width: 1000px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+/* 장치 연결 컨테이너 */
+.device-connection {
+    background-color: var(--bg-color-secondary);
+    border-radius: 8px;
+    padding: 15px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.device-connection h3 {
+    margin-top: 0;
+    margin-bottom: 15px;
+    color: var(--text-color-primary);
+    font-size: 1.2rem;
+}
+
+.device-connection-form {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 15px;
+}
+
+.device-connection-form input {
+    flex: 1;
+    padding: 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-size: 0.95rem;
+}
+
+.device-connection-form button {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    padding: 10px 15px;
+    cursor: pointer;
+    font-weight: 500;
+    transition: background-color 0.2s;
+}
+
+.device-connection-form button:hover {
+    background-color: var(--primary-color-dark);
+}
+
+.device-connection-form button:disabled {
+    background-color: var(--disabled-color);
+    cursor: not-allowed;
+}
+
+.connection-status {
+    padding: 10px;
+    border-radius: 4px;
+    font-size: 0.9rem;
+}
+
+.connection-status.connected {
+    background-color: rgba(25, 135, 84, 0.1);
+    color: #198754;
+    border: 1px solid rgba(25, 135, 84, 0.2);
+}
+
+.connection-status.disconnected {
+    background-color: rgba(108, 117, 125, 0.1);
+    color: #6c757d;
+    border: 1px solid rgba(108, 117, 125, 0.2);
+}
+
+.connection-status.error {
+    background-color: rgba(220, 53, 69, 0.1);
+    color: #dc3545;
+    border: 1px solid rgba(220, 53, 69, 0.2);
+}
+
+/* 장치 기능 컨테이너 */
+.device-functions {
+    background-color: var(--bg-color-secondary);
+    border-radius: 8px;
+    padding: 15px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    display: none; /* 초기에는 숨김 */
+}
+
+.device-functions.active {
+    display: block;
+}
+
+.device-functions h3 {
+    margin-top: 0;
+    margin-bottom: 15px;
+    color: var(--text-color-primary);
+    font-size: 1.2rem;
+}
+
+.function-buttons {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 15px;
+    flex-wrap: wrap;
+}
+
+.function-buttons button {
+    background-color: var(--secondary-color);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    padding: 8px 12px;
+    cursor: pointer;
+    font-size: 0.9rem;
+    transition: background-color 0.2s;
+}
+
+.function-buttons button:hover {
+    background-color: var(--secondary-color-dark);
+}
+
+.function-buttons button:disabled {
+    background-color: var(--disabled-color);
+    cursor: not-allowed;
+}
+
+.device-status-result {
+    width: 100%;
+    min-height: 100px;
+    max-height: 200px;
+    padding: 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-family: monospace;
+    font-size: 0.9rem;
+    overflow-y: auto;
+    background-color: var(--bg-color-tertiary);
+    margin-bottom: 15px;
+    resize: vertical;
+}
+
+/* 프로그램 실행 컨테이너 */
+.program-control {
+    background-color: var(--bg-color-secondary);
+    border-radius: 8px;
+    padding: 15px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    display: none; /* 초기에는 숨김 */
+}
+
+.program-control.active {
+    display: block;
+}
+
+.program-control h3 {
+    margin-top: 0;
+    margin-bottom: 15px;
+    color: var(--text-color-primary);
+    font-size: 1.2rem;
+}
+
+.program-list-container {
+    margin-bottom: 20px;
+}
+
+.program-list {
+    width: 100%;
+    border-collapse: collapse;
+    margin-bottom: 15px;
+}
+
+.program-list th, .program-list td {
+    padding: 10px;
+    text-align: left;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.program-list th {
+    background-color: var(--bg-color-tertiary);
+    font-weight: 500;
+}
+
+.program-list tr:hover {
+    background-color: var(--bg-color-tertiary);
+}
+
+.program-select-container {
+    margin-bottom: 15px;
+}
+
+.program-select-container select {
+    width: 100%;
+    padding: 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    font-size: 0.95rem;
+    background-color: var(--bg-color-tertiary);
+}
+
+.execute-btn {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    padding: 10px 15px;
+    cursor: pointer;
+    font-weight: 500;
+    transition: background-color 0.2s;
+    width: 100%;
+    margin-bottom: 15px;
+}
+
+.execute-btn:hover {
+    background-color: var(--primary-color-dark);
+}
+
+.execute-btn:disabled {
+    background-color: var(--disabled-color);
+    cursor: not-allowed;
+}
+
+.execute-result {
+    padding: 10px;
+    border-radius: 4px;
+    margin-top: 10px;
+    font-size: 0.9rem;
+}
+
+.execute-result.success {
+    background-color: rgba(25, 135, 84, 0.1);
+    color: #198754;
+    border: 1px solid rgba(25, 135, 84, 0.2);
+}
+
+.execute-result.error {
+    background-color: rgba(220, 53, 69, 0.1);
+    color: #dc3545;
+    border: 1px solid rgba(220, 53, 69, 0.2);
+}
+
+.execute-result.warning {
+    background-color: rgba(255, 193, 7, 0.1);
+    color: #ffc107;
+    border: 1px solid rgba(255, 193, 7, 0.2);
+}
+
+/* 로딩 표시 */
+.loading-spinner {
+    display: inline-block;
+    width: 16px;
+    height: 16px;
+    border: 2px solid rgba(0, 0, 0, 0.1);
+    border-radius: 50%;
+    border-top-color: var(--primary-color);
+    animation: spin 1s ease-in-out infinite;
+    margin-right: 8px;
+    vertical-align: middle;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+.loading-message {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 20px;
+    font-size: 0.95rem;
+    color: var(--text-color-secondary);
+}
+
+/* 에러 메시지 */
+.error-message {
+    background-color: rgba(220, 53, 69, 0.1);
+    color: #dc3545;
+    border: 1px solid rgba(220, 53, 69, 0.2);
+    padding: 10px;
+    border-radius: 4px;
+    margin-top: 10px;
+    font-size: 0.9rem;
+}
+
+/* 없음 메시지 */
+.no-programs-message {
+    text-align: center;
+    padding: 20px;
+    font-size: 0.95rem;
+    color: var(--text-color-secondary);
+    border: 1px dashed var(--border-color);
+    border-radius: 4px;
+    margin-top: 10px;
+}
+
+/* 재시도 버튼 */
+.retry-button {
+    background-color: var(--secondary-color);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    padding: 8px 12px;
+    cursor: pointer;
+    font-size: 0.9rem;
+    margin-top: 10px;
+    transition: background-color 0.2s;
+}
+
+.retry-button:hover {
+    background-color: var(--secondary-color-dark);
+}

app/static/css/style.css

@@ -0,0 +1,518 @@
+/* 기본 스타일 */
+:root {
+    --primary-color: #4a6da7;
+    --primary-dark: #345089;
+    --secondary-color: #f59e0b;
+    --text-color: #333;
+    --light-text: #666;
+    --bg-color: #f8f9fa;
+    --card-bg: #fff;
+    --border-color: #e0e0e0;
+    --error-color: #ef4444;
+    --success-color: #10b981;
+    --hover-color: #f1f5f9;
+    --transition: all 0.3s ease;
+}
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: 'Pretendard', 'Apple SD Gothic Neo', 'Noto Sans KR', sans-serif;
+    line-height: 1.6;
+    color: var(--text-color);
+    background-color: var(--bg-color);
+    margin: 0;
+}
+
+.container {
+    max-width: 1000px;
+    margin: 0 auto;
+    padding: 20px;
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+}
+
+/* 헤더 스타일 */
+header {
+    text-align: center;
+    margin-bottom: 20px;
+}
+
+header h1 {
+    color: var(--primary-color);
+    margin-bottom: 15px;
+}
+
+.llm-selector {
+    margin-bottom: 15px;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: 10px;
+}
+
+.llm-selector label {
+    font-weight: 600;
+    color: var(--primary-color);
+}
+
+#llmSelect {
+    padding: 8px 12px;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    background-color: white;
+    font-size: 14px;
+    outline: none;
+    transition: var(--transition);
+}
+
+#llmSelect:focus {
+    border-color: var(--primary-color);
+}
+
+.tabs {
+    display: flex;
+    justify-content: center;
+    margin-bottom: 20px;
+}
+
+.tab {
+    padding: 10px 20px;
+    background-color: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    margin: 0 5px;
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.tab:hover {
+    background-color: var(--hover-color);
+}
+
+.tab.active {
+    background-color: var(--primary-color);
+    color: white;
+    border-color: var(--primary-color);
+}
+
+/* 메인 컨텐츠 */
+main {
+    flex-grow: 1;
+}
+
+.tab-content {
+    display: none;
+}
+
+.tab-content.active {
+    display: block;
+}
+
+/* 채팅 섹션 */
+.chat-container {
+    background-color: var(--card-bg);
+    border-radius: 8px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    overflow: hidden;
+    height: 70vh;
+    display: flex;
+    flex-direction: column;
+}
+
+.chat-messages {
+    flex-grow: 1;
+    overflow-y: auto;
+    padding: 20px;
+}
+
+.message {
+    margin-bottom: 20px;
+    display: flex;
+    align-items: flex-start;
+}
+
+.message.user {
+    justify-content: flex-end;
+}
+
+.message-content {
+    padding: 12px 16px;
+    border-radius: 12px;
+    max-width: 80%;
+}
+
+.message.system .message-content {
+    background-color: #f0f7ff;
+    color: var(--primary-dark);
+}
+
+.message.user .message-content {
+    background-color: var(--primary-color);
+    color: white;
+    border-top-right-radius: 4px;
+}
+
+.message.bot .message-content {
+    background-color: #f1f5f9;
+    color: var(--text-color);
+    border-top-left-radius: 4px;
+}
+
+.message p {
+    margin-bottom: 8px;
+}
+
+.message p:last-child {
+    margin-bottom: 0;
+}
+
+.message .sources {
+    font-size: 0.85em;
+    color: var(--light-text);
+    margin-top: 5px;
+}
+
+.message .source-item {
+    margin-right: 10px;
+}
+
+.message .transcription {
+    font-style: italic;
+    opacity: 0.8;
+    font-size: 0.9em;
+    margin-bottom: 8px;
+}
+
+.chat-input-container {
+    display: flex;
+    padding: 15px;
+    border-top: 1px solid var(--border-color);
+    background-color: var(--card-bg);
+}
+
+#userInput {
+    flex-grow: 1;
+    border: 1px solid var(--border-color);
+    border-radius: 20px;
+    padding: 10px 15px;
+    font-size: 16px;
+    resize: none;
+    outline: none;
+    transition: var(--transition);
+}
+
+#userInput:focus {
+    border-color: var(--primary-color);
+}
+
+.mic-button, .send-button, .stop-recording-button {
+    border: none;
+    background-color: transparent;
+    color: var(--primary-color);
+    font-size: 20px;
+    margin-left: 10px;
+    cursor: pointer;
+    transition: var(--transition);
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.mic-button:hover, .send-button:hover, .stop-recording-button:hover {
+    background-color: var(--hover-color);
+}
+
+.stop-recording-button {
+    background-color: var(--error-color);
+    color: white;
+}
+
+.stop-recording-button:hover {
+    background-color: #dc2626; /* 더 어두운 빨간색 */
+}
+
+.recording-status {
+    display: flex;
+    align-items: center;
+    padding: 10px 15px;
+    background-color: rgba(239, 68, 68, 0.1);
+    border-top: 1px solid var(--border-color);
+    color: var(--error-color);
+}
+
+.recording-indicator {
+    position: relative;
+    width: 12px;
+    height: 12px;
+    margin-right: 10px;
+}
+
+.recording-pulse {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    background-color: var(--error-color);
+    border-radius: 50%;
+    animation: pulse 1.5s infinite;
+}
+
+@keyframes pulse {
+    0% {
+        transform: scale(0.8);
+        opacity: 1;
+    }
+    70% {
+        transform: scale(1.5);
+        opacity: 0;
+    }
+    100% {
+        transform: scale(0.8);
+        opacity: 0;
+    }
+}
+
+.hidden {
+    display: none;
+}
+
+/* 문서 관리 섹션 */
+.docs-container {
+    background-color: var(--card-bg);
+    border-radius: 8px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    overflow: hidden;
+    padding: 20px;
+}
+
+.upload-section {
+    margin-bottom: 30px;
+    padding-bottom: 20px;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.upload-section h2, .docs-list-section h2 {
+    margin-bottom: 15px;
+    color: var(--primary-color);
+}
+
+.file-upload {
+    display: flex;
+    align-items: center;
+    margin-bottom: 20px;
+}
+
+.file-upload input[type="file"] {
+    display: none;
+}
+
+.file-upload label {
+    padding: 10px 20px;
+    background-color: var(--primary-color);
+    color: white;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.file-upload label:hover {
+    background-color: var(--primary-dark);
+}
+
+#fileName {
+    margin-left: 15px;
+    color: var(--light-text);
+}
+
+.upload-button {
+    padding: 10px 20px;
+    background-color: var(--secondary-color);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: var(--transition);
+    display: flex;
+    align-items: center;
+}
+
+.upload-button i {
+    margin-right: 8px;
+}
+
+.upload-button:hover {
+    background-color: #d97706; /* 더 어두운 주황색 */
+}
+
+.upload-status {
+    margin-top: 15px;
+    padding: 10px 15px;
+    border-radius: 4px;
+}
+
+.upload-status.success {
+    background-color: rgba(16, 185, 129, 0.1);
+    color: var(--success-color);
+}
+
+.upload-status.error {
+    background-color: rgba(239, 68, 68, 0.1);
+    color: var(--error-color);
+}
+
+.docs-list-section {
+    position: relative;
+}
+
+.refresh-button {
+    position: absolute;
+    top: 0;
+    right: 0;
+    padding: 5px 10px;
+    background-color: transparent;
+    color: var(--primary-color);
+    border: 1px solid var(--primary-color);
+    border-radius: 4px;
+    cursor: pointer;
+    transition: var(--transition);
+    display: flex;
+    align-items: center;
+}
+
+.refresh-button i {
+    margin-right: 5px;
+}
+
+.refresh-button:hover {
+    background-color: var(--hover-color);
+}
+
+.docs-list {
+    width: 100%;
+    border-collapse: collapse;
+    margin-top: 20px;
+}
+
+.docs-list th, .docs-list td {
+    padding: 12px 15px;
+    text-align: left;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.docs-list th {
+    background-color: #f1f5f9;
+    font-weight: 600;
+}
+
+.docs-list tr:hover {
+    background-color: var(--hover-color);
+}
+
+.loading-indicator {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 30px;
+}
+
+.spinner {
+    width: 40px;
+    height: 40px;
+    border: 4px solid #f3f3f3;
+    border-top: 4px solid var(--primary-color);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+    margin-bottom: 15px;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.no-docs-message {
+    text-align: center;
+    padding: 30px;
+    color: var(--light-text);
+}
+
+/* 푸터 */
+footer {
+    text-align: center;
+    margin-top: 30px;
+    padding-top: 20px;
+    border-top: 1px solid var(--border-color);
+    color: var(--light-text);
+    font-size: 0.9em;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+footer p {
+    margin-bottom: 5px;
+}
+
+.current-llm {
+    color: var(--primary-color);
+    font-weight: 500;
+}
+
+#currentLLMInfo {
+    font-weight: 600;
+}
+
+/* 반응형 스타일 */
+@media (max-width: 768px) {
+    .container {
+        padding: 10px;
+    }
+    
+    .chat-container {
+        height: 65vh;
+    }
+    
+    .message-content {
+        max-width: 90%;
+    }
+    
+    .file-upload {
+        flex-direction: column;
+        align-items: flex-start;
+    }
+    
+    #fileName {
+        margin-left: 0;
+        margin-top: 10px;
+    }
+    
+    .refresh-button {
+        position: static;
+        margin-top: 10px;
+        margin-bottom: 10px;
+    }
+    
+    footer {
+        flex-direction: column;
+        text-align: center;
+    }
+    
+    .current-llm {
+        margin-top: 10px;
+    }
+    
+    .llm-selector {
+        flex-direction: column;
+        gap: 5px;
+    }
+}

app/static/js/app-core.js

@@ -0,0 +1,112 @@
+/**
+ * RAG 검색 챗봇 UI 공통 유틸리티 JavaScript
+ */
+
+// 전역 유틸리티 함수
+const AppUtils = {
+    // 시스템 알림 메시지 추가
+    addSystemNotification: function(message) {
+        console.log(`[시스템 알림] ${message}`);
+        
+        const messageDiv = document.createElement('div');
+        messageDiv.classList.add('message', 'system');
+        
+        const contentDiv = document.createElement('div');
+        contentDiv.classList.add('message-content');
+        
+        const messageP = document.createElement('p');
+        messageP.innerHTML = `<i class="fas fa-info-circle"></i> ${message}`;
+        contentDiv.appendChild(messageP);
+        
+        messageDiv.appendChild(contentDiv);
+        
+        // 채팅 메시지 영역이 있으면 추가
+        const chatMessages = document.getElementById('chatMessages');
+        if (chatMessages) {
+            chatMessages.appendChild(messageDiv);
+            // 스크롤을 가장 아래로 이동
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+    },
+    
+    // 오류 메시지 추가
+    addErrorMessage: function(errorText) {
+        console.error(`[오류] ${errorText}`);
+        
+        const messageDiv = document.createElement('div');
+        messageDiv.classList.add('message', 'system');
+        
+        const contentDiv = document.createElement('div');
+        contentDiv.classList.add('message-content');
+        contentDiv.style.backgroundColor = 'rgba(239, 68, 68, 0.1)';
+        contentDiv.style.color = 'var(--error-color)';
+        
+        const errorP = document.createElement('p');
+        errorP.innerHTML = `<i class="fas fa-exclamation-circle"></i> ${errorText}`;
+        contentDiv.appendChild(errorP);
+        
+        messageDiv.appendChild(contentDiv);
+        
+        // 채팅 메시지 영역이 있으면 추가
+        const chatMessages = document.getElementById('chatMessages');
+        if (chatMessages) {
+            chatMessages.appendChild(messageDiv);
+            // 스크롤을 가장 아래로 이동
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+    },
+    
+    // 타임아웃 기능이 있는 fetch
+    fetchWithTimeout: async function(url, options = {}, timeout = 30000) {
+        console.log(`API 요청: ${options.method || 'GET'} ${url}`);
+        
+        const controller = new AbortController();
+        const id = setTimeout(() => controller.abort(), timeout);
+        
+        try {
+            const response = await fetch(url, {
+                ...options,
+                signal: controller.signal
+            });
+            clearTimeout(id);
+            console.log(`API 응답 상태: ${response.status}`);
+            return response;
+        } catch (error) {
+            clearTimeout(id);
+            if (error.name === 'AbortError') {
+                console.error(`API 요청 타임아웃: ${url}`);
+                throw new Error('요청 시간이 초과되었습니다.');
+            }
+            console.error(`API 요청 실패: ${url}`, error);
+            throw error;
+        }
+    },
+    
+    // 로딩 스피너 HTML 생성
+    createLoadingSpinner: function() {
+        return '<div class="loading-spinner"></div>';
+    },
+    
+    // 날짜 포맷팅
+    formatDate: function(date) {
+        return new Date(date).toLocaleString('ko-KR', {
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit'
+        });
+    },
+    
+    // HTML 문자열 이스케이프 (XSS 방지)
+    escapeHtml: function(html) {
+        const div = document.createElement('div');
+        div.textContent = html;
+        return div.innerHTML;
+    }
+};
+
+// 페이지 로드 완료 시 공통 초기화
+document.addEventListener('DOMContentLoaded', function() {
+    console.log('앱 코어 모듈 초기화 완료');
+});

app/static/js/app-device.js

@@ -0,0 +1,653 @@
+/**
+ * RAG 검색 챗봇 장치 제어 JavaScript
+ */
+
+// 장치 제어 모듈
+const DeviceControl = {
+    // 장치 제어 상태
+    isConnected: false,
+    isStatusChecked: false,
+    isLoadingPrograms: false,
+    programsList: [],
+    
+    // DOM 요소들
+    elements: {
+        // 탭 및 섹션
+        deviceTab: null,
+        deviceSection: null,
+        
+        // 연결 관련
+        deviceServerUrlInput: null,
+        connectDeviceServerBtn: null,
+        deviceConnectionStatus: null,
+        
+        // 기본 기능
+        deviceBasicFunctions: null,
+        checkDeviceStatusBtn: null,
+        deviceStatusResult: null,
+        
+        // 프로그램 실행
+        deviceProgramControl: null,
+        getProgramsBtn: null,
+        programsList: null,
+        programSelectDropdown: null,
+        executeProgramBtn: null,
+        executeResult: null
+    },
+    
+    // 모듈 초기화
+    init: function() {
+        console.log('장치 제어 모듈 초기화 중...');
+        
+        // DOM 요소 참조 가져오기
+        this.initElements();
+        
+        // 이벤트 리스너 등록
+        this.initEventListeners();
+        
+        console.log('장치 제어 모듈 초기화 완료');
+    },
+    
+    // DOM 요소 참조 초기화
+    initElements: function() {
+        // 탭 및 섹션
+        this.elements.deviceTab = document.getElementById('deviceTab');
+        this.elements.deviceSection = document.getElementById('deviceSection');
+        
+        // 연결 관련
+        this.elements.deviceServerUrlInput = document.getElementById('deviceServerUrlInput');
+        this.elements.connectDeviceServerBtn = document.getElementById('connectDeviceServerBtn');
+        this.elements.deviceConnectionStatus = document.getElementById('deviceConnectionStatus');
+        
+        // 기본 기능
+        this.elements.deviceBasicFunctions = document.getElementById('deviceBasicFunctions');
+        this.elements.checkDeviceStatusBtn = document.getElementById('checkDeviceStatusBtn');
+        this.elements.deviceStatusResult = document.getElementById('deviceStatusResult');
+        
+        // 프로그램 실행
+        this.elements.deviceProgramControl = document.getElementById('deviceProgramControl');
+        this.elements.getProgramsBtn = document.getElementById('getProgramsBtn');
+        this.elements.programsList = document.getElementById('programsList');
+        this.elements.programSelectDropdown = document.getElementById('programSelectDropdown');
+        this.elements.executeProgramBtn = document.getElementById('executeProgramBtn');
+        this.elements.executeResult = document.getElementById('executeResult');
+        
+        console.log('장치 제어 DOM 요소 참조 초기화 완료');
+    },
+    
+    // 이벤트 리스너 등록
+    initEventListeners: function() {
+        // 탭 전환
+        if (this.elements.deviceTab) {
+            this.elements.deviceTab.addEventListener('click', () => {
+                console.log('장치 제어 탭 클릭');
+                this.switchToDeviceTab();
+            });
+        }
+        
+        // 서버 연결
+        if (this.elements.connectDeviceServerBtn) {
+            this.elements.connectDeviceServerBtn.addEventListener('click', () => {
+                console.log('장치 서버 연결 버튼 클릭');
+                this.connectServer();
+            });
+        }
+        
+        // 엔터 키로 연결
+        if (this.elements.deviceServerUrlInput) {
+            this.elements.deviceServerUrlInput.addEventListener('keydown', (event) => {
+                if (event.key === 'Enter') {
+                    console.log('장치 서버 URL 입력 필드에서 엔터 키 감지');
+                    event.preventDefault();
+                    this.connectServer();
+                }
+            });
+        }
+        
+        // 장치 상태 확인
+        if (this.elements.checkDeviceStatusBtn) {
+            this.elements.checkDeviceStatusBtn.addEventListener('click', () => {
+                console.log('장치 상태 확인 버튼 클릭');
+                this.checkDeviceStatus();
+            });
+        }
+        
+        // 프로그램 목록 조회
+        if (this.elements.getProgramsBtn) {
+            this.elements.getProgramsBtn.addEventListener('click', () => {
+                console.log('프로그램 목록 새로고침 버튼 클릭');
+                this.loadProgramsList();
+            });
+        }
+        
+        // 프로그램 선택 변경
+        if (this.elements.programSelectDropdown) {
+            this.elements.programSelectDropdown.addEventListener('change', (event) => {
+                console.log(`프로그램 선택 변경: ${event.target.value}`);
+                this.updateExecuteButton();
+            });
+        }
+        
+        // 프로그램 실행
+        if (this.elements.executeProgramBtn) {
+            this.elements.executeProgramBtn.addEventListener('click', () => {
+                const programId = this.elements.programSelectDropdown.value;
+                console.log(`프로그램 실행 버튼 클릭, 선택된 ID: ${programId}`);
+                this.executeProgram(programId);
+            });
+        }
+        
+        console.log('장치 제어 이벤트 리스너 등록 완료');
+    },
+    
+    // 장치 제어 탭으로 전환
+    switchToDeviceTab: function() {
+        // 모든 탭과 탭 콘텐츠 비활성화
+        const tabs = document.querySelectorAll('.tab');
+        const tabContents = document.querySelectorAll('.tab-content');
+        
+        tabs.forEach(tab => tab.classList.remove('active'));
+        tabContents.forEach(content => content.classList.remove('active'));
+        
+        // 장치 제어 탭 활성화
+        this.elements.deviceTab.classList.add('active');
+        this.elements.deviceSection.classList.add('active');
+        
+        console.log('장치 제어 탭으로 전환 완료');
+    },
+    
+    // 서버 연결 함수
+    connectServer: async function() {
+        // URL 가져오기 (입력된 것이 있으면 백업으로 사용)
+        const inputUrl = this.elements.deviceServerUrlInput.value.trim();
+        
+        // 연결 시도 중 UI 업데이트
+        this.elements.connectDeviceServerBtn.disabled = true;
+        this.updateConnectionStatus('connecting', '환경변수에 저장된 서버로 연결 시도 중...');
+        
+        try {
+            console.log('환경변수에 저장된 장치 서버로 연결 시도');
+            
+            // 백엔드 API 호출하여 서버 상태 확인
+            const response = await AppUtils.fetchWithTimeout('/api/device/status', {
+                method: 'GET'
+            }, 10000); // 10초 타임아웃
+            
+            const data = await response.json();
+            
+            if (response.ok && data.success) {
+                // 연결 성공
+                console.log('환경변수 설정 장치 서버 연결 성공:', data);
+                this.isConnected = true;
+                this.updateConnectionStatus('connected', `서버 연결 성공! 상태: ${data.server_status || '정상'}`);
+                
+                // 기능 UI 활성화
+                this.elements.deviceBasicFunctions.classList.add('active');
+                this.elements.deviceProgramControl.classList.add('active');
+                
+                // 장치 상태 자동 체크
+                this.checkDeviceStatus();
+                
+                // 프로그램 목록 자동 로드
+                this.loadProgramsList();
+                
+                // 시스템 알림
+                AppUtils.addSystemNotification(`장치 관리 서버 연결 성공! (환경변수 URL)`);
+            } else {
+                // 환경변수 URL 연결 실패, 입력된 URL로 시도
+                console.warn('환경변수 설정 장치 서버 연결 실패, 입력 URL로 재시도합니다:', data);
+                
+                // 입력 URL이 있는지 확인
+                if (!inputUrl) {
+                    console.error('입력된 URL이 없어 연결 실패');
+                    this.isConnected = false;
+                    this.updateConnectionStatus('error', '환경변수 URL 연결 실패 및 입력된 URL이 없습니다. URL을 입력해주세요.');
+                    return;
+                }
+                
+                // 입력 URL로 재시도
+                this.updateConnectionStatus('connecting', `입력 URL(${inputUrl})로 연결 시도 중...`);
+                console.log(`입력한 URL로 장치 서버 연결 시도: ${inputUrl}`);
+                
+                // 백엔드 API 호출 - 입력 URL 사용
+                const customUrlResponse = await AppUtils.fetchWithTimeout('/api/device/connect', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ url: inputUrl })
+                }, 10000);
+                
+                const customUrlData = await customUrlResponse.json();
+                
+                if (customUrlResponse.ok && customUrlData.success) {
+                    // 입력 URL 연결 성공
+                    console.log('입력 URL 장치 서버 연결 성공:', customUrlData);
+                    this.isConnected = true;
+                    this.updateConnectionStatus('connected', `서버 연결 성공! 상태: ${customUrlData.server_status || '정상'}`);
+                    
+                    // 기능 UI 활성화
+                    this.elements.deviceBasicFunctions.classList.add('active');
+                    this.elements.deviceProgramControl.classList.add('active');
+                    
+                    // 장치 상태 자동 체크
+                    this.checkDeviceStatus();
+                    
+                    // 프로그램 목록 자동 로드
+                    this.loadProgramsList();
+                    
+                    // 시스템 알림
+                    AppUtils.addSystemNotification(`장치 관리 서버 연결 성공! (${inputUrl})`);
+                } else {
+                    // 입력 URL 연결 실패
+                    console.error('입력 URL 장치 서버 연결 실패:', customUrlData);
+                    this.isConnected = false;
+                    this.updateConnectionStatus('error', `서버 연결 실패: ${customUrlData.error || '서버 응답 오류'}`);
+                }
+            }
+        } catch (error) {
+            // 예외 발생
+            console.error('서버 연결 중 오류 발생:', error);
+            this.isConnected = false;
+            
+            // 환경변수 URL 연결 실패, 입력된 URL로 시도
+            if (inputUrl) {
+                console.warn('환경변수 URL 연결 시 오류 발생, 입력 URL로 재시도합니다');
+                
+                try {
+                    // 입력 URL로 재시도
+                    this.updateConnectionStatus('connecting', `입력 URL(${inputUrl})로 연결 시도 중...`);
+                    console.log(`입력한 URL로 장치 서버 연결 시도: ${inputUrl}`);
+                    
+                    // 백엔드 API 호출 - 입력 URL 사용
+                    const customUrlResponse = await AppUtils.fetchWithTimeout('/api/device/connect', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({ url: inputUrl })
+                    }, 10000);
+                    
+                    const customUrlData = await customUrlResponse.json();
+                    
+                    if (customUrlResponse.ok && customUrlData.success) {
+                        // 입력 URL 연결 성공
+                        console.log('입력 URL 장치 서버 연결 성공:', customUrlData);
+                        this.isConnected = true;
+                        this.updateConnectionStatus('connected', `서버 연결 성공! 상태: ${customUrlData.server_status || '정상'}`);
+                        
+                        // 기능 UI 활성화
+                        this.elements.deviceBasicFunctions.classList.add('active');
+                        this.elements.deviceProgramControl.classList.add('active');
+                        
+                        // 장치 상태 자동 체크
+                        this.checkDeviceStatus();
+                        
+                        // 프로그램 목록 자동 로드
+                        this.loadProgramsList();
+                        
+                        // 시스템 알림
+                        AppUtils.addSystemNotification(`장치 관리 서버 연결 성공! (${inputUrl})`);
+                        return; // 성공하면 여기서 종료
+                    } else {
+                        // 입력 URL 연결 실패
+                        console.error('입력 URL 장치 서버 연결 실패:', customUrlData);
+                        this.updateConnectionStatus('error', `서버 연결 실패: ${customUrlData.error || '서버 응답 오류'}`);
+                    }
+                } catch (inputUrlError) {
+                    // 입력 URL로 재시도 중 오류
+                    console.error('입력 URL로 재시도 중 오류 발생:', inputUrlError);
+                    
+                    if (inputUrlError.message.includes('시간이 초과')) {
+                        this.updateConnectionStatus('error', '서버 연결 시간 초과. 서버가 실행 중인지 확인해주세요.');
+                    } else {
+                        this.updateConnectionStatus('error', `서버 연결 오류: ${inputUrlError.message}`);
+                    }
+                }
+            } else {
+                // 텍스트박스에 URL이 없는 경우
+                if (error.message.includes('시간이 초과')) {
+                    this.updateConnectionStatus('error', '환경변수 URL 연결 시간 초과. URL을 입력하여 다시 시도해주세요.');
+                } else {
+                    this.updateConnectionStatus('error', `환경변수 URL 연결 오류. URL을 입력하여 다시 시도해주세요: ${error.message}`);
+                }
+            }
+        } finally {
+            // 버튼 다시 활성화
+            this.elements.connectDeviceServerBtn.disabled = false;
+        }
+    },
+    
+    // 연결 상태 업데이트
+    updateConnectionStatus: function(status, message) {
+        const statusElement = this.elements.deviceConnectionStatus;
+        
+        // 모든 상태 클래스 제거
+        statusElement.classList.remove('connected', 'disconnected', 'error', 'connecting');
+        
+        // 상태에 따라 클래스 추가
+        statusElement.classList.add(status);
+        
+        // 메시지 업데이트
+        statusElement.textContent = message;
+        
+        console.log(`연결 상태 업데이트: ${status} - ${message}`);
+    },
+    
+    // 장치 상태 확인
+    checkDeviceStatus: async function() {
+        if (!this.isConnected) {
+            this.elements.deviceStatusResult.value = '오류: 먼저 서버에 연결해야 합니다.';
+            console.error('장치 상태 확인 시도 중 오류: 서버 연결 안됨');
+            return;
+        }
+        
+        // 상태 확인 중 UI 업데이트
+        this.elements.checkDeviceStatusBtn.disabled = true;
+        this.elements.deviceStatusResult.value = '장치 상태 확인 중...';
+        
+        try {
+            console.log('장치 상태 확인 요청 전송');
+            
+            // 백엔드 API 호출
+            const response = await AppUtils.fetchWithTimeout('/api/device/status', {
+                method: 'GET'
+            });
+            
+            const data = await response.json();
+            
+            if (response.ok && data.success) {
+                // 상태 확인 성공
+                console.log('장치 상태 확인 성공:', data);
+                this.isStatusChecked = true;
+                this.elements.deviceStatusResult.value = JSON.stringify(data, null, 2);
+            } else {
+                // 상태 확인 실패
+                console.error('장치 상태 확인 실패:', data);
+                this.elements.deviceStatusResult.value = `상태 확인 실패: ${data.error || '알 수 없는 오류'}`;
+            }
+        } catch (error) {
+            // 예외 발생
+            console.error('장치 상태 확인 중 오류 발생:', error);
+            this.elements.deviceStatusResult.value = `상태 확인 중 오류 발생: ${error.message}`;
+        } finally {
+            // 버튼 다시 활성화
+            this.elements.checkDeviceStatusBtn.disabled = false;
+        }
+    },
+    
+    // 프로그램 목록 조회
+    loadProgramsList: async function() {
+        if (!this.isConnected) {
+            this.showProgramsError('오류: 먼저 서버에 연결해야 합니다.');
+            console.error('프로그램 목록 조회 시도 중 오류: 서버 연결 안됨');
+            return;
+        }
+        
+        // 이미 로딩 중이면 중복 요청 방지
+        if (this.isLoadingPrograms) {
+            console.log('이미 프로그램 목록 로딩 중');
+            return;
+        }
+        
+        // 로딩 중 UI 업데이트
+        this.isLoadingPrograms = true;
+        this.elements.getProgramsBtn.disabled = true;
+        this.elements.programsList.innerHTML = `
+            <div class="loading-message">
+                ${AppUtils.createLoadingSpinner()} 프로그램 목록 로드 중...
+            </div>
+        `;
+        
+        try {
+            console.log('프로그램 목록 조회 요청 전송');
+            
+            // 백엔드 API 호출
+            const response = await AppUtils.fetchWithTimeout('/api/device/programs', {
+                method: 'GET'
+            });
+            
+            const data = await response.json();
+            
+            if (response.ok && data.success) {
+                // 목록 조회 성공
+                console.log('프로그램 목록 조회 성공:', data);
+                this.programsList = data.programs || [];
+                
+                // 목록 표시
+                this.displayProgramsList();
+                
+                // 드롭다운 업데이트
+                this.updateProgramsDropdown();
+                
+                // 실행 버튼 상태 업데이트
+                this.updateExecuteButton();
+            } else {
+                // 목록 조회 실패
+                console.error('프로그램 목록 조회 실패:', data);
+                this.showProgramsError(`프로그램 목록 조회 실패: ${data.error || '알 수 없는 오류'}`);
+            }
+        } catch (error) {
+            // 예외 발생
+            console.error('프로그램 목록 조회 중 오류 발생:', error);
+            this.showProgramsError(`프로그램 목록 조회 중 오류 발생: ${error.message}`);
+        } finally {
+            // 로딩 상태 및 버튼 상태 복원
+            this.isLoadingPrograms = false;
+            this.elements.getProgramsBtn.disabled = false;
+        }
+    },
+    
+    // 프로그램 목록 표시
+    displayProgramsList: function() {
+        const programsListElement = this.elements.programsList;
+        
+        if (!this.programsList || this.programsList.length === 0) {
+            programsListElement.innerHTML = `
+                <div class="no-programs-message">
+                    <i class="fas fa-info-circle"></i> 등록된 프로그램이 없습니다.
+                </div>
+            `;
+            return;
+        }
+        
+        // 테이블 형태로 프로그램 목록 표시
+        let html = `
+            <table class="program-list">
+                <thead>
+                    <tr>
+                        <th>이름</th>
+                        <th>설명</th>
+                        <th>경로</th>
+                    </tr>
+                </thead>
+                <tbody>
+        `;
+        
+        // 프로그램 항목 생성
+        this.programsList.forEach(program => {
+            html += `
+                <tr>
+                    <td>${AppUtils.escapeHtml(program.name || '알 수 없음')}</td>
+                    <td>${AppUtils.escapeHtml(program.description || '-')}</td>
+                    <td>${AppUtils.escapeHtml(program.path || '-')}</td>
+                </tr>
+            `;
+        });
+        
+        html += `
+                </tbody>
+            </table>
+            <div style="margin-top: 10px; font-size: 0.9em; color: #666;">
+                총 ${this.programsList.length}개 프로그램
+            </div>
+        `;
+        
+        programsListElement.innerHTML = html;
+    },
+    
+    // 프로그램 드롭다운 업데이트
+    updateProgramsDropdown: function() {
+        const dropdown = this.elements.programSelectDropdown;
+        
+        // 기존 옵션 제거
+        dropdown.innerHTML = '';
+        
+        // 기본 옵션 추가
+        const defaultOption = document.createElement('option');
+        defaultOption.value = '';
+        defaultOption.textContent = this.programsList.length > 0
+            ? '-- 실행할 프로그램 선택 --'
+            : '-- 프로그램 없음 --';
+        dropdown.appendChild(defaultOption);
+        
+        // 프로그램 옵션 추가
+        this.programsList.forEach(program => {
+            const option = document.createElement('option');
+            option.value = program.id || '';
+            option.textContent = program.name || '알 수 없음';
+            
+            // 설명이 있으면 괄호로 추가
+            if (program.description) {
+                option.textContent += ` (${program.description})`;
+            }
+            
+            dropdown.appendChild(option);
+        });
+    },
+    
+    // 실행 버튼 상태 업데이트
+    updateExecuteButton: function() {
+        const dropdown = this.elements.programSelectDropdown;
+        const executeBtn = this.elements.executeProgramBtn;
+        
+        // 선택된 프로그램이 있을 때만 버튼 활성화
+        executeBtn.disabled = !dropdown.value;
+    },
+    
+    // 프로그램 실행
+    executeProgram: async function(programId) {
+        if (!this.isConnected) {
+            this.showExecuteResult('error', '오류: 먼저 서버에 연결해야 합니다.');
+            console.error('프로그램 실행 시도 중 오류: 서버 연결 안됨');
+            return;
+        }
+        
+        if (!programId) {
+            this.showExecuteResult('error', '오류: 실행할 프로그램을 선택해주세요.');
+            console.error('프로그램 실행 시도 중 오류: 프로그램 ID 없음');
+            return;
+        }
+        
+        // 실행 중 UI 업데이트
+        this.elements.executeProgramBtn.disabled = true;
+        this.showExecuteResult('loading', '프로그램 실행 중...');
+        
+        try {
+            console.log(`프로그램 실행 요청 전송: ${programId}`);
+            
+            // 백엔드 API 호출
+            const response = await AppUtils.fetchWithTimeout(`/api/device/programs/${programId}/execute`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({})
+            }, 15000); // 15초 타임아웃 (실행에 시간이 더 걸릴 수 있음)
+            
+            const data = await response.json();
+            
+            if (response.ok && data.success) {
+                // 실행 성공
+                console.log('프로그램 실행 성공:', data);
+                this.showExecuteResult('success', `실행 성공: ${data.message || '프로그램이 성공적으로 실행되었습니다.'}`);
+                
+                // 시스템 알림
+                AppUtils.addSystemNotification(`프로그램 실행 성공: ${this.getSelectedProgramName()}`);
+            } else {
+                // 실행 실패
+                console.error('프로그램 실행 실패:', data);
+                this.showExecuteResult('error', `실행 실패: ${data.error || '알 수 없는 오류'}`);
+            }
+        } catch (error) {
+            // 예외 발생
+            console.error('프로그램 실행 중 오류 발생:', error);
+            
+            if (error.message.includes('시간이 초과')) {
+                this.showExecuteResult('error', '프로그램 실행 요청 시간 초과. 서버 응답이 없습니다.');
+            } else {
+                this.showExecuteResult('error', `프로그램 실행 중 오류 발생: ${error.message}`);
+            }
+        } finally {
+            // 버튼 다시 활성화
+            this.elements.executeProgramBtn.disabled = false;
+        }
+    },
+    
+    // 선택된 프로그램 이름 가져오기
+    getSelectedProgramName: function() {
+        const dropdown = this.elements.programSelectDropdown;
+        const selectedOption = dropdown.options[dropdown.selectedIndex];
+        return selectedOption ? selectedOption.textContent : '알 수 없는 프로그램';
+    },
+    
+    // 프로그램 목록 오류 표시
+    showProgramsError: function(errorMessage) {
+        this.elements.programsList.innerHTML = `
+            <div class="error-message">
+                <i class="fas fa-exclamation-circle"></i> ${errorMessage}
+                <button class="retry-button" id="retryLoadProgramsBtn">
+                    <i class="fas fa-sync"></i> 다시 시도
+                </button>
+            </div>
+        `;
+        
+        // 재시도 버튼 이벤트 리스너
+        document.getElementById('retryLoadProgramsBtn').addEventListener('click', () => {
+            console.log('프로그램 목록 재시도 버튼 클릭');
+            this.loadProgramsList();
+        });
+    },
+    
+    // 실행 결과 표시
+    showExecuteResult: function(status, message) {
+        const resultElement = this.elements.executeResult;
+        
+        // 모든 상태 클래스 제거
+        resultElement.classList.remove('success', 'error', 'warning');
+        
+        // 내용 초기화
+        resultElement.innerHTML = '';
+        
+        // 상태에 따라 처리
+        switch (status) {
+            case 'success':
+                resultElement.classList.add('success');
+                resultElement.innerHTML = `<i class="fas fa-check-circle"></i> ${message}`;
+                break;
+            case 'error':
+                resultElement.classList.add('error');
+                resultElement.innerHTML = `<i class="fas fa-exclamation-circle"></i> ${message}`;
+                break;
+            case 'warning':
+                resultElement.classList.add('warning');
+                resultElement.innerHTML = `<i class="fas fa-exclamation-triangle"></i> ${message}`;
+                break;
+            case 'loading':
+                resultElement.innerHTML = `${AppUtils.createLoadingSpinner()} ${message}`;
+                break;
+            default:
+                resultElement.textContent = message;
+        }
+    }
+};
+
+// 페이지 로드 완료 시 모듈 초기화
+document.addEventListener('DOMContentLoaded', function() {
+    console.log('장치 제어 모듈 로드됨');
+    
+    // DOM이 완전히 로드된 후 약간의 지연을 두고 초기화
+    setTimeout(() => {
+        DeviceControl.init();
+    }, 100);
+});

app/static/js/app-docs.js

@@ -0,0 +1,196 @@
+/**
+ * RAG 검색 챗봇 문서 관리 JavaScript
+ */
+
+// DOM 요소 미리 선언
+let uploadForm, documentFile, fileName, uploadButton, uploadStatus;
+let refreshDocsButton, docsList, docsLoading, noDocsMessage;
+
+/**
+ * 문서 관리 DOM 요소 초기화
+ */
+function initDocsElements() {
+    console.log('문서 관리 DOM 요소 초기화 중...');
+    
+    uploadForm = document.getElementById('uploadForm');
+    documentFile = document.getElementById('documentFile');
+    fileName = document.getElementById('fileName');
+    uploadButton = document.getElementById('uploadButton');
+    uploadStatus = document.getElementById('uploadStatus');
+    refreshDocsButton = document.getElementById('refreshDocsButton');
+    docsList = document.getElementById('docsList');
+    docsLoading = document.getElementById('docsLoading');
+    noDocsMessage = document.getElementById('noDocsMessage');
+    
+    console.log('문서 관리 DOM 요소 초기화 완료');
+    
+    // 문서 관리 이벤트 리스너 초기화
+    initDocsEventListeners();
+}
+
+/**
+ * 문서 관리 이벤트 리스너 초기화
+ */
+function initDocsEventListeners() {
+    console.log('문서 관리 이벤트 리스너 초기화 중...');
+    
+    // 문서 업로드 이벤트 리스너
+    documentFile.addEventListener('change', (event) => {
+        if (event.target.files.length > 0) {
+            fileName.textContent = event.target.files[0].name;
+            console.log(`파일 선택됨: ${event.target.files[0].name}`);
+        } else {
+            fileName.textContent = '선택된 파일 없음';
+            console.log('파일 선택 취소됨');
+        }
+    });
+    
+    uploadForm.addEventListener('submit', (event) => {
+        event.preventDefault();
+        console.log('업로드 폼 제출됨');
+        uploadDocument();
+    });
+    
+    // 문서 목록 새로고침 이벤트 리스너
+    refreshDocsButton.addEventListener('click', () => {
+        console.log('문서 목록 새로고침 요청');
+        loadDocuments();
+    });
+    
+    console.log('문서 관리 이벤트 리스너 초기화 완료');
+}
+
+/**
+ * 문서 업로드 함수
+ */
+async function uploadDocument() {
+    if (documentFile.files.length === 0) {
+        console.log('업로드할 파일이 선택되지 않음');
+        alert('파일을 선택해 주세요.');
+        return;
+    }
+    
+    console.log(`파일 업로드 시작: ${documentFile.files[0].name}`);
+    
+    // UI 업데이트
+    uploadStatus.classList.remove('hidden');
+    uploadStatus.className = 'upload-status';
+    uploadStatus.innerHTML = '<div class="spinner"></div><p>업로드 중...</p>';
+    uploadButton.disabled = true;
+    
+    try {
+        const formData = new FormData();
+        formData.append('document', documentFile.files[0]);
+        
+        console.log('문서 업로드 API 요청 전송');
+        // API 요청
+        const response = await fetch('/api/upload', {
+            method: 'POST',
+            body: formData
+        });
+        
+        const data = await response.json();
+        console.log('문서 업로드 API 응답 수신');
+        
+        // 응답 처리
+        if (data.error) {
+            console.error('업로드 오류:', data.error);
+            uploadStatus.className = 'upload-status error';
+            uploadStatus.textContent = `오류: ${data.error}`;
+        } else if (data.warning) {
+            console.warn('업로드 경고:', data.message);
+            uploadStatus.className = 'upload-status warning';
+            uploadStatus.textContent = data.message;
+        } else {
+            console.log('업로드 성공:', data.message);
+            uploadStatus.className = 'upload-status success';
+            uploadStatus.textContent = data.message;
+            
+            // 문서 목록 새로고침
+            loadDocuments();
+            
+            // 입력 필드 초기화
+            documentFile.value = '';
+            fileName.textContent = '선택된 파일 없음';
+        }
+    } catch (error) {
+        console.error('업로드 처리 중 오류:', error);
+        uploadStatus.className = 'upload-status error';
+        uploadStatus.textContent = '업로드 중 오류가 발생했습니다. 다시 시도해 주세요.';
+    } finally {
+        uploadButton.disabled = false;
+    }
+}
+
+/**
+ * 문서 목록 로드 함수
+ */
+async function loadDocuments() {
+    console.log('문서 목록 로드 시작');
+    
+    // UI 업데이트
+    docsList.querySelector('tbody').innerHTML = '';
+    docsLoading.classList.remove('hidden');
+    noDocsMessage.classList.add('hidden');
+    
+    try {
+        console.log('문서 목록 API 요청 전송');
+        // API 요청
+        const response = await fetch('/api/documents');
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        console.log(`문서 목록 API 응답 수신: ${data.documents ? data.documents.length : 0}개 문서`);
+        
+        // 응답 처리
+        docsLoading.classList.add('hidden');
+        
+        if (!data.documents || data.documents.length === 0) {
+            console.log('로드된 문서가 없음');
+            noDocsMessage.classList.remove('hidden');
+            return;
+        }
+        
+        // 문서 목록 업데이트
+        const tbody = docsList.querySelector('tbody');
+        data.documents.forEach(doc => {
+            console.log(`문서 표시: ${doc.filename || doc.source}`);
+            
+            const row = document.createElement('tr');
+            
+            const fileNameCell = document.createElement('td');
+            fileNameCell.textContent = doc.filename || doc.source;
+            row.appendChild(fileNameCell);
+            
+            const chunksCell = document.createElement('td');
+            chunksCell.textContent = doc.chunks;
+            row.appendChild(chunksCell);
+            
+            const typeCell = document.createElement('td');
+            typeCell.textContent = doc.filetype || '-';
+            row.appendChild(typeCell);
+            
+            tbody.appendChild(row);
+        });
+        
+        console.log('문서 목록 업데이트 완료');
+    } catch (error) {
+        console.error('문서 목록 로드 오류:', error);
+        docsLoading.classList.add('hidden');
+        noDocsMessage.classList.remove('hidden');
+        noDocsMessage.querySelector('p').textContent = '문서 목록을 불러오는 중 오류가 발생했습니다.';
+    }
+}
+
+// 페이지 로드 시 모듈 초기화
+document.addEventListener('DOMContentLoaded', function() {
+    console.log('문서 관리 모듈 초기화');
+    
+    // 비동기적으로 초기화 (DOM 요소가 준비된 후)
+    setTimeout(() => {
+        initDocsElements();
+    }, 100);
+});

app/static/js/app-llm.js

@@ -0,0 +1,273 @@
+/**
+ * RAG 검색 챗봇 LLM 관련 JavaScript
+ */
+
+/**
+ * LLM 목록 로드 함수
+ */
+async function loadLLMs() {
+    try {
+        console.log('LLM 목록 로드 시작');
+        
+        // API 요청
+        const response = await fetch('/api/llm');
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        supportedLLMs = data.supported_llms;
+        currentLLM = data.current_llm.id;
+        
+        console.log(`로드된 LLM 수: ${supportedLLMs.length}, 현재 LLM: ${currentLLM}`);
+        
+        // LLM 선택 드롭다운 업데이트
+        llmSelect.innerHTML = '';
+        supportedLLMs.forEach(llm => {
+            const option = document.createElement('option');
+            option.value = llm.id;
+            option.textContent = llm.name;
+            option.selected = llm.current;
+            llmSelect.appendChild(option);
+        });
+        
+        // 현재 LLM 표시
+        updateCurrentLLMInfo(data.current_llm);
+        console.log('LLM 목록 로드 완료');
+    } catch (error) {
+        console.error('LLM 목록 로드 실패:', error);
+    }
+}
+
+/**
+ * LLM 변경 함수
+ * @param {string} llmId - 변경할 LLM ID
+ */
+async function changeLLM(llmId) {
+    try {
+        console.log(`LLM 변경 시작: ${llmId}`);
+        
+        // API 요청
+        const response = await fetch('/api/llm', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ llm_id: llmId })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            currentLLM = llmId;
+            updateCurrentLLMInfo(data.current_llm);
+            console.log(`LLM 변경 성공: ${data.current_llm.name}`);
+            
+            // 시스템 메시지 추가
+            const systemMessage = `LLM이 ${data.current_llm.name}(으)로 변경되었습니다. 모델: ${data.current_llm.model}`;
+            addSystemNotification(systemMessage);
+        } else if (data.error) {
+            console.error('LLM 변경 오류:', data.error);
+            alert(`LLM 변경 오류: ${data.error}`);
+        }
+    } catch (error) {
+        console.error('LLM 변경 실패:', error);
+        alert('LLM 변경 중 오류가 발생했습니다.');
+    }
+}
+
+/**
+ * 현재 LLM 정보 표시 업데이트
+ * @param {Object} llmInfo - LLM 정보 객체
+ */
+function updateCurrentLLMInfo(llmInfo) {
+    console.log(`현재 LLM 정보 업데이트: ${llmInfo.name} (${llmInfo.model})`);
+    
+    if (currentLLMInfo) {
+        currentLLMInfo.textContent = `${llmInfo.name} (${llmInfo.model})`;
+    }
+}
+
+/**
+ * 채팅 메시지 전송 함수
+ */
+async function sendMessage() {
+    const message = userInput.value.trim();
+    if (!message) return;
+    
+    console.log(`메시지 전송: "${message}"`);
+    
+    // UI 업데이트
+    addMessage(message, 'user');
+    userInput.value = '';
+    adjustTextareaHeight();
+    
+    // 로딩 메시지 추가
+    const loadingMessageId = addLoadingMessage();
+    
+    try {
+        console.log('채팅 API 요청 시작');
+        
+        // API 요청
+        const response = await fetch('/api/chat', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ 
+                query: message,
+                llm_id: currentLLM  // 현재 선택된 LLM 전송
+            })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        console.log('채팅 API 응답 수신 완료');
+        
+        // 로딩 메시지 제거
+        removeLoadingMessage(loadingMessageId);
+        
+        // 응답 표시
+        if (data.error) {
+            console.error('채팅 응답 오류:', data.error);
+            addErrorMessage(data.error);
+        } else {
+            // LLM 정보 업데이트
+            if (data.llm) {
+                updateCurrentLLMInfo(data.llm);
+            }
+            console.log('봇 응답 표시');
+            addMessage(data.answer, 'bot', null, data.sources);
+        }
+    } catch (error) {
+        console.error('채팅 요청 오류:', error);
+        removeLoadingMessage(loadingMessageId);
+        addErrorMessage('오류가 발생했습니다. 다시 시도해 주세요.');
+    }
+}
+
+/**
+ * 음성 녹음 시작 함수
+ */
+async function startRecording() {
+    if (isRecording) return;
+    
+    console.log('음성 녹음 시작 요청');
+    
+    try {
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        isRecording = true;
+        audioChunks = [];
+        
+        mediaRecorder = new MediaRecorder(stream);
+        
+        mediaRecorder.addEventListener('dataavailable', (event) => {
+            if (event.data.size > 0) audioChunks.push(event.data);
+            console.log('오디오 데이터 청크 수신됨');
+        });
+        
+        mediaRecorder.addEventListener('stop', sendAudioMessage);
+        
+        // 녹음 시작
+        mediaRecorder.start();
+        console.log('MediaRecorder 시작됨');
+        
+        // UI 업데이트
+        micButton.style.display = 'none';
+        recordingStatus.classList.remove('hidden');
+    } catch (error) {
+        console.error('음성 녹음 권한을 얻을 수 없습니다:', error);
+        alert('마이크 접근 권한이 필요합니다.');
+    }
+}
+
+/**
+ * 음성 녹음 중지 함수
+ */
+function stopRecording() {
+    if (!isRecording || !mediaRecorder) return;
+    
+    console.log('음성 녹음 중지 요청');
+    
+    mediaRecorder.stop();
+    isRecording = false;
+    
+    // UI 업데이트
+    micButton.style.display = 'flex';
+    recordingStatus.classList.add('hidden');
+    
+    console.log('MediaRecorder 중지됨');
+}
+
+/**
+ * 녹음된 오디오 메시지 전송 함수
+ */
+async function sendAudioMessage() {
+    if (audioChunks.length === 0) return;
+    
+    console.log(`오디오 메시지 전송 준비, ${audioChunks.length}개 청크`);
+    
+    // 오디오 Blob 생성
+    const audioBlob = new Blob(audioChunks, { type: 'audio/wav' });
+    
+    // 로딩 메시지 추가
+    const loadingMessageId = addLoadingMessage();
+    
+    try {
+        // FormData에 오디오 추가
+        const formData = new FormData();
+        formData.append('audio', audioBlob, 'recording.wav');
+        // 현재 선택된 LLM 추가
+        formData.append('llm_id', currentLLM);
+        
+        console.log('음성 API 요청 시작');
+        // API 요청
+        const response = await fetch('/api/voice', {
+            method: 'POST',
+            body: formData
+        });
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        
+        const data = await response.json();
+        console.log('음성 API 응답 수신 완료');
+        
+        // 로딩 메시지 제거
+        removeLoadingMessage(loadingMessageId);
+        
+        // 응답 표시
+        if (data.error) {
+            console.error('음성 응답 오류:', data.error);
+            addErrorMessage(data.error);
+        } else {
+            // LLM 정보 업데이트
+            if (data.llm) {
+                updateCurrentLLMInfo(data.llm);
+            }
+            
+            // 사용자 메시지(음성 텍스트) 추가
+            if (data.transcription) {
+                console.log(`음성 인식 결과: "${data.transcription}"`);
+                addMessage(data.transcription, 'user');
+            }
+            
+            // 봇 응답 추가
+            console.log('봇 응답 표시');
+            addMessage(data.answer, 'bot', data.transcription, data.sources);
+        }
+    } catch (error) {
+        console.error('음성 요청 오류:', error);
+        removeLoadingMessage(loadingMessageId);
+        addErrorMessage('오디오 처리 중 오류가 발생했습니다. 다시 시도해 주세요.');
+    }
+}

app/static/js/app.js

@@ -0,0 +1,717 @@
+/**
+ * RAG 검색 챗봇 UI JavaScript
+ * 메인 파일 - 코어 및 장치 제어 모듈과 통합
+ */
+
+// DOM 요소
+const chatTab = document.getElementById('chatTab');
+const docsTab = document.getElementById('docsTab');
+const deviceTab = document.getElementById('deviceTab'); // 장치 제어 탭 추가
+const chatSection = document.getElementById('chatSection');
+const docsSection = document.getElementById('docsSection');
+const deviceSection = document.getElementById('deviceSection'); // 장치 제어 섹션 추가
+const chatMessages = document.getElementById('chatMessages');
+const userInput = document.getElementById('userInput');
+const sendButton = document.getElementById('sendButton');
+const micButton = document.getElementById('micButton');
+const stopRecordingButton = document.getElementById('stopRecordingButton');
+const recordingStatus = document.getElementById('recordingStatus');
+const uploadForm = document.getElementById('uploadForm');
+const documentFile = document.getElementById('documentFile');
+const fileName = document.getElementById('fileName');
+const uploadButton = document.getElementById('uploadButton');
+const uploadStatus = document.getElementById('uploadStatus');
+const refreshDocsButton = document.getElementById('refreshDocsButton');
+const docsList = document.getElementById('docsList');
+const docsLoading = document.getElementById('docsLoading');
+const noDocsMessage = document.getElementById('noDocsMessage');
+const llmSelect = document.getElementById('llmSelect');
+const currentLLMInfo = document.getElementById('currentLLMInfo');
+
+// LLM 관련 변수
+let currentLLM = 'openai';
+let supportedLLMs = [];
+
+// 녹음 관련 변수
+let mediaRecorder = null;
+let audioChunks = [];
+let isRecording = false;
+
+// 앱 초기화 상태 확인 함수
+async function checkAppStatus() {
+    try {
+        console.log('앱 상태 확인 요청 전송');
+        const response = await fetch('/api/status');
+        if (!response.ok) {
+            console.error(`앱 상태 확인 실패: ${response.status}`);
+            return false;
+        }
+        const data = await response.json();
+        console.log(`앱 상태 확인 결과: ${data.ready ? '준비됨' : '준비 안됨'}`);
+        return data.ready;
+    } catch (error) {
+        console.error('앱 상태 확인 중 오류 발생:', error);
+        return false;
+    }
+}
+
+/**
+ * LLM 목록 로드 함수
+ */
+async function loadLLMs() {
+    try {
+        // API 요청
+        console.log('LLM 목록 요청 전송');
+        const response = await AppUtils.fetchWithTimeout('/api/llm', {
+            method: 'GET'
+        });
+        
+        const data = await response.json();
+        supportedLLMs = data.supported_llms;
+        currentLLM = data.current_llm.id;
+        
+        console.log(`LLM 목록 로드 성공: ${supportedLLMs.length}개 모델`);
+        
+        // LLM 선택 드롭다운 업데이트
+        llmSelect.innerHTML = '';
+        supportedLLMs.forEach(llm => {
+            const option = document.createElement('option');
+            option.value = llm.id;
+            option.textContent = llm.name;
+            option.selected = llm.current;
+            llmSelect.appendChild(option);
+        });
+        
+        // 현재 LLM 표시
+        updateCurrentLLMInfo(data.current_llm);
+    } catch (error) {
+        console.error('LLM 목록 로드 실패:', error);
+    }
+}
+
+/**
+ * LLM 변경 함수
+ * @param {string} llmId - 변경할 LLM ID
+ */
+async function changeLLM(llmId) {
+    try {
+        // API 요청
+        console.log(`LLM 변경 요청: ${llmId}`);
+        const response = await AppUtils.fetchWithTimeout('/api/llm', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ llm_id: llmId })
+        });
+        
+        const data = await response.json();
+        
+        if (data.success) {
+            currentLLM = llmId;
+            updateCurrentLLMInfo(data.current_llm);
+            console.log(`LLM 변경 성공: ${data.current_llm.name}`);
+            
+            // 시스템 메시지 추가
+            const systemMessage = `LLM이 ${data.current_llm.name}(으)로 변경되었습니다. 모델: ${data.current_llm.model}`;
+            AppUtils.addSystemNotification(systemMessage);
+        } else if (data.error) {
+            console.error('LLM 변경 오류:', data.error);
+            alert(`LLM 변경 오류: ${data.error}`);
+        }
+    } catch (error) {
+        console.error('LLM 변경 실패:', error);
+        alert('LLM 변경 중 오류가 발생했습니다.');
+    }
+}
+
+/**
+ * 현재 LLM 정보 표시 업데이트
+ * @param {Object} llmInfo - LLM 정보 객체
+ */
+function updateCurrentLLMInfo(llmInfo) {
+    if (currentLLMInfo) {
+        currentLLMInfo.textContent = `${llmInfo.name} (${llmInfo.model})`;
+    }
+}
+
+// 탭 전환 함수
+function switchTab(tabName) {
+    console.log(`탭 전환: ${tabName}`);
+    
+    // 모든 탭과 섹션 비활성화
+    chatTab.classList.remove('active');
+    docsTab.classList.remove('active');
+    deviceTab.classList.remove('active');
+    chatSection.classList.remove('active');
+    docsSection.classList.remove('active');
+    deviceSection.classList.remove('active');
+    
+    // 선택한 탭과 섹션 활성화
+    if (tabName === 'chat') {
+        chatTab.classList.add('active');
+        chatSection.classList.add('active');
+    } else if (tabName === 'docs') {
+        docsTab.classList.add('active');
+        docsSection.classList.add('active');
+        // 문서 목록 로드
+        loadDocuments();
+    } else if (tabName === 'device') {
+        deviceTab.classList.add('active');
+        deviceSection.classList.add('active');
+    }
+}
+
+// 채팅 메시지 전송 함수
+async function sendMessage() {
+    const message = userInput.value.trim();
+    if (!message) {
+        console.log('메시지가 비어있어 전송하지 않음');
+        return;
+    }
+    
+    console.log('메시지 전송 시작');
+    
+    // UI 업데이트
+    addMessage(message, 'user');
+    userInput.value = '';
+    adjustTextareaHeight();
+    
+    // 로딩 메시지 추가
+    const loadingMessageId = addLoadingMessage();
+    
+    try {
+        // API 요청
+        console.log(`/api/chat API 호출: ${message.substring(0, 30)}${message.length > 30 ? '...' : ''}`);
+        const response = await AppUtils.fetchWithTimeout('/api/chat', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ 
+                query: message,
+                llm_id: currentLLM  // 현재 선택된 LLM 전송
+            })
+        });
+        
+        // 로딩 메시지 제거
+        removeLoadingMessage(loadingMessageId);
+        
+        // 응답 형식 확인
+        let data;
+        try {
+            data = await response.json();
+            console.log('API 응답 수신 완료');
+            
+            // 디버깅: 응답 구조 및 내용 로깅
+            console.log('응답 구조:', Object.keys(data));
+            if (data.answer) {
+                console.log('응답 길이:', data.answer.length);
+                console.log('응답 내용 일부:', data.answer.substring(0, 50) + '...');
+            }
+        } catch (jsonError) {
+            console.error('응답 JSON 파싱 실패:', jsonError);
+            AppUtils.addErrorMessage('서버 응답을 처리할 수 없습니다. 다시 시도해 주세요.');
+            return;
+        }
+        
+        // 응답 표시
+        if (data.error) {
+            console.error(`API 오류 응답: ${data.error}`);
+            AppUtils.addErrorMessage(data.error);
+        } else if (!data.answer || data.answer.trim() === '') {
+            console.error('응답 내용이 비어있음');
+            AppUtils.addErrorMessage('서버에서 빈 응답을 받았습니다. 다시 시도해 주세요.');
+        } else {
+            // LLM 정보 업데이트
+            if (data.llm) {
+                console.log(`LLM 정보 업데이트: ${data.llm.name}`);
+                updateCurrentLLMInfo(data.llm);
+            }
+            
+            try {
+                // 메시지 추가
+                addMessage(data.answer, 'bot', null, data.sources);
+                console.log('챗봇 응답 표시 완료');
+            } catch (displayError) {
+                console.error('응답 표시 중 오류:', displayError);
+                AppUtils.addErrorMessage('응답을 표시하는 중 오류가 발생했습니다. 다시 시도해 주세요.');
+            }
+        }
+    } catch (error) {
+        console.error('메시지 전송 중 오류 발생:', error);
+        removeLoadingMessage(loadingMessageId);
+        AppUtils.addErrorMessage('오류가 발생했습니다. 다시 시도해 주세요.');
+    }
+}
+
+/**
+ * 음성 녹음 시작 함수
+ */
+async function startRecording() {
+    if (isRecording) {
+        console.log('이미 녹음 중');
+        return;
+    }
+    
+    try {
+        console.log('마이크 접근 권한 요청');
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        isRecording = true;
+        audioChunks = [];
+        
+        mediaRecorder = new MediaRecorder(stream);
+        
+        mediaRecorder.addEventListener('dataavailable', (event) => {
+            if (event.data.size > 0) {
+                console.log('오디오 청크 데이터 수신');
+                audioChunks.push(event.data);
+            }
+        });
+        
+        mediaRecorder.addEventListener('stop', () => {
+            console.log('녹음 중지 이벤트 - 오디오 메시지 전송');
+            sendAudioMessage();
+        });
+        
+        // 녹음 시작
+        mediaRecorder.start();
+        console.log('녹음 시작됨');
+        
+        // UI 업데이트
+        micButton.style.display = 'none';
+        recordingStatus.classList.remove('hidden');
+    } catch (error) {
+        console.error('음성 녹음 권한을 얻을 수 없습니다:', error);
+        alert('마이크 접근 권한이 필요합니다.');
+    }
+}
+
+/**
+ * 음성 녹음 중지 함수
+ */
+function stopRecording() {
+    if (!isRecording || !mediaRecorder) {
+        console.log('녹음 중이 아님');
+        return;
+    }
+    
+    console.log('녹음 중지 요청');
+    mediaRecorder.stop();
+    isRecording = false;
+    
+    // UI 업데이트
+    micButton.style.display = 'flex';
+    recordingStatus.classList.add('hidden');
+}
+
+/**
+ * 녹음된 오디오 메시지 전송 함수
+ */
+async function sendAudioMessage() {
+    if (audioChunks.length === 0) {
+        console.log('오디오 청크가 없음');
+        return;
+    }
+    
+    console.log(`오디오 메시지 전송 시작: ${audioChunks.length}개 청크`);
+    
+    // 오디오 Blob 생성
+    const audioBlob = new Blob(audioChunks, { type: 'audio/wav' });
+    
+    // 로딩 메시지 추가
+    const loadingMessageId = addLoadingMessage();
+    
+    try {
+        // FormData에 오디오 추가
+        const formData = new FormData();
+        formData.append('audio', audioBlob, 'recording.wav');
+        // 현재 선택된 LLM 추가
+        formData.append('llm_id', currentLLM);
+        
+        console.log('/api/voice API 호출');
+        // API 요청
+        const response = await AppUtils.fetchWithTimeout('/api/voice', {
+            method: 'POST',
+            body: formData
+        }, 30000); // 음성 처리는 더 긴 타임아웃
+        
+        // 로딩 메시지 제거
+        removeLoadingMessage(loadingMessageId);
+        
+        // 응답 형식 확인
+        let data;
+        try {
+            data = await response.json();
+            console.log('음성 API 응답 수신 완료');
+            
+            // 디버깅: 응답 구조 및 내용 로깅
+            console.log('음성 응답 구조:', Object.keys(data));
+            if (data.answer) {
+                console.log('음성 응답 길이:', data.answer.length);
+                console.log('음성 응답 내용 일부:', data.answer.substring(0, 50) + '...');
+            }
+            if (data.transcription) {
+                console.log('음성 인식 길이:', data.transcription.length);
+            }
+        } catch (jsonError) {
+            console.error('음성 응답 JSON 파싱 실패:', jsonError);
+            AppUtils.addErrorMessage('서버 응답을 처리할 수 없습니다. 다시 시도해 주세요.');
+            return;
+        }
+        
+        // 응답 표시
+        if (data.error) {
+            console.error(`음성 API 오류 응답: ${data.error}`);
+            AppUtils.addErrorMessage(data.error);
+        } else if (!data.answer || data.answer.trim() === '') {
+            console.error('음성 응답 내용이 비어있음');
+            AppUtils.addErrorMessage('서버에서 빈 응답을 받았습니다. 다시 시도해 주세요.');
+        } else {
+            try {
+                // LLM 정보 업데이트
+                if (data.llm) {
+                    console.log(`LLM 정보 업데이트: ${data.llm.name}`);
+                    updateCurrentLLMInfo(data.llm);
+                }
+                
+                // 사용자 메시지(음성 텍스트) 추가
+                if (data.transcription) {
+                    console.log(`음성 인식 결과: ${data.transcription.substring(0, 30)}${data.transcription.length > 30 ? '...' : ''}`);
+                    addMessage(data.transcription, 'user');
+                }
+                
+                // 봇 응답 추가
+                addMessage(data.answer, 'bot', data.transcription, data.sources);
+                console.log('음성 채팅 응답 표시 완료');
+            } catch (displayError) {
+                console.error('음성 응답 표시 중 오류:', displayError);
+                AppUtils.addErrorMessage('응답을 표시하는 중 오류가 발생했습니다. 다시 시도해 주세요.');
+            }
+        }
+    } catch (error) {
+        console.error('음성 메시지 전송 중 오류 발생:', error);
+        removeLoadingMessage(loadingMessageId);
+        AppUtils.addErrorMessage('오디오 처리 중 오류가 발생했습니다. 다시 시도해 주세요.');
+    }
+}
+
+/**
+ * 문서 업로드 함수
+ */
+async function uploadDocument() {
+    if (documentFile.files.length === 0) {
+        console.log('선택된 파일 없음');
+        alert('파일을 선택해 주세요.');
+        return;
+    }
+    
+    console.log(`문서 업로드 시작: ${documentFile.files[0].name}`);
+    
+    // UI 업데이트
+    uploadStatus.classList.remove('hidden');
+    uploadStatus.className = 'upload-status';
+    uploadStatus.innerHTML = '<div class="spinner"></div><p>업로드 중...</p>';
+    uploadButton.disabled = true;
+    
+    try {
+        const formData = new FormData();
+        formData.append('document', documentFile.files[0]);
+        
+        // API 요청
+        console.log('/api/upload API 호출');
+        const response = await AppUtils.fetchWithTimeout('/api/upload', {
+            method: 'POST',
+            body: formData
+        }, 20000); // 업로드는 더 긴 타임아웃
+        
+        const data = await response.json();
+        console.log('업로드 API 응답 수신 완료');
+        
+        // 응답 처리
+        if (data.error) {
+            console.error(`업로드 오류: ${data.error}`);
+            uploadStatus.className = 'upload-status error';
+            uploadStatus.textContent = `오류: ${data.error}`;
+        } else if (data.warning) {
+            console.warn(`업로드 경고: ${data.message}`);
+            uploadStatus.className = 'upload-status warning';
+            uploadStatus.textContent = data.message;
+        } else {
+            console.log(`업로드 성공: ${data.message}`);
+            uploadStatus.className = 'upload-status success';
+            uploadStatus.textContent = data.message;
+            
+            // 문서 목록 새로고침
+            loadDocuments();
+            
+            // 입력 필드 초기화
+            documentFile.value = '';
+            fileName.textContent = '선택된 파일 없음';
+        }
+    } catch (error) {
+        console.error('문서 업로드 중 오류 발생:', error);
+        uploadStatus.className = 'upload-status error';
+        uploadStatus.textContent = '업로드 중 오류가 발생했습니다. 다시 시도해 주세요.';
+    } finally {
+        uploadButton.disabled = false;
+    }
+}
+
+/**
+ * 문서 목록 로드 함수
+ */
+async function loadDocuments() {
+    console.log('문서 목록 로드 시작');
+    
+    // UI 업데이트
+    docsList.querySelector('tbody').innerHTML = '';
+    docsLoading.classList.remove('hidden');
+    noDocsMessage.classList.add('hidden');
+    
+    try {
+        // API 요청
+        console.log('/api/documents API 호출');
+        const response = await AppUtils.fetchWithTimeout('/api/documents', {
+            method: 'GET'
+        });
+        
+        const data = await response.json();
+        console.log(`문서 목록 로드 성공: ${data.documents ? data.documents.length : 0}개 문서`);
+        
+        // 응답 처리
+        docsLoading.classList.add('hidden');
+        
+        if (!data.documents || data.documents.length === 0) {
+            console.log('문서 없음');
+            noDocsMessage.classList.remove('hidden');
+            return;
+        }
+        
+        // 문서 목록 업데이트
+        const tbody = docsList.querySelector('tbody');
+        data.documents.forEach(doc => {
+            const row = document.createElement('tr');
+            
+            const fileNameCell = document.createElement('td');
+            fileNameCell.textContent = doc.filename || doc.source;
+            row.appendChild(fileNameCell);
+            
+            const chunksCell = document.createElement('td');
+            chunksCell.textContent = doc.chunks;
+            row.appendChild(chunksCell);
+            
+            const typeCell = document.createElement('td');
+            typeCell.textContent = doc.filetype || '-';
+            row.appendChild(typeCell);
+            
+            tbody.appendChild(row);
+        });
+    } catch (error) {
+        console.error('문서 목록 로드 중 오류 발생:', error);
+        docsLoading.classList.add('hidden');
+        noDocsMessage.classList.remove('hidden');
+        noDocsMessage.querySelector('p').textContent = '문서 목록을 불러오는 중 오류가 발생했습니다.';
+    }
+}
+
+/**
+ * 메시지 추가 함수
+ * @param {string} text - 메시지 내용
+ * @param {string} sender - 메시지 발신자 ('user' 또는 'bot' 또는 'system')
+ * @param {string|null} transcription - 음성 인식 텍스트 (선택 사항)
+ * @param {Array|null} sources - 소스 정보 배열 (선택 사항)
+ */
+function addMessage(text, sender, transcription = null, sources = null) {
+    console.log(`메시지 추가: sender=${sender}, length=${text ? text.length : 0}`);
+    
+    const messageDiv = document.createElement('div');
+    messageDiv.classList.add('message', sender);
+    
+    const contentDiv = document.createElement('div');
+    contentDiv.classList.add('message-content');
+    
+    // 음성 인식 텍스트 추가 (있는 경우)
+    if (transcription && sender === 'bot') {
+        const transcriptionP = document.createElement('p');
+        transcriptionP.classList.add('transcription');
+        transcriptionP.textContent = `"${transcription}"`;
+        contentDiv.appendChild(transcriptionP);
+    }
+    
+    // 메시지 텍스트 추가
+    const textP = document.createElement('p');
+    textP.textContent = text;
+    contentDiv.appendChild(textP);
+    
+    // 소스 정보 추가 (있는 경우)
+    if (sources && sources.length > 0 && sender === 'bot') {
+        console.log(`소스 정보 추가: ${sources.length}개 소스`);
+        const sourcesDiv = document.createElement('div');
+        sourcesDiv.classList.add('sources');
+        
+        const sourcesTitle = document.createElement('strong');
+        sourcesTitle.textContent = '출처: ';
+        sourcesDiv.appendChild(sourcesTitle);
+        
+        sources.forEach((source, index) => {
+            if (index < 3) { // 최대 3개까지만 표시
+                const sourceSpan = document.createElement('span');
+                sourceSpan.classList.add('source-item');
+                sourceSpan.textContent = source.source;
+                sourcesDiv.appendChild(sourceSpan);
+            }
+        });
+        
+        contentDiv.appendChild(sourcesDiv);
+    }
+    
+    messageDiv.appendChild(contentDiv);
+    chatMessages.appendChild(messageDiv);
+    
+    // 스크롤을 가장 아래로 이동
+    chatMessages.scrollTop = chatMessages.scrollHeight;
+}
+
+/**
+ * 로딩 메시지 추가 함수
+ * @returns {string} 로딩 메시지 ID
+ */
+function addLoadingMessage() {
+    console.log('로딩 메시지 추가');
+    const id = 'loading-' + Date.now();
+    const messageDiv = document.createElement('div');
+    messageDiv.classList.add('message', 'bot');
+    messageDiv.id = id;
+    
+    const contentDiv = document.createElement('div');
+    contentDiv.classList.add('message-content');
+    
+    const loadingP = document.createElement('p');
+    loadingP.innerHTML = '<div class="spinner" style="width: 20px; height: 20px; display: inline-block; margin-right: 10px;"></div> 생각 중...';
+    contentDiv.appendChild(loadingP);
+    
+    messageDiv.appendChild(contentDiv);
+    chatMessages.appendChild(messageDiv);
+    
+    // 스크롤을 가장 아래로 이동
+    chatMessages.scrollTop = chatMessages.scrollHeight;
+    
+    return id;
+}
+
+/**
+ * 로딩 메시지 제거 함수
+ * @param {string} id - 로딩 메시지 ID
+ */
+function removeLoadingMessage(id) {
+    console.log(`로딩 메시지 제거: ${id}`);
+    const loadingMessage = document.getElementById(id);
+    if (loadingMessage) {
+        loadingMessage.remove();
+    }
+}
+
+/**
+ * textarea 높이 자동 조정 함수
+ */
+function adjustTextareaHeight() {
+    userInput.style.height = 'auto';
+    userInput.style.height = Math.min(userInput.scrollHeight, 100) + 'px';
+}
+
+// 페이지 로드 시 초기화
+document.addEventListener('DOMContentLoaded', () => {
+    console.log('메인 UI 초기화 중...');
+    
+    // 앱 상태 확인 (로딩 페이지가 아닌 경우에만)
+    if (window.location.pathname === '/' && !document.getElementById('app-loading-indicator')) {
+        // 앱 상태 주기적으로 확인
+        const statusInterval = setInterval(async () => {
+            const isReady = await checkAppStatus();
+            if (isReady) {
+                clearInterval(statusInterval);
+                console.log('앱이 준비되었습니다.');
+                
+                // 앱이 준비되면 LLM 목록 로드
+                loadLLMs();
+            }
+        }, 5000);
+    }
+
+    // 탭 전환 이벤트 리스너
+    chatTab.addEventListener('click', () => {
+        console.log('채팅 탭 클릭');
+        switchTab('chat');
+    });
+    
+    docsTab.addEventListener('click', () => {
+        console.log('문서 관리 탭 클릭');
+        switchTab('docs');
+    });
+    
+    // 장치 제어 탭은 DeviceControl 모듈에서 이벤트 리스너 등록함
+    
+    // LLM 선택 이벤트 리스너
+    llmSelect.addEventListener('change', (event) => {
+        console.log(`LLM 변경: ${event.target.value}`);
+        changeLLM(event.target.value);
+    });
+    
+    // 메시지 전송 이벤트 리스너
+    sendButton.addEventListener('click', () => {
+        console.log('메시지 전송 버튼 클릭');
+        sendMessage();
+    });
+    
+    userInput.addEventListener('keydown', (event) => {
+        if (event.key === 'Enter' && !event.shiftKey) {
+            console.log('텍스트 입력에서 엔터 키 감지');
+            event.preventDefault();
+            sendMessage();
+        }
+    });
+    
+    // 음성 인식 이벤트 리스너
+    micButton.addEventListener('click', () => {
+        console.log('마이크 버튼 클릭');
+        startRecording();
+    });
+    
+    stopRecordingButton.addEventListener('click', () => {
+        console.log('녹음 중지 버튼 클릭');
+        stopRecording();
+    });
+    
+    // 문서 업로드 이벤트 리스너
+    documentFile.addEventListener('change', (event) => {
+        console.log('파일 선택 변경');
+        if (event.target.files.length > 0) {
+            fileName.textContent = event.target.files[0].name;
+        } else {
+            fileName.textContent = '선택된 파일 없음';
+        }
+    });
+    
+    uploadForm.addEventListener('submit', (event) => {
+        console.log('문서 업로드 폼 제출');
+        event.preventDefault();
+        uploadDocument();
+    });
+    
+    // 문서 목록 새로고침 이벤트 리스너
+    refreshDocsButton.addEventListener('click', () => {
+        console.log('문서 목록 새로고침 버튼 클릭');
+        loadDocuments();
+    });
+    
+    // 자동 입력 필드 크기 조정
+    userInput.addEventListener('input', adjustTextareaHeight);
+    
+    // 초기 문서 목록 로드
+    if (docsSection.classList.contains('active')) {
+        loadDocuments();
+    }
+    
+    console.log('메인 UI 초기화 완료');
+});

app/templates/index.html

@@ -0,0 +1,175 @@
+<!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="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">
+        <header>
+            <h1>RAG 검색 챗봇</h1>
+            <div class="header-actions">
+                <div class="llm-selector">
+                    <label for="llmSelect">LLM 선택:</label>
+                    <select id="llmSelect">
+                        <!-- 옵션은 JavaScript에서 동적으로 로드됩니다 -->
+                    </select>
+                </div>
+                <div class="user-info">
+                    <span>사용자: {% if session.username %}{{ session.username }}{% else %}손님{% endif %}</span>
+                    <a href="{{ url_for('logout') }}" class="logout-button">
+                        <i class="fas fa-sign-out-alt"></i> 로그아웃
+                    </a>
+                </div>
+            </div>
+            <div class="tabs">
+                <button id="chatTab" class="tab active">대화</button>
+                <button id="docsTab" class="tab">문서관리</button>
+                <button id="deviceTab" class="tab">장치제어</button>
+            </div>
+        </header>
+
+        <main>
+            <!-- 대화 탭 -->
+            <section id="chatSection" class="tab-content active">
+                <div class="chat-container">
+                    <div class="chat-messages" id="chatMessages">
+                        <div class="message system">
+                            <div class="message-content">
+                                <p>안녕하세요! 지식베이스에 대해 궁금한 점을 물어보세요. 음성으로 질문하시려면 마이크 버튼을 누르세요.</p>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="chat-input-container">
+                        <textarea id="userInput" placeholder="메시지를 입력하세요..." rows="1"></textarea>
+                        <button id="micButton" class="mic-button">
+                            <i class="fas fa-microphone"></i>
+                        </button>
+                        <button id="sendButton" class="send-button">
+                            <i class="fas fa-paper-plane"></i>
+                        </button>
+                    </div>
+                    
+                    <div id="recordingStatus" class="recording-status hidden">
+                        <div class="recording-indicator">
+                            <div class="recording-pulse"></div>
+                        </div>
+                        <span>녹음 중...</span>
+                        <button id="stopRecordingButton" class="stop-recording-button">
+                            <i class="fas fa-stop"></i>
+                        </button>
+                    </div>
+                </div>
+            </section>
+
+            <!-- 문서관리 탭 -->
+            <section id="docsSection" class="tab-content">
+                <div class="docs-container">
+                    <div class="upload-section">
+                        <h2>문서 업로드</h2>
+                        <p>지식베이스에 추가할 문서를 업로드하세요. (지원 형식: .txt, .md, .csv)</p>
+                        
+                        <form id="uploadForm" enctype="multipart/form-data">
+                            <div class="file-upload">
+                                <input type="file" id="documentFile" name="document" accept=".txt,.md,.csv">
+                                <label for="documentFile">파일 선택</label>
+                                <span id="fileName">선택된 파일 없음</span>
+                            </div>
+                            
+                            <button type="submit" id="uploadButton" class="upload-button">
+                                <i class="fas fa-upload"></i> 업로드
+                            </button>
+                        </form>
+                        
+                        <div id="uploadStatus" class="upload-status hidden"></div>
+                    </div>
+                    
+                    <div class="docs-list-section">
+                        <h2>문서 목록</h2>
+                        <button id="refreshDocsButton" class="refresh-button">
+                            <i class="fas fa-sync-alt"></i> 새로고침
+                        </button>
+                        
+                        <div class="docs-list-container">
+                            <table id="docsList" class="docs-list">
+                                <thead>
+                                    <tr>
+                                        <th>파일명</th>
+                                        <th>청크 수</th>
+                                        <th>유형</th>
+                                    </tr>
+                                </thead>
+                                <tbody>
+                                    <!-- 문서 목록이 여기에 동적으로 추가됩니다 -->
+                                </tbody>
+                            </table>
+                            
+                            <div id="docsLoading" class="loading-indicator">
+                                <div class="spinner"></div>
+                                <p>문서 로딩 중...</p>
+                            </div>
+                            
+                            <div id="noDocsMessage" class="no-docs-message hidden">
+                                <p>지식베이스에 등록된 문서가 없습니다. 문서를 업로드해 주세요.</p>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+            <!-- 장치 제어 탭 -->
+            <section id="deviceSection" class="tab-content">
+                <div class="device-connection">
+                    <h3>1. 장치 서버 연결</h3>
+                    <div class="device-connection-form">
+                        <input type="text" id="deviceServerUrlInput" placeholder="LocalPCAgent Ngrok URL 입력 (https://xxxx-xx-xxx-xxx.ngrok-free.app 형식)">
+                        <button id="connectDeviceServerBtn">연결</button>
+                    </div>
+                    <div id="deviceConnectionStatus" class="connection-status disconnected">연결 상태: 연결되지 않음</div>
+                </div>
+
+                <div id="deviceBasicFunctions" class="device-functions">
+                    <h3>2. 기본 기능</h3>
+                    <div class="function-buttons">
+                        <button id="checkDeviceStatusBtn">장치 상태 확인</button>
+                    </div>
+                    <textarea id="deviceStatusResult" class="device-status-result" readonly></textarea>
+                </div>
+
+                <div id="deviceProgramControl" class="program-control">
+                    <h3>3. 프로그램 실행</h3>
+                    <div class="function-buttons">
+                        <button id="getProgramsBtn">프로그램 목록 새로고침</button>
+                    </div>
+                    <div id="programsList" class="program-list-container">
+                        <div class="no-programs-message">프로그램 목록이 여기에 표시됩니다.</div>
+                    </div>
+                    <div class="program-select-container">
+                        <select id="programSelectDropdown">
+                            <option value="">-- 목록 새로고침 후 선택 --</option>
+                        </select>
+                    </div>
+                    <button id="executeProgramBtn" class="execute-btn" disabled>선택한 프로그램 실행</button>
+                    <div id="executeResult" class="execute-result"></div>
+                </div>
+            </section>
+        </main>
+
+        <footer>
+            <p>© 2025 RAG 검색 챗봇 | OpenAI/DeepSeek LLM & VITO STT 활용</p>
+            <div class="current-llm">
+                <span>Current LLM: </span>
+                <span id="currentLLMInfo">-</span>
+            </div>
+        </footer>
+    </div>
+
+    <script src="{{ url_for('static', filename='js/app-core.js') }}"></script>
+    <script src="{{ url_for('static', filename='js/app-device.js') }}"></script>
+    <script src="{{ url_for('static', filename='js/app.js') }}"></script>
+</body>
+</html>

app/templates/loading.html

@@ -0,0 +1,75 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="refresh" content="5">  <!-- 5초마다 새로고침 -->
+    <title>RAG 검색 챗봇 - 초기화 중</title>
+    <style>
+        body {
+            font-family: 'Pretendard', 'Apple SD Gothic Neo', 'Noto Sans KR', sans-serif;
+            line-height: 1.6;
+            color: #333;
+            background-color: #f8f9fa;
+            text-align: center;
+            padding-top: 100px;
+            margin: 0;
+        }
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        h1 {
+            color: #4a6da7;
+            margin-bottom: 30px;
+        }
+        .loader {
+            border: 16px solid #f3f3f3;
+            border-top: 16px solid #4a6da7;
+            border-radius: 50%;
+            width: 80px;
+            height: 80px;
+            animation: spin 2s linear infinite;
+            margin: 0 auto 30px;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        p {
+            font-size: 18px;
+            margin-bottom: 20px;
+        }
+        .info {
+            background-color: #e7f0ff;
+            border-radius: 8px;
+            padding: 20px;
+            margin-top: 30px;
+            text-align: left;
+        }
+        .info h2 {
+            color: #4a6da7;
+            margin-top: 0;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>RAG 검색 챗봇 초기화 중...</h1>
+        <div class="loader"></div>
+        <p>첫 실행 시 데이터 준비에 시간이 소요됩니다. 잠시만 기다려주세요.</p>
+        <p>페이지는 5초마다 자동으로 새로고침됩니다.</p>
+        
+        <div class="info">
+            <h2>초기화 작업</h2>
+            <ul>
+                <li>벡터 인덱스 생성 중...</li>
+                <li>문서 처리 및 임베딩 생성 중...</li>
+                <li>검색 엔진 준비 중...</li>
+            </ul>
+            <p>이 과정은 최대 1-2분이 소요될 수 있습니다.</p>
+        </div>
+    </div>
+</body>
+</html>

app/templates/login.html

@@ -0,0 +1,126 @@
+<!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="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') }}">
+    <style>
+        .login-container {
+            max-width: 400px;
+            margin: 0 auto;
+            padding: 30px;
+            background-color: var(--card-bg);
+            border-radius: 10px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+        
+        .login-header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        
+        .login-form {
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .form-group {
+            margin-bottom: 20px;
+        }
+        
+        .form-group label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 600;
+            color: var(--primary-color);
+        }
+        
+        .form-group input {
+            width: 100%;
+            padding: 12px;
+            border: 1px solid var(--border-color);
+            border-radius: 4px;
+            font-size: 16px;
+            transition: var(--transition);
+        }
+        
+        .form-group input:focus {
+            border-color: var(--primary-color);
+            outline: none;
+        }
+        
+        .login-button {
+            padding: 12px;
+            background-color: var(--primary-color);
+            color: white;
+            border: none;
+            border-radius: 4px;
+            font-size: 16px;
+            cursor: pointer;
+            transition: var(--transition);
+        }
+        
+        .login-button:hover {
+            background-color: var(--primary-dark);
+        }
+        
+        .error-message {
+            color: var(--error-color);
+            margin: 15px 0;
+            text-align: center;
+            font-size: 14px;
+        }
+        
+        .login-footer {
+            text-align: center;
+            margin-top: 20px;
+            font-size: 0.9em;
+            color: var(--light-text);
+        }
+        
+        @media (max-width: 480px) {
+            .login-container {
+                padding: 20px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <main>
+            <div class="login-container">
+                <div class="login-header">
+                    <h1>RAG 검색 챗봇</h1>
+                    <p>계정 로그인 필요</p>
+                </div>
+                
+                {% if error %}
+                <div class="error-message">
+                    <i class="fas fa-exclamation-circle"></i> {{ error }}
+                </div>
+                {% endif %}
+                
+                <form class="login-form" method="post" action="{{ url_for('login') }}">
+                    <div class="form-group">
+                        <label for="username">아이디</label>
+                        <input type="text" id="username" name="username" required>
+                    </div>
+                    
+                    <div class="form-group">
+                        <label for="password">비밀번호</label>
+                        <input type="password" id="password" name="password" required>
+                    </div>
+                    
+                    <button type="submit" class="login-button">로그인</button>
+                </form>
+                
+                <div class="login-footer">
+                    <p>© 2025 RAG 검색 챗봇</p>
+                </div>
+            </div>
+        </main>
+    </div>
+</body>
+</html>

app_gradio.py

@@ -0,0 +1,206 @@
+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)

data/DatasetForRag.csv

@@ -0,0 +1,104 @@
+ID,���� ����,���� (Question),���� (Answer),���� ����/�ƶ� (Reference/Context)
+IT001,��� Ȯ��,������ 16 Pro Max ���� ȭ�� ũ��� �� ��ġ�ΰ���?,������ 16 Pro Max�� 6.9��ġ Super Retina XDR ���÷��̸� ž���߽��ϴ�.,"(2024-09-15) Apple's latest flagship, the iPhone 16 Pro Max, boasts an expansive 6.9-inch Super Retina XDR display, offering an immersive viewing experience with ProMotion technology and always-on capability."
+IT002,��� Ȯ��,�Ｚ ������ S25 Ultra�� ���� ī�޶� ȭ�Ҵ� ���ΰ���?,�Ｚ ������ S25 Ultra�� 2�� ȭ��(200MP)�� ���� ī�޶� ������ ž���� ������ ����˴ϴ�. (����: ��� �� �����̹Ƿ� ���� ����),"(2025-01-10) Leaks suggest the upcoming Samsung Galaxy S25 Ultra will retain a 200-megapixel primary camera sensor, likely with further improvements in sensor technology and image processing for enhanced low-light performance and detail capture."
+IT003,���� ����,����Ʈ���� '�ֻ���(Refresh Rate)'�̶� �����ΰ���?,"�ֻ����� ���÷��̰� 1�ʿ� ȭ���� �� ���̳� ���ΰ�ħ�ϴ����� ��Ÿ���� ��ġ�Դϴ�. ������ �츣��(Hz)�� ����ϸ�, ���� �ֻ���(��: 120Hz)�� ��ũ���̳� ȭ�� ��ȯ �� �� �ε巯�� �������� �����ݴϴ�.","Refresh rate, measured in Hertz (Hz), refers to how many times per second the display updates the image shown on the screen. A standard display might have a 60Hz refresh rate, while high-end smartphones often feature 90Hz, 120Hz, or even higher rates for smoother motion clarity, particularly noticeable in fast-paced games or while scrolling through content."
+IT004,�� �м�,������ 16�� ������ S25�� �ֿ� �������� �����ΰ���?,"�ü��(iOS vs Android), ������ ö��, ī�޶� �ý����� Ư¡(����, �� ���� ��), ���°� ������, �׸��� Ĩ�� ���� ��� �ֿ� ���̰� �ֽ��ϴ�. ������� ��ȣ���� ��� ȯ�濡 ���� ������� �޶��� �� �ֽ��ϴ�.","Key differences between the iPhone 16 and Galaxy S25 lie in their core operating systems (Apple's iOS vs. Google's Android), distinct design languages, camera philosophies (e.g., natural tones vs. vibrant processing, zoom capabilities), ecosystem integration (iMessage/AirDrop vs. Google/Samsung services), and the underlying chipset performance (A-series vs. Snapdragon/Exynos)."
+IT005,���� �ذ�,����Ʈ�� ���͸��� �ʹ� ���� ��ƿ�. ��� �ذ��� �� �ֳ���?,"ȭ�� ��� ����, ������� �ʴ� �� ����, ��׶��� �� Ȱ�� ����, ��ġ ���� ���� ����, ���� ��� Ȱ��ȭ, ���ʿ��� �˸� ���� ���� �õ��� �� �� �ֽ��ϴ�. ���͸� ��ü�� ����ȭ ���ɼ��� �����ؾ� �մϴ�.","To address rapid battery drain on your smartphone, try reducing screen brightness, closing apps you aren't actively using, limiting background app refresh and location services for non-essential apps, enabling power-saving or low-power modes, disabling unnecessary notifications, and checking battery usage statistics to identify power-hungry apps. If the issue persists, battery degradation might be the cause."
+IT006,��� ���,�ȵ���̵� ����Ʈ������ ��ũ������ ��� �ﳪ��?,"�Ϲ������� ���� ��ư�� ���� �ٿ� ��ư�� ���ÿ� ª�� ������ ��ũ������ �Կ��˴ϴ�. ��� �����糪 �𵨿� ���� �ճ��� ȭ�� ����, �� �հ������� ȭ�� ������ �� �ٸ� ����� ���� ���� �ֽ��ϴ�.","Taking a screenshot on most Android phones typically involves pressing and holding the power button and the volume down button simultaneously for a moment. Some manufacturers offer alternative methods, such as palm swipe gestures (Samsung) or three-finger swipes (various brands). The captured screenshot is usually saved to the gallery or a dedicated screenshots folder."
+IT007,��� Ȯ��,���� �ȼ� 8a�� ���� ��õǾ�����?,���� �ȼ� 8a�� 2024�� 5���� ���� ��ǥ �� ��õǾ����ϴ�.,"(2024-05-07) Google officially unveiled the Pixel 8a during its Google I/O event keynote in May 2024, making it available for purchase shortly thereafter. It serves as the more affordable alternative within the Pixel 8 lineup."
+IT008,���� ����,����Ʈ���� 'IP ���'�� ������ �ǹ��ϳ���? (��: IP68),"IP ����� 'Ingress Protection'�� ���ڷ�, ����� ����(ù ��° ����) �� ���(�� ��° ����) ������ ��Ÿ���ϴ�. IP68�� �ְ� ������ ����(6)�� ���� ���� �Ͽ����� ���(8, ���� 1.5m ���ɿ��� 30��)�� �ǹ��մϴ�.","The IP rating (Ingress Protection rating) classifies the level of protection an enclosure provides against intrusion from solid objects (like dust; indicated by the first digit) and liquids (water; indicated by the second digit). For example, an IP68 rating means the device is dust-tight (6) and protected against continuous immersion in water under conditions specified by the manufacturer (8, often up to 1.5 meters for 30 minutes)."
+IT009,���� �߷�,�ֽ� ����Ʈ���� AI ����� ���� ǰ�� ��� ��� �⿩�ϳ���?,"AI�� ��� �ν�, �ǻ�ü �ĺ�, ������ ����, ���� ������ �ռ�(HDR ��), �ι� ����� �ɵ� ȿ�� ����ȭ, ������ ȯ�濡���� ��� �� ������ ���� �� �پ��� ������� �����Ͽ� ���� ���� ������� ǰ���� ����ŵ�ϴ�.","AI algorithms in modern smartphones significantly enhance photo quality through various computational photography techniques. These include scene recognition for automatic setting optimization, subject detection for focus and exposure, advanced noise reduction, multi-frame synthesis for improved dynamic range (HDR) and low-light performance, sophisticated depth mapping for portrait mode bokeh, and semantic segmentation for targeted adjustments."
+IT010,�� �м�,OLED ���÷��̿� LCD ���÷����� ������� �����ΰ���?,"OLED�� ��ü �߱� ���ڸ� ����Ͽ� �Ϻ��� ������ ǥ��, ���� ���Ϻ�, ���� ���� �ӵ��� ����������, ���� ���� ���ɼ��� ��������� ���� ������ �����Դϴ�. LCD�� ���� ������ ���� ��� ǥ���� ������ ������, ���Ϻ� ���� ������ ǥ���� �Ѱ谡 �ֽ��ϴ�.","OLED (Organic Light-Emitting Diode) displays offer advantages like perfect blacks (pixels can turn off completely), infinite contrast ratios, wider viewing angles, and faster response times. Downsides can include potential burn-in over time and higher manufacturing costs. LCD (Liquid Crystal Display) panels are typically brighter, less prone to burn-in, and cheaper to produce, but they suffer from lower contrast ratios ('black' is dark grey due to the backlight) and potential backlight bleeding."
+IT011,��� Ȯ��,�ֽ� �����е� ���� �𵨿� ž��� Ĩ�� �̸��� �����ΰ���?,�ֽ� �����е� ���� (M4 Ĩ ž�� ��)���� Apple M4 Ĩ�� ž��Ǿ����ϴ�.,"(2024-05-07) Apple introduced the new iPad Pro lineup featuring the powerful, next-generation Apple M4 chip, delivering significant performance gains and enabling features like the Tandem OLED display and enhanced AI capabilities."
+IT012,���� ����,5G ��Ʈ��ũ�� �ֿ� Ư¡�� �����ΰ���?,"5G�� �ʰ���(eMBB), ��������(URLLC), �ʿ���(mMTC)�̶�� �� ���� �ֿ� Ư¡�� �����ϴ�. �̸� ���� �� ���� ������ �ӵ�, �ǽð��� ����� ���伺, �׸��� ������ ��⸦ ���ÿ� �����ϴ� ���� ���������ϴ�.","The key characteristics of 5G networks are Enhanced Mobile Broadband (eMBB) for significantly faster data speeds, Ultra-Reliable Low-Latency Communication (URLLC) for near-instantaneous responsiveness crucial for applications like autonomous driving and remote surgery, and Massive Machine-Type Communications (mMTC) enabling connectivity for a vast number of IoT devices simultaneously."
+IT013,���� �ذ�,����Ʈ�� ȭ���� ���ڱ� ���߰� ������ �����. ��� �ؾ� �ϳ���?,"��κ��� ���, ���� ��ư�� ���(10-30��) ���� ���� ������� �õ��ϸ� �ذ�� �� �ֽ��ϴ�. �ȵ���̵��� ��� '���� ��ư + ���� �ٿ� ��ư'�� ���ÿ� ��� ������ ���յ� ���˴ϴ�. ��⺰ ���� ����� ����� Ȯ���غ�����.","If your smartphone screen freezes and becomes unresponsive, the first troubleshooting step is usually a forced restart. For most iPhones, quickly press and release volume up, then volume down, then press and hold the side button. For many Android devices, press and hold the power button for 10-30 seconds, or press and hold the power button and volume down button together until the device restarts. Consult your device's manual for specific instructions."
+IT014,��� ���,���������� AirDrop(������) ����� ����ϴ� ����� �����ΰ���?,"���� ���͸� ���ų� ���� �ۿ��� AirDrop�� Ȱ��ȭ�ϰ� '���� ��', '����ó��', '��� ���' �� ���� �ɼ��� �����մϴ�. ������ ������ ���� ���� ��Ʈ���� AirDrop �������� ���ϰ� ������ ����̳� ��⸦ �����մϴ�.","To use AirDrop on an iPhone, ensure Wi-Fi and Bluetooth are turned on. Open Control Center or Settings > General > AirDrop, and choose your receiving preference ('Receiving Off', 'Contacts Only', or 'Everyone'). To share a file, tap the Share icon, select AirDrop, and then tap the user or device you want to share with. The recipient will receive a notification to accept or decline the file."
+IT015,���� �߷�,������ ����Ʈ�� ���� �� �����ؾ� �� ������� �����ϱ��?,"�������δ� ��ȭ���� �޴��ϱ� ���ϴٴ� ��, ��Ƽ�½�ŷ�� ���̼� ���� �ֽ��ϴ�. �������δ� �Ϲ� ����Ʈ�� ��� ���� ����, ������(Ư�� ������ ���� ���÷���)�� ���� ���, ��������� �β��� ���ſ� �� ���� �ֽ��ϴ�.","When considering purchasing a foldable smartphone, weigh the advantages, such as having a large tablet-like screen in a portable form factor and enhanced multitasking capabilities. However, also consider the disadvantages: higher price compared to traditional smartphones, potential concerns about long-term durability (especially the hinge mechanism and the flexible inner display), increased thickness and weight, and sometimes compromises in other specs (like battery size or camera modules) to accommodate the folding design."
+IT016,��� Ȯ��,������ 14 Ultra ���� ī�޶� ���� ������ ��� �dz���?,"������ 14 Ultra�� ����ī(Leica)�� ������ ���� ī�޶� �ý����� ���߰� ������, 1��ġ ������ ž���� ���� ī�޶�, �ʱ��� ī�޶�, �׸��� �� ���� ���� ī�޶�(3.2��, 5��)�� �����Ǿ� �ֽ��ϴ�.","(2024-02-22) The Xiaomi 14 Ultra features a sophisticated quad-camera system co-engineered with Leica. It includes a main camera with a large 1-inch LYT-900 sensor, an ultra-wide camera, a 3.2x telephoto camera with a floating lens element, and a 5x periscope telephoto camera, offering versatile focal lengths."
+IT017,���� ����,����Ʈ���� 'SoC(System on Chip)'�� �����ΰ���?,"SoC�� ����Ʈ���� �γ� ������ �ϴ� �ٽ� ��ǰ����, �߾�ó����ġ(CPU), �׷���ó����ġ(GPU), ��� ��(5G, LTE ��), AI ó�� ��ġ(NPU), �޸� ��Ʈ�ѷ� �� �پ��� ����� ȸ�θ� �ϳ��� Ĩ�� ������ ���Դϴ�.","A System on Chip (SoC) is an integrated circuit that combines multiple essential computing components onto a single silicon chip. In a smartphone, the SoC typically includes the Central Processing Unit (CPU), Graphics Processing Unit (GPU), memory controllers, communication modems (like 5G/LTE), Neural Processing Unit (NPU) for AI tasks, Image Signal Processor (ISP) for camera functions, and other necessary hardware accelerators, acting as the device's 'brain'."
+IT018,�� �м�,���� ������ ���� ���� �� � ����� �� ��������? �Ϲ������� �� �׷�����?,�Ϲ������� ���� ������ ���� �������� �� �����ϴ�. �̴� ���� ������ ���� �ս��� ���� �� ���� ������ ���������� ������ �� �ֱ� �����Դϴ�. ���� ������ ������ ���� �������� �����ϴ� �������� ������ �ս��� �߻��Ͽ� ���� ȿ���� �������� ������ �ֽ��ϴ�.,"Wired charging is generally faster than wireless charging because it offers a more direct and efficient transfer of electrical power with less energy loss. Wireless charging relies on electromagnetic induction between coils in the charger and the device, which inherently involves some energy loss as heat, limiting the maximum achievable charging speed and efficiency compared to a direct cable connection that can handle higher wattage more stably."
+IT019,���� �ذ�,��������(Wi-Fi)�� ����ƴٰ� �����µ� ���ͳ��� �� �ſ�. ��� �ؾ� �ϳ���?,1. ������(�����) ����� 2. ����Ʈ�� ����� 3. ����Ʈ���� Wi-Fi �������� �ش� ��Ʈ��ũ '�ر�' �� �翬�� 4. �ٸ� ��⿡���� ������ ������ �߻��ϴ��� Ȯ�� (������/���ͳ� ȸ�� ���� Ȯ��) 5. DNS ���� ���� ���� �õ��� �� �� �ֽ��ϴ�.,"If your phone shows it's connected to Wi-Fi but has no internet access, try these steps: 1. Restart your Wi-Fi router/modem. 2. Restart your smartphone. 3. Forget the Wi-Fi network on your phone (Settings > Wi-Fi > select network > Forget) and then reconnect. 4. Check if other devices on the same network have internet access (this helps isolate if the issue is with your phone or the network/ISP). 5. Try changing DNS settings on your phone (e.g., to Google DNS 8.8.8.8)."
+IT020,��� ���,������ ����Ʈ������ '�Ｚ ����(Samsung Pay)' ���� �� ������ �˷��ּ���.,"�Ｚ ����(�� �Ｚ ����) ���� ���� �Ｚ �������� �α����� ��, �ȳ��� ���� ���� ī��(�ſ�/üũ)�� ī�޶� ��ĵ �Ǵ� ���� �Է����� ����մϴ�. ���� �ÿ��� ȭ�� �ϴܿ��� ���� ����÷� ī�带 �����ϰ� ����/��й�ȣ ���� �� ���� �ܸ��⿡ ����Ʈ�� �޸��� ������ ��� �˴ϴ�.","To set up and use Samsung Pay (now part of Samsung Wallet) on a Galaxy phone: 1. Open the Samsung Wallet app and sign in with your Samsung account. 2. Follow the prompts to add a payment card by scanning it with the camera or entering details manually. 3. To pay, swipe up from the bottom of the screen (even when locked), select the desired card, authenticate with your fingerprint, PIN, or iris scan, and then tap the back of your phone near the payment terminal (NFC or MST)."
+IT021,���� �߷�,"����Ʈ�� ���� ����� ��ġ ���� ���� ������ �䱸�ϴ� ������ �����̸�, ��� �� � ���� �����ؾ� �ϳ���?","���� ��ġ ������ �䱸�ϴ� ������ ����/������̼�, �ֺ� ��� �˻�, ���� ���� ����, ������ ���� ǥ��, Ȱ�� ����(� ��) �� �پ��մϴ�. ��� �ÿ��� '�� ��� �߿��� ���' �ɼ��� �����ϰ�, ���ʿ��� �ۿ��� ������ �ο����� ������, �ֱ������� ���� ������ �����Ͽ� ���� ���� ���� ������ �ּ�ȭ�ؾ� �մϴ�.","Apps request location access for various functions: navigation (maps), finding nearby places, providing localized weather forecasts, delivering location-based ads or content, tracking workouts, geotagging photos, etc. When granting permission, it's crucial to: 1. Prefer the 'Allow only while using the app' option if available. 2. Deny permission to apps that don't genuinely need location data for their core function. 3. Regularly review app permissions in settings to minimize privacy risks and unnecessary data exposure."
+IT022,��� Ȯ��,���� ��ġ �ø��� 9�� �ֿ� �ǰ� ���� ����� �����ΰ���?,"������(ECG) ����, ���� ��� ��ȭ�� ����, �Ѿ��� ����, �浹 ����, �ո� �µ� ������ ���� ���� �ֱ� ����, �ɹڼ� ����͸�(��/�� �ɹڼ� �˸� ����) ���� �ֿ� �ǰ� ���� ����Դϴ�.","Key health-related features of the Apple Watch Series 9 include the ECG app for taking electrocardiograms, blood oxygen saturation (SpO2) measurement, fall detection, crash detection, wrist temperature sensing for retrospective ovulation estimates and cycle tracking, and continuous heart rate monitoring with notifications for high/low heart rates and irregular rhythms."
+IT023,���� ����,NFC(Near Field Communication)' ����� ����Ʈ������ ��� Ȱ��dz���?,"NFC�� ����� �Ÿ�(�� 10cm �̳�)���� ��� �� ���� ������ ����� �����ϰ� �ϴ� ����Դϴ�. ����Ʈ�������� ����� ����(�Ｚ����, ��������, �������� ��), ����ī�� ���, ������ ����(Android Beam ��), ����Ʈ ��� ���� �� ���� � Ȱ��˴ϴ�.","NFC (Near Field Communication) is a short-range wireless technology enabling communication between devices within close proximity (typically around 4 inches or 10 cm). On smartphones, it's used for various applications, including contactless mobile payments (like Google Pay, Apple Pay, Samsung Pay), transit passes, quick data transfer between phones (e.g., Android Beam - now deprecated but NFC still used for sharing), pairing with accessories (like headphones or speakers), and reading NFC tags for information or automation tasks."
+IT024,�� �м�,"����Ʈ�� �ü�� ������Ʈ�� �� �߿��ϸ�, ������Ʈ ���ķ� ������ ���� �����ΰ���?","OS ������Ʈ�� ���ο� ��� �߰�, ���� ����, ���� ����� ��ġ ���� �����ϹǷ� �߿��մϴ�. ������Ʈ ������ �߿��� �����͸� ����ϰ�, ����� ���� ������ ���͸� �ܷ��� Ȯ���ϸ�, �������� Wi-Fi ȯ�濡�� �����ϴ� ���� �����ϴ�. ������Ʈ �Ŀ��� ��Ȥ ���͸� �Ҹ� ������ �� ȣȯ�� ������ �߻��� �� �����Ƿ� ��ȭ�� ������ �ʿ䰡 �ֽ��ϴ�.","Smartphone OS updates are crucial as they often include new features, performance enhancements, bug fixes, and critical security patches to protect against vulnerabilities. Before updating, it's vital to back up important data, ensure sufficient storage space and battery level (or connect to power), and use a stable Wi-Fi connection. After updating, monitor for any changes, such as altered battery life or app compatibility issues, which can sometimes occur initially."
+IT025,���� �ذ�,����Ʈ�� �߿��� ���� �� ��� ��ó�ؾ� �ϳ���?,"����� ����/�� ��� �ߴ�, ���� �� ��� ����, ���籤�� ���� ���ϱ�, ����Ʈ�� ���̽� ��� ����, ���ʿ��� ���(GPS, �������� ��) ����, ��� ����� ���� �õ��� �� �� �ֽ��ϴ�. �߿��� ������������ ���ӵǸ� ���� ���� ������ �ʿ��� �� �ֽ��ϴ�.","If your smartphone overheats, try the following: Stop using demanding apps or games, avoid using the phone while it's charging, keep it out of direct sunlight, temporarily remove the case, turn off unnecessary features like GPS and Bluetooth, and restart the device. If excessive heating persists or seems abnormal, contact customer support or visit a service center, as it could indicate a hardware issue."
+IT026,���� ����,����Ʈ���� 'eSIM(�̽�)'�̶� �����ΰ���? ��� ����ϳ���?,"eSIM�� 'embedded SIM'�� ���ڷ�, �������� SIM ī�� ���� ��� ���ο� ����� Ĩ�� ���� ��Ż� ������ �ٿ�ε��Ͽ� ����ϴ� ������ SIM�Դϴ�. ��Ż� ���̳� QR �ڵ� ��ĵ ���� ���� �����Ͽ� ����� �� �ֽ��ϴ�.","An eSIM (embedded Subscriber Identity Module) is a digital SIM that allows users to activate a cellular plan from a carrier without having to use a physical nano-SIM card. The information is downloaded and programmed directly onto a dedicated chip inside the device. Activation is typically done through a carrier's app, a QR code, or manual entry of activation details provided by the carrier."
+IT027,��� Ȯ��,UWB(�ʱ��뿪) ����� ����Ʈ������ �ַ� � �뵵�� ���dz���?,"UWB ����� �ſ� ������ �Ÿ� �� ���� ������ �����Ͽ�, ����Ʈ�������� �ַ� ������ Ű(�ڵ��� �� ���� ��), �нǹ� ������(��: �����±�, ����Ʈ�±�)�� ���� Ž�� ���, ��� �� ���� ���� �� ���� �ν� � Ȱ��˴ϴ�.","Ultra-Wideband (UWB) technology enables highly accurate spatial awareness and precise distance measurement between devices. In smartphones, it's primarily used for features like secure digital car keys, precision finding of nearby tracker tags (e.g., Apple AirTag, Samsung SmartTag+), directional file sharing (like enhancing AirDrop), and seamless smart home device interactions."
+IT028,�� �м�,������ �۷��� ���ͽ� 2�� ������ �۷��� �Ƹ��� �������� �����ΰ���?,"������ �۷��� ���ͽ� 2�� ���� ��� ��ȣ�� ������ �� ��ȭ�����Դϴ�. �ݸ�, ������ S24 Ultra � ����� ������ �۷��� �ƸӴ� �پ ��ũ��ġ ���׼��� �Բ� ȭ�� �ݻ����� ũ�� ���� �������� ���� ���� Ư¡�Դϴ�.","Corning's Gorilla Glass Victus 2 primarily focuses on improved drop protection, particularly on rough surfaces like concrete. Gorilla Glass Armor, introduced on the Galaxy S24 Ultra, maintains strong scratch resistance while significantly reducing screen reflections (by up to 75%), enhancing outdoor visibility and perceived clarity."
+IT029,���� ����,����Ʈ�� ���� ��� �� 'GaN(��ȭ����)' ������� �����̸� ������ �����ΰ���?,"GaN ������� ���� �Ǹ��� ��� ��ȭ�����̶�� �ż��縦 ����Ͽ� ���� �������Դϴ�. GaN ����� ���� ȿ���� ���� ������ ���� ����� �� ���� ũ��� ���� �� ������, �߿��� ���ٴ� ������ �ֽ��ϴ�. �̸� ���� �� �۰� ������鼭�� ����� ������ ���������ϴ�.","GaN (Gallium Nitride) chargers utilize Gallium Nitride semiconductor material instead of traditional silicon. GaN is more power-efficient, allowing manufacturers to build smaller, lighter chargers that can deliver the same or higher power output compared to silicon-based ones. They also tend to generate less heat, contributing to their compact size and efficiency."
+IT030,��� Ȯ��,�Ｚ ������ ����Ʈ���� ������ �� �Ϲ������� � ���� ����Ʈ���� ������Ʈ ���� �Ⱓ�� �� �䰡��? (2025�� 4�� ����),"2025�� 4�� ��������, �÷��׽� ���� ��� �Ｚ�� ����(�ȼ�)�� �ִ� 7�Ⱓ�� OS �� ���� ������Ʈ�� ����ϸ� ���� �� ���� �Ⱓ�� �����ϴ� ������ �ֽ��ϴ�. ����(������) ���� �������� ������Ʈ�� ����������, �������� ���� �Ⱓ�� �������� �ʴ� ���Դϴ�.","(As of April 2025) For flagship devices, Samsung and Google (with its Pixel line) currently tend to offer the longest official software support durations, promising up to 7 years of both OS upgrades and security updates for recent models. Apple has a strong track record of providing long-term iOS updates for iPhones, often exceeding 5-6 years, but typically doesn't state a specific guaranteed timeframe upfront."
+IT031,���� �ذ�,�������� �̾����� ����Ʈ���� ������� �ʰų� �ڲ� ���ܿ�. �ذ� �����?,"1. �̾����� ����Ʈ�� ��� ����� 2. ����Ʈ�� �������� �������� �ش� �̾��� ��� ��� ���� �� ���� 3. �̾��� ���� ���� Ȯ�� 4. �ֺ� ���� ���� Ȯ��(�ٸ� �������� ���, Wi-Fi ������ ��) 5. ����Ʈ�� �� �̾��� �߿��� �ֽ� ������Ʈ Ȯ�� ���� �õ��� �� �� �ֽ��ϴ�.","If your Bluetooth earbuds won't connect or keep disconnecting: 1. Restart both the earbuds and your smartphone. 2. Unpair/forget the earbuds in your phone's Bluetooth settings and then re-pair them. 3. Ensure the earbuds are sufficiently charged. 4. Check for interference from other Bluetooth devices, Wi-Fi routers, or microwave ovens. 5. Make sure both your phone's OS and the earbuds' firmware are up-to-date."
+IT032,��� ���,�ȵ���̵� ����Ʈ������ Ȩ ȭ���� �ٸ� ��ó(Launcher) ������ �ٲٷ��� ��� �ϳ���?,"���� �÷��� ������ ���ϴ� ��ó ��(��: Nova Launcher, Microsoft Launcher ��)�� ��ġ�մϴ�. ��ġ ��, ����Ʈ�� ���� �޴��� '���ø����̼�' �Ǵ� 'Ȩ ȭ��' ���� �������� '�⺻ Ȩ ��' �Ǵ� '��ó' ������ ã�� ��ġ�� ��ó ������ �����ϸ� �˴ϴ�.","To change the home screen launcher on an Android phone: 1. Download a launcher app (e.g., Nova Launcher, Microsoft Launcher, Niagara Launcher) from the Google Play Store. 2. After installation, go to your phone's Settings app. 3. Navigate to 'Apps', 'Default apps', or 'Home screen' settings (the exact path varies by manufacturer). 4. Find the 'Default home app' or 'Launcher' setting and select the newly installed launcher you wish to use."
+IT033,�� �м�,"����Ʈ�� ���� ��, �÷��׽� �� ��� �߱ޱ�(�̵巹����)�� �����ص� ������ ���� �����ΰ���?","����� ���� �÷��̳� ������ ������ ī�޶� ������ �ʼ��� �ƴϸ�, �ַ� �� ����, SNS, ������ ��û, �⺻���� �� ��� �� �ϻ����� �뵵�� ����Ʈ���� ����Ѵٸ� ���� ��� ������ ���� �߱ޱ� �𵨷ε� ����� ���������� ��� ������ ���� �� �ֽ��ϴ�. ������ �������� ��쿡�� ���� ����Դϴ�.","Choosing a mid-range smartphone instead of a flagship is often suitable when: 1. You don't require top-tier gaming performance or professional-level camera capabilities. 2. Your primary usage involves everyday tasks like web Browse, social media, video streaming, messaging, and running standard apps. 3. Budget is a significant consideration, as mid-range phones offer good value for money. 4. You prioritize battery life, as some mid-range models excel in this area due to less power-hungry processors."
+IT034,���� ����,����� ���� �� MST(���׳�ƽ ���� ����) ��İ� NFC(�ٰŸ� ���� ���) ����� ���̴� �����ΰ���?,"NFC ����� ���� �ܸ���� ����Ʈ�� ���� ���� ���(RF ��ȣ)�� ���� ���� ������ ��ȯ�մϴ�. �ݸ�, MST ����� ����Ʈ������ �ڱ��� ��ȣ�� �߻����� ���� ���׳�ƽ ī�� �����Ⱑ �ִ� �ܸ��⿡���� ī�� ������ ���� �� �ֵ��� �ϴ� ����Դϴ�. (�Ｚ ���̿��� �ַ� ���Ǿ����� ���� NFC �߽����� ��ȯ ��)","NFC (Near Field Communication) payments work by establishing radio communication between the phone and an NFC-enabled payment terminal. MST (Magnetic Secure Transmission), primarily used by early Samsung Pay, generates a magnetic signal that mimics a physical card swipe, allowing payments on older terminals that only have a magnetic stripe reader. NFC requires specific NFC readers, while MST had broader (but declining) compatibility with older terminals."
+IT035,��� ���,���������� '���� ���(Focus Mode)'�� ��� �����ϰ� Ȱ���ϳ���?,"���� > ���� ��忡�� '���ر��� ���', '����', '����', '���� �ð�' �� �⺻ ��带 �����ϰų� '+' ��ư�� ���� ����� ���� ��带 ����ϴ�. �� ��庰�� �˸��� ����� ����� ���� �����ϰ�, Ư�� ��� ȭ�� �� Ȩ ȭ�� �������� �����Ͽ� �ش� ��忡 �´� ȯ���� ������ �� �ֽ��ϴ�.","To set up and use Focus Modes on an iPhone: Go to Settings > Focus. Choose a provided Focus (like Do Not Disturb, Work, Sleep, Personal) or tap the '+' button to create a custom one. For each Focus, specify which contacts and apps are allowed to send notifications. You can also link specific Lock Screen and Home Screen pages to a Focus, automatically activate it based on time, location, or app usage, and share your Focus status with others."
+IT036,���� �߷�,����Ʈ�� ���÷����� 'Always On Display(AOD)' ����� ���͸� �Ҹ� ��� ���� ������ ��ġ����? ��������� ��� �ּ�ȭ�ϳ���?,"AOD�� ȭ�� ��ü�� �ƴ� �Ϻ� �ȼ��� �Ѽ� �ð�, �˸� ���� ǥ���ϹǷ� �Ϲ����� ȭ�� �������ٴ� ���͸� �Ҹ� �����ϴ�. OLED ���÷��̴� ������ ǥ�� �� �ȼ��� ������ ���Ƿ� LCD���� AOD�� �����մϴ�. ����, ������ ���, ���� �ֻ���(��: 1Hz) ����, �ֺ� ��⿡ ���� ��� �ڵ� ���� ���� ���� ���͸� �Ҹ� �ּ�ȭ�մϴ�.","Always On Display (AOD) consumes less battery than having the full screen active because it only illuminates a small number of pixels to show information like time and notifications. OLED displays are particularly efficient for AOD as black pixels are completely turned off, consuming no power. Manufacturers further minimize battery drain by using low-power co-processors, drastically reducing the refresh rate (sometimes down to 1Hz) for the AOD, and automatically adjusting brightness based on ambient light or turning off AOD when the phone is in a pocket or face down."
+IT037,��� Ȯ��,Qi2(ġ��)' ���� ���� ǥ���� ���� Qi ǥ�ذ� ������ �� � ���� �����Ǿ�����?,"Qi2 ǥ���� ������ MagSafe ����� ������� �� MPP(Magnetic Power Profile)�� �����Ͽ�, ������� ��� ���� �ڼ� ������ ���� ������ ��ġ���� �������� ���� ������ �����ϰ� �մϴ�. �̸� ���� ���� ȿ���� ���̰�, ���������� �� ���� ���� ���� �ӵ��� �����ϸ�, ��ġ�� �� �پ��� ������ �׼����� ������ �����ϰ� �մϴ�.","The Qi2 wireless charging standard improves upon the original Qi standard primarily by incorporating the Magnetic Power Profile (MPP), based on Apple's MagSafe technology. This ensures perfect alignment between the charger and the device using magnets, leading to improved energy efficiency, potentially faster charging speeds (initially up to 15W, similar to MagSafe), and greater convenience, while also opening possibilities for new types of magnetic accessories like stands and mounts."
+IT038,���� ����,Ʈ�� ���̾�� �̾���(TWS)�� '��Ƽ�� ������ ĵ����(ANC)' ����� � ������ �۵��ϳ���?,"ANC�� �̾��� �ܺ� ����ũ�� �ֺ� ����(�ַ� �����ļ��� �ݺ����� ����)�� ������ ��, �� ������ �ݴ�Ǵ� ����(������)�� ���ĸ� �����Ͽ� ���� ����Ŀ�� ����մϴ�. �� �� ���İ� ���� �����ϸ鼭 ������ ����Ű�� �����Դϴ�.","Active Noise Cancellation (ANC) in True Wireless Stereo (TWS) earbuds works by using external microphones to pick up ambient noise (particularly low-frequency, consistent sounds like engine hum or AC noise). The ANC processor then generates an 'anti-noise' sound wave that is exactly out of phase with the incoming noise. This anti-noise is played through the earbud's internal speakers, and when the two sound waves meet, they interfere destructively, effectively cancelling out the unwanted noise before it reaches the listener's ear."
+IT039,���� �ذ�,����Ʈ�� ���� ������ �����ϴٴ� �˸��� ��� ����. ���� Ȯ�� �����?,"1. ������� �ʴ� �� ���� 2. ����/������ Ŭ����(���� ����, iCloud ��) ��� �� ��⿡�� ���� �Ǵ� �뷮 ����ȭ ��� ��� 3. ij�� ������ ���� (�� ���� �Ǵ� ��� ���� �޴�) 4. �ٿ�ε� ���� ���� 5. ��뷮 ����(������, ���� ������ ��) Ȯ�� �� ���� �Ǵ� ���� �޸�/PC�� �̵� (���� ��)","To free up storage space on your smartphone when you get 'storage full' warnings: 1. Uninstall apps you no longer use. 2. Back up photos and videos to a cloud service (like Google Photos, iCloud Photos) and then use the 'Free up space' option or delete them from the device. 3. Clear cached data for apps (via individual app settings or a device care/storage management tool). 4. Clean out the Downloads folder. 5. Identify and delete large files (videos, offline maps, game data) or move them to external storage (microSD card if supported) or a computer."
+IT040,��� ���,���������� �ٸ� ���������� �����͸� �ű�� ���� ���� ����� �����ΰ���?,"���� ����(Quick Start)' ����� ����ϴ� ���� ���� �����ϴ�. �� ������ ������ �Ѱ� ���� ������ ������ �θ�, ȭ�� �ȳ��� ���� ���� �������� ����, ��, ������ ��κ��� �� ���������� �������� ���� ������ �� �ֽ��ϴ�. iCloud ����� �̿��� ���� ����� �ֽ��ϴ�.","The easiest way to transfer data from an old iPhone to a new one is using 'Quick Start'. Turn on the new iPhone and place it near your old iPhone. Follow the on-screen prompts that appear on the old iPhone to use your Apple ID to set up the new device. You can then choose to transfer data directly (iPhone to iPhone wireless transfer) or restore from an iCloud backup. Direct transfer usually moves most settings, apps, and data seamlessly."
+IT041,�� �м�,����Ʈ�� ī�޶��� '���� ��'�� '������ ��'�� �ٺ����� ���̴� �����ΰ���?,"���� ���� ���� ���� ��� ���������� �̵����� ���� �Ÿ��� ���������ν� �̹����� Ȯ���ϴ� ����Դϴ�. ȭ�� ���� ���� �ǻ�ü�� ������ �Կ��� �� �ֽ��ϴ�. ������ ���� �Կ��� �̹����� Ư�� ������ ����Ʈ���������� Ȯ��(ũ��)�ϴ� ����̹Ƿ�, Ȯ�� ������ ���������� ȭ���� ����(�ȼ� ���� ����)�˴ϴ�.","Optical zoom uses the camera's lens elements physically moving to change the focal length and magnify the subject without losing image quality. It's like using the zoom lens on a traditional camera. Digital zoom, however, simply crops into the existing image captured by the sensor and enlarges that portion digitally (interpolation). This results in a loss of detail and pixelation as you increase the zoom level because no new image information is actually being captured."
+IT042,���� �߷�,����Ʈ���� '������ �Ǹ�(Right to Repair)' ���ǰ� ����ڿ��� ��ġ�� ������ ������ �����ϱ��?,"������ �Ǹ��� ����Ǹ� ����ڴ� �������� ���� ���񽺼��� �ܿ��� ���� �������� �̿��ϰų� �ڰ� ������ �� ���� �� �� �ְ� �˴ϴ�. �̴� ���� ��� ����, ���� �Ⱓ ����, ��� ���� ����(���� ��⹰ ����) ���� �������� ȿ���� �̾��� �� ������, ��ǰ �� ���� �Ŵ��� ���ټ� ����� ����� �� �ֽ��ϴ�.","The ""Right to Repair"" movement, when implemented through legislation or manufacturer policy changes, positively impacts smartphone users by: 1. Providing more choices for repairs beyond the original manufacturer (independent repair shops). 2. Potentially lowering repair costs due to increased competition. 3. Enabling easier self-repair through better access to genuine parts, tools, and repair manuals. 4. Extending the usable lifespan of devices, thus reducing electronic waste and saving users money on replacements."
+IT043,��� Ȯ��,�ֽ� ������ ��ġ(��: ������ ��ġ 7)���� ���� ���� ����� ž��Ǿ�����? (2025�� 4�� ����),"2025�� 4�� ����, ���ȭ�� ������ ��ġ �𵨿��� ��ħ���� ����� ���� ���� ���� ����� ���� ž����� �ʾҽ��ϴ�. ���� ����� ���� ���� ���̶�� �ҽ��� ������, ���� ���� �� ����� ������ ���ȭ������ �ð��� �� �ɸ� ������ ����˴ϴ�.","(As of April 2025) No, commercially available Galaxy Watch models, including the latest anticipated versions like the Galaxy Watch 7 series, do not yet feature non-invasive continuous blood glucose monitoring. While research and development in this area are ongoing by Samsung and others, the technology faces significant technical and regulatory hurdles before it can be reliably implemented and approved for consumer smartwatches."
+IT044,���� ����,"����Ʈ�� ī�޶��� 'Pro ���' �Ǵ� '������ ���'�� � ����̸�, ���� ����ϸ� ��������?","Pro ���� ISO(����), ���� �ӵ�, ȭ��Ʈ �뷱��, ����, ���� ���� �� ī�޶��� �ֿ� ������ ����ڰ� �������� ������ �� �ְ� ���ִ� ����Դϴ�. �ڵ� ��� ������� ���������� �ʰų�, Ư�� ȿ��(�����, Ư�� ���� ��)�� �ǵ������� �����ϰ� ���� �� ����ϸ� �����ϴ�.","The 'Pro' or 'Expert' mode in a smartphone camera app allows users to manually control key photographic settings, such as ISO (sensitivity), shutter speed, white balance, manual focus, and exposure compensation, much like on a DSLR or mirrorless camera. It's useful when you want more creative control over the final image than the automatic mode provides, for specific effects (like long exposures for light trails), or in tricky lighting situations where the auto mode struggles to produce the desired result."
+IT045,���� �ذ�,"Ư�� ��(��: īī����, �ν�Ÿ�׷�)���� �˸��� ���� �ʾƿ�. Ȯ���ؾ� �� ������?",1. ����Ʈ�� ��ü �˸� ���� Ȯ�� (�ش� �� �˸� ��� ����) 2. �� ���� �˸� ���� Ȯ�� (�� ���� ���� �˸� �ѱ�/���� ����) 3. ���ر��� ��� �Ǵ� ���� ��� Ȱ��ȭ ���� Ȯ�� 4. ���� ��� ���� Ȯ�� (��׶��� ������ �Ǵ� �˸� ���� ����) 5. �� ij�� ���� �Ǵ� �缳ġ �õ�,"If you're not receiving notifications from a specific app (e.g., KakaoTalk, Instagram): 1. Check the phone's main notification settings to ensure notifications are allowed for that app. 2. Check the in-app notification settings within the app itself. 3. Make sure Do Not Disturb or a Focus Mode isn't active and blocking notifications. 4. Verify that power-saving modes aren't restricting background data or notifications for the app. 5. Try clearing the app's cache or, as a last resort, reinstalling the app."
+IT046,��� ���,���� ����(Google Maps) �ۿ��� �������� ������ �ٿ�ε��ϰ� ����ϴ� �����?,���� ���� �� ���� > ������ ���� �� > '�������� ����' ���� > '�� ���� ����' �� > �ٿ�ε��� ������ �簢�� �ȿ� ���Խ�Ű�� '�ٿ�ε�' ��ư ������. �ٿ�ε�� ������ ���ͳ� ������ ���� �� �ڵ����� ���˴ϴ�.,To download and use offline maps in the Google Maps app: Open Google Maps > Tap your profile picture > Select 'Offline maps' > Tap 'Select your own map' > Pan and zoom the map to frame the area you want to download within the blue rectangle > Tap 'Download'. The downloaded map will be used automatically when you have a poor or no internet connection in that area.
+IT047,�� �м�,"����Ʈ�� ���� ��� �� ����, PIN, ���� �ν�, �� �ν� ������ �������?","����: �������� ���ȼ� ����(������ ����). PIN: ���Ϻ��� ���ȼ� ������ ���� ���� ���� ����. ���� �ν�: �����ϰ� ���ȼ� ������, �հ��� ����(����, ��ó)�� ���� �νķ� ���� ����. �� �ν�: �ſ� ����(���� ��� ��� ����)������, ����ũ ���� ��/��ο� ������ �νķ� ����, ���ȼ�(�ֵ���, ���� ��) �̽� ���� �� ���� (��� ��Ŀ� ���� �ٸ�).","Pattern: Fast, easy to remember, but low security (easily observed). PIN: More secure than pattern, but combinations can sometimes be guessed. Fingerprint: Convenient and generally secure, but recognition can fail with wet/dirty/injured fingers. Face Recognition: Very convenient (unlocks upon looking), but can struggle with masks or in low light, and security varies greatly by type (basic 2D vs. secure 3D like Face ID; 2D can sometimes be fooled by photos)."
+IT048,���� �߷�,����Ʈ�� ��ü �ֱⰡ ���� ������� ������ �ֵ� ������ �����̶�� �����ϳ���?,1. ����Ʈ�� ���� ���� ����ȭ: �ֽ����� ������ ���� ü�� ���� ���� ����. 2. ��� ���� ���: �÷��׽� �� ���� �δ� ����. 3. ����Ʈ���� ���� �Ⱓ ����: �������� �ֽ� OS ��� ����. 4. ���� ��ȭ: �ų� ���� ��� �������� ��� ��ȭ ����. 5. ȯ�� ���� �� ���Ӱ��ɼ��� ���� �ν� ����.,"The trend of longer smartphone replacement cycles can be attributed to several key factors: 1. Performance Plateau: Modern smartphones are powerful enough for most users' needs, reducing the perceived performance gap between new and older models. 2. Rising Device Prices: Flagship phone costs have increased significantly, making upgrades less affordable. 3. Longer Software Support: Manufacturers are providing OS and security updates for longer periods, keeping older devices functional and secure. 4. Slower Pace of Innovation: Year-over-year hardware innovations feel less revolutionary than in the past. 5. Increased Environmental Awareness: Users are more conscious of e-waste and the sustainability of frequent upgrades."
+IT049,��� Ȯ��,���� ���� ����(Apple Vision Pro)�� � ������ ����ΰ���?,"���� ���� ���δ� ������ ����� '���� ��ǻ��(Spatial Computer)'��, ȥ�� ����(MR) �����Դϴ�. ������� ���� ������ ������ �������� ���������Ͽ� �����ָ�, ��, ��, �������� ��ȣ�ۿ��մϴ�. VR(��������)�� AR(��������) ������ ��� �����մϴ�.","Apple Vision Pro is categorized by Apple as a ""spatial computer."" It is a mixed reality (MR) headset that blends digital content with the physical world. It allows users to interact with apps and media overlaid onto their surroundings using their eyes, hands, and voice. It provides both virtual reality (VR) and augmented reality (AR) experiences."
+IT050,���� ����,"Ŭ���� ���丮�� ����(iCloud, Google Drive, OneDrive ��)�� ����ϴ� �ֵ� ������ �����ΰ���?","1. ������ ��� �� ����: ��� �н�/���� �� ������ ��ȣ. 2. ���� ��� �� ���� ����ȭ: ����Ʈ��, �º���, PC ��� ���� ���� ����. 3. ���� ���� Ȯ��: ��� ���� ���� �뷮 �δ� ����. 4. ���� ���� �� ���� ���̼�.","The main advantages of using cloud storage services (like iCloud Drive, Google Drive, OneDrive, Dropbox) include: 1. Data Backup and Recovery: Protects files against device loss, theft, or failure. 2. Cross-Device Synchronization: Access the same files seamlessly across multiple devices (phone, tablet, computer). 3. Storage Expansion: Offloads files from local device storage, freeing up space. 4. Easy File Sharing and Collaboration: Simplifies sharing large files or working on documents with others."
+IT051,���� ����,"����Ʈ�� ���÷��� ��� �� 'LTPO'�� �����̸�, � ������ �ֳ���?","LTPO(Low-Temperature Polycrystalline Oxide)�� ���÷��� ���÷��� �����, ȭ�� �ֻ���(Refresh Rate)�� ��Ȳ�� �°� �ſ� ���� ����(��: 1Hz)���� �������� ������ �� �ְ� ���ݴϴ�. ������ ȭ�鿡���� �ֻ����� ���� ���͸� �Ҹ� ũ�� ���� �� �ִٴ� ���� ���� ū �����Դϴ�.","LTPO (Low-Temperature Polycrystalline Oxide) is an advanced display backplane technology primarily used in OLED panels. Its key advantage is enabling a variable refresh rate (VRR) that can dynamically adjust from very high (e.g., 120Hz) down to very low (e.g., 1Hz) depending on the content being displayed. This significantly reduces power consumption, especially for static content or Always-On Displays, thus improving battery life."
+IT052,���� ����,USB-PD ���� ǥ�ؿ��� 'PPS(Programmable Power Supply)'�� �����ΰ���?,"PPS�� USB Power Delivery(PD) 3.0 �̻� ���Ե� ���α׷��Ӻ� ���� ���� ǥ���Դϴ�. ���� �����Ⱑ �ǽð����� ����ϸ� ���а� ������ �̼��ϰ� �����Ͽ� ���� ȿ���� ���̰� �߿��� �ٿ��ָ�, Ư�� ���� ���� �� ���͸� �δ��� �����ִ� ������ �մϴ�.","PPS (Programmable Power Supply) is an optional standard within the USB Power Delivery (PD) 3.0 and later specifications. It allows for dynamic adjustment of voltage and current in small increments between the charger and the device being charged. This real-time negotiation leads to more efficient charging, reduced heat generation, and potentially faster charging speeds while being gentler on the battery's health compared to fixed voltage steps."
+IT053,�� �м�,����Ʈ�� RAM ���� �� LPDDR5�� LPDDR5X�� �ֿ� �������� �����ΰ���?,"LPDDR5X�� LPDDR5 ��� �� ���� ������ ���� �ӵ�(�뿪��)�� �����ϸ�, ���� ȿ������ �����Ǿ����ϴ�. �̴� ����� ����, ���ػ� ������ ó��, ��Ƽ�½�ŷ ��� �� ������ �ε巯�� ������ �����ϰ� �ϸ�, ���͸� �Ҹ�� ���̴� �� �⿩�մϴ�.","LPDDR5X is an evolution of the LPDDR5 mobile RAM standard. The primary difference is increased data transfer speed (bandwidth), with LPDDR5X typically offering speeds up to 8533 Mbps compared to LPDDR5's typical max of 6400 Mbps. It also features further improvements in power efficiency. This results in faster performance for demanding tasks like gaming, high-res video processing, and heavy multitasking, while potentially consuming less power."
+IT054,��� Ȯ��,��� ���÷��� ī�޶�(UDC) ����� 2025�� ���� ��� ���ر��� �����߳���? ������ ������ �ֳ���?,"2025�� ���� UDC ����� �ʱ� �� ��� ���� �����Ǿ�, ī�޶� Ȧ�� ���� ������ �����鼭�� ������ ǰ���� ��ī �Կ��� �����������ϴ�. ������ ������ �Ϲ� ��ġȦ ī�޶� ��� �� ������ ������ ������ �����̳� ���������� �ణ�� �ս��� ������, ���÷��� �ش� ������ ȭ�� ���ϼ� ������ ������ �ذ������ �ʾҽ��ϴ�.","(As of April 2025) Under-display camera (UDC) technology has matured significantly since its initial iterations. Current implementations (seen in some foldables and concept phones) offer a more seamless full-screen experience with the camera being less visible. Image quality has improved but generally still lags slightly behind traditional punch-hole cameras, especially in challenging low-light conditions or sharpness, due to light diffraction passing through the display layers. Minor display uniformity issues over the camera area can also still be perceptible."
+IT055,���� ����,����Ʈ���� '��ũ�� ����(Screen Reader)' ����� �����̸� �������� �ʿ��Ѱ���?,"��ũ�� ������ ȭ�鿡 ǥ�õ� �ؽ�Ʈ, ��ư, �̹��� ���� �� ��� ��Ҹ� �������� �о��ִ� ���ټ� ����Դϴ�. �ַ� �ð� ��ְ� �ִ� ����ڰ� ����Ʈ���� �����ϰ� ������ ���� �� �ֵ��� ���� ���� ���˴ϴ�. (��: iOS�� VoiceOver, Android�� TalkBack)","A Screen Reader is an accessibility feature that converts text, buttons, image descriptions, and other elements displayed on the screen into synthesized speech or braille output. It is primarily designed for users who are blind or have significant visual impairments, enabling them to navigate the interface, read content, and interact with their smartphone effectively. Examples include VoiceOver on iOS and TalkBack on Android."
+IT056,��� ���,"����� VPN�� � ��쿡 ����ϴ� ���� ������, ��� �� ������ ���� �����ΰ���?","���� Wi-Fi ��� �� ���� ��ȭ, ���� ���� ������ ����, ���� ���� ��ȣ(IP �ּ� ����) ���� ���� ����ϴ� ���� �����ϴ�. ������ �����δ� ���� VPN�� ��� �ӵ� ����, ������ �α�, ���� ���� ���� ���� �� �����Ƿ� �ŷ��� �� �ִ� ���� VPN ���񽺸� �����ϴ� ���� ����˴ϴ�. ���� VPN ����� �ҹ��� ������ �ֽ��ϴ�.","Using a mobile VPN is beneficial when: 1. Connecting to public Wi-Fi networks (enhances security). 2. Accessing geo-restricted content or services. 3. Protecting your privacy by masking your IP address. Points to consider: Free VPNs may have limitations like slow speeds, data caps, potential logging of your activity, or even security risks. Choosing a reputable paid VPN service is generally recommended for better performance and privacy. Also, be aware of the legality of VPN use in certain countries."
+IT057,��� Ȯ��,����Ʈ�� ��������� �������� �߰��� ���� �Ǹ�(Trade-in) ���α׷��� ��� �̿��ϳ���?,"�Ϲ������� ������ ������Ʈ�� ���� ������ �� ��� ���� �� '���� �Ǹ�' �ɼ��� �����մϴ�. ������ ����ϴ� ����� �𵨸�, ���� ���� �Է��ϸ� ���� ���� �ݾ��� Ȯ���� �� �ְ�, �� ��� ���� �� ���� ��⸦ ������ ������� �ݳ��ϸ� ���� �˼� �� ���� �ݾ��� Ȯ���Ǿ� ȯ�� �Ǵ� ���� ����˴ϴ�. (��: Apple Trade In, �Ｚ Ʈ���̵���)","Official trade-in programs from manufacturers like Apple (Apple Trade In) or Samsung (Samsung Trade-in) typically work as follows: When purchasing a new device online or in-store, select the trade-in option. You'll provide details about your old device (model, condition) to get an estimated trade-in value. After receiving your new device, you'll ship your old device back using provided instructions/materials. Once inspected, the final trade-in value is confirmed and applied as a credit or refund."
+IT058,���� �ذ�,����Ʈ�� GPS�� ���� ��ġ�� �� �� ��ų� ��Ȯ���� ��������. �ذ� �����?,1. GPS(��ġ ����) ���� Ȯ�� (���� ��Ȯ�� ��� Ȱ��ȭ) 2. �ǿܿ��� ��� ��� (���� ��ȣ ����) 3. ��� ����� 4. ���� �� ij��/������ ���� 5. A-GPS ������ ������Ʈ (Ư�� �� ��� �Ǵ� �ڵ� ������Ʈ Ȯ��) 6. ����Ʈ�� ���̽� ���� �� �׽�Ʈ (�ݼ� �� ���� Ȯ��) 7. OS ������Ʈ Ȯ��.,"If your smartphone's GPS is inaccurate or struggles to get a location fix: 1. Check location settings and ensure 'High accuracy' mode (using Wi-Fi, mobile networks, and GPS) is enabled. 2. Go outdoors with a clear view of the sky to allow better satellite signal reception. 3. Restart your device. 4. Clear the cache and data for your map app (e.g., Google Maps). 5. Reset/update A-GPS (Assisted GPS) data (some apps can help, or it happens automatically). 6. Temporarily remove the phone case to check for interference. 7. Check for OS updates."
+IT059,��� ���,�ȵ���̵� ������ ����� �ֽ���(�״���) ����� ��� �ѳ���?,���� > '��Ʈ��ũ �� ���ͳ�' �Ǵ� '����' > '����� �ֽ��� �� �״���' > '����� �ֽ���' ����ġ�� �մϴ�. �ֽ��� �̸�(SSID)�� ��й�ȣ�� Ȯ���ϰų� ������ �� �ֽ��ϴ�. ��� �����縶�� �޴� �̸��� �ణ �ٸ� �� �ֽ��ϴ�.,To turn on the mobile hotspot (tethering) feature on an Android phone: Go to Settings > Tap 'Network & internet' or 'Connections' > Select 'Hotspot & tethering' > Toggle the switch for 'Mobile Hotspot' (or Wi-Fi hotspot) to On. You can usually configure the hotspot name (SSID) and password within this menu. The exact menu names might vary slightly depending on the phone manufacturer and Android version.
+IT060,�� �м�,"�ֽ� ���� �ȼ� ��ġ�� �Ｚ ������ ��ġ�� ������ ��, ������ ������ �����ΰ���? (2025�� �� ����)","(���� �ó����� ���) �ȼ� ��ġ(��: �ȼ� ��ġ 3)�� ���� Wear OS ����, ���� ��ý���Ʈ ����, Fitbit �ǰ� ���� ����� ���� ������ �����Դϴ�. ������ ��ġ(��: ������ ��ġ 7)�� �پ��� ������/ũ�� �ɼ�, �Ｚ ���°� ������(SmartThings ��), ���� ������ Ȱ���� ��Ư�� ����� �������̽�(�Ϻ� ��) �� �� �� ���͸� ������ �����ϴ� ������ �ֽ��ϴ�.","(Based on typical trends, hypothetical 2025 models) The Pixel Watch (e.g., Pixel Watch 3) likely excels with its stock Wear OS experience, deep Google Assistant integration, and seamless Fitbit health tracking features. The Galaxy Watch (e.g., Galaxy Watch 7) often offers more hardware variety (sizes, rotating bezel option on some models), strong integration with the Samsung ecosystem (SmartThings, Samsung Health), potentially longer battery life on certain models, and a slightly different UI approach (One UI Watch)."
+IT061,���� �߷�,����Ʈ�� �����ο��� ���� ������� ���(IP68)�� Ȯ���ϴ� �Ͱ� ���� ���̼��� ���̴� �� ���̿��� � ���� ����(Trade-off)�� ���� �� �ֳ���?,"���� ������� ����� �޼��ϱ� ���� ��������� �������� �������ϰ� ����ϰ� ��ǰ���� �ſ� �����ϰ� ��ġ�ϸ�, ���� ����(��Ʈ ��)�� �ּ�ȭ�ϴ� ������ �ֽ��ϴ�. �̷��� ����� ���� ��ǰ ������ ��ư� ����� ���� �� ���� ������ �����ϰ� �ϰ� �ð��� ����� ������ų �� �ֽ��ϴ�. ��, ��� ���� ��ȭ�� ���� ���̼��� �����ϴ� ������ �� �� �ֽ��ϴ�.","Achieving a high IP rating (like IP68) often involves design choices that can hinder repairability. Manufacturers may use strong adhesives to seal the chassis, tightly pack components, use non-modular parts, and minimize ports, all of which make water and dust ingress harder. However, these same techniques make disassembly difficult and risky, increasing the complexity, time, and cost associated with repairs, thus creating a trade-off between water resistance and ease of repair."
+IT062,��� Ȯ��,"����Ʈ�� ī�޶� ���� ũ��(��: 1��ġ, 1/1.3��ġ)�� ���� ǰ���� � ������ �ֳ���?","�Ϲ������� ���� ũ�Ⱑ Ŭ���� �� �ȼ��� �� ���� ���� �޾Ƶ��� �� �ֽ��ϴ�. �̴� Ư�� ������ ȯ�濡�� ����� ���� �������� dz���ϸ�, ���̳��� ������(��� ��ο� �κ� ǥ�� �ɷ�)�� ���� ������ ��� �� �����մϴ�. ����, �� ���� �ɵ�(�ڿ������� ��� �帲) ǥ������ ������ �˴ϴ�.","A larger camera sensor size (e.g., 1-inch type vs. 1/1.3-inch type) generally allows each pixel on the sensor to be larger and capture more light. This translates to several advantages, particularly: better low-light performance (less noise, more detail), improved dynamic range (capturing detail in both bright highlights and dark shadows), and a shallower natural depth of field (more background blur or bokeh) without relying solely on software processing."
+IT063,���� ����,"��ƽ �ǵ��(Haptic Feedback)'�̶� �����̸�, ����Ʈ�� ����� ���迡 ��� �⿩�ϳ���?","��ƽ �ǵ���� ��ġ �Է��̳� Ư�� ���ۿ� �����Ͽ� ����ڿ��� �����̳� ������ ���� �˰��� �ǵ���� �����ϴ� ����Դϴ�. ����Ʈ�������� Ű���� Ÿ���� �� �̼��� ����, ��ư ���� ȿ��, ���ӿ����� Ÿ�ݰ� ���� �����Ͽ� ����� �������̽��� �� �������̰� ���԰� �ְ� �����, ������ ��ư�� ������ �ùķ��̼��ϴ� �� �⿩�մϴ�.","Haptic feedback refers to the use of touch sensations, like vibrations or textures, to provide feedback to the user in response to an action or event. On smartphones, sophisticated haptics (like Apple's Taptic Engine or similar Android implementations) enhance the user experience by providing subtle tactile confirmation for keyboard typing, simulating button presses, creating immersive effects in games, and making interactions feel more tangible and intuitive."
+IT064,���� �ذ�,����Ʈ�� ��ȭ �� ���� ��Ҹ��� �� �� �鸮�ų� �� ��Ҹ��� �� ���޵��� �ʾƿ�. ���ΰ� �ذ�å��?,"����: ��ȭ��(����Ŀ)/����ũ ���� �̹��� ����, ��� ��ȣ �ҷ�, ����Ʈ���� ����, �������� ��� ���� ����, VoLTE ���� ���� ��. �ذ�å: 1. ��ȭ��/����ũ ���� û�� 2. ��ȭ ���� �̵�(��ȣ ���� ��) 3. ��� ����� 4. �������� ���� 5. VoLTE �ѱ�/���� �õ� 6. OS �� ��Ż� ���� ������Ʈ Ȯ��.","Poor call quality (can't hear others well / they can't hear you) can be caused by: blocked earpiece/microphone holes (dust/debris), weak cellular signal, software glitches, issues with connected Bluetooth devices, VoLTE setting problems. Solutions: 1. Gently clean the earpiece speaker and microphone holes. 2. Move to an area with better cell reception. 3. Restart your phone. 4. Turn off Bluetooth temporarily. 5. Toggle VoLTE (Voice over LTE) settings on/off. 6. Check for OS and carrier settings updates."
+IT065,��� ���,����Ʈ�� ȭ�� ��ȭ ����� ��� ����ϳ���? (iOS / Android �Ϲ����� ���),"iOS: ���� ���Ϳ� 'ȭ�� ���' ��ư �߰� ��, ���� ���� ���� �ش� ��ư �� (����ũ ����� ���� ���� ���� ����). Android: ���� ���� �޴�(��� �� ����)�� 'ȭ�� ��ȭ' �Ǵ� '��ũ�� ���ڴ�' Ÿ�� �߰�/���� �� ��ȭ ���� (����� ���� �ɼ� ���� ����). �����纰�� �ణ�� ���� ����.","iOS: Add the 'Screen Recording' button to Control Center (Settings > Control Center). Open Control Center, tap the Screen Recording button (long-press to toggle microphone audio). Android (stock/common method): Swipe down to open the Quick Settings panel, find and tap the 'Screen record' or 'Screen recorder' tile (you might need to edit the panel to add it). Choose audio recording options and tap Start. Specific steps might vary slightly by manufacturer."
+IT066,�� �м�,"����Ʈ�� ���� �� ���� ���丮�� �뷮(128GB, 256GB, 512GB ��)�� � �������� �����ؾ� �ұ��?","����/������(Ư�� 4K) �Կ� ��, ����� ���� ��ġ ����, �������� ���� ������(����, ��ȭ) �뷮, Ŭ���� ���丮�� Ȱ�� ���� ���� �����ؾ� �մϴ�. �Ϲ������� ����/������ ���� ����ڴ� 256GB �̻�, ����/�� ���� ����ڴ� 512GB �̻�, Ŭ���� Ȱ�뵵�� ���� �⺻���� ��븸 �Ѵٸ� 128GB�� ������ �� �ֽ��ϴ�. microSD ī�� Ȯ�� ���� ���ε� �߿��� ���� �����Դϴ�.","Choosing internal storage capacity (128GB, 256GB, 512GB, etc.) depends on: How often you take photos/videos (especially high-resolution like 4K), how many large games you install, how much offline media (music, movies) you store, and how heavily you rely on cloud storage. General guidance: Casual users relying on cloud might be okay with 128GB. Moderate users/photographers often find 256GB a good balance. Heavy users, gamers, or videographers might need 512GB or more. Also consider if the phone supports microSD card expansion."
+IT067,���� �߷�,"����Ʈ�� �� ����(�۽����, �÷��̽����)�� �ξ� ���� ������ ��å ������ �����ڿ� �Һ��ڿ��� ��ġ�� ������ �����ϱ��?","������: ���� ������(15~30%)�� ���� ���ҷ� �̾��� �� ���� �λ� �Ǵ� ���� ��� ������ �� �� ������, �ܺ� ���� �ý��� ���� �� �� ���� ���� ���� ����. �Һ���: ���߻��� �δ��� �� ����/������ �λ����� ������ �� ����. �ܺ� ���� ��� �� ���� ���Ǽ�/���ȼ� ��ȭ ���ɼ�. �� ���� ���°� ���� �� ���ſ� ������ �� �� ����.","Debates over in-app purchase commission rates (typically 15-30%) on major app stores impact developers and consumers: Developers: High fees reduce revenue, potentially leading to higher app prices, reduced investment, or exploring alternative payment systems (which can risk app removal). Consumers: Developer costs might be passed on as higher prices or subscription fees. Allowing external payments could offer choice but might fragment the payment experience or raise security concerns for some. The policies influence competition and innovation within the app ecosystem."
+IT068,��� Ȯ��,"�Ｚ '����(DeX)' ����� �����̸�, � ��⿡�� ����� �� �ֳ���?","�Ｚ DeX�� �Ｚ ������ ����Ʈ���̳� �º����� �����, TV, PC � �����Ͽ� ����ũ�� ��ǻ�Ϳ� ������ ��� ȯ���� �����ϴ� ����Դϴ�. Ű����, ���콺 ������ ���� ��Ƽ�½�ŷ, ���� �۾�, ���������̼� ���� ū ȭ�鿡�� �����ϰ� ������ �� �ֽ��ϴ�. �ַ� ������ S �ø���, ��Ʈ �ø���(����), Z ���� �ø���, �� S �ø��� �� �÷��׽� ��⿡�� �����˴ϴ�.","Samsung DeX (Desktop Experience) is a feature that allows users to connect their Samsung Galaxy smartphone or tablet to an external display (monitor, TV, or PC) to get a desktop-like computing environment. With a keyboard and mouse connected, users can multitask with multiple windows, work on documents, give presentations, and use apps on a larger screen. It's primarily available on flagship Galaxy devices, including recent Galaxy S series, Z Fold series, and Tab S series models."
+IT069,���� ����,"����Ʈ�� ��� ��� �׽�Ʈ �� '���(Freshwater)' ������ ������ �ǹ��ϸ�, �� �ٴ幰�̳� �ٸ� ��ü�� ���ؾ� �ϳ���?","����Ʈ�� ��� �׽�Ʈ�� ������ ����� ȯ�濡�� ������ ��(���)�� �������� ����˴ϴ�. �ٴ幰�� ���� ������ �νļ��� ���ϰ�, ������� ȭ�� ��ǰ �� �ٸ� ��ü�� ������, ����, �ν� ���� �����Ͽ� ��� ���� �ջ��̳� ������ ����ų �� �ֽ��ϴ�. ���� ��� ����� ��� ȯ�濡 �����Ǹ�, �ٸ� ��ü�� ����Ǵ� ���� ���ؾ� �մϴ�.","Smartphone water resistance tests (IP ratings) are conducted under controlled lab conditions using fresh water. Saltwater (seawater) is highly corrosive due to salt content and can damage seals and internal components quickly. Other liquids like sugary drinks, coffee, or chemicals can cause stickiness, residue buildup, corrosion, and short circuits. Therefore, the advertised water resistance rating applies specifically to fresh water exposure, and contact with other liquids should be avoided."
+IT070,���� �ذ�,����Ʈ�� ȭ�� ��ġ�� ���������� �� �� �ǰų� Ư�� ������ �� �ſ�. ������ �����ϱ��?,"����: 1. ȭ�� ��ȣ �ʸ�/��ȭ ���� ���� (���, ����, �β�) 2. ȭ�� ���� (����, ����) 3. �Ͻ����� ����Ʈ���� ���� (�� �浹 ��) 4. Ư�� �۰��� ȣȯ�� ���� 5. �ϵ����(��ġ��ũ�� �г�) �ջ� ���ɼ�. �ذ� �õ�: �ʸ� ���� �� �׽�Ʈ, ȭ�� û��, ��� �����, �ǽ� �� ����, ������ �ɼǿ��� ��ġ �׽�Ʈ, ���Ŀ��� ���񽺼��� ����.","Intermittent or localized touch screen issues can be caused by: 1. Problems with the screen protector/tempered glass (poor fit, dirt underneath, thickness). 2. A dirty screen (water droplets, oil). 3. Temporary software glitches (app freezes). 4. Compatibility issues with a specific app. 5. Potential hardware damage to the digitizer (touch panel). Troubleshooting: Test without the screen protector, clean the screen thoroughly, restart the device, uninstall recently added apps, use developer options for touch diagnostics, and if problems persist, seek professional repair."
+IT071,���� �ذ�,Wi-Fi ������ �Ǵµ� �ڲ� ���ܿ�. ��� �ؾ� �ϳ���?,1. ������(�����) �� ����Ʈ�� ����� 2. ������� ����Ʈ�� �Ÿ� Ȯ�� �� ��ֹ� ���� 3. ����Ʈ�� Wi-Fi �������� '��Ʈ��ũ ���� �ʱ�ȭ' �õ� 4. Ư�� Wi-Fi ��Ʈ��ũ������ �߻��ϴ��� Ȯ�� (�ٸ� Wi-Fi �׽�Ʈ) 5. ������ �߿��� ������Ʈ Ȯ�� 6. �ٸ� ��⵵ ���� ���� �� ������ ���� �Ǵ� ���ͳ� ȸ�� ���� �ʿ�.,"(Forum Post Snippet) ""My phone keeps disconnecting from Wi-Fi even though it shows connected initially. I've tried restarting everything. Usually, checking router placement, resetting network settings on the phone, or even checking the router's channel settings can help. If it happens everywhere, might be the phone; if only at home and affects other devices, likely the router or ISP."""
+IT072,���� �ذ�,����� ������(LTE/5G)�� ���ڱ� �� �ſ�. ��Ż� �ΰ��� �ߴµ� ���ͳ� ������ �� �˴ϴ�.,1. ����� ��� �״ٰ� ���� 2. ����Ʈ�� ����� 3. ���� > '����� ��Ʈ��ũ' > '�׼��� ����Ʈ �̸�(APN)' �ʱ�ȭ �Ǵ� Ȯ�� 4. ������ ��뷮 �ѵ� �ʰ� ���� Ȯ�� (��Ż� ��/������Ʈ) 5. SIM ī�� ������ 6. ��Ʈ��ũ ���� �ʱ�ȭ �õ� 7. Ư�� ���� ������ �� ������ �ٸ� ��ҿ��� Ȯ��.,"(Carrier Help Article) ""If mobile data isn't working despite showing a signal: 1. Toggle Airplane mode. 2. Restart your device. 3. Check APN settings (Settings > Mobile Networks > Access Point Names > Reset to default). 4. Verify you haven't exceeded your data limit. 5. Reseat your SIM card. 6. Try resetting network settings. If the issue persists, contact customer support."""
+IT073,���� �ذ�,����Ʈ�� ���͸� ���� �ӵ��� �ʹ� ������. �������� �ξ� ���� �ɸ��ϴ�.,1. ��ǰ �Ǵ� ������ ���� ������ �� ���̺� ��� ���� Ȯ�� 2. ���� ���̺� �ջ� ���� Ȯ�� (�ٸ� ���̺��� �׽�Ʈ) 3. ���� ��Ʈ(����) �̹��� Ȯ�� �� û�� (�ε巯�� �� ���) 4. ���� �� ����� �� ��� ���� 5. ��� ����� 6. ��׶��� �� Ȱ�� Ȯ�� (���͸� �Ҹ� ���� �� Ȯ��) 7. ���� ���� �����Ͽ� ���� �ӵ� Ȯ�� (����Ʈ���� ���� ����).,"(Troubleshooting Guide) ""Slow charging can be due to a faulty cable, adapter, or dirty charging port. Always use certified chargers/cables. Check the port for lint/debris. Avoid heavy usage while charging. Background apps can also consume power. Testing in Safe Mode can help rule out third-party app issues. If the problem continues, the battery itself might be degrading."""
+IT074,���� �ذ�,����Ʈ�� ������ ���ڱ� �� ������. ȭ���� �׳� ��İ� ���ɴϴ�.,"1. ���͸� ���� ���� ���ɼ�: �ּ� 30�� �̻� ���� �õ� 2. ���� ����� �õ� (������ ��� Ȯ��: ��) ����+�����ٿ� ��� ������) 3. �ٸ� ������ �� ���̺��� ���� �õ� 4. ���� ���� ���� ���� Ȯ�� 5. ȭ�� ��Ⱑ ������ �Ǿ� �ְų� �ܺ� ���÷��� ���� �������� Ȯ�� (���� ��) 6. �� ������� �ذ� �� �Ǹ� ���� ���� ���� �ʿ� (���͸�, ���κ��� �� �ϵ���� ���� ���ɼ�).","(Device Manual Excerpt) ""If your phone doesn't turn on (black screen): 1. Charge the device for at least 30 minutes as the battery might be fully depleted. 2. Attempt a forced restart (e.g., Press and hold Power + Volume Down buttons for 10-15 seconds). 3. Try a different charger and cable. 4. Check the charging port connection. If unresponsive, it might require professional service."""
+IT075,���� �ذ�,����Ʈ�� ī�޶� ���� �����ϸ� ȭ���� ��İ� �����ų� ���� �ٷ� ����˴ϴ�.,"1. ī�޶� ���� ���� ���� Ȯ�� 2. ��� ����� 3. ���� > ���ø����̼� > ī�޶� �� > ���� ���� > 'ij�� ����' �� '������ ����' �õ� (������ ���� �� ���� �ʱ�ȭ��) 4. �ٸ� ī�޶� ��(��: �ν�Ÿ�׷�, ����� ��) ���� �� ���� ���� Ȯ�� (�ϵ���� ���� ����) 5. ���� ��忡�� ī�޶� �� ���� (����Ʈ���� �浹 Ȯ��) 6. OS ������Ʈ Ȯ�� 7. ���� �ʱ�ȭ (���� ����, ������ ��� �ʼ�).","(Tech Support Forum) ""Camera app showing black screen or crashing? First, restart the phone. Then try clearing the camera app's cache and data (Settings > Apps > Camera > Storage). Check if other apps using the camera work. Test in Safe Mode. If it still fails, it could be a hardware issue or might need a factory reset after backing up data."""
+IT076,���� �ذ�,SIM ī�带 ã�� �� ����' �Ǵ� 'SIM ī�� ����' ���� �޽����� ����.,1. ����� ��� �״ٰ� ���� 2. ��� ����� 3. SIM ī�� Ʈ���̸� ���� SIM ī�尡 �ùٸ��� �����Ǿ����� Ȯ�� �� ������ (�ݼ� ���˸� �ε巴�� �۱�) 4. �ٸ� �۵��ϴ� SIM ī�带 �־� �׽�Ʈ (SIM ī�� ��ü �ҷ� Ȯ��) 5. ���� SIM ī�带 �ٸ� ��⿡ �־� �׽�Ʈ (��� ���� Ȯ��) 6. ��Ʈ��ũ ���� �ʱ�ȭ 7. ��Ż翡 ���� (SIM ī�� Ȱ��ȭ/��ü �ʿ� ���ɼ�).,"(Mobile Network Provider FAQ) ""Seeing a 'No SIM card' error? 1. Toggle Airplane mode. 2. Restart your device. 3. Remove and reinsert the SIM card, ensuring it's seated correctly and the contacts are clean. 4. Try the SIM in another phone, or another working SIM in your phone to isolate the issue (SIM vs. phone). 5. Reset network settings. 6. Contact us if the problem persists, as the SIM might need replacement or reactivation."""
+IT077,���� �ذ�,����Ʈ���� ���� ���� �ڲ� ����õſ�.,"1. �ֱ� ��ġ�� �� Ȯ�� �� ���� (Ư�� �� �浹 ���ɼ�) 2. SD ī�� ��� �� ���� �� ���� Ȯ�� (SD ī�� ���� ���ɼ�) 3. ���͸� ���� ���� Ȯ�� (��ü�� �ƴ� ���) �Ǵ� ���͸� ����ȭ �ǽ� 4. ���� ���� ���� ���� Ȯ�� 5. OS ������Ʈ Ȯ�� �� ��ġ 6. ���� ��� ���� �� ���� Ȯ�� (�ý��� �� ��������, ��ġ�� �� �������� ����) 7. ���� �ʱ�ȭ (������ ��� �ʼ�).","(Android Help Center) ""Random reboots can be caused by problematic apps, faulty hardware (like battery or SD card), insufficient storage, or OS issues. Try uninstalling recently added apps, removing the SD card, checking for OS updates, and testing in Safe Mode. If frequent reboots continue, a factory reset (after backup) or hardware inspection might be necessary."""
+IT078,���� �ذ�,Ư�� ���� �����ϸ� �ٷ� '���� �����Ǿ����ϴ�' �޽����� �߸鼭 ����˴ϴ�.,"1. �� ���� ���� �� �ٽ� ���� 2. ��� ����� 3. ���� > ���ø����̼� > �ش� �� > ���� ���� > 'ij�� ����' �õ� 4. �� ������Ʈ Ȯ�� (�� ����) 5. �� ���� �� �缳ġ 6. OS ������ �� ȣȯ�� Ȯ�� (Ư�� OS ������Ʈ ���� �߻� ��) 7. '������ ����' �õ� (�� ���� �� ������ �ʱ�ȭ��, ������ ����) 8. �����ڿ��� ����.","(App Troubleshooting Guide) ""If an app crashes immediately upon opening: 1. Force stop the app and relaunch. 2. Restart your phone. 3. Clear the app's cache (Settings > Apps > [App Name] > Storage). 4. Check for app updates in the Play Store/App Store. 5. Uninstall and reinstall the app. 6. Ensure app compatibility with your current OS version. Clearing app data (use cautiously) might also help."""
+IT079,���� �ذ�,����Ʈ�� ���� �߿� ��Ⱑ �ʹ� �߰ſ�����. ������ �ǰ���? ��� �ؾ� �ϳ���?,"���� �� �ణ�� �߿��� ����������, ������ ����� ������ �̴߰ٸ� ���ǰ� �ʿ��մϴ�. 1. ���� �� ����� ����/�� ��� �ߴ� 2. ��dz�� �� �Ǵ� ������ ���� (�̺� �� �� ���ϱ�) 3. ��ǰ/���� ������ �� ���̺� ��� Ȯ�� 4. ����Ʈ�� ���̽� ��� ���� 5. ���� ���� ��� ��Ȱ��ȭ (���� ���� ��) 6. ��� ����� �� ����. ���������� ������ �߿� �� ���͸� �Ǵ� ���� ȸ�� ������ �� ������ ���� �ʿ�.","(Battery Safety Information) ""It's normal for your phone to get slightly warm while charging, especially during fast charging. However, if it becomes uncomfortably hot: Stop using demanding apps while charging, ensure good ventilation (avoid charging under pillows), use the original or certified charger/cable, remove the case, and consider disabling fast charging temporarily if the option exists. Persistent excessive heat could indicate an issue requiring service."""
+IT080,���� �ذ�,����Ʈ�� ȭ���� �̼��ϰ� �����ŷ���. ������ �����?,1. ȭ�� ��� ���� Ȯ�� (�ڵ� ��� ���� �Ǵ� Ư�� ��� ���� ����) 2. Ư�� �� ��� �ÿ��� �߻��ϴ��� Ȯ�� (�� ȣȯ�� ����) 3. ��� ����� 4. ������ �ɼ� Ȯ�� (�ϵ���� �������� ��� �� �� �� ���� ���� ���� �õ� - ���� �ʿ�) 5. ���� ��� ���� �� ���� Ȯ�� 6. OS ������Ʈ Ȯ�� 7. ȭ�� ��ü�� �ϵ���� ���� ���ɼ� (���ΰ��� �ٸ�). ���� �� ���� ���� ����.,"(Display Troubleshooting Tips) ""Screen flickering can be caused by software glitches, app incompatibility, or hardware issues. Check if it happens at specific brightness levels or only in certain apps. Try restarting the phone, disabling adaptive brightness temporarily, checking developer options (use caution), and testing in Safe Mode. If flickering persists across all apps and conditions, it might be a display hardware problem."""
+IT081,���� �ذ�,����Ʈ�� ����Ŀ �Ҹ��� �۰ų� �������ŷ���.,"1. ����Ŀ �׸�(����) �̹��� Ȯ�� �� �ε巯�� �ַ� û�� 2. ���� ���� Ȯ�� (�̵�� ����, ��ȭ ���� ��) 3. ���ر��� ��� �� ���Ұ� ���� ���� Ȯ�� 4. Ư�� �ۿ����� ���� �߻��ϴ��� Ȯ�� 5. �������� ����Ŀ/�̾��� ���� ���� Ȯ�� �� ���� �� �׽�Ʈ 6. ��� ����� 7. ���� ��忡�� �׽�Ʈ (����Ʈ���� ���� Ȯ��) 8. ����Ŀ ��ü�� �ϵ���� ���� ���ɼ�.","(Audio Problem Fixes) ""Low or distorted speaker sound? 1. Clean the speaker grille gently. 2. Double-check all volume settings (media, call, ringtone). 3. Ensure Do Not Disturb isn't silencing media. 4. Test sound in multiple apps. 5. Disconnect any Bluetooth audio devices. 6. Restart the phone. 7. Test in Safe Mode. If the issue remains, the speaker hardware might be faulty."""
+IT082,���� �ذ�,����Ʈ�� ���� ��ư�̳� ���� ��ư�� �����ϰų� ������ ������ �����.,1. ��ư �ֺ� �̹��� Ȯ�� �� û�� (���� ���� ��� ��) 2. ���̽��� ��ư�� ������ �ְų� �����ϴ��� Ȯ�� �� �����ϰ� �׽�Ʈ 3. ��� ����� (ȭ�� ��ġ�� ���� ��) 4. ������ �ջ�(���� ��) ���� Ȯ�� 5. ����Ʈ������ ��ư ��� Ȱ�� (���ټ� �޴� �� - �ӽù���) 6. �������� ���� �� ������ ��ư ��ǰ ���� ���ɼ� ���� ���� ���� �湮 �ʿ�.,"(Hardware Button Issues) ""If power or volume buttons are stuck or unresponsive: 1. Check for debris around the button and try cleaning gently (e.g., with compressed air). 2. Remove the case to ensure it's not interfering. 3. Restart the device if possible using on-screen options. 4. Consider physical damage history. 5. You might be able to use software alternatives temporarily (e.g., accessibility menus). Persistent issues likely require hardware repair."""
+IT083,���� �ذ�,���� ���� �е忡 ����Ʈ���� �÷����Ƶ� ������ ���۵��� �ʾƿ�.,"1. ����Ʈ�� ���� ���� ������ �����ϴ��� Ȯ�� 2. ���� �е� ���� ���� Ȯ�� 3. ����Ʈ���� ���� �е� ���� ��ġ Ȯ�� (��Ȯ�� ���� ��ġ�� ���߱�) 4. ����Ʈ�� ���̽� ���� �� �õ� (�β��� ���̽�, �ݼ� ������ �� ���� ����) 5. ����Ʈ�� �� ���� �е� �����(���� ��) 6. �ٸ� ���� ���� ���� ���� ���� �е� �׽�Ʈ 7. �ٸ� ���� ������� ����Ʈ�� �׽�Ʈ.","(Wireless Charging Not Working) ""Phone not charging wirelessly? 1. Confirm your phone supports Qi wireless charging. 2. Ensure the charging pad is powered on. 3. Adjust phone placement on the pad (coil alignment is key). 4. Remove thick cases or metal attachments. 5. Restart both phone and pad (if possible). 6. Test the pad with another compatible device, or your phone on another pad to isolate the problem."""
+IT084,���� �ذ�,"����Ʈ��ġ(������ ��ġ, ���� ��ġ ��)�� ����Ʈ�����κ��� �˸��� ���� ���ؿ�.",1. ����Ʈ���� ��ġ �������� ���� ���� Ȯ�� 2. ��ġ�� ����� ��� �Ǵ� ���ر��� ���� �����Ǿ� �ִ��� Ȯ�� 3. ����Ʈ�� ��(��ġ ���� ��)���� �˸� ���� Ȯ�� (�˸� ���� �� ���� ��) 4. ����Ʈ�� ��ü �˸� ���� Ȯ�� (�ش� �� �˸� ��� ����) 5. ����Ʈ���� ��ġ ��� ����� 6. ��ġ ���� �� ������Ʈ Ȯ�� 7. ��ġ �ʱ�ȭ �� �翬�� (���� ����).,"(Smartwatch Notification Sync) ""Not getting phone notifications on your watch? 1. Check Bluetooth connection between phone and watch. 2. Ensure the watch isn't in Airplane or Do Not Disturb mode. 3. Verify notification settings in the watch companion app on your phone (which apps are allowed). 4. Check phone's notification settings for those apps. 5. Restart both devices. 6. Update the watch app. 7. As a last resort, unpair and reset the watch, then re-pair."""
+IT085,���� �ذ�,���� ����(�Ǵ� iCloud) ����ó�� �� ����Ʈ������ ����ȭ���� �ʾƿ�.,1. �� ����Ʈ�� ���ͳ� ���� ���� Ȯ�� (Wi-Fi/����� ������) 2. ����Ʈ�� ���� > ���� �޴����� �ش� ����/iCloud ���� �α��� �� ����ȭ ���� Ȯ�� ('����ó' ����ȭ ���� �ִ���) 3. ���� ����ȭ �õ� (���� ���� �� '���� ����ȭ' ��ư) 4. ����ó �� ��ü ���� Ȯ�� (ǥ���� ���� ���� ��) 5. ��� ����� 6. ���� ���� �� �ٽ� �߰� 7. ��(contacts.google.com / icloud.com)���� ����ó ���������� ���̴��� Ȯ��.,"(Account Sync Issues) ""Contacts not syncing to new phone? 1. Ensure stable internet connection. 2. Go to Settings > Accounts > [Your Google/iCloud Account] and check if 'Contacts' sync is enabled. 3. Try initiating a manual sync ('Sync now'). 4. Check settings within the Contacts app itself (accounts to display). 5. Restart the phone. 6. Remove and re-add the account. 7. Verify contacts appear correctly on the web version (contacts.google.com or icloud.com)."""
+IT086,���� �ذ�,�ȵ���̵� ������ 'System UI�� �������� �ʽ��ϴ�' �Ǵ� 'System UI�� �����Ǿ����ϴ�' ������ ����.,"1. ��� ����� 2. �ֱ� ��ġ/������Ʈ�� �� Ȯ�� �� ���� (Ư�� ��ó, ���� �� �ý��� UI�� ���� �ִ� ��) 3. ���� > ���ø����̼� > �� ��� ���� '������' > '�ý��� �� ǥ��' > 'System UI' �� ���� > ���� ���� > 'ij�� ����' �õ� 4. Google �� �� Google Play ���� ������Ʈ Ȯ�� �� ij�� ���� 5. ���� ���� �����Ͽ� ���� Ȯ�� 6. ���� �ʱ�ȭ (������ ��� �ʼ�).","(Android Common Issues Forum) ""Getting 'System UI isn't responding'? This often relates to a conflicting app (like a third-party launcher or widget), outdated Google apps, or corrupted cache. Try restarting, uninstalling recent apps, clearing System UI cache (Settings > Apps > Show system apps > System UI > Storage > Clear cache), updating Google apps, and testing in Safe Mode. A factory reset is the last resort."""
+IT087,���� �ذ�,���� �÷��� ����(Google Play Services) ���� ���� �޽����� ��� ���Ϳ�.,1. ��� ����� 2. ���� > ���ø����̼� > (�ý��� �� ǥ��) > Google Play ���� > ���� ���� > 'ij�� ����' > '��� ������ �����' �õ� (���� ��α��� �ʿ��� �� ����) 3. Google Play ���� �� ������Ʈ Ȯ�� (�÷��� ����� �Ǵ� APK Mirror �� �ŷ��� �� �ִ� ��ó) 4. Google Play ����� �� ij�� �� ������ ���� 5. Google ���� ���� �� ���� 6. ��¥ �� �ð� ���� �ڵ� ����ȭ Ȯ��.,"(Google Support Page Snippet) ""Errors related to Google Play Services can often be resolved by: 1. Restarting the device. 2. Clearing the cache and data for Google Play Services (Settings > Apps > Google Play Services > Storage > Manage space > Clear All Data). 3. Ensuring Play Services and Play Store apps are up-to-date. 4. Removing and re-adding your Google account. 5. Checking that date and time are set automatically."""
+IT088,���� �ذ�,"���� �Է��Ϸ��� �ϴµ� Ű���尡 ��Ÿ���� �ʰų�, ��Ÿ���ٰ� �ٷ� �������.","1. ��� ����� 2. ���� ��� ���� Ű���� �� ���� ���� (���� > ���ø����̼� > �ش� Ű���� ��) 3. �ش� Ű���� �� ij�� ���� (���� ���� �޴�) 4. �ٸ� Ű���� ������ ���� �� �׽�Ʈ (��: Gboard, �Ｚ Ű���� ��) 5. �ش� Ű���� �� ������Ʈ Ȯ�� �Ǵ� �缳ġ 6. ���� ��忡�� �׽�Ʈ (Ÿ�� �� �浹 Ȯ��).","(Keyboard Troubleshooting Steps) ""Keyboard not appearing or disappearing? 1. Restart your phone. 2. Force stop the keyboard app you are using (via Settings > Apps). 3. Clear the cache for that keyboard app. 4. Try switching to a different keyboard app (like Gboard or the default manufacturer keyboard). 5. Update or reinstall the problematic keyboard app. 6. Test in Safe Mode to rule out conflicts."""
+IT089,���� �ذ�,"����� �ֽ��̿� �ٸ� ���� ����Ǵµ�, ���ͳ� ������ �Ҿ����ϰų� �ڲ� ����ϴ�.","1. �ֽ��� �� ����Ʈ�� ����� �� ����� ��� ����� 2. �ֽ��� ���� Ȯ�� (���� ���� ��� �� ����, ���� ��� ��) 3. ����Ʈ���� ����� ������ ��ȣ ���� Ȯ�� 4. �ֽ��� ���ļ� �뿪 ���� �õ� (2.4GHz <-> 5GHz) 5. �ֺ� ȯ���� ���� ���� Ȯ�� 6. ����Ʈ�� ��׶��� ������ ��� ���� ���� Ȯ�� 7. ����Ʈ�� OS ������Ʈ Ȯ��.","(Mobile Hotspot Guide) ""Unstable hotspot connection for connected devices? 1. Restart both the hotspot phone and the connected device. 2. Check hotspot settings (max connections, power saving options). 3. Ensure the hotspot phone has a strong mobile data signal. 4. Try switching the hotspot band (2.4GHz vs 5GHz). 5. Minimize potential interference. 6. Check for background data restrictions on the hotspot phone. 7. Keep the OS updated."""
+IT090,���� �ذ�,�������� �̾������� ���� ���� �� �Ҹ��� �ڲ� ����ų� �����ſ�.,"1. �̾����� ����Ʈ�� ����� �� ���� 2. �̾��� ���͸� �ܷ� Ȯ�� 3. ����Ʈ���� �̾��� �Ÿ� Ȯ�� (������ ����) 4. �ٸ� �������� ��� �Ǵ� Wi-Fi ��ȣ���� ���� �ּ�ȭ (�ֺ� ��� ����) 5. ����Ʈ�� ���̽� ���� �� �׽�Ʈ 6. ����Ʈ�� �� �̾��� �߿��� �ֽ� ������Ʈ 7. ������ �ɼǿ��� �������� �ڵ� ���� �õ� (SBC, AAC, aptX �� - ȣȯ�� Ȯ�� �ʿ�) 8. �ٸ� ����Ʈ���� �����Ͽ� �׽�Ʈ (���� ���� ��� �ľ�).","(Bluetooth Audio Stuttering Fixes) ""Bluetooth audio skipping? 1. Restart & re-pair devices. 2. Ensure earbuds are charged. 3. Keep phone and earbuds close. 4. Minimize interference (turn off other Bluetooth devices, move away from routers). 5. Remove phone case. 6. Update firmware for both phone and earbuds. 7. Try changing Bluetooth codecs in Developer Options (if applicable). 8. Test earbuds with another phone to isolate the issue."""
+IT091,���� �ذ�,"��ȭ�� �� ȭ���� ������ �ʰų�, ��ȭ ���� �Ŀ��� ȭ���� �ٷ� ������ �ʾƿ�. (���� ���� ����)",1. ȭ�� ��� ���� ���� �κ�(��ȭ�� ��ó) �̹��� Ȯ�� �� û�� 2. ȭ�� ��ȣ �ʸ�/��ȭ ������ ������ �����ų� �����ϴ��� Ȯ�� �� �����ϰ� �׽�Ʈ 3. ��� ����� 4. ���� ���� �׽�Ʈ ���(���� ��� �Ǵ� ������Ƽ ��) ��� 5. OS ������Ʈ Ȯ�� 6. ���� ��ü�� �ϵ���� ���� ���ɼ� (���� �� ���� ���� ����).,"(Proximity Sensor Issues) ""Screen not turning off during calls or staying off after? This is likely a proximity sensor issue. 1. Clean the sensor area near the earpiece. 2. Check if your screen protector is blocking the sensor; test without it. 3. Restart the phone. 4. Use a diagnostic tool/app to test the sensor. 5. Check for OS updates. If it persists, the sensor hardware might be faulty and require service."""
+IT092,���� �ذ�,����Ʈ�� ȭ�� �ڵ� ȸ��(����/���� ��ȯ) ����� �۵����� �ʾƿ�.,"1. ���� ���� �޴����� '�ڵ� ȸ��' ����� ���� �ִ��� Ȯ�� (���� �ִٸ� ���Ͽ� �ѱ�) 2. ��� ����� 3. Ư�� �ۿ����� ȸ���� �� �Ǵ��� Ȯ�� (�� ��ü���� ȸ�� ������ ���ɼ�) 4. ����(���ӵ���, ���̷ν�����) ���� (���� ��� �Ǵ� ���� �� ���) 5. ���� ��忡�� �׽�Ʈ (����Ʈ���� �浹 Ȯ��) 6. OS ������Ʈ Ȯ��. ���� �� ���� �ϵ���� ���� ���ɼ�.","(Auto-Rotate Not Working) ""Screen not auto-rotating? 1. Check the Quick Settings panel and ensure 'Auto-rotate' (or Portrait/Landscape lock) is enabled. 2. Restart your device. 3. Verify if rotation works in other apps (some apps don't support rotation). 4. Use a sensor testing app to check the accelerometer/gyroscope. 5. Test in Safe Mode. 6. Check for OS updates. Persistent issues might point to a sensor hardware failure."""
+IT093,���� �ذ�,���� �ν� ������ �� �۵����� �ʰų� �ʹ� ������.,1. ���� ǥ�� �� �հ��� û�� ���� Ȯ�� (�����ϰ� �����ϰ�) 2. ��ϵ� ���� ���� �� ���� (���� ������ ���� �� ��ĵ) 3. ȭ�� ��ȣ �ʸ�/��ȭ ������ ����(Ư�� ���÷��� ������)�� �����ϴ��� Ȯ�� (ȣȯ �ʸ� ���) 4. ��� ����� 5. OS �� ���� ��ü �ν� ����Ʈ���� ������Ʈ Ȯ�� 6. �������� ���� �ν� ���� ����ȭ �ɼ� Ȯ�� (�ִϸ��̼� ȿ�� ���� ��) 7. ���� ��� �׽�Ʈ.,"(Fingerprint Sensor Troubleshooting) ""Slow or unreliable fingerprint sensor? 1. Clean the sensor surface and your finger (ensure dry). 2. Delete registered fingerprints and re-register them carefully from multiple angles. 3. Ensure your screen protector is compatible (especially for under-display sensors). 4. Restart the phone. 5. Check for OS/biometric software updates. 6. Look for fingerprint optimization settings (e.g., disabling animations). 7. Test in Safe Mode."""
+IT094,���� �ذ�,���͸��� 20~30% ���Ҵٰ� ǥ�õǴµ� ���ڱ� ������ ����������.,1. ���͸� ����(Ķ���극�̼�) �õ�: ���� ���� -> ���� ����(�ڵ� ����) -> �ٽ� ���� ����. (��Ȯ�� ����� ������ ������ �� ����) 2. ���͸� ��� ��� Ȯ�� (Ư�� ���� �������� �Ҹ� �����ϴ���) 3. �߿� ȯ�� ���� ���� Ȯ�� (���¿��� ���͸� ���� ����) 4. OS ������Ʈ Ȯ�� (���͸� ���� ���� ���� ���ɼ�) 5. ���͸� ����ȭ ���ɼ� ���� (���� ���� ���͸�). ���� �� ���͸� ��ü ���� �ʿ�.,"(Phone Shutting Off Unexpectedly) ""Phone dying suddenly even with 20-30% battery left? 1. Try battery calibration (fully charge -> use until auto-off -> fully charge again). 2. Check battery usage stats for rogue apps. 3. Avoid extreme cold temperatures. 4. Check for OS updates. 5. This often indicates battery degradation (wear and tear). Consider battery replacement if the issue persists."""
+IT095,���� �ذ�,������ ���� '���� ���͸� ����(Wireless PowerShare)' ����� �۵����� �ʾƿ�.,1. ���� ���͸� ���� ��� Ȱ��ȭ Ȯ�� (���� ���� �޴� �Ǵ� ���� > ���͸�) 2. �����ϴ� ���� ���͸� �ܷ��� ���� ����(���� 30%) �̻����� Ȯ�� 3. ���� ���� ��Ⱑ Qi ���� ���� ǥ���� �����ϴ��� Ȯ�� 4. �� ��� �޸� �߾��� ��Ȯ�� �´�� �ִ��� Ȯ�� 5. �� ��� ��� ���̽� ���� �� �õ� 6. �����ϴ� ���� �����⿡ ����Ǿ� ���� ������ Ȯ�� (�Ϻ� �� ����) 7. ��� �����.,"(Wireless PowerShare Issues) ""Wireless PowerShare not working? 1. Ensure the feature is enabled (Quick Settings or Battery settings). 2. Check if the sharing phone's battery is above the minimum threshold (usually 30%). 3. Confirm the receiving device supports Qi wireless charging. 4. Align the backs of the devices carefully (center-to-center). 5. Remove cases from both devices. 6. Disconnect the sharing phone from any wired charger. 7. Restart the sharing phone."""
+IT096,���� �ذ�,"��ǻ�Ϳ��� ����Ʈ������ ����/������ ������ �����ߴµ�, ������ �ۿ��� ���� ���̰ų� ������ �ʾƿ�.","1. ���� ���� �� ���� �Ҿ��� ���ɼ�: ���̺� ���� ���� Ȯ�� �� �ٸ� ���̺�/��Ʈ ���, ������ �õ� 2. ����Ʈ�� ���� ���� ���� ���� Ȯ�� 3. ���� ���� ȣȯ�� Ȯ�� (����Ʈ������ �����ϴ� �ڵ�/��������) 4. ���� ���� ��ü �ջ� ���� Ȯ�� (��ǻ�Ϳ��� ���� ����Ǵ���) 5. ����Ʈ�� �̵�� ��ij�� ����� (��� ����� �Ǵ� ���� �� ���) 6. ���� Ž���� ������ ���� ���� ���� �� ���� �õ�.","(File Corruption After Transfer) ""Files appear corrupted or won't open after copying from PC? 1. Ensure a stable connection during transfer; try a different cable/port and re-transfer. 2. Check for sufficient storage space on the phone. 3. Verify file format compatibility (supported codecs). 4. Confirm the original file isn't corrupted (check on PC). 5. Trigger media rescan (restarting phone usually does this). 6. Try opening the file directly using a file manager app."""
+IT097,���� �ذ�,����Ʈ������ '�� ��� ã��(Find My Device / Find My Mobile)'�� ��ġ ��ȸ�� �� �ſ�.,1. �ش� ��� Ȱ��ȭ ���� Ȯ�� (���� > ����/���� > �� ��� ã��) 2. ����Ʈ�� ���� ���� �ְ� ���ͳ�(����� ������ �Ǵ� Wi-Fi)�� ����Ǿ� �ִ��� Ȯ�� 3. ��ġ(GPS) ���� ���� �ִ��� Ȯ�� 4. �ش� ����/�Ｚ ���� �α��� ���� Ȯ�� 5. ��׶��� ������ ���� ���� Ȯ�� (�� ��� ã�� ���� ����) 6. ��� �����.,"(Find My Device Not Working) ""Unable to locate phone using Find My Device/Mobile? 1. Ensure the feature is enabled in settings (Security/Account > Find My Device). 2. The phone must be powered on and connected to the internet (mobile data or Wi-Fi). 3. Location/GPS services must be turned on. 4. Verify you're signed into the correct Google/Samsung account. 5. Check for background data restrictions for related services. 6. Restart the phone."""
+IT098,���� �ذ�,S��(�Ǵ� ���� �潽)�� �º���/���� ������� �ʰų� �ʱ� �ν��� ����Ȯ�ؿ�.,1. S��/�����潽 ���� ���� Ȯ�� �� ���� (��� ���� �Ǵ� ���� ����) 2. �������� ���� Ȯ�� �� �翬�� (S�� ���� �׼� �� ��� ��� ��) 3. ���� ����/�ջ� ���� Ȯ�� �� ��ü 4. ȭ�� ��ȣ �ʸ�/��ȭ ������ �����ϴ��� Ȯ�� (Ư�� �β��� �ʸ�) 5. ��� ����� 6. S��/�����潽 ���� �ʱ�ȭ (����Ʈ���� ���� �޴�) 7. �ٸ� ȣȯ �ۿ��� �׽�Ʈ.,"(Stylus Connection/Accuracy Problems) ""S Pen/Apple Pencil not connecting or writing inaccurately? 1. Ensure the stylus is charged (attach to device or charge separately). 2. Check Bluetooth settings and try re-pairing (needed for air actions/features). 3. Inspect the nib/tip for wear or damage and replace if needed. 4. Check if the screen protector is interfering (especially thick ones). 5. Restart the host device. 6. Reset stylus settings if available. 7. Test in different compatible apps."""
+IT099,���� �ذ�,"����Ʈ���� USB-C ���̺��� ����Ϳ� �����ߴµ� ȭ���� ������ �ʾƿ�. (DeX, �̷��� ��)",1. ����Ʈ�� ���� USB-C ���� ���� ���(DisplayPort Alt Mode �Ǵ� �ش� ���(DeX ��)) �����ϴ��� Ȯ�� 2. ����ϴ� USB-C ���̺��� ���� ���(DP Alt Mode) �����ϴ��� Ȯ�� (���� ���� ���̺� �Ұ�) 3. ����� �Է� �ҽ� ���� Ȯ�� (����� HDMI/DP ��Ʈ ����) 4. �ٸ� ����� �Ǵ� �ٸ� ���̺��� �׽�Ʈ 5. ����Ʈ�� �� ����� ����� 6. ����Ʈ�� ���� Ȯ�� (DeX/ȭ�� �̷��� ���� ����).,"(USB-C to Monitor No Signal) ""No display when connecting phone to monitor via USB-C? 1. Verify your phone model supports video output over USB-C (DisplayPort Alt Mode, DeX, etc.). 2. Ensure you're using a USB-C cable that supports video output (not just charging). 3. Check the monitor's input source setting (select the correct HDMI/DP port). 4. Test with a different monitor or cable. 5. Restart both the phone and monitor. 6. Check relevant phone settings (DeX, Screen Mirroring)."""
+IT100,���� �ذ�,��Ʃ�� �ۿ��� �������� ���µ� ȭ���� �������� �ڲ� ���۸��� �ɸ��ų� ���ܿ�. ���ͳ� �ӵ��� �����.,1. ��Ʃ�� �� ij�� ���� (���� > ���ø����̼� > YouTube > ���� ����) 2. ��Ʃ�� �� ������Ʈ Ȯ�� �Ǵ� �缳ġ 3. ��� ����� 4. �����(������) ����� 5. �ٸ� ��⿡���� ���� ���� Ȯ�� (��Ʈ��ũ ���� ����) 6. DNS ���� ���� �õ� (��: Google DNS 8.8.8.8) 7. ��׶��忡�� ������ ���� ����ϴ� �� Ȯ�� �� ���� 8. �ð��� ���� �� �õ� (��Ʈ��ũ ȥ�� �ð���).,"(YouTube Buffering Despite Fast Internet) ""YouTube videos keep buffering/stuttering even with good internet speed? 1. Clear YouTube app cache. 2. Update or reinstall the YouTube app. 3. Restart your device. 4. Restart your router. 5. Check if other devices on the network have the same issue. 6. Try changing DNS settings (e.g., to Google DNS). 7. Close background apps consuming bandwidth. 8. Test during different times of day (off-peak hours)."""
+��ó,,,,
+https://blog.nus.edu.sg/esim/for-travel/the-best-esim-card-for-sweden-travel-in-2024.html,,,,
+https://www.windowtonews.com/news.php?id=558541&cat_id=15,,,,

huggingface-space.yml

@@ -0,0 +1,9 @@
+title: RAG 검색 챗봇 with 음성인식
+emoji: 🤖
+colorFrom: indigo
+colorTo: blue
+sdk: gradio
+sdk_version: 3.44.4
+app_file: app.py
+pinned: false
+license: mit

requirements.txt

@@ -0,0 +1,12 @@
+flask>=2.0.1
+python-dotenv>=1.0.0
+requests>=2.25.1
+numpy>=1.20.0
+scikit-learn>=1.0.2
+gunicorn>=20.1.0
+werkzeug>=2.0.1
+nltk>=3.6.5
+sentence-transformers>=2.2.2
+gradio>=3.50.0,<4.0.0
+openai>=1.0.0
+flask-cors>=3.0.10

retrieval/__init__.py

@@ -0,0 +1 @@
+# 검색 모듈 패키지

retrieval/base_retriever.py

@@ -0,0 +1,48 @@
+"""
+기본 검색기 인터페이스
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Union, Tuple
+
+class BaseRetriever(ABC):
+    """검색 인터페이스를 정의하는 추상 기본 클래스"""
+    
+    @abstractmethod
+    def search(self, query: str, top_k: int = 5, **kwargs) -> List[Dict[str, Any]]:
+        """
+        주어진 쿼리에 대해 검색을 수행하고 결과를 반환합니다.
+        
+        Args:
+            query: 검색 쿼리
+            top_k: 반환할 상위 결과 수
+            **kwargs: 추가 검색 매개변수
+            
+        Returns:
+            검색 결과 목록 (각 결과는 딕셔너리 형태)
+        """
+        pass
+    
+    @abstractmethod
+    def add_documents(self, documents: List[Dict[str, Any]]) -> None:
+        """
+        검색기에 문서를 추가합니다.
+        
+        Args:
+            documents: 추가할 문서 목록 (각 문서는 딕셔너리 형태)
+        """
+        pass
+    
+    def get_relevant_documents(self, query: str, top_k: int = 5, **kwargs) -> List[Dict[str, Any]]:
+        """
+        search 메서드의 별칭
+        
+        Args:
+            query: 검색 쿼리
+            top_k: 반환할 상위 결과 수
+            **kwargs: 추가 검색 매개변수
+            
+        Returns:
+            검색 결과 목록
+        """
+        return self.search(query, top_k, **kwargs)

retrieval/reranker.py

@@ -0,0 +1,127 @@
+"""
+재순위화 검색 구현 모듈
+"""
+
+import logging
+from typing import List, Dict, Any, Optional, Union, Callable
+from .base_retriever import BaseRetriever
+
+logger = logging.getLogger(__name__)
+
+class ReRanker(BaseRetriever):
+    """
+    검색 결과 재순위화 검색기
+    """
+    
+    def __init__(
+        self, 
+        base_retriever: BaseRetriever,
+        rerank_model: Optional[Union[str, Any]] = None,
+        rerank_fn: Optional[Callable] = None,
+        rerank_field: str = "text",
+        rerank_batch_size: int = 32
+    ):
+        """
+        ReRanker 초기화
+        
+        Args:
+            base_retriever: 기본 검색기 인스턴스
+            rerank_model: 재순위화 모델 (Cross-Encoder) 이름 또는 인스턴스
+            rerank_fn: 사용자 정의 재순위화 함수 (제공된 경우 rerank_model 대신 사용)
+            rerank_field: 재순위화에 사용할 문서 필드
+            rerank_batch_size: 재순위화 모델 배치 크기
+        """
+        self.base_retriever = base_retriever
+        self.rerank_field = rerank_field
+        self.rerank_batch_size = rerank_batch_size
+        self.rerank_fn = rerank_fn
+        
+        # 재순위화 모델 로드 (사용자 정의 함수가 제공되지 않은 경우)
+        if rerank_fn is None and rerank_model is not None:
+            try:
+                from sentence_transformers import CrossEncoder
+                if isinstance(rerank_model, str):
+                    logger.info(f"재순위화 모델 '{rerank_model}' 로드 중...")
+                    self.rerank_model = CrossEncoder(rerank_model)
+                else:
+                    self.rerank_model = rerank_model
+            except ImportError:
+                logger.warning("sentence-transformers 패키지가 설치되지 않았습니다. pip install sentence-transformers 명령으로 설치하세요.")
+                raise
+        else:
+            self.rerank_model = None
+    
+    def add_documents(self, documents: List[Dict[str, Any]]) -> None:
+        """
+        기본 검색기에 문서 추가
+        
+        Args:
+            documents: 추가할 문서 목록
+        """
+        self.base_retriever.add_documents(documents)
+    
+    def search(self, query: str, top_k: int = 5, first_stage_k: int = 30, **kwargs) -> List[Dict[str, Any]]:
+        """
+        2단계 검색 수행: 기본 검색 + 재순위화
+        
+        Args:
+            query: 검색 쿼리
+            top_k: 최종적으로 반환할 상위 결과 수
+            first_stage_k: 첫 번째 단계에서 검색할 결과 수
+            **kwargs: 추가 검색 매개변수
+        
+        Returns:
+            재순위화된 검색 결과 목록
+        """
+        # 첫 번째 단계: 기본 검색기로 more_k 문서 검색
+        logger.info(f"기본 검색기로 {first_stage_k}개 문서 검색 중...")
+        initial_results = self.base_retriever.search(query, top_k=first_stage_k, **kwargs)
+        
+        if not initial_results:
+            logger.warning("첫 번째 단계 검색 결과가 없습니다.")
+            return []
+        
+        if len(initial_results) < first_stage_k:
+            logger.info(f"요청한 {first_stage_k}개보다 적은 {len(initial_results)}개 결과를 검색했습니다.")
+        
+        # 사용자 정의 재순위화 함수가 제공된 경우
+        if self.rerank_fn is not None:
+            logger.info("사용자 정의 함수로 재순위화 중...")
+            reranked_results = self.rerank_fn(query, initial_results)
+            return reranked_results[:top_k]
+        
+        # 재순위화 모델이 로드된 경우
+        elif self.rerank_model is not None:
+            logger.info(f"CrossEncoder 모델로 재순위화 중...")
+            
+            # 텍스트 쌍 생성
+            text_pairs = []
+            for doc in initial_results:
+                if self.rerank_field not in doc:
+                    logger.warning(f"문서에 필드 '{self.rerank_field}'가 없습니다.")
+                    continue
+                text_pairs.append([query, doc[self.rerank_field]])
+            
+            # 모델로 점수 계산
+            scores = self.rerank_model.predict(
+                text_pairs, 
+                batch_size=self.rerank_batch_size,
+                show_progress_bar=True if len(text_pairs) > 10 else False
+            )
+            
+            # 결과 재정렬
+            for idx, doc in enumerate(initial_results[:len(scores)]):
+                doc["rerank_score"] = float(scores[idx])
+            
+            reranked_results = sorted(
+                initial_results[:len(scores)], 
+                key=lambda x: x.get("rerank_score", 0), 
+                reverse=True
+            )
+            
+            return reranked_results[:top_k]
+        
+        # 재순위화 없이 초기 결과 반환
+        else:
+            logger.info("재순위화 모델/함수가 없어 초기 검색 결과를 그대로 반환합니다.")
+            return initial_results[:top_k]

retrieval/vector_retriever.py

@@ -0,0 +1,202 @@
+"""
+벡터 검색 구현 모듈
+"""
+
+import os
+import numpy as np
+from typing import List, Dict, Any, Optional, Union, Tuple
+import logging
+from sentence_transformers import SentenceTransformer
+from .base_retriever import BaseRetriever
+
+logger = logging.getLogger(__name__)
+
+class VectorRetriever(BaseRetriever):
+    """
+    임베딩 기반 벡터 검색 구현
+    """
+    
+    def __init__(
+        self, 
+        embedding_model: Optional[Union[str, SentenceTransformer]] = "paraphrase-multilingual-MiniLM-L12-v2",
+        documents: Optional[List[Dict[str, Any]]] = None,
+        embedding_field: str = "text",
+        embedding_device: str = "cpu"
+    ):
+        """
+        VectorRetriever 초기화
+        
+        Args:
+            embedding_model: 임베딩 모델 이름 또는 SentenceTransformer 인스턴스
+            documents: 초기 문서 목록 (선택 사항)
+            embedding_field: 임베딩할 문서 필드 이름
+            embedding_device: 임베딩 모델 실행 장치 ('cpu' 또는 'cuda')
+        """
+        self.embedding_field = embedding_field
+        self.model_name = None
+        
+        # 임베딩 모델 로드
+        if isinstance(embedding_model, str):
+            logger.info(f"임베딩 모델 '{embedding_model}' 로드 중...")
+            self.model_name = embedding_model
+            self.embedding_model = SentenceTransformer(embedding_model, device=embedding_device)
+        else:
+            self.embedding_model = embedding_model
+            # 모델이 이미 로드된 인스턴스일 경우 이름 추출
+            if hasattr(embedding_model, '_modules') and 'modules' in embedding_model._modules:
+                self.model_name = "loaded_sentence_transformer"
+        
+        # 문서 저장소 초기화
+        self.documents = []
+        self.document_embeddings = None
+        
+        # 초기 문서가 제공된 경우 추가
+        if documents:
+            self.add_documents(documents)
+    
+    def add_documents(self, documents: List[Dict[str, Any]]) -> None:
+        """
+        검색기에 문서를 추가하고 임베딩 생성
+        
+        Args:
+            documents: 추가할 문서 목록
+        """
+        if not documents:
+            logger.warning("추가할 문서가 없습니다.")
+            return
+        
+        # 문서 추가
+        document_texts = []
+        for doc in documents:
+            if self.embedding_field not in doc:
+                logger.warning(f"문서에 필드 '{self.embedding_field}'가 없습니다. 건너뜁니다.")
+                continue
+            
+            self.documents.append(doc)
+            document_texts.append(doc[self.embedding_field])
+        
+        if not document_texts:
+            logger.warning(f"임베딩할 텍스트가 없습니다. 모든 문서에 '{self.embedding_field}' 필드가 있는지 확인하세요.")
+            return
+        
+        # 문서 임베딩 생성
+        logger.info(f"{len(document_texts)}개 문서의 임베딩 생성 중...")
+        new_embeddings = self.embedding_model.encode(document_texts, show_progress_bar=True)
+        
+        # 기존 임베딩과 병합
+        if self.document_embeddings is None:
+            self.document_embeddings = new_embeddings
+        else:
+            self.document_embeddings = np.vstack([self.document_embeddings, new_embeddings])
+        
+        logger.info(f"총 {len(self.documents)}개 문서, {self.document_embeddings.shape[0]}개 임베딩 저장됨")
+    
+    def search(self, query: str, top_k: int = 5, **kwargs) -> List[Dict[str, Any]]:
+        """
+        쿼리에 대한 벡터 검색 수행
+        
+        Args:
+            query: 검색 쿼리
+            top_k: 반환할 상위 결과 수
+            **kwargs: 추가 검색 매개변수
+        
+        Returns:
+            관련성 점수와 함께 검색된 문서 목록
+        """
+        if not self.documents or self.document_embeddings is None:
+            logger.warning("검색할 문서가 없습니다.")
+            return []
+        
+        # 쿼리 임베딩 생성
+        query_embedding = self.embedding_model.encode(query)
+        
+        # 코사인 유사도 계산
+        scores = np.dot(self.document_embeddings, query_embedding) / (
+            np.linalg.norm(self.document_embeddings, axis=1) * np.linalg.norm(query_embedding)
+        )
+        
+        # 상위 결과 선택
+        top_indices = np.argsort(scores)[-top_k:][::-1]
+        
+        # 결과 형식화
+        results = []
+        for idx in top_indices:
+            doc = self.documents[idx].copy()
+            doc["score"] = float(scores[idx])
+            results.append(doc)
+        
+        return results
+    
+    def save(self, directory: str) -> None:
+        """
+        검색기 상태를 디스크에 저장
+        
+        Args:
+            directory: 저장할 디렉토리 경로
+        """
+        import pickle
+        import json
+        
+        os.makedirs(directory, exist_ok=True)
+        
+        # 문서 저장
+        with open(os.path.join(directory, "documents.json"), "w", encoding="utf-8") as f:
+            json.dump(self.documents, f, ensure_ascii=False, indent=2)
+        
+        # 임베딩 저장
+        if self.document_embeddings is not None:
+            np.save(os.path.join(directory, "embeddings.npy"), self.document_embeddings)
+        
+        # 모델 정보 저장
+        model_info = {
+            "model_name": self.model_name or "paraphrase-multilingual-MiniLM-L12-v2",  # 기본값 설정
+            "embedding_dim": self.embedding_model.get_sentence_embedding_dimension() if hasattr(self.embedding_model, 'get_sentence_embedding_dimension') else 384 
+        }
+        
+        with open(os.path.join(directory, "model_info.json"), "w") as f:
+            json.dump(model_info, f)
+        
+        logger.info(f"검색기 상태를 '{directory}'에 저장했습니다.")
+    
+    @classmethod
+    def load(cls, directory: str, embedding_model: Optional[Union[str, SentenceTransformer]] = None) -> "VectorRetriever":
+        """
+        디스크에서 검색기 상태를 로드
+        
+        Args:
+            directory: 로드할 디렉토리 경로
+            embedding_model: 사용할 임베딩 모델 (제공되지 않으면 저장된 정보 사용)
+        
+        Returns:
+            로드된 VectorRetriever 인스턴스
+        """
+        import json
+        
+        # 모델 정보 로드
+        with open(os.path.join(directory, "model_info.json"), "r") as f:
+            model_info = json.load(f)
+        
+        # 임베딩 모델 인스턴스화
+        if embedding_model is None:
+            # 모델 이름을 사용하여 모델 인스턴스화
+            if "model_name" in model_info and isinstance(model_info["model_name"], str):
+                embedding_model = model_info["model_name"]
+            else:
+                # 안전장치: 모델 이름이 없거나 정수인 경우(이전 버전 호환성) 기본 모델 사용
+                logger.warning("유효한 모델 이름을 찾을 수 없습니다. 기본 모델을 사용합니다.")
+                embedding_model = "paraphrase-multilingual-MiniLM-L12-v2"
+        
+        # 검색기 인스턴스 생성 (문서 없이)
+        retriever = cls(embedding_model=embedding_model)
+        
+        # 문서 로드
+        with open(os.path.join(directory, "documents.json"), "r", encoding="utf-8") as f:
+            retriever.documents = json.load(f)
+        
+        # 임베딩 로드
+        embeddings_path = os.path.join(directory, "embeddings.npy")
+        if os.path.exists(embeddings_path):
+            retriever.document_embeddings = np.load(embeddings_path)
+        
+        logger.info(f"검색기 상태를 '{directory}'에서 로드했습니다.")
+        return retriever

run.py

@@ -0,0 +1,24 @@
+"""
+개발 환경에서 빠르게 실행할 수 있는 스크립트
+"""
+import os
+import logging
+import webbrowser
+from app.app import app
+
+# 로거 설정
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 5000))
+    logger.info(f"서버를 http://localhost:{port}에서 시작합니다...")
+    
+    # 브라우저 자동 실행 (선택 사항)
+    webbrowser.open_new(f"http://localhost:{port}")
+    
+    # 플라스크 서버 실행
+    app.run(debug=True, host="0.0.0.0", port=port)

runtime.txt

@@ -0,0 +1 @@
+python-3.10.12

utils/__init__.py

@@ -0,0 +1 @@
+# 유틸리티 모듈 패키지

utils/deepseek_client.py

@@ -0,0 +1,263 @@
+"""
+DeepSeek API 클라이언트 모듈
+"""
+
+import os
+import json
+import logging
+import traceback
+from typing import List, Dict, Any, Optional, Union
+from dotenv import load_dotenv
+import requests
+
+# 환경 변수 로드
+load_dotenv()
+
+# 로거 설정
+logger = logging.getLogger("DeepSeekLLM")
+if not logger.hasHandlers():
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+class DeepSeekLLM:
+    """DeepSeek API 래퍼 클래스"""
+    
+    def __init__(self):
+        """DeepSeek LLM 클래스 초기화"""
+        self.api_key = os.getenv("DEEPSEEK_API_KEY")
+        self.api_base = os.getenv("DEEPSEEK_API_BASE", "https://api.deepseek.com")
+        self.model = os.getenv("DEEPSEEK_MODEL", "deepseek-chat")
+        
+        if not self.api_key:
+            logger.warning("DeepSeek API 키가 .env 파일에 설정되지 않았습니다.")
+            logger.warning("DEEPSEEK_API_KEY를 확인하세요.")
+        else:
+            logger.info("DeepSeek API 키 로드 완료.")
+    
+    def chat_completion(
+        self, 
+        messages: List[Dict[str, str]], 
+        temperature: float = 0.7, 
+        max_tokens: int = 1000,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        DeepSeek 채팅 완성 API 호출
+        
+        Args:
+            messages: 채팅 메시지 목록
+            temperature: 생성 온도 (낮을수록 결정적)
+            max_tokens: 생성할 최대 토큰 수
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            API 응답 (딕셔너리)
+        """
+        if not self.api_key:
+            logger.error("API 키가 설정되지 않아 DeepSeek API를 호출할 수 없습니다.")
+            raise ValueError("DeepSeek API 키가 설정되지 않았습니다.")
+        
+        try:
+            logger.info(f"DeepSeek API 요청 전송 중 (모델: {self.model})")
+            
+            # API 요청 헤더 및 데이터 준비
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            data = {
+                "model": self.model,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            # 추가 매개변수 병합
+            for key, value in kwargs.items():
+                if key not in data:
+                    data[key] = value
+            
+            # API 요청 보내기
+            endpoint = f"{self.api_base}/v1/chat/completions"
+            
+            # 디버깅: API 요청 데이터 로깅 (민감 정보 제외)
+            debug_data = data.copy()
+            debug_data["messages"] = f"[{len(data['messages'])}개 메시지]"
+            logger.debug(f"DeepSeek API 요청 데이터: {json.dumps(debug_data)}")
+            
+            response = requests.post(
+                endpoint,
+                headers=headers,
+                json=data,
+                timeout=30  # 30초 타임아웃 설정
+            )
+            
+            # 응답 상태 코드 확인
+            if not response.ok:
+                logger.error(f"DeepSeek API 오류: 상태 코드 {response.status_code}")
+                logger.error(f"응답 내용: {response.text}")
+                return {"error": f"API 오류: 상태 코드 {response.status_code}", "detail": response.text}
+            
+            # 응답 파싱
+            try:
+                result = response.json()
+                logger.debug(f"API 응답 구조: {list(result.keys())}")
+                return result
+            except json.JSONDecodeError as e:
+                logger.error(f"DeepSeek API JSON 파싱 실패: {e}")
+                logger.error(f"원본 응답: {response.text[:500]}...")
+                return {"error": "API 응답을 파싱할 수 없습니다", "detail": str(e)}
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"DeepSeek API 요청 실패: {e}")
+            return {"error": f"API 요청 실패: {str(e)}"}
+        except Exception as e:
+            logger.error(f"DeepSeek API 호출 중 예상치 못한 오류: {e}")
+            logger.error(traceback.format_exc())
+            return {"error": f"예상치 못한 오류: {str(e)}"}
+    
+    def generate(
+        self, 
+        prompt: str, 
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 1000,
+        **kwargs
+    ) -> str:
+        """
+        간단한 텍스트 생성 인터페이스
+        
+        Args:
+            prompt: 사용자 프롬프트
+            system_prompt: 시스템 프롬프트 (선택 사항)
+            temperature: 생성 온도
+            max_tokens: 생성할 최대 토큰 수
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            생성된 텍스트
+        """
+        messages = []
+        
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        messages.append({"role": "user", "content": prompt})
+        
+        try:
+            response = self.chat_completion(
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+            
+            # 오류 응답 확인
+            if "error" in response:
+                logger.error(f"텍스트 생성 중 API 오류: {response['error']}")
+                error_detail = response.get("detail", "")
+                return f"API 오류: {response['error']} {error_detail}"
+            
+            # 응답 형식 검증
+            if 'choices' not in response or not response['choices']:
+                logger.error(f"API 응답에 'choices' 필드가 없습니다: {response}")
+                return "응답 형식 오류: 생성된 텍스트를 찾을 수 없습니다."
+            
+            # 메시지 컨텐츠 확인
+            choice = response['choices'][0]
+            if 'message' not in choice or 'content' not in choice['message']:
+                logger.error(f"API 응답에 예상 필드가 없습니다: {choice}")
+                return "응답 형식 오류: 메시지 내용을 찾을 수 없습니다."
+            
+            generated_text = choice['message']['content'].strip()
+            logger.info(f"텍스트 생성 완료 (길이: {len(generated_text)})")
+            return generated_text
+            
+        except Exception as e:
+            logger.error(f"텍스트 생성 중 예외 발생: {e}")
+            logger.error(traceback.format_exc())
+            return f"오류 발생: {str(e)}"
+    
+    def rag_generate(
+        self, 
+        query: str, 
+        context: List[str],
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.3,
+        max_tokens: int = 1000,
+        **kwargs
+    ) -> str:
+        """
+        RAG 검색 결과를 활용한 텍스트 생성
+        
+        Args:
+            query: 사용자 질의
+            context: 검색된 문맥 목록
+            system_prompt: 시스템 프롬프트 (선택 사항)
+            temperature: 생성 온도
+            max_tokens: 생성할 최대 토큰 수
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            생성된 텍스트
+        """
+        if not system_prompt:
+            system_prompt = """당신은 검색 결과를 기반으로 질문에 답변하는 도우미입니다.
+- 검색 결과는 <context> 태그 안에 제공됩니다.
+- 검색 결과에 답변이 있으면 해당 정보를 사용하여 명확하게 답변하세요.
+- 검색 결과에 답변이 없으면 "검색 결과에 관련 정보가 없습니다"라고 말하세요.
+- 검색 내용을 그대로 복사하지 말고, 자연스러운 한국어로 답변을 작성하세요.
+- 답변은 간결하고 정확하게 제공하세요."""
+        
+        try:
+            # 중요: 컨텍스트 길이 제한
+            max_context = 10
+            if len(context) > max_context:
+                logger.warning(f"컨텍스트가 너무 길어 처음 {max_context}개만 사용합니다.")
+                context = context[:max_context]
+            
+            # 각 컨텍스트 액세스
+            limited_context = []
+            for i, doc in enumerate(context):
+                # 각 문서를 1000자로 제한
+                if len(doc) > 1000:
+                    logger.warning(f"문서 {i+1}의 길이가 제한되었습니다 ({len(doc)} -> 1000)")
+                    doc = doc[:1000] + "...(생략)"
+                limited_context.append(doc)
+            
+            context_text = "\n\n".join([f"문서 {i+1}: {doc}" for i, doc in enumerate(limited_context)])
+            
+            prompt = f"""질문: {query}
+
+<context>
+{context_text}
+</context>
+
+위 검색 결과를 참고하여 질문에 답변해 주세요."""
+            
+            logger.info(f"RAG 프롬프트 생성 완료 (길이: {len(prompt)})")
+            
+            result = self.generate(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+            
+            # 결과가 오류 메시지인지 확인
+            if result.startswith("오류") or result.startswith("API 오류") or result.startswith("응답 형식 오류"):
+                logger.error(f"RAG 생성 결과가 오류를 포함합니다: {result}")
+                # 좀 더 사용자 친화적인 오류 메시지 반환
+                return "죄송합니다. 현재 응답을 생성하는데 문제가 발생했습니다. 잠시 후 다시 시도해주세요."
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"RAG 텍스트 생성 중 예외 발생: {str(e)}")
+            logger.error(traceback.format_exc())
+            return "죄송합니다. 응답 생성 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요."

utils/document_processor.py

@@ -0,0 +1,396 @@
+"""
+문서 처리 유틸리티 모듈
+"""
+
+import os
+import re
+import csv
+import io
+import logging
+from typing import List, Dict, Any, Optional, Tuple, Union
+import numpy as np
+
+logger = logging.getLogger("DocProcessor")
+if not logger.hasHandlers():
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+class DocumentProcessor:
+    """문서 처리 유틸리티 클래스"""
+    
+    @staticmethod
+    def split_text(
+        text: str, 
+        chunk_size: int = 512,
+        chunk_overlap: int = 50,
+        separator: str = "\n"
+    ) -> List[str]:
+        """
+        텍스트를 더 작은 청크로 분할
+        
+        Args:
+            text: 분할할 텍스트
+            chunk_size: 각 청크의 최대 문자 수
+            chunk_overlap: 청크 간 중첩되는 문자 수
+            separator: 분할 시 사용할 구분자
+        
+        Returns:
+            분할된 텍스트 청크 목록
+        """
+        if not text or chunk_size <= 0:
+            return []
+        
+        # 구분자로 분할
+        parts = text.split(separator)
+        chunks = []
+        current_chunk = []
+        current_size = 0
+        
+        for part in parts:
+            part_size = len(part)
+            
+            if current_size + part_size + len(current_chunk) > chunk_size and current_chunk:
+                # 현재 청크가 최대 크기를 초과하면 저장
+                chunks.append(separator.join(current_chunk))
+                
+                # 중첩을 위해 일부 청크 유지
+                overlap_tokens = []
+                overlap_size = 0
+                for token in reversed(current_chunk):
+                    if overlap_size + len(token) <= chunk_overlap:
+                        overlap_tokens.insert(0, token)
+                        overlap_size += len(token) + 1  # separator 길이 포함
+                    else:
+                        break
+                
+                current_chunk = overlap_tokens
+                current_size = overlap_size - len(current_chunk)  # separator 길이 제외
+            
+            current_chunk.append(part)
+            current_size += part_size
+        
+        # 마지막 청크 추가
+        if current_chunk:
+            chunks.append(separator.join(current_chunk))
+        
+        return chunks
+    
+    @staticmethod
+    def clean_text(text: str, remove_urls: bool = True, remove_extra_whitespace: bool = True) -> str:
+        """
+        텍스트 정제
+        
+        Args:
+            text: 정제할 텍스트
+            remove_urls: URL 제거 여부
+            remove_extra_whitespace: 여분의 공백 제거 여부
+        
+        Returns:
+            정제된 텍스트
+        """
+        if not text:
+            return ""
+        
+        # URL 제거
+        if remove_urls:
+            text = re.sub(r'https?://\S+|www\.\S+', '', text)
+        
+        # 특수 문자 및 HTML 태그 정제
+        text = re.sub(r'<.*?>', '', text)  # HTML 태그 제거
+        
+        # 여분의 공백 제거
+        if remove_extra_whitespace:
+            text = re.sub(r'\s+', ' ', text).strip()
+        
+        return text
+    
+    @staticmethod
+    def text_to_documents(
+        text: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        chunk_size: int = 512,
+        chunk_overlap: int = 50
+    ) -> List[Dict[str, Any]]:
+        """
+        텍스트를 문서 객체 목록으로 변환
+        
+        Args:
+            text: 변환할 텍스트
+            metadata: 문서에 추가할 메타데이터
+            chunk_size: 각 청크의 최대 문자 수
+            chunk_overlap: 청크 간 중첩되는 문자 수
+        
+        Returns:
+            문서 객체 목록
+        """
+        if not text:
+            return []
+        
+        # 텍스트 정제
+        clean = DocumentProcessor.clean_text(text)
+        
+        # 텍스트 분할
+        chunks = DocumentProcessor.split_text(
+            clean, 
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap
+        )
+        
+        # 문서 객체 생성
+        documents = []
+        for i, chunk in enumerate(chunks):
+            doc = {
+                "text": chunk,
+                "index": i,
+                "chunk_count": len(chunks)
+            }
+            
+            # 메타데이터 추가
+            if metadata:
+                doc.update(metadata)
+            
+            documents.append(doc)
+        
+        return documents
+    
+    @staticmethod
+    def load_documents_from_directory(
+        directory: str,
+        extensions: List[str] = [".txt", ".md", ".csv"],
+        recursive: bool = True,
+        chunk_size: int = 512,
+        chunk_overlap: int = 50
+    ) -> List[Dict[str, Any]]:
+        """
+        디렉토리에서 문서 로드 및 처리
+        
+        Args:
+            directory: 로드할 디렉토리 경로
+            extensions: 처리할 파일 확장자 목록
+            recursive: 하위 디렉토리 검색 여부
+            chunk_size: 각 청크의 최대 문자 수
+            chunk_overlap: 청크 간 중첩되는 문자 수
+        
+        Returns:
+            문서 객체 목록
+        """
+        if not os.path.isdir(directory):
+            logger.error(f"디렉토리를 찾을 수 없습니다: {directory}")
+            return []
+        
+        documents = []
+        
+        for root, dirs, files in os.walk(directory):
+            if not recursive and root != directory:
+                continue
+            
+            for file in files:
+                _, ext = os.path.splitext(file)
+                if ext.lower() not in extensions:
+                    continue
+                
+                file_path = os.path.join(root, file)
+                rel_path = os.path.relpath(file_path, directory)
+                
+                try:
+                    logger.info(f"파일 로드 중: {rel_path}")
+                    # 먼저 UTF-8로 시도
+                    try:
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            content = f.read()
+                    except UnicodeDecodeError:
+                        # UTF-8로 실패하면 CP949(한국어 Windows 기본 인코딩)로 시도
+                        logger.info(f"UTF-8 디코딩 실패, CP949로 시도: {rel_path}")
+                        with open(file_path, 'r', encoding='cp949') as f:
+                            content = f.read()
+                    
+                    # 메타데이터 생성
+                    metadata = {
+                        "source": rel_path,
+                        "filename": file,
+                        "filetype": ext.lower()[1:],
+                        "filepath": file_path
+                    }
+                    
+                    # CSV 파일은 특별 처리
+                    if ext.lower() == '.csv':
+                        logger.info(f"CSV 파일 감지, 행 단위로 분할 처리: {rel_path}")
+                        file_docs = DocumentProcessor.csv_to_documents(content, metadata)
+                    else:
+                        # 일반 텍스트 문서 처리
+                        file_docs = DocumentProcessor.text_to_documents(
+                            content,
+                            metadata=metadata,
+                            chunk_size=chunk_size,
+                            chunk_overlap=chunk_overlap
+                        )
+                    
+                    documents.extend(file_docs)
+                    logger.info(f"{len(file_docs)}개 청크 추출: {rel_path}")
+                    
+                except Exception as e:
+                    logger.error(f"파일 '{rel_path}' 처리 중 오류 발생: {e}")
+                    continue
+        
+        logger.info(f"총 {len(documents)}개 문서 청크를 로드했습니다.")
+        return documents
+    
+    @staticmethod
+    def prepare_rag_context(results: List[Dict[str, Any]], field: str = "text") -> List[str]:
+        """
+        검색 결과에서 RAG에 사용할 컨텍스트 추출
+        
+        Args:
+            results: 검색 결과 목록
+            field: 텍스트 내용이 있는 필드 이름
+            
+        Returns:
+            컨텍스트 텍스트 목록
+        """
+        context = []
+        
+        for result in results:
+            if field in result:
+                context.append(result[field])
+        
+        return context
+    
+    @staticmethod
+    def csv_to_documents(content: str, metadata: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        CSV 파일 내용을 행 단위로 분리하여 각 행을 별도의 문서로 처리
+        
+        Args:
+            content: CSV 파일의 내용
+            metadata: 기본 메타데이터
+            
+        Returns:
+            문서 객체 목록 (각 행이 별도의 문서)
+        """
+        documents = []
+        
+        try:
+            # 일반 CSV 파싱 시도 (코마 구분자 기본)
+            try:
+                csv_reader = csv.reader(io.StringIO(content))
+                rows = list(csv_reader)
+                if len(rows) > 0 and len(rows[0]) > 1:
+                    # 코마로 제대로 구분되었다고 판단
+                    logger.info(f"CSV 파일 코마 구분자로 처리: {metadata.get('source', 'unknown')}")
+                    has_valid_format = True
+                else:
+                    # 코마로 제대로 구분되지 않음
+                    has_valid_format = False
+            except Exception:
+                has_valid_format = False
+            
+            # 코마 형식이 아닌 경우, 공백 구분자 처리 시도
+            if not has_valid_format:
+                logger.warning(f"CSV 파일이 표준 코마 형식이 아닙니다. 공백 구분자로 처리하겠습니다: {metadata.get('source', 'unknown')}")
+                lines = content.strip().split('\n')
+                
+                for i, line in enumerate(lines):
+                    # IT로 시작하는 줄만 처리 (데이터 행으로 간주)
+                    if not line.strip().startswith('IT'):
+                        continue
+                        
+                    # 공백으로 분리하되, 최소 5개 열로 보장
+                    parts = line.split(maxsplit=4)
+                    
+                    # 유효한 행의 최소 길이 확인
+                    if len(parts) < 5:
+                        logger.warning(f"행 {i+1} 부족한 데이터: {line[:50]}...")
+                        continue
+                    
+                    # 각 필드 추출
+                    doc_id = parts[0].strip()  # IT 번호
+                    query_type = parts[1].strip()  # 쿼리 유형
+                    question = parts[2].strip()  # 질문
+                    answer = parts[3].strip()  # 답변
+                    reference = parts[4].strip() if len(parts) > 4 else ""  # 참조
+                    
+                    # 문서 텍스트 생성 - 각 필드를 구분하여 포함
+                    text = f"ID: {doc_id}\n"
+                    text += f"쿼리 유형: {query_type}\n"
+                    text += f"질의 (Question): {question}\n"
+                    text += f"응답 (Answer): {answer}\n"
+                    if reference:
+                        text += f"참조 문서/맥락 (Reference/Context): {reference}"
+                    
+                    # 문서 객체 생성
+                    doc_metadata = metadata.copy()
+                    doc_metadata.update({
+                        "row": i,
+                        "query_type": query_type,
+                        "question": question,
+                        "answer": answer,
+                        "reference": reference
+                    })
+                    
+                    document = {
+                        "text": text,
+                        "id": doc_id,  # IT 번호를 ID로 사용
+                        **doc_metadata
+                    }
+                    
+                    documents.append(document)
+                    logger.debug(f"IT 문서 처리: {doc_id} - {question[:30]}...")
+                
+                logger.info(f"공백 구분자 CSV 파일 '{metadata.get('source', 'unknown')}'에서 {len(documents)}개 행을 문서로 변환했습니다.")
+                return documents
+            
+            # 표준 CSV 형식 처리 (코마 구분자 사용)
+            if not rows:
+                logger.warning(f"CSV 파일에 데이터가 없습니다: {metadata.get('source', 'unknown')}")
+                return []
+            
+            # 첫 번째 행을 헤더로 사용
+            headers = rows[0]
+            logger.debug(f"CSV 헤더: {headers}")
+            
+            # 각 행을 별도의 문서로 변환
+            for i, row in enumerate(rows[1:], 1):  # 헤더 제외, 1부터 시작
+                # 행이 헤더보다 짧으면 빈 값으로 채움
+                while len(row) < len(headers):
+                    row.append("")
+                
+                # 행 데이터를 사전형으로 변환
+                row_data = {headers[j]: value for j, value in enumerate(row) if j < len(headers)}
+                
+                # 첫 번째 열을 ID로 사용 (있는 경우)
+                row_id = row[0] if row and len(row) > 0 else f"row_{i}"
+                
+                # 문서 텍스트 생성 - 모든 필드를 포함한 표현
+                text_parts = []
+                for j, header in enumerate(headers):
+                    if j < len(row) and row[j]:
+                        text_parts.append(f"{header}: {row[j]}")
+                
+                text = "\n".join(text_parts)
+                
+                # 문서 객체 생성
+                doc_metadata = metadata.copy()
+                doc_metadata.update({
+                    "row": i,
+                    "row_id": row_id,
+                    "total_rows": len(rows) - 1,  # 헤더 제외
+                    "csv_data": row_data  # 원본 행 데이터도 저장
+                })
+                
+                document = {
+                    "text": text,
+                    "id": row_id,
+                    **doc_metadata
+                }
+                
+                documents.append(document)
+            
+            logger.info(f"CSV 파일 '{metadata.get('source', 'unknown')}'에서 {len(documents)}개 행을 문서로 변환했습니다.")
+            
+        except Exception as e:
+            logger.error(f"CSV 파일 처리 중 오류 발생: {e}")
+        
+        return documents

utils/llm_client.py

@@ -0,0 +1,199 @@
+"""
+DeepSeek LLM API 클라이언트 모듈
+"""
+
+import os
+import json
+import logging
+import requests
+from typing import List, Dict, Any, Optional, Union
+from dotenv import load_dotenv
+
+# 환경 변수 로드
+load_dotenv()
+
+# 로거 설정
+logger = logging.getLogger("DeepSeekLLM")
+if not logger.hasHandlers():
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+class DeepSeekLLM:
+    """DeepSeek LLM API 래퍼 클래스"""
+    
+    def __init__(self):
+        """DeepSeek LLM 클래스 초기화"""
+        self.api_key = os.getenv("DEEPSEEK_API_KEY")
+        self.endpoint = os.getenv("DEEPSEEK_ENDPOINT", "https://api.deepseek.com/v1/chat/completions")
+        self.model = os.getenv("DEEPSEEK_MODEL", "deepseek-chat")
+        
+        if not self.api_key:
+            logger.warning("DeepSeek API 키가 .env 파일에 설정되지 않았습니다.")
+            logger.warning("DEEPSEEK_API_KEY를 확인하세요.")
+        else:
+            logger.info("DeepSeek LLM API 키 로드 완료.")
+    
+    def chat_completion(
+        self, 
+        messages: List[Dict[str, str]], 
+        temperature: float = 0.7, 
+        max_tokens: int = 1000,
+        stream: bool = False,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        DeepSeek 채팅 완성 API 호출
+        
+        Args:
+            messages: 채팅 메시지 목록
+            temperature: 생성 온도 (낮을수록 결정적)
+            max_tokens: 생성할 최대 토큰 수
+            stream: 스트리밍 응답 활성화 여부
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            API 응답 (딕셔너리)
+        """
+        if not self.api_key:
+            logger.error("API 키가 설정되지 않아 DeepSeek API를 호출할 수 없습니다.")
+            raise ValueError("DeepSeek API 키가 설정되지 않았습니다.")
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": stream,
+            **kwargs
+        }
+        
+        try:
+            logger.info(f"DeepSeek API 요청 전송 중: {self.endpoint}")
+            response = requests.post(
+                self.endpoint,
+                headers=headers,
+                json=payload,
+                timeout=60  # 타임아웃 설정
+            )
+            response.raise_for_status()
+            
+            if stream:
+                return response  # 스트리밍 응답은 원시 응답 객체 반환
+            else:
+                return response.json()
+                
+        except requests.exceptions.Timeout:
+            logger.error("DeepSeek API 요청 시간 초과")
+            raise TimeoutError("DeepSeek API 요청 시간 초과")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"DeepSeek API 요청 실패: {e}")
+            if hasattr(e, 'response') and e.response is not None:
+                logger.error(f"응답 코드: {e.response.status_code}, 내용: {e.response.text}")
+            raise ConnectionError(f"DeepSeek API 요청 실패: {e}")
+    
+    def generate(
+        self, 
+        prompt: str, 
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 1000,
+        **kwargs
+    ) -> str:
+        """
+        간단한 텍스트 생성 인터페이스
+        
+        Args:
+            prompt: 사용자 프롬프트
+            system_prompt: 시스템 프롬프트 (선택 사항)
+            temperature: 생성 온도
+            max_tokens: 생성할 최대 토큰 수
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            생성된 텍스트
+        """
+        messages = []
+        
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        messages.append({"role": "user", "content": prompt})
+        
+        try:
+            response = self.chat_completion(
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+            
+            if not response or "choices" not in response or not response["choices"]:
+                logger.error("DeepSeek API 응답에서 생성된 텍스트를 찾을 수 없습니다.")
+                return ""
+            
+            return response["choices"][0]["message"]["content"].strip()
+            
+        except Exception as e:
+            logger.error(f"텍스트 생성 중 오류 발생: {e}")
+            return f"오류: {str(e)}"
+    
+    def rag_generate(
+        self, 
+        query: str, 
+        context: List[str],
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.3,
+        max_tokens: int = 1000,
+        **kwargs
+    ) -> str:
+        """
+        RAG 검색 결과를 활용한 텍스트 생성
+        
+        Args:
+            query: 사용자 질의
+            context: 검색된 문맥 목록
+            system_prompt: 시스템 프롬프트 (선택 사항)
+            temperature: 생성 온도
+            max_tokens: 생성할 최대 토큰 수
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            생성된 텍스트
+        """
+        if not system_prompt:
+            system_prompt = """당신은 검색 결과를 기반으로 질문에 답변하는 도우미입니다.
+- 검색 결과는 <context> 태그 안에 제공됩니다.
+- 검색 결과에 답변이 있으면 해당 정보를 사용하여 명확하게 답변하세요.
+- 검색 결과에 답변이 없으면 "검색 결과에 관련 정보가 없습니다"라고 말하세요.
+- 검색 내용을 그대로 복사하지 말고, 자연스러운 한국어로 답변을 작성하세요.
+- 답변은 간결하고 정확하게 제공하세요."""
+        
+        context_text = "\n\n".join([f"문서 {i+1}: {doc}" for i, doc in enumerate(context)])
+        
+        prompt = f"""질문: {query}
+
+<context>
+{context_text}
+</context>
+
+위 검색 결과를 참고하여 질문에 답변해 주세요."""
+        
+        try:
+            return self.generate(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+        except Exception as e:
+            logger.error(f"RAG 텍스트 생성 중 오류 발생: {e}")
+            return f"오류: {str(e)}"

utils/llm_interface.py

@@ -0,0 +1,159 @@
+"""
+LLM 인터페이스 모듈 - 다양한 LLM을 통합 관리
+"""
+
+import os
+import logging
+from typing import List, Dict, Any, Optional, Union
+from dotenv import load_dotenv
+
+# LLM 클라이언트 임포트
+from utils.openai_client import OpenAILLM
+from utils.deepseek_client import DeepSeekLLM
+
+# 환경 변수 로드
+load_dotenv()
+
+# 로거 설정
+logger = logging.getLogger("LLMInterface")
+if not logger.hasHandlers():
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+class LLMInterface:
+    """다양한 LLM API를 통합 관리하는 인터페이스 클래스"""
+    
+    # 지원되는 LLM 목록 (UI에서 표시될 이름과 내부 식별자)
+    SUPPORTED_LLMS = {
+        "OpenAI": "openai",
+        "DeepSeek": "deepseek"
+    }
+    
+    def __init__(self, default_llm: str = "openai"):
+        """LLM 인터페이스 초기화
+        
+        Args:
+            default_llm: 기본 LLM 식별자 ('openai' 또는 'deepseek')
+        """
+        # LLM 클라이언트 초기화
+        self.llm_clients = {
+            "openai": OpenAILLM(),
+            "deepseek": DeepSeekLLM()
+        }
+        
+        # 기본 LLM 설정 (유효하지 않은 경우 openai로 설정)
+        if default_llm not in self.llm_clients:
+            logger.warning(f"지정된 기본 LLM '{default_llm}'가 유효하지 않습니다. 'openai'로 설정됩니다.")
+            default_llm = "openai"
+        
+        self.default_llm = default_llm
+        self.current_llm = default_llm
+        
+        logger.info(f"LLM 인터페이스 초기화 완료, 기본 LLM: {default_llm}")
+    
+    def set_llm(self, llm_id: str) -> bool:
+        """현재 LLM을 설정
+        
+        Args:
+            llm_id: LLM 식별자
+            
+        Returns:
+            성공 여부
+        """
+        if llm_id not in self.llm_clients:
+            logger.error(f"지원되지 않는 LLM 식별자: {llm_id}")
+            return False
+        
+        self.current_llm = llm_id
+        logger.info(f"현재 LLM이 '{llm_id}'로 설정되었습니다.")
+        return True
+    
+    def get_current_llm_name(self) -> str:
+        """현재 LLM의 표시 이름 반환"""
+        for name, id in self.SUPPORTED_LLMS.items():
+            if id == self.current_llm:
+                return name
+        return "Unknown"
+    
+    def get_current_llm_details(self) -> Dict[str, str]:
+        """현재 LLM의 세부 정보 반환"""
+        name = self.get_current_llm_name()
+        model = ""
+        
+        if self.current_llm == "openai":
+            model = self.llm_clients["openai"].model
+        elif self.current_llm == "deepseek":
+            model = self.llm_clients["deepseek"].model
+        
+        return {
+            "name": name,
+            "id": self.current_llm,
+            "model": model
+        }
+    
+    def generate(
+        self, 
+        prompt: str, 
+        system_prompt: Optional[str] = None,
+        llm_id: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """텍스트 생성
+        
+        Args:
+            prompt: 사용자 프롬프트
+            system_prompt: 시스템 프롬프트 (선택 사항)
+            llm_id: 사용할 LLM 식별자 (미지정 시 현재 LLM 사용)
+            **kwargs: 추가 인자 (temperature, max_tokens 등)
+            
+        Returns:
+            생성된 텍스트
+        """
+        # 사용할 LLM 결정
+        llm_to_use = llm_id if llm_id and llm_id in self.llm_clients else self.current_llm
+        llm_client = self.llm_clients[llm_to_use]
+        
+        # LLM 정보 로깅
+        logger.info(f"텍스트 생성 요청, LLM: {llm_to_use}")
+        
+        # 생성 요청
+        return llm_client.generate(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            **kwargs
+        )
+    
+    def rag_generate(
+        self, 
+        query: str, 
+        context: List[str],
+        llm_id: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """RAG 기반 텍스트 생성
+        
+        Args:
+            query: 사용자 질의
+            context: 검색된 문맥 목록
+            llm_id: 사용할 LLM 식별자 (미지정 시 현재 LLM 사용)
+            **kwargs: 추가 인자 (temperature, max_tokens 등)
+            
+        Returns:
+            생성된 텍스트
+        """
+        # 사용할 LLM 결정
+        llm_to_use = llm_id if llm_id and llm_id in self.llm_clients else self.current_llm
+        llm_client = self.llm_clients[llm_to_use]
+        
+        # LLM 정보 로깅
+        logger.info(f"RAG 텍스트 생성 요청, LLM: {llm_to_use}")
+        
+        # 생성 요청
+        return llm_client.rag_generate(
+            query=query,
+            context=context,
+            **kwargs
+        )

utils/openai_client.py

@@ -0,0 +1,195 @@
+"""
+OpenAI API 클라이언트 모듈
+"""
+
+import os
+import json
+import logging
+from typing import List, Dict, Any, Optional, Union
+from dotenv import load_dotenv
+from openai import OpenAI
+
+# 환경 변수 로드
+load_dotenv()
+
+# 로거 설정
+logger = logging.getLogger("OpenAILLM")
+if not logger.hasHandlers():
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+class OpenAILLM:
+    """OpenAI API 래퍼 클래스"""
+    
+    def __init__(self):
+        """OpenAI LLM 클래스 초기화"""
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        self.model = os.getenv("OPENAI_MODEL", "gpt-3.5-turbo")
+        
+        if not self.api_key:
+            logger.warning("OpenAI API 키가 .env 파일에 설정되지 않았습니다.")
+            logger.warning("OPENAI_API_KEY를 확인하세요.")
+        else:
+            # OpenAI 클라이언트 초기화
+            self.client = OpenAI(api_key=self.api_key)
+            logger.info("OpenAI API 키 로드 완료.")
+    
+    def chat_completion(
+        self, 
+        messages: List[Dict[str, str]], 
+        temperature: float = 0.7, 
+        max_tokens: int = 1000,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        OpenAI 채팅 완성 API 호출
+        
+        Args:
+            messages: 채팅 메시지 목록
+            temperature: 생성 온도 (낮을수록 결정적)
+            max_tokens: 생성할 최대 토큰 수
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            API 응답 (딕셔너리)
+        """
+        if not self.api_key:
+            logger.error("API 키가 설정되지 않아 OpenAI API를 호출할 수 없습니다.")
+            raise ValueError("OpenAI API 키가 설정되지 않았습니다.")
+        
+        try:
+            logger.info(f"OpenAI API 요청 전송 중 (모델: {self.model})")
+            
+            # 새로운 OpenAI SDK를 사용하여 API 호출
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+            
+            return response
+                
+        except Exception as e:
+            logger.error(f"OpenAI API 요청 실패: {e}")
+            raise Exception(f"OpenAI API 요청 실패: {e}")
+    
+    def generate(
+        self, 
+        prompt: str, 
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 1000,
+        **kwargs
+    ) -> str:
+        """
+        간단한 텍스트 생성 인터페이스
+        
+        Args:
+            prompt: 사용자 프롬프트
+            system_prompt: 시스템 프롬프트 (선택 사항)
+            temperature: 생성 온도
+            max_tokens: 생성할 최대 토큰 수
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            생성된 텍스트
+        """
+        messages = []
+        
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        messages.append({"role": "user", "content": prompt})
+        
+        try:
+            response = self.chat_completion(
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+            
+            # 새로운 OpenAI SDK 응답 구조에 맞게 처리
+            if not response or not hasattr(response, 'choices') or not response.choices:
+                logger.error("OpenAI API 응답에서 생성된 텍스트를 찾을 수 없습니다.")
+                return ""
+            
+            return response.choices[0].message.content.strip()
+            
+        except Exception as e:
+            logger.error(f"텍스트 생성 중 오류 발생: {e}")
+            return f"오류: {str(e)}"
+    
+    def rag_generate(
+        self, 
+        query: str, 
+        context: List[str],
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.3,
+        max_tokens: int = 1000,
+        **kwargs
+    ) -> str:
+        """
+        RAG 검색 결과를 활용한 텍스트 생성
+        
+        Args:
+            query: 사용자 질의
+            context: 검색된 문맥 목록
+            system_prompt: 시스템 프롬프트 (선택 사항)
+            temperature: 생성 온도
+            max_tokens: 생성할 최대 토큰 수
+            **kwargs: 추가 API 매개변수
+        
+        Returns:
+            생성된 텍스트
+        """
+        if not system_prompt:
+            system_prompt = """당신은 검색 결과를 기반으로 질문에 답변하는 도우미입니다.
+- 검색 결과는 <context> 태그 안에 제공됩니다.
+- 검색 결과에 답변이 있으면 해당 정보를 사용하여 명확하게 답변하세요.
+- 검색 결과에 답변이 없으면 "검색 결과에 관련 정보가 없습니다"라고 말하세요.
+- 검색 내용을 그대로 복사하지 말고, 자연스러운 한국어로 답변을 작성하세요.
+- 답변은 간결하고 정확하게 제공하세요."""
+        
+        # 중요: 컨텍스트 길이 제한
+        # gpt-4o-mini에 맞게 제한 완화
+        max_context = 10  # 3개에서 10개로 증가
+        if len(context) > max_context:
+            logger.warning(f"컨텍스트가 너무 길어 처음 {max_context}개만 사용합니다.")
+            context = context[:max_context]
+        
+        # 각 컨텍스트 액세스
+        limited_context = []
+        for i, doc in enumerate(context):
+            # 각 문서를 1000자로 제한 (이전 500자에서 업그레이드)
+            if len(doc) > 1000:
+                logger.warning(f"문서 {i+1}의 길이가 제한되었습니다 ({len(doc)} -> 1000)")
+                doc = doc[:1000] + "...(생략)"
+            limited_context.append(doc)
+        
+        context_text = "\n\n".join([f"문서 {i+1}: {doc}" for i, doc in enumerate(limited_context)])
+        
+        prompt = f"""질문: {query}
+
+<context>
+{context_text}
+</context>
+
+위 검색 결과를 참고하여 질문에 답변해 주세요."""
+        
+        try:
+            return self.generate(
+                prompt=prompt,
+                system_prompt=system_prompt,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+        except Exception as e:
+            logger.error(f"RAG 텍스트 생성 중 오류 발생: {e}")
+            return f"오류: {str(e)}"

utils/vito_stt.py

@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+"""
+VITO API를 사용한 음성 인식(STT) 모듈
+"""
+
+import os
+import logging
+import requests
+import json
+import time # time import 추가
+from dotenv import load_dotenv
+
+# 환경 변수 로드
+load_dotenv()
+
+# 로거 설정 (app.py와 공유하거나 독립적으로 설정 가능)
+# 여기서는 독립적인 로거를 사용합니다. 필요시 app.py의 로거를 사용하도록 수정할 수 있습니다.
+logger = logging.getLogger("VitoSTT")
+# 기본 로깅 레벨 설정 (핸들러가 없으면 출력이 안될 수 있으므로 기본 핸들러 추가 고려)
+if not logger.hasHandlers():
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO) # 기본 레벨 INFO로 설정
+
+class VitoSTT:
+    """VITO STT API 래퍼 클래스"""
+
+    def __init__(self):
+        """VITO STT 클래스 초기화"""
+        self.client_id = os.getenv("VITO_CLIENT_ID")
+        self.client_secret = os.getenv("VITO_CLIENT_SECRET")
+
+        if not self.client_id or not self.client_secret:
+            logger.warning("VITO API 인증 정보가 .env 파일에 설정되지 않았습니다.")
+            logger.warning("VITO_CLIENT_ID와 VITO_CLIENT_SECRET를 확인하세요.")
+            # 에러를 발생시키거나, 기능 사용 시점에 체크하도록 둘 수 있습니다.
+            # 여기서는 경고만 하고 넘어갑니다.
+        else:
+            logger.info("VITO STT API 클라이언트 ID/Secret 로드 완료.")
+
+        # API 엔드포인트
+        self.token_url = "https://openapi.vito.ai/v1/authenticate"
+        self.stt_url = "https://openapi.vito.ai/v1/transcribe"
+
+        # 액세스 토큰
+        self.access_token = None
+        self._token_expires_at = 0 # 토큰 만료 시간 추적 (선택적 개선)
+
+    def get_access_token(self):
+        """VITO API 액세스 토큰 획득"""
+        # 현재 시간을 가져와 토큰 만료 여부 확인 (선택적 개선)
+        # now = time.time()
+        # if self.access_token and now < self._token_expires_at:
+        #     logger.debug("기존 VITO API 토큰 사용")
+        #     return self.access_token
+
+        if not self.client_id or not self.client_secret:
+            logger.error("API 키가 설정되지 않아 토큰을 획득할 수 없습니다.")
+            raise ValueError("VITO API 인증 정보가 설정되지 않았습니다.")
+
+        logger.info("VITO API 액세스 토큰 요청 중...")
+        try:
+            response = requests.post(
+                self.token_url,
+                data={"client_id": self.client_id, "client_secret": self.client_secret},
+                timeout=10 # 타임아웃 설정
+            )
+            response.raise_for_status() # HTTP 오류 발생 시 예외 발생
+
+            result = response.json()
+            self.access_token = result.get("access_token")
+            expires_in = result.get("expires_in", 3600) # 만료 시간 (초), 기본값 1시간
+            self._token_expires_at = time.time() + expires_in - 60 # 60초 여유
+
+            if not self.access_token:
+                logger.error("VITO API 응답에서 토큰을 찾을 수 없습니다.")
+                raise ValueError("VITO API 토큰을 받아오지 못했습니다.")
+
+            logger.info("VITO API 액세스 토큰 획득 성공")
+            return self.access_token
+        except requests.exceptions.Timeout:
+            logger.error(f"VITO API 토큰 획득 시간 초과: {self.token_url}")
+            raise TimeoutError("VITO API 토큰 획득 시간 초과")
+        except requests.exceptions.RequestException as e:
+            logger.error(f"VITO API 토큰 획득 실패: {e}")
+            if hasattr(e, 'response') and e.response is not None:
+                 logger.error(f"응답 코드: {e.response.status_code}, 내용: {e.response.text}")
+            raise ConnectionError(f"VITO API 토큰 획득 실패: {e}")
+
+
+    def transcribe_audio(self, audio_bytes, language="ko"):
+        """
+        오디오 바이트 데이터를 텍스트로 변환
+
+        Args:
+            audio_bytes: 오디오 파일 바이트 데이터
+            language: 언어 코드 (기본값: 'ko')
+
+        Returns:
+            인식된 텍스트 또는 오류 메시지를 포함한 딕셔너리
+            {'success': True, 'text': '인식된 텍스트'}
+            {'success': False, 'error': '오류 메시지', 'details': '상세 내용'}
+        """
+        if not self.client_id or not self.client_secret:
+            logger.error("API 키가 설정되지 않았습니다.")
+            return {"success": False, "error": "API 키가 설정되지 않았습니다."}
+
+        try:
+            # 토큰 획득 또는 갱신
+            # (선택적 개선: 만료 시간 체크 로직 추가 시 self._token_expires_at 사용)
+            if not self.access_token: # or time.time() >= self._token_expires_at:
+                logger.info("VITO API 토큰 획득/갱신 시도...")
+                self.get_access_token()
+
+            headers = {
+                "Authorization": f"Bearer {self.access_token}"
+            }
+
+            files = {
+                "file": ("audio_file", audio_bytes) # 파일명 튜플로 전달
+            }
+
+            # API 설정값 (필요에 따라 수정)
+            config = {
+                "use_multi_channel": False,
+                "use_itn": True, # Inverse Text Normalization (숫자, 날짜 등 변환)
+                "use_disfluency_filter": True, # 필러 (음, 아...) 제거
+                "use_profanity_filter": False, # 비속어 필터링
+                "language": language,
+                # "type": "audio" # type 파라미터는 VITO 문서상 필수 아님 (자동 감지)
+            }
+            data = {"config": json.dumps(config)}
+
+            logger.info(f"VITO STT API ({self.stt_url}) 요청 전송 중...")
+            response = requests.post(
+                self.stt_url,
+                headers=headers,
+                files=files,
+                data=data,
+                timeout=20 # 업로드 타임아웃
+            )
+            response.raise_for_status()
+
+            result = response.json()
+            job_id = result.get("id")
+
+            if not job_id:
+                logger.error("VITO API 작업 ID를 받아오지 못했습니다.")
+                return {"success": False, "error": "VITO API 작업 ID를 받아오지 못했습니다."}
+
+            logger.info(f"VITO STT 작업 ID: {job_id}, 결과 확인 시작...")
+
+            # 결과 확인 URL
+            transcript_url = f"{self.stt_url}/{job_id}"
+            max_tries = 15 # 최대 시도 횟수 증가
+            wait_time = 2 # 대기 시간 증가 (초)
+
+            for try_count in range(max_tries):
+                time.sleep(wait_time) # API 부하 감소 위해 대기
+                logger.debug(f"결과 확인 시도 ({try_count + 1}/{max_tries}) - URL: {transcript_url}")
+                get_response = requests.get(
+                    transcript_url,
+                    headers=headers,
+                    timeout=10 # 결과 확인 타임아웃
+                )
+                get_response.raise_for_status()
+
+                result = get_response.json()
+                status = result.get("status")
+                logger.debug(f"현재 상태: {status}")
+
+                if status == "completed":
+                    # 결과 추출 (utterances 구조 확인 필요)
+                    utterances = result.get("results", {}).get("utterances", [])
+                    if utterances:
+                         # 전체 텍스트를 하나로 합침
+                        transcript = " ".join([seg.get("msg", "") for seg in utterances if seg.get("msg")]).strip()
+                        logger.info(f"VITO STT 인식 성공 (일부): {transcript[:50]}...")
+                        return {
+                            "success": True,
+                            "text": transcript
+                            # "raw_result": result # 필요시 전체 결과 반환
+                        }
+                    else:
+                         logger.warning("VITO STT 완료되었으나 결과 utterances가 비어있습니다.")
+                         return {"success": True, "text": ""} # 성공이지만 텍스트 없음
+
+                elif status == "failed":
+                    error_msg = f"VITO API 변환 실패: {result.get('message', '알 수 없는 오류')}"
+                    logger.error(error_msg)
+                    return {"success": False, "error": error_msg, "details": result}
+
+                elif status == "transcribing":
+                    logger.info(f"VITO API 처리 중... ({try_count + 1}/{max_tries})")
+                else: # registered, waiting 등 다른 상태
+                    logger.info(f"VITO API 상태 '{status}', 대기 중... ({try_count + 1}/{max_tries})")
+
+
+            logger.error(f"VITO API 응답 타임아웃 ({max_tries * wait_time}초 초과)")
+            return {"success": False, "error": "VITO API 응답 타임아웃"}
+
+        except requests.exceptions.HTTPError as e:
+            # 토큰 만료 오류 처리 (401 Unauthorized)
+            if e.response.status_code == 401:
+                logger.warning("VITO API 토큰이 만료되었거나 유효하지 않습니다. 토큰 재발급 시도...")
+                self.access_token = None # 기존 토큰 무효화
+                try:
+                    # 재귀 호출 대신, 토큰 재발급 후 다시 시도하는 로직 구성
+                    self.get_access_token()
+                    logger.info("새 토큰으로 재시도합니다.")
+                    # 재시도는 이 함수를 다시 호출하는 대신, 호출하는 쪽에서 처리하는 것이 더 안전할 수 있음
+                    # 여기서는 한 번 더 시도하는 로직 추가 (무한 루프 방지 필요)
+                    # return self.transcribe_audio(audio_bytes, language) # 재귀 호출 방식
+                    # --- 비재귀 방식 ---
+                    headers["Authorization"] = f"Bearer {self.access_token}" # 헤더 업데이트
+                    # POST 요청부터 다시 시작 (코드 중복 발생 가능성 있음)
+                    # ... (POST 요청 및 결과 폴링 로직 반복) ...
+                    # 간단하게는 그냥 실패 처리하고 상위에서 재시도 유도
+                    return {"success": False, "error": "토큰 만료 후 재시도 필요", "details": "토큰 재발급 성공"}
+
+                except Exception as token_e:
+                    logger.error(f"토큰 재획득 실패: {token_e}")
+                    return {"success": False, "error": f"토큰 재획득 실패: {str(token_e)}"}
+
+            else:
+                # 401 외 다른 HTTP 오류
+                error_body = ""
+                try:
+                    error_body = e.response.text
+                except Exception:
+                    pass
+                logger.error(f"VITO API HTTP 오류: {e.response.status_code}, 응답: {error_body}")
+                return {
+                    "success": False,
+                    "error": f"API HTTP 오류: {e.response.status_code}",
+                    "details": error_body
+                }
+
+        except requests.exceptions.Timeout:
+            logger.error("VITO API 요청 시간 초과")
+            return {"success": False, "error": "API 요청 시간 초과"}
+        except requests.exceptions.RequestException as e:
+            logger.error(f"VITO API 요청 중 네트워크 오류 발생: {str(e)}")
+            return {"success": False, "error": "API 요청 네트워크 오류", "details": str(e)}
+        except Exception as e:
+            logger.error(f"음성인식 처리 중 예상치 못한 오류 발생: {str(e)}", exc_info=True)
+            return {
+                "success": False,
+                "error": "음성인식 내부 처리 실패",
+                "details": str(e)
+            }