Add greeting function to app.py

.gitignore

@@ -0,0 +1,34 @@
+# 환경 변수
+.env
+
+# 캐시 및 임시 파일
+__pycache__/
+*.py[cod]
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# 폴더
+documents/
+faiss_index/
+cached_data/
+preprocessed_index/
+**/__pycache__/
+
+# 프로젝트 특화 파일
+parts_extraction_cache.json
+.venv/

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/RAG3_voice.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.10 (RAG3_voice)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.10 (RAG3_voice)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (RAG3_voice)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/RAG3_voice.iml" filepath="$PROJECT_DIR$/.idea/RAG3_voice.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/RAG3_Voice" vcs="Git" />
+  </component>
+</project>

app.py

@@ -0,0 +1,1454 @@
+"""
+디버깅을 위한 코드 추가 - 경로 관련 문제 해결
+"""
+import os
+import time
+import hashlib
+import pickle
+import json
+import logging
+import glob
+from typing import List, Dict, Tuple, Any, Optional
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from langchain.schema import Document
+
+from config import (
+    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()  # 즉시 출력 강제
+
+# 주요 함수/메서드 호출 전후에도 디버깅 출력 추가
+print("Loading config...")
+sys.stdout.flush()
+# from config import ... 등의 코드
+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
+            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()
+
+# 현재 작업 디렉토리 확인을 위한 디버깅 코드
+current_dir = os.getcwd()
+logger.info(f"현재 작업 디렉토리: {current_dir}")
+
+# 설정된 PDF 디렉토리 확인
+abs_pdf_dir = os.path.abspath(PDF_DIRECTORY)
+logger.info(f"설정된 PDF 디렉토리: {PDF_DIRECTORY}")
+logger.info(f"절대 경로로 변환된 PDF 디렉토리: {abs_pdf_dir}")
+
+# PDF 디렉토리 존재 확인
+if os.path.exists(abs_pdf_dir):
+    logger.info(f"PDF 디렉토리가 존재합니다: {abs_pdf_dir}")
+    # 디렉토리 내용 확인
+    pdf_files = glob.glob(os.path.join(abs_pdf_dir, "*.pdf"))
+    logger.info(f"디렉토리 내 PDF 파일 목록: {pdf_files}")
+else:
+    logger.error(f"PDF 디렉토리가 존재하지 않습니다: {abs_pdf_dir}")
+    # 상위 디렉토리 내용 확인
+    parent_dir = os.path.dirname(abs_pdf_dir)
+    logger.info(f"상위 디렉토리: {parent_dir}")
+    if os.path.exists(parent_dir):
+        dir_contents = os.listdir(parent_dir)
+        logger.info(f"상위 디렉토리 내용: {dir_contents}")
+
+# 설정 상태 확인
+logger.info("애플리케이션 설정 검증 중...")
+config_status = validate_config()
+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:
+    logger.warning(f"RAG 체인 모듈을 로드할 수 없습니다: {e}")
+    RAG_CHAIN_AVAILABLE = False
+except Exception as e:
+    logger.warning(f"RAG 체인 모듈 로드 중 예상치 못한 오류: {e}")
+    RAG_CHAIN_AVAILABLE = False
+
+# 폴백 RAG 관련 모듈도 미리 확인
+try:
+    from fallback_rag_chain import FallbackRAGChain
+    FALLBACK_AVAILABLE = True
+    print("폴백 RAG 체인 모듈 로드 성공!")
+except ImportError as e:
+    logger.warning(f"폴백 RAG 체인 모듈을 로드할 수 없습니다: {e}")
+    FALLBACK_AVAILABLE = False
+
+try:
+    from offline_fallback_rag import OfflineFallbackRAG
+    OFFLINE_FALLBACK_AVAILABLE = True
+    print("오프라인 폴백 RAG 모듈 로드 성공!")
+except ImportError as e:
+    logger.warning(f"오프라인 폴백 RAG 모듈을 로드할 수 없습니다: {e}")
+    OFFLINE_FALLBACK_AVAILABLE = False
+
+
+class DocumentProcessingError(Exception):
+    """문서 처리 중 발생하는 예외"""
+    pass
+
+
+class VectorStoreError(Exception):
+    """벡터 스토어 작업 중 발생하는 예외"""
+    pass
+
+
+class RAGInitializationError(Exception):
+    """RAG 체인 초기화 중 발생하는 예외"""
+    pass
+
+
+class ConfigurationError(Exception):
+    """설정 관련 오류"""
+    pass
+
+
+class AutoRAGChatApp:
+    """
+    documents 폴더의 PDF 파일을 자동으로 처리하는 RAG 챗봇
+    """
+
+    def __init__(self):
+        """
+        RAG 챗봇 애플리케이션 초기화
+        """
+        try:
+            logger.info("AutoRAGChatApp 초기화 시작")
+            
+            # 데이터 디렉토리 정의 (설정에서 가져옴)
+            # 절대 경로로 변환하여 사용
+            self.pdf_directory = os.path.abspath(PDF_DIRECTORY)
+            self.cache_directory = os.path.abspath(CACHE_DIRECTORY)
+            self.index_file = os.path.join(self.cache_directory, "file_index.json")
+            self.chunks_dir = os.path.join(self.cache_directory, "chunks")
+            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()
+
+            logger.info(f"PDF 문서 디렉토리: '{self.pdf_directory}'")
+            logger.info(f"캐시 디렉토리: '{self.cache_directory}'")
+
+            # 컴포넌트 초기화
+            try:
+                self.document_processor = OptimizedDocumentProcessor(
+                    chunk_size=CHUNK_SIZE,
+                    chunk_overlap=CHUNK_OVERLAP
+                )
+            except Exception as e:
+                logger.error(f"문서 처리기 초기화 실패: {e}")
+                raise DocumentProcessingError(f"문서 처리기 초기화 실패: {str(e)}")
+
+            # 벡터 저장소 초기화
+            try:
+                self.vector_store = VectorStore(use_milvus=False)
+            except Exception as e:
+                logger.error(f"벡터 저장소 초기화 실패: {e}")
+                raise VectorStoreError(f"벡터 저장소 초기화 실패: {str(e)}")
+
+            # 문서 인덱스 로드
+            self.file_index = self._load_file_index()
+
+            # 기본 변수 초기화
+            self.documents = []
+            self.processed_files = []
+            self.is_initialized = False
+
+            # 시작 시 자동으로 문서 로드 및 처리
+            logger.info("문서 자동 로드 및 처리 시작...")
+            self.auto_process_documents()
+            
+            logger.info("AutoRAGChatApp 초기화 완료")
+            
+        except Exception as e:
+            logger.critical(f"애플리케이션 초기화 중 심각한 오류: {e}", exc_info=True)
+            # 기본 상태 설정으로 최소한의 기능 유지
+            self.pdf_directory = os.path.abspath(PDF_DIRECTORY)
+            self.documents = []
+            self.processed_files = []
+            self.is_initialized = False
+            self.file_index = {}
+
+    def _ensure_directories_exist(self) -> None:
+        """
+        필요한 디렉토리가 존재하는지 확인하고 생성
+        """
+        directories = [
+            self.pdf_directory,
+            self.cache_directory,
+            self.chunks_dir,
+            self.vector_index_dir
+        ]
+        
+        for directory in directories:
+            try:
+                os.makedirs(directory, exist_ok=True)
+            except Exception as e:
+                logger.error(f"디렉토리 생성 실패 '{directory}': {e}")
+                raise OSError(f"디렉토리 생성 실패 '{directory}': {str(e)}")
+
+    def _process_pdf_file(self, file_path: str) -> List[Document]:
+        """
+        PDF 파일 처리 - docling 실패 시 PyPDFLoader 사용
+
+        Args:
+            file_path: 처리할 PDF 파일 경로
+
+        Returns:
+            처리된 문서 청크 리스트
+        """
+        if not os.path.exists(file_path):
+            logger.error(f"파일이 존재하지 않음: {file_path}")
+            raise FileNotFoundError(f"파일이 존재하지 않음: {file_path}")
+            
+        try:
+            logger.info(f"docling으로 처리 시도: {file_path}")
+
+            # docling 사용 시도
+            try:
+                # 10초 타임아웃 설정 (옵션)
+                import signal
+
+                def timeout_handler(signum, frame):
+                    raise TimeoutError("docling 처리 시간 초과 (60초)")
+
+                # 리눅스/맥에서만 작동 (윈도우에서는 무시됨)
+                try:
+                    signal.signal(signal.SIGALRM, timeout_handler)
+                    signal.alarm(60)  # 60초 타임아웃
+                except (AttributeError, ValueError) as se:
+                    logger.warning(f"시그널 설정 실패 (윈도우 환경일 수 있음): {se}")
+
+                # docling으로 처리 시도
+                chunks = self.document_processor.process_pdf(file_path, use_docling=True)
+
+                # 타임아웃 취소
+                try:
+                    signal.alarm(0)
+                except (AttributeError, ValueError):
+                    pass
+
+                return chunks
+
+            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)
+                if "Invalid code point" in error_str or "RuntimeError" in error_str:
+                    logger.warning(f"docling 처리 오류 (코드 포인트 문제): {error_str}")
+                    logger.info("PyPDFLoader로 대체합니다.")
+                else:
+                    logger.warning(f"docling 처리 오류: {error_str}")
+                    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 DocumentProcessingError:
+            # 이미 래핑된 예외는 그대로 전달
+            raise
+        except Exception as e:
+            logger.error(f"PDF 처리 중 심각한 오류: {e}", exc_info=True)
+            # 빈 청크라도 반환하여 전체 처리가 중단되지 않도록 함
+            logger.warning(f"'{file_path}' 처리 실패로 빈 청크 목록 반환")
+            return []
+
+    def _load_file_index(self) -> Dict[str, Dict[str, Any]]:
+        """
+        파일 인덱스 로드
+
+        Returns:
+            파일 경로 -> 메타데이터 매핑
+        """
+        if os.path.exists(self.index_file):
+            try:
+                with open(self.index_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except json.JSONDecodeError as e:
+                logger.error(f"인덱스 파일 JSON 파싱 실패: {e}")
+                logger.warning("손상된 인덱스 파일, 새로운 인덱스를 생성합니다.")
+                return {}
+            except Exception as e:
+                logger.error(f"인덱스 파일 로드 실패: {e}")
+                return {}
+        return {}
+
+    def _save_file_index(self) -> None:
+        """
+        파일 인덱스 저장
+        """
+        try:
+            with open(self.index_file, 'w', encoding='utf-8') as f:
+                json.dump(self.file_index, f, ensure_ascii=False, indent=2)
+            logger.debug("파일 인덱스 저장 완료")
+        except Exception as e:
+            logger.error(f"파일 인덱스 저장 실패: {e}")
+            raise IOError(f"파일 인덱스 저장 실패: {str(e)}")
+
+    def _calculate_file_hash(self, file_path: str) -> str:
+        """
+        파일 해시 계산
+
+        Args:
+            file_path: 파일 경로
+
+        Returns:
+            MD5 해시값
+        """
+        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:
+                buf = f.read(65536)
+                while len(buf) > 0:
+                    hasher.update(buf)
+                    buf = f.read(65536)
+            return hasher.hexdigest()
+        except Exception as e:
+            logger.error(f"파일 해시 계산 중 오류: {e}")
+            raise IOError(f"파일 해시 계산 실패: {str(e)}")
+
+    def _is_file_processed(self, file_path: str) -> bool:
+        """
+        파일이 이미 처리되었고 변경되지 않았는지 확인
+
+        Args:
+            file_path: 파일 경로
+
+        Returns:
+            처리 여부
+        """
+        # 파일 존재 확인
+        if not os.path.exists(file_path):
+            logger.warning(f"파일이 존재하지 않음: {file_path}")
+            return False
+            
+        # 인덱스에 파일 존재 여부 확인
+        if file_path not in self.file_index:
+            return False
+
+        try:
+            # 현재 해시값 계산
+            current_hash = self._calculate_file_hash(file_path)
+
+            # 저장된 해시값과 비교
+            if self.file_index[file_path]['hash'] != current_hash:
+                logger.info(f"파일 변경 감지: {file_path}")
+                return False
+
+            # 청크 파일 존재 확인
+            chunks_path = self.file_index[file_path]['chunks_path']
+            if not os.path.exists(chunks_path):
+                logger.warning(f"청크 파일이 존재하지 않음: {chunks_path}")
+                return False
+
+            return True
+        except Exception as e:
+            logger.error(f"파일 처리 상태 확인 중 오류: {e}")
+            return False
+
+    def _get_chunks_path(self, file_hash: str) -> str:
+        """
+        청크 파일 경로 생성
+
+        Args:
+            file_hash: 파일 해시값
+
+        Returns:
+            청크 파일 경로
+        """
+        return os.path.join(self.chunks_dir, f"{file_hash}.pkl")
+
+    def _save_chunks(self, file_path: str, chunks: List[Document]) -> None:
+        """
+        청크 데이터 저장
+
+        Args:
+            file_path: 원본 파일 경로
+            chunks: 문서 청크 리스트
+        """
+        try:
+            # 해시 계산
+            file_hash = self._calculate_file_hash(file_path)
+
+            # 청크 파일 경로
+            chunks_path = self._get_chunks_path(file_hash)
+
+            # 청크 데이터 저장
+            with open(chunks_path, 'wb') as f:
+                pickle.dump(chunks, f)
+
+            # 인덱스 업데이트
+            self.file_index[file_path] = {
+                'hash': file_hash,
+                'chunks_path': chunks_path,
+                'last_processed': time.time(),
+                'chunks_count': len(chunks),
+                'file_size': os.path.getsize(file_path),
+                'file_name': os.path.basename(file_path)
+            }
+
+            # 인덱스 저장
+            self._save_file_index()
+
+            logger.info(f"청크 저장 완료: {file_path} ({len(chunks)}개 청크)")
+        except Exception as e:
+            logger.error(f"청크 저장 실패: {e}", exc_info=True)
+            raise IOError(f"청크 저장 실패: {str(e)}")
+
+    def _load_chunks(self, file_path: str) -> List[Document]:
+        """
+        저장된 청크 데이터 로드
+
+        Args:
+            file_path: 파일 경로
+
+        Returns:
+            문서 청크 리스트
+        """
+        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)
+
+            logger.info(f"청크 로드 완료: {file_path} ({len(chunks)}개 청크)")
+            return chunks
+        except pickle.UnpicklingError as e:
+            logger.error(f"청크 파일 역직렬화 실패: {e}")
+            raise IOError(f"청크 파일 손상: {str(e)}")
+        except Exception as e:
+            logger.error(f"청크 로드 실패: {e}", exc_info=True)
+            raise IOError(f"청크 로드 실패: {str(e)}")
+
+    def _verify_pdf_directory(self):
+        """PDF 디렉토리 검증 및 파일 존재 확인"""
+        try:
+            # 디렉토리 존재 확인
+            if not os.path.exists(self.pdf_directory):
+                try:
+                    logger.warning(f"PDF 디렉토리가 존재하지 않아 생성합니다: {self.pdf_directory}")
+                    os.makedirs(self.pdf_directory, exist_ok=True)
+                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:
+                # 여러 경로에서 PDF 파일 탐색 시도
+                alternative_paths = [
+                    "./documents",
+                    "../documents",
+                    "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):
+                        alt_pdf_files = [f for f in os.listdir(alt_path) if f.lower().endswith('.pdf')]
+                        if alt_pdf_files:
+                            logger.warning(f"대체 경로 '{alt_path}'에서 PDF 파일을 찾았습니다. 이 경로를 사용합니다.")
+                            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
+
+    def auto_process_documents(self) -> str:
+        """
+        documents 폴더의 PDF 파일 자동 처리
+
+        Returns:
+            처리 결과 메시지
+        """
+        try:
+            start_time = time.time()
+
+            # PDF 파일 목록 수집을 개선하여 다양한 경로 처리
+            try:
+                pdf_files = []
+
+                # 설정된 디렉토리에서 PDF 파일 찾기
+                logger.info(f"PDF 파일 검색 경로: {self.pdf_directory}")
+
+                if os.path.exists(self.pdf_directory) and os.path.isdir(self.pdf_directory):
+                    # 디렉토리 내용 출력 (디버깅용)
+                    dir_contents = os.listdir(self.pdf_directory)
+                    logger.info(f"디렉토리 내용: {dir_contents}")
+
+                    # PDF 파일만 필터링
+                    for filename in os.listdir(self.pdf_directory):
+                        if filename.lower().endswith('.pdf'):
+                            file_path = os.path.join(self.pdf_directory, filename)
+                            if os.path.isfile(file_path):  # 실제 파일인지 확인
+                                pdf_files.append(file_path)
+                                logger.info(f"PDF 파일 찾음: {file_path}")
+
+                # 발견된 모든 파일 로그
+                logger.info(f"발견된 모든 PDF 파일: {pdf_files}")
+
+            except FileNotFoundError:
+                logger.error(f"PDF 디렉토리를 찾을 수 없음: {self.pdf_directory}")
+                return f"'{self.pdf_directory}' 디렉토리를 찾을 수 없습니다. 디렉토리가 존재하는지 확인하세요."
+            except PermissionError:
+                logger.error(f"PDF 디렉토리 접근 권한 없음: {self.pdf_directory}")
+                return f"'{self.pdf_directory}' 디렉토리에 접근할 수 없습니다. 권한을 확인하세요."
+
+            if not pdf_files:
+                logger.warning(f"'{self.pdf_directory}' 폴더에 PDF 파일이 없습니다.")
+                return f"'{self.pdf_directory}' 폴더에 PDF 파일이 없습니다."
+
+            logger.info(f"발견된 PDF 파일: {len(pdf_files)}개")
+
+            # 폴더 내 PDF 파일 처리
+            new_files = []
+            updated_files = []
+            cached_files = []
+            failed_files = []
+            all_chunks = []
+
+            for file_path in pdf_files:
+                try:
+                    if self._is_file_processed(file_path):
+                        # 캐시에서 청크 로드
+                        try:
+                            chunks = self._load_chunks(file_path)
+                            all_chunks.extend(chunks)
+                            cached_files.append(file_path)
+                            self.processed_files.append(os.path.basename(file_path))
+                        except Exception as e:
+                            logger.error(f"캐시된 청크 로드 실패: {e}")
+                            # 파일을 다시 처리
+                            logger.info(f"캐시 실패로 파일 재처리: {file_path}")
+                            chunks = self._process_pdf_file(file_path)
+                            if chunks:
+                                self._save_chunks(file_path, chunks)
+                                all_chunks.extend(chunks)
+                                updated_files.append(file_path)
+                                self.processed_files.append(os.path.basename(file_path))
+                            else:
+                                failed_files.append(file_path)
+                    else:
+                        # 새 파일 또는 변경된 파일 처리
+                        logger.info(f"처리 중: {file_path}")
+
+                        try:
+                            # 개선된 PDF 처리 메서드 사용
+                            chunks = self._process_pdf_file(file_path)
+
+                            if chunks:  # 청크가 있는 경우에만 저장
+                                # 청크 저장
+                                self._save_chunks(file_path, chunks)
+
+                                all_chunks.extend(chunks)
+                                if file_path in self.file_index:
+                                    updated_files.append(file_path)
+                                else:
+                                    new_files.append(file_path)
+
+                                self.processed_files.append(os.path.basename(file_path))
+                            else:
+                                logger.warning(f"'{file_path}' 처리 실패: 추출된 청크 없음")
+                                failed_files.append(file_path)
+                        except Exception as e:
+                            logger.error(f"'{file_path}' 처리 중 오류: {e}", exc_info=True)
+                            failed_files.append(file_path)
+                except Exception as e:
+                    logger.error(f"'{file_path}' 파일 처리 루프 중 오류: {e}", exc_info=True)
+                    failed_files.append(file_path)
+
+            # 모든 청크 저장
+            self.documents = all_chunks
+
+            processing_time = time.time() - start_time
+            logger.info(f"문서 처리 완료: {len(all_chunks)}개 청크, {processing_time:.2f}초")
+
+            # 벡터 인덱스 처리
+            try:
+                self._process_vector_index(new_files, updated_files)
+            except Exception as e:
+                logger.error(f"벡터 인덱스 처리 실패: {e}", exc_info=True)
+                return f"문서는 처리되었으나 벡터 인덱스 생성에 실패했습니다: {str(e)}"
+
+            # RAG 체인 초기화
+            if RAG_CHAIN_AVAILABLE:
+                try:
+                    logger.info("RAGChain으로 초기화를 시도합니다.")
+                    self.rag_chain = RAGChain(self.vector_store)
+                    self.is_initialized = True
+                    logger.info("RAG 체인 초기화 성공")
+                except Exception as e:
+                    logger.error(f"RAG 체인 초기화 실패: {e}", exc_info=True)
+
+                    # FallbackRAGChain으로 대체 시도
+                    try:
+                        logger.info("FallbackRAGChain으로 대체합니다...")
+                        from fallback_rag_chain import FallbackRAGChain
+                        self.rag_chain = FallbackRAGChain(self.vector_store)
+                        self.is_initialized = True
+                        logger.info("폴백 RAG 체인 초기화 성공")
+                    except Exception as fallback_e:
+                        logger.error(f"폴백 RAG 체인 초기화 실패: {fallback_e}", exc_info=True)
+
+                        # SimpleRAGChain 시도 (최후의 수단)
+                        try:
+                            logger.info("SimpleRAGChain으로 대체합니다...")
+                            from simple_rag_chain import SimpleRAGChain
+
+                            # API 정보 가져오기
+                            try:
+                                from config import DEEPSEEK_API_KEY, DEEPSEEK_MODEL, DEEPSEEK_ENDPOINT
+                                logger.info(f"설정 파일에서 DeepSeek API 정보를 로드했습니다: 모델={DEEPSEEK_MODEL}")
+                            except ImportError:
+                                # 설정 파일에서 가져올 수 없는 경우 환경 변수 확인
+                                DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY", "")
+                                DEEPSEEK_MODEL = os.environ.get("DEEPSEEK_MODEL", "deepseek-chat")
+                                DEEPSEEK_ENDPOINT = os.environ.get("DEEPSEEK_ENDPOINT",
+                                                                   "https://api.deepseek.com/v1/chat/completions")
+                                logger.info(f"환경 변수에서 DeepSeek API 정보를 로드했습니다: 모델={DEEPSEEK_MODEL}")
+
+                            # SimpleRAGChain 초기화 시도
+                            self.rag_chain = SimpleRAGChain(self.vector_store)
+                            self.is_initialized = True
+                            logger.info("SimpleRAGChain 초기화 성공")
+                        except Exception as simple_e:
+                            logger.error(f"모든 RAG 체인 초기화 실패: {simple_e}", exc_info=True)
+                            return f"문서와 벡터 인덱스는 처리되었으나 RAG 체인 초기화에 실패했습니다: {str(e)}"
+            else:
+                # RAGChain을 사용할 수 없는 경우
+                try:
+                    logger.info("기본 RAG Chain을 사용할 수 없어 대체 버전을 시도합니다...")
+
+                    # FallbackRAGChain 시도
+                    try:
+                        from fallback_rag_chain import FallbackRAGChain
+                        self.rag_chain = FallbackRAGChain(self.vector_store)
+                        self.is_initialized = True
+                        logger.info("폴백 RAG 체인 초기화 성공")
+                    except Exception as fallback_e:
+                        logger.error(f"폴백 RAG 체인 초기화 실패: {fallback_e}", exc_info=True)
+
+                        # SimpleRAGChain 시도 (최후의 수단)
+                        try:
+                            from simple_rag_chain import SimpleRAGChain
+                            self.rag_chain = SimpleRAGChain(self.vector_store)
+                            self.is_initialized = True
+                            logger.info("SimpleRAGChain 초기화 성공")
+                        except Exception as simple_e:
+                            logger.error(f"모든 RAG 체인 초기화 실패: {simple_e}", exc_info=True)
+                            return f"문서와 벡터 인덱스는 처리되었으나 RAG 체인 초기화에 실패했습니다"
+                except Exception as e:
+                    logger.error(f"RAG 체인 초기화 실패: {e}", exc_info=True)
+                    return f"문서와 벡터 인덱스는 처리되었으나 RAG 체인 초기화에 실패했습니다: {str(e)}"
+
+            # 성공 메시지 생성
+            result_message = f"""문서 처리 완료!
+    - 처리된 파일: {len(pdf_files)}개
+    - 캐시된 파일: {len(cached_files)}개
+    - 새 파일: {len(new_files)}개
+    - 업데이트된 파일: {len(updated_files)}개
+    - 실패한 파일: {len(failed_files)}개
+    - 총 청크 수: {len(all_chunks)}개
+    - 처리 시간: {processing_time:.2f}초
+    이제 질문할 준비가 되었습니다!"""
+
+            return result_message
+
+        except Exception as e:
+            error_message = f"문서 처리 중 오류 발생: {str(e)}"
+            logger.error(error_message, exc_info=True)
+            return error_message
+
+    def _process_vector_index(self, new_files: List[str], updated_files: List[str]) -> None:
+        """
+        벡터 인덱스 처리
+        
+        Args:
+            new_files: 새로 추가된 파일 목록
+            updated_files: 업데이트된 파일 목록
+        """
+        # 벡터 인덱스 저장 경로 확인
+        if os.path.exists(self.vector_index_dir) and any(os.listdir(self.vector_index_dir)):
+            # 기존 벡터 인덱스 로드
+            try:
+                logger.info("저장된 벡터 인덱스 로드 중...")
+                vector_store_loaded = self.vector_store.load_local(self.vector_index_dir)
+
+                # 인덱스 로드 성공 확인
+                if self.vector_store.vector_store is not None:
+                    # 새 문서나 변경된 문서가 있으면 인덱스 업데이트
+                    if new_files or updated_files:
+                        logger.info("벡터 인덱스 업데이트 중...")
+                        self.vector_store.add_documents(self.documents)
+
+                    logger.info("벡터 인덱스 로드 완료")
+                else:
+                    logger.warning("벡터 인덱스를 로드했으나 유효하지 않음, 새로 생성합니다.")
+                    self.vector_store.create_or_load(self.documents)
+
+            except Exception as e:
+                logger.error(f"벡터 인덱스 로드 실패, 새로 생성합니다: {e}", exc_info=True)
+                # 새 벡터 인덱스 생성
+                self.vector_store.create_or_load(self.documents)
+        else:
+            # 새 벡터 인덱스 생성
+            logger.info("새 벡터 인덱스 생성 중...")
+            self.vector_store.create_or_load(self.documents)
+
+        # 벡터 인덱스 저장
+        if self.vector_store and self.vector_store.vector_store is not None:
+            try:
+                logger.info(f"벡터 인덱스 저장 중: {self.vector_index_dir}")
+                save_result = self.vector_store.save_local(self.vector_index_dir)
+                logger.info(f"벡터 인덱스 저장 완료: {self.vector_index_dir}")
+            except Exception as e:
+                logger.error(f"벡터 인덱스 저장 실패: {e}", exc_info=True)
+                raise VectorStoreError(f"벡터 인덱스 저장 실패: {str(e)}")
+        else:
+            logger.warning("벡터 인덱스가 초기화되지 않아 저장하지 않습니다.")
+
+    def reset_cache(self) -> str:
+        """
+        캐시 초기화
+
+        Returns:
+            결과 메시지
+        """
+        try:
+            # 청크 파일 삭제
+            try:
+                for filename in os.listdir(self.chunks_dir):
+                    file_path = os.path.join(self.chunks_dir, filename)
+                    if os.path.isfile(file_path):
+                        os.remove(file_path)
+                logger.info("청크 캐시 파일 삭제 완료")
+            except Exception as e:
+                logger.error(f"청크 파일 삭제 중 오류: {e}")
+                return f"청크 파일 삭제 중 오류 발생: {str(e)}"
+
+            # 인덱스 초기화
+            self.file_index = {}
+            try:
+                self._save_file_index()
+                logger.info("파일 인덱스 초기화 완료")
+            except Exception as e:
+                logger.error(f"인덱스 파일 초기화 중 오류: {e}")
+                return f"인덱스 파일 초기화 중 ��류 발생: {str(e)}"
+
+            # 벡터 인덱스 삭제
+            try:
+                for filename in os.listdir(self.vector_index_dir):
+                    file_path = os.path.join(self.vector_index_dir, filename)
+                    if os.path.isfile(file_path):
+                        os.remove(file_path)
+                logger.info("벡터 인덱스 파일 삭제 완료")
+            except Exception as e:
+                logger.error(f"벡터 인덱스 파일 삭제 중 오류: {e}")
+                return f"벡터 인덱스 파일 삭제 중 오류 발생: {str(e)}"
+
+            self.documents = []
+            self.processed_files = []
+            self.is_initialized = False
+
+            logger.info("캐시 초기화 완료")
+            return "캐시가 초기화되었습니다. 다음 실행 시 모든 문서가 다시 처리됩니다."
+        except Exception as e:
+            error_msg = f"캐시 초기화 중 오류 발생: {str(e)}"
+            logger.error(error_msg, exc_info=True)
+            return error_msg
+
+    def process_query(self, query: str, chat_history: List[Tuple[str, str]]) -> Tuple[str, List[Tuple[str, str]]]:
+        """
+        사용자 쿼리 처리
+
+        Args:
+            query: 사용자 질문
+            chat_history: 대화 기록
+
+        Returns:
+            응답 및 업데이트된 대화 기록
+        """
+        if not query or not query.strip():
+            response = "질문이 비어 있습니다. 질문을 입력해 주세요."
+            chat_history.append((query, response))
+            return "", chat_history
+
+        if not self.is_initialized:
+            response = "문서 로드가 초기화되지 않았습니다. 자동 로드를 시도합니다."
+            chat_history.append((query, response))
+
+            # 자동 로드 시도
+            try:
+                init_result = self.auto_process_documents()
+                if not self.is_initialized:
+                    response = f"문서를 로드할 수 없습니다. 'documents' 폴더에 PDF 파일이 있는지 확인하세요. 초기화 결과: {init_result}"
+                    chat_history.append((query, response))
+                    return "", chat_history
+            except Exception as e:
+                response = f"문서 로드 중 오류 발생: {str(e)}"
+                logger.error(f"자동 로드 실패: {e}", exc_info=True)
+                chat_history.append((query, response))
+                return "", chat_history
+
+        try:
+            # RAG 체인 실행 및 응답 생성
+            start_time = time.time()
+            logger.info(f"쿼리 처리 시작: {query}")
+
+            # rag_chain이 초기화되었는지 확인
+            if not hasattr(self, 'rag_chain') or self.rag_chain is None:
+                raise RAGInitializationError("RAG 체인이 초기화되지 않았습니다")
+
+            # 1. 먼저 표준 RAG 체인으로 시도
+            try:
+                response = self.rag_chain.run(query)
+                logger.info(f"기본 RAG 체인으로 응답 생성 성공")
+            except Exception as rag_error:
+                logger.error(f"기본 RAG 체인 실행 실패: {rag_error}, 대안 시도")
+
+                # 2. DeepSeek API 직접 호출 시도 (RAG 체인 우회)
+                try:
+                    # DeepSeek API 정보 가져오기
+                    try:
+                        from config import DEEPSEEK_API_KEY, DEEPSEEK_MODEL, DEEPSEEK_ENDPOINT
+                    except ImportError:
+                        # 설정 모듈에서 가져올 수 없는 경우 기본값 설정
+                        DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY", "")
+                        DEEPSEEK_MODEL = os.environ.get("DEEPSEEK_MODEL", "deepseek-chat")
+                        DEEPSEEK_ENDPOINT = os.environ.get("DEEPSEEK_ENDPOINT",
+                                                           "https://api.deepseek.com/v1/chat/completions")
+
+                    # 직접 API 호출 함수 정의 (외부 모듈 의존성 제거)
+                    def direct_api_call(query, context, api_key, model_name, endpoint, max_retries=3, timeout=60):
+                        """DeepSeek API 직접 호출 함수"""
+                        import requests
+                        import json
+                        import time
+
+                        # 프롬프트 길이 제한
+                        if len(context) > 6000:
+                            context = context[:2500] + "\n...(중략)...\n" + context[-2500:]
+
+                        # 프롬프트 구성
+                        prompt = f"""
+                        다음 정보를 기반으로 질문에 정확하게 답변해주세요.
+
+                        질문: {query}
+
+                        참고 정보:
+                        {context}
+
+                        참고 정보에 답이 있으면 반드시 그 정보를 기반으로 답변하세요.
+                        참고 정보에 ��이 없는 경우에는 일반적인 지식을 활용하여 답변할 수 있지만, "제공된 문서에는 이 정보가 없으나, 일반적으로는..." 식으로 시작하세요.
+                        답변은 정확하고 간결하게 제공하되, 가능한 참고 정보에서 근거를 찾아 설명해주세요.
+                        참고 정보의 출처도 함께 알려주세요.
+                        """
+
+                        # API 요청 시도
+                        headers = {
+                            "Content-Type": "application/json",
+                            "Authorization": f"Bearer {api_key}"
+                        }
+
+                        payload = {
+                            "model": model_name,
+                            "messages": [{"role": "user", "content": prompt}],
+                            "temperature": 0.3,
+                            "max_tokens": 1000
+                        }
+
+                        # 재시도 로직
+                        retry_delay = 1.0
+                        for attempt in range(max_retries):
+                            try:
+                                logger.info(f"DeepSeek API 직접 호출 시도 ({attempt + 1}/{max_retries})...")
+                                response = requests.post(
+                                    endpoint,
+                                    headers=headers,
+                                    json=payload,
+                                    timeout=timeout
+                                )
+
+                                if response.status_code == 200:
+                                    result = response.json()
+                                    content = result.get("choices", [{}])[0].get("message", {}).get("content", "")
+                                    logger.info(f"DeepSeek API 직접 호출 성공")
+                                    return content
+                                else:
+                                    logger.warning(f"API 오류: 상태 코드 {response.status_code}")
+                                    # 요청 한도인 경우 더 오래 대기
+                                    if response.status_code == 429:
+                                        retry_delay = min(retry_delay * 3, 15)
+                                    else:
+                                        retry_delay = min(retry_delay * 2, 10)
+
+                                    if attempt < max_retries - 1:
+                                        logger.info(f"{retry_delay}초 후 재시도...")
+                                        time.sleep(retry_delay)
+                            except Exception as e:
+                                logger.error(f"API 호출 오류: {e}")
+                                if attempt < max_retries - 1:
+                                    logger.info(f"{retry_delay}초 후 재시도...")
+                                    time.sleep(retry_delay)
+                                    retry_delay = min(retry_delay * 2, 10)
+
+                        # 모든 시도 실패
+                        raise Exception("최대 재시도 횟수 초과")
+
+                    # 벡터 검색 수행
+                    if self.vector_store and hasattr(self.vector_store, "similarity_search"):
+                        logger.info("벡터 검색 수행...")
+                        docs = self.vector_store.similarity_search(query, k=5)
+
+                        # 검색 결과 컨텍스트 구성
+                        context_parts = []
+                        for i, doc in enumerate(docs, 1):
+                            source = doc.metadata.get("source", "알 수 없는 출처")
+                            page = doc.metadata.get("page", "")
+                            source_info = f"{source}"
+                            if page:
+                                source_info += f" (페이지: {page})"
+                            context_parts.append(f"[참고자료 {i}] - 출처: {source_info}\n{doc.page_content}\n")
+                        context = "\n".join(context_parts)
+
+                        # 직접 API 호출
+                        logger.info("DeepSeek API 직접 호출 시도...")
+                        response = direct_api_call(
+                            query,
+                            context,
+                            DEEPSEEK_API_KEY,
+                            DEEPSEEK_MODEL,
+                            DEEPSEEK_ENDPOINT,
+                            max_retries=3,
+                            timeout=120
+                        )
+                        logger.info("DeepSeek API 직접 호출 성공")
+                    else:
+                        raise Exception("벡터 스토어가 초기화되지 않았습니다")
+
+                except Exception as direct_api_error:
+                    logger.error(f"DeepSeek API 직접 호출 실패: {direct_api_error}, 검색 결과 반환")
+
+                    # 3. 검색 결과만이라도 반환
+                    try:
+                        # 벡터 검색 수행
+                        if self.vector_store and hasattr(self.vector_store, "similarity_search"):
+                            docs = self.vector_store.similarity_search(query, k=5)
+
+                            # 검색 결과 컨텍스트 구성
+                            context_parts = []
+                            for i, doc in enumerate(docs, 1):
+                                source = doc.metadata.get("source", "알 수 없는 출처")
+                                page = doc.metadata.get("page", "")
+                                source_info = f"{source}"
+                                if page:
+                                    source_info += f" (페이지: {page})"
+                                context_parts.append(f"[참고자료 {i}] - 출처: {source_info}\n{doc.page_content}\n")
+                            context = "\n".join(context_parts)
+
+                            # 간단한 응답 생성
+                            predefined_answers = {
+                                "대한민국의 수도": "대한민국의 수도는 서울입니다.",
+                                "수도": "대한민국의 수도는 서울입니다.",
+                                "누구야": "저는 RAG 기반 질의응답 시스템입니다. 문서를 검색하고 관련 정보를 찾아드립니다.",
+                                "안녕": "안녕하세요! 무엇을 도와드릴까요?",
+                                "뭐해": "사용자의 질문에 답변하기 위해 문서를 검색하고 있습니다. 무엇을 알려드릴까요?"
+                            }
+
+                            # 질문에 맞는 미리 정의된 응답이 있는지 확인
+                            for key, answer in predefined_answers.items():
+                                if key in query.lower():
+                                    response = answer
+                                    logger.info(f"미리 정의된 응답 제공: {key}")
+                                    break
+                            else:
+                                # 미리 정의된 응답이 없으면 검색 결과만 표시
+                                response = f"""
+    API 서버 연결에 문제가 있어 검색 결과만 표시합니다.
+
+    질문: {query}
+
+    검색된 관련 문서:
+    {context}
+
+    [참고] API 연결 문제로 인해 자동 요약이 제공되지 않습니다. 다시 시도하거나 다른 질문을 해보세요.
+    """
+                                logger.info("검색 결과만 표시")
+                        else:
+                            response = f"API 연결 및 벡터 검색에 모두 실패했습니다. 시스템 관리자에게 문의하세요."
+                    except Exception as fallback_error:
+                        logger.error(f"최종 폴백 응답 생성 실패: {fallback_error}")
+
+                        # 4. 최후의 방법: 오류 메시지를 응답으로 반환
+                        if "Connection error" in str(rag_error) or "timeout" in str(rag_error).lower():
+                            response = f"""
+    API 서버 연결에 문제가 있습니다. 잠시 후 다시 시도해주세요.
+
+    질문: {query}
+
+    [참고] 현재 DeepSeek API 서버와의 연결이 원활하지 않습니다. 이로 인해 질문에 대한 응답을 제공할 수 없습니다.
+                            """
+                        else:
+                            response = f"쿼리 처리 중 오류가 발생했습니다: {str(rag_error)}"
+
+            end_time = time.time()
+            query_time = end_time - start_time
+            logger.info(f"쿼리 처리 완료: {query_time:.2f}초")
+
+            chat_history.append((query, response))
+            return "", chat_history
+        except RAGInitializationError as e:
+            error_msg = f"RAG 시스템 초기화 오류: {str(e)}. 'documents' 폴더에 PDF 파일이 있는지 확인하고, 재시작해 보세요."
+            logger.error(f"쿼리 처리 중 RAG 초기화 오류: {e}", exc_info=True)
+            chat_history.append((query, error_msg))
+            return "", chat_history
+        except (VectorStoreError, DocumentProcessingError) as e:
+            error_msg = f"문서 처리 시스템 오류: {str(e)}. 문서 형식이 올바른지 확인해 보세요."
+            logger.error(f"쿼리 처리 중 문서/벡터 스토어 오류: {e}", exc_info=True)
+            chat_history.append((query, error_msg))
+            return "", chat_history
+        except Exception as e:
+            error_msg = f"쿼리 처리 중 오류 발생: {str(e)}"
+            logger.error(f"쿼리 처리 중 예상치 못한 오류: {e}", exc_info=True)
+            chat_history.append((query, error_msg))
+            return "", chat_history
+
+    def launch_app(self) -> None:
+        """
+        Gradio 앱 실행
+        """
+        try:
+            import gradio as gr
+        except ImportError:
+            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
+                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="캐시된 파일 정보",
+                                value=self._get_cache_info(),
+                                lines=5,
+                                interactive=False
+                            )
+
+                    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",
+                                    label="음성으로 질문하기"
+                                )
+
+                        with gr.Row():
+                            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()  # 캐시 정보 업데이트
+                        )
+
+                    # --- Gradio 이벤트 핸들러 설정 ---
+                    # 예: audio_input 컴포넌트의 stop_recording 이벤트를 아래와 같이 수정
+                    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]
+                    )
+
+                    # 캐시 초기화 버튼
+                    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}")
+
+                    reset_button.click(
+                        fn=reset_and_process,
+                        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]
+                    )
+
+                # 앱 실행
+                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:
+        """
+        현재 처리 상태 메시지 생성
+
+        Returns:
+            상태 메시지
+        """
+        if not self.processed_files:
+            return "처리된 문서가 없습니다. '문서 새로 읽기' 버튼을 클릭하세요."
+
+        # DeepSeek API 상태 확인
+        from config import USE_DEEPSEEK, DEEPSEEK_API_KEY, DEEPSEEK_MODEL
+
+        model_info = ""
+        if USE_DEEPSEEK and DEEPSEEK_API_KEY:
+            # DeepSeek API 테스트 수행
+            try:
+                # 테스트 함수 가져오기 시도
+                try:
+                    from deepseek_utils import test_deepseek_api
+
+                    # DeepSeek 설정 가져오기
+                    from config import DEEPSEEK_ENDPOINT
+
+                    # API 테스트
+                    test_result = test_deepseek_api(DEEPSEEK_API_KEY, DEEPSEEK_ENDPOINT, DEEPSEEK_MODEL)
+
+                    if test_result["success"]:
+                        model_info = f"\nDeepSeek API 상태: 정상 ({DEEPSEEK_MODEL})"
+                    else:
+                        model_info = f"\nDeepSeek API 상태: 오류 - {test_result['message']}"
+
+                except ImportError:
+                    # 직접 테스트 실행
+                    import requests
+                    import json
+
+                    # DeepSeek 설정 가져오기
+                    from config import DEEPSEEK_ENDPOINT
+
+                    # 테스트용 간단한 프롬프트
+                    test_prompt = "Hello, please respond with a short greeting."
+
+                    # API 요청 헤더 및 데이터
+                    headers = {
+                        "Content-Type": "application/json",
+                        "Authorization": f"Bearer {DEEPSEEK_API_KEY}"
+                    }
+
+                    payload = {
+                        "model": DEEPSEEK_MODEL,
+                        "messages": [{"role": "user", "content": test_prompt}],
+                        "temperature": 0.7,
+                        "max_tokens": 50
+                    }
+
+                    # API 요청 전송
+                    try:
+                        response = requests.post(
+                            DEEPSEEK_ENDPOINT,
+                            headers=headers,
+                            data=json.dumps(payload),
+                            timeout=5  # 5초 타임아웃 (UI 반응성 유지)
+                        )
+
+                        # 응답 확인
+                        if response.status_code == 200:
+                            model_info = f"\nDeepSeek API 상태: 정상 ({DEEPSEEK_MODEL})"
+                        else:
+                            error_message = response.text[:100]
+                            model_info = f"\nDeepSeek API 상태: 오류 (상태 코드: {response.status_code})"
+                    except Exception as e:
+                        model_info = f"\nDeepSeek API 상태: 연결 실패 ({str(e)[:100]})"
+            except Exception as e:
+                model_info = f"\nDeepSeek API 상태 확인 실패: {str(e)[:100]}"
+
+        return f"처리된 문서 ({len(self.processed_files)}개): {', '.join(self.processed_files)}{model_info}"
+
+    def _get_cache_info(self) -> str:
+        """
+        캐시 세부 정보 메시지 생성
+
+        Returns:
+            캐시 정보 메시지
+        """
+        if not self.file_index:
+            return "캐시된 파일이 없습니다."
+
+        file_info = ""
+        for file_path, info in self.file_index.items():
+            file_name = info.get('file_name', os.path.basename(file_path))
+            chunks_count = info.get('chunks_count', 0)
+            file_size = info.get('file_size', 0)
+            last_processed = info.get('last_processed', 0)
+
+            # 파일 크기를 사람이 읽기 쉬운 형태로 변환
+            if file_size < 1024:
+                size_str = f"{file_size} bytes"
+            elif file_size < 1024 * 1024:
+                size_str = f"{file_size / 1024:.1f} KB"
+            else:
+                size_str = f"{file_size / (1024 * 1024):.1f} MB"
+
+            # 마지막 처리 시간을 날짜/시간 형식으로 변환
+            if last_processed:
+                from datetime import datetime
+                last_time = datetime.fromtimestamp(last_processed).strftime('%Y-%m-%d %H:%M:%S')
+            else:
+                last_time = "알 수 없음"
+
+            file_info += f"- {file_name}: {chunks_count}개 청크, {size_str}, 마지막 처리: {last_time}\n"
+
+        return file_info
+
+
+
+if __name__ == "__main__":
+    app = AutoRAGChatApp()
+    app.launch_app()

autorag.log

@@ -0,0 +1,493 @@
+2025-03-29 23:17:05,934 - AutoRAG - INFO - ���� �۾� ���丮: C:\Users\USER\PycharmProjects\RagPipeline\RAG3
+2025-03-29 23:17:05,934 - AutoRAG - INFO - ������ PDF ���丮: C:\Users\USER\RAG3\documents
+2025-03-29 23:17:05,934 - AutoRAG - INFO - ���� ��η� ��ȯ�� PDF ���丮: C:\Users\USER\RAG3\documents
+2025-03-29 23:17:05,934 - AutoRAG - INFO - PDF ���丮�� �����մϴ�: C:\Users\USER\RAG3\documents
+2025-03-29 23:17:05,934 - AutoRAG - INFO - ���丮 �� PDF ���� ���: ['C:\\Users\\USER\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:17:05,934 - AutoRAG - INFO - ���ø����̼� ���� ���� ��...
+2025-03-29 23:17:07,025 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ ����
+2025-03-29 23:17:07,025 - AutoRAG - INFO - ������ PDF ���丮 (���� ���): C:\Users\USER\RAG3\documents
+2025-03-29 23:17:07,026 - AutoRAG - INFO - PDF ���丮���� 1���� PDF ������ ã�ҽ��ϴ�: ['RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:17:07,026 - AutoRAG - INFO - PDF ���� ���丮: 'C:\Users\USER\RAG3\documents'
+2025-03-29 23:17:07,026 - AutoRAG - INFO - ij�� ���丮: 'C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data'
+2025-03-29 23:17:07,849 - VectorStore - INFO - �Ӻ��� �� �ε� ��: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:17:07,851 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:17:12,304 - VectorStore - INFO - �Ӻ��� �� �ʱ�ȭ �Ϸ�: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:17:12,304 - AutoRAG - INFO - ���� �ڵ� �ε� �� ó�� ����...
+2025-03-29 23:17:12,305 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\RAG3\documents
+2025-03-29 23:17:12,305 - AutoRAG - INFO - ���丮 ����: ['RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:17:12,305 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-29 23:17:12,305 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:17:12,305 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-03-29 23:17:12,305 - AutoRAG - INFO - ó�� ��: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-29 23:17:12,305 - AutoRAG - INFO - docling���� ó�� �õ�: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-29 23:17:12,305 - AutoRAG - WARNING - �ñ׳� ���� ���� (������ ȯ���� �� ����): module 'signal' has no attribute 'SIGALRM'
+2025-03-29 23:17:13,014 - docling.document_converter - INFO - Going to convert document batch...
+2025-03-29 23:17:13,025 - docling.models.factories.base_factory - INFO - Loading plugin 'docling_defaults'
+2025-03-29 23:17:13,026 - docling.models.factories - INFO - Registered ocr engines: ['easyocr', 'ocrmac', 'rapidocr', 'tesserocr', 'tesseract']
+2025-03-29 23:17:13,150 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cuda:0'
+2025-03-29 23:17:15,247 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cuda:0'
+2025-03-29 23:17:16,731 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cuda:0'
+2025-03-29 23:17:17,206 - docling.models.factories.base_factory - INFO - Loading plugin 'docling_defaults'
+2025-03-29 23:17:17,207 - docling.models.factories - INFO - Registered picture descriptions: ['vlm', 'api']
+2025-03-29 23:17:17,207 - docling.pipeline.base_pipeline - INFO - Processing document RAG �Ʒÿ� Q.pdf
+2025-03-29 23:17:18,062 - docling.document_converter - INFO - Finished converting document RAG �Ʒÿ� Q.pdf in 5.76 sec.
+2025-03-29 23:17:18,110 - AutoRAG - INFO - ûũ ���� �Ϸ�: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-03-29 23:17:18,111 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 5.81��
+2025-03-29 23:17:18,111 - AutoRAG - INFO - �� ���� ��� ���� ��...
+2025-03-29 23:17:18,111 - VectorStore - INFO - FAISS ��� ���� ��: 1�� ����
+2025-03-29 23:17:18,331 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2025-03-29 23:17:18,517 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2025-03-29 23:17:18,523 - faiss - INFO - Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will not load constructor refs for GPU indexes.
+2025-03-29 23:17:18,523 - VectorStore - INFO - FAISS �ε��� ���� �Ϸ�
+2025-03-29 23:17:18,523 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:17:18,525 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:17:18,525 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:17:18,525 - RAGChain - INFO - RAGChain �ʱ�ȭ ����...
+2025-03-29 23:17:18,525 - RAGChain - INFO - ����Ŀ ��� ����: True
+2025-03-29 23:17:20,596 - sentence_transformers.cross_encoder.CrossEncoder - INFO - Use pytorch device: cuda
+2025-03-29 23:17:20,800 - RAGChain - INFO - ����Ŀ �ʱ�ȭ ����
+2025-03-29 23:17:20,800 - RAGChain - INFO - Ollama �� �ʱ�ȭ: gemma3:latest
+2025-03-29 23:17:20,810 - RAGChain - INFO - Ollama �� �ʱ�ȭ ����
+2025-03-29 23:17:20,810 - RAGChain - INFO - RAG ü�� ���� ����...
+2025-03-29 23:17:20,810 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:17:20,810 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:17:20,810 - AutoRAG - INFO - ���� ó�� �Ϸ�!
+- �� ����: 1��
+- ij�õ� ����: 0��
+- �� ����: 0��
+- ������Ʈ�� ����: 1��
+- ������ ����: 0��
+- �� ûũ ��: 1��
+- ó�� �ð�: 8.51��
+���� ������ �غ� �Ǿ����ϴ�!
+2025-03-29 23:17:20,810 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ �Ϸ�
+2025-03-29 23:20:20,300 - AutoRAG - INFO - ���� �۾� ���丮: C:\Users\USER\PycharmProjects\RagPipeline\RAG3
+2025-03-29 23:20:20,300 - AutoRAG - INFO - ������ PDF ���丮: C:\Users\USER\RAG3\documents
+2025-03-29 23:20:20,300 - AutoRAG - INFO - ���� ��η� ��ȯ�� PDF ���丮: C:\Users\USER\RAG3\documents
+2025-03-29 23:20:20,300 - AutoRAG - INFO - PDF ���丮�� �����մϴ�: C:\Users\USER\RAG3\documents
+2025-03-29 23:20:20,300 - AutoRAG - INFO - ���丮 �� PDF ���� ���: ['C:\\Users\\USER\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:20:20,300 - AutoRAG - INFO - ���ø����̼� ���� ���� ��...
+2025-03-29 23:20:21,048 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ ����
+2025-03-29 23:20:21,048 - AutoRAG - INFO - ������ PDF ���丮 (���� ���): C:\Users\USER\RAG3\documents
+2025-03-29 23:20:21,048 - AutoRAG - INFO - PDF ���丮���� 1���� PDF ������ ã�ҽ��ϴ�: ['RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:20:21,048 - AutoRAG - INFO - PDF ���� ���丮: 'C:\Users\USER\RAG3\documents'
+2025-03-29 23:20:21,048 - AutoRAG - INFO - ij�� ���丮: 'C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data'
+2025-03-29 23:20:21,794 - VectorStore - INFO - �Ӻ��� �� �ε� ��: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:20:21,796 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:20:25,626 - VectorStore - INFO - �Ӻ��� �� �ʱ�ȭ �Ϸ�: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:20:25,626 - AutoRAG - INFO - ���� �ڵ� �ε� �� ó�� ����...
+2025-03-29 23:20:25,626 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\RAG3\documents
+2025-03-29 23:20:25,627 - AutoRAG - INFO - ���丮 ����: ['RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:20:25,627 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-29 23:20:25,627 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:20:25,627 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-03-29 23:20:25,627 - AutoRAG - INFO - ûũ �ε� �Ϸ�: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-03-29 23:20:25,627 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 0.00��
+2025-03-29 23:20:25,627 - AutoRAG - INFO - ����� ���� �ε��� �ε� ��...
+2025-03-29 23:20:25,627 - VectorStore - INFO - FAISS �ε��� �ε� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:20:25,629 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2025-03-29 23:20:25,641 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2025-03-29 23:20:25,644 - faiss - INFO - Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will not load constructor refs for GPU indexes.
+2025-03-29 23:20:25,645 - VectorStore - INFO - FAISS �ε��� �ε� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:20:25,645 - AutoRAG - INFO - ���� �ε��� �ε� �Ϸ�
+2025-03-29 23:20:25,645 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:20:25,645 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:20:25,645 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:20:25,645 - RAGChain - INFO - RAGChain �ʱ�ȭ ����...
+2025-03-29 23:20:25,645 - RAGChain - INFO - ����Ŀ ��� ����: True
+2025-03-29 23:20:27,424 - sentence_transformers.cross_encoder.CrossEncoder - INFO - Use pytorch device: cuda
+2025-03-29 23:20:27,622 - RAGChain - INFO - ����Ŀ �ʱ�ȭ ����
+2025-03-29 23:20:27,622 - RAGChain - INFO - Ollama �� �ʱ�ȭ: gemma3:latest
+2025-03-29 23:20:27,623 - RAGChain - INFO - Ollama �� �ʱ�ȭ ����
+2025-03-29 23:20:27,623 - RAGChain - INFO - RAG ü�� ���� ����...
+2025-03-29 23:20:27,623 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:20:27,623 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:20:27,624 - AutoRAG - INFO - ���� ó�� �Ϸ�!
+- �� ����: 1��
+- ij�õ� ����: 1��
+- �� ����: 0��
+- ������Ʈ�� ����: 0��
+- ������ ����: 0��
+- �� ûũ ��: 1��
+- ó�� �ð�: 2.00��
+���� ������ �غ� �Ǿ����ϴ�!
+2025-03-29 23:20:27,624 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ �Ϸ�
+2025-03-29 23:20:29,758 - httpx - INFO - HTTP Request: GET https://api.gradio.app/gradio-messaging/en "HTTP/1.1 200 OK"
+2025-03-29 23:20:30,349 - AutoRAG - ERROR - Gradio �� ���� �� ���� �߻�: 'AutoRAGChatApp' object has no attribute '_get_status_message'
+Traceback (most recent call last):
+  File "C:\Users\USER\PycharmProjects\RagPipeline\RAG3\app.py", line 855, in launch_app
+    value=self._get_status_message(),
+          ^^^^^^^^^^^^^^^^^^^^^^^^
+AttributeError: 'AutoRAGChatApp' object has no attribute '_get_status_message'
+2025-03-29 23:20:31,087 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-03-29 23:22:28,187 - AutoRAG - INFO - ���� �۾� ���丮: C:\Users\USER\PycharmProjects\RagPipeline\RAG3
+2025-03-29 23:22:28,188 - AutoRAG - INFO - ������ PDF ���丮: C:\Users\USER\RAG3\documents
+2025-03-29 23:22:28,188 - AutoRAG - INFO - ���� ��η� ��ȯ�� PDF ���丮: C:\Users\USER\RAG3\documents
+2025-03-29 23:22:28,188 - AutoRAG - INFO - PDF ���丮�� �����մϴ�: C:\Users\USER\RAG3\documents
+2025-03-29 23:22:28,188 - AutoRAG - INFO - ���丮 �� PDF ���� ���: ['C:\\Users\\USER\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:22:28,188 - AutoRAG - INFO - ���ø����̼� ���� ���� ��...
+2025-03-29 23:22:28,930 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ ����
+2025-03-29 23:22:28,930 - AutoRAG - INFO - ������ PDF ���丮 (���� ���): C:\Users\USER\RAG3\documents
+2025-03-29 23:22:28,930 - AutoRAG - INFO - PDF ���丮���� 1���� PDF ������ ã�ҽ��ϴ�: ['RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:22:28,931 - AutoRAG - INFO - PDF ���� ���丮: 'C:\Users\USER\RAG3\documents'
+2025-03-29 23:22:28,931 - AutoRAG - INFO - ij�� ���丮: 'C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data'
+2025-03-29 23:22:29,680 - VectorStore - INFO - �Ӻ��� �� �ε� ��: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:22:29,681 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:22:33,510 - VectorStore - INFO - �Ӻ��� �� �ʱ�ȭ �Ϸ�: Alibaba-NLP/gte-multilingual-base
+2025-03-29 23:22:33,510 - AutoRAG - INFO - ���� �ڵ� �ε� �� ó�� ����...
+2025-03-29 23:22:33,510 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\RAG3\documents
+2025-03-29 23:22:33,510 - AutoRAG - INFO - ���丮 ����: ['RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:22:33,510 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-29 23:22:33,510 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-29 23:22:33,510 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-03-29 23:22:33,510 - AutoRAG - INFO - ûũ �ε� �Ϸ�: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-03-29 23:22:33,510 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 0.00��
+2025-03-29 23:22:33,510 - AutoRAG - INFO - ����� ���� �ε��� �ε� ��...
+2025-03-29 23:22:33,510 - VectorStore - INFO - FAISS �ε��� �ε� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:22:33,512 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2025-03-29 23:22:33,523 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2025-03-29 23:22:33,526 - faiss - INFO - Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will not load constructor refs for GPU indexes.
+2025-03-29 23:22:33,532 - VectorStore - INFO - FAISS �ε��� �ε� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:22:33,532 - AutoRAG - INFO - ���� �ε��� �ε� �Ϸ�
+2025-03-29 23:22:33,532 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:22:33,533 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:22:33,533 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-29 23:22:33,533 - RAGChain - INFO - RAGChain �ʱ�ȭ ����...
+2025-03-29 23:22:33,533 - RAGChain - INFO - ����Ŀ ��� ����: True
+2025-03-29 23:22:35,580 - sentence_transformers.cross_encoder.CrossEncoder - INFO - Use pytorch device: cuda
+2025-03-29 23:22:35,782 - RAGChain - INFO - ����Ŀ �ʱ�ȭ ����
+2025-03-29 23:22:35,782 - RAGChain - INFO - Ollama �� �ʱ�ȭ: gemma3:latest
+2025-03-29 23:22:35,783 - RAGChain - INFO - Ollama �� �ʱ�ȭ ����
+2025-03-29 23:22:35,783 - RAGChain - INFO - RAG ü�� ���� ����...
+2025-03-29 23:22:35,783 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:22:35,783 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:22:35,783 - AutoRAG - INFO - ���� ó�� �Ϸ�!
+- �� ����: 1��
+- ij�õ� ����: 1��
+- �� ����: 0��
+- ������Ʈ�� ����: 0��
+- ������ ����: 0��
+- �� ûũ ��: 1��
+- ó�� �ð�: 2.27��
+���� ������ �غ� �Ǿ����ϴ�!
+2025-03-29 23:22:35,783 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ �Ϸ�
+2025-03-29 23:22:37,712 - httpx - INFO - HTTP Request: GET https://api.gradio.app/gradio-messaging/en "HTTP/1.1 200 OK"
+2025-03-29 23:22:38,171 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7860/gradio_api/startup-events "HTTP/1.1 200 OK"
+2025-03-29 23:22:38,259 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7860/ "HTTP/1.1 200 OK"
+2025-03-29 23:22:38,510 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-03-29 23:23:06,606 - AutoRAG - INFO - ���� ó�� ����: �ȳ�?
+2025-03-29 23:23:06,606 - RAGChain - INFO - RAG ü�� ����: '�ȳ�?'
+2025-03-29 23:23:06,616 - RAGChain - INFO - ���� �˻� ����: '�ȳ�?'
+2025-03-29 23:23:06,616 - VectorStore - INFO - �˻� ���� ����: '�ȳ�?', ���� 5�� ��� ��û
+2025-03-29 23:23:06,674 - VectorStore - INFO - �˻� �Ϸ�: 1�� ��� ã��
+2025-03-29 23:23:06,674 - RAGChain - INFO - ����ŷ ����: 1�� ����
+2025-03-29 23:23:06,992 - RAGChain - INFO - ����ŷ �Ϸ�: 1�� ���� ���õ�
+2025-03-29 23:23:06,992 - RAGChain - INFO - ���ؽ�Ʈ ���� �Ϸ�: 1�� ����, 683 ����
+2025-03-29 23:23:13,887 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:23:13,887 - AutoRAG - INFO - ���� ó�� �Ϸ�: 7.28��
+2025-03-29 23:23:44,199 - AutoRAG - INFO - ���� ó�� ����: ���ѹα� ������?
+2025-03-29 23:23:44,199 - RAGChain - INFO - RAG ü�� ����: '���ѹα� ������?'
+2025-03-29 23:23:44,200 - RAGChain - INFO - ���� �˻� ����: '���ѹα� ������?'
+2025-03-29 23:23:44,201 - VectorStore - INFO - �˻� ���� ����: '���ѹα� ������?', ���� 5�� ��� ��û
+2025-03-29 23:23:44,237 - VectorStore - INFO - �˻� �Ϸ�: 1�� ��� ã��
+2025-03-29 23:23:44,238 - RAGChain - INFO - ����ŷ ����: 1�� ����
+2025-03-29 23:23:44,358 - RAGChain - INFO - ����ŷ �Ϸ�: 1�� ���� ���õ�
+2025-03-29 23:23:44,358 - RAGChain - INFO - ���ؽ�Ʈ ���� �Ϸ�: 1�� ����, 683 ����
+2025-03-29 23:23:47,486 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:23:47,486 - AutoRAG - INFO - ���� ó�� �Ϸ�: 3.29��
+2025-03-29 23:24:29,670 - AutoRAG - INFO - ���� ó�� ����: �� ������?
+2025-03-29 23:24:29,670 - RAGChain - INFO - RAG ü�� ����: '�� ������?'
+2025-03-29 23:24:29,673 - RAGChain - INFO - ���� �˻� ����: '�� ������?'
+2025-03-29 23:24:29,673 - VectorStore - INFO - �˻� ���� ����: '�� ������?', ���� 5�� ��� ��û
+2025-03-29 23:24:29,707 - VectorStore - INFO - �˻� �Ϸ�: 1�� ��� ã��
+2025-03-29 23:24:29,708 - RAGChain - INFO - ����ŷ ����: 1�� ����
+2025-03-29 23:24:29,827 - RAGChain - INFO - ����ŷ �Ϸ�: 1�� ���� ���õ�
+2025-03-29 23:24:29,827 - RAGChain - INFO - ���ؽ�Ʈ ���� �Ϸ�: 1�� ����, 683 ����
+2025-03-29 23:24:32,394 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-29 23:24:32,394 - AutoRAG - INFO - ���� ó�� �Ϸ�: 2.72��
+2025-03-30 00:09:22,627 - AutoRAG - INFO - ���� �۾� ���丮: C:\Users\USER\PycharmProjects\RagPipeline\RAG3
+2025-03-30 00:09:22,627 - AutoRAG - INFO - ������ PDF ���丮: C:\Users\USER\RAG3\documents
+2025-03-30 00:09:22,627 - AutoRAG - INFO - ���� ��η� ��ȯ�� PDF ���丮: C:\Users\USER\RAG3\documents
+2025-03-30 00:09:22,627 - AutoRAG - INFO - PDF ���丮�� �����մϴ�: C:\Users\USER\RAG3\documents
+2025-03-30 00:09:22,627 - AutoRAG - INFO - ���丮 �� PDF ���� ���: ['C:\\Users\\USER\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:09:22,628 - AutoRAG - INFO - ���ø����̼� ���� ���� ��...
+2025-03-30 00:09:23,685 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ ����
+2025-03-30 00:09:23,685 - AutoRAG - INFO - ������ PDF ���丮 (���� ���): C:\Users\USER\RAG3\documents
+2025-03-30 00:09:23,685 - AutoRAG - INFO - PDF ���丮���� 1���� PDF ������ ã�ҽ��ϴ�: ['RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:09:23,686 - AutoRAG - INFO - PDF ���� ���丮: 'C:\Users\USER\RAG3\documents'
+2025-03-30 00:09:23,686 - AutoRAG - INFO - ij�� ���丮: 'C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data'
+2025-03-30 00:09:24,553 - VectorStore - INFO - �Ӻ��� �� �ε� ��: Alibaba-NLP/gte-multilingual-base
+2025-03-30 00:09:24,560 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: Alibaba-NLP/gte-multilingual-base
+2025-03-30 00:09:28,468 - VectorStore - INFO - �Ӻ��� �� �ʱ�ȭ �Ϸ�: Alibaba-NLP/gte-multilingual-base
+2025-03-30 00:09:28,473 - AutoRAG - INFO - ���� �ڵ� �ε� �� ó�� ����...
+2025-03-30 00:09:28,473 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\RAG3\documents
+2025-03-30 00:09:28,473 - AutoRAG - INFO - ���丮 ����: ['.gitkeep', 'RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:09:28,473 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-30 00:09:28,473 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:09:28,473 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-03-30 00:09:28,479 - AutoRAG - INFO - ûũ �ε� �Ϸ�: C:\Users\USER\RAG3\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-03-30 00:09:28,479 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 0.01��
+2025-03-30 00:09:28,479 - AutoRAG - INFO - ����� ���� �ε��� �ε� ��...
+2025-03-30 00:09:28,479 - VectorStore - INFO - FAISS �ε��� �ε� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:09:28,480 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2025-03-30 00:09:28,625 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2025-03-30 00:09:28,630 - faiss - INFO - Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will not load constructor refs for GPU indexes.
+2025-03-30 00:09:28,635 - VectorStore - INFO - FAISS �ε��� �ε� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:09:28,636 - AutoRAG - INFO - ���� �ε��� �ε� �Ϸ�
+2025-03-30 00:09:28,636 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:09:28,636 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:09:28,636 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:09:28,636 - RAGChain - INFO - RAGChain �ʱ�ȭ ����...
+2025-03-30 00:09:28,636 - RAGChain - INFO - ����Ŀ ��� ����: True
+2025-03-30 00:09:30,453 - sentence_transformers.cross_encoder.CrossEncoder - INFO - Use pytorch device: cuda
+2025-03-30 00:09:30,651 - RAGChain - INFO - ����Ŀ �ʱ�ȭ ����
+2025-03-30 00:09:30,652 - RAGChain - INFO - Ollama �� �ʱ�ȭ: gemma3:latest
+2025-03-30 00:09:30,653 - RAGChain - INFO - Ollama �� �ʱ�ȭ ����
+2025-03-30 00:09:30,653 - RAGChain - INFO - RAG ü�� ���� ����...
+2025-03-30 00:09:30,653 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-30 00:09:30,653 - RAGChain - INFO - RAG ü�� ���� �Ϸ�
+2025-03-30 00:09:30,653 - AutoRAG - INFO - ���� ó�� �Ϸ�!
+- �� ����: 1��
+- ij�õ� ����: 1��
+- �� ����: 0��
+- ������Ʈ�� ����: 0��
+- ������ ����: 0��
+- �� ûũ ��: 1��
+- ó�� �ð�: 2.18��
+���� ������ �غ� �Ǿ����ϴ�!
+2025-03-30 00:09:30,653 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ �Ϸ�
+2025-03-30 00:09:33,004 - httpx - INFO - HTTP Request: GET https://api.gradio.app/gradio-messaging/en "HTTP/1.1 200 OK"
+2025-03-30 00:09:33,980 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7860/gradio_api/startup-events "HTTP/1.1 200 OK"
+2025-03-30 00:09:34,074 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7860/ "HTTP/1.1 200 OK"
+2025-03-30 00:09:34,318 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-03-30 00:32:10,853 - AutoRAG - INFO - ���� �۾� ���丮: C:\Users\USER\PycharmProjects\RagPipeline\RAG3
+2025-03-30 00:32:10,854 - AutoRAG - INFO - ������ PDF ���丮: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents
+2025-03-30 00:32:10,854 - AutoRAG - INFO - ���� ��η� ��ȯ�� PDF ���丮: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents
+2025-03-30 00:32:10,854 - AutoRAG - INFO - PDF ���丮�� �����մϴ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents
+2025-03-30 00:32:10,854 - AutoRAG - INFO - ���丮 �� PDF ���� ���: ['C:\\Users\\USER\\PycharmProjects\\RagPipeline\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:32:10,854 - AutoRAG - INFO - ���ø����̼� ���� ���� ��...
+2025-03-30 00:32:11,619 - AutoRAG - WARNING - RAG ü�� ����� �ε��� �� �����ϴ�.
+2025-03-30 00:32:11,620 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ ����
+2025-03-30 00:32:11,620 - AutoRAG - INFO - ������ PDF ���丮 (���� ���): C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents
+2025-03-30 00:32:11,620 - AutoRAG - INFO - PDF ���丮���� 1���� PDF ������ ã�ҽ��ϴ�: ['RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:32:11,620 - AutoRAG - INFO - PDF ���� ���丮: 'C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents'
+2025-03-30 00:32:11,620 - AutoRAG - INFO - ij�� ���丮: 'C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data'
+2025-03-30 00:32:12,436 - VectorStore - INFO - �Ӻ��� �� �ε� ��: Alibaba-NLP/gte-multilingual-base
+2025-03-30 00:32:12,514 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: Alibaba-NLP/gte-multilingual-base
+2025-03-30 00:32:16,937 - VectorStore - INFO - �Ӻ��� �� �ʱ�ȭ �Ϸ�: Alibaba-NLP/gte-multilingual-base
+2025-03-30 00:32:16,938 - AutoRAG - INFO - ���� �ڵ� �ε� �� ó�� ����...
+2025-03-30 00:32:16,938 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents
+2025-03-30 00:32:16,938 - AutoRAG - INFO - ���丮 ����: ['RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:32:16,938 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-30 00:32:16,938 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\PycharmProjects\\RagPipeline\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:32:16,938 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-03-30 00:32:16,938 - AutoRAG - INFO - ó�� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-30 00:32:16,938 - AutoRAG - INFO - docling���� ó�� �õ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-30 00:32:16,938 - AutoRAG - WARNING - �ñ׳� ���� ���� (������ ȯ���� �� ����): module 'signal' has no attribute 'SIGALRM'
+2025-03-30 00:32:17,580 - docling.document_converter - INFO - Going to convert document batch...
+2025-03-30 00:32:17,596 - docling.models.factories.base_factory - INFO - Loading plugin 'docling_defaults'
+2025-03-30 00:32:17,596 - docling.models.factories - INFO - Registered ocr engines: ['easyocr', 'ocrmac', 'rapidocr', 'tesserocr', 'tesseract']
+2025-03-30 00:32:17,693 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cuda:0'
+2025-03-30 00:32:19,673 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cuda:0'
+2025-03-30 00:32:20,999 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cuda:0'
+2025-03-30 00:32:21,412 - docling.models.factories.base_factory - INFO - Loading plugin 'docling_defaults'
+2025-03-30 00:32:21,412 - docling.models.factories - INFO - Registered picture descriptions: ['vlm', 'api']
+2025-03-30 00:32:21,412 - docling.pipeline.base_pipeline - INFO - Processing document RAG �Ʒÿ� Q.pdf
+2025-03-30 00:32:22,019 - docling.document_converter - INFO - Finished converting document RAG �Ʒÿ� Q.pdf in 5.08 sec.
+2025-03-30 00:32:22,079 - AutoRAG - INFO - ûũ ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-03-30 00:32:22,079 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 5.14��
+2025-03-30 00:32:22,079 - AutoRAG - INFO - ����� ���� �ε��� �ε� ��...
+2025-03-30 00:32:22,079 - VectorStore - INFO - FAISS �ε��� �ε� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:22,082 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2025-03-30 00:32:22,104 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2025-03-30 00:32:22,108 - faiss - INFO - Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will not load constructor refs for GPU indexes.
+2025-03-30 00:32:22,113 - VectorStore - INFO - FAISS �ε��� �ε� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:22,113 - AutoRAG - INFO - ���� �ε��� ������Ʈ ��...
+2025-03-30 00:32:22,113 - VectorStore - INFO - 1�� ������ ���� ���� ���� �߰��մϴ�
+2025-03-30 00:32:22,324 - VectorStore - INFO - 1�� ���� �߰� �Ϸ�
+2025-03-30 00:32:22,324 - AutoRAG - INFO - ���� �ε��� �ε� �Ϸ�
+2025-03-30 00:32:22,324 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:22,325 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:22,325 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:22,325 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ �Ϸ�
+2025-03-30 00:32:24,654 - httpx - INFO - HTTP Request: GET https://api.gradio.app/gradio-messaging/en "HTTP/1.1 200 OK"
+2025-03-30 00:32:24,990 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7860/gradio_api/startup-events "HTTP/1.1 200 OK"
+2025-03-30 00:32:25,035 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7860/ "HTTP/1.1 200 OK"
+2025-03-30 00:32:25,293 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-03-30 00:32:45,649 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents
+2025-03-30 00:32:45,649 - AutoRAG - INFO - ���丮 ����: ['RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:32:45,650 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents\RAG �Ʒÿ� Q.pdf
+2025-03-30 00:32:45,650 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\PycharmProjects\\RagPipeline\\RAG3\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-03-30 00:32:45,650 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-03-30 00:32:45,658 - AutoRAG - INFO - ûũ �ε� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-03-30 00:32:45,658 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 0.01��
+2025-03-30 00:32:45,658 - AutoRAG - INFO - ����� ���� �ε��� �ε� ��...
+2025-03-30 00:32:45,658 - VectorStore - INFO - FAISS �ε��� �ε� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:45,666 - VectorStore - INFO - FAISS �ε��� �ε� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:45,666 - AutoRAG - INFO - ���� �ε��� �ε� �Ϸ�
+2025-03-30 00:32:45,666 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:45,667 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-03-30 00:32:45,667 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\PycharmProjects\RagPipeline\RAG3\cached_data\vector_index
+2025-04-10 23:37:57,365 - AutoRAG - INFO - ���� �۾� ���丮: C:\Users\USER\RAG3_voice
+2025-04-10 23:37:57,365 - AutoRAG - INFO - ������ PDF ���丮: C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:37:57,365 - AutoRAG - INFO - ���� ��η� ��ȯ�� PDF ���丮: C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:37:57,366 - AutoRAG - INFO - PDF ���丮�� �����մϴ�: C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:37:57,366 - AutoRAG - INFO - ���丮 �� PDF ���� ���: ['C:\\Users\\USER\\RAG3_voice\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-04-10 23:37:57,366 - AutoRAG - INFO - ���ø����̼� ���� ���� ��...
+2025-04-10 23:37:57,366 - Config - INFO - DeepSeek API ���� �׽�Ʈ ����: https://api.deepseek.com/v1/chat/completions, ��: deepseek-chat
+2025-04-10 23:38:04,670 - Config - INFO - DeepSeek API ���� ����
+2025-04-10 23:38:04,674 - AutoRAG - WARNING - RAG ü�� ����� �ε��� �� �����ϴ�: cannot import name 'RAGChain' from 'rag_chain' (C:\Users\USER\RAG3_voice\rag_chain.py)
+2025-04-10 23:38:04,678 - AutoRAG - WARNING - �������� ���� RAG ����� �ε��� �� �����ϴ�: No module named 'offline_fallback_rag'
+2025-04-10 23:38:04,678 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ ����
+2025-04-10 23:38:04,679 - AutoRAG - INFO - ������ PDF ���丮 (���� ���): C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:38:04,679 - AutoRAG - INFO - PDF ���丮���� 1���� PDF ������ ã�ҽ��ϴ�: ['RAG �Ʒÿ� Q.pdf']
+2025-04-10 23:38:04,679 - AutoRAG - INFO - PDF ���� ���丮: 'C:\Users\USER\RAG3_voice\documents'
+2025-04-10 23:38:04,679 - AutoRAG - INFO - ij�� ���丮: 'C:\Users\USER\RAG3_voice\cached_data'
+2025-04-10 23:38:05,611 - VectorStore - INFO - �Ӻ��� �� �ε� ��: Alibaba-NLP/gte-multilingual-base
+2025-04-10 23:38:05,823 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: Alibaba-NLP/gte-multilingual-base
+2025-04-10 23:38:09,891 - VectorStore - INFO - �Ӻ��� �� �ʱ�ȭ �Ϸ�: Alibaba-NLP/gte-multilingual-base
+2025-04-10 23:38:09,891 - AutoRAG - INFO - ���� �ڵ� �ε� �� ó�� ����...
+2025-04-10 23:38:09,891 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:38:09,891 - AutoRAG - INFO - ���丮 ����: ['.gitkeep', 'RAG �Ʒÿ� Q.pdf']
+2025-04-10 23:38:09,891 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\RAG3_voice\documents\RAG �Ʒÿ� Q.pdf
+2025-04-10 23:38:09,891 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\RAG3_voice\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-04-10 23:38:09,891 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-04-10 23:38:09,891 - AutoRAG - INFO - ó�� ��: C:\Users\USER\RAG3_voice\documents\RAG �Ʒÿ� Q.pdf
+2025-04-10 23:38:09,892 - AutoRAG - INFO - docling���� ó�� �õ�: C:\Users\USER\RAG3_voice\documents\RAG �Ʒÿ� Q.pdf
+2025-04-10 23:38:09,892 - AutoRAG - WARNING - �ñ׳� ���� ���� (������ ȯ���� �� ����): module 'signal' has no attribute 'SIGALRM'
+2025-04-10 23:38:09,911 - docling.document_converter - INFO - Going to convert document batch...
+2025-04-10 23:38:09,911 - docling.document_converter - INFO - Initializing pipeline for StandardPdfPipeline with options hash 3d2abd0e021741887551c73bd132b421
+2025-04-10 23:38:09,920 - docling.models.factories.base_factory - INFO - Loading plugin 'docling_defaults'
+2025-04-10 23:38:09,921 - docling.models.factories - INFO - Registered ocr engines: ['easyocr', 'ocrmac', 'rapidocr', 'tesserocr', 'tesseract']
+2025-04-10 23:38:09,951 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cpu'
+2025-04-10 23:38:11,882 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cpu'
+2025-04-10 23:38:12,840 - docling.utils.accelerator_utils - INFO - Accelerator device: 'cpu'
+2025-04-10 23:38:13,366 - docling.models.factories.base_factory - INFO - Loading plugin 'docling_defaults'
+2025-04-10 23:38:13,367 - docling.models.factories - INFO - Registered picture descriptions: ['vlm', 'api']
+2025-04-10 23:38:13,367 - docling.pipeline.base_pipeline - INFO - Processing document RAG �Ʒÿ� Q.pdf
+2025-04-10 23:38:14,803 - docling.document_converter - INFO - Finished converting document RAG �Ʒÿ� Q.pdf in 4.92 sec.
+2025-04-10 23:38:14,825 - AutoRAG - INFO - ûũ ���� �Ϸ�: C:\Users\USER\RAG3_voice\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-04-10 23:38:14,825 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 4.93��
+2025-04-10 23:38:14,825 - AutoRAG - INFO - �� ���� ��� ���� ��...
+2025-04-10 23:38:14,826 - VectorStore - INFO - FAISS ��� ���� ��: 1�� ����
+2025-04-10 23:38:15,340 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2025-04-10 23:38:15,355 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2025-04-10 23:38:15,359 - faiss - INFO - Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will not load constructor refs for GPU indexes.
+2025-04-10 23:38:15,359 - VectorStore - INFO - FAISS �ε��� ���� �Ϸ�
+2025-04-10 23:38:15,359 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-10 23:38:15,360 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-10 23:38:15,360 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-10 23:38:15,360 - AutoRAG - INFO - �⺻ RAG Chain�� ����� �� ���� ��ü ������ �õ��մϴ�...
+2025-04-10 23:38:15,360 - FallbackRAGChain - INFO - ���� RAG ü�� �ʱ�ȭ...
+2025-04-10 23:38:15,360 - FallbackRAGChain - INFO - DeepSeek �� ���� �ʱ�ȭ: deepseek-chat
+2025-04-10 23:38:15,360 - DirectDeepSeek - INFO - DirectDeepSeekClient �ʱ�ȭ: ��=deepseek-chat, ��������Ʈ=https://api.deepseek.com/v1/chat/completions
+2025-04-10 23:38:15,360 - FallbackRAGChain - INFO - DeepSeek �� ���� �ʱ�ȭ ����
+2025-04-10 23:38:15,361 - FallbackRAGChain - INFO - ���� RAG ü�� �ʱ�ȭ �Ϸ�
+2025-04-10 23:38:15,361 - AutoRAG - INFO - ���� RAG ü�� �ʱ�ȭ ����
+2025-04-10 23:38:15,361 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ �Ϸ�
+2025-04-10 23:38:16,336 - httpx - INFO - HTTP Request: GET https://api.gradio.app/gradio-messaging/en "HTTP/1.1 200 OK"
+2025-04-10 23:38:16,681 - DeepSeekUtils - INFO - DeepSeek API ���� �׽�Ʈ ����: https://api.deepseek.com/v1/chat/completions, ��: deepseek-chat
+2025-04-10 23:38:17,260 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-04-10 23:38:20,420 - DeepSeekUtils - INFO - DeepSeek API ���� ����
+2025-04-10 23:38:20,534 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7860/gradio_api/startup-events "HTTP/1.1 200 OK"
+2025-04-10 23:38:20,545 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7860/ "HTTP/1.1 200 OK"
+2025-04-10 23:44:10,873 - AutoRAG - INFO - ���� �۾� ���丮: C:\Users\USER\RAG3_voice
+2025-04-10 23:44:10,873 - AutoRAG - INFO - ������ PDF ���丮: C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:44:10,874 - AutoRAG - INFO - ���� ��η� ��ȯ�� PDF ���丮: C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:44:10,874 - AutoRAG - INFO - PDF ���丮�� �����մϴ�: C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:44:10,874 - AutoRAG - INFO - ���丮 �� PDF ���� ���: ['C:\\Users\\USER\\RAG3_voice\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-04-10 23:44:10,875 - AutoRAG - INFO - ���ø����̼� ���� ���� ��...
+2025-04-10 23:44:10,875 - Config - INFO - DeepSeek API ���� �׽�Ʈ ����: https://api.deepseek.com/v1/chat/completions, ��: deepseek-chat
+2025-04-10 23:44:17,355 - Config - INFO - DeepSeek API ���� ����
+2025-04-10 23:44:17,358 - AutoRAG - WARNING - RAG ü�� ����� �ε��� �� �����ϴ�: cannot import name 'RAGChain' from 'rag_chain' (C:\Users\USER\RAG3_voice\rag_chain.py)
+2025-04-10 23:44:17,363 - AutoRAG - WARNING - �������� ���� RAG ����� �ε��� �� �����ϴ�: No module named 'offline_fallback_rag'
+2025-04-10 23:44:17,363 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ ����
+2025-04-10 23:44:17,364 - AutoRAG - INFO - ������ PDF ���丮 (���� ���): C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:44:17,364 - AutoRAG - INFO - PDF ���丮���� 1���� PDF ������ ã�ҽ��ϴ�: ['RAG �Ʒÿ� Q.pdf']
+2025-04-10 23:44:17,365 - AutoRAG - INFO - PDF ���� ���丮: 'C:\Users\USER\RAG3_voice\documents'
+2025-04-10 23:44:17,366 - AutoRAG - INFO - ij�� ���丮: 'C:\Users\USER\RAG3_voice\cached_data'
+2025-04-10 23:44:18,213 - VectorStore - INFO - �Ӻ��� �� �ε� ��: Alibaba-NLP/gte-multilingual-base
+2025-04-10 23:44:18,460 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: Alibaba-NLP/gte-multilingual-base
+2025-04-10 23:44:23,069 - VectorStore - INFO - �Ӻ��� �� �ʱ�ȭ �Ϸ�: Alibaba-NLP/gte-multilingual-base
+2025-04-10 23:44:23,070 - AutoRAG - INFO - ���� �ڵ� �ε� �� ó�� ����...
+2025-04-10 23:44:23,070 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\RAG3_voice\documents
+2025-04-10 23:44:23,070 - AutoRAG - INFO - ���丮 ����: ['.gitkeep', 'RAG �Ʒÿ� Q.pdf']
+2025-04-10 23:44:23,070 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\RAG3_voice\documents\RAG �Ʒÿ� Q.pdf
+2025-04-10 23:44:23,070 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\RAG3_voice\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-04-10 23:44:23,070 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-04-10 23:44:23,070 - AutoRAG - INFO - ûũ �ε� �Ϸ�: C:\Users\USER\RAG3_voice\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-04-10 23:44:23,071 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 0.00��
+2025-04-10 23:44:23,071 - AutoRAG - INFO - ����� ���� �ε��� �ε� ��...
+2025-04-10 23:44:23,071 - VectorStore - INFO - FAISS �ε��� �ε� ��: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-10 23:44:23,072 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2025-04-10 23:44:23,083 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2025-04-10 23:44:23,085 - faiss - INFO - Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will not load constructor refs for GPU indexes.
+2025-04-10 23:44:23,086 - VectorStore - INFO - FAISS �ε��� �ε� �Ϸ�: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-10 23:44:23,086 - AutoRAG - INFO - ���� �ε��� �ε� �Ϸ�
+2025-04-10 23:44:23,086 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-10 23:44:23,087 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-10 23:44:23,087 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-10 23:44:23,087 - AutoRAG - INFO - �⺻ RAG Chain�� ����� �� ���� ��ü ������ �õ��մϴ�...
+2025-04-10 23:44:23,087 - FallbackRAGChain - INFO - ���� RAG ü�� �ʱ�ȭ...
+2025-04-10 23:44:23,087 - FallbackRAGChain - INFO - DeepSeek �� ���� �ʱ�ȭ: deepseek-chat
+2025-04-10 23:44:23,087 - DirectDeepSeek - INFO - DirectDeepSeekClient �ʱ�ȭ: ��=deepseek-chat, ��������Ʈ=https://api.deepseek.com/v1/chat/completions
+2025-04-10 23:44:23,087 - FallbackRAGChain - INFO - DeepSeek �� ���� �ʱ�ȭ ����
+2025-04-10 23:44:23,087 - FallbackRAGChain - INFO - ���� RAG ü�� �ʱ�ȭ �Ϸ�
+2025-04-10 23:44:23,087 - AutoRAG - INFO - ���� RAG ü�� �ʱ�ȭ ����
+2025-04-10 23:44:23,087 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ �Ϸ�
+2025-04-10 23:44:23,988 - httpx - INFO - HTTP Request: GET https://api.gradio.app/gradio-messaging/en "HTTP/1.1 200 OK"
+2025-04-10 23:44:24,635 - DeepSeekUtils - INFO - DeepSeek API ���� �׽�Ʈ ����: https://api.deepseek.com/v1/chat/completions, ��: deepseek-chat
+2025-04-10 23:44:25,196 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-04-10 23:44:28,870 - DeepSeekUtils - INFO - DeepSeek API ���� ����
+2025-04-10 23:44:29,004 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7860/gradio_api/startup-events "HTTP/1.1 200 OK"
+2025-04-10 23:44:29,016 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7860/ "HTTP/1.1 200 OK"
+2025-04-11 00:59:57,522 - AutoRAG - INFO - ���� �۾� ���丮: C:\Users\USER\RAG3_voice
+2025-04-11 00:59:57,523 - AutoRAG - INFO - ������ PDF ���丮: C:\Users\USER\RAG3_voice\documents
+2025-04-11 00:59:57,523 - AutoRAG - INFO - ���� ��η� ��ȯ�� PDF ���丮: C:\Users\USER\RAG3_voice\documents
+2025-04-11 00:59:57,523 - AutoRAG - INFO - PDF ���丮�� �����մϴ�: C:\Users\USER\RAG3_voice\documents
+2025-04-11 00:59:57,524 - AutoRAG - INFO - ���丮 �� PDF ���� ���: ['C:\\Users\\USER\\RAG3_voice\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-04-11 00:59:57,524 - AutoRAG - INFO - ���ø����̼� ���� ���� ��...
+2025-04-11 00:59:57,524 - Config - INFO - DeepSeek API ���� �׽�Ʈ ����: https://api.deepseek.com/v1/chat/completions, ��: deepseek-chat
+2025-04-11 01:00:01,647 - Config - INFO - DeepSeek API ���� ����
+2025-04-11 01:00:01,661 - AutoRAG - WARNING - RAG ü�� ����� �ε��� �� �����ϴ�: cannot import name 'RAGChain' from 'rag_chain' (C:\Users\USER\RAG3_voice\rag_chain.py)
+2025-04-11 01:00:01,666 - AutoRAG - WARNING - �������� ���� RAG ����� �ε��� �� �����ϴ�: No module named 'offline_fallback_rag'
+2025-04-11 01:00:01,667 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ ����
+2025-04-11 01:00:01,668 - AutoRAG - INFO - ������ PDF ���丮 (���� ���): C:\Users\USER\RAG3_voice\documents
+2025-04-11 01:00:01,668 - AutoRAG - INFO - PDF ���丮���� 1���� PDF ������ ã�ҽ��ϴ�: ['RAG �Ʒÿ� Q.pdf']
+2025-04-11 01:00:01,669 - AutoRAG - INFO - PDF ���� ���丮: 'C:\Users\USER\RAG3_voice\documents'
+2025-04-11 01:00:01,669 - AutoRAG - INFO - ij�� ���丮: 'C:\Users\USER\RAG3_voice\cached_data'
+2025-04-11 01:00:02,471 - VectorStore - INFO - �Ӻ��� �� �ε� ��: Alibaba-NLP/gte-multilingual-base
+2025-04-11 01:00:02,744 - sentence_transformers.SentenceTransformer - INFO - Load pretrained SentenceTransformer: Alibaba-NLP/gte-multilingual-base
+2025-04-11 01:00:07,061 - VectorStore - INFO - �Ӻ��� �� �ʱ�ȭ �Ϸ�: Alibaba-NLP/gte-multilingual-base
+2025-04-11 01:00:07,061 - AutoRAG - INFO - ���� �ڵ� �ε� �� ó�� ����...
+2025-04-11 01:00:07,061 - AutoRAG - INFO - PDF ���� �˻� ���: C:\Users\USER\RAG3_voice\documents
+2025-04-11 01:00:07,061 - AutoRAG - INFO - ���丮 ����: ['.gitkeep', 'RAG �Ʒÿ� Q.pdf']
+2025-04-11 01:00:07,061 - AutoRAG - INFO - PDF ���� ã��: C:\Users\USER\RAG3_voice\documents\RAG �Ʒÿ� Q.pdf
+2025-04-11 01:00:07,061 - AutoRAG - INFO - �߰ߵ� ��� PDF ����: ['C:\\Users\\USER\\RAG3_voice\\documents\\RAG �Ʒÿ� Q.pdf']
+2025-04-11 01:00:07,062 - AutoRAG - INFO - �߰ߵ� PDF ����: 1��
+2025-04-11 01:00:07,062 - AutoRAG - INFO - ûũ �ε� �Ϸ�: C:\Users\USER\RAG3_voice\documents\RAG �Ʒÿ� Q.pdf (1�� ûũ)
+2025-04-11 01:00:07,062 - AutoRAG - INFO - ���� ó�� �Ϸ�: 1�� ûũ, 0.00��
+2025-04-11 01:00:07,062 - AutoRAG - INFO - ����� ���� �ε��� �ε� ��...
+2025-04-11 01:00:07,062 - VectorStore - INFO - FAISS �ε��� �ε� ��: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-11 01:00:07,065 - faiss.loader - INFO - Loading faiss with AVX2 support.
+2025-04-11 01:00:07,173 - faiss.loader - INFO - Successfully loaded faiss with AVX2 support.
+2025-04-11 01:00:07,177 - faiss - INFO - Failed to load GPU Faiss: name 'GpuIndexIVFFlat' is not defined. Will not load constructor refs for GPU indexes.
+2025-04-11 01:00:07,185 - VectorStore - INFO - FAISS �ε��� �ε� �Ϸ�: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-11 01:00:07,185 - AutoRAG - INFO - ���� �ε��� �ε� �Ϸ�
+2025-04-11 01:00:07,186 - AutoRAG - INFO - ���� ��� ���� ��: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-11 01:00:07,187 - VectorStore - INFO - FAISS �ε��� ���� ���� �Ϸ�: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-11 01:00:07,187 - AutoRAG - INFO - ���� �ε��� ���� �Ϸ�: C:\Users\USER\RAG3_voice\cached_data\vector_index
+2025-04-11 01:00:07,187 - AutoRAG - INFO - �⺻ RAG Chain�� ����� �� ���� ��ü ������ �õ��մϴ�...
+2025-04-11 01:00:07,188 - FallbackRAGChain - INFO - ���� RAG ü�� �ʱ�ȭ...
+2025-04-11 01:00:07,188 - FallbackRAGChain - INFO - DeepSeek �� ���� �ʱ�ȭ: deepseek-chat
+2025-04-11 01:00:07,188 - DirectDeepSeek - INFO - DirectDeepSeekClient �ʱ�ȭ: ��=deepseek-chat, ��������Ʈ=https://api.deepseek.com/v1/chat/completions
+2025-04-11 01:00:07,188 - FallbackRAGChain - INFO - DeepSeek �� ���� �ʱ�ȭ ����
+2025-04-11 01:00:07,189 - FallbackRAGChain - INFO - ���� RAG ü�� �ʱ�ȭ �Ϸ�
+2025-04-11 01:00:07,189 - AutoRAG - INFO - ���� RAG ü�� �ʱ�ȭ ����
+2025-04-11 01:00:07,189 - AutoRAG - INFO - AutoRAGChatApp �ʱ�ȭ �Ϸ�
+2025-04-11 01:00:08,133 - httpx - INFO - HTTP Request: GET https://api.gradio.app/gradio-messaging/en "HTTP/1.1 200 OK"
+2025-04-11 01:00:09,395 - DeepSeekUtils - INFO - DeepSeek API ���� �׽�Ʈ ����: https://api.deepseek.com/v1/chat/completions, ��: deepseek-chat
+2025-04-11 01:00:09,953 - httpx - INFO - HTTP Request: GET https://api.gradio.app/pkg-version "HTTP/1.1 200 OK"
+2025-04-11 01:00:13,592 - DeepSeekUtils - INFO - DeepSeek API ���� ����
+2025-04-11 01:00:13,714 - httpx - INFO - HTTP Request: GET http://127.0.0.1:7860/gradio_api/startup-events "HTTP/1.1 200 OK"
+2025-04-11 01:00:13,789 - httpx - INFO - HTTP Request: HEAD http://127.0.0.1:7860/ "HTTP/1.1 200 OK"

clova_stt.py

@@ -0,0 +1,92 @@
+"""
+네이버 클로바 음성인식(STT) API 연동 모듈
+"""
+import os
+import json
+import requests
+import logging
+from typing import Dict, Any
+from dotenv import load_dotenv
+
+# .env 파일 로드
+load_dotenv()
+
+# 로깅 설정
+logger = logging.getLogger("ClovaSTT")
+
+class ClovaSTT:
+    """
+    네이버 클로바 음성인식(STT) API 클래스
+    """
+
+    def __init__(self):
+        """
+        클로바 STT 클라이언트 초기화
+        """
+        # .env 파일에서 설정 가져오기
+        self.client_id = os.getenv("NAVER_CLIENT_ID", "")
+        self.client_secret = os.getenv("NAVER_CLIENT_SECRET", "")
+
+        # 클라이언트 ID와 Secret 검증
+        if not self.client_id or not self.client_secret:
+            logger.warning("네이버 클로바 API 키가 설정되지 않았습니다.")
+            logger.warning(".env 파일에 NAVER_CLIENT_ID와 NAVER_CLIENT_SECRET를 설정해주세요.")
+        else:
+            logger.info("네이버 클로바 STT API 설정 완료")
+
+    def recognize(self, audio_bytes, language="Kor") -> Dict[str, Any]:
+        """
+        오디오 데이터를 텍스트로 변환
+
+        Args:
+            audio_bytes: 오디오 파일 바이트 데이터
+            language: 언어 코드 (기본값: 'Kor')
+
+        Returns:
+            인식된 텍스트 또는 오류 메시지
+        """
+        if not self.client_id or not self.client_secret:
+            logger.error("API 키가 설정되지 않았습니다.")
+            return {"success": False, "error": "API 키가 설정되지 않았습니다."}
+
+        try:
+            # API 엔드포인트 URL
+            url = f"https://naveropenapi.apigw.ntruss.com/recog/v1/stt?lang={language}"
+
+            # 요청 헤더 설정
+            headers = {
+                "X-NCP-APIGW-API-KEY-ID": self.client_id,
+                "X-NCP-APIGW-API-KEY": self.client_secret,
+                "Content-Type": "application/octet-stream"
+            }
+
+            logger.info("네이버 클로바 STT 요청 전송 중...")
+
+            # API 요청 전송
+            response = requests.post(url, headers=headers, data=audio_bytes, timeout=30)
+
+            # 응답 처리
+            if response.status_code == 200:
+                result = response.json()
+                recognized_text = result.get("text", "")
+                logger.info(f"인식 성공: {recognized_text[:50]}...")
+                return {
+                    "success": True,
+                    "text": recognized_text,
+                    "result": result
+                }
+            else:
+                logger.error(f"API 오류 응답: {response.status_code}, {response.text}")
+                return {
+                    "success": False,
+                    "error": f"API 오류: {response.status_code}",
+                    "details": response.text
+                }
+
+        except Exception as e:
+            logger.error(f"음성인식 처리 중 오류 발생: {str(e)}")
+            return {
+                "success": False,
+                "error": "음성인식 처리 실패",
+                "details": str(e)
+            }

config.py

@@ -0,0 +1,402 @@
+"""
+벡터 스토어, 임베딩 모델, LLM 등 구성 요소 설정
+환경 변수 및 .env 파일 활용 개선 버전 - HuggingFace 환경 지원 추가
+"""
+import os
+import logging
+import sys
+import re
+import requests
+import json
+from pathlib import Path
+from typing import Dict, Any
+from dotenv import load_dotenv
+
+# 로깅 설정
+logger = logging.getLogger("Config")
+
+# 현재 실행 위치 확인 (디버깅용)
+script_dir = os.path.dirname(os.path.abspath(__file__))
+logger.info(f"스크립트 디렉토리: {script_dir}")
+logger.info(f"현재 작업 디렉토리: {os.getcwd()}")
+logger.info(f"운영 체제: {os.name}")
+
+# 환경 감지 - HuggingFace Space 환경인지 확인
+IS_HUGGINGFACE = False
+if os.getenv('SPACE_ID') is not None or os.getenv('SYSTEM') == 'spaces':
+    IS_HUGGINGFACE = True
+    logger.info("HuggingFace Spaces 환경이 감지되었습니다.")
+else:
+    # 로컬 환경인 경우 .env 파일 로드
+    # .env 파일 위치 후보들
+    env_paths = [
+        ".env",  # 현재 디렉토리
+        os.path.join(script_dir, ".env"),  # 스크립트 디렉토리
+        os.path.join(script_dir, "config", ".env"),  # config 하위 디렉토리
+        os.path.join(os.path.dirname(script_dir), ".env"),  # 상위 디렉토리
+    ]
+
+    # .env 파일 찾아서 로드
+    env_loaded = False
+    for env_path in env_paths:
+        if os.path.isfile(env_path):
+            logger.info(f".env 파일 발견: {env_path}")
+            env_loaded = load_dotenv(env_path, verbose=True)
+            if env_loaded:
+                logger.info(f".env 파일 로드 성공: {env_path}")
+                break
+
+    if not env_loaded:
+        logger.warning(".env 파일을 찾을 수 없습니다. 기본값 또는 시스템 환경 변수를 사용합니다.")
+
+    logger.info(f"로컬 환경에서 실행 중입니다. (OS: {'Windows' if os.name == 'nt' else 'Unix/Linux/MacOS'})")
+
+# Windows 환경 감지
+IS_WINDOWS = os.name == 'nt'
+
+# 유틸리티 함수: 환경 변수 가져오기 (HuggingFace 환경과 로컬 환경 구분)
+def get_env(key: str, default: Any = None, required: bool = False) -> Any:
+    """
+    환경 변수를 가져오는 유틸리티 함수 (HuggingFace 환경 지원)
+
+    Args:
+        key: 환경 변수 키
+        default: 환경 변수가 없을 경우 기본값
+        required: 환경 변수가 필수적인지 여부
+
+    Returns:
+        환경 변수 값 또는 기본값
+    """
+    # HuggingFace Spaces 환경에서는 내부 환경변수 활용
+    if IS_HUGGINGFACE:
+        # HuggingFace Spaces에서는 시크릿 값을 직접 사용
+        # HF_SECRET_<KEY> 형식으로 저장된 시크릿 확인
+        hf_secret_key = f"HF_SECRET_{key.upper()}"
+        value = os.getenv(hf_secret_key)
+
+        # 시크릿이 없으면 일반 환경변수 확인
+        if value is None:
+            value = os.getenv(key, default)
+    else:
+        # 로컬 환경에서는 일반적인 방식으로 환경변수 가져오기
+        value = os.getenv(key, default)
+
+    if required and value is None:
+        if IS_HUGGINGFACE:
+            error_msg = f"필수 환경 변수 {key}가 설정되지 않았습니다. HuggingFace Space에서 시크릿을 설정해주세요."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        else:
+            error_msg = f"필수 환경 변수 {key}가 설정되지 않았습니다. .env 파일에 추가해주세요."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+    return value
+
+# 경로 생성 유틸리티 함수
+def ensure_absolute_path(path_str: str) -> str:
+    """
+    상대 경로를 절대 경로로 변환 (Windows 경로 지원)
+
+    Args:
+        path_str: 변환할 경로 문자열
+
+    Returns:
+        절대 경로
+    """
+    # Windows 드라이브 문자(C:\ 등)로 시작하는 경로 확인
+    if IS_WINDOWS and re.match(r'^[a-zA-Z]:\\', path_str):
+        logger.info(f"Windows 절대 경로 감지: {path_str}")
+        # Windows 절대 경로는 그대로 사용
+        return path_str
+
+    path = Path(path_str)
+    if path.is_absolute():
+        return str(path)
+
+    # 스크립트 디렉토리 기준 경로
+    script_based_path = Path(script_dir) / path
+
+    # 현재 작업 디렉토리 기준 경로
+    cwd_based_path = Path.cwd() / path
+
+    # 두 경로 중 존재하는 경로 우선 사용
+    if script_based_path.exists():
+        return str(script_based_path)
+    elif cwd_based_path.exists():
+        return str(cwd_based_path)
+    else:
+        # 기본적으로 현재 작업 디렉토리 기준 경로 반환
+        return str(cwd_based_path)
+
+# Windows 경로 처리를 위한 유틸리티 함수
+def normalize_path(path_str: str) -> str:
+    """
+    경로 문자열을 정규화하여 OS에 맞게 변환
+
+    Args:
+        path_str: 변환할 경로 문자열
+
+    Returns:
+        정규화된 경로
+    """
+    # Windows 경로 형식('\')��� OS에 맞게 변환
+    return os.path.normpath(path_str)
+
+# 기본 디렉토리 설정 (절대 경로로 변환)
+PDF_DIRECTORY_RAW = get_env("PDF_DIRECTORY", "documents")
+# Windows 백슬래시 이중 처리를 위해 정규화
+PDF_DIRECTORY_RAW = normalize_path(PDF_DIRECTORY_RAW)
+PDF_DIRECTORY = ensure_absolute_path(PDF_DIRECTORY_RAW)
+
+CACHE_DIRECTORY_RAW = get_env("CACHE_DIRECTORY", "cached_data")
+CACHE_DIRECTORY_RAW = normalize_path(CACHE_DIRECTORY_RAW)
+CACHE_DIRECTORY = ensure_absolute_path(CACHE_DIRECTORY_RAW)
+
+logger.info(f"PDF 디렉토리 (원본): {PDF_DIRECTORY_RAW}")
+logger.info(f"PDF 디렉토리 (절대): {PDF_DIRECTORY}")
+logger.info(f"캐시 디렉토리 (원본): {CACHE_DIRECTORY_RAW}")
+logger.info(f"캐시 디렉토리 (절대): {CACHE_DIRECTORY}")
+
+# 청킹 설정
+CHUNK_SIZE = int(get_env("CHUNK_SIZE", "1000"))
+CHUNK_OVERLAP = int(get_env("CHUNK_OVERLAP", "200"))
+
+# API 키 및 환경 설정
+OPENAI_API_KEY = get_env("OPENAI_API_KEY", "")
+LANGFUSE_PUBLIC_KEY = get_env("LANGFUSE_PUBLIC_KEY", "")
+LANGFUSE_SECRET_KEY = get_env("LANGFUSE_SECRET_KEY", "")
+LANGFUSE_HOST = get_env("LANGFUSE_HOST", "https://cloud.langfuse.com")
+
+# DeepSeek 관련 설정 추가
+DEEPSEEK_API_KEY = get_env("DEEPSEEK_API_KEY", "")
+DEEPSEEK_ENDPOINT = get_env("DEEPSEEK_ENDPOINT", "https://api.deepseek.com/v1/chat/completions")
+DEEPSEEK_MODEL = get_env("DEEPSEEK_MODEL", "deepseek-chat")
+
+# 허깅페이스 환경에서 API 키 확인 및 로그 출력
+if IS_HUGGINGFACE:
+    logger.info(f"허깅페이스 환경에서 DeepSeek API 키 존재 여부: {bool(DEEPSEEK_API_KEY)}")
+    # 보안을 위해 API 키 첫 4자리와 마지막 4자리만 표시 (키가 존재하는 경우)
+    if DEEPSEEK_API_KEY:
+        masked_key = DEEPSEEK_API_KEY[:4] + "****" + DEEPSEEK_API_KEY[-4:] if len(DEEPSEEK_API_KEY) > 8 else "****"
+        logger.info(f"DeepSeek API 키: {masked_key}")
+
+    logger.info(f"DeepSeek 모델: {DEEPSEEK_MODEL}")
+    logger.info(f"DeepSeek 엔드포인트: {DEEPSEEK_ENDPOINT}")
+
+# Milvus 벡터 DB 설정
+MILVUS_HOST = get_env("MILVUS_HOST", "localhost")
+MILVUS_PORT = get_env("MILVUS_PORT", "19530")
+MILVUS_COLLECTION = get_env("MILVUS_COLLECTION", "pdf_documents")
+
+# 임베딩 모델 설정
+EMBEDDING_MODEL = get_env("EMBEDDING_MODEL", "Alibaba-NLP/gte-multilingual-base")  # 다국어 지원 모델
+RERANKER_MODEL = get_env("RERANKER_MODEL", "Alibaba-NLP/gte-multilingual-reranker-base")  # 다국어 지원 리랭커
+
+# LLM 모델 설정 (환경에 따라 자동 선택)
+USE_OPENAI = get_env("USE_OPENAI", "False").lower() == "true"
+USE_DEEPSEEK = get_env("USE_DEEPSEEK", "False").lower() == "true"
+
+# 허깅페이스 환경에서는 DeepSeek 우선 사용
+if IS_HUGGINGFACE:
+    # 허깅페이스 환경에서 DeepSeek API 키가 있는지 확인
+    if DEEPSEEK_API_KEY:
+        USE_DEEPSEEK = True
+        USE_OPENAI = False
+        LLM_MODEL = DEEPSEEK_MODEL
+        logger.info("HuggingFace Spaces 환경: DeepSeek 모델 사용")
+    else:
+        logger.warning("HuggingFace Spaces 환경에서 DeepSeek API 키가 설정되지 않았습니다.")
+        USE_DEEPSEEK = False
+        USE_OPENAI = False  # 기본적으로 API 키가 없으면 비활성화
+        LLM_MODEL = get_env("LLM_MODEL", "gemma3:latest")  # 대체 모델 설정
+        logger.info(f"HuggingFace Spaces 환경: DeepSeek API 키 없음, LLM 모델: {LLM_MODEL}")
+else:
+    # 로컬 환경에서는 설정에 따라 LLM 선택
+    if USE_DEEPSEEK:
+        LLM_MODEL = DEEPSEEK_MODEL
+        logger.info(f"로컬 환경: DeepSeek 모델 사용 ({DEEPSEEK_MODEL})")
+    elif USE_OPENAI:
+        LLM_MODEL = get_env("LLM_MODEL", "gpt-3.5-turbo")
+        logger.info(f"로컬 환경: OpenAI 모델 사용 ({LLM_MODEL})")
+    else:
+        LLM_MODEL = get_env("LLM_MODEL", "gemma3:latest")
+        OLLAMA_HOST = get_env("OLLAMA_HOST", "http://localhost:11434")
+        logger.info(f"로컬 환경: Ollama 모델 사용 ({LLM_MODEL})")
+
+# API 키 검증 (로컬 환경만)
+if not IS_HUGGINGFACE:
+    if USE_DEEPSEEK and not DEEPSEEK_API_KEY:
+        logger.warning("DeepSeek 모델이 선택되었지만 API 키가 설정되지 않았습니다.")
+        USE_DEEPSEEK = False
+        USE_OPENAI = False
+        LLM_MODEL = get_env("LLM_MODEL", "gemma3:latest")
+        logger.info("DeepSeek API 키가 없어 Ollama로 폴백합니다.")
+    elif USE_OPENAI and not OPENAI_API_KEY:
+        logger.warning("OpenAI 모델이 선택되었지만 API 키가 설정되지 않았습니다.")
+        logger.warning("OpenAI API 키가 없어 Ollama로 폴백합니다.")
+        USE_OPENAI = False
+        LLM_MODEL = get_env("LLM_MODEL", "gemma3:latest")
+
+# DeepSeek API 테스트 함수
+def test_deepseek_connection():
+    """
+    DeepSeek API 연결 테스트
+
+    Returns:
+        테스트 결과 딕셔너리 (성공 여부 및 메시지)
+    """
+    if not DEEPSEEK_API_KEY:
+        logger.warning("DeepSeek API 키가 설정되지 않아 테스트를 건너뜁니다.")
+        return {
+            "success": False,
+            "message": "API 키가 설정되지 않았습니다.",
+            "status_code": None
+        }
+
+    try:
+        logger.info(f"DeepSeek API 연결 테스트 시작: {DEEPSEEK_ENDPOINT}, 모델: {DEEPSEEK_MODEL}")
+
+        # 테스트용 간단한 프롬프트
+        test_prompt = "Hello, please respond with a short greeting."
+
+        # API 요청 헤더 및 데이터
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {DEEPSEEK_API_KEY}"
+        }
+
+        payload = {
+            "model": DEEPSEEK_MODEL,
+            "messages": [{"role": "user", "content": test_prompt}],
+            "temperature": 0.7,
+            "max_tokens": 50
+        }
+
+        # API 요청 전송
+        response = requests.post(
+            DEEPSEEK_ENDPOINT,
+            headers=headers,
+            json=payload,
+            timeout=10  # 10초 타임아웃
+        )
+
+        # 응답 확인
+        if response.status_code == 200:
+            logger.info("DeepSeek API 연결 성공")
+            return {
+                "success": True,
+                "message": "API 연결 성공",
+                "status_code": response.status_code
+            }
+        else:
+            logger.error(f"DeepSeek API 오류: 상태 코드 {response.status_code}")
+            error_message = ""
+            try:
+                error_data = response.json()
+                error_message = error_data.get("error", {}).get("message", str(error_data))
+            except:
+                error_message = response.text
+
+            return {
+                "success": False,
+                "message": f"API 오류: {error_message}",
+                "status_code": response.status_code
+            }
+
+    except requests.exceptions.Timeout:
+        logger.error("DeepSeek API 요청 시간 초과")
+        return {
+            "success": False,
+            "message": "API 요청 시간 초과",
+            "status_code": None
+        }
+    except requests.exceptions.ConnectionError:
+        logger.error("DeepSeek API 연결 실패")
+        return {
+            "success": False,
+            "message": "API 서버 연결 실패",
+            "status_code": None
+        }
+    except Exception as e:
+        logger.error(f"DeepSeek API 테스트 중 예상치 못한 오류: {e}", exc_info=True)
+        return {
+            "success": False,
+            "message": f"예상치 못한 오류: {str(e)}",
+            "status_code": None
+        }
+
+# 벡터 검색 설정
+TOP_K_RETRIEVAL = int(get_env("TOP_K_RETRIEVAL", "5"))  # 벡터 검색 결과 수
+TOP_K_RERANK = int(get_env("TOP_K_RERANK", "3"))  # 리랭킹 후 선택할 결과 수
+
+# 로깅 설정
+LOG_LEVEL = get_env("LOG_LEVEL", "INFO")
+LOG_FILE = get_env("LOG_FILE", "autorag.log")
+
+# 설정 정보 출력 (디버깅용)
+def print_config():
+    """현재 설정 정보를 로그에 출력"""
+    logger.info("===== 현재 설정 정보 =====")
+    logger.info(f"실행 환경: {'HuggingFace Spaces' if IS_HUGGINGFACE else '로컬'}")
+    logger.info(f"문서 디렉토리: {PDF_DIRECTORY}")
+    logger.info(f"캐시 디렉토리: {CACHE_DIRECTORY}")
+    logger.info(f"청크 크기: {CHUNK_SIZE}, 오버랩: {CHUNK_OVERLAP}")
+    logger.info(f"OpenAI 사용: {USE_OPENAI}")
+    logger.info(f"DeepSeek 사용: {USE_DEEPSEEK}")
+    logger.info(f"LLM 모델: {LLM_MODEL}")
+    if not USE_OPENAI and not USE_DEEPSEEK and not IS_HUGGINGFACE:
+        logger.info(f"Ollama 호스트: {OLLAMA_HOST}")
+    logger.info(f"임베딩 모델: {EMBEDDING_MODEL}")
+    logger.info(f"리랭커 모델: {RERANKER_MODEL}")
+    logger.info(f"TOP_K 검색: {TOP_K_RETRIEVAL}, 리랭킹: {TOP_K_RERANK}")
+    logger.info("=========================")
+
+# 설정 유효성 검사
+def validate_config() -> Dict[str, Any]:
+    """
+    현재 설정의 유효성을 검사하고 경고나 오류를 로그에 기록
+
+    Returns:
+        검증 결과 (status: 상태, warnings: 경고 목록)
+    """
+    warnings = []
+
+    # 디렉토리 확인
+    if not os.path.exists(PDF_DIRECTORY):
+        warnings.append(f"PDF 디렉토리({PDF_DIRECTORY})가 존재하지 않습니다.")
+
+    # API 키 확인 (허깅페이스와 로컬 환경 구분)
+    if IS_HUGGINGFACE:
+        if USE_DEEPSEEK and not DEEPSEEK_API_KEY:
+            warnings.append("허깅페이스 환경에서 DeepSeek 사용이 설정되었지만 API 키가 제공되지 않았습니다.")
+    else:
+        if USE_OPENAI and not OPENAI_API_KEY:
+            warnings.append("OpenAI 사용이 설정되었지만 API 키가 제공되지 않았습니다.")
+
+        if USE_DEEPSEEK and not DEEPSEEK_API_KEY:
+            warnings.append("DeepSeek 사용이 설정되었지만 API 키가 제공되지 않았습니다.")
+
+    # 모델 및 설정 값 확인
+    if CHUNK_SIZE <= CHUNK_OVERLAP:
+        warnings.append(f"청크 크기({CHUNK_SIZE})가 오버랩({CHUNK_OVERLAP})보다 작거나 같습니다.")
+
+    # DeepSeek API 연결 확인 (설정된 경우)
+    if USE_DEEPSEEK and DEEPSEEK_API_KEY:
+        deepseek_test_result = test_deepseek_connection()
+        if not deepseek_test_result["success"]:
+            warnings.append(f"DeepSeek API 연결 테스트 실패: {deepseek_test_result['message']}")
+
+    # 결과 기록
+    if warnings:
+        for warning in warnings:
+            logger.warning(warning)
+
+    return {
+        "status": "valid" if not warnings else "warnings",
+        "warnings": warnings
+    }
+
+# 설정 로드 시 실행
+print_config()
+config_status = validate_config()

custom_rag_chain.py

@@ -0,0 +1,224 @@
+"""
+DeepSeek API를 활용한 커스텀 RAG 체인 구현
+"""
+import os
+import logging
+import time
+from typing import List, Dict, Any, Optional, Tuple
+
+from langchain.schema import Document
+from langchain.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+
+# DeepSeek 커스텀 LLM 임포트
+from deepseek_llm import DeepSeekLLM, DeepSeekChat
+
+# 설정 가져오기
+try:
+    from config import (
+        DEEPSEEK_API_KEY, DEEPSEEK_MODEL, DEEPSEEK_ENDPOINT,
+        TOP_K_RETRIEVAL, TOP_K_RERANK
+    )
+except ImportError:
+    # 설정 모듈을 가져올 수 없는 경우 기본값 설정
+    DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY", "")
+    DEEPSEEK_MODEL = os.environ.get("DEEPSEEK_MODEL", "deepseek-chat")
+    DEEPSEEK_ENDPOINT = os.environ.get("DEEPSEEK_ENDPOINT", "https://api.deepseek.com/v1/chat/completions")
+    TOP_K_RETRIEVAL = int(os.environ.get("TOP_K_RETRIEVAL", "5"))
+    TOP_K_RERANK = int(os.environ.get("TOP_K_RERANK", "3"))
+
+# 로깅 설정
+logger = logging.getLogger("CustomRAGChain")
+
+
+class CustomRAGChain:
+    """
+    DeepSeek API를 활용한 커스텀 RAG 체인
+    """
+
+    def __init__(self, vector_store, use_reranker=False):
+        """
+        RAG 체인 초기화
+
+        Args:
+            vector_store: 벡터 스토어 인스턴스
+            use_reranker: 리랭커 사용 여부 (현재 미지원)
+        """
+        logger.info("커스텀 RAG 체인 초기화...")
+        self.vector_store = vector_store
+        self.use_reranker = use_reranker
+
+        # API 키 확인
+        if not DEEPSEEK_API_KEY:
+            logger.error("DeepSeek API 키가 설정되지 않았습니다.")
+            raise ValueError("DeepSeek API 키가 설정되지 않았습니다.")
+
+        # DeepSeek LLM 초기화
+        try:
+            self.llm = DeepSeekLLM(
+                api_key=DEEPSEEK_API_KEY,
+                model=DEEPSEEK_MODEL,
+                endpoint=DEEPSEEK_ENDPOINT,
+                temperature=0.3,
+                max_tokens=1000,
+                request_timeout=120,
+                max_retries=5
+            )
+            logger.info(f"DeepSeek LLM 초기화 성공: {DEEPSEEK_MODEL}")
+        except Exception as e:
+            logger.error(f"DeepSeek LLM 초기화 실패: {e}")
+            raise ValueError(f"DeepSeek LLM 초기화 실패: {str(e)}")
+
+        # 챗 인터페이스 초기화 (대체용)
+        self.chat = DeepSeekChat(
+            api_key=DEEPSEEK_API_KEY,
+            model=DEEPSEEK_MODEL,
+            endpoint=DEEPSEEK_ENDPOINT
+        )
+
+        # RAG 프롬프트 템플릿
+        self.prompt = PromptTemplate.from_template("""
+다음 정보를 기반으로 질문에 정확하게 답변해주세요.
+
+질문: {question}
+
+참고 정보:
+{context}
+
+참고 정보에 답이 있으면 반드시 그 정보를 기반으로 답변하세요.
+참고 정보에 답이 없는 경우에는 일반적인 지식을 활용하여 답변할 수 있지만, "제공된 문서에는 이 정보가 없으나, 일반적으로는..." 식으로 시작하세요.
+답변은 정확하고 간결하게 제공하되, 가능한 참고 정보에서 근거를 찾아 설명해주세요.
+참고 정보의 출처도 함께 알려주세요.
+""")
+
+        # RAG 체인 구성
+        self.chain = (
+                {"context": self._retrieve, "question": RunnablePassthrough()}
+                | self.prompt
+                | self.llm
+                | StrOutputParser()
+        )
+
+        logger.info("커스텀 RAG 체인 초기화 완료")
+
+    def _retrieve(self, query: str) -> str:
+        """
+        쿼리에 대한 관련 문서 검색 및 컨텍스트 구성
+
+        Args:
+            query: 사용자 질문
+
+        Returns:
+            검색 결과를 포함한 컨텍스트 문자열
+        """
+        if not query or not query.strip():
+            logger.warning("빈 쿼리로 검색 시도")
+            return "검색 쿼리가 비어있습니다."
+
+        try:
+            # 벡터 검색 수행
+            logger.info(f"벡터 검색 수행: '{query[:50]}{'...' if len(query) > 50 else ''}'")
+            docs = self.vector_store.similarity_search(query, k=TOP_K_RETRIEVAL)
+
+            if not docs:
+                logger.warning("검색 결과가 없습니다")
+                return "관련 문서를 찾을 수 없습니다."
+
+            # 검색 결과 컨텍스트 구성
+            context_parts = []
+            for i, doc in enumerate(docs, 1):
+                source = doc.metadata.get("source", "알 수 없는 출처")
+                page = doc.metadata.get("page", "")
+                source_info = f"{source}"
+                if page:
+                    source_info += f" (페이지: {page})"
+
+                context_parts.append(f"[참고자료 {i}] - 출처: {source_info}\n{doc.page_content}\n")
+
+            context = "\n".join(context_parts)
+
+            # ��텍스트 길이 제한 (토큰 수 제한)
+            if len(context) > 6000:
+                logger.warning(f"컨텍스트가 너무 깁니다 ({len(context)} 문자). 제한합니다.")
+                context = context[:2500] + "\n...(중략)...\n" + context[-2500:]
+
+            logger.info(f"컨텍스트 생성 완료: {len(context_parts)}개 문서, {len(context)} 문자")
+            return context
+
+        except Exception as e:
+            logger.error(f"검색 중 오류: {e}")
+            return f"검색 중 오류 발생: {str(e)}"
+
+    def run(self, query: str) -> str:
+        """
+        사용자 쿼리에 대한 RAG 파이프라인 실행
+
+        Args:
+            query: 사용자 질문
+
+        Returns:
+            모델 응답 문자열
+        """
+        if not query or not query.strip():
+            logger.warning("빈 쿼리로 실행 시도")
+            return "질문이 비어있습니다. 질문을 입력해 주세요."
+
+        try:
+            logger.info(f"RAG 체인 실행: '{query[:50]}{'...' if len(query) > 50 else ''}'")
+            start_time = time.time()
+
+            # 벡터 검색 실행
+            context = self._retrieve(query)
+
+            # 직접 LLM 호출 (체인 사용)
+            try:
+                response = self.chain.invoke(query)
+                logger.info(f"LangChain 체인 호출 성공")
+            except Exception as chain_error:
+                logger.error(f"체인 호출 실패: {chain_error}, 대체 방식 시도")
+
+                # 대체 방식: 직접 채팅 API 호출
+                try:
+                    prompt = self.prompt.format(question=query, context=context)
+                    response = self.chat.generate([{"role": "user", "content": prompt}])
+                    logger.info("대체 채팅 API 호출 성공")
+                except Exception as chat_error:
+                    logger.error(f"대체 채팅 API 호출 실패: {chat_error}")
+
+                    # 미리 정의된 응답으로 폴백
+                    predefined_answers = {
+                        "대한민국의 수도": "대한민국의 수도는 서울입니다.",
+                        "수도": "대한민국의 수도는 서울입니다.",
+                        "누구야": "저는 RAG 기반 질의응답 시스템입니다. 문서를 검색하고 관련 정보를 찾아드립니다.",
+                        "안녕": "안녕하세요! 무엇을 도와드릴까요?",
+                        "뭐해": "사용자의 질문에 답변하기 위해 문서를 검색하고 있습니다. 무엇을 알려드릴까요?"
+                    }
+
+                    # 질문에 맞는 미리 정의된 응답이 있는지 확인
+                    for key, answer in predefined_answers.items():
+                        if key in query.lower():
+                            response = answer
+                            logger.info(f"미리 정의된 응답 제공: {key}")
+                            break
+                    else:
+                        # 검색 결과만 표시
+                        response = f"""
+API 연결 오류로 인해 검색 결과만 표시합니다.
+
+질문: {query}
+
+검색된 관련 문서:
+{context}
+
+[참고] API 연결 문제로 인해 자동 요약이 제공되지 않습니다. 다시 시도하거나 다른 질문을 해보세요.
+"""
+                        logger.info("검색 결과만 표시")
+
+            end_time = time.time()
+            logger.info(f"RAG 체인 실행 완료: {end_time - start_time:.2f}초")
+            return response
+
+        except Exception as e:
+            logger.error(f"RAG 체인 실행 중 오류: {e}")
+            return f"질문 처리 중 오류가 발생했습니다: {str(e)}"

deepseek_utils.py

@@ -0,0 +1,170 @@
+"""
+DeepSeek API 테스트 및 유틸리티 기능
+"""
+import os
+import logging
+import requests
+import json
+from typing import Dict, Any, Optional
+
+# 로깅 설정
+logger = logging.getLogger("DeepSeekUtils")
+
+
+class DeepSeekError(Exception):
+    """DeepSeek API 관련 오류"""
+    pass
+
+
+def test_deepseek_api(api_key: str, endpoint: str, model: str) -> Dict[str, Any]:
+    """
+    DeepSeek API 연결 테스트
+
+    Args:
+        api_key: DeepSeek API 키
+        endpoint: DeepSeek API 엔드포인트
+        model: 사용할 모델명
+
+    Returns:
+        테스트 결과 딕셔너리 (성공 여부 및 메시지)
+    """
+    if not api_key:
+        logger.error("DeepSeek API 키가 제공되지 않았습니다.")
+        return {
+            "success": False,
+            "message": "API 키가 제공되지 않았습니다.",
+            "status_code": None,
+            "response": None
+        }
+
+    try:
+        logger.info(f"DeepSeek API 연결 테스트 시작: {endpoint}, 모델: {model}")
+
+        # 테스트용 간단한 프롬프트
+        test_prompt = "Hello, please respond with a short greeting."
+
+        # API 요청 헤더 및 데이터
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+
+        payload = {
+            "model": model,
+            "messages": [{"role": "user", "content": test_prompt}],
+            "temperature": 0.7,
+            "max_tokens": 50
+        }
+
+        # API 요청 전송
+        response = requests.post(
+            endpoint,
+            headers=headers,
+            data=json.dumps(payload),
+            timeout=10  # 10초 타임아웃
+        )
+
+        # 응답 확인
+        if response.status_code == 200:
+            logger.info("DeepSeek API 연결 성공")
+            response_data = response.json()
+
+            # 응답 내용 확인
+            if "choices" in response_data and len(response_data["choices"]) > 0:
+                message_content = response_data["choices"][0].get("message", {}).get("content", "")
+                return {
+                    "success": True,
+                    "message": "API 연결 성공",
+                    "status_code": response.status_code,
+                    "response": message_content[:100] + "..." if len(message_content) > 100 else message_content
+                }
+            else:
+                return {
+                    "success": True,
+                    "message": "API 연결 성공했으나 응답 형식이 예상과 다릅니다.",
+                    "status_code": response.status_code,
+                    "response": response_data
+                }
+        else:
+            logger.error(f"DeepSeek API 오류: 상태 코드 {response.status_code}")
+            error_message = ""
+            try:
+                error_data = response.json()
+                error_message = error_data.get("error", {}).get("message", str(error_data))
+            except:
+                error_message = response.text
+
+            return {
+                "success": False,
+                "message": f"API 오류: {error_message}",
+                "status_code": response.status_code,
+                "response": error_message
+            }
+
+    except requests.exceptions.Timeout:
+        logger.error("DeepSeek API 요청 시간 초과")
+        return {
+            "success": False,
+            "message": "API 요청 시간 초과",
+            "status_code": None,
+            "response": None
+        }
+    except requests.exceptions.ConnectionError:
+        logger.error("DeepSeek API 연결 실패")
+        return {
+            "success": False,
+            "message": "API 서버 연결 실패",
+            "status_code": None,
+            "response": None
+        }
+    except Exception as e:
+        logger.error(f"DeepSeek API 테스트 중 예상치 못한 오류: {e}", exc_info=True)
+        return {
+            "success": False,
+            "message": f"예상치 못한 오류: {str(e)}",
+            "status_code": None,
+            "response": None
+        }
+
+
+def create_deepseek_client(api_key: str, endpoint: str, model: str):
+    """
+    DeepSeek 클라이언트 생성 (LangChain 호환)
+
+    Args:
+        api_key: DeepSeek API 키
+        endpoint: DeepSeek API 엔드포인트
+        model: 사용할 모델명
+
+    Returns:
+        DeepSeek 클라이언트 객체 또는 None
+    """
+    # LangChain과 DeepSeek 통합 시도
+    try:
+        from langchain_openai import ChatOpenAI
+
+        # API 연결 테스트 먼저 수행
+        test_result = test_deepseek_api(api_key, endpoint, model)
+
+        if not test_result["success"]:
+            logger.error(f"DeepSeek API 연결 테스트 실패: {test_result['message']}")
+            return None
+
+        # 정상 연결 시 클라이언트 생성
+        # DeepSeek는 OpenAI 호환 API를 제공하므로 ChatOpenAI를 사용
+        client = ChatOpenAI(
+            model=model,
+            temperature=0.2,
+            api_key=api_key,
+            base_url=endpoint.rstrip("/v1/chat/completions"),  # OpenAI 호환 베이스 URL
+        )
+
+        logger.info(f"DeepSeek 클라이언트 생성 성공: {model}")
+        return client
+
+    except ImportError as e:
+        logger.error(f"필요한 라이브러리 임포트 실패: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"DeepSeek 클라이언트 생성 중 오류: {e}", exc_info=True)
+        return None

dir

@@ -0,0 +1,154 @@
+"""
+동의어 처리 모듈
+"""
+import os
+import sys
+import re
+from typing import Dict, List, Optional, Set
+
+# 기본 동의어 사전 (MP_synonyms.py 파일이 없을 경우 사용)
+DEFAULT_SYNONYMS = {
+    "엑츄레이터": "액츄에이터",
+    "액츄에이터": "액츄에이터",
+    "모터": "액츄에이터",
+    "컨박": "컨트롤박스"
+}
+
+
+class SynonymsHandler:
+    """
+    부품명의 동의어를 처리하는 클래스
+    """
+
+    def __init__(self, synonyms_file: Optional[str] = None):
+        """
+        동의어 핸들러 초기화
+
+        Args:
+            synonyms_file: 동의어 파일 경로 (선택적)
+        """
+        self.synonyms = {}
+        self.loaded = False
+
+        # 1. 기본 제공된 파일 경로 확인
+        if synonyms_file and os.path.exists(synonyms_file):
+            self._load_from_file(synonyms_file)
+
+        # 2. 일반적인 위치 확인 (.venv/SYNONYMS/MP_synonyms.py)
+        elif os.path.exists(".venv/SYNONYMS/MP_synonyms.py"):
+            self._load_from_file(".venv/SYNONYMS/MP_synonyms.py")
+
+        # 3. 현재 디렉토리 확인
+        elif os.path.exists("MP_synonyms.py"):
+            self._load_from_file("MP_synonyms.py")
+
+        # 4. 기본 동의어 사용
+        else:
+            print("동의어 파일을 찾을 수 없어 기본 동의어 사전을 사용합니다.")
+            self.synonyms = DEFAULT_SYNONYMS
+            self.loaded = True
+
+    def _load_from_file(self, file_path: str) -> None:
+        """
+        파일에서 동의어 사전 로드
+
+        Args:
+            file_path: 동의어 파일 경로
+        """
+        try:
+            # 파일 내용 읽기
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            # SYNONYMS 딕셔너리 추출
+            synonyms_match = re.search(r'SYNONYMS\s*=\s*\{(.*?)\}', content, re.DOTALL)
+            if synonyms_match:
+                # 실행하지 않고 변환하는 방법
+                synonyms_str = "{" + synonyms_match.group(1) + "}"
+
+                # 정규식을 사용하여 딕셔너리 형태로 파싱
+                pattern = r'"([^"]*)"\s*:\s*"([^"]*)"'
+                matches = re.findall(pattern, synonyms_str)
+
+                self.synonyms = {key: value for key, value in matches}
+                self.loaded = True
+                print(f"동의어 사전 로드 완료: {file_path}, {len(self.synonyms)}개 항목")
+            else:
+                print(f"파일에서 SYNONYMS 딕셔너리를 찾을 수 없습니다: {file_path}")
+                self.synonyms = DEFAULT_SYNONYMS
+                self.loaded = True
+
+        except Exception as e:
+            print(f"동의어 사전 로드 중 오류: {e}")
+            self.synonyms = DEFAULT_SYNONYMS
+            self.loaded = True
+
+    def find_in_text(self, text: str) -> List[str]:
+        """
+        텍스트에서 동의어 찾기
+
+        Args:
+            text: 검색할 텍스트
+
+        Returns:
+            찾은 표준화된 부품명 리스트
+        """
+        if not text or not self.loaded:
+            return []
+
+        # 공백 제거 및 소문자 변환
+        text = text.lower()
+
+        found_parts = set()
+
+        # 동의어 키워드가 텍스트에 포함되어 있는지 확인
+        for keyword, standard_name in self.synonyms.items():
+            if keyword.lower() in text:
+                found_parts.add(standard_name)
+
+        return list(found_parts)
+
+    def standardize(self, part_name: str) -> str:
+        """
+        부품명을 표준화
+
+        Args:
+            part_name: 표준화할 부품명
+
+        Returns:
+            표준화된 부품명
+        """
+        if not part_name or not self.loaded:
+            return part_name
+
+        # 소문자 변환하여 비교
+        part_lower = part_name.lower().strip()
+
+        # 동의어 사전에서 검색
+        for keyword, standard_name in self.synonyms.items():
+            if part_lower == keyword.lower():
+                return standard_name
+
+        # 매칭되지 않으면 원래 이름 반환
+        return part_name
+
+    def standardize_parts_list(self, parts: List[str]) -> List[str]:
+        """
+        부품명 리스트를 표준화
+
+        Args:
+            parts: 표준화할 부품명 리스트
+
+        Returns:
+            표준화된 부품명 리스트
+        """
+        if not parts or not self.loaded:
+            return parts
+
+        standardized = set()
+
+        for part in parts:
+            if part:
+                standardized.add(self.standardize(part))
+
+        return list(standardized)

direct_deepseek.py

@@ -0,0 +1,306 @@
+"""
+직접 DeepSeek API 호출을 위한 클라이언트 구현 - 허깅페이스 환경 지원
+"""
+import os
+import time
+import logging
+import requests
+import json
+from typing import Dict, Any, Optional, List
+
+# 로깅 설정
+logger = logging.getLogger("DirectDeepSeek")
+
+# 환경 감지
+IS_HUGGINGFACE = os.getenv('SPACE_ID') is not None or os.getenv('SYSTEM') == 'spaces'
+
+class DirectDeepSeekClient:
+    """
+    DeepSeek API를 직접 호출하는 클라이언트
+    OpenAI 클라이언트를 우회하고 직접 HTTP 요청 사용
+    허깅페이스 환경 지원
+    """
+    def __init__(self, api_key: Optional[str] = None, model_name: str = "deepseek-chat"):
+        """
+        클라이언트 초기화
+
+        Args:
+            api_key: DeepSeek API 키 (None인 경우 환경변수에서 가져옴)
+            model_name: 사용할 모델 이름 (기본값: "deepseek-chat")
+        """
+        # API 키 설정 (허깅페이스 환경 확인)
+        if api_key is None:
+            if IS_HUGGINGFACE:
+                # 허깅페이스 환경에서는 시크릿에서 가져오기 시도
+                api_key = os.getenv('HF_SECRET_DEEPSEEK_API_KEY')
+                if not api_key:
+                    # 시크릿이 없으면 일반 환경변수 확인
+                    api_key = os.getenv("DEEPSEEK_API_KEY", "")
+            else:
+                # 로컬 환경에서는 환경변수 사용
+                api_key = os.getenv("DEEPSEEK_API_KEY", "")
+
+        self.api_key = api_key
+        self.model_name = model_name
+
+        # 엔드포인트 설정 (허깅페이스 환경 확인)
+        if IS_HUGGINGFACE:
+            # 허깅페이스 환경에서는 시크릿에서 가져오기 시도
+            self.endpoint = os.getenv('HF_SECRET_DEEPSEEK_ENDPOINT')
+            if not self.endpoint:
+                # 시크릿이 없으면 일반 환경변수 확인
+                self.endpoint = os.getenv("DEEPSEEK_ENDPOINT", "https://api.deepseek.com/v1/chat/completions")
+        else:
+            # 로컬 환경에서는 환경변수 사용
+            self.endpoint = os.getenv("DEEPSEEK_ENDPOINT", "https://api.deepseek.com/v1/chat/completions")
+
+        logger.info(f"DirectDeepSeekClient 초기화: 모델={model_name}, 엔드포인트={self.endpoint}")
+
+        # API 키 확인
+        if not self.api_key:
+            if IS_HUGGINGFACE:
+                logger.warning("허깅페이스 환경에서 DeepSeek API 키가 설정되지 않았습니다. Space 시크릿을 확인하세요.")
+            else:
+                logger.warning("DeepSeek API 키가 설정되지 않았습니다. .env 파일이나 환경변수를 확인하세요.")
+
+    def generate(self,
+                 prompt: str,
+                 temperature: float = 0.3,
+                 max_tokens: int = 1000,
+                 max_retries: int = 3,
+                 timeout: int = 60) -> Dict[str, Any]:
+        """
+        텍스트 생성 요청
+
+        Args:
+            prompt: 입력 프롬프트
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
+
+        Returns:
+            생성 결과 딕셔너리 (success, response, message 등)
+        """
+        # 메시지 구성 (단일 사용자 메시지)
+        messages = [{"role": "user", "content": prompt}]
+        return self.chat(messages, temperature, max_tokens, max_retries, timeout)
+
+    def chat(self,
+             messages: List[Dict[str, str]],
+             temperature: float = 0.3,
+             max_tokens: int = 1000,
+             max_retries: int = 3,
+             timeout: int = 60) -> Dict[str, Any]:
+        """
+        채팅 API 호출
+
+        Args:
+            messages: 채팅 메시지 리스트 (role, content 키를 가진 딕셔너리 리스트)
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
+
+        Returns:
+            생성 결과 딕셔너리 (success, response, message 등)
+        """
+        # API 키 확인
+        if not self.api_key:
+            error_msg = "DeepSeek API 키가 설정되지 않았습니다."
+            logger.error(error_msg)
+            return {
+                "success": False,
+                "message": error_msg,
+                "status_code": None
+            }
+
+        # API 요청 헤더 및 데이터
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+
+        payload = {
+            "model": self.model_name,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+
+        # 재시도 로직
+        retry_delay = 1.0
+        attempt = 0
+
+        while attempt < max_retries:
+            attempt += 1
+            try:
+                logger.info(f"DeepSeek API 요청 시도 ({attempt}/{max_retries})...")
+
+                # API 요청 전송
+                response = requests.post(
+                    self.endpoint,
+                    headers=headers,
+                    json=payload,
+                    timeout=timeout
+                )
+
+                # 응답 확인
+                if response.status_code == 200:
+                    result = response.json()
+
+                    # 응답 내용 추출
+                    if "choices" in result and len(result["choices"]) > 0:
+                        message_content = result["choices"][0].get("message", {}).get("content", "")
+                        logger.info(f"DeepSeek API 응답 성공 (길이: {len(message_content)})")
+
+                        return {
+                            "success": True,
+                            "response": message_content,
+                            "status_code": response.status_code,
+                            "raw_response": result
+                        }
+                    else:
+                        logger.warning(f"DeepSeek API 응답은 성공했으나 예상치 못한 응답 형식: {result}")
+                        return {
+                            "success": False,
+                            "message": "응답에서 메시지를 찾을 수 없습니다",
+                            "status_code": response.status_code,
+                            "raw_response": result
+                        }
+                else:
+                    logger.error(f"DeepSeek API 오류: 상태 코드 {response.status_code}")
+
+                    # 오류 메시지 추출
+                    error_message = ""
+                    try:
+                        error_data = response.json()
+                        error_message = error_data.get("error", {}).get("message", str(error_data))
+                    except:
+                        error_message = response.text
+
+                    # 요청 한도 초과시 더 오래 대기
+                    if response.status_code == 429:
+                        retry_delay = min(retry_delay * 3, 15)
+                    else:
+                        retry_delay = min(retry_delay * 2, 10)
+
+                    if attempt < max_retries:
+                        logger.info(f"{retry_delay}초 후 재시도...")
+                        time.sleep(retry_delay)
+                    else:
+                        # 모든 시도 실패
+                        return {
+                            "success": False,
+                            "message": f"API 오류: {error_message}",
+                            "status_code": response.status_code
+                        }
+
+            except requests.exceptions.Timeout:
+                logger.error("DeepSeek API 요청 시간 초과")
+
+                if attempt < max_retries:
+                    logger.info(f"{retry_delay}초 후 재시도...")
+                    time.sleep(retry_delay)
+                    retry_delay = min(retry_delay * 2, 10)
+                else:
+                    return {
+                        "success": False,
+                        "message": "API 요청 시간 초과",
+                        "status_code": None
+                    }
+
+            except requests.exceptions.ConnectionError:
+                logger.error("DeepSeek API 연결 실패")
+
+                if attempt < max_retries:
+                    logger.info(f"{retry_delay}초 후 재시도...")
+                    time.sleep(retry_delay)
+                    retry_delay = min(retry_delay * 2, 10)
+                else:
+                    return {
+                        "success": False,
+                        "message": "API 서버 연결 실패",
+                        "status_code": None
+                    }
+
+            except Exception as e:
+                logger.error(f"DeepSeek API 요청 중 예상치 못한 오류: {e}")
+
+                if attempt < max_retries:
+                    logger.info(f"{retry_delay}초 후 재시도...")
+                    time.sleep(retry_delay)
+                    retry_delay = min(retry_delay * 2, 10)
+                else:
+                    return {
+                        "success": False,
+                        "message": f"예상치 못한 오류: {str(e)}",
+                        "status_code": None
+                    }
+
+        # 모든 시도 실패
+        return {
+            "success": False,
+            "message": "최대 재시도 횟수 초과",
+            "status_code": None
+        }
+
+    def system_prompt_chat(self,
+                           system_prompt: str,
+                           user_prompt: str,
+                           temperature: float = 0.3,
+                           max_tokens: int = 1000,
+                           max_retries: int = 3,
+                           timeout: int = 60) -> Dict[str, Any]:
+        """
+        시스템 프롬프트와 사용자 프롬프트를 이용한 채팅 API 호출
+
+        Args:
+            system_prompt: 시스템 프롬프트
+            user_prompt: 사용자 프롬프트
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
+
+        Returns:
+            생성 결과 딕셔너리
+        """
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+
+        return self.chat(messages, temperature, max_tokens, max_retries, timeout)
+
+
+# 단독 실행을 위한 테스트 코드
+if __name__ == "__main__":
+    # 로깅 설정
+    logging.basicConfig(level=logging.INFO)
+
+    # 허깅페이스 환경 확인
+    if IS_HUGGINGFACE:
+        print("허깅페이스 환경에서 실행 중입니다.")
+        print("HF_SECRET_DEEPSEEK_API_KEY 시크릿 설정이 필요합니다.")
+    else:
+        print("로컬 환경에서 실행 중입니다.")
+        print("DEEPSEEK_API_KEY 환경변수 설정이 필요합니다.")
+
+    # 클라이언트 생성
+    client = DirectDeepSeekClient()
+
+    # API 키 확인
+    if not client.api_key:
+        print("DeepSeek API 키가 설정되지 않았습니다.")
+        exit(1)
+
+    # 간단한 테스트
+    response = client.generate("Hello, what can you do?")
+
+    # 결과 출력
+    if response["success"]:
+        print("응답 성공!")
+        print(response["response"])
+    else:
+        print(f"응답 실패: {response['message']}")

fallback_rag_chain.py

@@ -0,0 +1,230 @@
+"""
+폴백 RAG 체인 구현 (기본적인 기능만 포함) - 직접 DeepSeek API 호출 방식
+"""
+import os
+import logging
+import time
+from typing import List, Dict, Any, Optional, Tuple
+from langchain.schema import Document
+
+# 직접 DeepSeek 클라이언트 사용
+from direct_deepseek import DirectDeepSeekClient
+
+# 설정 가져오기
+from config import (
+    LLM_MODEL, USE_OPENAI, USE_DEEPSEEK,
+    DEEPSEEK_API_KEY, DEEPSEEK_ENDPOINT, DEEPSEEK_MODEL,
+    TOP_K_RETRIEVAL
+)
+
+# 로깅 설정
+logger = logging.getLogger("FallbackRAGChain")
+
+class FallbackRAGChain:
+    """
+    기본적인 RAG 체인 구현 (단순화된 버전, 문제 해결용)
+    직접 DeepSeek API 호출 방식 사용
+    """
+
+    def __init__(self, vector_store):
+        """
+        RAG 체인 초기화
+
+        Args:
+            vector_store: 벡터 스토어 인스턴스
+        """
+        logger.info("폴백 RAG 체인 초기화...")
+        self.vector_store = vector_store
+
+        # DeepSeek 모델 직접 초기화
+        if USE_DEEPSEEK and DEEPSEEK_API_KEY:
+            logger.info(f"DeepSeek 모델 직접 초기화: {DEEPSEEK_MODEL}")
+            try:
+                self.client = DirectDeepSeekClient(
+                    api_key=DEEPSEEK_API_KEY,
+                    model_name=DEEPSEEK_MODEL
+                )
+                logger.info("DeepSeek 모델 직접 초기화 성공")
+            except Exception as e:
+                logger.error(f"DeepSeek 모델 초기화 실패: {e}")
+                # 오프라인 모드로 폴백
+                self.client = None
+                logger.warning("LLM이 초기화되지 않아 오프라인 모드로 동작합니다.")
+        else:
+            # LLM이 설정되지 않음
+            logger.warning("LLM이 설정되지 않아 오프라인 모드로 동작합니다.")
+            self.client = None
+
+        logger.info("폴백 RAG 체인 초기화 완료")
+
+    def _retrieve(self, query: str) -> str:
+        """
+        쿼리에 대한 관련 문서 검색 및 컨텍스트 구성
+
+        Args:
+            query: 사용자 질문
+
+        Returns:
+            검색 결과를 포함한 컨텍스트 문자열
+        """
+        if not query or not query.strip():
+            return "검색 쿼리가 비어있습니다."
+
+        try:
+            # 벡터 검색 수행
+            logger.info(f"벡터 검색: '{query[:30]}...'")
+            docs = self.vector_store.similarity_search(query, k=TOP_K_RETRIEVAL)
+
+            if not docs:
+                return "관련 문서를 찾을 수 없습니다."
+
+            # 검색 결과 컨텍스트 구성
+            context_parts = []
+            for i, doc in enumerate(docs, 1):
+                source = doc.metadata.get("source", "알 수 없는 출처")
+                page = doc.metadata.get("page", "")
+                source_info = f"{source}"
+                if page:
+                    source_info += f" (페이지: {page})"
+
+                context_parts.append(f"[참고자료 {i}] - 출처: {source_info}\n{doc.page_content}\n")
+
+            context = "\n".join(context_parts)
+
+            # 컨텍스트 길이 제한 (토큰 수 제한)
+            if len(context) > 6000:
+                logger.warning(f"컨텍스트가 너무 깁니다 ({len(context)} 문자). 제한합니다.")
+                context = context[:2500] + "\n...(중략)...\n" + context[-2500:]
+
+            return context
+
+        except Exception as e:
+            logger.error(f"검색 중 오류: {e}")
+            return f"검색 중 오류 발생: {str(e)}"
+
+    def _generate_prompt(self, query: str, context: str) -> List[Dict[str, str]]:
+        """
+        프롬프트 생성 (DeepSeek API 형식)
+
+        Args:
+            query: 사용자 질문
+            context: 검색 결과 컨텍스트
+
+        Returns:
+            DeepSeek API용 messages 형식
+        """
+        # 시스템 프롬프트
+        system_prompt = """다음 정보를 기반으로 질문에 정확하게 답변해주세요.
+참고 정보에 답이 있으면 반드시 그 정보를 기반으로 답변하세요.
+참고 정보에 답이 없는 경우에는 일반적인 지식을 활용하여 답변할 수 있지만, "제공된 문서에는 이 정보가 없으나, 일반적으로는..." 식으로 시작하세요.
+답변은 정확하고 간결하게 제공하되, 가능한 참고 정보에서 근거를 찾아 설명해주세요.
+참고 정보의 출처도 함께 알려주세요."""
+
+        # 사용자 프롬프트 (질문과 컨텍스트 포함)
+        user_prompt = f"""질문: {query}
+
+참고 정보:
+{context}"""
+
+        # DeepSeek API에 맞는 메시지 포맷
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+
+        return messages
+
+    def _generate_simple_response(self, query: str, context: str) -> str:
+        """
+        간단한 오프라인 응답 생성 (LLM이 없을 때 사용)
+        """
+        # 기본 제공 응답 (일반적인 질문에 대한 정해진 응답)
+        predefined_answers = {
+            "대한민국의 수도": "대한민국의 수도는 서울입니다.",
+            "수도": "대한민국의 수도는 서울입니다.",
+            "누구야": "저는 RAG 기반 질의응답 시스템입니다. 문서를 검색하고 관련 정보를 찾아드립니다.",
+            "안녕": "안녕하세요! 무엇을 도와드릴까요?",
+            "뭐해": "사용자의 질문에 답변하기 위해 문서를 검색하고 있습니다. 무엇을 알려드릴까요?"
+        }
+
+        # 질문에 맞는 미리 정의된 응답이 있는지 확인
+        for key, answer in predefined_answers.items():
+            if key in query.lower():
+                return answer
+
+        # 미리 정의된 응답이 없으면 검색 결과만 표시
+        return f"""
+현재 LLM API 연결에 문제가 있어 검색 결과만 표시합니다.
+
+질문: {query}
+
+검색된 관련 문서:
+{context}
+
+[참고] 관련 정보를 찾으셨나요? API 연결 문제로 인해 자동 요약이 제공되지 않습니다. 다시 시도하거나 다른 질문을 해보세요.
+"""
+
+    def run(self, query: str) -> str:
+        """
+        사용자 쿼리에 대한 RAG 파이프라인 실행
+
+        Args:
+            query: 사용자 질문
+
+        Returns:
+            모델 응답 문자열
+        """
+        if not query or not query.strip():
+            return "질문이 비어있습니다. 질문을 입력해 주세요."
+
+        try:
+            logger.info(f"RAG 체인 실행: '{query[:30]}...'")
+
+            # 문서 검색
+            context = self._retrieve(query)
+
+            # LLM이 초기화되지 않은 경우 오프라인 응답
+            if self.client is None:
+                logger.warning("LLM이 초기화되지 않아 오프라인 응답 생성")
+                return self._generate_simple_response(query, context)
+
+            # 프롬프트 구성
+            messages = self._generate_prompt(query, context)
+
+            # 응답 생성 (최대 3회 시도)
+            max_retries = 3
+            retry_delay = 1.0
+
+            for attempt in range(max_retries):
+                try:
+                    logger.info(f"응답 생성 시도 ({attempt+1}/{max_retries})")
+
+                    # 직접 DeepSeek API 호출
+                    response = self.client.chat(messages)
+
+                    if response["success"]:
+                        logger.info(f"응답 생성 성공 (길이: {len(response['response'])})")
+                        return response["response"]
+                    else:
+                        logger.error(f"응답 생성 실패: {response['message']}")
+                        if attempt < max_retries - 1:
+                            logger.info(f"{retry_delay}초 후 재시도...")
+                            time.sleep(retry_delay)
+                            retry_delay *= 2
+                        else:
+                            # 모든 시도 실패 시 오프라인 응답
+                            logger.warning("최대 재시도 횟수 초과, 오프라인 응답 생성")
+                            return self._generate_simple_response(query, context)
+                except Exception as e:
+                    logger.error(f"응답 생성 중 오류: {e}")
+                    if attempt < max_retries - 1:
+                        logger.info(f"{retry_delay}초 후 재시도...")
+                        time.sleep(retry_delay)
+                        retry_delay *= 2
+                    else:
+                        # 모든 시도 실패 시 오프라인 응답 생성
+                        return self._generate_simple_response(query, context)
+
+        except Exception as e:
+            logger.error(f"RAG 체인 실행 중 오류: {e}")
+            return f"질문 처리 중 오류가 발생했습니다: {str(e)}"

optimized_document_processor.py

@@ -0,0 +1,346 @@
+"""
+CPU에 최적화된 문서 처리 모듈 - 병렬 처리 적용
+"""
+import os
+import time
+from typing import List, Dict, Any, Optional
+from langchain.schema import Document
+from concurrent.futures import ThreadPoolExecutor
+
+# 멀티프로세싱 가져오기
+import multiprocessing
+
+try:
+    CPU_COUNT = multiprocessing.cpu_count()
+except:
+    CPU_COUNT = 4
+
+print(f"CPU 코어 수: {CPU_COUNT}")
+
+# docling 라이브러리 존재 여부 확인
+try:
+    from docling.datamodel.base_models import InputFormat
+    from docling.document_converter import DocumentConverter, PdfFormatOption
+    from docling.datamodel.pipeline_options import PdfPipelineOptions, TableFormerMode
+    from docling.chunking import HybridChunker
+
+    DOCLING_AVAILABLE = True
+    print("docling 라이브러리 사용 가능")
+except ImportError:
+    print("docling 라이브러리를 찾을 수 없습니다. PyPDFLoader만 사용합니다.")
+    DOCLING_AVAILABLE = False
+
+# LangChain 문서 로더
+from langchain_community.document_loaders import PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+
+class OptimizedDocumentProcessor:
+    """
+    CPU에 최적화된 병렬 처리 문서 처리 클래스
+    """
+
+    def __init__(self,
+                 chunk_size: int = 1000,
+                 chunk_overlap: int = 200,
+                 tokenizer: str = "Alibaba-NLP/gte-multilingual-base",  # 올바른 모델 경로로 수정
+                 max_workers: int = CPU_COUNT):
+        """
+        문서 처리기 초기화
+
+        Args:
+            chunk_size: 텍스트 청크 크기
+            chunk_overlap: 청크 간 겹침 크기
+            tokenizer: HybridChunker에서 사용할 토크나이저
+            max_workers: 병렬 처리시 최대 작업자 수
+        """
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.tokenizer = tokenizer
+        self.max_workers = max(1, min(max_workers, CPU_COUNT))  # CPU 코어 수 초과하지 않도록
+
+        print(f"병렬 처리 작업자 수: {self.max_workers}")
+
+        # LangChain 텍스트 스플리터
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            separators=["\n\n", "\n", ". ", " ", ""],
+        )
+
+        # docling 관련 컴포넌트 초기화
+        if DOCLING_AVAILABLE:
+            # 파이프라인 옵션 설정
+            self.pipeline_options = PdfPipelineOptions(do_table_structure=True)
+            self.pipeline_options.table_structure_options.mode = TableFormerMode.ACCURATE
+
+            # 문서 변환기 초기화
+            self.doc_converter = DocumentConverter(
+                format_options={
+                    InputFormat.PDF: PdfFormatOption(pipeline_options=self.pipeline_options)
+                }
+            )
+
+            # HybridChunker 초기화 (trust_remote_code=True 추가)
+            self.hybrid_chunker = HybridChunker(
+                tokenizer=tokenizer,
+                chunk_size=chunk_size,
+                overlap=chunk_overlap,
+                tokenizer_kwargs={"trust_remote_code": True}  # 원격 코드 실행 허용
+            )
+
+            print(f"docling 초기화 완료: HybridChunker(청크 크기={chunk_size}, 오버랩={chunk_overlap})")
+
+    def process_with_docling(self, pdf_path: str) -> Dict[str, Any]:
+        """
+        docling을 사용하여 PDF 문서 처리
+
+        Args:
+            pdf_path: PDF 파일 경로
+
+        Returns:
+            처리된 문서 데이터
+        """
+        if not DOCLING_AVAILABLE:
+            raise ImportError("docling 라이브러리가 설치되지 않았습니다.")
+
+        try:
+            start_time = time.time()
+
+            # 문서 변환
+            conv_res = self.doc_converter.convert(pdf_path)
+            doc = conv_res.document
+
+            # 성능 측정
+            conversion_time = time.time() - start_time
+            print(f"PDF 변환 시간: {conversion_time:.2f}초")
+
+            # 메타데이터 추출
+            metadata = {
+                "source": pdf_path,
+                "title": os.path.basename(pdf_path),
+                "processing_time": conversion_time
+            }
+
+            return {
+                "content": doc.export_to_markdown(),
+                "metadata": metadata,
+                "raw_document": doc,
+            }
+
+        except Exception as e:
+            print(f"docling으로 문서 처리 중 오류 발생: {e}")
+            raise
+
+    def chunk_with_hybrid_chunker(self, doc: Any) -> List[Dict[str, Any]]:
+        """
+        HybridChunker를 사용하여 문서를 청크로 분할
+
+        Args:
+            doc: docling 문서 객체
+
+        Returns:
+            청크 리스트
+        """
+        start_time = time.time()
+
+        # 청킹 수행
+        chunk_iter = self.hybrid_chunker.chunk(doc)
+        chunks = list(chunk_iter)
+
+        chunking_time = time.time() - start_time
+        print(f"청킹 시간: {chunking_time:.2f}초 (청크 수: {len(chunks)})")
+
+        return chunks
+
+    def create_langchain_documents_from_chunks(self,
+                                               chunks: List[Dict[str, Any]],
+                                               metadata: Dict[str, Any]) -> List[Document]:
+        """
+        docling 청크를 LangChain Document 객체로 변환
+
+        Args:
+            chunks: docling HybridChunker로 생성한 청크 리스트
+            metadata: 문서 메타데이터
+
+        Returns:
+            LangChain Document 객체 리스트
+        """
+        documents = []
+
+        for i, chunk in enumerate(chunks):
+            # 각 청크에 대한 메타데이터
+            chunk_metadata = metadata.copy()
+            chunk_metadata["chunk_id"] = i
+
+            # 청크 내용 추출
+            if hasattr(chunk, "text"):
+                content = chunk.text
+            elif hasattr(chunk, "content"):
+                content = chunk.content
+            else:
+                content = str(chunk)
+
+            document = Document(
+                page_content=content,
+                metadata=chunk_metadata
+            )
+            documents.append(document)
+
+        return documents
+
+    def process_with_langchain(self, pdf_path: str) -> List[Document]:
+        """
+        LangChain의 PyPDFLoader를 사용하여 PDF 문서 로드
+
+        Args:
+            pdf_path: PDF 파일 경로
+
+        Returns:
+            LangChain Document 객체 리스트
+        """
+        start_time = time.time()
+
+        try:
+            loader = PyPDFLoader(pdf_path)
+            documents = loader.load()
+
+            processing_time = time.time() - start_time
+            print(f"PyPDFLoader 처리 시간: {processing_time:.2f}초")
+
+            return documents
+        except Exception as e:
+            print(f"PyPDFLoader로 문서 처리 중 오류 발생: {e}")
+            raise
+
+    def process_pdf(self, pdf_path: str, use_docling: bool = True) -> List[Document]:
+        """
+        PDF 파일 처리
+
+        Args:
+            pdf_path: PDF 파일 경로
+            use_docling: docling 사용 여부
+
+        Returns:
+            처리된 문서의 청크 리스트
+        """
+        total_start_time = time.time()
+
+        # docling 사용 가능 여부 확인
+        can_use_docling = use_docling and DOCLING_AVAILABLE
+
+        if can_use_docling:
+            try:
+                # 1. docling으로 PDF 처리
+                docling_result = self.process_with_docling(pdf_path)
+                doc = docling_result["raw_document"]
+                metadata = docling_result["metadata"]
+
+                # 2. HybridChunker로 청크 생성
+                chunks = self.chunk_with_hybrid_chunker(doc)
+
+                # 3. 청크를 LangChain Document로 변환
+                documents = self.create_langchain_documents_from_chunks(chunks, metadata)
+
+                total_time = time.time() - total_start_time
+                print(f"docling 처리 완료: '{pdf_path}', {len(documents)} 청크, 총 {total_time:.2f}초")
+
+                return documents
+            except Exception as e:
+                print(f"docling 처리 실패, PyPDFLoader로 대체: {e}")
+                can_use_docling = False
+
+        if not can_use_docling:
+            # PyPDFLoader로 처리 (대체 방안)
+            documents = self.process_with_langchain(pdf_path)
+            chunks = self.text_splitter.split_documents(documents)
+
+            total_time = time.time() - total_start_time
+            print(f"PyPDFLoader 처리 완료: '{pdf_path}', {len(chunks)} 청크, 총 {total_time:.2f}초")
+
+            return chunks
+
+    def process_directory_parallel(self, directory: str, use_docling: bool = True) -> List[Document]:
+        """
+        디렉토리 내 모든 PDF 파일 병렬 처리 (멀티스레딩)
+
+        Args:
+            directory: PDF 파일 디렉토리 경로
+            use_docling: docling 사용 여부
+
+        Returns:
+            처리된 모든 문서의 청크 리스트
+        """
+        all_documents = []
+        pdf_files = []
+
+        # PDF 파일 목록 수집
+        for file in os.listdir(directory):
+            if file.endswith(".pdf"):
+                pdf_path = os.path.join(directory, file)
+                pdf_files.append(pdf_path)
+
+        if not pdf_files:
+            print(f"'{directory}' 디렉토리에 PDF 파일이 없습니다.")
+            return []
+
+        print(f"총 {len(pdf_files)}개 PDF 파일 병렬 처리 시작 (최대 {self.max_workers} 작업자)")
+        start_time = time.time()
+
+        # 병렬 처리 실행
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            # 각 PDF 파일에 대해 process_pdf 함수 병렬 실행
+            future_to_pdf = {executor.submit(self.process_pdf, pdf_path, use_docling): pdf_path
+                             for pdf_path in pdf_files}
+
+            # 결과 수집
+            for future in future_to_pdf:
+                pdf_path = future_to_pdf[future]
+                try:
+                    # 결과 가져오기
+                    chunks = future.result()
+                    all_documents.extend(chunks)
+                    print(f"'{os.path.basename(pdf_path)}' 처리 완료: {len(chunks)} 청크")
+                except Exception as e:
+                    print(f"'{pdf_path}' 처리 중 오류 발생: {e}")
+
+        total_time = time.time() - start_time
+        print(f"병렬 처리 완료: 총 {len(all_documents)} 청크, 처리 시간: {total_time:.2f}초")
+
+        return all_documents
+
+    def process_directory(self, directory: str, use_docling: bool = True, parallel: bool = True) -> List[Document]:
+        """
+        디렉토리 내 모든 PDF 파일 처리
+
+        Args:
+            directory: PDF 파일 디렉토리 경로
+            use_docling: docling 사용 여부
+            parallel: 병렬 처리 사용 여부
+
+        Returns:
+            처리된 모든 문서의 청크 리스트
+        """
+        # 병렬 처리 사용
+        if parallel:
+            return self.process_directory_parallel(directory, use_docling)
+
+        # 순차 처리
+        all_documents = []
+        start_time = time.time()
+
+        for file in os.listdir(directory):
+            if file.endswith(".pdf"):
+                pdf_path = os.path.join(directory, file)
+                print(f"처리 중: {pdf_path}")
+
+                try:
+                    chunks = self.process_pdf(pdf_path, use_docling=use_docling)
+                    all_documents.extend(chunks)
+                except Exception as e:
+                    print(f"'{pdf_path}' 처리 중 오류 발생: {e}")
+
+        total_time = time.time() - start_time
+        print(f"순차 처리 완료: 총 {len(all_documents)} 청크, 처리 시간: {total_time:.2f}초")
+
+        return all_documents

rag_chain.py

@@ -0,0 +1,255 @@
+"""
+직접 DeepSeek API 호출을 위한 클라이언트 구현
+"""
+import os
+import time
+import logging
+import requests
+import json
+from typing import Dict, Any, Optional, List
+
+# 로깅 설정
+logger = logging.getLogger("DirectDeepSeek")
+
+class DirectDeepSeekClient:
+    """
+    DeepSeek API를 직접 호출하는 클라이언트
+    OpenAI 클라이언트를 우회하고 직접 HTTP 요청 사용
+    """
+    def __init__(self, api_key: str, model_name: str = "deepseek-chat"):
+        """
+        클라이언트 초기화
+
+        Args:
+            api_key: DeepSeek API 키
+            model_name: 사용할 모델 이름 (기본값: "deepseek-chat")
+        """
+        self.api_key = api_key
+        self.model_name = model_name
+        self.endpoint = os.getenv("DEEPSEEK_ENDPOINT", "https://api.deepseek.com/v1/chat/completions")
+        logger.info(f"DirectDeepSeekClient 초기화: 모델={model_name}, 엔드포인트={self.endpoint}")
+
+    def generate(self,
+                 prompt: str,
+                 temperature: float = 0.3,
+                 max_tokens: int = 1000,
+                 max_retries: int = 3,
+                 timeout: int = 60) -> Dict[str, Any]:
+        """
+        텍스트 생성 요청
+
+        Args:
+            prompt: 입력 프롬프트
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
+
+        Returns:
+            생성 결과 딕셔너리 (success, response, message 등)
+        """
+        # 메시지 구성 (단일 사용자 메시지)
+        messages = [{"role": "user", "content": prompt}]
+        return self.chat(messages, temperature, max_tokens, max_retries, timeout)
+
+    def chat(self,
+             messages: List[Dict[str, str]],
+             temperature: float = 0.3,
+             max_tokens: int = 1000,
+             max_retries: int = 3,
+             timeout: int = 60) -> Dict[str, Any]:
+        """
+        채팅 API 호출
+
+        Args:
+            messages: 채팅 메시지 리스트 (role, content 키를 가진 딕셔너리 리스트)
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
+
+        Returns:
+            생성 결과 딕셔너리 (success, response, message 등)
+        """
+        # API 요청 헤더 및 데이터
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+
+        payload = {
+            "model": self.model_name,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+
+        # 재시도 로직
+        retry_delay = 1.0
+        attempt = 0
+
+        while attempt < max_retries:
+            attempt += 1
+            try:
+                logger.info(f"DeepSeek API 요청 시도 ({attempt}/{max_retries})...")
+
+                # API 요청 전송
+                response = requests.post(
+                    self.endpoint,
+                    headers=headers,
+                    json=payload,
+                    timeout=timeout
+                )
+
+                # 응답 확인
+                if response.status_code == 200:
+                    result = response.json()
+
+                    # 응답 내용 추출
+                    if "choices" in result and len(result["choices"]) > 0:
+                        message_content = result["choices"][0].get("message", {}).get("content", "")
+                        logger.info(f"DeepSeek API 응답 성공 (길이: {len(message_content)})")
+
+                        return {
+                            "success": True,
+                            "response": message_content,
+                            "status_code": response.status_code,
+                            "raw_response": result
+                        }
+                    else:
+                        logger.warning(f"DeepSeek API 응답은 성공했으나 예상치 못한 응답 형식: {result}")
+                        return {
+                            "success": False,
+                            "message": "응답에서 메시지를 찾을 수 없습니다",
+                            "status_code": response.status_code,
+                            "raw_response": result
+                        }
+                else:
+                    logger.error(f"DeepSeek API 오류: 상태 코드 {response.status_code}")
+
+                    # 오류 메시지 추출
+                    error_message = ""
+                    try:
+                        error_data = response.json()
+                        error_message = error_data.get("error", {}).get("message", str(error_data))
+                    except:
+                        error_message = response.text
+
+                    # 요청 한도 ��과시 더 오래 대기
+                    if response.status_code == 429:
+                        retry_delay = min(retry_delay * 3, 15)
+                    else:
+                        retry_delay = min(retry_delay * 2, 10)
+
+                    if attempt < max_retries:
+                        logger.info(f"{retry_delay}초 후 재시도...")
+                        time.sleep(retry_delay)
+                    else:
+                        # 모든 시도 실패
+                        return {
+                            "success": False,
+                            "message": f"API 오류: {error_message}",
+                            "status_code": response.status_code
+                        }
+
+            except requests.exceptions.Timeout:
+                logger.error("DeepSeek API 요청 시간 초과")
+
+                if attempt < max_retries:
+                    logger.info(f"{retry_delay}초 후 재시도...")
+                    time.sleep(retry_delay)
+                    retry_delay = min(retry_delay * 2, 10)
+                else:
+                    return {
+                        "success": False,
+                        "message": "API 요청 시간 초과",
+                        "status_code": None
+                    }
+
+            except requests.exceptions.ConnectionError:
+                logger.error("DeepSeek API 연결 실패")
+
+                if attempt < max_retries:
+                    logger.info(f"{retry_delay}초 후 재시도...")
+                    time.sleep(retry_delay)
+                    retry_delay = min(retry_delay * 2, 10)
+                else:
+                    return {
+                        "success": False,
+                        "message": "API 서버 연결 실패",
+                        "status_code": None
+                    }
+
+            except Exception as e:
+                logger.error(f"DeepSeek API 요청 중 예상치 못한 오류: {e}")
+
+                if attempt < max_retries:
+                    logger.info(f"{retry_delay}초 후 재시도...")
+                    time.sleep(retry_delay)
+                    retry_delay = min(retry_delay * 2, 10)
+                else:
+                    return {
+                        "success": False,
+                        "message": f"예상치 못한 오류: {str(e)}",
+                        "status_code": None
+                    }
+
+        # 모든 시도 실패
+        return {
+            "success": False,
+            "message": "최대 재시도 횟수 초과",
+            "status_code": None
+        }
+
+    def system_prompt_chat(self,
+                           system_prompt: str,
+                           user_prompt: str,
+                           temperature: float = 0.3,
+                           max_tokens: int = 1000,
+                           max_retries: int = 3,
+                           timeout: int = 60) -> Dict[str, Any]:
+        """
+        시스템 프롬프트와 사용자 프롬프트를 이용한 채팅 API 호출
+
+        Args:
+            system_prompt: 시스템 프롬프트
+            user_prompt: 사용자 프롬프트
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
+
+        Returns:
+            생성 결과 딕셔너리
+        """
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+
+        return self.chat(messages, temperature, max_tokens, max_retries, timeout)
+
+
+# 단독 실행을 위한 테스트 코드
+if __name__ == "__main__":
+    # 로깅 설정
+    logging.basicConfig(level=logging.INFO)
+
+    # API 키 확인
+    api_key = os.environ.get("DEEPSEEK_API_KEY")
+    if not api_key:
+        print("환경 변수 DEEPSEEK_API_KEY가 설정되지 않았습니다.")
+        exit(1)
+
+    # 클라이언트 생성
+    client = DirectDeepSeekClient(api_key)
+
+    # 간단한 테스트
+    response = client.generate("Hello, what can you do?")
+
+    # 결과 출력
+    if response["success"]:
+        print("응답 성공!")
+        print(response["response"])
+    else:
+        print(f"응답 실패: {response['message']}")

requirements.txt

@@ -0,0 +1,16 @@
+langchain>=0.1.0
+langchain-community>=0.0.10
+langchain-huggingface>=0.0.1
+sentence-transformers>=2.2.2
+faiss-cpu>=1.7.4
+pypdf>=3.15.1
+gradio>=4.0.0
+python-dotenv>=1.0.0
+torch>=2.0.0
+transformers>=4.34.0
+langchain-openai>=0.0.2
+openai>=1.0.0
+docling>=0.1.3
+soundfile>=0.12.1
+numpy>=1.20.0
+requests>=2.25.1

reranker.py

@@ -0,0 +1,58 @@
+"""
+원격 코드 실행 옵션이 추가된 리랭커 모듈
+"""
+from typing import List, Dict, Tuple
+import numpy as np
+from sentence_transformers import CrossEncoder
+from langchain.schema import Document
+from config import RERANKER_MODEL
+
+class Reranker:
+    def __init__(self, model_name: str = RERANKER_MODEL):
+        """
+        Cross-Encoder 리랭커 초기화
+
+        Args:
+            model_name: 사용할 Cross-Encoder 모델 이름
+        """
+        print(f"리랭커 모델 로드 중: {model_name}")
+
+        # 원격 코드 실행 허용 옵션 추가
+        self.model = CrossEncoder(
+            model_name,
+            trust_remote_code=True  # 원격 코드 실행 허용 (필수)
+        )
+
+        print(f"리랭커 모델 로드 완료: {model_name}")
+
+    def rerank(self, query: str, documents: List[Document], top_k: int = 3) -> List[Document]:
+        """
+        검색 결과 재정렬
+
+        Args:
+            query: 검색 쿼리
+            documents: 벡터 검색 결과 문서 리스트
+            top_k: 반환할 상위 결과 수
+
+        Returns:
+            재정렬된 상위 문서 리스트
+        """
+        if not documents:
+            return []
+
+        # Cross-Encoder 입력 쌍 생성
+        document_texts = [doc.page_content for doc in documents]
+        query_doc_pairs = [(query, doc) for doc in document_texts]
+
+        # 점수 계산
+        print(f"리랭킹 수행 중: {len(documents)}개 문서")
+        scores = self.model.predict(query_doc_pairs)
+
+        # 점수에 따라 문서 재정렬
+        doc_score_pairs = list(zip(documents, scores))
+        doc_score_pairs.sort(key=lambda x: x[1], reverse=True)
+
+        print(f"리랭킹 완료: 상위 {top_k}개 문서 선택")
+
+        # 상위 k개 결과 반환
+        return [doc for doc, score in doc_score_pairs[:top_k]]

simple_rag_chain.py

@@ -0,0 +1,123 @@
+"""
+간단한 RAG 체인 구현 (디버깅용) - 직접 DeepSeek API 호출 방식
+"""
+import os
+import logging
+import time
+from typing import Dict, Any, List
+
+# 직접 DeepSeek 클라이언트 사용
+from direct_deepseek import DirectDeepSeekClient
+
+# 로깅 설정
+logger = logging.getLogger("SimpleRAGChain")
+
+class SimpleRAGChain:
+    def __init__(self, vector_store, api_key=None, model="deepseek-chat", endpoint=None):
+        """간단한 RAG 체인 초기화"""
+        logger.info("간단한 RAG 체인 초기화 중...")
+        self.vector_store = vector_store
+
+        # DeepSeek API 키 확인
+        self.api_key = api_key or os.environ.get("DEEPSEEK_API_KEY", "")
+        self.model = model or os.environ.get("DEEPSEEK_MODEL", "deepseek-chat")
+        logger.info(f"API 키 설정됨: {bool(self.api_key)}")
+
+        # DeepSeek 클라이언트 초기화
+        if self.api_key:
+            try:
+                self.client = DirectDeepSeekClient(
+                    api_key=self.api_key,
+                    model_name=self.model
+                )
+                logger.info(f"DeepSeek 클라이언트 초기화 성공: {self.model}")
+            except Exception as e:
+                logger.error(f"DeepSeek 클라이언트 초기화 실패: {e}")
+                self.client = None
+        else:
+            logger.warning("API 키가 설정되지 않아 클라이언트를 초기화할 수 없습니다.")
+            self.client = None
+
+        logger.info("간단한 RAG 체인 초기화 완료")
+
+    def _retrieve(self, query: str) -> str:
+        """문서 검색 및 컨텍스트 구성"""
+        try:
+            docs = self.vector_store.similarity_search(query, k=3)
+            if not docs:
+                return "관련 문서를 찾을 수 없습니다."
+
+            # 검색 결과 컨텍스트 구성
+            context_parts = []
+            for i, doc in enumerate(docs, 1):
+                source = doc.metadata.get("source", "알 수 없는 출처")
+                page = doc.metadata.get("page", "")
+                source_info = f"{source}"
+                if page:
+                    source_info += f" (페이지: {page})"
+
+                context_parts.append(f"[참고자료 {i}] - 출처: {source_info}\n{doc.page_content}\n")
+
+            context = "\n".join(context_parts)
+
+            # 길이 제한
+            if len(context) > 6000:
+                context = context[:2500] + "\n...(중략)...\n" + context[-2500:]
+
+            return context
+        except Exception as e:
+            logger.error(f"검색 중 오류: {e}")
+            return "문서 검색 중 오류가 발생했습니다."
+
+    def _generate_prompt(self, query: str, context: str) -> List[Dict[str, str]]:
+        """DeepSeek API용 프롬프트 생성"""
+        # 시스템 프롬프트
+        system_prompt = """다음 정보를 기반으로 질문에 정확하게 답변해주세요.
+참고 정보에서 답을 찾을 수 없는 경우 "제공된 문서에서 해당 정보를 찾을 수 없습니다."라고 답변하세요.
+정보 출처를 포함해서 대답하세요."""
+
+        # 사용자 프롬프트
+        user_prompt = f"""질문: {query}
+
+참고 정보:
+{context}"""
+
+        # DeepSeek API 프롬프트 포맷
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
+
+        return messages
+
+    def run(self, query: str) -> str:
+        """쿼리 처리"""
+        try:
+            logger.info(f"SimpleRAGChain 실행: {query[:50]}...")
+
+            # 문서 검색
+            context = self._retrieve(query)
+
+            # 클라이언트가 초기화되지 않은 경우
+            if self.client is None:
+                logger.warning("DeepSeek 클라이언트가 초기화되지 않음. 검색 결과만 반환.")
+                return f"API 연결이 설정되지 않았습니다. 검색 결과:\n\n{context}"
+
+            # 프롬프트 생성
+            messages = self._generate_prompt(query, context)
+
+            # API 호출
+            start_time = time.time()
+            response = self.client.chat(messages)
+            logger.info(f"API 응답 시간: {time.time() - start_time:.2f}초")
+
+            if response["success"]:
+                logger.info("응답 생성 성공")
+                return response["response"]
+            else:
+                logger.error(f"응답 생성 실패: {response['message']}")
+                return f"응답 생성 실패: {response['message']}\n\n검색 결과:\n{context}"
+
+        except Exception as e:
+            logger.error(f"실행 중 오류: {e}")
+            return f"오류 발생: {str(e)}"

vector_store.py

@@ -0,0 +1,349 @@
+"""
+개선된 벡터 스토어 모듈 - Milvus 설정 최적화 및 예외 처리 강화
+"""
+import os
+import logging
+from typing import List, Dict, Any, Optional
+import uuid
+from langchain.schema import Document
+
+# 로깅 설정
+logger = logging.getLogger("VectorStore")
+
+# 벡터 스토어 관련 예외 클래스
+class VectorStoreInitError(Exception):
+    """벡터 스토어 초기화 중 발생한 오류"""
+    pass
+
+class EmbeddingModelError(Exception):
+    """임베딩 모델 초기화 중 발생한 오류"""
+    pass
+
+class DocumentIndexError(Exception):
+    """문서 인덱싱 중 발생한 오류"""
+    pass
+
+class VectorSearchError(Exception):
+    """벡터 검색 중 발생한 오류"""
+    pass
+
+class PersistenceError(Exception):
+    """인덱스 저장/로드 중 발생한 오류"""
+    pass
+
+# 벡터 스토어 임포트
+try:
+    # 최신 버전 임포트
+    from langchain_milvus import Milvus
+    from langchain_community.vectorstores import FAISS
+    from langchain_huggingface import HuggingFaceEmbeddings
+    MODERN_IMPORTS = True
+    logger.info("최신 langchain 패키지 임포트 성공")
+except ImportError:
+    try:
+        # 이전 버전 임포트
+        from langchain_community.vectorstores import Milvus, FAISS
+        from langchain_community.embeddings import HuggingFaceEmbeddings
+        MODERN_IMPORTS = False
+        logger.info("레거시 langchain_community 패키지 사용")
+    except ImportError as e:
+        logger.error(f"필수 벡터 스토어 라이브러리를 임포트할 수 없습니다: {e}")
+        raise VectorStoreInitError(f"필수 벡터 스토어 라이브러리를 임포트할 수 없습니다: {str(e)}")
+
+from config import MILVUS_HOST, MILVUS_PORT, MILVUS_COLLECTION, EMBEDDING_MODEL
+
+class VectorStore:
+    def __init__(self, use_milvus: bool = True):
+        """
+        벡터 스토어 초기화
+
+        Args:
+            use_milvus: Milvus 사용 여부 (False이면 FAISS 사용)
+        """
+        self.use_milvus = use_milvus
+        self.vector_store = None
+
+        # 임베딩 모델 설정
+        logger.info(f"임베딩 모델 로드 중: {EMBEDDING_MODEL}")
+        model_kwargs = {
+            "device": "cpu",
+            "trust_remote_code": True  # 원격 코드 실행 허용 (필수)
+        }
+        encode_kwargs = {"normalize_embeddings": True}
+
+        try:
+            self.embeddings = HuggingFaceEmbeddings(
+                model_name=EMBEDDING_MODEL,
+                model_kwargs=model_kwargs,
+                encode_kwargs=encode_kwargs
+            )
+            logger.info(f"임베딩 모델 초기화 완료: {EMBEDDING_MODEL}")
+        except Exception as e:
+            logger.error(f"임베딩 모델 초기화 실패: {e}", exc_info=True)
+            raise EmbeddingModelError(f"임베딩 모델 '{EMBEDDING_MODEL}' 초기화 실패: {str(e)}")
+
+    def init_milvus(self) -> Milvus:
+        """
+        Milvus 벡터 스토어 초기화
+
+        Returns:
+            Milvus 벡터 스토어 인스턴스
+        """
+        try:
+            connection_args = {
+                "host": MILVUS_HOST,
+                "port": MILVUS_PORT,
+            }
+
+            # 벡터 검색 인덱스 파라미터 (FLAT 인덱스 및 코사인 유사도 메트릭)
+            index_params = {
+                "index_type": "FLAT",  # 정확도 우선 FLAT 인덱스
+                "metric_type": "COSINE",  # 코사인 유사도 (정규화된 벡터에 적합)
+                "params": {}  # FLAT 인덱스에는 추가 파라미터 없음
+            }
+
+            logger.info(f"Milvus 연결 시도 중: {MILVUS_HOST}:{MILVUS_PORT}")
+            milvus_store = Milvus(
+                embedding_function=self.embeddings,
+                collection_name=MILVUS_COLLECTION,
+                connection_args=connection_args,
+                index_params=index_params
+            )
+            logger.info(f"Milvus 연결 성공: {MILVUS_COLLECTION}")
+            return milvus_store
+        except Exception as e:
+            logger.error(f"Milvus 초기화 실패: {e}", exc_info=True)
+            raise VectorStoreInitError(f"Milvus 벡터 스토어 초기화 실패: {str(e)}")
+
+    def init_faiss(self) -> FAISS:
+        """
+        FAISS 벡터 스토어 초기화 (로컬 대체용)
+
+        Returns:
+            FAISS 벡터 스토어 인스턴스
+        """
+        try:
+            logger.info("FAISS 벡터 스토어 초기화 중")
+            faiss_store = FAISS.from_documents([], self.embeddings)
+            logger.info("FAISS 벡터 스토어 초기화 완료")
+            return faiss_store
+        except Exception as e:
+            logger.error(f"FAISS 초기화 실패: {e}", exc_info=True)
+            raise VectorStoreInitError(f"FAISS 벡터 스토어 초기화 실패: {str(e)}")
+
+    def create_or_load(self, documents: Optional[List[Document]] = None) -> Any:
+        """
+        벡터 스토어 생성 또는 로드
+
+        Args:
+            documents: 저장할 문서 리스트 (None이면 빈 스토어 생성)
+
+        Returns:
+            벡터 스토어 인스턴스
+        """
+        if self.use_milvus:
+            if documents:
+                # 문서가 제공된 경우 새 컬렉션 생성
+                try:
+                    # 연결 설정
+                    connection_args = {
+                        "host": MILVUS_HOST,
+                        "port": MILVUS_PORT,
+                    }
+
+                    # 검색 인덱스 설정
+                    index_params = {
+                        "index_type": "FLAT",  # 정확도 우선
+                        "metric_type": "COSINE",  # 코사인 유사도
+                        "params": {}
+                    }
+
+                    logger.info(f"Milvus 컬렉션 생성 중: {MILVUS_COLLECTION} (기존 컬렉션 삭제)")
+
+                    # 문서로부터 Milvus 컬렉션 생성
+                    self.vector_store = Milvus.from_documents(
+                        documents=documents,
+                        embedding=self.embeddings,
+                        collection_name=MILVUS_COLLECTION,
+                        connection_args=connection_args,
+                        index_params=index_params,
+                        drop_old=True  # 기존 컬렉션 삭제 (재구축)
+                    )
+
+                    logger.info(f"Milvus 컬렉션 생성 완료: {len(documents)}개 문서 인덱싱됨")
+
+                except Exception as e:
+                    logger.error(f"Milvus 컬렉션 생성 실패: {e}", exc_info=True)
+                    # 대체 방안으로 FAISS 사용
+                    logger.warning("Milvus 실패로 FAISS로 대체합니다")
+                    self.use_milvus = False
+                    try:
+                        self.vector_store = FAISS.from_documents(documents, self.embeddings)
+                        logger.info(f"FAISS로 대체 성공: {len(documents)}개 문서 인덱싱됨")
+                    except Exception as faiss_err:
+                        logger.error(f"FAISS 대체 실패: {faiss_err}", exc_info=True)
+                        raise DocumentIndexError(f"문서 인덱싱 실패 (Milvus 및 FAISS): {str(e)} / {str(faiss_err)}")
+            else:
+                # 기존 컬렉션 로드
+                try:
+                    self.vector_store = self.init_milvus()
+                except VectorStoreInitError as e:
+                    logger.error(f"Milvus 컬렉션 로드 실패: {e}")
+                    # 대체 방안으로 FAISS 사용
+                    logger.warning("Milvus 실패로 FAISS로 대체합니다")
+                    self.use_milvus = False
+                    try:
+                        self.vector_store = self.init_faiss()
+                    except VectorStoreInitError as faiss_err:
+                        logger.error(f"FAISS 대체 실패: {faiss_err}", exc_info=True)
+                        raise VectorStoreInitError(f"벡터 스토어 초기화 실패 (Milvus 및 FAISS): {str(e)} / {str(faiss_err)}")
+        else:
+            # FAISS 사용
+            if documents:
+                try:
+                    logger.info(f"FAISS 인덱스 생성 중: {len(documents)}개 문서")
+                    self.vector_store = FAISS.from_documents(documents, self.embeddings)
+                    logger.info("FAISS 인덱스 생성 완료")
+                except Exception as e:
+                    logger.error(f"FAISS 인덱스 생성 실패: {e}", exc_info=True)
+                    raise DocumentIndexError(f"FAISS 문서 인덱싱 실패: {str(e)}")
+            else:
+                try:
+                    self.vector_store = self.init_faiss()
+                except VectorStoreInitError as e:
+                    # 이미 로깅됨
+                    raise
+
+        return self.vector_store
+
+    def add_documents(self, documents: List[Document]) -> None:
+        """
+        벡터 스토어에 문서 추가
+
+        Args:
+            documents: 추가할 문서 리스트
+        """
+        if not documents:
+            logger.warning("추가할 문서가 없습니다")
+            return
+            
+        try:
+            if self.vector_store is None:
+                logger.info("벡터 스토어가 초기화되지 않았습니다. 새 벡터 스토어를 생성합니다.")
+                self.create_or_load(documents)
+            else:
+                logger.info(f"{len(documents)}개 문서를 기존 벡터 스토어에 추가합니다")
+                self.vector_store.add_documents(documents)
+                logger.info(f"{len(documents)}개 문서 추가 완료")
+        except Exception as e:
+            logger.error(f"문서 추가 실패: {e}", exc_info=True)
+            raise DocumentIndexError(f"벡터 스토어에 문서 추가 실패: {str(e)}")
+
+    def similarity_search(self, query: str, k: int = 5) -> List[Document]:
+        """
+        벡터 유사도 검색 수행
+
+        Args:
+            query: 검색 쿼리
+            k: 반환할 결과 수
+
+        Returns:
+            유사도가 높은 문서 리스트
+        """
+        if not query or not query.strip():
+            logger.warning("빈 쿼리로 검색 시도")
+            return []
+            
+        if self.vector_store is None:
+            logger.error("벡터 스토어가 초기화되지 않았습니다")
+            raise VectorSearchError("벡터 스토어가 초기화되지 않았습니다")
+
+        try:
+            logger.info(f"검색 쿼리 실행: '{query[:50]}{'...' if len(query) > 50 else ''}', 상위 {k}개 결과 요청")
+            results = self.vector_store.similarity_search(query, k=k)
+            logger.info(f"검색 완료: {len(results)}개 결과 찾음")
+            return results
+        except Exception as e:
+            logger.error(f"검색 중 오류 발생: {e}", exc_info=True)
+            raise VectorSearchError(f"벡터 검색 실패: {str(e)}")
+
+    def save_local(self, path: str = "faiss_index") -> bool:
+        """
+        FAISS 인덱스 로컬 저장 (Milvus 사용 안 할 경우)
+
+        Args:
+            path: 저장 경로
+            
+        Returns:
+            저장 성공 여부
+        """
+        if self.vector_store is None:
+            logger.error("저장할 벡터 스토어가 초기화되지 않았습니다")
+            raise PersistenceError("저장할 벡터 스토어가 초기화되지 않았습니다")
+            
+        # FAISS만 로컬 저장 가능
+        if not self.use_milvus:
+            try:
+                # 저장 디렉토리가 존재하는지 확인
+                os.makedirs(os.path.dirname(path) if os.path.dirname(path) else path, exist_ok=True)
+                
+                self.vector_store.save_local(path)
+                logger.info(f"FAISS 인덱스 로컬 저장 완료: {path}")
+                return True
+            except Exception as e:
+                logger.error(f"FAISS 인덱스 저장 실패: {e}", exc_info=True)
+                raise PersistenceError(f"벡터 인덱스 저장 실패: {str(e)}")
+        else:
+            logger.info("Milvus는 로컬 저장이 필요하지 않습니다")
+            return True
+
+    def load_local(self, path: str = "faiss_index") -> bool:
+        """
+        FAISS 인덱스 로컬 로드 (Milvus 사용 안 할 경우)
+
+        Args:
+            path: 로드할 인덱스 경로
+            
+        Returns:
+            로드 성공 여부
+        """
+        if self.use_milvus:
+            logger.info("Milvus 사용 중이므로 로컬 로드를 건너뜁니다")
+            try:
+                # Milvus 연결 확인
+                self.vector_store = self.init_milvus()
+                return True
+            except Exception as e:
+                logger.error(f"Milvus 연결 실패, FAISS로 대체: {e}")
+                self.use_milvus = False
+                # FAISS로 계속 진행
+        
+        if not os.path.exists(path):
+            logger.warning(f"인덱스 경로가 존재하지 않음: {path}")
+            raise FileNotFoundError(f"벡터 인덱스 경로가 존재하지 않음: {path}")
+            
+        try:
+            logger.info(f"FAISS 인덱스 로드 중: {path}")
+
+            # 역직렬화 허용 옵션 추가 (보안 경고 확인 필요)
+            self.vector_store = FAISS.load_local(
+                path,
+                self.embeddings,
+                allow_dangerous_deserialization=True  # 역직렬화 허용
+            )
+            logger.info(f"FAISS 인덱스 로드 완료: {path}")
+            return True
+        except FileNotFoundError as e:
+            logger.error(f"FAISS 인덱스 파일을 찾을 수 없음: {e}")
+            raise PersistenceError(f"벡터 인덱스 파일을 찾을 수 없음: {str(e)}")
+        except Exception as e:
+            logger.error(f"FAISS 인덱스 로드 실패: {e}", exc_info=True)
+
+            # 오류 세부 정보 출력
+            import traceback
+            logger.error(f"상세 오류: {traceback.format_exc()}")
+
+            # 새 인덱스 초기화
+            logger.warning("인덱스 로드 실패로 새 FAISS 인덱스 초기화")
+            self.vector_store = self.init_faiss()
+            return False