Upload 16 files

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/EUR_RAG/EUR_index.faiss filter=lfs diff=lfs merge=lfs -text
+data/EUR_RAG/EUR_metadata_mapping.db filter=lfs diff=lfs merge=lfs -text
+data/FMVSS_RAG/US_index.faiss filter=lfs diff=lfs merge=lfs -text
+data/FMVSS_RAG/US_metadata_mapping.db filter=lfs diff=lfs merge=lfs -text
+data/KMVSS_RAG/Kor_index.faiss filter=lfs diff=lfs merge=lfs -text
+data/KMVSS_RAG/Kor_metadata_mapping.db filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,242 @@
+# app.py
+from flask import Flask, render_template, jsonify, request
+from flask_socketio import SocketIO
+import threading
+import os
+import sqlite3
+import gc
+import time
+import re
+
+# --- 외부 모듈 임포트 ---
+import reg_embedding_system
+import leximind_prompts
+
+# --- Together AI SDK ---
+from together import Together
+
+# --- Flask & SocketIO 설정 ---
+app = Flask(__name__)
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='eventlet')
+
+# --- 전역 변수 ---
+connected_clients = 0
+search_document_number = 30
+Filtered_search = False
+filters = {"regulation_part": []}
+
+# --- 경로 설정 ---
+current_dir = os.path.dirname(os.path.abspath(__file__))
+ResultFile_FolderAddress = os.path.join(current_dir, 'result.txt')
+
+# --- RAG 데이터 경로 ---
+region_paths = {
+    "국내": "/app/data/KMVSS_RAG",
+    "북미": "/app/data/FMVSS_RAG",
+    "유럽": "/app/data/EUR_RAG"
+}
+
+# --- 프롬프트 ---
+lexi_prompts = leximind_prompts.PromptLibrary()
+
+# --- RAG 객체 ---
+region_rag_objects = {}
+
+# --- Together AI 클라이언트 (Hugging Face Secrets에서 API 키 가져오기) ---
+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)
+
+# --- RAG 로딩 ---
+def load_rag_objects():
+    global region_rag_objects
+    for region, path in region_paths.items():
+        if not os.path.exists(path):
+            msg = f"[{region}] 경로 없음: {path}"
+            socketio.emit('message', {'message': msg})
+            print(msg)
+            continue
+
+        try:
+            socketio.emit('message', {'message': f"[{region}] RAG 로딩 중..."})
+            ensemble_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)
+
+            region_rag_objects[region] = {
+                "ensemble_retriever": ensemble_retriever,
+                "vectorstore": vectorstore,
+                "sqlite_conn": new_conn
+            }
+            socketio.emit('message', {'message': f"[{region}] 로딩 완료"})
+            print(f"[{region}] RAG 로딩 완료")
+
+        except Exception as e:
+            error_msg = f"[{region}] 로딩 실패: {str(e)}"
+            print(error_msg)
+            socketio.emit('message', {'message': error_msg})
+
+    socketio.emit('message', {'message': "Ready to Search"})
+    print("Ready to Search")
+
+# --- 웹 ---
+@app.route('/')
+def index():
+    return render_template('chat.html')
+
+# --- 메시지 ---
+@app.route('/get_message', methods=['POST'])
+def get_message():
+    global Filtered_search, filters
+    data = request.get_json()
+    query = data.get('query', '').strip()
+    regions = data.get('regions', [])
+    selected_regulations = data.get('selectedRegulations', [])
+
+    filters = {"regulation_part": []}
+    Filtered_search = bool(selected_regulations)
+    if selected_regulations:
+        for reg in selected_regulations:
+            title = reg.get('title', '')
+            if title:
+                filters["regulation_part"].append(title)
+
+    Rag_Results = search_DB_from_multiple_regions(query, regions, region_rag_objects)
+    AImessage = RegAI(query, Rag_Results, ResultFile_FolderAddress)
+
+    return jsonify(message=AImessage)
+
+# --- 법규 리스트 ---
+@app.route('/get_reg_list', methods=['POST'])
+def get_reg_list():
+    data = request.get_json()
+    selected_regions = data.get('regions', []) or ["국내", "북미", "유럽"]
+
+    all_reg_list_part = []
+    for region in selected_regions:
+        rag = region_rag_objects.get(region)
+        if not rag: continue
+        try:
+            conn = rag["sqlite_conn"]
+            parts = reg_embedding_system.get_unique_metadata_values(conn, "regulation_part")
+            all_reg_list_part.extend(parts)
+        except Exception as e:
+            print(f"[{region}] 법규 로드 실패: {e}")
+
+    unique_parts = sorted(set(all_reg_list_part), key=reg_embedding_system.natural_sort_key)
+    return jsonify(reg_list_part="\n".join(unique_parts))
+
+# --- SocketIO ---
+@socketio.on('connect')
+def handle_connect():
+    global connected_clients
+    connected_clients += 1
+    print(f"클라이언트 연결: {connected_clients}명")
+
+@socketio.on('disconnect')
+def handle_disconnect():
+    global connected_clients
+    connected_clients -= 1
+    print(f"연결 해제: {connected_clients}명")
+    if connected_clients <= 0:
+        cleanup_connections()
+        print("서버 종료")
+        os._exit(0)
+
+def cleanup_connections():
+    for region, rag in region_rag_objects.items():
+        try:
+            rag["sqlite_conn"].close()
+            print(f"[{region}] DB 연결 종료")
+        except:
+            pass
+
+# --- 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)
+
+    response = client.chat.completions.create(
+        model="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=1024,
+        temperature=0.7
+    )
+    return response.choices[0].message.content
+
+# --- 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)
+
+    response = client.chat.completions.create(
+        model="meta-llama/Llama-3.2-3B-Instruct-Turbo",
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=512,
+        temperature=0.3
+    )
+    return response.choices[0].message.content
+
+# --- 검색 ---
+def search_DB_from_multiple_regions(query, selected_regions, region_rag_objects):
+    selected_regions = selected_regions or list(region_rag_objects.keys())
+    query = Gemma3_AI_Translate(query)
+    print(f"번역된 쿼리: {query}")
+
+    combined_results = []
+    for region in selected_regions:
+        rag = region_rag_objects.get(region)
+        if not rag: continue
+
+        retriever = rag["ensemble_retriever"]
+        vectorstore = rag["vectorstore"]
+        sqlite_conn = rag["sqlite_conn"]
+
+        if Filtered_search:
+            results = reg_embedding_system.search_with_metadata_filter(
+                ensemble_retriever=retriever,
+                vectorstore=vectorstore,
+                query=query,
+                k=search_document_number,
+                metadata_filter=filters,
+                sqlite_conn=sqlite_conn
+            )
+        else:
+            results = reg_embedding_system.smart_search_vectorstore(
+                retriever=retriever,
+                query=query,
+                k=search_document_number,
+                vectorstore=vectorstore,
+                sqlite_conn=sqlite_conn,
+                enable_detailed_search=True
+            )
+        print(f"[{region}] 검색: {len(results)}건")
+        combined_results.extend(results)
+
+    return combined_results
+
+# --- 최종 AI ---
+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)
+        for i, doc in enumerate(Rag_Results):
+            print(f"문서 {i+1}: {doc.page_content[:200]}... (메타: {doc.metadata})", file=f)
+        print("\n답변:", file=f)
+        print(AI_Result, file=f)
+
+    return AI_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)

data/EUR_RAG/EUR_index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99a3b3da85ca0106907d631ee7fa643f4bec194b33890f4500ddaf94a4f4b1c8
+size 55246893

data/EUR_RAG/EUR_index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7e12c0d80639e31b16e5b02dd407c10e0da6d1cb88e7bd7c0974edc5f9f0e35
+size 15563867

data/EUR_RAG/EUR_metadata_mapping.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d97546a48ac470642e836e85ba7816dc811e4101fb983462e12e661761cf9668
+size 14094336

data/FMVSS_RAG/US_index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:549e23730d18b1278735d97688dd119a1710231f191ac907f05661e451c4e0d3
+size 13553709

data/FMVSS_RAG/US_index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e28e5ac5eeaa73e0fe554c78cde263e42631f70b387c9df0cdb46d737f746607
+size 7182308

data/FMVSS_RAG/US_metadata_mapping.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c3c9db3fbc0af365f9dc2c55c68bd516d6ae30cfab0fd18b5b36d934b441ba1
+size 5029888

data/KMVSS_RAG/Kor_index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84d109f1b1b078ff106eb1b3a7c429583a34528c57422d6049b136854ada824f
+size 3041325

data/KMVSS_RAG/Kor_index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c3fedff0fa38752bcdf5d62bd244151a6cdb2691db781970f5cdad1ae7a5b1f
+size 1490577

data/KMVSS_RAG/Kor_metadata_mapping.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eaeebd3d9f8a96cc37fb0984084283ca326d445ff561d499c9eafef922294dc9
+size 704512

dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.11-slim
+WORKDIR /app
+RUN apt-get update && apt-get install -y gcc g++ && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 7860
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--worker-class", "eventlet", "--workers", "1", "app:socketio"]

leximind_prompts.py

@@ -0,0 +1,37 @@
+class PromptLibrary:
+    def __init__(self):
+        #RAG용 Document를 찾기 위해 질문 자체를 한번 변경하기 위한 프롬프트
+        #영문 법규를 번역하기 위해서는 질문도 영문인것이 성능상 좋기 때문에 일단 번역을 붙이는 정도로 초안 작성됨
+        #이 프롬프트를 고도화하기 위해서는 통상 쓰는 용어를 법규적인 용어로 바꿔주는 부분도 필요 
+        #예를 들어 다음과 같이 바뀔수 있도록 프롬프트 작성 필요 예) 충돌 관련 규정 찾아줘 --> 충돌(crash,impact,rollover) 관련 규정 찾아줘
+        self.query_translator = """
+        다음 질문을 RAG 검색을 위해 가장 적합한 Query로 변경할텐데 다음에 유의해서 질문을 잘 반영하는 키워드만 뽑고 다른말은 하지마.
+        유의사항
+        1. 키워드는 한국어, 영어 둘다로 만들어줘
+        2. 충돌이라는 말이 나오면 키워드에는 한글로는 충돌, 충격이 포함되고 영어는 collision, crash, impact, rollover라는 말이 다 포함되어야 해
+        3. 연소성이라는 말이 나오면 '차실내장재의 내인화성' 이라는 한글 표현과 'Flammability of interior materials'라는 키워드도 넣어줘
+        4. 파워윈도우 또는 파워윈도우 반전기능이라는 말이 나오면 한글로는 안전기준34조, 창유리, 영어로는 571.118, UN regulation 21도 넣어줘
+        5. ESC와 관련한 질문이 있었을 때는, 한글로는 자동차안정성제어장치, 영어로는 UN Regulation 140, 571.126 Electronic stability control systems 키워드도 넣어줘
+        6. 내부돌기와 관련한 질문이 있었을 때는 UN regulation 21, Interior Fittings도 넣어줘
+        
+        질문 : {query_txt}
+        """
+
+        #RAG용 Document(content_txt 변수가 해당)가 생성된 이후 사용자의 질문과 document 내용을 가지고 답을 생성하도록 하는 명령어
+        #질문의 유형에 따라서 답변에 꼭 포함되어야 할 것으로 생각되는 내용들이 Prompt에 잘 반영되어 있어야 함 
+        self.AI_system_prompt = """
+        다음 질문에 대한 검색 결과가 아래와 같을때 질문에 대하여 아래 유의사항을 고려하여 검색 결과 내용을 정리해서 알려줘. 
+        유의사항
+        1. 형식은 HTML 형식으로 결과를 만들것
+        2. 답은 질문자가 별도로 요구하지 않는 한 한국말로 할 것
+        2. 검색 결과에 있는 내용에 근거해서만 대답할 것. 검색 결과에 근거가 없는 경우는 검색 결과에 관련 근거가 없다고 알려줄것
+        3. 답변에 근거가 되는 조항은 아래에 근거로 표시할 것
+        4. 경고등 점등과 관련한 문서에서 Control에 대한 점등과 telltale에 대한 점등이 구분되어 있다면 구분해서 말할것. 별도의 구분이 없을 경우 따로 언급은 하지마
+        5. 비교하라는 요청이 있거나 그 밖에 표로 정리할 수 있는 경우는 표 형식으로 정리할 것
+
+        질문 : {query_txt}
+        검색 결과 : {content_txt}
+        """
+
+    def use_prompt(self, prompt_text, **kwargs):
+        return prompt_text.format(**kwargs)

reg_embedding_system.py

@@ -0,0 +1,527 @@
+import gc
+import json
+import sqlite3 #  SQLite 모듈 추가
+from pathlib import Path
+from typing import Optional, Tuple, Any, Dict, List, Set
+from collections import Counter  # 빈도 계산을 위한 추가
+import numpy as np
+
+import faiss
+from langchain.retrievers import BM25Retriever, EnsembleRetriever
+from langchain_core.documents import Document
+from langchain_community.vectorstores import FAISS
+from sentence_transformers import SentenceTransformer
+
+# 런타임에 Embeddings 클래스를 찾기 위한 로직 (원본 코드 유지)
+try:
+    from langchain_core.embeddings import Embeddings
+except ImportError:
+    try:
+        from langchain.embeddings.base import Embeddings
+    except ImportError:
+        Embeddings = object
+
+# --- SQLite 헬퍼 함수 ---
+SQLITE_DB_NAME = "metadata_mapping.db"
+
+# === IDSelector 클래스 정의 (파일 상단 또는 함수 외부에 위치) ===
+# IDSelector 대신 IDSelectorBatch 사용
+class MetadataIDSelector(faiss.IDSelectorBatch):
+    def __init__(self, allowed_ids: Set[int]):
+        # IDSelectorBatch는 allowed_ids 리스트를 직접 받음
+        super().__init__(list(allowed_ids))  # 리스트로 변환해서 전달
+
+def get_db_connection(persist_directory: str) -> sqlite3.Connection:
+    """FAISS 저장 경로를 기반으로 SQLite 연결을 설정하고 반환합니다."""
+    db_path = Path(persist_directory) / SQLITE_DB_NAME
+    conn = sqlite3.connect(db_path)
+    return conn
+
+def _create_and_populate_sqlite_db(chunks: List[Document], persist_directory: str):
+    """문서 청크를 기반으로 SQLite DB를 생성하고 채웁니다. (save_embedding_system 내부용)"""
+    conn = get_db_connection(persist_directory)
+    cursor = conn.cursor()
+    
+    # 1. 테이블 생성
+    cursor.execute("""
+    CREATE TABLE IF NOT EXISTS documents (
+        faiss_id INTEGER PRIMARY KEY,
+        regulation_part TEXT,
+        regulation_section TEXT,
+        chapter_section TEXT,          
+        jo TEXT,
+        json_metadata TEXT 
+    )
+    """)
+    conn.commit()
+
+    # 2. 데이터 채우기: FAISS ID는 청크 인덱스 i와 동일하게 매핑
+    for i, doc in enumerate(chunks):
+        faiss_id = i 
+        metadata_json = json.dumps(doc.metadata, ensure_ascii=False)
+        reg_part = doc.metadata.get('regulation_part')
+        reg_section = doc.metadata.get('regulation_section')
+        reg_chapter = doc.metadata.get('chapter_section')
+        reg_jo = doc.metadata.get('jo')
+
+        # 변수가 리스트인 경우, 쉼표로 구분된 문자열로 변환
+        if isinstance(reg_section, list):
+            reg_section = ', '.join(map(str, reg_section))
+        if isinstance(reg_part, list):
+            reg_part = ', '.join(map(str, reg_part))
+        if isinstance(reg_chapter, list):
+            reg_chapter = ', '.join(map(str, reg_chapter))
+        if isinstance(reg_jo, list):
+            reg_jo = ', '.join(map(str, reg_jo))
+        
+        # 문서 메타데이터에 FAISS ID 추가 (검색 후 필터링 함수에서 활용) 
+        doc.metadata['faiss_id'] = faiss_id 
+        
+        cursor.execute(
+            "INSERT OR REPLACE INTO documents (faiss_id, regulation_part, regulation_section, chapter_section, jo, json_metadata) VALUES (?, ?, ?, ?, ?, ?)",
+            (faiss_id, reg_part, reg_section, reg_chapter, reg_jo, metadata_json)
+        )
+
+    conn.commit()
+    conn.close()
+
+# --- LocalSentenceTransformerEmbeddings (변경 없음) ---
+
+class LocalSentenceTransformerEmbeddings(Embeddings):
+    """SentenceTransformer를 LangChain Embeddings 인터페이스로 래핑"""
+    
+    def __init__(self, st_model, normalize_embeddings: bool = True, encode_batch_size: int = 32):
+        self.model = st_model
+        self.normalize = normalize_embeddings
+        self.encode_batch_size = encode_batch_size
+
+    def embed_documents(self, texts):
+        vecs = self.model.encode(
+            texts,
+            batch_size=self.encode_batch_size,
+            show_progress_bar=False,
+            normalize_embeddings=self.normalize,
+            convert_to_numpy=True,
+        )
+        return vecs.tolist()
+
+    def embed_query(self, text: str):
+        vec = self.model.encode(
+            [text],
+            batch_size=self.encode_batch_size,
+            show_progress_bar=False,
+            normalize_embeddings=self.normalize,
+            convert_to_numpy=True,
+        )[0]
+        return vec.tolist()
+
+# --- save_embedding_system (SQLite 저장 로직 추가) ---
+
+def save_embedding_system(
+    chunks, 
+    persist_directory: str = r"D:/Project AI/RAG", 
+    batch_size: int = 32,
+    device: str = 'cuda'
+):
+    """
+    청크를 임베딩하여 FAISS 벡터스토어와 앙상블 리트리버를 생성하고,
+    SQLite DB에 메타데이터를 저장합니다. 
+    """
+    Path(persist_directory).mkdir(parents=True, exist_ok=True)
+    
+    # 1) SQLite DB에 메타데이터 저장 및 청크에 faiss_id 추가 
+    # 이 함수 내에서 chunks 리스트의 metadata에 'faiss_id'가 추가됩니다.
+    _create_and_populate_sqlite_db(chunks, persist_directory)
+
+    # 2) SentenceTransformer 로드 (원래 코드와 동일)
+    model = SentenceTransformer(
+        'nomic-ai/nomic-embed-text-v2-moe', 
+        trust_remote_code=True,
+        device=device
+    )
+
+    embeddings = LocalSentenceTransformerEmbeddings(
+        st_model=model,
+        normalize_embeddings=True,
+        encode_batch_size=batch_size
+    )
+
+    # 3) FAISS 벡터스토어 생성 (원래 코드와 동일)
+    vectorstore = None
+    for i in range(0, len(chunks), batch_size):
+        batch = chunks[i:i + batch_size]
+        if vectorstore is None:
+            vectorstore = FAISS.from_documents(documents=batch, embedding=embeddings)
+        else:
+            vectorstore.add_documents(documents=batch)
+        gc.collect()
+
+    # 4) BM25 + 벡터 앙상블 리트리버 생성 (원래 코드와 동일)
+    bm25_retriever = BM25Retriever.from_documents(chunks)
+    bm25_retriever.k = 5
+    
+    vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
+    
+    ensemble_retriever = EnsembleRetriever(
+        retrievers=[vector_retriever, bm25_retriever],
+        weights=[0.6, 0.4]
+    )
+
+    # 5) FAISS 인덱스 저장 (원래 코드와 동일)
+    vectorstore.save_local(persist_directory)
+    
+    # 6) SQLite 연결 
+    sqlite_conn = get_db_connection(persist_directory)
+    gc.collect()
+
+    return ensemble_retriever, vectorstore, sqlite_conn
+
+# --- load_embedding_from_faiss (SQLite 연결 반환 추가) ---
+
+def load_embedding_from_faiss(
+    persist_directory: str = r"D:/Project AI/RAG",
+    top_k: int = 10,
+    bm25_k: int = 10,
+    weights: Tuple[float, float] = (0.6, 0.4),
+    embeddings: Optional[Any] = None,
+    device: str = 'cpu'
+) -> Tuple[Any, FAISS, sqlite3.Connection]: #  반환 값에 SQLite 연결 추가
+    """
+    저장된 FAISS 인덱스와 SQLite 연결을 로드하여 앙상블 리트리버를 생성합니다.
+    """
+    # 1) Embeddings 준비 (원래 코드와 동일)
+    if embeddings is None:
+        st_model = SentenceTransformer(
+            'nomic-ai/nomic-embed-text-v2-moe',
+            trust_remote_code=True,
+            device=device
+        )
+        embeddings = LocalSentenceTransformerEmbeddings(
+            st_model=st_model,
+            normalize_embeddings=True,
+            encode_batch_size=32
+        )
+
+    # 2) FAISS 벡터스토어 로드 (원래 코드와 동일)
+    persist_dir = Path(persist_directory)
+    if not persist_dir.exists():
+        raise FileNotFoundError(f"FAISS 경로가 없습니다: {persist_dir}")
+
+    vectorstore = FAISS.load_local(
+        folder_path=str(persist_dir),
+        embeddings=embeddings,
+        allow_dangerous_deserialization=True
+    )
+
+    # 3) BM25를 위한 문서 추출 (원래 코드와 동일)
+    docs = []
+    try:
+        # FAISS docstore에서 문서 추출
+        if hasattr(vectorstore, "docstore") and hasattr(vectorstore.docstore, "_dict"):
+            docs = list(vectorstore.docstore._dict.values())
+    except Exception as e:
+        print(f"[경고] 저장된 문서를 읽는 중 문제가 발생했습니다: {e}")
+
+    # 4) 앙상블 리트리버 구성 (원래 코드와 동일)
+    vector_retriever = vectorstore.as_retriever(search_kwargs={"k": top_k})
+    
+    if docs:
+        bm25_retriever = BM25Retriever.from_documents(docs)
+        bm25_retriever.k = bm25_k
+        ensemble_retriever = EnsembleRetriever(
+            retrievers=[vector_retriever, bm25_retriever],
+            weights=list(weights)
+        )
+    else:
+        print("[안내] 문서를 찾지 못해 BM25 없이 벡터 리트리버만 반환합니다.")
+        ensemble_retriever = vector_retriever
+
+    # 5) SQLite 연결 
+    sqlite_conn = get_db_connection(persist_directory)
+
+    return ensemble_retriever, vectorstore, sqlite_conn #  SQLite 연결 반환
+
+# --- search_vectorstore (변경 없음) ---
+
+def search_vectorstore(retriever, query, k=5):
+    """리트리버를 사용해 쿼리와 관련된 문서를 검색합니다."""
+    results = retriever.invoke(query)
+    return results[:k]
+
+# === search_with_metadata_filter (사전 필터링 버전) ===
+def search_with_metadata_filter(
+    ensemble_retriever: EnsembleRetriever,
+    vectorstore: FAISS,
+    query: str,
+    k: int = 5,
+    metadata_filter: Optional[Dict[str, Any]] = None,
+    sqlite_conn: Optional[sqlite3.Connection] = None,
+    exact_match: bool = True
+) -> List[Document]:
+    """
+    SQLite로 사전 필터링 → FAISS ID 추출 → IDSelector로 FAISS 검색 제한
+    → BM25는 post-filtering (BM25는 IDSelector 미지원)
+    """
+    vector_ret, bm25_ret = ensemble_retriever.retrievers
+
+    # === 1. SQLite에서 필터링된 FAISS ID 추출 ===
+    filtered_ids = None
+    if metadata_filter and sqlite_conn:
+        cursor = sqlite_conn.cursor()
+        where_clauses = []
+        params = []
+
+        for key, value in metadata_filter.items():
+            print(f"[key] {key}")
+            print(f"[value] {value}")
+            if isinstance(value, list): 
+                # IN 쿼리: 리스트 값 지원 
+                if not value: 
+                    continue # 빈 리스트면 무시 
+                placeholders = ', '.join(['?'] * len(value)) 
+                where_clauses.append(f"{key} IN ({placeholders})") 
+                params.extend(value) 
+            else: 
+                # 단일 값 
+                where_clauses.append(f"{key} = ?") 
+                params.append(value)
+
+
+        if where_clauses:
+            where_sql = " OR ".join(where_clauses)
+            sql_query = f"SELECT faiss_id FROM documents WHERE {where_sql}"
+
+            try:
+                cursor.execute(sql_query, params)
+                filtered_ids = {row[0] for row in cursor.fetchall()}
+                print(f"[사전 필터링] {len(filtered_ids)}개 ID 획득 → FAISS 검색 제한")
+            except Exception as e:
+                print(f"[경고] SQLite 필터링 실패: {e}")
+                filtered_ids = None
+        else:
+            print("[안내] 필터 조건 없음 → 전체 검색")
+    else:
+        print("[안내] 필터 또는 DB 없음 → 전체 검색")
+
+    # === 2. FAISS 벡터 검색 (IDSelector 기반 사전 필터링) ===
+    if filtered_ids and len(filtered_ids) > 0:
+        # IDSelector 생성
+        selector = MetadataIDSelector(filtered_ids)
+
+        # FAISS 인덱스 추출
+        index: faiss.Index = vectorstore.index
+        if not hasattr(index, "search"):
+            raise ValueError("FAISS 인덱스가 검색을 지원하지 않습니다.")
+
+        # 쿼리 임베딩
+        query_embedding = np.array(vectorstore.embeddings.embed_query(query)).astype('float32')
+        query_embedding = query_embedding.reshape(1, -1)
+
+        # 검색 파라미터 설정
+        search_params = faiss.SearchParametersIVF(
+            sel=selector,
+            nprobe=50  # 필요시 조정 (성능 vs 재현율)
+        )
+
+        # 여유 있게 k * 10개 후보 요청 (필터 후 부족 방지)
+        _k = max(k * 10, 100)
+        D, I = index.search(query_embedding, _k, params=search_params)
+
+        # 유효한 결과만 추출
+        valid_indices = [i for i in I[0] if i != -1]
+        vector_docs = []
+        for idx in valid_indices[:k]:
+            doc_id = vectorstore.index_to_docstore_id[idx]
+            doc = vectorstore.docstore.search(doc_id)
+            if isinstance(doc, Document):
+                vector_docs.append(doc)
+
+        print(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)}개 후보")
+
+    # === 3. BM25 검색 (post-filtering, BM25는 IDSelector 미지원) ===
+    bm25_docs = []
+    if hasattr(bm25_ret, "invoke"):
+        search_k = k * 5
+        candidates = bm25_ret.invoke(query, config={"search_kwargs": {"k": search_k}})
+        if filtered_ids:
+            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)}개 필터링 후")
+
+    # === 4. 병합 및 최종 k개 반환 ===
+    combined = {id(d): d for d in (vector_docs + bm25_docs)}.values()
+    final_results = list(combined)[:k]
+
+    print(f"[최종 결과] {len(final_results)}개 문서 반환")
+    return final_results
+
+
+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:
+        중복이 제거된 고유한 값들의 리스트.
+    """
+    if not sqlite_conn:
+        print("[경고] SQLite 연결이 없어 고유 값 검색을 수행할 수 없습니다.")
+        return []
+
+    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]
+        
+        return unique_values
+
+    except sqlite3.OperationalError as e:
+        # 컬럼 이름이 DB에 없을 때 발생하는 에러 처리
+        print(f"[에러] SQLite 쿼리 실행 실패 (컬럼 '{key_name}' 이름 오류 가능): {e}")
+        return []
+    except Exception as e:
+        print(f"[에러] 고유 값 검색 중 알 수 없는 오류 발생: {e}")
+        return []
+
+def smart_search_vectorstore(
+    retriever, 
+    query, 
+    k=5, 
+    vectorstore=None, 
+    sqlite_conn=None, 
+    enable_detailed_search=True
+):
+    """
+    리트리버를 사용해 쿼리와 관련된 문서를 검색하고,
+    선택적으로 가장 빈번한 regulation_part 카테고리에 대해 상세 검색을 수행합니다.
+    
+    Args:
+        retriever: 기본 검색에 사용할 리트리버
+        query: 검색 쿼리
+        k: 반환할 문서 수
+        vectorstore: FAISS 벡터스토어 (상세 검색용)
+        sqlite_conn: SQLite 연결 (상세 검색용)
+        enable_detailed_search: 상세 검색 활성화 여부
+    
+    Returns:
+        검색된 문서 리스트 (기본 검색 + 상세 검색 결과)
+    """
+    # 1. 기본 검색 수행
+    basic_results = retriever.invoke(query)
+    basic_results = basic_results[:k]
+    
+    print(f"[기본 검색] {len(basic_results)}개 문서 검색 완료")
+    
+    # 상세 검색이 비활성화되었거나 필요한 컴포넌트가 없으면 기본 결과만 반환
+    if not enable_detailed_search or not vectorstore or not sqlite_conn:
+        print("[안내] 상세 검색 비활성화 또는 컴포넌트 부족 → 기본 검색 결과만 반환")
+        return basic_results
+    
+    # 2. regulation_part 메타데이터 빈도 분석
+    regulation_parts = []
+    for doc in basic_results:
+        reg_part = doc.metadata.get('regulation_part')
+        if reg_part:
+            # regulation_part가 리스트인 경우 모든 항목 추가
+            if isinstance(reg_part, list):
+                regulation_parts.extend(reg_part)
+            elif isinstance(reg_part, str):
+                # 쉼표로 구분된 문자열인 경우 분리
+                if ',' in reg_part:
+                    regulation_parts.extend([part.strip() for part in reg_part.split(',')])
+                else:
+                    regulation_parts.append(reg_part)
+    
+    # 빈도 계산 및 상위 카테고리 추출
+    if not regulation_parts:
+        print("[안내] regulation_part 메타데이터 없음 → 기본 검색 결과만 반환")
+        return basic_results
+    
+    counter = Counter(regulation_parts)
+    most_extracted_category = counter.most_common(2)  # 상위 2개 카테고리
+    
+    print(f"[빈도 분석] regulation_part 빈도: {dict(counter)}")
+    print(f"[상위 카테고리] {most_extracted_category}")
+    
+    # 3. 상위 카테고리에 대한 상세 검색 수행
+    detailed_results = []
+    
+    for rank, (category, count) in enumerate(most_extracted_category, 1):
+        print(f"[상세 검색 {rank}순위] '{category}' 카테고리 검색 시작 (빈도: {count})")
+        
+        # metadata_filter 구성
+        metadata_filter = {'regulation_part': category}
+        
+        try:
+            # search_with_metadata_filter 호출 
+            category_results = search_with_metadata_filter(
+                ensemble_retriever=retriever,
+                vectorstore=vectorstore,
+                query=query,
+                k=k,
+                metadata_filter=metadata_filter,
+                sqlite_conn=sqlite_conn
+            )
+            
+            detailed_results.extend(category_results)
+            print(f"[상세 검색 {rank}순위] {len(category_results)}개 추가 문서 검색 완료")
+            
+        except Exception as e:
+            print(f"[경고] 상세 검색 {rank}순위 실패 ({category}): {e}")
+            continue
+    
+    # 4. 결과 병합 (중복 제거)
+    # Document 객체의 고유성을 위해 page_content와 metadata의 조합으로 중복 판단
+    seen = set()
+    final_results = []
+    
+    # 기본 검색 결과 우선 추가
+    for doc in basic_results:
+        doc_signature = (doc.page_content, str(sorted(doc.metadata.items())))
+        if doc_signature not in seen:
+            seen.add(doc_signature)
+            final_results.append(doc)
+    
+    # 상세 검색 결과 추가 (중복 제거)
+    for doc in detailed_results:
+        doc_signature = (doc.page_content, str(sorted(doc.metadata.items())))
+        if doc_signature not in seen:
+            seen.add(doc_signature)
+            final_results.append(doc)
+    
+    # 최종 k개로 제한
+    final_results = final_results[:k]
+    
+    print(f"[최종 결과] 기본 {len(basic_results)}개 + 상세 {len(detailed_results)}개 → 중복 제거 후 {len(final_results)}개 반환")
+    
+    return final_results

requirements.txt

@@ -0,0 +1,20 @@
+Flask==3.0.3
+Flask-SocketIO==5.3.6
+eventlet==0.36.1
+gunicorn==22.0.0
+
+# Together AI
+together==1.2.1
+
+# LangChain & RAG
+langchain==0.1.20
+langchain-community==0.0.38
+faiss-cpu==1.8.0
+rank-bm25==0.2.2
+
+# Embedding
+sentence-transformers==3.0.1
+transformers==4.40.0
+torch==2.3.0
+
+numpy==1.26.4

templates/chat.html

@@ -0,0 +1,1243 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>LexiMind - 자동차 인증 법규를 더 쉽게</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script src="https://cdn.socket.io/4.7.2/socket.io.min.js"></script>
+    <style>
+        :root {
+            --primary-color: #0066FF;
+            --primary-hover: #4da8ff;
+            --bg-primary: #1a1a1a;
+            --bg-secondary: #2c2c2c;
+            --bg-tertiary: #333;
+            --bg-quaternary: #444;
+            --text-primary: #e0e0e0;
+            --text-secondary: #b0b0b0;
+            --text-muted: #888;
+            --border-color: #444;
+            --shadow: 0 2px 8px rgba(0,0,0,0.2);
+            --radius: 8px;
+            --success-color: #4caf50;
+            --warning-color: #ff9800;
+        }
+
+        * { box-sizing: border-box; }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Noto Sans KR', sans-serif;
+            margin: 0; padding: 0;
+            background-color: var(--bg-primary);
+            color: var(--text-primary);
+            line-height: 1.6;
+        }
+
+        /* ===== 헤더 ===== */
+        .header {
+            background: var(--bg-secondary);
+            padding: 16px 24px;
+            box-shadow: var(--shadow);
+            display: flex; justify-content: space-between; align-items: center;
+            position: sticky; top: 0; z-index: 100;
+        }
+
+        .logo { 
+            font-size: 28px; font-weight: 700; color: var(--primary-color); letter-spacing: -0.5px; 
+        }
+        
+        .nav { 
+            display: flex; list-style: none; gap: 32px; margin: 0; padding: 0; 
+        }
+        
+        .nav a {
+            text-decoration: none; color: var(--text-secondary); font-weight: 500;
+            padding: 8px 12px; border-radius: var(--radius); transition: all 0.2s ease;
+        }
+
+        .nav a:hover { 
+            color: var(--primary-hover); background: rgba(77, 168, 255, 0.1); 
+        }
+
+        /* ===== 사이드바 컨트롤 ===== */
+        .sidebar-toggle {
+            position: fixed;
+            top: 100px;
+            left: 30px;
+            width: 40px;
+            height: 40px;
+            background: rgba(0, 102, 255, 0.7);
+            border: 1px solid rgba(255, 255, 255, 0.2);
+            border-radius: 50%;
+            cursor: pointer;
+            z-index: 1001;
+            transition: all 0.3s ease;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            backdrop-filter: blur(10px);
+            box-shadow: 0 8px 32px rgba(0, 102, 255, 0.3);
+        }
+
+        .sidebar-toggle:hover {
+            background: rgba(77, 168, 255, 0.8);
+            transform: scale(1.05);
+        }
+
+        .hamburger {
+            width: 15px;
+            height: 2px;
+            background: white;
+            position: relative;
+            transition: all 0.3s ease;
+            transform: translateX(-7px);
+        }
+
+        .hamburger::before,
+        .hamburger::after {
+            content: '';
+            position: absolute;
+            width: 15px;
+            height: 2px;
+            background: white;
+            transition: all 0.3s ease;
+        }
+
+        .hamburger::before { top: -6px; }
+        .hamburger::after { top: 6px; }
+
+        .sidebar-toggle.active .hamburger { background: transparent; }
+        .sidebar-toggle.active .hamburger::before { transform: rotate(45deg); top: 0; }
+        .sidebar-toggle.active .hamburger::after { transform: rotate(-45deg); top: 0; }
+
+        .new-page-btn {
+            position: fixed;
+            top: 100px;
+            left: 85px;
+            min-width: 120px;
+            height: 40px;
+            padding: 8px 16px;
+            background: rgba(255, 255, 255, 1);
+            border: 2px solid rgba(0, 102, 255, 0.2);
+            border-radius: 12px;
+            cursor: pointer;
+            z-index: 1001;
+            transition: all 0.3s ease;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 8px;
+            opacity: 0;
+            visibility: hidden;
+            transform: translateX(-20px);
+        }
+
+        .new-page-btn.show {
+            opacity: 1;
+            visibility: visible;
+            transform: translateX(0);
+        }
+
+        .new-page-btn:hover {
+            background: rgba(255, 255, 255, 0.8);
+            transform: translateY(-2px);
+        }
+
+        .plus-icon {
+            color: #0066FF;
+            font-size: 16px;
+            font-weight: 700;
+        }
+
+        /* ===== 사이드바 ===== */
+        .sidebar { 
+            position: fixed; top: 76px; left: -300px; width: 300px; 
+            height: calc(100vh - 76px); background: #2c2c2c; 
+            transition: left 0.3s ease; z-index: 1000; overflow-y: auto; 
+        }
+        .sidebar.open { left: 0; }
+        
+        .sidebar-content {
+            padding: 75px 30px 30px 30px;
+        }
+
+        .sidebar-overlay { 
+            position: fixed; top: 76px; left: 0; width: 100%; 
+            height: calc(100vh - 76px); background: rgba(0, 0, 0, 0.5); 
+            opacity: 0; visibility: hidden; transition: all 0.3s ease; z-index: 999; 
+        }
+        .sidebar-overlay.active { opacity: 1; visibility: visible; }
+
+        .date-ranges {
+            display: flex;
+            flex-direction: column;
+            gap: 12px;
+        }
+
+        .date-range-item {
+            display: block;
+            padding: 16px;
+            background: var(--bg-tertiary);
+            border: 2px solid transparent;
+            border-radius: var(--radius);
+            text-decoration: none;
+            color: var(--text-primary);
+            transition: all 0.3s ease;
+        }
+
+        .date-range-item:hover {
+            background: var(--bg-quaternary);
+            border-color: var(--primary-color);
+            transform: translateY(-2px);
+        }
+
+        .date-period {
+            display: block;
+            font-weight: 600;
+            font-size: 14px;
+            color: var(--primary-color);
+            margin-bottom: 4px;
+        }
+
+        .date-count {
+            display: block;
+            font-size: 12px;
+            color: var(--text-muted);
+        }
+
+        /* ===== 메인 레이아웃 ===== */
+        .main {
+            display: flex;
+            height: calc(100vh - 76px);
+            max-width: 100%;
+            margin: 0;
+            padding: 0;
+        }
+
+        /* ===== 필터 패널 ===== */
+        .filter-panel { 
+            width: 350px; 
+            background: var(--bg-secondary); 
+            border-right: 1px solid var(--border-color); 
+            display: flex; 
+            flex-direction: column; 
+            overflow: hidden;
+        }
+        
+        .filter-header { 
+            padding: 100px 20px 20px 20px; 
+            border-bottom: 1px solid var(--border-color); 
+            background: var(--bg-tertiary); 
+        }
+        .filter-title { 
+            font-size: 20px; 
+            font-weight: 700; 
+            color: var(--text-primary); 
+            margin: 0 0 16px 0; 
+        }
+        
+        /* 지역 선택 토글 */
+        .toggle-group { margin-bottom: 24px; }
+        .toggle-label { 
+            display: block; 
+            font-size: 14px; 
+            font-weight: 600; 
+            color: var(--text-secondary); 
+            margin-bottom: 12px; 
+        }
+        .toggle-options {
+            display: flex;
+            gap: 8px;
+            flex-wrap: wrap;
+        }
+        .toggle-btn { 
+            padding: 8px 16px; 
+            background: var(--bg-quaternary); 
+            border: 2px solid transparent; 
+            border-radius: 20px; 
+            color: var(--text-secondary); 
+            cursor: pointer; 
+            transition: all 0.2s ease; 
+            font-size: 13px; 
+            font-weight: 500; 
+        }
+        .toggle-btn:hover { 
+            background: #3a3a3a; 
+            color: var(--text-primary); 
+        }
+        .toggle-btn.active { 
+            background: var(--primary-color); 
+            border-color: var(--primary-hover); 
+            color: white; 
+        }
+
+        /* 법규 목록 스타일 */
+        .regulation-list-container { 
+            border-bottom: 1px solid var(--border-color);
+            padding: 24px;
+            max-height: 250px;
+            overflow-y: auto;
+        }
+
+        .regulation-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 12px;
+        }
+
+        .selected-count {
+            font-size: 12px;
+            color: var(--primary-color);
+            background: rgba(77, 168, 255, 0.1);
+            padding: 4px 8px;
+            border-radius: 4px;
+        }
+
+        .regulation-item {
+            padding: 12px; 
+            margin: 8px 0; 
+            background: var(--bg-quaternary); 
+            border-radius: var(--radius);
+            cursor: pointer; 
+            transition: all 0.2s ease; 
+            border: 2px solid transparent; 
+            user-select: none;
+        }
+        .regulation-item:hover { 
+            background: #3a3a3a; 
+            border-color: var(--primary-color); 
+        }
+        .regulation-item.selected { 
+            background: var(--primary-color); 
+            color: white; 
+            border-color: var(--primary-hover); 
+        }
+
+        /* ===== 상세 법규 리스트 ===== */
+        .regulation-details-container {
+            flex: 1; 
+            display: flex; 
+            flex-direction: column; 
+            overflow: hidden;
+        }
+        .regulation-details-header { 
+            display: flex; 
+            justify-content: space-between; 
+            align-items: center; 
+            padding: 16px 24px; 
+            border-bottom: 1px solid var(--border-color); 
+        }
+
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: var(--radius);
+            background: var(--primary-color);
+            color: white;
+            cursor: pointer;
+            font-size: 13px;
+            font-weight: 600;
+            transition: all 0.2s ease;
+        }
+
+        .btn:hover {
+            background: var(--primary-hover);
+            transform: translateY(-1px);
+        }
+
+        .btn-small {
+            padding: 6px 12px;
+            font-size: 12px;
+        }
+
+        .btn-load {
+            background: var(--success-color);
+        }
+
+        .btn-load:hover {
+            background: #45a049;
+        }
+
+        .btn-secondary {
+            background: var(--bg-quaternary);
+        }
+
+        .btn-secondary:hover {
+            background: #555;
+        }
+
+        .regulation-search { 
+            padding: 12px 24px; 
+            background: var(--bg-tertiary); 
+            border-bottom: 1px solid var(--border-color); 
+        }
+        .regulation-search-input { 
+            width: 100%; 
+            padding: 8px 12px; 
+            border: 1px solid var(--border-color); 
+            border-radius: var(--radius); 
+            background: var(--bg-quaternary); 
+            color: var(--text-primary); 
+            font-size: 13px; 
+            transition: border-color 0.2s ease; 
+        }
+        .regulation-search-input:focus { 
+            outline: none; 
+            border-color: var(--primary-color); 
+        }
+        .regulation-search-input::placeholder { 
+            color: var(--text-muted); 
+        }
+        .regulation-details-list { 
+            flex: 1; 
+            overflow-y: auto; 
+            padding: 12px 24px; 
+        }
+        .regulation-detail-item { 
+            padding: 10px 12px; 
+            margin: 6px 0; 
+            background: var(--bg-quaternary); 
+            border-radius: var(--radius); 
+            cursor: pointer; 
+            transition: all 0.2s ease; 
+            border: 2px solid transparent; 
+            user-select: none; 
+            font-size: 13px; 
+            line-height: 1.4; 
+        }
+        .regulation-detail-item:hover { 
+            background: #3a3a3a; 
+            border-color: var(--primary-color); 
+        }
+        .regulation-detail-item.selected { 
+            background: var(--primary-color); 
+            color: white; 
+            border-color: var(--primary-hover); 
+        }
+        .regulation-detail-item.hidden {
+            display: none;
+        }
+
+        .action-buttons {
+            display: flex;
+            gap: 12px;
+            padding: 16px 24px;
+            border-top: 1px solid var(--border-color);
+            background: var(--bg-secondary);
+        }
+
+        /* ===== 채팅 패널 ===== */
+        .chat-panel { 
+            flex: 1; 
+            display: flex; 
+            flex-direction: column; 
+            background: var(--bg-primary); 
+        }
+        .chat-header { 
+            padding: 20px 24px; 
+            background: var(--bg-secondary); 
+            border-bottom: 1px solid var(--border-color); 
+        }
+        .chat-title { 
+            font-size: 18px; 
+            font-weight: 600; 
+            color: var(--text-primary); 
+            margin: 0; 
+            display: flex; 
+            align-items: baseline; 
+            gap: 10px; 
+        }
+        .title-subtitle { 
+            font-size: 14px; 
+            font-weight: 400; 
+            color: var(--text-muted); 
+        }
+
+        .status-text {
+            margin-top: 8px;
+            padding: 8px 12px;
+            background: var(--bg-tertiary);
+            border-radius: var(--radius);
+            font-size: 12px;
+            color: var(--primary-color);
+        }
+
+        .chat-messages { 
+            flex: 1; 
+            overflow-y: auto; 
+            padding: 24px; 
+            display: flex; 
+            flex-direction: column; 
+            gap: 16px; 
+        }
+
+        /* 메시지 버블 */
+        .message { 
+            display: flex; 
+            gap: 12px; 
+            max-width: 80%; 
+            animation: slideIn 0.3s ease; 
+        }
+        @keyframes slideIn { 
+            from { opacity: 0; transform: translateY(10px); } 
+            to { opacity: 1; transform: translateY(0); } 
+        }
+        .message.user { 
+            align-self: flex-end; 
+            flex-direction: row-reverse; 
+        }
+        .message.assistant { 
+            align-self: flex-start; 
+        }
+        .message-avatar { 
+            width: 36px; 
+            height: 36px; 
+            border-radius: 50%; 
+            background: var(--primary-color); 
+            display: flex; 
+            align-items: center; 
+            justify-content: center; 
+            color: white; 
+            font-weight: 700; 
+            font-size: 14px; 
+            flex-shrink: 0; 
+        }
+        .message.user .message-avatar { 
+            background: var(--success-color); 
+        }
+        .message-content { 
+            background: var(--bg-secondary); 
+            padding: 12px 16px; 
+            border-radius: 16px; 
+            color: var(--text-primary); 
+            line-height: 1.5; 
+            word-wrap: break-word; 
+        }
+        .message.user .message-content { 
+            background: var(--primary-color); 
+            color: white; 
+        }
+        .message-time { 
+            font-size: 11px; 
+            color: var(--text-muted); 
+            margin-top: 4px; 
+        }
+
+        /* 메시지 콘텐츠 내 HTML 스타일링 */
+        .message-content h1,
+        .message-content h2 {
+            color: var(--primary-color);
+            margin: 12px 0 8px 0;
+            font-weight: 600;
+        }
+
+        .message-content h1 { font-size: 18px; }
+        .message-content h2 { 
+            font-size: 16px; 
+            border-bottom: 1px solid var(--border-color);
+            padding-bottom: 4px;
+        }
+
+        .message-content ul,
+        .message-content ol {
+            margin: 8px 0;
+            padding-left: 20px;
+        }
+
+        .message-content li {
+            margin: 4px 0;
+            line-height: 1.4;
+        }
+
+        .message-content strong {
+            color: var(--primary-color);
+        }
+
+        .message-content p {
+            margin: 8px 0;
+            line-height: 1.5;
+        }
+
+        .message.user .message-content h1,
+        .message.user .message-content h2,
+        .message.user .message-content strong {
+            color: white;
+        }
+
+        /* 채팅 입력 영역 */
+        .chat-input-container { 
+            padding: 20px 24px; 
+            background: var(--bg-secondary); 
+            border-top: 1px solid var(--border-color); 
+        }
+        .chat-input-wrapper { 
+            display: flex; 
+            gap: 12px; 
+            align-items: flex-end; 
+        }
+        .chat-input { 
+            flex: 1; 
+            padding: 12px 16px; 
+            background: var(--bg-tertiary); 
+            border: 2px solid var(--border-color); 
+            border-radius: 24px; 
+            color: var(--text-primary); 
+            font-size: 14px; 
+            resize: none; 
+            max-height: 120px; 
+            min-height: 44px; 
+            font-family: inherit; 
+            transition: border-color 0.2s ease; 
+        }
+        .chat-input:focus { 
+            outline: none; 
+            border-color: var(--primary-color); 
+        }
+        .chat-input::placeholder { 
+            color: var(--text-muted); 
+        }
+        .send-btn { 
+            width: 44px; 
+            height: 44px; 
+            border-radius: 50%; 
+            background: var(--primary-color); 
+            border: none; 
+            color: white; 
+            cursor: pointer; 
+            display: flex; 
+            align-items: center; 
+            justify-content: center; 
+            transition: all 0.2s ease; 
+            flex-shrink: 0; 
+        }
+        .send-btn:hover { 
+            background: var(--primary-hover); 
+            transform: scale(1.05); 
+        }
+        .send-btn:active { 
+            transform: scale(0.95); 
+        }
+        .send-btn:disabled { 
+            background: var(--bg-quaternary); 
+            cursor: not-allowed; 
+            transform: none; 
+        }
+
+        /* 로딩 인디케이터 */
+        .typing-indicator { 
+            display: flex; 
+            gap: 4px; 
+            padding: 12px 16px; 
+            background: var(--bg-secondary); 
+            border-radius: 16px; 
+            width: fit-content; 
+        }
+        .typing-dot { 
+            width: 8px; 
+            height: 8px; 
+            border-radius: 50%; 
+            background: var(--text-muted); 
+            animation: typing 1.4s infinite; 
+        }
+        .typing-dot:nth-child(2) { animation-delay: 0.2s; }
+        .typing-dot:nth-child(3) { animation-delay: 0.4s; }
+
+        @keyframes typing { 
+            0%, 60%, 100% { opacity: 0.3; transform: translateY(0); } 
+            30% { opacity: 1; transform: translateY(-10px); } 
+        }
+
+        /* 스크롤바 스타일 */
+        .chat-messages::-webkit-scrollbar,
+        .filter-panel::-webkit-scrollbar,
+        .regulation-list-container::-webkit-scrollbar,
+        .regulation-details-list::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        .chat-messages::-webkit-scrollbar-track,
+        .filter-panel::-webkit-scrollbar-track,
+        .regulation-list-container::-webkit-scrollbar-track,
+        .regulation-details-list::-webkit-scrollbar-track {
+            background: var(--bg-tertiary);
+        }
+
+        .chat-messages::-webkit-scrollbar-thumb,
+        .filter-panel::-webkit-scrollbar-thumb,
+        .regulation-list-container::-webkit-scrollbar-thumb,
+        .regulation-details-list::-webkit-scrollbar-thumb {
+            background: var(--bg-quaternary);
+            border-radius: 4px;
+        }
+
+        .chat-messages::-webkit-scrollbar-thumb:hover,
+        .filter-panel::-webkit-scrollbar-thumb:hover,
+        .regulation-list-container::-webkit-scrollbar-thumb:hover,
+        .regulation-details-list::-webkit-scrollbar-thumb:hover {
+            background: #555;
+        }
+    </style>
+</head>
+
+<body>
+    <header class="header">
+        <div class="logo">LexiMind</div>
+        <nav>
+            <ul class="nav">
+                <li><a href="#">법규 검색</a></li>
+                <li><a href="#">체크리스트 생성</a></li>
+                <li><a href="#">유권해석</a></li>
+                <li><a href="#">사용문의</a></li>
+            </ul>
+        </nav>
+    </header>
+
+    <!-- 햄버거 버튼 -->
+    <button class="sidebar-toggle" id="sidebarToggle">
+        <span class="hamburger"></span>
+    </button>
+
+    <!-- 새 페이지 버튼 -->
+    <button class="new-page-btn" id="newPageBtn">
+        <span class="plus-icon">+ 새 대화 생성</span>
+    </button>
+
+    <!-- 사이드바 오버레이 -->
+    <div class="sidebar-overlay" id="sidebarOverlay"></div>
+
+    <!-- 사이드바 -->
+    <nav class="sidebar" id="sidebar">
+        <div class="sidebar-content">
+            <h3>과거 이력</h3>
+            <div class="date-ranges">
+                <a href="/history/202511" class="date-range-item">
+                    <span class="date-period">2025.11.01 ~ 2025.11.30</span>
+                    <span class="date-count">검색 15건</span>
+                </a>
+                <a href="/history/202510" class="date-range-item">
+                    <span class="date-period">2025.10.01 ~ 2025.10.31</span>
+                    <span class="date-count">검색 8건</span>
+                </a>
+                <a href="/history/202509" class="date-range-item">
+                    <span class="date-period">2025.09.01 ~ 2025.09.30</span>
+                    <span class="date-count">검색 12건</span>
+                </a>
+            </div>
+        </div>
+    </nav>
+
+    <main class="main">
+        <!-- 필터 패널 -->
+        <aside class="filter-panel">
+            <div class="filter-header">
+                <h2 class="filter-title">검색 필터</h2>
+                <div class="toggle-group">
+                    <span class="toggle-label">지역</span>
+                    <div class="toggle-options">
+                        <button class="toggle-btn region-toggle" data-value="국내">국내</button>
+                        <button class="toggle-btn region-toggle" data-value="북미">북미</button>
+                        <button class="toggle-btn region-toggle" data-value="유럽">유럽</button>
+                        <button class="toggle-btn region-toggle active" data-value="전체">전체</button>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 상세 법규 리스트 -->
+            <div class="regulation-details-container">
+                <div class="regulation-details-header">
+                    <span class="toggle-label">상세 법규 리스트</span>
+                    <button class="btn btn-load btn-small" onclick="loadDetailedRegulationList()">리스트 불러오기</button>
+                </div>
+                <div class="regulation-search" id="regulationSearchContainer" style="display: none;">
+                    <input type="text" id="regulationSearchInput" class="regulation-search-input" placeholder="법규 검색...">
+                </div>
+                <div class="regulation-details-list" id="regulationDetailsList">
+                    <p style="color: var(--text-muted); padding: 20px; text-align: center; margin: 0;">
+                        리스트 불러오기를 눌러 상세 법규를 확인하세요.
+                    </p>
+                </div>
+            </div>
+
+            <div class="action-buttons">
+                <button class="btn btn-secondary" onclick="clearAllSelections()">선택 초기화</button>
+            </div>
+        </aside>
+
+        <!-- 채팅 패널 -->
+        <section class="chat-panel">
+            <div class="chat-header">
+                <h1 class="chat-title">자동차 인증 법규 검색
+                    <span class="title-subtitle">&nbsp&nbsp관련 법규 내용을 검색으로 편리하게 찾아보세요! ※ 모든 결과물은 AI에 의해 생성된 것으로 오류가 있을 수 있습니다</span>
+                </h1>
+                <div id="statusText" class="status-text">시스템 준비 중...</div>
+            </div>
+
+            <div class="chat-messages" id="chatMessages">
+                <div class="message assistant">
+                    <div class="message-avatar">Lexi</div>
+                    <div>
+                        <div class="message-content">
+                            안녕하세요! 자동차 인증 법규 검색 도우미입니다.<br>
+                            궁금하신 법규 내용을 검색해보세요.<br><br>
+                            (ex : ISA의 작동 요건을 알려주고, 표로 정리해줘)
+                        </div>
+                        <div class="message-time" id="welcomeTime"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 채팅 입력 영역 -->
+            <div class="chat-input-container">
+                <div class="chat-input-wrapper">
+                    <textarea 
+                        id="chatInput" 
+                        class="chat-input" 
+                        placeholder="검색하고 싶은 내용을 입력하세요..."
+                        rows="1"
+                    ></textarea>
+                    <button class="send-btn" id="sendBtn" title="전송">
+                        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <path d="M22 2L11 13M22 2l-7 20-4-9-9-4 20-7z"/>
+                        </svg>
+                    </button>
+                </div>
+            </div>
+        </section>
+    </main>
+
+    <script>
+        // ===== 전역 변수 =====
+        let selectedRegulations = [];
+        let selectedRegions = [];
+        let socket;
+
+        // ===== 초기화 =====
+        document.addEventListener('DOMContentLoaded', function() {
+            initializeSocket();
+            initializeSidebar();
+            initializeToggles();
+            initializeChat();
+            initializeRegulationList();
+            setWelcomeTime();
+            updateSelectedCount();
+        });
+
+        // 환영 메시지 시간 설정
+        function setWelcomeTime() {
+            const timeElement = document.getElementById('welcomeTime');
+            if (timeElement) {
+                const now = new Date();
+                timeElement.textContent = formatTime(now);
+            }
+        }
+
+        // 시간 포맷팅
+        function formatTime(date) {
+            const hours = date.getHours().toString().padStart(2, '0');
+            const minutes = date.getMinutes().toString().padStart(2, '0');
+            return `${hours}:${minutes}`;
+        }
+
+        // ===== Socket.IO 초기화 =====
+        function initializeSocket() {
+            socket = io();
+            socket.on('message', function(data) {
+                document.getElementById('statusText').innerText = data.message;
+            });
+        }
+
+        // ===== 사이드바 초기화 =====
+        function initializeSidebar() {
+            const sidebarToggle = document.getElementById('sidebarToggle');
+            const sidebar = document.getElementById('sidebar');
+            const sidebarOverlay = document.getElementById('sidebarOverlay');
+            const newPageBtn = document.getElementById('newPageBtn');
+
+            sidebarToggle.addEventListener('click', function() {
+                const isOpen = sidebar.classList.contains('open');
+                if (isOpen) {
+                    closeSidebar();
+                } else {
+                    openSidebar();
+                }
+            });
+
+            sidebarOverlay.addEventListener('click', closeSidebar);
+
+            document.addEventListener('keydown', function(e) {
+                if (e.key === 'Escape') {
+                    closeSidebar();
+                }
+            });
+
+            if (newPageBtn) {
+                newPageBtn.addEventListener('click', function() {
+                    window.open('/', '_blank');
+                });
+            }
+        }
+
+        function openSidebar() {
+            const sidebar = document.getElementById('sidebar');
+            const sidebarToggle = document.getElementById('sidebarToggle');
+            const sidebarOverlay = document.getElementById('sidebarOverlay');
+            const newPageBtn = document.getElementById('newPageBtn');
+
+            sidebar.classList.add('open');
+            sidebarToggle.classList.add('active');
+            sidebarOverlay.classList.add('active');
+            if (newPageBtn) newPageBtn.classList.add('show');
+        }
+
+        function closeSidebar() {
+            const sidebar = document.getElementById('sidebar');
+            const sidebarToggle = document.getElementById('sidebarToggle');
+            const sidebarOverlay = document.getElementById('sidebarOverlay');
+            const newPageBtn = document.getElementById('newPageBtn');
+
+            sidebar.classList.remove('open');
+            sidebarToggle.classList.remove('active');
+            sidebarOverlay.classList.remove('active');
+            if (newPageBtn) newPageBtn.classList.remove('show');
+        }
+
+        // ===== 토글 버튼 초기화 =====
+        function initializeToggles() {
+            document.querySelectorAll('.region-toggle').forEach(btn => {
+                btn.addEventListener('click', function() {
+                    handleRegionToggle(this);
+                });
+            });
+        }
+
+        function handleRegionToggle(clickedBtn) {
+            const value = clickedBtn.getAttribute('data-value');
+            const allButtons = document.querySelectorAll('.region-toggle');
+
+            if (value === '전체') {
+                // 전체 선택 - 다른 모든 버튼 비활성화
+                allButtons.forEach(btn => btn.classList.remove('active'));
+                clickedBtn.classList.add('active');
+                selectedRegions.length = 0;
+            } else {
+                // 개별 선택 - 전체 버튼 비활성화
+                const allBtn = document.querySelector('.region-toggle[data-value="전체"]');
+                if (allBtn) allBtn.classList.remove('active');
+
+                clickedBtn.classList.toggle('active');
+
+                if (clickedBtn.classList.contains('active')) {
+                    if (!selectedRegions.includes(value)) {
+                        selectedRegions.push(value);
+                    }
+                } else {
+                    selectedRegions = selectedRegions.filter(region => region !== value);
+                }
+
+                // 아무것도 선택되지 않았으면 전체 활성화
+                if (selectedRegions.length === 0 && allBtn) {
+                    allBtn.classList.add('active');
+                }
+            }
+            
+            console.log('선택된 지역:', selectedRegions);
+        }
+
+        function getSelectedRegions() {
+            return selectedRegions.length > 0 ? selectedRegions : [];
+        }
+
+        // ===== 법규 리스트 초기화 =====
+        function initializeRegulationList() {
+            const regulationListDiv = document.getElementById('regulationList');
+            regulationListDiv.addEventListener('click', function(e) {
+                const item = e.target.closest('.regulation-item');
+                if (item) {
+                    toggleRegulationSelection(item);
+                }
+            });
+        }
+
+        function toggleRegulationSelection(element) {
+            const id = element.getAttribute('data-id');
+            if (selectedRegulations.includes(id)) {
+                selectedRegulations = selectedRegulations.filter(item => item !== id);
+                element.classList.remove('selected');
+            } else {
+                selectedRegulations.push(id);
+                element.classList.add('selected');
+            }
+            updateSelectedCount();
+        }
+
+        function updateSelectedCount() {
+            const countElement = document.getElementById('selectedCount');
+            if (countElement) {
+                countElement.textContent = `선택됨: ${selectedRegulations.length}`;
+            }
+        }
+
+        // ===== 채팅 초기화 =====
+        function initializeChat() {
+            const chatInput = document.getElementById('chatInput');
+            const sendBtn = document.getElementById('sendBtn');
+
+            // 자동 높이 조절
+            chatInput.addEventListener('input', function() {
+                this.style.height = 'auto';
+                this.style.height = Math.min(this.scrollHeight, 120) + 'px';
+            });
+
+            // Enter 키로 전송
+            chatInput.addEventListener('keydown', function(e) {
+                if (e.key === 'Enter' && !e.shiftKey) {
+                    e.preventDefault();
+                    sendMessage();
+                }
+            });
+
+            // 전송 버튼 클릭
+            sendBtn.addEventListener('click', sendMessage);
+        }
+
+        // ===== 메시지 전송 =====
+        function sendMessage() {
+            const chatInput = document.getElementById('chatInput');
+            const message = chatInput.value.trim();
+            if (!message) return;
+
+            // 사용자 메시지 추가
+            addMessage(message, 'user');
+
+            // 입력창 초기화
+            chatInput.value = '';
+            chatInput.style.height = 'auto';
+
+            // 로딩 표시
+            showTypingIndicator();
+
+            // 서버에 요청
+            const requestData = {
+                query: message,
+                regions: getSelectedRegions(),
+                selectedRegulations: selectedRegulations.map(id => {
+                    const element = document.querySelector(`[data-id="${id}"]`);
+                    return {
+                        id: id,
+                        title: element ? element.getAttribute('data-title') || element.textContent.trim() : id
+                    };
+                })
+            };
+
+            fetch('/get_message', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(requestData)
+            })
+            .then(response => response.json())
+            .then(data => {
+                hideTypingIndicator();
+                if (data.message) {
+                    addMessage(data.message, 'assistant');
+                }
+            })
+            .catch(error => {
+                console.error('검색 오류:', error);
+                hideTypingIndicator();
+                addMessage('죄송합니다. 검색 중 오류가 발생했습니다.', 'assistant');
+            });
+        }
+
+        function addMessage(text, type) {
+            const chatMessages = document.getElementById('chatMessages');
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${type}`;
+
+            const avatar = document.createElement('div');
+            avatar.className = 'message-avatar';
+            avatar.textContent = type === 'user' ? 'Me' : 'Lexi';
+
+            const contentWrapper = document.createElement('div');
+            const content = document.createElement('div');
+            content.className = 'message-content';
+            
+            if (type === 'assistant') {
+                const decodedText = decodeHtmlEntities(text);
+                content.innerHTML = decodedText;
+            } else {
+                content.textContent = text;
+            }
+
+            const time = document.createElement('div');
+            time.className = 'message-time';
+            time.textContent = formatTime(new Date());
+
+            contentWrapper.appendChild(content);
+            contentWrapper.appendChild(time);
+            messageDiv.appendChild(avatar);
+            messageDiv.appendChild(contentWrapper);
+            chatMessages.appendChild(messageDiv);
+
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+
+        function decodeHtmlEntities(text) {
+            const textarea = document.createElement('textarea');
+            textarea.innerHTML = text;
+            return textarea.value;
+        }
+
+        function showTypingIndicator() {
+            const chatMessages = document.getElementById('chatMessages');
+            const indicator = document.createElement('div');
+            indicator.className = 'message assistant';
+            indicator.id = 'typingIndicator';
+
+            const avatar = document.createElement('div');
+            avatar.className = 'message-avatar';
+            avatar.textContent = 'Lexi';
+
+            const typing = document.createElement('div');
+            typing.className = 'typing-indicator';
+            typing.innerHTML = '<div class="typing-dot"></div><div class="typing-dot"></div><div class="typing-dot"></div>';
+
+            indicator.appendChild(avatar);
+            indicator.appendChild(typing);
+            chatMessages.appendChild(indicator);
+            chatMessages.scrollTop = chatMessages.scrollHeight;
+        }
+
+        function hideTypingIndicator() {
+            const indicator = document.getElementById('typingIndicator');
+            if (indicator) {
+                indicator.remove();
+            }
+        }
+
+        // ===== 상세 법규 리스트 관련 함수 =====
+        function loadDetailedRegulationList() {
+            const selectedRegions = getSelectedRegions();
+            const detailsListDiv = document.getElementById('regulationDetailsList');
+            const searchContainer = document.getElementById('regulationSearchContainer');
+            
+            detailsListDiv.innerHTML = '<p style="color: var(--text-muted); padding: 20px; text-align: center; margin: 0;">상세 법규 리스트 로딩 중...</p>';
+
+            fetch('/get_reg_list', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ regions: selectedRegions })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.reg_list_part) {
+                    displayDetailedRegulationList(data.reg_list_part);
+                    searchContainer.style.display = 'block';
+                    initializeRegulationSearch();
+                } else {
+                    detailsListDiv.innerHTML = '<p style="color: var(--text-muted); padding: 20px; text-align: center; margin: 0;">상세 법규 리스트를 불러올 수 없습니다.</p>';
+                }
+            })
+            .catch(error => {
+                console.error('상세 법규 리스트 로딩 오류:', error);
+                detailsListDiv.innerHTML = '<p style="color: #ff6b6b; padding: 20px; text-align: center; margin: 0;">리스트 로딩 중 오류가 발생했습니다.</p>';
+            });
+        }
+
+        function displayDetailedRegulationList(data) {
+            const detailsListDiv = document.getElementById('regulationDetailsList');
+            
+            let listHTML = '';
+            
+            if (typeof data === 'string') {
+                const lines = data.split('\n').filter(line => line.trim());
+                lines.forEach((line, index) => {
+                    const regId = `detail_reg_${Date.now()}_${index}`;
+                    const isSelected = selectedRegulations.includes(regId);
+                    listHTML += `
+                        <div class="regulation-detail-item ${isSelected ? 'selected' : ''}" 
+                             data-id="${regId}" 
+                             data-title="${line.trim()}"
+                             data-search-text="${line.trim().toLowerCase()}">
+                            ${line.trim()}
+                        </div>
+                    `;
+                });
+            } else if (Array.isArray(data)) {
+                data.forEach((item, index) => {
+                    const regId = item.id || `detail_reg_${Date.now()}_${index}`;
+                    const title = item.title || item.name || item.toString();
+                    const isSelected = selectedRegulations.includes(regId);
+                    listHTML += `
+                        <div class="regulation-detail-item ${isSelected ? 'selected' : ''}" 
+                             data-id="${regId}" 
+                             data-title="${title}"
+                             data-search-text="${title.toLowerCase()}">
+                            ${title}
+                        </div>
+                    `;
+                });
+            } else {
+                listHTML = '<p style="color: var(--text-muted); padding: 20px; text-align: center; margin: 0;">상세 법규 데이터를 표시할 수 없습니다.</p>';
+            }
+            
+            detailsListDiv.innerHTML = listHTML;
+            updateSelectedCount();
+            
+            // 상세 법규 리스트 클릭 이벤트 추가
+            detailsListDiv.addEventListener('click', function(e) {
+                const item = e.target.closest('.regulation-detail-item');
+                if (item) {
+                    toggleRegulationSelection(item);
+                }
+            });
+        }
+
+        function initializeRegulationSearch() {
+            const searchInput = document.getElementById('regulationSearchInput');
+            
+            searchInput.addEventListener('input', function() {
+                const searchTerm = this.value.toLowerCase().trim();
+                filterRegulationList(searchTerm);
+            });
+        }
+
+        function filterRegulationList(searchTerm) {
+            const detailItems = document.querySelectorAll('.regulation-detail-item');
+            
+            detailItems.forEach(item => {
+                const searchText = item.getAttribute('data-search-text') || '';
+                
+                if (searchTerm === '' || searchText.includes(searchTerm)) {
+                    item.classList.remove('hidden');
+                } else {
+                    item.classList.add('hidden');
+                }
+            });
+        }
+
+        function clearAllSelections() {
+            selectedRegulations = [];
+            document.querySelectorAll('.regulation-item').forEach(item => {
+                item.classList.remove('selected');
+            });
+            document.querySelectorAll('.regulation-detail-item').forEach(item => {
+                item.classList.remove('selected');
+            });
+            updateSelectedCount();
+            
+            // 검색창 초기화
+            const searchInput = document.getElementById('regulationSearchInput');
+            if (searchInput) {
+                searchInput.value = '';
+                filterRegulationList('');
+            }
+        }
+    </script>
+</body>
+</html>

templates/toss_dark.html

@@ -0,0 +1,811 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>트리니티2 - 자동차 인증 법규를 더 쉽게</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script src="https://cdn.socket.io/4.7.2/socket.io.min.js"></script>
+    <style>
+        /* ... existing styles ... */
+        :root {
+            --primary-color: #4da8ff;
+            --primary-hover: #4d8cff;
+            --bg-primary: #1a1a1a;
+            --bg-secondary: #2c2c2c;
+            --bg-tertiary: #333;
+            --bg-quaternary: #444;
+            --text-primary: #e0e0e0;
+            --text-secondary: #b0b0b0;
+            --text-muted: #888;
+            --border-color: #444;
+            --shadow: 0 2px 8px rgba(0,0,0,0.2);
+            --radius: 8px;
+            --success-color: #4caf50;
+            --warning-color: #ff9800;
+        }
+
+        * {
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Noto Sans KR', sans-serif;
+            margin: 0;
+            padding: 0;
+            background-color: var(--bg-primary);
+            color: var(--text-primary);
+            line-height: 1.6;
+        }
+
+        /* ===== 헤더 ===== */
+        .header {
+            background: var(--bg-secondary);
+            padding: 16px 24px;
+            box-shadow: var(--shadow);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            position: sticky;
+            top: 0;
+            z-index: 100;
+        }
+
+        .logo {
+            font-size: 28px;
+            font-weight: 700;
+            color: var(--primary-color);
+            letter-spacing: -0.5px;
+        }
+
+        .nav {
+            display: flex;
+            list-style: none;
+            gap: 32px;
+            margin: 0;
+            padding: 0;
+        }
+
+        .nav a {
+            text-decoration: none;
+            color: var(--text-secondary);
+            font-weight: 500;
+            padding: 8px 12px;
+            border-radius: var(--radius);
+            transition: all 0.2s ease;
+        }
+
+        .nav a:hover {
+            color: var(--primary-hover);
+            background: rgba(77, 168, 255, 0.1);
+        }
+
+        /* ===== 메인 컨텐츠 ===== */
+        .main {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 32px 24px;
+        }
+
+        .hero {
+            text-align: center;
+            margin-bottom: 48px;
+        }
+
+        .hero-title {
+            font-size: 42px;
+            font-weight: 700;
+            color: var(--text-primary);
+            margin-bottom: 12px;
+            letter-spacing: -1px;
+        }
+
+        .hero-subtitle {
+            font-size: 20px;
+            color: var(--text-secondary);
+            margin: 0 0 24px 0;
+        }
+
+        .status-text {
+            padding: 12px 20px;
+            background: var(--bg-tertiary);
+            border-radius: var(--radius);
+            display: inline-block;
+            font-size: 14px;
+            color: var(--primary-color);
+        }
+
+        /* ===== 검색 섹션 ===== */
+        .search-section {
+            background: var(--bg-secondary);
+            border-radius: 16px;
+            padding: 32px;
+            box-shadow: var(--shadow);
+            margin-bottom: 32px;
+        }
+
+        .section-title {
+            font-size: 24px;
+            font-weight: 600;
+            margin-bottom: 24px;
+            color: var(--text-primary);
+        }
+
+        .checkbox-container {
+            display: flex;
+            gap: 24px;
+            flex-wrap: wrap;
+            margin-bottom: 24px;
+            align-items: center;
+            padding: 16px;
+            background: var(--bg-tertiary);
+            border-radius: var(--radius);
+        }
+
+        .checkbox-label {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 14px;
+            color: var(--text-secondary);
+            cursor: pointer;
+            transition: color 0.2s ease;
+        }
+
+        .checkbox-label:hover {
+            color: var(--text-primary);
+        }
+
+        .checkbox-label input[type="checkbox"] {
+            accent-color: var(--primary-color);
+            transform: scale(1.1);
+        }
+
+        .search-controls {
+            display: flex;
+            gap: 12px;
+            margin-bottom: 24px;
+            flex-wrap: wrap;
+        }
+
+        .search-input {
+            padding: 12px 16px;
+            border: 2px solid var(--border-color);
+            border-radius: var(--radius);
+            font-size: 16px;
+            flex: 1;
+            min-width: 300px;
+            background: var(--bg-tertiary);
+            color: var(--text-primary);
+            transition: border-color 0.2s ease;
+        }
+
+        .search-input:focus {
+            outline: none;
+            border-color: var(--primary-color);
+        }
+
+        .search-input::placeholder {
+            color: var(--text-muted);
+        }
+
+        .btn {
+            padding: 12px 20px;
+            border: none;
+            border-radius: var(--radius);
+            background: var(--primary-color);
+            color: white;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: 600;
+            transition: all 0.2s ease;
+            white-space: nowrap;
+        }
+
+        .btn:hover {
+            background: var(--primary-hover);
+            transform: translateY(-1px);
+        }
+
+        .btn-secondary {
+            background: var(--bg-quaternary);
+        }
+
+        .btn-secondary:hover {
+            background: #555;
+        }
+
+        /* ===== 결과 컨테이너 ===== */
+        .results-container {
+            display: grid;
+            grid-template-columns: 1fr 2fr;
+            gap: 24px;
+            margin-top: 24px;
+        }
+
+        .result-panel {
+            padding: 24px;
+            border-radius: 12px;
+            min-height: 200px;
+            box-shadow: var(--shadow);
+        }
+
+        .regulation-list {
+            background: var(--bg-tertiary);
+        }
+
+        .search-results {
+            background: var(--bg-quaternary);
+        }
+
+        .panel-title {
+            font-size: 18px;
+            font-weight: 600;
+            margin-bottom: 16px;
+            color: var(--text-primary);
+            border-bottom: 2px solid var(--primary-color);
+            padding-bottom: 8px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .selected-count {
+            font-size: 14px;
+            color: var(--primary-color);
+            background: rgba(77, 168, 255, 0.1);
+            padding: 4px 8px;
+            border-radius: 4px;
+        }
+
+        .regulation-item {
+            padding: 12px;
+            margin: 8px 0;
+            background: var(--bg-quaternary);
+            border-radius: var(--radius);
+            cursor: pointer;
+            transition: all 0.2s ease;
+            border: 2px solid transparent;
+            user-select: none;
+        }
+
+        .regulation-item:hover {
+            background: #3a3a3a;
+            border-color: var(--primary-color);
+        }
+
+        .regulation-item.selected {
+            background: var(--primary-color);
+            color: white;
+            border-color: var(--primary-hover);
+        }
+
+        .regulation-item.selected:hover {
+            background: var(--primary-hover);
+        }
+
+        .region-table {
+            width: 100%;
+            border-collapse: separate;
+            border-spacing: 0;
+            margin-bottom: 16px;
+            border-radius: var(--radius);
+            overflow: hidden;
+            box-shadow: var(--shadow);
+        }
+
+        .region-table th,
+        .region-table td {
+            padding: 12px 16px;
+            border: 1px solid var(--border-color);
+            text-align: left;
+            background: var(--bg-secondary);
+        }
+
+        .region-table th {
+            background: var(--bg-quaternary);
+            font-weight: 600;
+            text-align: center;
+            color: var(--primary-color);
+        }
+
+        .action-buttons {
+            display: flex;
+            gap: 12px;
+            margin-top: 16px;
+            padding-top: 16px;
+            border-top: 1px solid var(--border-color);
+        }
+
+        .btn-submit {
+            background: var(--success-color);
+        }
+
+        .btn-submit:hover {
+            background: #45a049;
+        }
+
+        .btn-clear {
+            background: var(--warning-color);
+        }
+
+        .btn-clear:hover {
+            background: #f57c00;
+        }
+
+        /* ===== 푸터 ===== */
+        .footer {
+            text-align: center;
+            padding: 48px 24px;
+            color: var(--text-secondary);
+            border-top: 1px solid var(--border-color);
+            margin-top: 48px;
+        }
+
+        /* ===== 반응형 ===== */
+        @media (max-width: 768px) {
+            .header {
+                padding: 12px 16px;
+            }
+            
+            .nav {
+                gap: 16px;
+            }
+            
+            .hero-title {
+                font-size: 28px;
+            }
+            
+            .main {
+                padding: 16px;
+            }
+            
+            .search-section {
+                padding: 20px;
+            }
+            
+            .results-container {
+                grid-template-columns: 1fr;
+            }
+            
+            .search-controls {
+                flex-direction: column;
+            }
+            
+            .search-input {
+                min-width: auto;
+            }
+            
+            .checkbox-container {
+                flex-direction: column;
+                align-items: flex-start;
+                gap: 12px;
+            }
+
+            .action-buttons {
+                flex-direction: column;
+            }
+
+            .search-results-content {
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            line-height: 1.6;
+        }
+        }
+
+        @media (max-width: 480px) {
+            .checkbox-container {
+                padding: 12px;
+            }
+            
+            .nav {
+                display: none;
+            }
+        }
+    </style>
+</head>
+
+<body>
+    <header class="header">
+        <div class="logo">트리니티</div>
+        <nav>
+            <ul class="nav">
+                <li><a href="#">법규 검색</a></li>
+                <li><a href="#">체크리스트 생성</a></li>
+                <li><a href="#">유권해석</a></li>
+                <li><a href="#">사용문의</a></li>
+            </ul>
+        </nav>
+    </header>
+
+    <main class="main">
+        <section class="hero">
+            <h1 class="hero-title">자동차 인증 법규를 더 쉽게</h1>
+            <p class="hero-subtitle">관련 법규를 검색으로 편리하게 찾아보세요</p>
+            <div id="statusText" class="status-text">시스템 준비 중...</div>
+        </section>
+
+        <section class="search-section">
+            <h2 class="section-title">법규 검색</h2>
+            
+            <div class="checkbox-container">
+                <span class="checkbox-label"><strong>검색 범위:</strong></span>
+                <label class="checkbox-label">
+                    <input type="checkbox" id="allRegions">
+                    모두 선택
+                </label>
+                <label class="checkbox-label">
+                    <input type="checkbox" class="region-checkbox" value="국내">
+                    국내
+                </label>
+                <label class="checkbox-label">
+                    <input type="checkbox" class="region-checkbox" value="북미">
+                    북미
+                </label>
+                <label class="checkbox-label">
+                    <input type="checkbox" class="region-checkbox" value="유럽">
+                    유럽
+                </label>
+            </div>
+
+            <div class="search-controls">
+                <input 
+                    type="text" 
+                    id="searchInput" 
+                    class="search-input" 
+                    placeholder="검색하고 싶은 내용을 입력하세요 (예: ISA 기능과 관련된 법규가 뭐야?)"
+                >
+                <button class="btn" onclick="showMessage()">검색</button>
+                <button class="btn btn-secondary" onclick="loadRegulationList()">법규 리스트</button>
+            </div>
+
+            <div class="results-container">
+                <div class="result-panel regulation-list">
+                    <div class="panel-title">
+                        법규 리스트
+                        <span id="selectedCount" class="selected-count">선택됨: 0</span>
+                    </div>
+                    <div id="regulationList">
+                        <div class="regulation-item" data-id="reg1" data-title="국내 배출가스 기준">
+                            법규 1 - 국내 배출가스 기준
+                        </div>
+                        <div class="regulation-item" data-id="reg2" data-title="북미 안전 기준">
+                            법규 2 - 북미 안전 기준
+                        </div>
+                        <div class="regulation-item" data-id="reg3" data-title="유럽 환경 규정">
+                            법규 3 - 유럽 환경 규정
+                        </div>
+                    </div>
+                    <div class="action-buttons">
+                        <button class="btn btn-submit" onclick="submitSelectedRegulations()">선택 항목 전송</button>
+                        <button class="btn btn-clear" onclick="clearAllSelections()">선택 초기화</button>
+                    </div>
+                </div>
+
+                <div class="result-panel search-results">
+                    <div class="panel-title">검색 결과</div>
+                    <div id="searchResults">검색 결과가 여기에 표시됩니다.</div>
+                </div>
+            </div>
+        </section>
+    </main>
+
+    <footer class="footer">
+        <p>© 2024 법규인증3팀 - 트리니티 시스템</p>
+    </footer>
+
+    <script>
+        // ===== 전역 변수 =====
+        let selectedRegulations = [];
+        let socket;
+
+        // ===== 초기화 =====
+        document.addEventListener('DOMContentLoaded', function() {
+            initializeSocket();
+            initializeEventListeners();
+            updateSelectedCount();
+        });
+
+        // ===== Socket.IO 초기화 =====
+        function initializeSocket() {
+            socket = io();
+            socket.on('message', function(data) {
+                document.getElementById('statusText').innerText = data.message;
+            });
+        }
+
+		// ===== 이벤트 리스너 초기화 =====
+		function initializeEventListeners() {
+			// 전체 선택 체크박스
+			document.getElementById('allRegions').addEventListener('change', toggleAllRegions);
+			
+			// 개별 체크박스들에 이벤트 리스너 추가
+			document.querySelectorAll('.region-checkbox').forEach(checkbox => {
+				checkbox.addEventListener('change', updateAllRegionsCheckbox);
+			});
+			
+			// 검색 입력 엔터키
+			document.getElementById('searchInput').addEventListener('keypress', function(e) {
+				if (e.key === 'Enter') {
+					showMessage();
+				}
+			});
+
+			// 법규 리스트 이벤트 위임 (동적으로 추가되는 항목들도 클릭 가능)
+			document.getElementById('regulationList').addEventListener('click', function(e) {
+				const item = e.target.closest('.regulation-item');
+				if (item) {
+					toggleSelection(item);
+				}
+			});
+		}
+
+		// ===== 지역 선택 관련 함수 =====
+		function toggleAllRegions() {
+			const allCheckbox = document.getElementById('allRegions');
+			const regionCheckboxes = document.querySelectorAll('.region-checkbox');
+			
+			regionCheckboxes.forEach(checkbox => {
+				checkbox.checked = allCheckbox.checked;
+			});
+		}
+
+		// 개별 체크박스 변경 시 "모두 선택" 체크박스 상태 업데이트
+		function updateAllRegionsCheckbox() {
+			const allCheckbox = document.getElementById('allRegions');
+			const regionCheckboxes = document.querySelectorAll('.region-checkbox');
+			const checkedCount = document.querySelectorAll('.region-checkbox:checked').length;
+			
+			if (checkedCount === 0) {
+				// 아무것도 선택되지 않음
+				allCheckbox.checked = false;
+				allCheckbox.indeterminate = false;
+			} else if (checkedCount === regionCheckboxes.length) {
+				// 모두 선택됨
+				allCheckbox.checked = true;
+				allCheckbox.indeterminate = false;
+			} else {
+				// 일부만 선택됨
+				allCheckbox.checked = false;
+				allCheckbox.indeterminate = true;
+			}
+		}
+
+		function getSelectedRegions() {
+			const checkboxes = document.querySelectorAll('.region-checkbox:checked');
+			return Array.from(checkboxes).map(cb => cb.value);
+		}
+
+        // ===== 검색 관련 함수 (기존 performSearch를 showMessage로 통합) =====
+        function showMessage() {
+            const query = document.getElementById('searchInput').value.trim();
+            const resultsDiv = document.getElementById('searchResults');
+            const selectedRegions = getSelectedRegions();
+            
+            if (!query) {
+                resultsDiv.innerHTML = '<p style="color: var(--text-muted);">검색어를 입력해주세요.</p>';
+                return;
+            }
+
+            // 로딩 상태 표시
+            resultsDiv.innerHTML = '<p>검색 중...</p>';
+
+            // 검색과 선택된 법규 정보를 함께 서버에 전송
+            const requestData = {
+                query: query,
+                regions: selectedRegions,
+                selectedRegulations: selectedRegulations.map(id => {
+                    const element = document.querySelector(`[data-id="${id}"]`);
+                    return {
+                        id: id,
+                        title: element ? element.getAttribute('data-title') || element.textContent.trim() : id
+                    };
+                })
+            };
+
+            fetch('/get_message', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(requestData)
+            })
+            .then(response => response.json())
+            .then(data => {
+                displaySearchResults(data, query, selectedRegions);
+            })
+            .catch(error => {
+                console.error('검색 오류:', error);
+                resultsDiv.innerHTML = '<p style="color: #ff6b6b;">검색 중 오류가 발생했습니다.</p>';
+            });
+        }
+
+        function displaySearchResults(data, query, selectedRegions) {
+            const resultsDiv = document.getElementById('searchResults');
+            
+            if (selectedRegions.length === 0) {
+                selectedRegions = ['국내', '북미', '유럽'];
+            }
+
+            let resultsHTML = `
+                <div style="margin-bottom: 16px; padding: 12px; background: var(--bg-tertiary); border-radius: var(--radius);">
+                    <p><strong>검색어:</strong> ${query}</p>
+                    ${selectedRegulations.length > 0 ? `<p><strong>선택된 법규:</strong> ${selectedRegulations.length}개</p>` : ''}
+                </div>
+            `;
+            
+            if (data.message) {
+                resultsHTML += `<div class="search-results-content" style="margin: 16px 0; padding: 16px; background: var(--bg-tertiary); border-radius: var(--radius);">
+                    ${data.message}
+                </div>`;
+            }
+
+            selectedRegions.forEach(region => {
+                const content = `${region} 관련 규정: ${query}에 대한 내용`;
+                const regId = `REG-${Math.random().toString(36).substr(2, 9).toUpperCase()}`;
+                const updateDate = new Date().toLocaleDateString('ko-KR');
+
+                resultsHTML += `
+                    <table class="region-table">
+                        <tr>
+                            <th>${region}</th>
+                            <td>
+                                <ul style="margin: 0; padding-left: 20px;">
+                                    <li>법규 ID: ${regId}</li>
+                                    <li>내용: ${content}</li>
+                                    <li>업데이트: ${updateDate}</li>
+                                </ul>
+                            </td>
+                        </tr>
+                    </table>
+                `;
+            });
+
+            resultsDiv.innerHTML = resultsHTML;
+        }
+
+        // ===== 법규 리스트 관련 함수 =====
+        function loadRegulationList() {
+            const selectedRegions = getSelectedRegions();
+            const listDiv = document.getElementById('regulationList');
+            
+            listDiv.innerHTML = '<p>법규 리스트 로딩 중...</p>';
+
+            fetch('/get_reg_list', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ regions: selectedRegions })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.reg_list_part) {
+                    displayRegulationList(data.reg_list_part);
+                } else {
+                    listDiv.innerHTML = '<p style="color: var(--text-muted);">법규 리스트를 불러올 수 없습니다.</p>';
+                }
+				//if (data.reg_list_section) {
+                //    displayRegulationList(data.reg_list_section);
+                //} else {
+                //    listDiv.innerHTML = '<p style="color: var(--text-muted);">법규 리스트를 불러올 수 없습니다.</p>';
+                //}
+            })
+            .catch(error => {
+                console.error('법규 리스트 로딩 오류:', error);
+                listDiv.innerHTML = '<p style="color: #ff6b6b;">법규 리스트 로딩 중 오류가 발생했습니다.</p>';
+            });
+        }
+
+        function displayRegulationList(data) {
+            const listDiv = document.getElementById('regulationList');
+            
+            // 서버 데이터를 파싱해서 클릭 가능한 항목들로 변환
+            // 실제 데이터 구조에 맞게 수정 필요
+            let listHTML = '';
+            
+            if (typeof data === 'string') {
+                // 문자열 데이터를 줄 단위로 분할해서 처리
+                const lines = data.split('\n').filter(line => line.trim());
+                lines.forEach((line, index) => {
+                    const regId = `reg_${Date.now()}_${index}`;
+                    const isSelected = selectedRegulations.includes(regId);
+                    listHTML += `
+                        <div class="regulation-item ${isSelected ? 'selected' : ''}" 
+                             data-id="${regId}" 
+                             data-title="${line.trim()}">
+                            ${line.trim()}
+                        </div>
+                    `;
+                });
+            } else if (Array.isArray(data)) {
+                // 배열 데이터 처리
+                data.forEach((item, index) => {
+                    const regId = item.id || `reg_${Date.now()}_${index}`;
+                    const title = item.title || item.name || item.toString();
+                    const isSelected = selectedRegulations.includes(regId);
+                    listHTML += `
+                        <div class="regulation-item ${isSelected ? 'selected' : ''}" 
+                             data-id="${regId}" 
+                             data-title="${title}">
+                            ${title}
+                        </div>
+                    `;
+                });
+            } else {
+                // 기본 처리
+                listHTML = '<p style="color: var(--text-muted);">법규 데이터를 표시할 수 없습니다.</p>';
+            }
+            
+            listDiv.innerHTML = listHTML;
+            updateSelectedCount();
+        }
+
+        // ===== 법규 선택 관련 함수 =====
+        function toggleSelection(element) {
+            const id = element.getAttribute('data-id');
+            
+            if (selectedRegulations.includes(id)) {
+                selectedRegulations = selectedRegulations.filter(item => item !== id);
+                element.classList.remove('selected');
+            } else {
+                selectedRegulations.push(id);
+                element.classList.add('selected');
+            }
+            
+            updateSelectedCount();
+            console.log('선택된 법규:', selectedRegulations);
+        }
+
+        function updateSelectedCount() {
+            const countElement = document.getElementById('selectedCount');
+            countElement.textContent = `선택됨: ${selectedRegulations.length}`;
+        }
+
+        function clearAllSelections() {
+            selectedRegulations = [];
+            document.querySelectorAll('.regulation-item').forEach(item => {
+                item.classList.remove('selected');
+            });
+            updateSelectedCount();
+        }
+
+        // ===== 데이터 전송 함수 =====
+        function submitSelectedRegulations() {
+            if (selectedRegulations.length === 0) {
+                alert('선택된 법규가 없습니다.');
+                return;
+            }
+
+            const messageData = {
+                selected: selectedRegulations.map(id => {
+                    const element = document.querySelector(`[data-id="${id}"]`);
+                    return {
+                        id: id,
+                        title: element ? element.getAttribute('data-title') || element.textContent.trim() : id
+                    };
+                })
+            };
+
+            fetch('/submit', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(messageData)
+            })
+            .then(response => {
+                if (response.ok) {
+                    alert(`선택된 ${selectedRegulations.length}개 법규가 전송되었습니다!`);
+                } else {
+                    alert('전송 실패');
+                }
+            })
+            .catch(error => {
+                console.error('전송 오류:', error);
+                alert('전송 중 오류가 발생했습니다.');
+            });
+        }
+    </script>
+</body>
+</html>