Update reg_embedding_system.py

reg_embedding_system.py

@@ -207,9 +207,9 @@ def load_embedding_from_faiss(
             embeddings=embeddings,
             allow_dangerous_deserialization=True
         )
-        print(f"[로드 성공] FAISS 인덱스 로드 완료: {persist_dir}")
+        logger.info(f"[로드 성공] FAISS 인덱스 로드 완료: {persist_dir}")
     except Exception as e:
-        print(f"[로드 오류] FAISS 로드 실패: {e}")
+        logger.info(f"[로드 오류] FAISS 로드 실패: {e}")
         raise
 
     # 3) BM25를 위한 문서 추출
@@ -218,7 +218,7 @@ def load_embedding_from_faiss(
         if hasattr(vectorstore, "docstore") and hasattr(vectorstore.docstore, "_dict"):
             docs = list(vectorstore.docstore._dict.values())
     except Exception as e:
-        print(f"[경고] 저장된 문서를 읽는 중 문제가 발생했습니다: {e}")
+        logger.info(f"[경고] 저장된 문서를 읽는 중 문제가 발생했습니다: {e}")
 
     # 4) 앙상블 리트리버 구성
     vector_retriever = vectorstore.as_retriever(search_kwargs={"k": top_k})
@@ -231,7 +231,7 @@ def load_embedding_from_faiss(
             weights=list(weights)
         )
     else:
-        print("[안내] 문서를 찾지 못해 BM25 없이 벡터 리트리버만 반환합니다.")
+        logger.info("[안내] 문서를 찾지 못해 BM25 없이 벡터 리트리버만 반환합니다.")
         ensemble_retriever = vector_retriever
 
     # 5) SQLite 연결 
@@ -266,8 +266,8 @@ def search_with_metadata_filter(
         params = []
 
         for key, value in metadata_filter.items():
-            print(f"[key] {key}")
-            print(f"[value] {value}")
+            logger.info(f"[key] {key}")
+            logger.info(f"[value] {value}")
             if isinstance(value, list): 
                 if not value: 
                     continue
@@ -285,14 +285,14 @@ def search_with_metadata_filter(
             try:
                 cursor.execute(sql_query, params)
                 filtered_ids = {row[0] for row in cursor.fetchall()}
-                print(f"[사전 필터링] {len(filtered_ids)}개 ID 획득 → FAISS 검색 제한")
+                logger.info(f"[사전 필터링] {len(filtered_ids)}개 ID 획득 → FAISS 검색 제한")
             except Exception as e:
-                print(f"[경고] SQLite 필터링 실패: {e}")
+                logger.info(f"[경고] SQLite 필터링 실패: {e}")
                 filtered_ids = None
         else:
-            print("[안내] 필터 조건 없음 → 전체 검색")
+            logger.info("[안내] 필터 조건 없음 → 전체 검색")
     else:
-        print("[안내] 필터 또는 DB 없음 → 전체 검색")
+        logger.info("[안내] 필터 또는 DB 없음 → 전체 검색")
 
     # === 2. FAISS 벡터 검색 ===
     if filtered_ids and len(filtered_ids) > 0:
@@ -321,11 +321,11 @@ def search_with_metadata_filter(
             if isinstance(doc, Document):
                 vector_docs.append(doc)
 
-        print(f"[벡터 검색] {len(valid_indices)}개 후보 → {len(vector_docs)}개 유효")
+        logger.info(f"[벡터 검색] {len(valid_indices)}개 후보 → {len(vector_docs)}개 유효")
     else:
         search_k = k * 5
         vector_docs = vector_ret.invoke(query, config={"search_kwargs": {"k": search_k}})
-        print(f"[벡터 검색] 전체 검색 → {len(vector_docs)}개 후보")
+        logger.info(f"[벡터 검색] 전체 검색 → {len(vector_docs)}개 후보")
 
     # === 3. BM25 검색 ===
     bm25_docs = []
@@ -336,13 +336,13 @@ def search_with_metadata_filter(
             bm25_docs = [d for d in candidates if d.metadata.get('faiss_id') in filtered_ids]
         else:
             bm25_docs = candidates[:k]
-        print(f"[BM25 검색] {len(candidates)}개 후보 → {len(bm25_docs)}개 필터링 후")
+        logger.info(f"[BM25 검색] {len(candidates)}개 후보 → {len(bm25_docs)}개 필터링 후")
 
     # === 4. 병합 및 최종 k개 반환 ===
     combined = {id(d): d for d in (vector_docs + bm25_docs)}.values()
     final_results = list(combined)[:k]
 
-    print(f"[최종 결과] {len(final_results)}개 문서 반환")
+    logger.info(f"[최종 결과] {len(final_results)}개 문서 반환")
     return final_results
 
 def get_unique_metadata_values(
@@ -352,7 +352,7 @@ def get_unique_metadata_values(
 ) -> List[str]:
     """SQLite에서 특정 컬럼의 고유한 값 리스트를 반환합니다."""
     if not sqlite_conn:
-        print("[경고] SQLite 연결이 없어 고유 값 검색을 수행할 수 없습니다.")
+        logger.info("[경고] SQLite 연결이 없어 고유 값 검색을 수행할 수 없습니다.")
         return []
 
     cursor = sqlite_conn.cursor()
@@ -368,10 +368,10 @@ def get_unique_metadata_values(
         unique_values = [row[0] for row in cursor.fetchall() if row[0] is not None]
         return unique_values
     except sqlite3.OperationalError as e:
-        print(f"[에러] SQLite 쿼리 실행 실패 (컬럼 '{key_name}' 이름 오류 가능): {e}")
+        logger.info(f"[에러] SQLite 쿼리 실행 실패 (컬럼 '{key_name}' 이름 오류 가능): {e}")
         return []
     except Exception as e:
-        print(f"[에러] 고유 값 검색 중 알 수 없는 오류 발생: {e}")
+        logger.info(f"[에러] 고유 값 검색 중 알 수 없는 오류 발생: {e}")
         return []
 
 def smart_search_vectorstore(
@@ -386,10 +386,10 @@ def smart_search_vectorstore(
     # 1. 기본 검색
     basic_results = retriever.invoke(query)
     basic_results = basic_results[:k]
-    print(f"[기본 검색] {len(basic_results)}개 문서 검색 완료")
+    logger.info(f"[기본 검색] {len(basic_results)}개 문서 검색 완료")
     
     if not enable_detailed_search or not vectorstore or not sqlite_conn:
-        print("[안내] 상세 검색 비활성화 또는 컴포넌트 부족 → 기본 검색 결과만 반환")
+        logger.info("[안내] 상세 검색 비활성화 또는 컴포넌트 부족 → 기본 검색 결과만 반환")
         return basic_results
     
     # 2. regulation_part 빈도 분석
@@ -406,18 +406,18 @@ def smart_search_vectorstore(
                     regulation_parts.append(reg_part)
     
     if not regulation_parts:
-        print("[안내] regulation_part 메타데이터 없음 → 기본 검색 결과만 반환")
+        logger.info("[안내] regulation_part 메타데이터 없음 → 기본 검색 결과만 반환")
         return basic_results
     
     counter = Counter(regulation_parts)
     most_extracted_category = counter.most_common(2)
-    print(f"[빈도 분석] regulation_part 빈도: {dict(counter)}")
-    print(f"[상위 카테고리] {most_extracted_category}")
+    logger.info(f"[빈도 분석] regulation_part 빈도: {dict(counter)}")
+    logger.info(f"[상위 카테고리] {most_extracted_category}")
     
     # 3. 상세 검색
     detailed_results = []
     for rank, (category, count) in enumerate(most_extracted_category, 1):
-        print(f"[상세 검색 {rank}순위] '{category}' 카테고리 검색 시작 (빈도: {count})")
+        logger.info(f"[상세 검색 {rank}순위] '{category}' 카테고리 검색 시작 (빈도: {count})")
         metadata_filter = {'regulation_part': category}
         
         try:
@@ -430,9 +430,9 @@ def smart_search_vectorstore(
                 sqlite_conn=sqlite_conn
             )
             detailed_results.extend(category_results)
-            print(f"[상세 검색 {rank}순위] {len(category_results)}개 추가 문서 검색 완료")
+            logger.info(f"[상세 검색 {rank}순위] {len(category_results)}개 추가 문서 검색 완료")
         except Exception as e:
-            print(f"[경고] 상세 검색 {rank}순위 실패 ({category}): {e}")
+            logger.info(f"[경고] 상세 검색 {rank}순위 실패 ({category}): {e}")
             continue
     
     # 4. 결과 병합
@@ -452,7 +452,7 @@ def smart_search_vectorstore(
             final_results.append(doc)
     
     final_results = final_results[:k]
-    print(f"[최종 결과] 기본 {len(basic_results)}개 + 상세 {len(detailed_results)}개 → 중복 제거 후 {len(final_results)}개 반환")
+    logger.info(f"[최종 결과] 기본 {len(basic_results)}개 + 상세 {len(detailed_results)}개 → 중복 제거 후 {len(final_results)}개 반환")
     
     return final_results