deepseek_done

app.py

@@ -562,15 +562,15 @@ class AutoRAGChatApp:
             # 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'):
@@ -578,10 +578,10 @@ class AutoRAGChatApp:
                             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}' 디렉토리를 찾을 수 없습니다. 디렉토리가 존재하는지 확인하세요."
@@ -668,32 +668,87 @@ class AutoRAGChatApp:
             # 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:
-                        # 폴백 RAG 체인 시도
+                        logger.info("FallbackRAGChain으로 대체합니다...")
                         from fallback_rag_chain import FallbackRAGChain
-                        logger.info("폴백 RAG 체인으로 전환합니다...")
                         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)
-                        return f"문서와 벡터 인덱스는 처리되었으나 RAG 체인 초기화에 실패했습니다: {str(e)}"
+
+                        # 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:
-                    # RAGChain을 사용할 수 없는 경우 폴백 버전 사용
-                    from fallback_rag_chain import FallbackRAGChain
-                    logger.info("기본 RAG Chain을 사용할 수 없어 폴백 버전을 사용합니다...")
-                    self.rag_chain = FallbackRAGChain(self.vector_store)
-                    self.is_initialized = True
-                    logger.info("폴백 RAG 체인 초기화 성공")
+                    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)
+                    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)

config.py

@@ -1,6 +1,6 @@
 """
 벡터 스토어, 임베딩 모델, LLM 등 구성 요소 설정
-환경 변수 및 .env 파일 활용 개선 버전 - DeepSeek 지원 추가
+환경 변수 및 .env 파일 활용 개선 버전 - 탐색 속도 최적화
 """
 import os
 import logging
@@ -21,26 +21,35 @@ logger.info(f"스크립트 디렉토리: {script_dir}")
 logger.info(f"현재 작업 디렉토리: {os.getcwd()}")
 logger.info(f"운영 체제: {os.name}")
 
-# .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:
+# .env 파일 검색 최적화
+def fast_env_load():
+    """
+    .env 파일을 빠르게 찾아 로드하는 함수
+
+    Returns:
+        bool: 환경 변수 로드 성공 여부
+    """
+    # .env 파일 위치 후보들 (.env 파일은 일반적으로 프로젝트 루트에 있음)
+    env_paths = [
+        ".env",  # 현재 디렉토리
+        os.path.join(script_dir, ".env"),  # 스크립트 디렉토리
+    ]
+
+    # 위에서 빠르게 순회하며 찾기
+    for env_path in env_paths:
+        if os.path.isfile(env_path):
+            logger.info(f".env 파일 발견: {env_path}")
+            loaded = load_dotenv(env_path, verbose=False, override=True)
+            if loaded:
+                logger.info(f".env 파일 로드 성공: {env_path}")
+                return True
+
+    # 검색 실패 시 환경 변수 사용 메시지 출력
     logger.warning(".env 파일을 찾을 수 없습니다. 기본값 또는 시스템 환경 변수를 사용합니다.")
+    return False
+
+# 환경 변수 로드
+env_loaded = fast_env_load()
 
 # 환경 감지
 IS_HUGGINGFACE = os.getenv('SPACE_ID') is not None
@@ -143,8 +152,8 @@ 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_PUBLIC_KEY = get_env("LANGFUSE_PUBLIC_KEY", "pk-lf-cd6248e2-59ad-496d-a4cb-487bb3ecfcd5")
+LANGFUSE_SECRET_KEY = get_env("LANGFUSE_SECRET_KEY", "sk-lf-61460a1d-e637-4c22-b5e9-9250ac2579ba")
 LANGFUSE_HOST = get_env("LANGFUSE_HOST", "https://cloud.langfuse.com")
 
 # DeepSeek 관련 설정 추가
@@ -165,6 +174,9 @@ RERANKER_MODEL = get_env("RERANKER_MODEL", "Alibaba-NLP/gte-multilingual-reranke
 USE_OPENAI = get_env("USE_OPENAI", "False").lower() == "true"
 USE_DEEPSEEK = get_env("USE_DEEPSEEK", "False").lower() == "true"
 
+# Ollama 호스트 설정 (기본값)
+OLLAMA_HOST = get_env("OLLAMA_HOST", "http://localhost:11434")
+
 # DeepSeek API 테스트 함수
 def test_deepseek_connection():
     """
@@ -301,7 +313,6 @@ else:
         logger.info(f"OpenAI 모델 사용")
     else:
         LLM_MODEL = get_env("LLM_MODEL", "gemma3:latest")
-        OLLAMA_HOST = get_env("OLLAMA_HOST", "http://localhost:11434")
         logger.info(f"Ollama 모델 사용")
 
 # API 키 검증
@@ -336,8 +347,7 @@ def print_config():
     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:
-        logger.info(f"Ollama 호스트: {OLLAMA_HOST}")
+    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}")
@@ -410,7 +420,6 @@ def list_directory_contents():
     except Exception as e:
         logger.error(f"PDF 디렉토리 내용 확인 실패: {e}")
 
-
 # 직접 주어진 경로에서 PDF 찾기 (디버깅용)
 def find_pdf_files_in_path(path: str) -> list:
     """
@@ -434,7 +443,6 @@ def find_pdf_files_in_path(path: str) -> list:
         logger.error(f"경로 '{path}'에서 PDF 파일 검색 중 오류: {e}")
         return []
 
-
 # 윈도우즈 주요 경로에서 PDF 파일 검색 (디버깅용)
 def find_pdfs_in_windows_paths():
     """윈도우즈에서 주요 경로에 PDF 파일이 있는지 확인"""
@@ -454,7 +462,6 @@ def find_pdfs_in_windows_paths():
     for path in common_paths:
         find_pdf_files_in_path(path)
 
-
 # 설정 정보 출력 및 검증 (모듈 임포트 시 실행)
 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)}"

direct_deepseek.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']}")

fallback_rag_chain.py

@@ -1,53 +1,29 @@
 """
-폴백 RAG 체인 구현 (기본적인 기능만 포함)
+폴백 RAG 체인 구현 (기본적인 기능만 포함) - 직접 DeepSeek API 호출 방식
 """
 import os
 import logging
 import time
-import requests
-import json
 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 직접 클라이언트 사용
+# 직접 DeepSeek 클라이언트 사용
 from direct_deepseek import DirectDeepSeekClient
 
 # 설정 가져오기
 from config import (
     LLM_MODEL, USE_OPENAI, USE_DEEPSEEK,
-    OPENAI_API_KEY, DEEPSEEK_API_KEY, DEEPSEEK_ENDPOINT, DEEPSEEK_MODEL,
+    DEEPSEEK_API_KEY, DEEPSEEK_ENDPOINT, DEEPSEEK_MODEL,
     TOP_K_RETRIEVAL
 )
 
 # 로깅 설정
 logger = logging.getLogger("FallbackRAGChain")
 
-class CustomDeepSeekLLM:
-    """
-    OpenAI 클라이언트를 우회하는 커스텀 DeepSeek LLM 클래스
-    """
-    def __init__(self, api_key, model, temperature=0.3, request_timeout=120):
-        self.client = DirectDeepSeekClient(api_key, model)
-        self.temperature = temperature
-        self.request_timeout = request_timeout
-        logger.info(f"커스텀 DeepSeek LLM 초기화: 모델={model}, 온도={temperature}")
-
-    def invoke(self, prompt):
-        """
-        텍스트 생성 요청
-        """
-        result = self.client.generate(prompt, max_retries=3, timeout=self.request_timeout)
-        if result["success"]:
-            return result["response"]
-        else:
-            raise Exception(f"DeepSeek API 호출 실패: {result['message']}")
-
 class FallbackRAGChain:
     """
     기본적인 RAG 체인 구현 (단순화된 버전, 문제 해결용)
+    직접 DeepSeek API 호출 방식 사용
     """
 
     def __init__(self, vector_store):
@@ -60,41 +36,24 @@ class FallbackRAGChain:
         logger.info("폴백 RAG 체인 초기화...")
         self.vector_store = vector_store
 
-        # DeepSeek 모델 직접 초기화 (OpenAI 클라이언트 우회)
+        # DeepSeek 모델 직접 초기화
         if USE_DEEPSEEK and DEEPSEEK_API_KEY:
             logger.info(f"DeepSeek 모델 직접 초기화: {DEEPSEEK_MODEL}")
             try:
-                self.llm = CustomDeepSeekLLM(
+                self.client = DirectDeepSeekClient(
                     api_key=DEEPSEEK_API_KEY,
-                    model=DEEPSEEK_MODEL,
-                    temperature=0.3,
-                    request_timeout=120
+                    model_name=DEEPSEEK_MODEL
                 )
                 logger.info("DeepSeek 모델 직접 초기화 성공")
             except Exception as e:
                 logger.error(f"DeepSeek 모델 초기화 실패: {e}")
                 # 오프라인 모드로 폴백
-                self.llm = None
+                self.client = None
                 logger.warning("LLM이 초기화되지 않아 오프라인 모드로 동작합니다.")
         else:
             # LLM이 설정되지 않음
             logger.warning("LLM이 설정되지 않아 오프라인 모드로 동작합니다.")
-            self.llm = None
-
-        # 프롬프트 설정
-        self.prompt_template = """
-        다음 정보를 기반으로 질문에 정확하게 답변해주세요.
-
-        질문: {question}
-
-        참고 정보:
-        {context}
-
-        참고 정보에 답이 있으면 반드시 그 정보를 기반으로 답변하세요.
-        참고 정보에 답이 없는 경우에는 일반적인 지식을 활용하여 답변할 수 있지만, "제공된 문서에는 이 정보가 없으나, 일반적으로는..." 식으로 시작하세요.
-        답변은 정확하고 간결하게 제공하되, 가능한 참고 정보에서 근거를 찾아 설명해주세요.
-        참고 정보의 출처도 함께 알려주세요.
-        """
+            self.client = None
 
         logger.info("폴백 RAG 체인 초기화 완료")
 
@@ -143,6 +102,38 @@ class FallbackRAGChain:
             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이 없을 때 사용)
@@ -193,12 +184,12 @@ class FallbackRAGChain:
             context = self._retrieve(query)
 
             # LLM이 초기화되지 않은 경우 오프라인 응답
-            if self.llm is None:
+            if self.client is None:
                 logger.warning("LLM이 초기화되지 않아 오프라인 응답 생성")
                 return self._generate_simple_response(query, context)
 
             # 프롬프트 구성
-            prompt = self.prompt_template.format(question=query, context=context)
+            messages = self._generate_prompt(query, context)
 
             # 응답 생성 (최대 3회 시도)
             max_retries = 3
@@ -207,18 +198,31 @@ class FallbackRAGChain:
             for attempt in range(max_retries):
                 try:
                     logger.info(f"응답 생성 시도 ({attempt+1}/{max_retries})")
-                    response = self.llm.invoke(prompt)
-                    logger.info(f"응답 생성 성공 (길이: {len(response)})")
-                    return response
+
+                    # 직접 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}")
+                    logger.error(f"응답 생성 중 오류: {e}")
                     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:

monitoring.py

@@ -1,136 +0,0 @@
-"""
-Langfuse를 활용한 모니터링 구현 (선택적)
-"""
-from typing import Dict, Any, Optional
-import time
-import os
-from dotenv import load_dotenv
-
-# 환경 변수 로드
-load_dotenv()
-
-# 설정 값 가져오기
-LANGFUSE_SECRET_KEY = os.getenv("LANGFUSE_SECRET_KEY", "")
-LANGFUSE_PUBLIC_KEY = os.getenv("LANGFUSE_PUBLIC_KEY", "")
-LANGFUSE_HOST = os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com")
-
-class LangfuseMonitoring:
-    def __init__(self):
-        """
-        Langfuse 모니터링 초기화 (선택적 기능)
-        """
-        self.enabled = False
-        print("모니터링 기능을 초기화합니다...")
-
-        # Langfuse가 설치되어 있는지 확인
-        try:
-            from langfuse import Langfuse
-
-            if LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY:
-                try:
-                    self.langfuse = Langfuse(
-                        public_key=LANGFUSE_PUBLIC_KEY,
-                        secret_key=LANGFUSE_SECRET_KEY,
-                        host=LANGFUSE_HOST,
-                    )
-                    self.enabled = True
-                    print("Langfuse 모니터링이 활성화되었습니다.")
-                except Exception as e:
-                    print(f"Langfuse 초기화 실패: {e}")
-            else:
-                print("Langfuse API 키가 설정되지 않았습니다. 모니터링은 비활성화됩니다.")
-        except ImportError:
-            print("langfuse 패키지가 설치되지 않았습니다. 모니터링 기능이 비활성화됩니다.")
-            print("pip install langfuse 명령으로 설치할 수 있습니다.")
-
-    def start_trace(self, name: str, user_id: Optional[str] = None, metadata: Optional[Dict[str, Any]] = None) -> Any:
-        """
-        새 트레이스 시작
-
-        Args:
-            name: 트레이스 이름
-            user_id: 사용자 ID (선택적)
-            metadata: 추가 메타데이터 (선택적)
-
-        Returns:
-            트레이스 객체 또는 None
-        """
-        if not self.enabled:
-            return None
-
-        try:
-            return self.langfuse.trace(
-                name=name,
-                user_id=user_id,
-                metadata=metadata or {},
-            )
-        except Exception as e:
-            print(f"트레이스 생성 실패: {e}")
-            return None
-
-    def log_generation(self, trace: Any, name: str, prompt: str, response: str, metadata: Optional[Dict[str, Any]] = None) -> None:
-        """
-        LLM 생성 로깅
-
-        Args:
-            trace: 트레이스 객체
-            name: 생성 이름
-            prompt: 입력 프롬프트
-            response: 모델 응답
-            metadata: 추가 메타데이터 (선택적)
-        """
-        if not self.enabled or trace is None:
-            return
-
-        try:
-            trace.generation(
-                name=name,
-                model="user-defined-model",
-                prompt=prompt,
-                completion=response,
-                metadata=metadata or {},
-            )
-        except Exception as e:
-            print(f"생성 로깅 실패: {e}")
-
-    def log_span(self, trace: Any, name: str, input_data: Any, output_data: Any, start_time: float, end_time: float) -> None:
-        """
-        처리 구간 로깅
-
-        Args:
-            trace: 트레이스 객체
-            name: 구간 이름
-            input_data: 입력 데이터
-            output_data: 출력 데이터
-            start_time: 시작 시간
-            end_time: 종료 시간
-        """
-        if not self.enabled or trace is None:
-            return
-
-        try:
-            trace.span(
-                name=name,
-                start_time=start_time,
-                end_time=end_time,
-                input=input_data,
-                output=output_data,
-                metadata={"duration_ms": (end_time - start_time) * 1000},
-            )
-        except Exception as e:
-            print(f"구간 로깅 실패: {e}")
-
-    def end_trace(self, trace: Any) -> None:
-        """
-        트레이스 종료
-
-        Args:
-            trace: 종료할 트레이스 객체
-        """
-        if not self.enabled or trace is None:
-            return
-
-        try:
-            trace.update(status="success")
-        except Exception as e:
-            print(f"트레이스 종료 실패: {e}")

rag_chain.py

@@ -1,163 +1,133 @@
 """
-LangChain을 활용한 RAG 체인 구현 - DeepSeek 지원 추가 및 예외 처리 강화
+직접 DeepSeek API 호출을 위한 클라이언트 구현
 """
 import os
+import time
 import logging
-from typing import List, Dict, Any, Optional
-from langchain.schema import Document
-from langchain.prompts import PromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.runnables import RunnablePassthrough
-from langchain_community.chat_models import ChatOllama
-from langchain_openai import ChatOpenAI
-
-from config import (
-    OLLAMA_HOST, LLM_MODEL, USE_OPENAI, USE_DEEPSEEK,
-    OPENAI_API_KEY, DEEPSEEK_API_KEY, DEEPSEEK_ENDPOINT, DEEPSEEK_MODEL,
-    TOP_K_RETRIEVAL, TOP_K_RERANK
-)
-from vector_store import VectorStore
-from reranker import Reranker
-
-# DeepSeek 유틸리티 임포트
-try:
-    from deepseek_utils import test_deepseek_api, create_deepseek_client, DeepSeekError
-    DEEPSEEK_UTILS_AVAILABLE = True
-except ImportError:
-    DEEPSEEK_UTILS_AVAILABLE = False
+import requests
+import json
+from typing import Dict, Any, Optional, List
 
 # 로깅 설정
-logger = logging.getLogger("RAGChain")
-
-# 환경 감지
-IS_HUGGINGFACE = os.getenv('SPACE_ID') is not None
-
-# RAG 관련 예외 클래스
-class RAGChainInitError(Exception):
-    """RAG 체인 초기화 관련 오류"""
-    pass
-
-class LLMInitError(Exception):
-    """LLM 모델 초기화 관련 오류"""
-    pass
-
-class RerankerInitError(Exception):
-    """리랭커 초기화 관련 오류"""
-    pass
-
-class QueryProcessingError(Exception):
-    """쿼리 처리 중 발생한 오류"""
-    pass
-
-
-class RAGChain:
-    def __init__(self, vector_store: VectorStore, use_reranker: bool = True):
+logger = logging.getLogger("DirectDeepSeek")
+
+class DirectDeepSeekClient:
+    """
+    DeepSeek API를 직접 호출하는 클라이언트
+    OpenAI 클라이언트를 우회하고 직접 HTTP 요청 사용
+    """
+    def __init__(self, api_key: str, model_name: str = "deepseek-chat"):
         """
-        RAG 체인 초기화 (환경에 따른 LLM 선택)
+        클라이언트 초기화
 
         Args:
-            vector_store: 벡터 스토어 인스턴스
-            use_reranker: 리랭커 사용 여부
+            api_key: DeepSeek API 키
+            model_name: 사용할 모델 이름 (기본값: "deepseek-chat")
         """
-        try:
-            logger.info("RAGChain 초기화 시작...")
-
-            # 입력 유효성 검사
-            if vector_store is None or vector_store.vector_store is None:
-                raise RAGChainInitError("유효한 벡터 스토어가 필요합니다")
-
-            self.vector_store = vector_store
-            self.use_reranker = use_reranker
-            logger.info(f"리랭커 사용 여부: {use_reranker}")
-
-            # 리랭커 초기화
-            if use_reranker:
-                try:
-                    self.reranker = Reranker()
-                    logger.info("리랭커 초기화 성공")
-                except Exception as e:
-                    logger.error(f"리랭커 초기화 실패: {e}", exc_info=True)
-                    self.reranker = None
-                    self.use_reranker = False
-                    logger.warning("리랭커 사용이 비활성화되었습니다")
-            else:
-                self.reranker = None
-
-            # LLM 모델 초기화
-            self._initialize_llm()
-
-            # RAG 체인 구성 및 프롬프트 설정
-            logger.info("RAG 체인 설정 시작...")
-            self.setup_chain()
-            logger.info("RAG 체인 설정 완료")
-
-        except RAGChainInitError:
-            # 이미 로깅됨
-            raise
-        except Exception as e:
-            logger.error(f"RAGChain 초기화 중 예상치 못한 오류: {e}", exc_info=True)
-            raise RAGChainInitError(f"RAG 체인 초기화 실패: {str(e)}")
-
-    def _test_deepseek_api(self):
+        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]:
         """
-        DeepSeek API 연결 테스트 (별도 유틸리티 사용)
+        텍스트 생성 요청
+
+        Args:
+            prompt: 입력 프롬프트
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
 
         Returns:
-            테스트 결과 딕셔너리
+            생성 결과 딕셔너리 (success, response, message 등)
         """
-        if DEEPSEEK_UTILS_AVAILABLE:
-            try:
-                return test_deepseek_api(DEEPSEEK_API_KEY, DEEPSEEK_ENDPOINT, DEEPSEEK_MODEL)
-            except Exception as e:
-                logger.error(f"DeepSeek API 테스트 실패: {e}", exc_info=True)
-                return {"success": False, "message": f"테스트 오류: {str(e)}"}
-        else:
-            # 직접 구현
-            try:
-                import requests
-                import json
-
-                if not DEEPSEEK_API_KEY:
-                    return {
-                        "success": False,
-                        "message": "API 키가 설정되지 않았습니다."
-                    }
-
-                logger.info(f"DeepSeek API 연결 테스트: {DEEPSEEK_ENDPOINT}, 모델: {DEEPSEEK_MODEL}")
-
-                # 테스트용 간단한 프롬프트
-                test_prompt = "Hello, please respond with a short greeting."
+        # 메시지 구성 (단일 사용자 메시지)
+        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 호출
 
-                # API 요청 헤더 및 데이터
-                headers = {
-                    "Content-Type": "application/json",
-                    "Authorization": f"Bearer {DEEPSEEK_API_KEY}"
-                }
+        Args:
+            messages: 채팅 메시지 리스트 (role, content 키를 가진 딕셔너리 리스트)
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
 
-                payload = {
-                    "model": DEEPSEEK_MODEL,
-                    "messages": [{"role": "user", "content": test_prompt}],
-                    "temperature": 0.7,
-                    "max_tokens": 50
-                }
+        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(
-                    DEEPSEEK_ENDPOINT,
+                    self.endpoint,
                     headers=headers,
-                    data=json.dumps(payload),
-                    timeout=10  # 10초 타임아웃
+                    json=payload,
+                    timeout=timeout
                 )
 
                 # 응답 확인
                 if response.status_code == 200:
-                    logger.info("DeepSeek API 연결 성공")
-                    return {
-                        "success": True,
-                        "message": "API 연결 성공"
-                    }
+                    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()
@@ -165,200 +135,121 @@ class RAGChain:
                     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": f"API 오류: {error_message}"
+                        "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}", exc_info=True)
-                return {
-                    "success": False,
-                    "message": f"연결 테스트 오류: {str(e)}"
-                }
-
-    def _initialize_llm(self):
-        """LLM 모델 초기화 (환경에 따라 다른 모델 선택)"""
-        # DeepSeek 사용이 설정된 경우
-        if USE_DEEPSEEK:
-            logger.info(f"DeepSeek 모델 초기화: {DEEPSEEK_MODEL}")
-
-            if not DEEPSEEK_API_KEY:
-                logger.error("DeepSeek API 키가 설정되지 않았습니다")
-                raise LLMInitError("DeepSeek API 키가 설정되지 않았습니다")
-
-            # API 연결 테스트
-            test_result = self._test_deepseek_api()
-            if not test_result["success"]:
-                logger.error(f"DeepSeek API 연결 실패: {test_result['message']}")
-                raise LLMInitError(f"DeepSeek API 연결 실패: {test_result['message']}")
 
-            try:
-                # DeepSeek API는 OpenAI 호환 API를 제공
-                self.llm = ChatOpenAI(
-                    model=DEEPSEEK_MODEL,
-                    temperature=0.2,
-                    api_key=DEEPSEEK_API_KEY,
-                    base_url=DEEPSEEK_ENDPOINT.rstrip("/v1/chat/completions")  # 호환성을 위해 경로 조정
-                )
-                logger.info("DeepSeek 모델 초기화 성공")
-            except Exception as e:
-                logger.error(f"DeepSeek 모델 초기화 실패: {e}", exc_info=True)
-                raise LLMInitError(f"DeepSeek 모델 초기화 실패: {str(e)}")
-
-        # OpenAI 사용이 설정된 경우
-        elif USE_OPENAI or IS_HUGGINGFACE:
-            logger.info(f"OpenAI 모델 초기화: {LLM_MODEL}")
-            api_key = OPENAI_API_KEY
-            logger.info(f"API 키 존재 여부: {'있음' if api_key else '없음'}")
-            
-            if not api_key:
-                logger.error("OpenAI API 키가 설정되지 않았습니다")
-                raise LLMInitError("OpenAI API 키가 설정되지 않았습니다")
-                
-            try:
-                self.llm = ChatOpenAI(
-                    model_name=LLM_MODEL,
-                    temperature=0.2,
-                    api_key=api_key,
-                )
-                logger.info("OpenAI 모델 초기화 성공")
-            except Exception as e:
-                logger.error(f"OpenAI 모델 초기화 실패: {e}", exc_info=True)
-                raise LLMInitError(f"OpenAI 모델 초기화 실패: {str(e)}")
-        else:
-            try:
-                logger.info(f"Ollama 모델 초기화: {LLM_MODEL}")
-                
-                # Ollama 호스트 유효성 검사
-                if not OLLAMA_HOST:
-                    logger.error("Ollama 호스트가 설정되지 않았습니다")
-                    raise LLMInitError("Ollama 호스트가 설정되지 않았습니다")
-                    
-                self.llm = ChatOllama(
-                    model=LLM_MODEL,
-                    temperature=0.2,
-                    base_url=OLLAMA_HOST,
-                )
-                logger.info("Ollama 모델 초기화 성공")
             except Exception as e:
-                logger.error(f"Ollama 모델 초기화 실패: {e}", exc_info=True)
-                raise LLMInitError(f"Ollama 모델 초기화 실패: {str(e)}. Ollama가 실행 중인지 확인하세요.")
+                logger.error(f"DeepSeek API 요청 중 예상치 못한 오류: {e}")
 
-    def setup_chain(self) -> None:
-        """
-        RAG 체인 및 프롬프트 설정
-        """
-        try:
-            # 프롬프트 템플릿 정의
-            template = """
-            다음 정보를 기반으로 질문에 정확하게 답변해주세요.
-
-            질문: {question}
-
-            참고 정보:
-            {context}
-
-            참고 정보에 답이 있으면 반드시 그 정보를 기반으로 답변하세요.
-            참고 정보에 답이 없는 경우에는 일반적인 지식을 활용하여 답변할 수 있지만, "제공된 문서에는 이 정보가 없으나, 일반적으로는..." 식으로 시작하세요.
-            답변은 정확하고 간결하게 제공하되, 가능한 참고 정보에서 근거를 찾아 설명해주세요.
-            참고 정보의 출처도 함께 알려주세요.
-            """
-
-            self.prompt = PromptTemplate.from_template(template)
-
-            # RAG 체인 정의
-            self.chain = (
-                    {"context": self._retrieve, "question": RunnablePassthrough()}
-                    | self.prompt
-                    | self.llm
-                    | StrOutputParser()
-            )
-            
-            logger.info("RAG 체인 설정 완료")
-        except Exception as e:
-            logger.error(f"RAG 체인 설정 실패: {e}", exc_info=True)
-            raise RAGChainInitError(f"RAG 체인 설정 실패: {str(e)}")
-
-    def _retrieve(self, query: str) -> str:
+                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:
-            query: 사용자 질문
+            system_prompt: 시스템 프롬프트
+            user_prompt: 사용자 프롬프트
+            temperature: 생성 온도 (0.0 ~ 1.0)
+            max_tokens: 최대 생성 토큰 수
+            max_retries: 재시도 횟수
+            timeout: 요청 타임아웃 (초)
 
         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 "관련 문서를 찾을 수 없습니다."
-
-            # 리랭커 적용 (선택적)
-            if self.use_reranker and self.reranker and docs:
-                try:
-                    logger.info(f"리랭킹 수행: {len(docs)}개 문서")
-                    docs = self.reranker.rerank(query, docs, top_k=TOP_K_RERANK)
-                    logger.info(f"리랭킹 완료: {len(docs)}개 문서 선택됨")
-                except Exception as e:
-                    logger.error(f"리랭킹 실패: {e}", exc_info=True)
-                    # 리랭킹 실패 시 원본 문서 사용
-                    logger.warning("리랭킹 실패로 원본 검색 결과 사용")
-
-            # 검색 결과 컨텍스트 구성
-            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)
-            logger.info(f"컨텍스트 생성 완료: {len(context_parts)}개 문서, {len(context)} 문자")
-            return context
-            
-        except Exception as e:
-            logger.error(f"검색 중 오류: {e}", exc_info=True)
-            raise QueryProcessingError(f"문서 검색 중 오류 발생: {str(e)}")
-
-    def run(self, query: str) -> str:
+            생성 결과 딕셔너리
         """
-        사용자 쿼리에 대한 RAG 파이프라인 실행
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt}
+        ]
 
-        Args:
-            query: 사용자 질문
+        return self.chat(messages, temperature, max_tokens, max_retries, timeout)
 
-        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 = logger.debug(f"RAG 체인 실행 시작")
-            
-            # 체인 실행
-            response = self.chain.invoke(query)
-            
-            logger.info("RAG 체인 실행 완료")
-            return response
-            
-        except QueryProcessingError as e:
-            # 이미 로깅됨
-            return f"검색 오류: {str(e)}"
-        except Exception as e:
-            logger.error(f"RAG 체인 실행 중 오류: {e}", exc_info=True)
-            return f"질문 처리 중 오류가 발생했습니다: {str(e)}"
+
+# 단독 실행을 위한 테스트 코드
+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']}")

simple_rag_chain.py

@@ -1,66 +1,123 @@
 """
-간단한 RAG 체인 구현 (디버깅용)
+간단한 RAG 체인 구현 (디버깅용) - 직접 DeepSeek API 호출 방식
 """
 import os
-from langchain_openai import ChatOpenAI
-from langchain.prompts import PromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.runnables import RunnablePassthrough
+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):
+    def __init__(self, vector_store, api_key=None, model="deepseek-chat", endpoint=None):
         """간단한 RAG 체인 초기화"""
-        print("간단한 RAG 체인 초기화 중...")
+        logger.info("간단한 RAG 체인 초기화 중...")
         self.vector_store = vector_store
 
-        # OpenAI API 키 확인
-        openai_api_key = os.environ.get("OPENAI_API_KEY", "")
-        print(f"API 키 설정됨: {bool(openai_api_key)}")
+        # 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)}")
 
-        # OpenAI 모델 초기화
-        self.llm = ChatOpenAI(
-            model_name="gpt-3.5-turbo",
-            temperature=0.2,
-            api_key=openai_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
 
-        # 프롬프트 템플릿
-        template = """
-        다음 정보를 기반으로 질문에 정확하게 답변해주세요.
+        logger.info("간단한 RAG 체인 초기화 완료")
 
-        질문: {question}
+    def _retrieve(self, query: str) -> str:
+        """문서 검색 및 컨텍스트 구성"""
+        try:
+            docs = self.vector_store.similarity_search(query, k=3)
+            if not docs:
+                return "관련 문서를 찾을 수 없습니다."
 
-        참고 정보:
-        {context}
+            # 검색 결과 컨텍스트 구성
+            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")
 
-        self.prompt = PromptTemplate.from_template(template)
+            context = "\n".join(context_parts)
 
-        # 체인 구성
-        self.chain = (
-                {"context": self._retrieve, "question": RunnablePassthrough()}
-                | self.prompt
-                | self.llm
-                | StrOutputParser()
-        )
-        print("간단한 RAG 체인 초기화 완료")
+            # 길이 제한
+            if len(context) > 6000:
+                context = context[:2500] + "\n...(중략)...\n" + context[-2500:]
 
-    def _retrieve(self, query):
-        """문서 검색"""
-        try:
-            docs = self.vector_store.similarity_search(query, k=3)
-            return "\n\n".join(doc.page_content for doc in docs)
+            return context
         except Exception as e:
-            print(f"검색 중 오류: {e}")
+            logger.error(f"검색 중 오류: {e}")
             return "문서 검색 중 오류가 발생했습니다."
 
-    def run(self, query):
+    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:
-            return self.chain.invoke(query)
+            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:
-            print(f"실행 중 오류: {e}")
+            logger.error(f"실행 중 오류: {e}")
             return f"오류 발생: {str(e)}"

test_deepseek.py

@@ -1,123 +0,0 @@
-"""
-DeepSeek API 연결 테스트 스크립트
-사용법: python test_deepseek.py
-"""
-import os
-import sys
-import requests
-import json
-import time
-from dotenv import load_dotenv
-
-
-def main():
-    # .env 파일 로드 시도
-    load_dotenv()
-
-    # API 키 확인
-    api_key = os.getenv("DEEPSEEK_API_KEY", "")
-    if not api_key:
-        print("오류: DEEPSEEK_API_KEY가 설정되지 않았습니다.")
-        print("다음 방법 중 하나로 API 키를 설정해주세요:")
-        print("1. .env 파일에 DEEPSEEK_API_KEY=your_api_key 추가")
-        print("2. 환경 변수로 설정 (export DEEPSEEK_API_KEY=your_api_key)")
-        return False
-
-    # 엔드포인트 및 모델 설정
-    endpoint = os.getenv("DEEPSEEK_ENDPOINT", "https://api.deepseek.com/v1/chat/completions")
-    model = os.getenv("DEEPSEEK_MODEL", "deepseek-chat")
-
-    print(f"DeepSeek API 테스트를 시작합니다...")
-    print(f"엔드포인트: {endpoint}")
-    print(f"모델: {model}")
-    print(f"API 키: {api_key[:5]}...{api_key[-4:] if len(api_key) > 8 else '****'}")
-
-    # 간단한 프롬프트
-    test_prompt = "Hello, please respond with a short greeting in Korean."
-
-    # 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": 100
-    }
-
-    print("\n요청 데이터:")
-    print(json.dumps(payload, indent=2, ensure_ascii=False))
-
-    # 타이머 시작
-    start_time = time.time()
-
-    try:
-        print("\nAPI 요청 전송 중...")
-        response = requests.post(
-            endpoint,
-            headers=headers,
-            data=json.dumps(payload),
-            timeout=30  # 30초 타임아웃
-        )
-
-        elapsed_time = time.time() - start_time
-
-        print(f"응답 수신 (소요 시간: {elapsed_time:.2f}초)")
-        print(f"HTTP 상태 코드: {response.status_code}")
-
-        # 응답 확인
-        if response.status_code == 200:
-            print("\n성공! DeepSeek API가 정상 작동합니다.")
-
-            try:
-                response_data = response.json()
-                print("\n응답 데이터:")
-                print(json.dumps(response_data, indent=2, ensure_ascii=False))
-
-                # 응답 텍스트 추출
-                if "choices" in response_data and len(response_data["choices"]) > 0:
-                    message = response_data["choices"][0].get("message", {})
-                    content = message.get("content", "")
-                    print("\n응답 내용:")
-                    print("-" * 40)
-                    print(content)
-                    print("-" * 40)
-                else:
-                    print("\n경고: 응답에서 'choices' 필드를 찾을 수 없습니다.")
-
-                return True
-            except json.JSONDecodeError:
-                print("\n경고: 응답을 JSON으로 파싱할 수 없습니다.")
-                print("원본 응답 내용:")
-                print(response.text)
-                return False
-        else:
-            print("\n오류: DeepSeek API 호출 실패")
-
-            try:
-                error_data = response.json()
-                print("\n오류 정보:")
-                print(json.dumps(error_data, indent=2, ensure_ascii=False))
-            except:
-                print("\n원본 오류 응답:")
-                print(response.text)
-
-            return False
-
-    except requests.exceptions.Timeout:
-        print("\n오류: API 요청 시간 초과")
-        return False
-    except requests.exceptions.ConnectionError:
-        print("\n오류: API 서버 연결 실패")
-        return False
-    except Exception as e:
-        print(f"\n오류: 예상치 못한 오류 발생 - {str(e)}")
-        return False
-
-
-if __name__ == "__main__":
-    success = main()
-    sys.exit(0 if success else 1)