Add greeting function to app.py

.gitignore

@@ -23,7 +23,7 @@ var/
 *.egg
 
 # 폴더
-documents/
+!documents/
 faiss_index/
 cached_data/
 preprocessed_index/

RAG4_Voice_Fast

@@ -0,0 +1 @@
+Subproject commit 1f59ca46087f51b255eebf8f37d21083256683fe

app.py

@@ -14,13 +14,14 @@ from pathlib import Path
 from langchain.schema import Document
 
 from config import (
-    PDF_DIRECTORY, CACHE_DIRECTORY, CHUNK_SIZE, CHUNK_OVERLAP, 
+    PDF_DIRECTORY, CACHE_DIRECTORY, CHUNK_SIZE, CHUNK_OVERLAP,
     LLM_MODEL, LOG_LEVEL, LOG_FILE, print_config, validate_config
 )
 from optimized_document_processor import OptimizedDocumentProcessor
 from vector_store import VectorStore
 
 import sys
+
 print("===== Script starting =====")
 sys.stdout.flush()  # 즉시 출력 강제
 
@@ -31,40 +32,42 @@ sys.stdout.flush()
 print("Config loaded!")
 sys.stdout.flush()
 
+
 # 로깅 설정 개선
 def setup_logging():
     """애플리케이션 로깅 설정"""
     # 로그 레벨 설정
     log_level = getattr(logging, LOG_LEVEL.upper(), logging.INFO)
-    
+
     # 로그 포맷 설정
     log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
     formatter = logging.Formatter(log_format)
-    
+
     # 루트 로거 설정
     root_logger = logging.getLogger()
     root_logger.setLevel(log_level)
-    
+
     # 핸들러 초기화
     # 콘솔 핸들러
     console_handler = logging.StreamHandler()
     console_handler.setFormatter(formatter)
     root_logger.addHandler(console_handler)
-    
+
     # 파일 핸들러 (회전식)
     try:
         file_handler = RotatingFileHandler(
-            LOG_FILE, 
-            maxBytes=10*1024*1024,  # 10 MB
+            LOG_FILE,
+            maxBytes=10 * 1024 * 1024,  # 10 MB
             backupCount=5
         )
         file_handler.setFormatter(formatter)
         root_logger.addHandler(file_handler)
     except Exception as e:
         console_handler.warning(f"로그 파일 설정 실패: {e}, 콘솔 로깅만 사용합니다.")
-    
+
     return logging.getLogger("AutoRAG")
 
+
 # 로거 설정
 logger = setup_logging()
 
@@ -99,12 +102,10 @@ if config_status["status"] != "valid":
     for warning in config_status["warnings"]:
         logger.warning(f"설정 경고: {warning}")
 
-
-
-
 # 안전한 임포트
 try:
     from rag_chain import RAGChain
+
     RAG_CHAIN_AVAILABLE = True
     print("RAG 체인 모듈 로드 성공!")
 except ImportError as e:
@@ -117,6 +118,7 @@ except Exception as e:
 # 폴백 RAG 관련 모듈도 미리 확인
 try:
     from fallback_rag_chain import FallbackRAGChain
+
     FALLBACK_AVAILABLE = True
     print("폴백 RAG 체인 모듈 로드 성공!")
 except ImportError as e:
@@ -125,6 +127,7 @@ except ImportError as e:
 
 try:
     from offline_fallback_rag import OfflineFallbackRAG
+
     OFFLINE_FALLBACK_AVAILABLE = True
     print("오프라인 폴백 RAG 모듈 로드 성공!")
 except ImportError as e:
@@ -163,7 +166,7 @@ class AutoRAGChatApp:
         """
         try:
             logger.info("AutoRAGChatApp 초기화 시작")
-            
+
             # 데이터 디렉토리 정의 (설정에서 가져옴)
             # 절대 경로로 변환하여 사용
             self.pdf_directory = os.path.abspath(PDF_DIRECTORY)
@@ -173,10 +176,10 @@ class AutoRAGChatApp:
             self.vector_index_dir = os.path.join(self.cache_directory, "vector_index")
 
             logger.info(f"설정된 PDF 디렉토리 (절대 경로): {self.pdf_directory}")
-            
+
             # 디렉토리 검증
             self._verify_pdf_directory()
-            
+
             # 디렉토리 생성
             self._ensure_directories_exist()
 
@@ -211,9 +214,9 @@ class AutoRAGChatApp:
             # 시작 시 자동으로 문서 로드 및 처리
             logger.info("문서 자동 로드 및 처리 시작...")
             self.auto_process_documents()
-            
+
             logger.info("AutoRAGChatApp 초기화 완료")
-            
+
         except Exception as e:
             logger.critical(f"애플리케이션 초기화 중 심각한 오류: {e}", exc_info=True)
             # 기본 상태 설정으로 최소한의 기능 유지
@@ -233,7 +236,7 @@ class AutoRAGChatApp:
             self.chunks_dir,
             self.vector_index_dir
         ]
-        
+
         for directory in directories:
             try:
                 os.makedirs(directory, exist_ok=True)
@@ -254,7 +257,7 @@ class AutoRAGChatApp:
         if not os.path.exists(file_path):
             logger.error(f"파일이 존재하지 않음: {file_path}")
             raise FileNotFoundError(f"파일이 존재하지 않음: {file_path}")
-            
+
         try:
             logger.info(f"docling으로 처리 시도: {file_path}")
 
@@ -287,14 +290,14 @@ class AutoRAGChatApp:
             except TimeoutError as te:
                 logger.warning(f"docling 처리 시간 초과: {te}")
                 logger.info("PyPDFLoader로 대체합니다.")
-                
+
                 # PyPDFLoader로 대체
                 try:
                     return self.document_processor.process_pdf(file_path, use_docling=False)
                 except Exception as inner_e:
                     logger.error(f"PyPDFLoader 처리 오류: {inner_e}", exc_info=True)
                     raise DocumentProcessingError(f"PDF 로딩 실패 (PyPDFLoader): {str(inner_e)}")
-                
+
             except Exception as e:
                 # docling 오류 확인
                 error_str = str(e)
@@ -366,7 +369,7 @@ class AutoRAGChatApp:
         if not os.path.exists(file_path):
             logger.error(f"해시 계산 실패 - 파일이 존재하지 않음: {file_path}")
             raise FileNotFoundError(f"파일이 존재하지 않음: {file_path}")
-            
+
         try:
             hasher = hashlib.md5()
             with open(file_path, 'rb') as f:
@@ -393,7 +396,7 @@ class AutoRAGChatApp:
         if not os.path.exists(file_path):
             logger.warning(f"파일이 존재하지 않음: {file_path}")
             return False
-            
+
         # 인덱스에 파일 존재 여부 확인
         if file_path not in self.file_index:
             return False
@@ -480,13 +483,13 @@ class AutoRAGChatApp:
         if file_path not in self.file_index:
             logger.error(f"인덱스에 파일이 존재하지 않음: {file_path}")
             raise KeyError(f"인덱스에 파일이 존재하지 않음: {file_path}")
-            
+
         chunks_path = self.file_index[file_path]['chunks_path']
-        
+
         if not os.path.exists(chunks_path):
             logger.error(f"청크 파일이 존재하지 않음: {chunks_path}")
             raise FileNotFoundError(f"청크 파일이 존재하지 않음: {chunks_path}")
-            
+
         try:
             with open(chunks_path, 'rb') as f:
                 chunks = pickle.load(f)
@@ -511,15 +514,15 @@ class AutoRAGChatApp:
                 except Exception as e:
                     logger.error(f"PDF 디렉토리 생성 실패: {e}")
                     raise
-            
+
             # 디렉토리인지 확인
             if not os.path.isdir(self.pdf_directory):
                 logger.error(f"PDF 경로가 디렉토리가 아닙니다: {self.pdf_directory}")
                 raise ConfigurationError(f"PDF 경로가 디렉토리가 아닙니다: {self.pdf_directory}")
-            
+
             # PDF 파일 존재 확인
             pdf_files = [f for f in os.listdir(self.pdf_directory) if f.lower().endswith('.pdf')]
-            
+
             if pdf_files:
                 logger.info(f"PDF 디렉토리에서 {len(pdf_files)}개의 PDF 파일을 찾았습니다: {pdf_files}")
             else:
@@ -530,7 +533,7 @@ class AutoRAGChatApp:
                     "documents",
                     os.path.join(os.getcwd(), "documents")
                 ]
-                
+
                 found_pdfs = False
                 for alt_path in alternative_paths:
                     if os.path.exists(alt_path) and os.path.isdir(alt_path):
@@ -540,11 +543,11 @@ class AutoRAGChatApp:
                             self.pdf_directory = os.path.abspath(alt_path)
                             found_pdfs = True
                             break
-                
+
                 if not found_pdfs:
                     logger.warning(f"PDF 디렉토리에 PDF 파일이 없습니다: {self.pdf_directory}")
                     logger.info("PDF 파일을 디렉토리에 추가해주세요.")
-        
+
         except Exception as e:
             logger.error(f"PDF 디렉토리 검증 중 오류: {e}", exc_info=True)
             raise
@@ -757,7 +760,7 @@ class AutoRAGChatApp:
     def _process_vector_index(self, new_files: List[str], updated_files: List[str]) -> None:
         """
         벡터 인덱스 처리
-        
+
         Args:
             new_files: 새로 추가된 파일 목록
             updated_files: 업데이트된 파일 목록
@@ -1118,36 +1121,32 @@ class AutoRAGChatApp:
             logger.error("Gradio 라이브러리를 찾을 수 없습니다. pip install gradio로 설치하세요.")
             print("Gradio 라이브러리를 찾을 수 없습니다. pip install gradio로 설치하세요.")
             return
-        # 내부 함수들이 현재 인스턴스(self)에 접근할 수 있도록 클로저 변수로 정의
+
         app_instance = self
         try:
             with gr.Blocks(title="PDF 문서 기반 RAG 챗봇") as app:
                 gr.Markdown("# PDF 문서 기반 RAG 챗봇")
                 gr.Markdown(f"* 사용 중인 LLM 모델: **{LLM_MODEL}**")
 
-                # 여기를 수정: 실제 경로 표시
-                actual_pdf_dir = self.pdf_directory.replace('\\', '\\\\') if os.name == 'nt' else self.pdf_directory
+                actual_pdf_dir = (
+                    self.pdf_directory.replace("\\", "\\\\")
+                    if os.name == 'nt' else self.pdf_directory
+                )
                 gr.Markdown(f"* PDF 문서 폴더: **{actual_pdf_dir}**")
+
                 with gr.Row():
                     with gr.Column(scale=1):
-                        # 문서 상태 섹션
                         status_box = gr.Textbox(
                             label="문서 처리 상태",
                             value=self._get_status_message(),
                             lines=5,
                             interactive=False
                         )
-
-                        # 캐시 관리 버튼
                         refresh_button = gr.Button("문서 새로 읽기", variant="primary")
                         reset_button = gr.Button("캐시 초기화", variant="stop")
-
-                        # 상태 및 오류 표시
                         status_info = gr.Markdown(
                             value=f"시스템 상태: {'초기화됨' if self.is_initialized else '초기화되지 않음'}"
                         )
-
-                        # 처리된 파일 정보
                         with gr.Accordion("캐시 세부 정보", open=False):
                             cache_info = gr.Textbox(
                                 label="캐시된 파일 정보",
@@ -1157,25 +1156,20 @@ class AutoRAGChatApp:
                             )
 
                     with gr.Column(scale=2):
-                        # 채팅 인터페이스
                         chatbot = gr.Chatbot(
                             label="대화 내용",
                             bubble_full_width=False,
                             height=500,
                             show_copy_button=True
                         )
-
-                        # 음성 녹음 UI 추가
                         with gr.Row():
                             with gr.Column(scale=4):
-                                # 질문 입력과 전송 버튼
                                 query_box = gr.Textbox(
                                     label="질문",
                                     placeholder="처리된 문서 내용에 대해 질문하세요...",
                                     lines=2
                                 )
                             with gr.Column(scale=1):
-                                # 음성 녹음 컴포넌트
                                 audio_input = gr.Audio(
                                     sources=["microphone"],
                                     type="numpy",
@@ -1186,153 +1180,118 @@ class AutoRAGChatApp:
                             submit_btn = gr.Button("전송", variant="primary")
                             clear_chat_button = gr.Button("대화 초기화")
 
-                    # 음성 인식 처리 함수
-                    # app.py 내 process_audio 함수 보강
-                    # Gradio 앱 내에 있는 음성 인식 처리 함수 (원본)
-                    def process_audio(audio):
-                        logger.info("음성 인식 처리 시작...")
-                        try:
-                            from clova_stt import ClovaSTT
-                            import numpy as np
-                            import soundfile as sf
-                            import tempfile
-                            import os
-
-                            if audio is None:
-                                return "음성이 녹음되지 않았습니다."
-
-                            # 오디오 데이터를 임시 파일로 저장
-                            sr, y = audio
-                            logger.info(f"오디오 녹음 데이터 수신: 샘플레이트={sr}Hz, 길이={len(y)}샘플")
-                            if len(y) / sr < 1.0:
-                                return "녹음된 음성이 너무 짧습니다. 다시 시도해주세요."
-
-                            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
-                                temp_path = temp_file.name
-                                sf.write(temp_path, y, sr, format="WAV")
-                                logger.info(f"임시 WAV 파일 저장됨: {temp_path}")
-
-                            # 음성 인식 실행
-                            stt_client = ClovaSTT()
-                            with open(temp_path, "rb") as f:
-                                audio_bytes = f.read()
-                            result = stt_client.recognize(audio_bytes)
-
-                            # 임시 파일 삭제
-                            try:
-                                os.unlink(temp_path)
-                                logger.info("임시 오디오 파일 삭제됨")
-                            except Exception as e:
-                                logger.warning(f"임시 파일 삭제 실패: {e}")
-
-                            if result["success"]:
-                                recognized_text = result["text"]
-                                logger.info(f"음성인식 성공: {recognized_text}")
-                                return recognized_text
-                            else:
-                                error_msg = f"음성 인식 실패: {result.get('error', '알 수 없는 오류')}"
-                                logger.error(error_msg)
-                                return error_msg
-
-                        except ImportError as e:
-                            logger.error(f"필요한 라이브러리 누락: {e}")
-                            return "음성인식에 필���한 라이브러리가 설치되지 않았습니다. pip install soundfile numpy requests를 실행해주세요."
-                        except Exception as e:
-                            logger.error(f"음성 처리 중 오류 발생: {e}", exc_info=True)
-                            return f"음성 처리 중 오류 발생: {str(e)}"
-
-                    # 새로 추가할 process_audio_and_submit 함수
-                    def process_audio_and_submit(audio, chat_history):
-                        """
-                        녹음 정지 시 음성 인식 후 자동으로 질문을 처리하는 함수.
-                        입력:
-                          - audio: 녹음 데이터 (gr.Audio의 값)
-                          - chat_history: 현재 대화 기록 (gr.Chatbot의 값)
-                        출력:
-                          - query_box: 빈 문자열 (질문 입력란 초기화)
-                          - chatbot: 업데이트된 대화 기록
-                        """
-                        recognized_text = process_audio(audio)
-
-                        # 음성 인식 결과가 오류 메시지인 경우 그대로 반환
-                        if not recognized_text or recognized_text.startswith("음성 인식 실패") or recognized_text.startswith(
-                                "음성 처리 중 오류"):
-                            return recognized_text, chat_history
-
-                        # 인식된 텍스트를 사용하여 질문 처리
-                        return app_instance.process_query(recognized_text, chat_history)
-
-                    # 기존 update_ui_after_refresh 함수 수정 (self 대신 app_instance 사용)
-                    def update_ui_after_refresh(result):
-                        return (
-                            result,  # 상태 메시지
-                            app_instance._get_status_message(),  # 상태 박스 업데이트
-                            f"시스템 상태: {'초기화됨' if app_instance.is_initialized else '초기화되지 않음'}",  # 상태 정보 업데이트
-                            app_instance._get_cache_info()  # 캐시 정보 업데이트
-                        )
+                # VITO STT용 음성 처리 함수
+                def process_audio(audio):
+                    logger.info("음성 인식 처리 시작...")
+                    try:
+                        from vito_stt import VitoSTT
+                        import soundfile as sf
+                        import tempfile
+                        import os
 
-                    # --- Gradio 이벤트 핸들러 설정 ---
-                    # 예: audio_input 컴포넌트의 stop_recording 이벤트를 아래와 같이 수정
-                    audio_input.stop_recording(
-                        fn=process_audio_and_submit,
-                        inputs=[audio_input, chatbot],
-                        outputs=[query_box, chatbot]
-                    )
+                        if audio is None:
+                            return "음성이 녹음되지 않았습니다."
 
-                    # 음성 인식 결과를 질문 상자에 업데이트
-                    audio_input.stop_recording(
-                        fn=process_audio,
-                        inputs=[audio_input],
-                        outputs=[query_box]
-                    )
+                        sr, y = audio
+                        logger.info(f"오디오 녹음 데이터 수신: 샘플레이트={sr}Hz, 길이={len(y)}샘플")
+                        if len(y) / sr < 1.0:
+                            return "녹음된 음성이 너무 짧습니다. 다시 시도해주세요."
 
-                    # 문서 새로 읽기 버튼
-                    refresh_button.click(
-                        fn=lambda: update_ui_after_refresh(self.auto_process_documents()),
-                        inputs=[],
-                        outputs=[status_box, status_box, status_info, cache_info]
-                    )
+                        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
+                            tmp_path = tmp.name
+                            sf.write(tmp_path, y, sr, format="WAV")
+                            logger.info(f"임시 WAV 파일 저장됨: {tmp_path}")
 
-                    # 캐시 초기화 버튼
-                    def reset_and_process():
-                        reset_result = self.reset_cache()
-                        process_result = self.auto_process_documents()
-                        return update_ui_after_refresh(f"{reset_result}\n\n{process_result}")
+                        vito = VitoSTT()
+                        with open(tmp_path, "rb") as f:
+                            audio_bytes = f.read()
+                        result = vito.transcribe_audio(audio_bytes, language="ko")
 
-                    reset_button.click(
-                        fn=reset_and_process,
-                        inputs=[],
-                        outputs=[status_box, status_box, status_info, cache_info]
-                    )
+                        try:
+                            os.unlink(tmp_path)
+                            logger.info("임시 오디오 파일 삭제됨")
+                        except Exception as e:
+                            logger.warning(f"임시 파일 삭제 실패: {e}")
 
-                    # 전송 버튼 클릭 이벤트
-                    submit_btn.click(
-                        fn=self.process_query,
-                        inputs=[query_box, chatbot],
-                        outputs=[query_box, chatbot]
+                        if result.get("success"):
+                            recognized_text = result.get("text", "")
+                            logger.info(f"음성인식 성공: {recognized_text}")
+                            return recognized_text
+                        else:
+                            error_msg = f"음성 인식 실패: {result.get('error', '알 수 없는 오류')}"
+                            logger.error(error_msg)
+                            return error_msg
+
+                    except ImportError as e:
+                        logger.error(f"필요한 라이브러리 누락: {e}")
+                        return ("음성인식에 필요한 라이브러리가 설치되지 않았습니다. "
+                                "pip install soundfile numpy requests 를 실행해주세요.")
+                    except Exception as e:
+                        logger.error(f"음성 처리 중 오류 발생: {e}", exc_info=True)
+                        return f"음성 처리 중 오류 발생: {str(e)}"
+
+                # 음성 인식 후 자동 질문 처리
+                def process_audio_and_submit(audio, chat_history):
+                    recognized_text = process_audio(audio)
+                    if (not recognized_text
+                        or recognized_text.startswith("음성 인식 실패")
+                        or recognized_text.startswith("음성 처리 중 오류")):
+                        return recognized_text, chat_history
+                    return app_instance.process_query(recognized_text, chat_history)
+
+                def update_ui_after_refresh(result):
+                    return (
+                        result,
+                        app_instance._get_status_message(),
+                        f"시스템 상태: {'초기화됨' if app_instance.is_initialized else '초기화되지 않음'}",
+                        app_instance._get_cache_info()
                     )
 
-                    # 엔터키 입력 이벤트
-                    query_box.submit(
-                        fn=self.process_query,
-                        inputs=[query_box, chatbot],
-                        outputs=[query_box, chatbot]
-                    )
+                # 이벤트 핸들러 바인딩
+                audio_input.stop_recording(
+                    fn=process_audio_and_submit,
+                    inputs=[audio_input, chatbot],
+                    outputs=[query_box, chatbot]
+                )
+                audio_input.stop_recording(
+                    fn=process_audio,
+                    inputs=[audio_input],
+                    outputs=[query_box]
+                )
+                refresh_button.click(
+                    fn=lambda: update_ui_after_refresh(self.auto_process_documents()),
+                    inputs=[],
+                    outputs=[status_box, status_box, status_info, cache_info]
+                )
+                reset_button.click(
+                    fn=lambda: update_ui_after_refresh(
+                        f"{self.reset_cache()}\n\n{self.auto_process_documents()}"
+                    ),
+                    inputs=[],
+                    outputs=[status_box, status_box, status_info, cache_info]
+                )
+                submit_btn.click(
+                    fn=self.process_query,
+                    inputs=[query_box, chatbot],
+                    outputs=[query_box, chatbot]
+                )
+                query_box.submit(
+                    fn=self.process_query,
+                    inputs=[query_box, chatbot],
+                    outputs=[query_box, chatbot]
+                )
+                clear_chat_button.click(
+                    fn=lambda: [],
+                    outputs=[chatbot]
+                )
 
-                    # 대화 초기화 버튼
-                    clear_chat_button.click(
-                        fn=lambda: [],
-                        outputs=[chatbot]
-                    )
+            app.launch(share=False)
 
-                # 앱 실행
-                app.launch(share=False)
         except Exception as e:
             logger.error(f"Gradio 앱 실행 중 오류 발생: {e}", exc_info=True)
             print(f"Gradio 앱 실행 중 오류 발생: {e}")
 
 
-
     def _get_status_message(self) -> str:
         """
         현재 처리 상태 메시지 생성
@@ -1448,7 +1407,6 @@ class AutoRAGChatApp:
         return file_info
 
 
-
 if __name__ == "__main__":
     app = AutoRAGChatApp()
     app.launch_app()

vito_stt.py

@@ -0,0 +1,254 @@
+# -*- 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 = {
+                "diarization": {"use_verification": False},
+                "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)
+            }