Update app.py

app.py

@@ -1,4 +1,8 @@
 import os
+#os.environ["PYDANTIC_V1_STYLE"] = "1"
+#os.environ["PYDANTIC_SKIP_VALIDATING_CORE_SCHEMAS"] = "1"
+# --------------------------------------------------------------------------
+
 from flask import Flask, render_template, jsonify, request, Response
 from flask_socketio import SocketIO, emit
 import uuid
@@ -34,12 +38,16 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 # --- 외부 모듈 임포트 ---
-import reg_embedding_system
+# [수정됨] v02 파일명에 맞춰 임포트 (파일명이 reg_embedding_system_v02.py라면 아래와 같이 수정)
+# 여기서는 편의상 reg_embedding_system으로 사용하되 내용은 v02라고 가정합니다.
+import reg_embedding_system_v02 as reg_embedding_system 
 import leximind_prompts
 
 # --- 전역 변수 ---
 connected_clients = 0
 search_document_number = 30
+Filtered_search = False
+filters = {"regulation": []} # [수정됨] 기본 필터 키 변경
 
 # --- 경로 설정 ---
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -62,18 +70,19 @@ active_sessions = {}
 # --- RAG 객체 ---
 region_rag_objects = {}
 
-# --- Together AI 설정 (SDK 대신 API 호출에 사용) ---
+# --- Together AI 설정 ---
 TOGETHER_API_KEY = os.getenv("TOGETHER_API_KEY")
 if not TOGETHER_API_KEY:
-    raise EnvironmentError("TOGETHER_API_KEY가 설정되지 않았습니다. Hugging Face Secrets에 추가하세요.")
-# client = Together(api_key=TOGETHER_API_KEY) # <--- Together SDK 클라이언트 제거
+    # 로컬 테스트용 예외 처리 등을 위해 raise 대신 경고 로그만 남길 수도 있음
+    logger.warning("TOGETHER_API_KEY가 설정되지 않았습니다.")
 
 try:
-    # TOGETHER_API_KEY를 사용해 클라이언트 초기화 (TOGETHER_API_KEY가 코드 내에 정의되어 있다고 가정)
     client = Together(api_key=TOGETHER_API_KEY) 
 except NameError:
-    # TOGETHER_API_KEY가 정의되지 않은 경우 환경 변수 사용을 시도
     client = Together()
+except Exception as e:
+    logger.warning(f"Together Client 초기화 실패 (API 키 확인 필요): {e}")
+    client = None
 
 rag_connection_status_info = ""
 
@@ -82,7 +91,6 @@ def load_rag_objects():
     global region_rag_objects
     global rag_connection_status_info
     
-    # 로딩 스레드 시작 로그를 추가하여 Gunicorn 로그에서 확인 가능하게 함
     logger.info(">>> [RAG_LOADER] RAG 로딩 스레드 시작 <<<")
     
     for region, path in region_paths.items():
@@ -96,14 +104,16 @@ def load_rag_objects():
             socketio.emit('message', {'message': f"[{region}] RAG 로딩 중..."})
             rag_connection_status_info = f"[{region}] RAG 로딩 중..."
             
-            # NOTE: reg_embedding_system 모듈이 현재 환경에 설치/존재하는지 확인해야 합니다.
-            ensemble_retriever, vectorstore, sqlite_conn = reg_embedding_system.load_embedding_from_faiss(path)
+            # [수정됨] load_embedding_from_faiss 반환값 변경 (Ensemble -> BM25)
+            bm25_retriever, vectorstore, sqlite_conn = reg_embedding_system.load_embedding_from_faiss(path)
             sqlite_conn.close()
+            
             db_path = os.path.join(path, "metadata_mapping.db")
             new_conn = sqlite3.connect(db_path, check_same_thread=False)
 
+            # [수정됨] 딕셔너리 키 변경 (ensemble_retriever -> bm25_retriever)
             region_rag_objects[region] = {
-                "ensemble_retriever": ensemble_retriever,
+                "bm25_retriever": bm25_retriever,
                 "vectorstore": vectorstore,
                 "sqlite_conn": new_conn
             }
@@ -114,8 +124,7 @@ def load_rag_objects():
         except Exception as e:
             error_msg = f"[{region}] 로딩 실패: {str(e)}"
             logger.info(error_msg)
-            # [수정]: 상세한 에러 추적을 위해 traceback 추가
-            traceback.logger.info_exc() 
+            traceback.print_exc() 
             socketio.emit('message', {'message': error_msg})
 
     socketio.emit('message', {'message': "Ready to Search"})
@@ -128,65 +137,57 @@ def index():
     return render_template('chat_v03.html')
 
 # 전역 변수에 기본값 추가
-Search_each_all_mode = True  # 기본값을 클라이언트에서 제어 가능
+Search_each_all_mode = True
 
 @socketio.on('search_query')
 def handle_search_query(data):
+    global Filtered_search
+    global filters
     global Search_each_all_mode
-    global current_dir
 
-    # 세션 ID 생성
     session_id = str(uuid.uuid4())
     active_sessions[session_id] = True
     
-    # 클라이언트에 session_id 전달
     emit('search_started', {'session_id': session_id})
     
     try:
-        # 클라이언트에서 전송된 검색 모드 사용
         Search_each_all_mode = data.get('searchEachMode', True)
-
         query = data.get('query', '')
         regions = data.get('regions', [])
         selected_regulations = data.get('selectedRegulations', [])
         
         emit('search_status', {'status': 'processing', 'message': '검색 요청을 처리하는 중입니다...'})
         
-        logger.info("선택된 지역: %s", regions)
-        logger.info("선택된 법규: %s", selected_regulations)
-        logger.info("검색 모드: %s", "각각 검색" if Search_each_all_mode else "통합 검색")
+        # [수정됨] 초기 필터 구조 변경 (새로운 DB 스키마 반영)
+        filters = {
+            "regulation": [],    # 구 regulation_part
+            "section": [],       # 구 regulation_section
+            "chapter": [],       # 구 chapter_section
+            "standard": []       # 구 jo
+        }
 
-        # 번역 진행 상황 알림
         emit('search_status', {'status': 'translating', 'message': '질문에 대해 생각 중입니다...'})
         
         if session_id not in active_sessions:
-            emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
-            emit('search_status', {'status': 'processing', 'message': 'Ready to search'})
             return
 
         Translated_query = Gemma3_AI_Translate(query)
         emit('search_status', {'status': 'translated', 'message': f'번역 완료: {Translated_query}'})
-        logger.info(f"Query: Original query : {query}")
-        logger.info(f"Query: Translated_query : {Translated_query}")
         
         if selected_regulations:
+            Filtered_search = True
             cont_selected_num = 0
 
-            # 파일로 저장
             output_path = os.path.join(current_dir, "merged_ai_messages.txt")
-            
             if os.path.exists(output_path):
                 os.remove(output_path)
-                logger.info(f"기존 파일 삭제 완료: {output_path}")
             
-             # 통합 검색 모드 - 타입별로 그룹화
+            # 통합 검색 모드 - 타입별로 그룹화
             grouped_regulations = group_regulations_by_type(selected_regulations)
             emit('search_status', {'status': 'searching', 'message': f'선택된 {len(selected_regulations)}개 법규를 타입별로 통합하여 검색 중...'})
             
             # 타입별로 필터 생성
             combined_filters = create_combined_filters(grouped_regulations)
-            logger.info(f"통합 필터: {combined_filters}")
-
             combined_cleaned_filter = {k: v for k, v in combined_filters.items() if v}
 
             if Search_each_all_mode:
@@ -196,14 +197,12 @@ def handle_search_query(data):
                 total_search_num = sum(len(v) for v in combined_cleaned_filter.values())
                 i = 0
                 for RegType, RegNames in combined_cleaned_filter.items():
-                    if RegNames:  # 값이 비어있지 않은 경우만 처리
+                    if RegNames:
                         for RegName in RegNames:
                             i = i + 1
-                            #RegType는 법규 유형, RegName은 법규 명칭
-
+                            
                             if session_id not in active_sessions:
                                 emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
-                                emit('search_status', {'status': 'processing', 'message': 'Ready to search'})
                                 return
 
                             emit('search_status', {
@@ -214,15 +213,12 @@ def handle_search_query(data):
 
                             # 법규 타입별 필터 생성
                             current_filters = create_filter_by_type(RegType, RegName)
-                            logger.info(f"생성된 필터: {current_filters}")
 
-                            Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, current_filters, False) #마지막 False값은 유사한 값에 대한 검색을 하지 않겠다는 의미
+                            # [수정됨] failsafe_mode 인자 제거 (v02 함수 정의에 없음)
+                            Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, current_filters)
 
                             if Rag_Results:
-                                if session_id not in active_sessions:
-                                    emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
-                                    emit('search_status', {'status': 'processing', 'message': 'Ready to search'})
-                                    return
+                                if session_id not in active_sessions: return
                                     
                                 emit('search_status', {
                                     'status': 'ai_processing', 
@@ -230,13 +226,9 @@ def handle_search_query(data):
                                 })
                                 
                                 AImessage = RegAI(query, Rag_Results, ResultFile_FolderAddress)
-                                logger.info(f"Answer: {AImessage}")
 
-                                if session_id not in active_sessions:
-                                    emit('search_cancelled', {'message': '검색이 취소되었습니다.'})
-                                    return
+                                if session_id not in active_sessions: return
 
-                                # 각 법규별 결과를 실시간으로 전송 (타입 정보 포함)
                                 emit('regulation_result', {
                                     'regulation_title': f"[{RegName}]",
                                     'regulation_index': i,
@@ -244,7 +236,6 @@ def handle_search_query(data):
                                     'result': AImessage
                                 })
 
-                                # 파일에 저장
                                 if isinstance(AImessage, str) and AImessage.strip():
                                     with open(output_path, "a", encoding="utf-8") as f:
                                         cont_selected_num += 1
@@ -254,27 +245,28 @@ def handle_search_query(data):
 
                 emit('search_complete', {'status': 'completed', 'message': '모든 법규 검색이 완료되었습니다.'})
             else:
-                Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, combined_filters, True)
+                # [수정됨] failsafe_mode 인자 제거
+                Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, combined_filters)
                 
                 if session_id in active_sessions:
                     emit('search_status', {'status': 'ai_processing', 'message': 'AI가 통합 답변을 생성 중...'})
                     AImessage = RegAI(query, Rag_Results, ResultFile_FolderAddress)
-                    logger.info(f"Answer: {AImessage}")
                     
                     if session_id in active_sessions:
                         emit('search_result', {'result': AImessage})
                         emit('search_complete', {'status': 'completed', 'message': '통합 검색이 완료되었습니다.'})
 
         else:
+            Filtered_search = False
             emit('search_status', {'status': 'searching_all', 'message': '전체 법규에서 검색 중...'})
             
             # 필터 없이 검색
-            Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, None, True)
+            # [수정됨] failsafe_mode 인자 제거
+            Rag_Results = search_DB_from_multiple_regions(Translated_query, regions, region_rag_objects, None)
             
             if session_id in active_sessions:
                 emit('search_status', {'status': 'ai_processing', 'message': 'AI가 답변을 생성 중...'})
                 AImessage = RegAI(query, Rag_Results, ResultFile_FolderAddress)
-                logger.info(f"Answer: {AImessage}")
                 
                 if session_id in active_sessions:
                     emit('search_result', {'result': AImessage})
@@ -282,9 +274,9 @@ def handle_search_query(data):
 
     except Exception as e:
         print(f"검색 오류: {e}")
+        traceback.print_exc()
         emit('search_error', {'error': str(e), 'message': '검색 중 오류가 발생했습니다.'})
     finally:
-        # 세션 정리
         if session_id in active_sessions:
             del active_sessions[session_id]
 
@@ -303,7 +295,6 @@ def get_reg_list():
     data = request.get_json()
     selected_regions = data.get('regions', [])
 
-    # 지역이 선택되지 않았으면 전체 지역으로 설정
     if not selected_regions:
         selected_regions = ["국내", "북미", "유럽"]
 
@@ -315,28 +306,20 @@ def get_reg_list():
     for region in selected_regions:
         rag = region_rag_objects.get(region)
         if not rag:
-            continue  # 해당 지역 RAG가 없으면 건너뜀
+            continue 
 
         try:
-            # 이미 로드된 SQLite 연결 재사용
             sqlite_conn = rag["sqlite_conn"]
-            reg_list_part = get_unique_metadata_values(sqlite_conn, "regulation_part")
-            reg_list_section = get_unique_metadata_values(sqlite_conn, "regulation_section")
-            reg_list_chapter = get_unique_metadata_values(sqlite_conn, "chapter_section")
-            reg_list_jo = get_unique_metadata_values(sqlite_conn, "jo")
-
-            # 문자열이면 리스트로 변환
-            if isinstance(reg_list_part, str):
-                reg_list_part = [reg_list_part]
-            
-            if isinstance(reg_list_section, str):
-                reg_list_section = [reg_list_section]
-            
-            if isinstance(reg_list_chapter, str):
-                reg_list_chapter = [reg_list_chapter]
-            
-            if isinstance(reg_list_jo, str):
-                reg_list_jo = [reg_list_jo]
+            # [수정됨] v02 스키마(regulation, section, chapter, standard)에 맞춰 쿼리
+            reg_list_part = get_unique_metadata_values(sqlite_conn, "regulation")  # 구 regulation_part
+            reg_list_section = get_unique_metadata_values(sqlite_conn, "section")  # 구 regulation_section
+            reg_list_chapter = get_unique_metadata_values(sqlite_conn, "chapter")  # 구 chapter_section
+            reg_list_jo = get_unique_metadata_values(sqlite_conn, "standard")      # 구 jo
+
+            if isinstance(reg_list_part, str): reg_list_part = [reg_list_part]
+            if isinstance(reg_list_section, str): reg_list_section = [reg_list_section]
+            if isinstance(reg_list_chapter, str): reg_list_chapter = [reg_list_chapter]
+            if isinstance(reg_list_jo, str): reg_list_jo = [reg_list_jo]
 
             all_reg_list_part.extend(reg_list_part)
             all_reg_list_section.extend(reg_list_section)
@@ -345,19 +328,14 @@ def get_reg_list():
         except Exception as e:
             print(f"[{region}] DB 연결 오류: {e}")
 
-    # 중복 제거
-    #unique_reg_list_part = list(set(all_reg_list_part)) 
+    # 자연 정렬 및 중복 제거
     unique_reg_list_part = sorted(set(all_reg_list_part), key=reg_embedding_system.natural_sort_key)
-
-    #unique_reg_list_section = list(set(all_reg_list_section))
     unique_reg_list_section = sorted(set(all_reg_list_section), key=reg_embedding_system.natural_sort_key)
-
-    #unique_reg_list_chapter = list(set(all_reg_list_chapter))
     unique_reg_list_chapter = sorted(set(all_reg_list_chapter), key=reg_embedding_system.natural_sort_key)
-
-    #unique_reg_list_jo = list(set(all_reg_list_jo))
     unique_reg_list_jo = sorted(set(all_reg_list_jo), key=reg_embedding_system.natural_sort_key)
 
+    # Frontend(HTML)에서는 기존 key(reg_list_part 등)를 그대로 사용할 가능성이 높으므로 
+    # 반환 변수명은 유지하되 내용은 새로운 DB 컬럼에서 가져온 것을 넣습니다.
     text_result_part = "\n".join(str(item) for item in unique_reg_list_part)
     text_result_section = "\n".join(str(item) for item in unique_reg_list_section)
     text_result_chapter = "\n".join(str(item) for item in unique_reg_list_chapter)
@@ -374,16 +352,11 @@ def handle_connect():
     global connected_clients
     connected_clients += 1
     
-    # 클라이언트 IP 가져오기
     client_ip = request.remote_addr
-    
-    # 프록시(Nginx, Cloudflare 등)를 거치는 경우 실제 IP는 헤더에 들어있을 수 있음
     if request.headers.get('X-Forwarded-For'):
-        # X-Forwarded-For 는 "client, proxy1, proxy2" 형태로 여러 IP가 있을 수 있음
         client_ip = request.headers.get('X-Forwarded-For').split(',')[0].strip()
     elif request.headers.get('X-Real-IP'):
         client_ip = request.headers.get('X-Real-IP')
-    # Cloudflare의 경우
     elif request.headers.get('CF-Connecting-IP'):
         client_ip = request.headers.get('CF-Connecting-IP')
 
@@ -397,10 +370,6 @@ def handle_disconnect():
     global connected_clients
     connected_clients -= 1
     logger.info(f"클라이언트 연결: {connected_clients}명")
-    #if connected_clients <= 0:
-    #    cleanup_connections()
-    #    logger.info("서버 종료")
-    #    os._exit(0)
 
 def cleanup_connections():
     for region, rag in region_rag_objects.items():
@@ -410,85 +379,62 @@ def cleanup_connections():
         except:
             pass
 
-# --- Together AI 분석 (SDK -> requests 직접 호출로 변경) ---
+# --- Together AI 분석 ---
 def Gemma3_AI_analysis(query_txt, content_txt):
     content_txt = "\n".join(doc.page_content for doc in content_txt) if isinstance(content_txt, list) else str(content_txt)
     query_txt = str(query_txt)
     prompt = lexi_prompts.use_prompt(lexi_prompts.AI_system_prompt, query_txt=query_txt, content_txt=content_txt)
 
+    if not client:
+        return "AI Client가 초기화되지 않았습니다."
+
     try:
         response = client.chat.completions.create(
-            #model="meta-llama/Llama-4-Scout-17B-16E-Instruct", #비용 효율 측면 최고
-            model="moonshotai/Kimi-K2-Instruct-0905", #오픈소스 최고 성능
-            messages=[
-                {
-                    "role": "user",
-                    "content": prompt,
-                }
-            ],
+            model="moonshotai/Kimi-K2-Instruct-0905", 
+            messages=[{"role": "user", "content": prompt}],
         )
-    
-        # 응답에서 결과 텍스트를 추출
         AI_Result = response.choices[0].message.content
         return AI_Result
-    
     except Exception as e:
-        # Together SDK의 오류는 requests.exceptions.RequestException이 아닌 다른 종류의 예외로 발생합니다.
-        # 따라서 일반적인 Exception으로 처리하는 것이 안전합니다.
         logger.info(f"Together AI 분석 API 호출 실패: {e}")
-        traceback.print_exc() # traceback.logger.info_exc() 대신 일반 print_exc()를 사용하거나, logging 모듈 설정을 확인하세요.
+        traceback.print_exc()
         return f"AI 분석 중 오류가 발생했습니다: {e}"
 
-# --- Together AI 번역 (SDK -> requests 직접 호출로 변경) ---
+# --- Together AI 번역 ---
 def Gemma3_AI_Translate(query_txt):
     query_txt = str(query_txt)
     prompt = lexi_prompts.use_prompt(lexi_prompts.query_translator, query_txt=query_txt)
 
+    if not client:
+        return query_txt
+
     try:
         response = client.chat.completions.create(
-            #model="meta-llama/Llama-4-Scout-17B-16E-Instruct", #비용 효율 측면 최고
-            model="moonshotai/Kimi-K2-Instruct-0905", #오픈소스 최고 성능
-            messages=[
-                {
-                    "role": "user",
-                    "content": prompt,
-                }
-            ],
+            model="moonshotai/Kimi-K2-Instruct-0905", 
+            messages=[{"role": "user", "content": prompt}],
         )
-    
-        # 응답에서 결과 텍스트를 추출
         AI_Result = response.choices[0].message.content
         return AI_Result
-    
     except Exception as e:
-        # API 호출 실패 시 처리 (SDK 사용 시 일반 Exception으로 처리)
         logger.info(f"Together AI 번역 API 호출 실패: {e}")
-        
-        # traceback.logger.info_exc() 대신 traceback.print_exc() 사용 (권장)
-        # 만약 기존 로깅 시스템에서 해당 함수를 정의해 사용하고 있다면 그대로 두셔도 됩니다.
-        # 여기서는 표준 traceback 모듈을 사용합니다.
         traceback.print_exc() 
-        
-        # 번역 실패 시 query_txt 변수를 반환 (기존 코드 로직 반영)
         return query_txt
 
-# --- 검색 ---
-# 검색 함수 수정
-def search_DB_from_multiple_regions(query, selected_regions, region_rag_objects, custom_filters=None, failsafe_mode=True):
+# --- 검색 (수정됨) ---
+def search_DB_from_multiple_regions(query, selected_regions, region_rag_objects, custom_filters=None):
+    # [수정됨] failsafe_mode 인자 제거 (v02 함수 정의와 일치시킴)
+    global Filtered_search
+    global filters
+    
     if not selected_regions:
         selected_regions = list(region_rag_objects.keys())
 
     print(f"Translated Query : {query}")
 
-    # None일 때 안전하게 처리
-    if custom_filters is None:
-        custom_filters = {}  # 빈 딕셔너리로 대체 (필터 없음 = 전체 검색)
+    search_filters = custom_filters if custom_filters is not None else filters
+    has_filters = any(search_filters.get(key, []) for key in search_filters.keys())
     
-    # 필터가 설정되어 있는지 확인
-    has_filters = any(custom_filters.get(key, []) for key in custom_filters.keys())
-    
-    print(f"사용된 검색 필터: {custom_filters}")
-    print(f"필터 사용 여부: {has_filters}")
+    print(f"사용된 검색 필터: {search_filters}")
 
     combined_results = []
 
@@ -497,27 +443,29 @@ def search_DB_from_multiple_regions(query, selected_regions, region_rag_objects,
         if not rag:
             continue
 
-        ensemble_retriever = rag["ensemble_retriever"]
+        # [수정됨] 키 변경 (ensemble_retriever -> bm25_retriever)
+        bm25_retriever = rag["bm25_retriever"]
         vectorstore = rag["vectorstore"]
         sqlite_conn = rag["sqlite_conn"]
 
-        if ensemble_retriever:
+        if bm25_retriever:
             if has_filters:
+                # [수정됨] v02 시그니처 반영 (ensemble->bm25, failsafe 제거)
                 results = reg_embedding_system.search_with_metadata_filter(
-                    ensemble_retriever=ensemble_retriever,
+                    bm25_retriever=bm25_retriever,
                     vectorstore=vectorstore,    
                     query=query,
                     k=search_document_number,
-                    metadata_filter=custom_filters,
-                    sqlite_conn=sqlite_conn,
-                    failsafe_search=failsafe_mode
+                    metadata_filter=search_filters,
+                    sqlite_conn=sqlite_conn
                 )
             else:
+                # [수정됨] v02 시그니처 반영 (retriever->bm25, failsafe 제거)
                 results = reg_embedding_system.smart_search_vectorstore(
-                    retriever=ensemble_retriever,
+                    bm25_retriever=bm25_retriever,
+                    vectorstore=vectorstore,
                     query=query,
                     k=search_document_number,
-                    vectorstore=vectorstore,
                     sqlite_conn=sqlite_conn,
                     enable_detailed_search=True
                 )
@@ -531,55 +479,40 @@ def search_DB_from_multiple_regions(query, selected_regions, region_rag_objects,
 def RegAI(query, Rag_Results, ResultFile_FolderAddress):
     gc.collect()
     AI_Result = "검색 결과가 없습니다." if not Rag_Results else Gemma3_AI_analysis(query, Rag_Results)
-
-    #with open(ResultFile_FolderAddress, 'w', encoding='utf-8') as f:
-    #    print("검색된 문서:", file=f)
-    #    logger.info("검색된 문서:")
-    #    for i, doc in enumerate(Rag_Results):
-    #        print(f"문서 {i+1}: {doc.page_content[:200]}... (메타: {doc.metadata})", file=f)
-    #        logger.info(f"문서 {i+1}: {doc.page_content[:200]}... (메타: {doc.metadata})")
-            
-    #    print("\n답변:", file=f)
-    #    logger.info("\n답변:")
-        
-    #    print(AI_Result, file=f)
-    #    logger.info(AI_Result)
-
     return AI_Result
 
-# 법규 타입별 필터 생성 함수
+# [수정됨] 법규 타입별 필터 생성 함수 - DB 스키마 변경 반영
 def create_filter_by_type(regulation_type, regulation_title):
-    """법규 타입에 따라 적절한 필터 딕셔너리 생성"""
+    """
+    법규 타입에 따라 적절한 필터 딕셔너리 생성
+    v02 DB 컬럼: regulation, section, chapter, standard
+    """
     filter_dict = {
-        "regulation_part": [],
-        "regulation_section": [], 
-        "chapter_section": [],
-        "jo": []
+        "regulation": [],
+        "section": [], 
+        "chapter": [],
+        "standard": []
     }
     
-    # 타입별 매핑
-
-    # 전체 키를 지원하는 매핑 (입력으로 'regulation_section' 등을 받는 경우)
+    # [수정됨] 기존 Frontend 타입 -> v02 DB 컬럼 매핑
     type_mapping = {
-        "regulation_part": "regulation_part",
-        "regulation_section": "regulation_section",
-        "chapter_section": "chapter_section",
-        "jo": "jo",
-        # 혹시 짧은 형태로 들어오는 경우도 함께 지원
-        "part": "regulation_part",
-        "section": "regulation_section",
-        "chapter": "chapter_section",
+        "regulation_part": "regulation",
+        "regulation_section": "section",
+        "chapter_section": "chapter",
+        "jo": "standard",
+        # 축약형 지원
+        "part": "regulation",
+        "section": "section",
+        "chapter": "chapter",
     }
-
     
-    filter_key = type_mapping.get(regulation_type, "regulation_part")
+    filter_key = type_mapping.get(regulation_type, "regulation")
     filter_dict[filter_key].append(regulation_title)
     
     return filter_dict
 
 # 법규들을 타입별로 그룹화하는 함수
 def group_regulations_by_type(selected_regulations):
-    """선택된 법규들을 타입별로 그룹화"""
     grouped = {
         "part": [],
         "section": [], 
@@ -596,87 +529,52 @@ def group_regulations_by_type(selected_regulations):
     
     return grouped
 
-# 통합 필터 생성 함수
+# [수정됨] 통합 필터 생성 함수 - DB 키 변경 반영
 def create_combined_filters(grouped_regulations):
-    """그룹화된 법규들로부터 통합 필터 생성"""
+    """그룹화된 법규들로부터 통합 필터 생성 (v02 DB 키 사용)"""
     filters = {
-        "regulation_part": grouped_regulations["part"],
-        "regulation_section": grouped_regulations["section"], 
-        "chapter_section": grouped_regulations["chapter"],
-        "jo": grouped_regulations["jo"]
+        "regulation": grouped_regulations["part"],   # regulation_part -> regulation
+        "section": grouped_regulations["section"],   # regulation_section -> section
+        "chapter": grouped_regulations["chapter"],   # chapter_section -> chapter
+        "standard": grouped_regulations["jo"]        # jo -> standard
     }
-    
     return filters
 
-def natural_sort_key(text):
-    """숫자가 포함된 문자열을 자연스럽게 정렬 (예: item1, item2, item10)"""
-    return [int(c) if c.isdigit() else c.lower() for c in re.split('([0-9]+)', str(text))]
-
 def get_unique_metadata_values(
     sqlite_conn: sqlite3.Connection,
     key_name: str,
     partial_match: Optional[str] = None
 ) -> List[str]:
-    """
-    SQLite 'documents' 테이블에서 특정 컬럼(key_name)의 중복되지 않은
-    모든 고유 값 리스트를 반환합니다.
-
-    Args:
-        sqlite_conn: SQLite 데이터베이스 연결 객체.
-        key_name: 고유한 값을 가져올 컬럼 이름 (예: 'regulation_name', 'part_name').
-        partial_match: (선택 사항) 해당 문자열을 포함하는 값만 검색할 때 사용.
-
-    Returns:
-        중복이 제거된 고유한 값들의 리스트.
-    """
-
+    """SQLite 고유 값 반환"""
     text_result = ""
     if not sqlite_conn:
-        print("[경고] SQLite 연결이 없어 고유 값 검색을 수행할 수 없습니다.")
         return text_result
 
     cursor = sqlite_conn.cursor()
-
-    # SQL 쿼리 구성
-    # 1. 컬럼 이름에 백틱(`)을 사용하여 안전성 확보
-    # 2. DISTINCT를 사용하여 중복 제거
-
     sql_query = f"SELECT DISTINCT `{key_name}` FROM documents"
     params = []
 
-    # 부분 문자열 검색 (LIKE) 조건 추가
     if partial_match:
         sql_query += f" WHERE `{key_name}` LIKE ?"
         params.append(f"%{partial_match}%")
 
     try:
         cursor.execute(sql_query, params)
-
-        # 쿼리 결과에서 첫 번째 항목 (값)만 추출
         unique_values = [row[0] for row in cursor.fetchall() if row[0] is not None]
-        unique_values.sort(key=natural_sort_key)
+        unique_values.sort(key=reg_embedding_system.natural_sort_key)
         text_result = "\n".join(str(value) for value in unique_values)
-
-        return text_result
-
-    except sqlite3.OperationalError as e:
-        # 컬럼 이름이 DB에 없을 때 발생하는 에러 처리
-        print(f"[에러] SQLite 쿼리 실행 실패 (컬럼 '{key_name}' 이름 오류 가능): {e}")
         return text_result
     except Exception as e:
-        print(f"[에러] 고유 값 검색 중 알 수 없는 오류 발생: {e}")
+        print(f"[에러] 고유 값 검색 실패 ({key_name}): {e}")
         return text_result
 
-
 # --- 실행 ---
 if __name__ == '__main__':
-    # 로컬 개발용
     threading.Thread(target=load_rag_objects, daemon=True).start()
     time.sleep(2)
     socketio.emit('message', {'message': '데이터 로딩 시작...'})
     socketio.run(app, host='0.0.0.0', port=7860, debug=False)
 else:
-    # Gunicorn용: 워커 시작 후 로딩
     import atexit
     loading_thread = threading.Thread(target=load_rag_objects, daemon=True)
     loading_thread.start()