fix

app/app_routes.py

@@ -1,5 +1,5 @@
 """
-RAG 검색 챗봇 웹 애플리케이션 - API 라우트 정의
+RAG 검??챗봇 ???�플리�??�션 - API ?�우???�의
 """
 
 import os
@@ -11,20 +11,19 @@ from flask import request, jsonify, render_template, send_from_directory, sessio
 from datetime import datetime
 from werkzeug.utils import secure_filename
 
-# 로거 가져오기
-logger = logging.getLogger(__name__)
+# 로거 가?�오�?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 애플리케이션에 기본 라우트 등록"""
+    """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
 
@@ -32,70 +31,69 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
     def login():
         error = None
         next_url = request.args.get('next')
-        logger.info(f"-------------- 로그인 페이지 접속 (Next: {next_url}) --------------")
+        logger.info(f"-------------- 로그???�이지 ?�속 (Next: {next_url}) --------------")
         logger.info(f"Method: {request.method}")
 
         if request.method == 'POST':
-            logger.info("로그인 시도 받음")
+            logger.info("로그???�도 받음")
             username = request.form.get('username', '')
             password = request.form.get('password', '')
-            logger.info(f"입력된 사용자명: {username}")
-            logger.info(f"비밀번호 입력 여부: {len(password) > 0}")
+            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}")
+            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}")
+                logger.info(f"로그???�공: {username}")
+                # ?�션 ?�정 ???�재 ?�션 ?�태 로깅
+                logger.debug(f"?�션 ?�정 ?? {session}")
 
-                # 세션에 로그인 정보 저장
-                session.permanent = True
+                # ?�션??로그???�보 ?�??                session.permanent = True
                 session['logged_in'] = True
                 session['username'] = username
                 session.modified = True
 
-                logger.info(f"세션 설정 후: {session}")
-                logger.info("세션 설정 완료, 리디렉션 시도")
+                logger.info(f"?�션 ?�정 ?? {session}")
+                logger.info("?�션 ?�정 ?�료, 리디?�션 ?�도")
 
-                # 로그인 성공 후 리디렉션
+                # 로그???�공 ??리디?�션
                 redirect_to = next_url or url_for('index')
-                logger.info(f"리디렉션 대상: {redirect_to}")
+                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 = '아이디 또는 비밀번호가 올바르지 않습니다.'
+                logger.warning("로그???�패: ?�이???�는 비�?번호 불일�?)
+                if username != valid_username: logger.warning("?�용?�명 불일�?)
+                if password != valid_password: logger.warning("비�?번호 불일�?)
+                error = '?�이???�는 비�?번호�� ?�바르�? ?�습?�다.'
         else:
-            logger.info("로그인 페이지 GET 요청")
+            logger.info("로그???�이지 GET ?�청")
             if 'logged_in' in session:
-                logger.info("이미 로그인된 사용자, 메인 페이지로 리디렉션")
+                logger.info("?��? 로그?�된 ?�용?? 메인 ?�이지�?리디?�션")
                 return redirect(url_for('index'))
 
-        logger.info("---------- 로그인 페이지 렌더링 ----------")
+        logger.info("---------- 로그???�이지 ?�더�?----------")
         return render_template('login.html', error=error, next=next_url)
 
 
     @app.route('/logout')
     def logout():
-        """로그아웃 처리"""
+        """로그?�웃 처리"""
         if 'logged_in' in session:
             username = session.get('username', 'unknown')
-            logger.info(f"사용자 {username} 로그아웃 처리 시작")
+            logger.info(f"?�용??{username} 로그?�웃 처리 ?�작")
             session.pop('logged_in', None)
             session.pop('username', None)
             session.modified = True
-            logger.info(f"세션 정보 삭제 완료. 현재 세션: {session}")
+            logger.info(f"?�션 ?�보 ??�� ?�료. ?�재 ?�션: {session}")
         else:
-            logger.warning("로그인되지 않은 상태에서 로그아웃 시도")
+            logger.warning("로그?�되지 ?��? ?�태?�서 로그?�웃 ?�도")
 
-        logger.info("로그인 페이지로 리디렉션")
+        logger.info("로그???�이지�?리디?�션")
         response = redirect(url_for('login'))
         return response
 
@@ -103,43 +101,42 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
     @app.route('/')
     @login_required
     def index():
-        """메인 페이지"""
+        """메인 ?�이지"""
         nonlocal app_ready
         
-        # 앱 준비 상태 확인 - 30초 이상 지났으면 강제로 ready 상태로 변경
-        current_time = datetime.now()
+        # ??준�??�태 ?�인 - 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 상태로 변경합니다.")
+            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('loading.html'), 503  # ?�비??준�??�됨 ?�태 코드
         
-        logger.info("메인 페이지 요청")
+        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'}")
+        """??초기???�태 ?�인 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"""
+        """?�용 가?�한 LLM 목록 �??�택 API"""
         if not app_ready:
-            return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+            return jsonify({"error": "?�이 ?�직 초기??중입?�다. ?�시 ???�시 ?�도?�주?�요."}), 503
 
         if request.method == 'GET':
-            logger.info("LLM 목록 요청")
+            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 {}
@@ -152,87 +149,86 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                     "current_llm": current_details
                 })
             except Exception as e:
-                logger.error(f"LLM 정보 조회 오류: {e}")
-                return jsonify({"error": "LLM 정보 조회 중 오류 발생"}), 500
+                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
+                return jsonify({"error": "LLM ID가 ?�공?��? ?�았?�니??"}), 400
 
             llm_id = data['llm_id']
-            logger.info(f"LLM 변경 요청: {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 인터페이스에 필요한 메소드/속성 없음")
+                    raise NotImplementedError("LLM ?�터?�이?�에 ?�요??메소???�성 ?�음")
 
                 if llm_id not in llm_interface.llm_clients:
-                    return jsonify({"error": f"지원되지 않는 LLM ID: {llm_id}"}), 400
+                    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)}'로 변경되었습니다.")
+                    logger.info(f"LLM??'{new_details.get('name', llm_id)}'�?변경되?�습?�다.")
                     return jsonify({
                         "success": True,
-                        "message": f"LLM이 '{new_details.get('name', llm_id)}'로 변경되었습니다.",
+                        "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
+                    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
+                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"""
+        """?�스??기반 챗봇 API"""
         if not app_ready or retriever is None:
-            return jsonify({"error": "앱/검색기가 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503
+            return jsonify({"error": "??검?�기가 ?�직 초기??중입?�다. ?�시 ???�시 ?�도?�주?�요."}), 503
 
         try:
             data = request.get_json()
             if not data or 'query' not in data:
-                return jsonify({"error": "쿼리가 제공되지 않았습니다."}), 400
+                return jsonify({"error": "쿼리가 ?�공?��? ?�았?�니??"}), 400
 
             query = data['query']
-            logger.info(f"텍스트 쿼리 수신: {query[:100]}...")
+            logger.info(f"?�스??쿼리 ?�신: {query[:100]}...")
 
-            # RAG 검색 수행
+            # RAG 검???�행
             if not hasattr(retriever, 'search'):
-                raise NotImplementedError("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 메소드가 없습니다.")
+            # 컨텍?�트 준�?            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("검색 결과가 없어 컨텍스트를 생성하지 못함.")
+                logger.warning("검??결과가 ?�어 컨텍?�트�??�성?��? 못함.")
 
-            # LLM에 질의
+            # LLM??질의
             llm_id = data.get('llm_id', None)
             if not hasattr(llm_interface, 'rag_generate'):
-                raise NotImplementedError("LLMInterface에 rag_generate 메소드가 없습니다.")
+                raise NotImplementedError("LLMInterface??rag_generate 메소?��? ?�습?�다.")
 
             if not context:
-                answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
-                logger.info("컨텍스트 없이 기본 응답 생성")
+                answer = "죄송?�니?? 관???�보�?찾을 ???�습?�다."
+                logger.info("컨텍?�트 ?�이 기본 ?�답 ?�성")
             else:
                 answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
-                logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+                logger.info(f"LLM ?�답 ?�성 ?�료 (길이: {len(answer)})")
 
-            # 소스 정보 추출 (CSV ID 추출 로직 포함)
+            # ?�스 ?�보 추출 (CSV ID 추출 로직 ?�함)
             sources = []
             if search_results:
                 for result in search_results:
                     if not isinstance(result, dict):
-                        logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
+                        logger.warning(f"?�상�?못한 검??결과 ?�식: {type(result)}")
                         continue
 
                     if "source" in result:
@@ -241,7 +237,7 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                             "score": result.get("rerank_score", result.get("score", 0))
                         }
 
-                        # CSV 파일 특정 처리
+                        # CSV ?�일 ?�정 처리
                         if "text" in result and result.get("filetype") == "csv":
                             try:
                                 text_lines = result["text"].strip().split('\n')
@@ -250,13 +246,13 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                                     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']}")
+                                        logger.debug(f"CSV ?�스 ID 추출: {first_column} from {source_info['source']}")
                             except Exception as e:
-                                logger.warning(f"CSV 소스 ID 추출 실패 ({result.get('source')}): {e}")
+                                logger.warning(f"CSV ?�스 ID 추출 ?�패 ({result.get('source')}): {e}")
 
                         sources.append(source_info)
 
-            # 최종 응답
+            # 최종 ?�답
             response_data = {
                 "answer": answer,
                 "sources": sources,
@@ -265,104 +261,100 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             return jsonify(response_data)
 
         except Exception as e:
-            logger.error(f"채팅 처리 중 오류 발생: {e}", exc_info=True)
-            return jsonify({"error": f"처리 중 오류가 발생했습니다: {str(e)}"}), 500
+            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 엔드포인트"""
+        """?�성 �?API ?�드?�인??""
         if not app_ready:
-            logger.warning("앱 초기화가 완료되지 않았지만 음성 API 요청 처리 시도")
-            # 여기서 바로 리턴하지 않고 계속 진행
-            # 사전 검사: retriever와 stt_client가 제대로 초기화되었는지 확인
+            logger.warning("??초기?��? ?�료?��? ?�았지�??�성 API ?�청 처리 ?�도")
+            # ?�기??바로 리턴?��? ?�고 계속 진행
+            # ?�전 검?? retriever?� stt_client가 ?��?�?초기?�되?�는지 ?�인
 
         if retriever is None:
-            logger.error("retriever가 아직 초기화되지 않았습니다")
+            logger.error("retriever가 ?�직 초기?�되지 ?�았?�니??)
             return jsonify({
-                "transcription": "(음성을 텍스트로 변환했지만 검색 엔진이 아직 준비되지 않았습니다)",
-                "answer": "죄송합니다. 검색 엔진이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요.",
+                "transcription": "(?�성???�스?�로 변?�했지�?검???�진???�직 준비되지 ?�았?�니??",
+                "answer": "죄송?�니?? 검???�진???�직 초기??중입?�다. ?�시 ???�시 ?�도?�주?�요.",
                 "sources": []
             })
-        # 또는 필수 컴포넌트가 없을 때만 특별 응답 반환
+        # ?�는 ?�수 컴포?�트가 ?�을 ?�만 ?�별 ?�답 반환
         if stt_client is None:
             return jsonify({
-                "transcription": "(음성 인식 기능이 준비 중입니다)",
-                "answer": "죄송합니다. 현재 음성 인식 서비스가 초기화 중입니다. 잠시 후 다시 시도해주세요.",
+                "transcription": "(?�성 ?�식 기능??준�?중입?�다)",
+                "answer": "죄송?�니?? ?�재 ?�성 ?�식 ?�비?��? 초기??중입?�다. ?�시 ???�시 ?�도?�주?�요.",
                 "sources": []
             })
 
-        logger.info("음성 ��� 요청 수신")
+        logger.info("?�성 �??�청 ?�신")
         
         if 'audio' not in request.files:
-            logger.error("오디오 파일이 제공되지 않음")
-            return jsonify({"error": "오디오 파일이 제공되지 않았습니다."}), 400
+            logger.error("?�디???�일???�공?��? ?�음")
+            return jsonify({"error": "?�디???�일???�공?��? ?�았?�니??"}), 400
 
         audio_file = request.files['audio']
-        logger.info(f"수신된 오디오 파일: {audio_file.filename} ({audio_file.content_type})")
+        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}")
-                # VitoSTT.transcribe_audio 가 파일 경로 또는 바이트를 받을 수 있도록 구현되어야 함
-                # 여기서는 파일 경로를 사용한다고 가정
-                if not hasattr(stt_client, 'transcribe_audio'):
-                    raise NotImplementedError("STT 클라이언트에 transcribe_audio 메소드가 없습니다.")
-
-                # 파일 경로로 전달 시
-                # stt_result = stt_client.transcribe_audio(temp_audio.name, language="ko")
-                # 바이트로 전달 시
-                with open(temp_audio.name, 'rb') as f_bytes:
+                logger.info(f"?�디???�일???�시 ?�?? {temp_audio.name}")
+                # VitoSTT.transcribe_audio 가 ?�일 경로 ?�는 바이?��? 받을 ???�도�?구현?�어????                # ?�기?�는 ?�일 경로�??�용?�다�?가??                if not hasattr(stt_client, 'transcribe_audio'):
+                    raise NotImplementedError("STT ?�라?�언?�에 transcribe_audio 메소?��? ?�습?�다.")
+
+                # ?�일 경로�??�달 ??                # stt_result = stt_client.transcribe_audio(temp_audio.name, language="ko")
+                # 바이?�로 ?�달 ??                with open(temp_audio.name, 'rb') as f_bytes:
                     audio_bytes = f_bytes.read()
                 stt_result = stt_client.transcribe_audio(audio_bytes, language="ko")
 
 
             if not isinstance(stt_result, dict) or not stt_result.get("success"):
-                error_msg = stt_result.get("error", "알 수 없는 STT 오류") if isinstance(stt_result, dict) else "STT 결과 형식 오류"
-                logger.error(f"음성인식 실패: {error_msg}")
+                error_msg = stt_result.get("error", "?????�는 STT ?�류") if isinstance(stt_result, dict) else "STT 결과 ?�식 ?�류"
+                logger.error(f"?�성?�식 ?�패: {error_msg}")
                 return jsonify({
-                    "error": "음성인식 실패",
+                    "error": "?�성?�식 ?�패",
                     "details": error_msg
                 }), 500
 
             transcription = stt_result.get("text", "")
             if not transcription:
-                logger.warning("음성인식 결과가 비어있습니다.")
-                return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다.", "transcription": ""}), 400
+                logger.warning("?�성?�식 결과가 비어?�습?�다.")
+                return jsonify({"error": "?�성?�서 ?�스?��? ?�식?��? 못했?�니??", "transcription": ""}), 400
 
-            logger.info(f"음성인식 성공: {transcription[:50]}...")
+            logger.info(f"?�성?�식 ?�공: {transcription[:50]}...")
             if retriever is None:
-                logger.error("STT 성공 후 검색 시도 중 retriever가 None임")
+                logger.error("STT ?�공 ??검???�도 �?retriever가 None??)
                 return jsonify({
                     "transcription": transcription,
-                    "answer": "음성을 인식했지만, 현재 검색 시스템이 준비되지 않았습니다. 잠시 후 다시 시도해주세요.",
+                    "answer": "?�성???�식?��?�? ?�재 검???�스?�이 준비되지 ?�았?�니?? ?�시 ???�시 ?�도?�주?�요.",
                     "sources": []
                 })
-            # --- 이후 로직은 /api/chat과 거의 동일 ---
-            # RAG 검색 수행
+            # --- ?�후 로직?� /api/chat�?거의 ?�일 ---
+            # RAG 검???�행
             search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
             context = DocumentProcessor.prepare_rag_context(search_results, field="text")
 
             if not context:
-                logger.warning("음성 쿼리에 대한 검색 결과 없음.")
-                # answer = "죄송합니다. 관련 정보를 찾을 수 없습니다." (아래 LLM 호출 로직에서 처���)
+                logger.warning("?�성 쿼리???�??검??결과 ?�음.")
+                # answer = "죄송?�니?? 관???�보�?찾을 ???�습?�다." (?�래 LLM ?�출 로직?�서 처리)
                 pass
 
-            # LLM 호출
-            llm_id = request.form.get('llm_id', None) # 음성 요청은 form 데이터로 LLM ID 받을 수 있음
+            # LLM ?�출
+            llm_id = request.form.get('llm_id', None) # ?�성 ?�청?� form ?�이?�로 LLM ID 받을 ???�음
             if not context:
-                answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
-                logger.info("컨텍스트 없이 기본 응답 생성")
+                answer = "죄송?�니?? 관???�보�?찾을 ???�습?�다."
+                logger.info("컨텍?�트 ?�이 기본 ?�답 ?�성")
             else:
                 answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
-                logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")
+                logger.info(f"LLM ?�답 ?�성 ?�료 (길이: {len(answer)})")
 
 
-            # 소스 정보 추출
+            # ?�스 ?�보 추출
             enhanced_sources = []
             if search_results:
                 for doc in search_results:
@@ -381,10 +373,10 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                                         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}")
+                                logger.warning(f"[?�성�? CSV ?�스 ID 추출 ?�패 ({doc.get('source')}): {e}")
                         enhanced_sources.append(source_info)
 
-            # 최종 응답
+            # 최종 ?�답
             response_data = {
                 "transcription": transcription,
                 "answer": answer,
@@ -394,9 +386,9 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             return jsonify(response_data)
 
         except Exception as e:
-            logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
+            logger.error(f"?�성 �?처리 �??�류 발생: {e}", exc_info=True)
             return jsonify({
-                "error": "음성 처리 중 내부 오류 발생",
+                "error": "?�성 처리 �??��? ?�류 발생",
                 "details": str(e)
             }), 500
 
@@ -404,45 +396,45 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
     @app.route('/api/upload', methods=['POST'])
     @login_required
     def upload_document():
-        """지식베이스 문서 업로드 API"""
-        if not app_ready or base_retriever is None:
-            return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503
+        """지?�베?�스 문서 ?�로??API"""
+        if base_retriever is None:
+            return jsonify({"error": "??기본 검?�기가 ?�직 초기??중입?�다."}), 503
 
         if 'document' not in request.files:
-            return jsonify({"error": "문서 파일이 제공되지 않았습니다."}), 400
+            return jsonify({"error": "문서 ?�일???�공?��? ?�았?�니??"}), 400
 
         doc_file = request.files['document']
         if doc_file.filename == '':
-            return jsonify({"error": "선택된 파일이 없습니다."}), 400
+            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
+            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}")
+            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}")
+                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
+                    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
+                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(),
@@ -452,91 +444,84 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             docs = []
 
             if not hasattr(DocumentProcessor, 'csv_to_documents') or not hasattr(DocumentProcessor, 'text_to_documents'):
-                raise NotImplementedError("DocumentProcessor에 필요한 메소드 없음")
+                raise NotImplementedError("DocumentProcessor???�요??메소???�음")
 
             if file_ext == 'csv':
-                logger.info(f"CSV 파일 처리 시작: {filename}")
-                docs = DocumentProcessor.csv_to_documents(content, metadata) # 행 단위 처리 가정
-            else: # 기타 텍스트 기반 문서
-                logger.info(f"일반 텍스트 문서 처리 시작: {filename}")
-                # PDF, DOCX 등은 별도 라이브러리(pypdf, python-docx) 필요
+                logger.info(f"CSV ?�일 처리 ?�작: {filename}")
+                docs = DocumentProcessor.csv_to_documents(content, metadata) # ???�위 처리 가??            else: # 기�? ?�스??기반 문서
+                logger.info(f"?�반 ?�스??문서 처리 ?�작: {filename}")
+                # PDF, DOCX ?��? 별도 ?�이브러�?pypdf, python-docx) ?�요
                 if file_ext in ['pdf', 'docx']:
-                    logger.warning(f".{file_ext} 파일 처리는 현재 구현되지 않았습니다. 텍스트 추출 로직 추가 필요.")
-                    # 여기에 pdf/docx 텍스트 추출 로직 추가
-                    # 예: content = extract_text_from_pdf(filepath)
+                    logger.warning(f".{file_ext} ?�일 처리???�재 구현?��? ?�았?�니?? ?�스??추출 로직 추�? ?�요.")
+                    # ?�기??pdf/docx ?�스??추출 로직 추�?
+                    # ?? content = extract_text_from_pdf(filepath)
                     # content = extract_text_from_docx(filepath)
-                    # 임시로 비워둠
-                    content = ""
+                    # ?�시�?비워??                    content = ""
 
-                if content: # 텍스트 내용이 있을 때만 처리
+                if content: # ?�스???�용???�을 ?�만 처리
                     docs = DocumentProcessor.text_to_documents(
                         content, metadata=metadata,
                         chunk_size=512, chunk_overlap=50
                     )
 
-            # 검색기에 문서 추가 및 인덱스 저장
-            if docs:
+            # 검?�기??문서 추�? �??�덱???�??            if docs:
                 if not hasattr(base_retriever, 'add_documents') or not hasattr(base_retriever, 'save'):
-                    raise NotImplementedError("기본 검색기에 add_documents 또는 save 메소드 없음")
+                    raise NotImplementedError("기본 검?�기??add_documents ?�는 save 메소???�음")
 
-                logger.info(f"{len(docs)}개 문서 청크를 검색기에 추가합니다...")
+                logger.info(f"{len(docs)}�?문서 �?���?검?�기??추�??�니??..")
                 base_retriever.add_documents(docs)
 
-                # 인덱스 저장 (업로드마다 저장 - 비효율적일 수 있음)
-                logger.info(f"검색기 상태를 저장합니다...")
+                # ?�덱???�??(?�로?�마???�??- 비효?�적?????�음)
+                logger.info(f"검?�기 ?�태�??�?�합?�다...")
                 index_path = app.config['INDEX_PATH']
                 try:
                     base_retriever.save(index_path)
-                    logger.info("인덱스 저장 완료")
-                    # 재순위화 검색기도 업데이트 필요 시 로직 추가
-                    # 예: retriever.update_base_retriever(base_retriever)
+                    logger.info("?�덱???�???�료")
+                    # ?�순?�화 검?�기???�데?�트 ?�요 ??로직 추�?
+                    # ?? retriever.update_base_retriever(base_retriever)
                     return jsonify({
                         "success": True,
-                        "message": f"파일 '{filename}' 업로드 및 처리 완료 ({len(docs)}개 청크 추가)."
+                        "message": f"?�일 '{filename}' ?�로??�?처리 ?�료 ({len(docs)}�?�?�� 추�?)."
                     })
                 except Exception as e_save:
-                    logger.error(f"인덱스 저장 중 오류 발생: {e_save}")
-                    return jsonify({"error": f"인덱스 저장 중 오류: {str(e_save)}"}), 500
+                    logger.error(f"?�덱???�??�??�류 발생: {e_save}")
+                    return jsonify({"error": f"?�덱???�??�??�류: {str(e_save)}"}), 500
             else:
-                logger.warning(f"파일 '{filename}'에서 처리할 내용이 없거나 지원되지 않는 형식입니다.")
-                # 파일은 저장되었으므로 성공으로 간주할지 결정 필요
+                logger.warning(f"?�일 '{filename}'?�서 처리???�용???�거??지?�되지 ?�는 ?�식?�니??")
+                # ?�일?� ?�?�되?�으므�??�공?�로 간주?��? 결정 ?�요
                 return jsonify({
                     "warning": True,
-                    "message": f"파일 '{filename}'이 저장되었지만 처리할 내용이 없습니다."
+                    "message": f"?�일 '{filename}'???�?�되?��?�?처리???�용???�습?�다."
                 })
 
         except Exception as e:
-            logger.error(f"파일 업로드 또는 처리 중 오류 발생: {e}", exc_info=True)
-            return jsonify({"error": f"파일 업로드 중 오류: {str(e)}"}), 500
+            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"""
-        if not app_ready or base_retriever is None:
-            return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503
+        """지?�베?�스 문서 목록 API"""
+        if base_retriever is None:
+            return jsonify({"error": "??기본 검?�기가 ?�직 초기??중입?�다."}), 503
 
         try:
             sources = {}
             total_chunks = 0
-            # base_retriever.documents 와 같은 속성이 실제 클래스에 있다고 가정
-            if hasattr(base_retriever, 'documents') and base_retriever.documents:
-                logger.info(f"총 {len(base_retriever.documents)}개 문서 청크에서 소스 목록 생성 중...")
+            # base_retriever.documents ?� 같�? ?�성???�제 ?�래?�에 ?�다�?가??            if hasattr(base_retriever, 'documents') and base_retriever.documents:
+                logger.info(f"�?{len(base_retriever.documents)}�?문서 �?��?�서 ?�스 목록 ?�성 �?..")
                 for doc in base_retriever.documents:
-                    # 문서 청크가 딕셔너리 형태라고 가정
-                    if not isinstance(doc, dict): continue
+                    # 문서 �?��가 ?�셔?�리 ?�태?�고 가??                    if not isinstance(doc, dict): continue
 
-                    source = doc.get("source", "unknown") # 메타데이터에서 source 가져오기
-                    if source == "unknown" and "metadata" in doc and isinstance(doc["metadata"], dict):
+                    source = doc.get("source", "unknown") # 메�??�이?�에??source 가?�오�?                    if source == "unknown" and "metadata" in doc and isinstance(doc["metadata"], dict):
                         source = doc["metadata"].get("source", "unknown") # Langchain Document 구조 고려
 
                     if source != "unknown":
                         if source in sources:
                             sources[source]["chunks"] += 1
                         else:
-                            # 메타데이터에서 추가 정보 가져오기
-                            filename = doc.get("filename", source)
+                            # 메�??�이?�에??추�? ?�보 가?�오�?                            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)
@@ -549,13 +534,13 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
                             }
                     total_chunks += 1
             else:
-                logger.info("검색기에 문서가 없거나 documents 속성을 찾을 수 없습니다.")
+                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}개 청크")
+            logger.info(f"문서 목록 조회 ?�료: {len(documents)}�??�스 ?�일, {total_chunks}�?�?��")
             return jsonify({
                 "documents": documents,
                 "total_documents": len(documents),
@@ -563,5 +548,5 @@ def register_routes(app, login_required, llm_interface, retriever, stt_client, D
             })
 
         except Exception as e:
-            logger.error(f"문서 목록 조회 중 오류 발생: {e}", exc_info=True)
-            return jsonify({"error": f"문서 목록 조회 중 오류: {str(e)}"}), 500
+            logger.error(f"문서 목록 조회 �??�류 발생: {e}", exc_info=True)
+            return jsonify({"error": f"문서 목록 조회 �??�류: {str(e)}"}), 500

app/static/js/app-device.js

@@ -1,8 +1,8 @@
 /**
- * RAG 검색 챗봇 장치 관리 JavaScript
+ * RAG 검??챗봇 ?�치 관�?JavaScript
  */
 
-// DOM 요소
+// DOM ?�소
 const deviceTab = document.getElementById('deviceTab');
 const deviceSection = document.getElementById('deviceSection');
 const checkDeviceStatusButton = document.getElementById('checkDeviceStatusButton');
@@ -19,118 +19,110 @@ const programsLoading = document.getElementById('programsLoading');
 const programsList = document.getElementById('programsList');
 const noProgramsMessage = document.getElementById('noProgramsMessage');
 
-// 장치 서버 URL 설정
-// 직접 접근 설정: 빈 문자열이면 현재 호스트의 5051 포트를 사용
-let DEVICE_SERVER_URL = ''; // 서버에서 전달된 URL이 있으면 초기화 시 설정됨
-
+// ?�치 ?�버 URL ?�정
+// 직접 ?�근 ?�정: �?문자?�이�??�재 ?�스?�의 5051 ?�트�??�용
+let DEVICE_SERVER_URL = ''; // ?�버?�서 ?�달??URL???�으�?초기?????�정??
 /**
- * 장치 서버 API 경로 생성 함수
- * @param {string} endpoint - API 엔드포인트 경로
- * @returns {string} - 완전한 API URL
+ * ?�치 ?�버 API 경로 ?�성 ?�수
+ * @param {string} endpoint - API ?�드?�인??경로
+ * @returns {string} - ?�전??API URL
  */
 function getDeviceApiUrl(endpoint) {
-    // 직접 접근 모드인 경우 (별도 서버에 직접 요청)
+    // 직접 ?�근 모드??경우 (별도 ?�버??직접 ?�청)
     if (DEVICE_SERVER_URL) {
         return `${DEVICE_SERVER_URL}${endpoint}`;
     }
     
-    // 프록시 모드인 경우 (내부 API 경로 사용)
+    // ?�록??모드??경우 (?��? API 경로 ?�용)
     return endpoint;
 }
 
 /**
- * 장치 서버 설정 초기화 (페이지 로드 시 호출)
+ * ?�치 ?�버 ?�정 초기??(?�이지 로드 ???�출)
  */
 function initDeviceServerSettings() {
-    console.log("장치 서버 설정 초기화 시작");
-    // 서버 URL 설정 (웹 서버로부터 설정 불러오기)
+    console.log("?�치 ?�버 ?�정 초기???�작");
+    // ?�버 URL ?�정 (???�버로�????�정 불러?�기)
     fetch('/api/device/settings')
         .then(response => {
             if (!response.ok) {
-                throw new Error('설정을 가져올 수 없습니다');
+                throw new Error('?�정??가?�올 ???�습?�다');
             }
             return response.json();
         })
         .then(data => {
             if (data.server_url) {
-                console.log(`장치 서버 URL 설정됨: ${data.server_url}`);
+                console.log(`?�치 ?�버 URL ?�정?? ${data.server_url}`);
                 DEVICE_SERVER_URL = data.server_url;
             } else {
-                // 설정 없음 - 자동 생성 (현재 호스트 + 포트 5051)
+                // ?�정 ?�음 - ?�동 ?�성 (?�재 ?�스??+ ?�트 5051)
                 const currentHost = window.location.hostname;
                 const protocol = window.location.protocol;
                 DEVICE_SERVER_URL = `${protocol}//${currentHost}:5051`;
-                console.log(`장치 서버 URL 자동 설정: ${DEVICE_SERVER_URL}`);
+                console.log(`?�치 ?�버 URL ?�동 ?�정: ${DEVICE_SERVER_URL}`);
             }
         })
         .catch(error => {
-            console.error('장치 서버 설정 초기화 오류:', error);
-            // 기본값으로 설정 (현재 호스트 + 포트 5051)
+            console.error('?�치 ?�버 ?�정 초기???�류:', error);
+            // 기본값으�??�정 (?�재 ?�스??+ ?�트 5051)
             const currentHost = window.location.hostname;
             const protocol = window.location.protocol;
             DEVICE_SERVER_URL = `${protocol}//${currentHost}:5051`;
-            console.log(`장치 서버 URL 기본값 설정: ${DEVICE_SERVER_URL}`);
+            console.log(`?�치 ?�버 URL 기본�??�정: ${DEVICE_SERVER_URL}`);
         });
 }
 
-// 페이지 로드 시 초기화
-document.addEventListener('DOMContentLoaded', () => {
-    console.log("장치 관리 모듈 초기화");
+// ?�이지 로드 ??초기??document.addEventListener('DOMContentLoaded', () => {
+    console.log("?�치 관�?모듈 초기??);
     
-    // 장치 서버 설정 초기화
-    initDeviceServerSettings();
+    // ?�치 ?�버 ?�정 초기??    initDeviceServerSettings();
     
-    // 탭 전환 이벤트 리스너는 이미 app.js에서 등록되어 있으므로 여기서는 등록하지 않음
-    // 대신 전역 함수가 올바르게 설정되어 있는지 확인
+    // ???�환 ?�벤??리스?�는 ?��? app.js?�서 ?�록?�어 ?�으므�??�기?�는 ?�록?��? ?�음
+    // ?�???�역 ?�수가 ?�바르게 ?�정?�어 ?�는지 ?�인
     if (typeof window.switchTab !== 'function') {
-        console.log("window.switchTab 함수가 정의되지 않았습니다. 내부 구현을 사용합니다.");
+        console.log("window.switchTab ?�수가 ?�의?��? ?�았?�니?? ?��? 구현???�용?�니??");
     } else {
-        console.log("window.switchTab 함수 사용 가능합니다.");
+        console.log("window.switchTab ?�수 ?�용 가?�합?�다.");
     }
     
-    // 장치 상태 확인 버튼 이벤트 리스너
-    checkDeviceStatusButton.addEventListener('click', () => {
-        console.log("장치 상태 확인 버튼 클릭");
+    // ?�치 ?�태 ?�인 버튼 ?�벤??리스??    checkDeviceStatusButton.addEventListener('click', () => {
+        console.log("?�치 ?�태 ?�인 버튼 ?�릭");
         checkDeviceStatus();
     });
     
-    // 장치 목록 새로고침 버튼 이벤트 리스너
-    refreshDevicesButton.addEventListener('click', () => {
-        console.log("장치 목록 새로고침 버튼 클릭");
+    // ?�치 목록 ?�로고침 버튼 ?�벤??리스??    refreshDevicesButton.addEventListener('click', () => {
+        console.log("?�치 목록 ?�로고침 버튼 ?�릭");
         loadDevices();
     });
     
-    // 프로그램 목록 로드 버튼 이벤트 리스너
-    loadProgramsButton.addEventListener('click', () => {
-        console.log("프로그램 목록 로드 버튼 클릭");
+    // ?�로그램 목록 로드 버튼 ?�벤??리스??    loadProgramsButton.addEventListener('click', () => {
+        console.log("?�로그램 목록 로드 버튼 ?�릭");
         loadPrograms();
     });
 });
 
 /**
- * 에러 처리 헬퍼 함수
- * @param {Error} error - 발생한 오류
- * @returns {string} - 사용자에게 표시할 오류 메시지
+ * ?�러 처리 ?�퍼 ?�수
+ * @param {Error} error - 발생???�류
+ * @returns {string} - ?�용?�에�??�시???�류 메시지
  */
 function handleError(error) {
-    console.error("오류 발생:", error);
+    console.error("?�류 발생:", error);
     
     if (error.name === 'AbortError') {
-        return '요청 시간이 초과되었습니다. 서버가 응답하지 않습니다.';
+        return '?�청 ?�간??초과?�었?�니?? ?�버가 ?�답?��? ?�습?�다.';
     }
     
     if (error.message && (error.message.includes('NetworkError') || error.message.includes('Failed to fetch'))) {
-        return '네트워크 오류가 발생했습니다. 서버에 연결할 수 없습니다.';
+        return '?�트?�크 ?�류가 발생?�습?�다. ?�버???�결?????�습?�다.';
     }
     
-    return `오류가 발생했습니다: ${error.message || '알 수 없는 오류'}`;
+    return `?�류가 발생?�습?�다: ${error.message || '?????�는 ?�류'}`;
 }
 
 /**
- * HTML 이스케이프 함수 (XSS 방지)
- * @param {string} unsafe - 이스케이프 전 문자열
- * @returns {string} - 이스케이프 후 문자열
- */
+ * HTML ?�스케?�프 ?�수 (XSS 방�?)
+ * @param {string} unsafe - ?�스케?�프 ??문자?? * @returns {string} - ?�스케?�프 ??문자?? */
 function escapeHtml(unsafe) {
     if (typeof unsafe !== 'string') return unsafe;
     return unsafe
@@ -142,55 +134,54 @@ function escapeHtml(unsafe) {
 }
 
 /**
- * 장치 관리 서버 상태 확인 함수 - 전역 함수로 export
+ * ?�치 관�??�버 ?�태 ?�인 ?�수 - ?�역 ?�수�?export
  */
 async function checkDeviceStatus() {
-    console.log("장치 상태 확인 중...");
+    console.log("?�치 ?�태 ?�인 �?..");
     
-    // UI 업데이트
+    // UI ?�데?�트
     deviceStatusResult.classList.add('hidden');
     deviceStatusLoading.classList.remove('hidden');
     
     try {
-        // 타임아웃 설정을 위한 컨트롤러
+        // ?�?�아???�정???�한 컨트롤러
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5초 타임아웃
-        
-        // API 요청 - 수정된 URL 구성 사용
+        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5�??�?�아??        
+        // API ?�청 - ?�정??URL 구성 ?�용
         const response = await fetch(getDeviceApiUrl('/api/status'), {
             signal: controller.signal
         });
         
-        clearTimeout(timeoutId); // 타임아웃 해제
+        clearTimeout(timeoutId); // ?�?�아???�제
         
-        // 응답 처리
+        // ?�답 처리
         if (!response.ok) {
-            throw new Error(`HTTP 오류: ${response.status}`);
+            throw new Error(`HTTP ?�류: ${response.status}`);
         }
         
         const data = await response.json();
-        console.log("장치 상태 응답:", data);
+        console.log("?�치 ?�태 ?�답:", data);
         
-        // UI 업데이트
+        // UI ?�데?�트
         deviceStatusLoading.classList.add('hidden');
         deviceStatusResult.classList.remove('hidden');
         
         if (data.status === "online") {
-            // 온라인 상태인 경우
+            // ?�라???�태??경우
             statusIcon.innerHTML = '<i class="fas fa-circle online"></i>';
-            statusText.textContent = `서버 상태: ${data.status || '정상'}`;
+            statusText.textContent = `?�버 ?�태: ${data.status || '?�상'}`;
             
-            // 자동으로 장치 목록 로드
+            // ?�동?�로 ?�치 목록 로드
             loadDevices();
         } else {
-            // 오프라인 또는 오류 상태인 경우
+            // ?�프?�인 ?�는 ?�류 ?�태??경우
             statusIcon.innerHTML = '<i class="fas fa-circle offline"></i>';
-            statusText.textContent = `서버 오류: ${data.error || '알 수 없는 오류'}`;
+            statusText.textContent = `?�버 ?�류: ${data.error || '?????�는 ?�류'}`;
         }
     } catch (error) {
-        console.error("장치 상태 확인 오류:", error);
+        console.error("?�치 ?�태 ?�인 ?�류:", error);
         
-        // UI 업데이트
+        // UI ?�데?�트
         deviceStatusLoading.classList.add('hidden');
         deviceStatusResult.classList.remove('hidden');
         
@@ -200,53 +191,52 @@ async function checkDeviceStatus() {
 }
 
 /**
- * 장치 목록 로드 함수
+ * ?�치 목록 로드 ?�수
  */
 async function loadDevices() {
-    console.log("장치 목록 로드 중...");
+    console.log("?�치 목록 로드 �?..");
     
-    // UI 업데이트
+    // UI ?�데?�트
     deviceList.innerHTML = '';
     noDevicesMessage.classList.add('hidden');
     devicesLoading.classList.remove('hidden');
     
     try {
-        // 타임아웃 설정을 위한 컨트롤러
+        // ?�?�아???�정???�한 컨트롤러
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5초 타임아웃
-        
-        // API 요청 - 수정된 URL 구성 사용
+        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5�??�?�아??        
+        // API ?�청 - ?�정??URL 구성 ?�용
         const response = await fetch(getDeviceApiUrl('/api/devices'), {
             signal: controller.signal
         });
         
-        clearTimeout(timeoutId); // 타임아웃 해제
+        clearTimeout(timeoutId); // ?�?�아???�제
         
-        // 응답 처리
+        // ?�답 처리
         if (!response.ok) {
-            throw new Error(`HTTP 오류: ${response.status}`);
+            throw new Error(`HTTP ?�류: ${response.status}`);
         }
         
         const data = await response.json();
-        console.log("장치 목록 응답:", data);
+        console.log("?�치 목록 ?�답:", data);
         
-        // UI 업데이트
+        // UI ?�데?�트
         devicesLoading.classList.add('hidden');
         
         if (data.devices && data.devices.length > 0) {
-            // 장치 목록 표시
+            // ?�치 목록 ?�시
             data.devices.forEach(device => {
                 const deviceElement = createDeviceItem(device);
                 deviceList.appendChild(deviceElement);
             });
         } else {
-            // 장치 없음 메시지 표시
+            // ?�치 ?�음 메시지 ?�시
             noDevicesMessage.classList.remove('hidden');
         }
     } catch (error) {
-        console.error("장치 목록 로드 오류:", error);
+        console.error("?�치 목록 로드 ?�류:", error);
         
-        // UI 업데이트
+        // UI ?�데?�트
         devicesLoading.classList.add('hidden');
         noDevicesMessage.classList.remove('hidden');
         noDevicesMessage.textContent = handleError(error);
@@ -254,61 +244,61 @@ async function loadDevices() {
 }
 
 /**
- * 장치 아이템 생성 함수
- * @param {Object} device - 장치 정보 객체
- * @returns {HTMLElement} - 장치 아이템 DOM 요소
+ * ?�치 ?�이???�성 ?�수
+ * @param {Object} device - ?�치 ?�보 객체
+ * @returns {HTMLElement} - ?�치 ?�이??DOM ?�소
  */
 function createDeviceItem(device) {
     const deviceItem = document.createElement('div');
     deviceItem.classList.add('device-item');
     
-    // 상태에 따른 클래스 추가
-    if (device.status === 'online' || device.status === '온라인') {
+    // ?�태???�른 ?�래??추�?
+    if (device.status === 'online' || device.status === '?�라??) {
         deviceItem.classList.add('online');
-    } else if (device.status === 'offline' || device.status === '오프라인') {
+    } else if (device.status === 'offline' || device.status === '?�프?�인') {
         deviceItem.classList.add('offline');
     } else if (device.status === 'warning' || device.status === '경고') {
         deviceItem.classList.add('warning');
     }
     
-    // 장치 헤더 (이름 및 상태)
+    // ?�치 ?�더 (?�름 �??�태)
     const deviceHeader = document.createElement('div');
     deviceHeader.classList.add('device-item-header');
     
     const deviceName = document.createElement('div');
     deviceName.classList.add('device-name');
-    deviceName.textContent = device.name || '알 수 없는 장치';
+    deviceName.textContent = device.name || '?????�는 ?�치';
     
     const deviceStatusBadge = document.createElement('div');
     deviceStatusBadge.classList.add('device-status-badge');
     
-    // 상태에 따른 배지 설정
-    if (device.status === 'online' || device.status === '온라인') {
+    // ?�태???�른 배�? ?�정
+    if (device.status === 'online' || device.status === '?�라??) {
         deviceStatusBadge.classList.add('online');
-        deviceStatusBadge.textContent = '온라인';
-    } else if (device.status === 'offline' || device.status === '오프라인') {
+        deviceStatusBadge.textContent = '?�라??;
+    } else if (device.status === 'offline' || device.status === '?�프?�인') {
         deviceStatusBadge.classList.add('offline');
-        deviceStatusBadge.textContent = '오프라인';
+        deviceStatusBadge.textContent = '?�프?�인';
     } else if (device.status === 'warning' || device.status === '경고') {
         deviceStatusBadge.classList.add('warning');
         deviceStatusBadge.textContent = '경고';
     } else {
-        deviceStatusBadge.textContent = device.status || '알 수 없음';
+        deviceStatusBadge.textContent = device.status || '?????�음';
     }
     
     deviceHeader.appendChild(deviceName);
     deviceHeader.appendChild(deviceStatusBadge);
     
-    // 장치 정보
+    // ?�치 ?�보
     const deviceInfo = document.createElement('div');
     deviceInfo.classList.add('device-info');
-    deviceInfo.textContent = `유형: ${device.type || '알 수 없음'}`;
+    deviceInfo.textContent = `?�형: ${device.type || '?????�음'}`;
     
-    // 장치 세부 정보
+    // ?�치 ?��? ?�보
     const deviceDetails = document.createElement('div');
     deviceDetails.classList.add('device-details');
     
-    // 추가 정보가 있는 경우 표시
+    // 추�? ?�보가 ?�는 경우 ?�시
     if (device.ip) {
         deviceDetails.textContent += `IP: ${device.ip}`;
     }
@@ -316,10 +306,10 @@ function createDeviceItem(device) {
         deviceDetails.textContent += (deviceDetails.textContent ? ', ' : '') + `MAC: ${device.mac}`;
     }
     if (device.lastSeen) {
-        deviceDetails.textContent += (deviceDetails.textContent ? ', ' : '') + `마지막 활동: ${device.lastSeen}`;
+        deviceDetails.textContent += (deviceDetails.textContent ? ', ' : '') + `마�?�??�동: ${device.lastSeen}`;
     }
     
-    // 아이템에 요소 추가
+    // ?�이?�에 ?�소 추�?
     deviceItem.appendChild(deviceHeader);
     deviceItem.appendChild(deviceInfo);
     
@@ -331,53 +321,52 @@ function createDeviceItem(device) {
 }
 
 /**
- * 프로그램 목록 로드 함수
+ * ?�로그램 목록 로드 ?�수
  */
 async function loadPrograms() {
-    console.log("프로그램 목록 로드 중...");
+    console.log("?�로그램 목록 로드 �?..");
     
-    // UI 업데이트
+    // UI ?�데?�트
     programsList.innerHTML = '';
     noProgramsMessage.classList.add('hidden');
     programsLoading.classList.remove('hidden');
     
     try {
-        // 타임아웃 설정을 위한 컨트롤러
+        // ?�?�아???�정???�한 컨트롤러
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5초 타임아웃
-        
-        // API 요청 - 수정된 URL 구성 사용
+        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5�??�?�아??        
+        // API ?�청 - ?�정??URL 구성 ?�용
         const response = await fetch(getDeviceApiUrl('/api/programs'), {
             signal: controller.signal
         });
         
-        clearTimeout(timeoutId); // 타임아웃 해제
+        clearTimeout(timeoutId); // ?�?�아???�제
         
-        // 응답 처리
+        // ?�답 처리
         if (!response.ok) {
-            throw new Error(`HTTP 오류: ${response.status}`);
+            throw new Error(`HTTP ?�류: ${response.status}`);
         }
         
         const data = await response.json();
-        console.log("프로그램 목록 응답:", data);
+        console.log("?�로그램 목록 ?�답:", data);
         
-        // UI 업데이트
+        // UI ?�데?�트
         programsLoading.classList.add('hidden');
         
         if (data.programs && data.programs.length > 0) {
-            // 프로그램 목록 표시
+            // ?�로그램 목록 ?�시
             data.programs.forEach(program => {
                 const programElement = createProgramItem(program);
                 programsList.appendChild(programElement);
             });
         } else {
-            // 프로그램 없음 메시지 표시
+            // ?�로그램 ?�음 메시지 ?�시
             noProgramsMessage.classList.remove('hidden');
         }
     } catch (error) {
-        console.error("프로그램 목록 로드 오류:", error);
+        console.error("?�로그램 목록 로드 ?�류:", error);
         
-        // UI 업데이트
+        // UI ?�데?�트
         programsLoading.classList.add('hidden');
         noProgramsMessage.classList.remove('hidden');
         noProgramsMessage.textContent = handleError(error);
@@ -385,25 +374,25 @@ async function loadPrograms() {
 }
 
 /**
- * 프로그램 아이템 생성 함수
- * @param {Object} program - 프로그램 정보 객체
- * @returns {HTMLElement} - 프로그램 아이템 DOM 요소
+ * ?�로그램 ?�이???�성 ?�수
+ * @param {Object} program - ?�로그램 ?�보 객체
+ * @returns {HTMLElement} - ?�로그램 ?�이??DOM ?�소
  */
 function createProgramItem(program) {
     const programItem = document.createElement('div');
     programItem.classList.add('program-item');
     
-    // 프로그램 헤더 (이름)
+    // ?�로그램 ?�더 (?�름)
     const programHeader = document.createElement('div');
     programHeader.classList.add('program-item-header');
     
     const programName = document.createElement('div');
     programName.classList.add('program-name');
-    programName.textContent = program.name || '알 수 없는 프로그램';
+    programName.textContent = program.name || '?????�는 ?�로그램';
     
     programHeader.appendChild(programName);
     
-    // 프로그램 설명
+    // ?�로그램 ?�명
     if (program.description) {
         const programDescription = document.createElement('div');
         programDescription.classList.add('program-description');
@@ -411,15 +400,15 @@ function createProgramItem(program) {
         programItem.appendChild(programDescription);
     }
     
-    // 실행 버튼
+    // ?�행 버튼
     const executeButton = document.createElement('button');
     executeButton.classList.add('execute-btn');
-    executeButton.textContent = '실행';
+    executeButton.textContent = '?�행';
     executeButton.addEventListener('click', () => {
         executeProgram(program.id, program.name);
     });
     
-    // 아이템에 요소 추가
+    // ?�이?�에 ?�소 추�?
     programItem.appendChild(programHeader);
     programItem.appendChild(executeButton);
     
@@ -427,72 +416,72 @@ function createProgramItem(program) {
 }
 
 /**
- * 프로그램 실행 함수
- * @param {string} programId - 실행할 프로그램 ID
- * @param {string} programName - 프로그램 이름 (알림용)
+ * ?�로그램 ?�행 ?�수
+ * @param {string} programId - ?�행???�로그램 ID
+ * @param {string} programName - ?�로그램 ?�름 (?�림??
  */
 async function executeProgram(programId, programName) {
     if (!programId) return;
     
-    console.log(`프로그램 실행 요청: ${programId} (${programName})`);
+    console.log(`?�로그램 ?�행 ?�청: ${programId} (${programName})`);
     
-    // 실행 확인
-    if (!confirm(`'${programName}' 프로그램을 실행하시겠습니까?`)) {
-        console.log('프로그램 실행 취소됨');
+    // ?�행 ?�인
+    if (!confirm(`'${programName}' ?�로그램???�행?�시겠습?�까?`)) {
+        console.log('?�로그램 ?�행 취소??);
         return;
     }
     
     try {
-        // 로딩 알림 표시
-        showNotification(`'${programName}' 실행 중...`, 'info');
+        // 로딩 ?�림 ?�시
+        showNotification(`'${programName}' ?�행 �?..`, 'info');
         
-        // API 요청 - 수정된 URL 구성 사용
+        // API ?�청 - ?�정??URL 구성 ?�용
         const response = await fetch(getDeviceApiUrl(`/api/programs/${programId}/execute`), {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json'
             },
-            body: JSON.stringify({}) // 필요 시 추가 파라미터 전달
+            body: JSON.stringify({}) // ?�요 ??추�? ?�라미터 ?�달
         });
         
-        // 응답 처리
+        // ?�답 처리
         if (!response.ok) {
-            throw new Error(`HTTP 오류: ${response.status}`);
+            throw new Error(`HTTP ?�류: ${response.status}`);
         }
         
         const data = await response.json();
-        console.log(`프로그램 실행 응답:`, data);
+        console.log(`?�로그램 ?�행 ?�답:`, data);
         
         // 결과 처리
         if (data.success) {
-            showNotification(`'${programName}' 실행 성공: ${data.message}`, 'success');
+            showNotification(`'${programName}' ?�행 ?�공: ${data.message}`, 'success');
         } else {
-            showNotification(`'${programName}' 실행 실패: ${data.message || '알 수 없는 오류'}`, 'error');
+            showNotification(`'${programName}' ?�행 ?�패: ${data.message || '?????�는 ?�류'}`, 'error');
         }
     } catch (error) {
-        console.error(`프로그램 실행 오류 (${programId}):`, error);
-        showNotification(`'${programName}' 실행 오류: ${handleError(error)}`, 'error');
+        console.error(`?�로그램 ?�행 ?�류 (${programId}):`, error);
+        showNotification(`'${programName}' ?�행 ?�류: ${handleError(error)}`, 'error');
     }
 }
 
 /**
- * 알림 표시 함수
- * @param {string} message - 알림 메시지
- * @param {string} type - 알림 유형 ('success', 'error', 'warning')
+ * ?�림 ?�시 ?�수
+ * @param {string} message - ?�림 메시지
+ * @param {string} type - ?�림 ?�형 ('success', 'error', 'warning')
  */
 function showNotification(message, type = 'info') {
-    // 기존 알림이 있으면 제거
+    // 기존 ?�림???�으�??�거
     const existingNotification = document.querySelector('.notification');
     if (existingNotification) {
         existingNotification.remove();
     }
     
-    // 새 알림 생성
+    // ???�림 ?�성
     const notification = document.createElement('div');
     notification.classList.add('notification', type);
     notification.textContent = message;
     
-    // 알림 닫기 버튼
+    // ?�림 ?�기 버튼
     const closeButton = document.createElement('button');
     closeButton.classList.add('notification-close');
     closeButton.innerHTML = '&times;';
@@ -502,16 +491,15 @@ function showNotification(message, type = 'info') {
     
     notification.appendChild(closeButton);
     
-    // 문서에 알림 추가
+    // 문서???�림 추�?
     document.body.appendChild(notification);
     
-    // 일정 시간 후 자동으로 사라지도록 설정
+    // ?�정 ?�간 ???�동?�로 ?�라지?�록 ?�정
     setTimeout(() => {
         if (document.body.contains(notification)) {
             notification.remove();
         }
-    }, 5000); // 5초 후 사라짐
-}
+    }, 5000); // 5�????�라�?}
 
-// checkDeviceStatus 함수를 전역으로 노출
-window.checkDeviceStatus = checkDeviceStatus;
+// checkDeviceStatus ?�수�??�역?�로 ?�출
+window.checkDeviceStatus = checkDeviceStatus;