Add application file

app.py

@@ -1,31 +1,151 @@
 """
-음성인식(STT) 기능이 구현된 RAG 챗봇 앱
+음성인식 기능이 추가된 RAG 챗봇 앱
 """
 import os
 import time
+import tempfile
+from typing import List, Dict, Tuple, Any, Optional
 import hashlib
 import pickle
 import json
-import tempfile
-from typing import List, Dict, Tuple, Any
-
-from langchain.schema import Document
 
+# 기존 임포트
 from config import (
     PDF_DIRECTORY, CHUNK_SIZE, CHUNK_OVERLAP, LLM_MODEL,
-    STT_LANGUAGE, IS_HUGGINGFACE
+    STT_LANGUAGE, IS_HUGGINGFACE, OPENAI_API_KEY, USE_OPENAI
 )
 from optimized_document_processor import OptimizedDocumentProcessor
 from vector_store import VectorStore
+from langchain.schema import Document
+
+# 클로바 STT 모듈 임포트
 from clova_stt import ClovaSTT
 
 # 안전한 임포트
 try:
+    print("RAG 체인 모듈 로드 시도...")
     from rag_chain import RAGChain
+    # RAGChain 클래스가 제대로 임포트되었는지 확인
     RAG_CHAIN_AVAILABLE = True
-except ImportError:
-    print("RAG 체인 모듈을 로드할 수 없습니다.")
-    RAG_CHAIN_AVAILABLE = False
+    print("외부 RAG 체인 모듈 로드 성공")
+except Exception as e:
+    print(f"외부 RAG 체인 로드 실패: {e}")
+    print("내장 RAG 체인을 사용합니다.")
+    # 내장 RAG 체인 구현 사용
+    RAG_CHAIN_AVAILABLE = True
+
+    # 필요한 langchain 임포트
+    try:
+        from langchain_openai import ChatOpenAI
+        from langchain_community.chat_models import ChatOllama
+        from langchain.prompts import PromptTemplate
+        from langchain_core.output_parsers import StrOutputParser
+        from langchain_core.runnables import RunnablePassthrough
+
+        # SimpleRAGChain 내장 클래스 정의
+        class RAGChain:
+            """앱에 내장된 간단한 RAG 체인"""
+            def __init__(self, vector_store):
+                print("내장 RAG 체인 초기화 중...")
+                self.vector_store = vector_store
+
+                # 환경 설정 임포트
+                from config import OPENAI_API_KEY, LLM_MODEL, USE_OPENAI, TOP_K_RETRIEVAL, OLLAMA_HOST
+
+                try:
+                    # LLM 초기화
+                    if USE_OPENAI:
+                        self.llm = ChatOpenAI(
+                            model_name=LLM_MODEL,
+                            temperature=0.2,
+                            api_key=OPENAI_API_KEY,
+                        )
+                        print(f"OpenAI 모델 초기화: {LLM_MODEL}")
+                    else:
+                        try:
+                            self.llm = ChatOllama(
+                                model=LLM_MODEL,
+                                temperature=0.2,
+                                base_url=OLLAMA_HOST,
+                            )
+                            print(f"Ollama 모델 초기화: {LLM_MODEL}")
+                        except Exception as e:
+                            print(f"Ollama 초기화 실패: {e}, OpenAI 모델로 대체")
+                            self.llm = ChatOpenAI(
+                                model_name="gpt-3.5-turbo",
+                                temperature=0.2,
+                                api_key=OPENAI_API_KEY,
+                            )
+
+                    # 프롬프트 템플릿
+                    template = """
+                    다음 정보를 기반으로 질문에 정확하게 답변해주세요.
+
+                    질문: {question}
+
+                    참고 정보:
+                    {context}
+
+                    참고 정보에 답이 없는 경우 "제공된 문서에서 해당 정보를 찾을 수 없습니다."라고 답변하세요.
+                    답변은 정확하고 간결하게 제공하되, 참고 정보에서 근거를 찾아 설명해주세요.
+                    참고 정보의 출처도 함께 알려주세요.
+                    """
+
+                    self.prompt = PromptTemplate.from_template(template)
+
+                    # 체인 구성
+                    self.chain = (
+                            {"context": self._retrieve, "question": RunnablePassthrough()}
+                            | self.prompt
+                            | self.llm
+                            | StrOutputParser()
+                    )
+                    print("내장 RAG 체인 초기화 완료")
+                except Exception as e:
+                    print(f"LLM 초기화 실패: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    raise
+
+            def _retrieve(self, query):
+                """문서 검색"""
+                try:
+                    from config import TOP_K_RETRIEVAL
+                    docs = self.vector_store.similarity_search(query, k=TOP_K_RETRIEVAL)
+
+                    # 검색 결과 컨텍스트 구성
+                    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")
+
+                    return "\n".join(context_parts)
+                except Exception as e:
+                    print(f"검색 중 오류: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    return "문서 검색 중 오류가 발생했습니다."
+
+            def run(self, query):
+                """쿼리 처리"""
+                try:
+                    return self.chain.invoke(query)
+                except Exception as e:
+                    print(f"RAG 체인 실행 오류: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    return f"오류 발생: {str(e)}"
+
+    except Exception as inner_e:
+        print(f"내장 RAG 체인 정의 실패: {inner_e}")
+        import traceback
+        traceback.print_exc()
+        RAG_CHAIN_AVAILABLE = False
 
 
 class AutoRAGChatApp:
@@ -88,6 +208,43 @@ class AutoRAGChatApp:
         print(f"초기화 완료 상태: {self.is_initialized}")
         print("=" * 50)
 
+    def _fallback_response(self, query: str) -> str:
+        """
+        RAG 체인 초기화 실패 시 기본 응답 생성
+
+        Args:
+            query: 사용자 질문
+
+        Returns:
+            기본 응답 텍스트
+        """
+        try:
+            # 벡터 검색이라도 실행
+            if self.vector_store and self.vector_store.vector_store:
+                try:
+                    docs = self.vector_store.similarity_search(query, k=3)
+                    if docs:
+                        context = "\n\n".join([doc.page_content for doc in docs])
+                        response = f"""
+                        질문에 대한 응답을 생성할 수 없습니다. RAG 체인이 초기화되지 않았습니다.
+                        
+                        그러나 문서에서 관련 정보를 찾았습니다:
+                        
+                        {context}
+                        
+                        RAG 체인 초기화 문제를 해결하려면 로그를 확인하세요.
+                        """
+                        return response.strip()
+                except Exception as e:
+                    print(f"벡터 검색 실패: {e}")
+
+            # 기본 응답
+            return "죄송합니다. RAG 체인이 초기화되지 않아 질문에 응답할 수 없습니다. 기술적인 문제를 해결 중입니다."
+
+        except Exception as e:
+            print(f"기본 응답 생성 실패: {e}")
+            return "시스템 오류가 발생했습니다. 관리자에게 문의하세요."
+
     def _process_pdf_file(self, file_path: str) -> List[Document]:
         """
         PDF 파일 처리 - docling 실패 시 PyPDFLoader 사용
@@ -393,42 +550,61 @@ class AutoRAGChatApp:
                 print("벡터 인덱스가 초기화되지 않아 저장하지 않습니다.")
 
             # RAG 체인 초기화
-            if RAG_CHAIN_AVAILABLE:
-                print("RAG 체인 초기화 중...")
-                try:
-                    # 반드시 모든 문서 처리와 벡터 스토어 설정이 완료된 후 RAG 체인 초기화
+            try:
+                print("RAG 체인 초기화 시도...")
+                if RAG_CHAIN_AVAILABLE:
+                    print("RAG_CHAIN_AVAILABLE=True, 초기화 진행")
+                    # 직접 RAG 체인 클래스를 사용하여 초기화
                     self.rag_chain = RAGChain(self.vector_store)
-                    self.is_initialized = True
-                    print("RAG 체인 초기화 완료!")
-                except Exception as e:
-                    print(f"RAG 체인 초기화 실패: {e}")
-                    import traceback
-                    traceback.print_exc()
+                    print("RAG 체인 객체 생성 완료")
+                    # 테스트 쿼리 실행하여 체인이 작동하는지 확인
+                    try:
+                        test_response = self.rag_chain.run("테스트 쿼리입니다.")
+                        print(f"RAG 체인 테스트 성공: 응답 길이 {len(test_response)}")
+                        self.is_initialized = True
+                    except Exception as test_e:
+                        print(f"RAG 체인 테스트 실패: {test_e}")
+                        import traceback
+                        traceback.print_exc()
+                        self.is_initialized = False
+                        return f"RAG 체인 테스트 실패: {test_e}"
+                else:
+                    print("RAG_CHAIN_AVAILABLE=False, 초기화 불가")
                     self.is_initialized = False
-                    return f"RAG ��인 초기화 실패: {e}"
-
-                total_time = time.time() - start_time
-
-                status_message = (
-                    f"문서 처리 완료!\n"
-                    f"- 처리된 파일: {len(self.processed_files)}개\n"
-                    f"- 캐시된 파일: {len(cached_files)}개\n"
-                    f"- 새 파일: {len(new_files)}개\n"
-                    f"- 업데이트된 파일: {len(updated_files)}개\n"
-                    f"- 실패한 파일: {len(failed_files)}개\n"
-                    f"- 총 청크 수: {len(self.documents)}개\n"
-                    f"- 처리 시간: {total_time:.2f}초\n"
-                    f"- RAG 체인 초기화: {'성공' if self.is_initialized else '실패'}\n"
-                    f"이제 질문할 준비가 되었습니다!"
-                )
-
-                print(status_message)
-                return status_message
-            else:
+                    return "RAG 체인 모듈을 사용할 수 없습니다."
+
+                # 최종 상태 확인 및 로그
+                print(f"RAG 체인 초기화 결과: is_initialized={self.is_initialized}")
+                if self.is_initialized:
+                    print("RAG 체인 초기화 성공!")
+                else:
+                    print("RAG 체인 초기화 실패했지만 예외는 발생하지 않음.")
+                    return "RAG 체인 초기화 실패: 원인 불명"
+
+            except Exception as e:
+                print(f"RAG 체인 초기화 중 예외 발생: {e}")
+                import traceback
+                traceback.print_exc()
                 self.is_initialized = False
-                error_msg = "RAG 체인을 초기화할 수 없습니다. 필요한 라이브러리가 설치되어 있는지 확인하세요."
-                print(error_msg)
-                return error_msg
+                return f"RAG 체인 초기화 실패: {e}"
+
+            total_time = time.time() - start_time
+
+            status_message = (
+                f"문서 처리 완료!\n"
+                f"- 처리된 파일: {len(self.processed_files)}개\n"
+                f"- 캐시된 파일: {len(cached_files)}개\n"
+                f"- 새 파일: {len(new_files)}개\n"
+                f"- 업데이트된 파일: {len(updated_files)}개\n"
+                f"- 실패한 파일: {len(failed_files)}개\n"
+                f"- 총 청크 수: {len(self.documents)}개\n"
+                f"- 처리 시간: {total_time:.2f}초\n"
+                f"- RAG 체인 초기화: {'성공' if self.is_initialized else '실패'}\n"
+                f"이제 질문할 준비가 되었습니다!"
+            )
+
+            print(status_message)
+            return status_message
 
         except Exception as e:
             self.is_initialized = False
@@ -512,7 +688,13 @@ class AutoRAGChatApp:
             # RAG 체인 실행 및 응답 생성
             start_time = time.time()
             print(f"RAG 체인 실행 중: 쿼리 = '{query}'")
-            response = self.rag_chain.run(query)
+
+            if self.is_initialized and self.rag_chain is not None:
+                response = self.rag_chain.run(query)
+            else:
+                print("RAG 체인이 초기화되지 않음: 기본 응답 사용")
+                response = self._fallback_response(query)
+
             end_time = time.time()
 
             query_time = end_time - start_time
@@ -533,7 +715,7 @@ class AutoRAGChatApp:
             new_history.append([query, error_msg])
             return "", new_history
 
-    def process_voice_query(self, audio, chat_history: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
+    def process_voice_query(self, audio, chat_history: List[List[str]]) -> List[List[str]]:
         """
         음성 쿼리 처리
 
@@ -545,7 +727,7 @@ class AutoRAGChatApp:
             업데이트된 대화 기록
         """
         if audio is None:
-            return "", chat_history
+            return chat_history
 
         try:
             import numpy as np
@@ -575,16 +757,18 @@ class AutoRAGChatApp:
             if "error" in result:
                 error_msg = f"음성인식 오류: {result.get('error')}"
                 print(f"[STT] {error_msg}")
-                chat_history.append(("음성 메시지", error_msg))
-                return "", chat_history
+                new_history = list(chat_history)
+                new_history.append(["음성 메시지", error_msg])
+                return new_history
 
             # 인식된 텍스트 추출
             recognized_text = result.get("text", "")
             if not recognized_text:
                 error_msg = "음성을 인식할 수 없습니다. 다시 시도해주세요."
                 print("[STT] 인식된 텍스트 없음")
-                chat_history.append(("음성 메시지", error_msg))
-                return "", chat_history
+                new_history = list(chat_history)
+                new_history.append(["음성 메시지", error_msg])
+                return new_history
 
             print(f"[STT] 인식된 텍스트: {recognized_text}")
 
@@ -621,7 +805,13 @@ class AutoRAGChatApp:
                 # RAG 체인 실행 및 응답 생성
                 start_time = time.time()
                 print(f"RAG 체인 실행 중: 쿼리 = '{query}'")
-                response = self.rag_chain.run(query)
+
+                if self.is_initialized and self.rag_chain is not None:
+                    response = self.rag_chain.run(query)
+                else:
+                    print("RAG 체인이 초기화되지 않음: 기본 응답 사용")
+                    response = self._fallback_response(query)
+
                 end_time = time.time()
 
                 query_time = end_time - start_time
@@ -645,8 +835,11 @@ class AutoRAGChatApp:
         except Exception as e:
             error_msg = f"음성 처리 중 오류 발생: {str(e)}"
             print(f"[STT] {error_msg}")
-            chat_history.append(("음성 메시지", error_msg))
-            return "", chat_history
+            import traceback
+            traceback.print_exc()
+            new_history = list(chat_history)
+            new_history.append(["음성 메시지", error_msg])
+            return new_history
 
     def launch_app(self) -> None:
         """

clova_stt.py

@@ -5,11 +5,9 @@ import os
 import json
 import requests
 import tempfile
-from dotenv import load_dotenv
-
-# 환경 변수 로드
-load_dotenv()
 
+# config.py에서 설정 가져오기
+from config import NAVER_CLIENT_ID, NAVER_CLIENT_SECRET
 
 class ClovaSTT:
     """
@@ -20,8 +18,8 @@ class ClovaSTT:
         """
         클로바 STT 클라이언트 초기화
         """
-        self.client_id = os.getenv("NAVER_CLIENT_ID", "")
-        self.client_secret = os.getenv("NAVER_CLIENT_SECRET", "")
+        self.client_id = NAVER_CLIENT_ID
+        self.client_secret = NAVER_CLIENT_SECRET
 
         # 클라이언트 ID와 Secret 검증
         if not self.client_id or not self.client_secret: