initial commit

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+faiss_data/criminal_judgments.index filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+/data_source/
+/data_ori/
+/faiss_data/
+.env
+.DS_Store
+.cursorignore

README.md

@@ -0,0 +1,76 @@
+---
+title: Judge Search
+emoji: 💬
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 5.0.1
+app_file: app.py
+pinned: false
+---
+
+# 司法判決搜尋與問答系統
+
+## 專案概述
+
+本系統是一個專為研究人員及一般查詢設計的司法判決搜尋與問答平台。根據用戶的自然語言查詢司法判決，提供摘要與判決書連結。
+
+### 主要功能
+- 人名/關鍵詞搜尋：能夠精確識別判決中的人名、法條、案由等關鍵資訊（支援文本匹配搜尋、向量相似度搜尋及混合搜尋策略）
+- 專業格式化：將複雜的判決文書整理為易於取得資訊的列表及摘要，並提供原文連結
+- 互動式使用者介面：使用Gradio架構UI
+
+## 資料來源
+
+本系統使用台灣司法判決資料庫中的刑事判決書，經過清理與預處理。主要資料來源為[司法院資料開放平臺](https://opendata.judicial.gov.tw/)：
+- 刑事判決文書：透過資料清理整併至`data_source/merged_criminal_cases.json`
+- 每筆判決資料包含案號、判決日期、案件標題、判決全文及PDF連結等資訊
+
+## 技術架構
+
+### 主要方法
+1. **向量化**
+2. **搜尋方式**：
+   - FAISS（Facebook AI相似性搜尋）提供向量檢索
+   - 自訂文本搜尋函數用於關鍵詞匹配（支援人名等專有名詞搜尋）
+3. **AI推理**：整合OpenAI API（支援GPT-4o-mini和GPT-4o）
+4. **使用者介面**：Gradio架構的互動式Web界面
+
+### 主要檔案
+- `create_judgment_embeddings.py`：處理判決書文本並生成向量索引、包含Meta索引
+- `app.py`：主要程式，包含搜尋邏輯及Gradio界面
+- `faiss_data/`：存放FAISS向量索引及Meta索引
+- `data_source/`：原始判決書資料（未上傳）
+- `merge_criminal_cases.py`：資料整理（合併判決書）
+- `requirements.txt`：專案所需套件
+
+## 如何使用
+
+### 安裝與設定
+1. 安裝所需套件：
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. 配置OpenAI API密鑰（在 `.env` 檔案或存到伺服器的環境變數）：
+   ```
+   OPENAI_API_KEY=your_api_key
+   ```
+
+3. 生成向量索引（首次使用時）：
+   ```bash
+   python create_judgment_embeddings.py
+   ```
+   若有需要，須先整併裁判書（merge_criminal_cases.py）
+
+4. 啟動應用程式：
+   ```bash
+   python app.py
+   ```
+
+### 使用界面
+- **問題輸入**：在輸入框中輸入與刑事判決相關的問題
+- **搜尋模式**：選擇「自動」、「僅文本搜尋」或「僅向量搜尋」
+- **模型選擇**：可選擇GPT-4o-mini（快速）或GPT-4o（更精確）
+- **參數調整**：可調整生成參數，如最大字數、溫度、多樣性等
+- **查看原文**：點擊判決連結可查看完整判決原文

app.py

@@ -0,0 +1,496 @@
+import gradio as gr
+import os
+import json
+import pickle
+import re
+from typing import List, Tuple, Dict, Any
+from dotenv import load_dotenv
+import openai
+import faiss
+import numpy as np
+from sentence_transformers import SentenceTransformer
+
+# 載入環境變數
+load_dotenv()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+# API金鑰不再是必須的，因為使用者可以提供自己的金鑰
+if OPENAI_API_KEY:
+    print("[INFO] 已從環境變數讀取API金鑰")
+else:
+    print("[INFO] 未設置環境變數API金鑰，將使用使用者提供的金鑰")
+
+# 配置
+FAISS_DATA_DIR = "faiss_data"  # FAISS 資料的資料夾
+MODEL_NAME = 'paraphrase-multilingual-MiniLM-L12-v2'  # 使用與建立索引時相同的模型
+
+def load_faiss_data(data_dir=FAISS_DATA_DIR):
+    """載入 FAISS 索引和 meta 資料"""
+    if not os.path.exists(data_dir):
+        raise ValueError(f"未找到 FAISS 資料資料夾：{data_dir}")
+    
+    # 載入 FAISS 索引
+    index_path = os.path.join(data_dir, 'criminal_judgments.index')
+    meta_path = os.path.join(data_dir, 'criminal_judgments_meta.pkl')
+    
+    if not os.path.exists(index_path) or not os.path.exists(meta_path):
+        raise ValueError("未找到必要的 FAISS 資料檔案")
+    
+    print(f"[INFO] 載入 FAISS 索引和 meta 資料")
+    index = faiss.read_index(index_path)
+    with open(meta_path, 'rb') as f:
+        meta_data = pickle.load(f)
+    
+    return index, meta_data
+
+# 載入模型和資料
+try:
+    model = SentenceTransformer(MODEL_NAME)
+    faiss_index, meta_data = load_faiss_data()
+    print("[INFO] 成功載入模型和 FAISS 資料")
+except Exception as e:
+    print(f"[ERROR] 載入失敗：{e}")
+    print("[INFO] 請先執行 create_judgment_embeddings.py 建立索引")
+    model, faiss_index, meta_data = None, None, None
+
+def format_judgment_info(judgment_meta):
+    """格式化判決資訊"""
+    return f"""
+案件編號：{judgment_meta['JID']}
+年度：{judgment_meta['JYEAR']}
+案件類型：{judgment_meta['JCASE']}
+案號：{judgment_meta['JNO']}
+判決日期：{judgment_meta['JDATE']}
+案件標題：{judgment_meta['JTITLE']}
+PDF連結：{judgment_meta['JPDF']}
+"""
+
+def format_retrieval_results(results, meta_data):
+    """格式化檢索結果，用於顯示給用戶"""
+    html = "<div style='max-height: 500px; overflow-y: auto; padding: 1rem; background-color: #f7f7f7; border-radius: 0.5rem;'>"
+    html += "<h3>📚 檢索到的相關判決</h3>"
+    
+    for i, (text, meta, match_context) in enumerate(results, start=1):
+        html += f"<div style='margin-bottom: 1rem; padding: 0.8rem; background-color: white; border-radius: 0.3rem; border-left: 4px solid #3498db;'>"
+        html += f"<p><strong>判決 {i}</strong></p>"
+        html += f"<p><strong>案件編號:</strong> {meta['JID']}</p>"
+        html += f"<p><strong>案件類型:</strong> {meta['JCASE']}</p>"
+        html += f"<p><strong>判決日期:</strong> {meta['JDATE']}</p>"
+        html += f"<p><strong>案件標題:</strong> {meta['JTITLE']}</p>"
+        html += f"<p><strong>PDF連結:</strong> <a href='{meta['JPDF']}' target='_blank'>查看原文</a></p>"
+        
+        # 顯示匹配上下文（若有）
+        if match_context:
+            html += f"<div style='margin-top: 0.5rem; padding: 0.5rem; background-color: #fffbea; border-radius: 0.3rem; border-left: 4px solid #f0c674;'>"
+            html += f"<p><strong>匹配內容:</strong><br>{match_context}</p>"
+            html += "</div>"
+        
+        # 添加判決內容摘要，但縮短長度
+        html += f"<div style='margin-top: 0.5rem; padding: 0.5rem; background-color: #f8f9fa; border-radius: 0.3rem;'>"
+        html += f"<p><strong>相關內容摘要:</strong><br>{text[:250]}...</p>"
+        html += "</div></div>"
+    
+    html += "</div>"
+    return html
+
+def preprocess_judgment_text(text: str) -> str:
+    """預處理判決書文本，處理可能觸發內容審查的詞彙"""
+    # 建立替換對照表，保留專業用語的原意
+    replacements = {
+        "殺人": "故意致人於死",
+        "自殺": "自我傷害",
+        "性侵": "違反性自主",
+        "強制性交": "違反性自主",
+        "毒品": "管制藥品",
+        "槍械": "危險物品",
+        "暴力": "強制力",
+        "血": "生理組織",
+    }
+    
+    # 進行替換
+    processed_text = text
+    for old, new in replacements.items():
+        processed_text = processed_text.replace(old, new)
+    
+    return processed_text
+
+def text_search(query: str, meta_data: List[Dict[str, Any]], max_results: int = 10) -> List[Tuple[int, str]]:
+    """
+    使用文本搜尋方式尋找相關判決
+    
+    Args:
+        query: 搜尋關鍵字
+        meta_data: 判決meta資料列表
+        max_results: 最大返回結果數
+        
+    Returns:
+        搜尋結果：[(索引，匹配上下文), ...]
+    """
+    results = []
+    
+    # 如果查詢字串少於2個字符，返回空結果
+    if len(query.strip()) < 2:
+        return results
+    
+    # 將查詢轉為小寫並移除特殊字符
+    clean_query = re.sub(r'[^\w\s]', '', query.lower())
+    search_terms = clean_query.split()
+    
+    # 為每個判決計算匹配分數
+    for idx, meta in enumerate(meta_data):
+        full_text = meta['JFULL'].lower()
+        
+        # 計算匹配分數和匹配上下文
+        score = 0
+        best_context = ""
+        best_score = 0
+        
+        # 對每個搜尋詞進行匹配
+        for term in search_terms:
+            if term in full_text:
+                # 完全匹配
+                term_score = len(term) * 2
+                
+                # 找出匹配詞的上下文（前後50個字符）
+                match_idx = full_text.find(term)
+                start_idx = max(0, match_idx - 50)
+                end_idx = min(len(full_text), match_idx + len(term) + 50)
+                context = "..." + meta['JFULL'][start_idx:end_idx] + "..."
+                
+                if term_score > best_score:
+                    best_score = term_score
+                    best_context = context
+                
+                score += term_score
+            else:
+                # 部分匹配（例如：搜尋ABC，找到BC）
+                for partial_size in range(len(term)-1, 0, -1):
+                    for i in range(len(term) - partial_size + 1):
+                        partial = term[i:i+partial_size]
+                        if len(partial) >= 2 and partial in full_text:  # 只考慮至少2個字符的部分
+                            partial_score = partial_size
+                            
+                            # 找出匹配詞的上下文
+                            match_idx = full_text.find(partial)
+                            start_idx = max(0, match_idx - 50)
+                            end_idx = min(len(full_text), match_idx + len(partial) + 50)
+                            context = "..." + meta['JFULL'][start_idx:end_idx] + "..."
+                            
+                            if partial_score > best_score:
+                                best_score = partial_score
+                                best_context = context
+                            
+                            score += partial_score
+                            break  # 找到第一個部分匹配就跳出
+        
+        # 如果有匹配，加入結果
+        if score > 0:
+            results.append((idx, score, best_context))
+    
+    # 根據分數排序並返回前N個結果
+    results.sort(key=lambda x: x[1], reverse=True)
+    return [(idx, context) for idx, _, context in results[:max_results]]
+
+def combined_search(query: str, k: int = 5, search_mode: str = "自動（先文本後向量）"):
+    """
+    結合文本搜尋和向量搜尋
+    
+    Args:
+        query: 搜尋查詢
+        k: 返回結果數量
+        search_mode: 搜尋模式，可選 "自動（先文本後向量）", "僅文本搜尋", "僅向量搜尋"
+        
+    Returns:
+        搜尋結果列表
+    """
+    # 根據搜尋模式選擇搜尋策略
+    if search_mode == "僅文本搜尋":
+        # 只使用文本搜尋
+        text_results = text_search(query, meta_data)
+        if not text_results:
+            return []  # 沒有找到匹配結果
+        
+        results = []
+        for idx, context in text_results[:k]:
+            judgment_meta = meta_data[idx]
+            processed_text = preprocess_judgment_text(judgment_meta['JFULL'])
+            results.append((processed_text, judgment_meta, context))
+        return results
+    
+    elif search_mode == "僅向量搜尋":
+        # 只使用向量搜尋
+        query_vector = model.encode([query])[0].astype('float32')
+        distances, indices = faiss_index.search(query_vector.reshape(1, -1), k)
+        
+        results = []
+        for idx in indices[0]:
+            judgment_meta = meta_data[idx]
+            processed_text = preprocess_judgment_text(judgment_meta['JFULL'])
+            results.append((processed_text, judgment_meta, ""))  # 無匹配上下文
+        return results
+    
+    else:  # 預設為 "自動（先文本後向量）"
+        # 先進行文本搜尋
+        text_results = text_search(query, meta_data)
+        
+        # 如果文本搜尋有結果，優先使用
+        if text_results:
+            results = []
+            for idx, context in text_results[:k]:
+                judgment_meta = meta_data[idx]
+                processed_text = preprocess_judgment_text(judgment_meta['JFULL'])
+                results.append((processed_text, judgment_meta, context))
+            return results
+        
+        # 如果文本搜尋無結果，使用向量搜尋作為備用
+        query_vector = model.encode([query])[0].astype('float32')
+        distances, indices = faiss_index.search(query_vector.reshape(1, -1), k)
+        
+        results = []
+        for idx in indices[0]:
+            judgment_meta = meta_data[idx]
+            processed_text = preprocess_judgment_text(judgment_meta['JFULL'])
+            results.append((processed_text, judgment_meta, ""))  # 無匹配上下文
+        
+        return results
+
+def respond(
+    message: str,
+    history: List[Tuple[str, str]],
+    system_message: str,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
+    show_retrieval_results: bool,
+    user_api_key: str = "",
+    k: int = 5,
+    model_name: str = "gpt-4o-mini",
+    search_mode: str = "自動（先文本後向量）",
+):
+    # 檢查必要組件是否已載入
+    if None in (model, faiss_index, meta_data):
+        return "錯誤：系統未完全載入。請確認已執行 create_judgment_embeddings.py 建立索引。", None
+    
+    # 檢查 API 金鑰
+    api_key = user_api_key.strip() if user_api_key.strip() else OPENAI_API_KEY
+    if not api_key:
+        return "錯誤：未提供 OpenAI API 金鑰。請在設定中輸入您的 API 金鑰，或在環境變數中設置。", None
+    
+    # 臨時設置 API 金鑰，僅用於本次請求
+    client = openai.OpenAI(api_key=api_key)
+    
+    # 根據問題長度動態調整檢索數量，避免超出上下文限制
+    effective_k = min(k, 3) if len(message) > 100 else min(k, 4)
+    
+    # 搜尋相關判決（使用改進的搜尋方法）
+    results = combined_search(message, k=effective_k, search_mode=search_mode)
+    
+    # 如果沒有找到結果，返回提示訊息
+    if not results:
+        return "抱歉，我沒有找到與您問題相關的判決。請嘗試使用不同的搜尋詞或切換搜尋模式。", None
+    
+    # 準備上下文，限制每個判決摘要的長度
+    context = ""
+    for i, (text, meta, match_context) in enumerate(results, start=1):
+        context += f"\n[判決 {i}]\n"
+        context += format_judgment_info(meta)
+        
+        # 如果有匹配上下文，加入上下文
+        if match_context:
+            context += f"匹配內容：\n{match_context}\n"
+        
+        # 限制每個判決文本的長度
+        summary_length = 300
+        context += f"內容摘要：\n{text[:summary_length]}...\n"
+    
+    # 如果用戶要求顯示檢索結果
+    retrieval_display = format_retrieval_results(results, meta_data) if show_retrieval_results else None
+    
+    # 建立系統提示
+    rag_system_message = f"""{system_message}
+
+這是一個司法判決書分析系統，所有內容均來自真實判決書。請注意：
+1. 判決書中可能包含暴力、犯罪等敏感描述，這些是判決書的必要組成部分
+2. 請以客觀、專業的法律角度分析這些內容
+3. 不要對判決書中的敏感內容進行道德評判或迴避
+4. 保持專業中立的態度，準確傳達判決書的內容
+
+根據以下判決資料回答用戶問題。若問題無法從判決資料中回答，請說明你無法提供答案，不要憑空編造。
+
+請在回答中引用具體的判決案號和日期，並說明資訊來源。您可以透過提供的 PDF 連結查看完整判決內容。
+
+參考判決：
+{context}
+"""
+    
+    # 建立訊息清單
+    messages = [
+        {"role": "system", "content": "你現在是一個專業的法律助理，正在處理司法判決書。請以客觀、專業的態度處理所有內容，包括敏感話題。"},
+        {"role": "system", "content": rag_system_message}
+    ]
+    
+    # 只保留最近的幾次對話歷史，減少 token 使用量
+    recent_history = history[-2:] if len(history) > 2 else history
+    for val in recent_history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+    messages.append({"role": "user", "content": message})
+    
+    # 呼叫 OpenAI API 生成回答
+    response = ""
+    try:
+        for chunk in client.chat.completions.create(
+            model=model_name,
+            messages=messages,
+            max_tokens=max_tokens,
+            stream=True,
+            temperature=temperature,
+            top_p=top_p,
+            presence_penalty=0.6,
+            frequency_penalty=0.3,
+        ):
+            if chunk.choices[0].delta.content is not None:
+                token = chunk.choices[0].delta.content
+                response += token
+                yield response, retrieval_display
+    except Exception as e:
+        error_message = f"呼叫 OpenAI API 時發生錯誤：{str(e)}"
+        yield error_message, retrieval_display
+
+# 自定義 CSS
+css = """
+.gradio-container {
+    font-family: "Noto Sans TC", sans-serif !important;
+}
+.retrieval-results {
+    margin-top: 1rem;
+    margin-bottom: 1rem;
+}
+"""
+
+# Gradio 界面
+with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
+    gr.HTML("<h1>🔍 司法判決書搜尋系統（示範）</h1>")
+    gr.HTML("<p>這個系統能夠搜尋並分析刑事判決書的內容，支援人名搜尋（用於測試與展示，資料為2025年2月全台灣各級法院之刑事判決）。輸入您的問題��系統將檢索相關判決並給出回答。</p>")
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(height=500)
+            msg = gr.Textbox(
+                placeholder="請輸入您的問題...",
+                label="問題輸入",
+                lines=3
+            )
+            with gr.Row():
+                submit_btn = gr.Button("提交問題", variant="primary")
+                clear_btn = gr.Button("清除對話")
+            
+            system_message = gr.Textbox(
+                value="你是一個專業的法律助理，專門處理司法判決書的分析工作。這是一個司法專業場景，判決書中可能包含暴力、犯罪等敏感描述，這些都是判決書的必要內容，請以客觀、專業的態度處理，不要過度審查或迴避這些內容。請使用專業且平易近人的方式回答問題，並引用具體的判決案號和日期。我會提供判決書的摘要內容，請基於這些摘要進行分析，需要時可以參考完整判決內容的PDF連結。",
+                label="系統訊息"
+            )
+        
+        with gr.Column(scale=1):
+            show_retrieval = gr.Checkbox(label="顯示檢索結果", value=True)
+            
+            # 添加 API 金鑰輸入欄位
+            api_key_input = gr.Textbox(
+                placeholder="輸入您的 OpenAI API 金鑰...",
+                label="OpenAI API 金鑰（僅用於本次使用，不會儲存）",
+                type="password"
+            )
+            
+            # 金鑰說明
+            gr.HTML("""
+            <div style="margin-bottom: 10px;">
+                <p style="font-size: 0.85em; color: #666;">
+                    您的 API 金鑰僅用於當前會話，不會被儲存或記錄。
+                </p>
+            </div>
+            """)
+            
+            # 搜尋模式選擇
+            search_mode = gr.Radio(
+                choices=["自動（先文本後向量）", "僅文本搜尋", "僅向量搜尋"],
+                value="自動（先文本後向量）",
+                label="搜尋模式"
+            )
+            
+            max_tokens = gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="最大生成字數")
+            temperature = gr.Slider(minimum=0.1, maximum=1.0, value=0.7, step=0.1, label="溫度 (Temperature)")
+            top_p = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p 採樣")
+            
+            # 模型選擇
+            model_choice = gr.Radio(
+                choices=["gpt-4o-mini", "gpt-4o"],
+                value="gpt-4o-mini",
+                label="選擇模型"
+            )
+
+            gr.Markdown("""
+            ### 📝 系統說明
+            
+            #### 參數設定
+            - **API 金鑰**：輸入您的 OpenAI API 金鑰（不會被儲存）
+            - **顯示檢索結果**：勾選後會顯示系統檢索到的原始判決內容
+            - **搜尋模式**：選擇如何搜尋判決書（直接使用AI向量搜尋可能遭遇內容審查，如需搜尋敏感詞彙或人名，請用自動或文本搜尋）
+              - **自動**：先嘗試文本搜尋，若無結果再用向量搜尋
+              - **僅文本**：使用精確字詞匹配（支持部分匹配）
+              - **僅向量**：使用語義相似度搜尋
+            - **最大生成字數**：控制 AI 回答的最大長度（1-2048）
+            - **溫度**：控制回答的創造性，越高越有創意（0.1-1.0）
+            - **Top-p 採樣**：控制用詞的多樣性（0.1-1.0）
+            - **模型選擇**：選擇不同的 OpenAI 模型
+            
+            #### 系統特點
+            - **資料來源**：2025年2月份各級法院刑事判決書（[司法院資料開放平臺](https://opendata.judicial.gov.tw/)）
+            - **向量檢索**：FAISS 向量資料庫
+            - **文本搜尋**：支持模糊匹配，例如搜尋 ABC 也可以找到 BC
+            #### 使用提示
+            1. 搜尋人名時，建議使用「文本搜尋」模式
+            2. 搜尋概念或法律問題時，建議使用「向量搜尋」模式
+            3. 「自動」模式適合大多數情況
+            """)
+    
+    retrieval_results = gr.HTML(label="檢索結果", elem_classes=["retrieval-results"])
+    
+    def user(user_message, history):
+        return "", history + [[user_message, None]]
+    
+    def bot(history, system_msg, max_tok, temp, top_p_val, show_ret, api_key, model_name, search_mode_val):
+        user_message = history[-1][0]
+        history[-1][1] = ""
+        for response, retrieval_html in respond(
+            user_message, 
+            history[:-1], 
+            system_msg, 
+            max_tok, 
+            temp, 
+            top_p_val, 
+            show_ret,
+            api_key,
+            model_name=model_name,
+            search_mode=search_mode_val
+        ):
+            history[-1][1] = response
+            if retrieval_html:
+                yield history, retrieval_html
+            else:
+                yield history, None
+    
+    def clear_history():
+        return [], None
+    
+    msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot, [chatbot, system_message, max_tokens, temperature, top_p, show_retrieval, api_key_input, model_choice, search_mode], [chatbot, retrieval_results]
+    )
+    
+    submit_btn.click(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot, [chatbot, system_message, max_tokens, temperature, top_p, show_retrieval, api_key_input, model_choice, search_mode], [chatbot, retrieval_results]
+    )
+    
+    clear_btn.click(clear_history, None, [chatbot, retrieval_results])
+
+if __name__ == "__main__":
+    demo.launch() 

create_judgment_embeddings.py

@@ -0,0 +1,96 @@
+import json
+from pathlib import Path
+from typing import List, Dict, Any
+import numpy as np
+from tqdm import tqdm
+import faiss
+from sentence_transformers import SentenceTransformer
+import pickle
+
+def load_judgments() -> List[Dict[str, Any]]:
+    """載入合併後的判決資料"""
+    file_path = Path('data_source/merged_criminal_cases.json')
+    with open(file_path, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+def create_embeddings(judgments: List[Dict[str, Any]], batch_size: int = 32) -> tuple:
+    """將判決文本轉換為 embeddings，並準備 meta 資料"""
+    # 初始化 BERT 模型，使用多語言模型以支援中文
+    model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
+    
+    # 準備文本和 meta 資料
+    texts = []
+    meta_data = []
+    
+    for judgment in judgments:
+        # 取出判決全文作為文本
+        full_text = judgment['JFULL']
+        texts.append(full_text)
+        
+        # 其他欄位作為 meta 資料，包含全文
+        meta = {
+            'JID': judgment['JID'],
+            'JYEAR': judgment['JYEAR'],
+            'JCASE': judgment['JCASE'],
+            'JNO': judgment['JNO'],
+            'JDATE': judgment['JDATE'],
+            'JTITLE': judgment['JTITLE'],
+            'JPDF': judgment['JPDF'],
+            'JFULL': full_text
+        }
+        meta_data.append(meta)
+    
+    # 批次處理文本轉換為 embeddings
+    embeddings = []
+    for i in tqdm(range(0, len(texts), batch_size), desc="生成 Embeddings"):
+        batch_texts = texts[i:i + batch_size]
+        batch_embeddings = model.encode(batch_texts, show_progress_bar=False)
+        embeddings.extend(batch_embeddings)
+    
+    embeddings_array = np.array(embeddings, dtype=np.float32)
+    return embeddings_array, meta_data
+
+def create_faiss_index(embeddings: np.ndarray) -> faiss.Index:
+    """建立 FAISS 索引"""
+    # 取得向量維度
+    dimension = embeddings.shape[1]
+    
+    # 建立索引（使用 L2 距離的 IndexFlatL2）
+    index = faiss.IndexFlatL2(dimension)
+    
+    # 將 embeddings 加入索引
+    index.add(embeddings)
+    return index
+
+def save_faiss_data(index: faiss.Index, meta_data: List[Dict[str, Any]], output_dir: str = 'faiss_data'):
+    """儲存 FAISS 索引和 meta 資料"""
+    # 建立輸出目錄
+    output_path = Path(output_dir)
+    output_path.mkdir(exist_ok=True)
+    
+    # 儲存 FAISS 索引
+    faiss.write_index(index, str(output_path / 'criminal_judgments.index'))
+    
+    # 儲存 meta 資料
+    with open(output_path / 'criminal_judgments_meta.pkl', 'wb') as f:
+        pickle.dump(meta_data, f)
+
+def main():
+    print("開始載入判決資料...")
+    judgments = load_judgments()
+    print(f"已載入 {len(judgments)} 筆判決資料")
+    
+    print("\n開始生成 embeddings...")
+    embeddings, meta_data = create_embeddings(judgments)
+    print(f"已生成 {len(embeddings)} 個 embeddings")
+    
+    print("\n建立 FAISS 索引...")
+    index = create_faiss_index(embeddings)
+    print("FAISS 索引建立完成")
+    
+    print("\n儲存資料...")
+    save_faiss_data(index, meta_data)
+    print("資料儲存完成！")
+
+if __name__ == '__main__':
+    main() 

merge_criminal_cases.py

@@ -0,0 +1,39 @@
+import os
+import json
+from pathlib import Path
+
+def merge_criminal_cases():
+    # 設定資料來源目錄
+    data_source_dir = Path('data_ori')
+    
+    # 找出所有以「刑事」結尾的資料夾
+    criminal_dirs = [d for d in data_source_dir.iterdir() if d.is_dir() and d.name.endswith('刑事')]
+    
+    # 用於存儲所有案件的列表
+    all_cases = []
+    
+    # 遍歷每個刑事資料夾
+    for criminal_dir in criminal_dirs:
+        # 遍歷資料夾中的所有 JSON 檔案
+        for json_file in criminal_dir.rglob('*.json'):
+            try:
+                with open(json_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    # 如果讀取到的是列表，則擴展到 all_cases
+                    if isinstance(data, list):
+                        all_cases.extend(data)
+                    # 如果讀取到的是字典，則添加到 all_cases
+                    elif isinstance(data, dict):
+                        all_cases.append(data)
+            except Exception as e:
+                print(f"處理檔案 {json_file} 時發生錯誤: {str(e)}")
+    
+    # 將合併後的資料寫入新的 JSON 檔案
+    output_file = 'data_source/merged_criminal_cases.json'
+    with open(output_file, 'w', encoding='utf-8') as f:
+        json.dump(all_cases, f, ensure_ascii=False, indent=2)
+    
+    print(f"已成功合併 {len(all_cases)} 筆案件資料到 {output_file}")
+
+if __name__ == '__main__':
+    merge_criminal_cases() 

rag_run.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+使用範例：
+1. 執行本程式後，會在本地產生一個 FAISS 向量索引 (faiss_index) 目錄。
+   - 若索引已經存在，即可直接載入使用，不必每次重複做 Embedding。
+2. 在互動模式下輸入問題，即可檢索並查看結果來源與時間等資訊。
+"""
+
+import os
+import glob
+import json
+import csv
+import re
+from datetime import datetime
+
+# 以下套件若未安裝，請先 pip install
+from dotenv import load_dotenv
+from docx import Document as DocxDocument
+
+# LangChain 相關套件
+import openai
+from langchain_openai import OpenAIEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain.docstore.document import Document
+
+# 載入 .env 檔案，取得 OPENAI_API_KEY
+load_dotenv()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    raise ValueError("未在 .env 檔或環境變數中找到 OPENAI_API_KEY，請確認設定。")
+
+openai.api_key = OPENAI_API_KEY
+
+# ============ 基本參數設定 ============
+CHUNK_SIZE = 500  # 每個 Chunk 大小，可視需要做調整
+CHUNK_OVERLAP = 50  # 重疊區段，避免切斷句子
+FAISS_INDEX_DIR = "faiss_index"  # 儲存 FAISS 索引的目錄
+DATA_DIR = "data_source"  # 預設的資料來源資料夾（自行調整）
+
+
+def extract_date_from_string(s: str) -> str:
+    """
+    嘗試從字串中找出 YYYY-MM-DD 或 YYYY-MM 或 YYYY 格式日期，若失敗則回傳 '未知日期'。
+    根據需求調整正則或解析邏輯。
+    """
+    # 解析 ISO 格式 (2025-03-18T04:39:36+0000) 或 YYYY-MM-DD
+    iso_pattern = r"(\d{4}-\d{1,2}-\d{1,2})"
+    match_iso = re.search(iso_pattern, s)
+    if match_iso:
+        return match_iso.group(1)
+
+    # 只抓年份 (YYYY)
+    year_pattern = r"(\d{4})"
+    match_year = re.search(year_pattern, s)
+    if match_year:
+        return f"{match_year.group(1)}-01-01"
+
+    return "未知日期"
+
+
+def read_json_file(file_path: str) -> list:
+    """
+    讀取單一 JSON 檔案，並回傳一個包含 Document-like dict 的 list。
+    每個 dict：{'text': str, 'metadata': dict}
+    """
+    docs = []
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except Exception as e:
+        print(f"讀取 JSON 檔失敗：{file_path}, {e}")
+        return docs
+
+    # 假設可能是一個 JSON 陣列，也可能是一個物件
+    if isinstance(data, dict):
+        data = [data]
+
+    for item in data:
+        text = item.get("message", "")
+        created_time = item.get("created_time", "")
+        # 若沒有 message，就跳過
+        if not text.strip():
+            continue
+
+        date_str = extract_date_from_string(created_time)
+        metadata = {
+            "source": "Facebook粉專",  # 可自行命名
+            "filename": os.path.basename(file_path),
+            "date": date_str,
+            "id": item.get("id", "unknown_id")
+        }
+        docs.append({"text": text, "metadata": metadata})
+    return docs
+
+
+def read_csv_file(file_path: str) -> list:
+    """
+    讀取 CSV 檔，假設有 date 欄和 caption (或 content) 欄。
+    回傳 list[{"text": ..., "metadata": ...}]
+    """
+    docs = []
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                caption = row.get("caption", "")
+                date_raw = row.get("date", "")
+                date_str = extract_date_from_string(date_raw)
+
+                # 若無內容則跳過
+                if not caption.strip():
+                    continue
+
+                metadata = {
+                    "source": "Instagram/其它CSV來源",  # 自行定義
+                    "filename": os.path.basename(file_path),
+                    "date": date_str,
+                    "media_id": row.get("media_id", "unknown_id")
+                }
+                docs.append({"text": caption, "metadata": metadata})
+    except Exception as e:
+        print(f"讀取 CSV 檔失敗：{file_path}, {e}")
+    return docs
+
+
+def read_docx_file(file_path: str) -> list:
+    """
+    讀取 DOCX 檔案，取得完整文字。嘗試從檔名中找日期。
+    回傳 list[{"text": ..., "metadata": ...}] (通常只會有一個元素)
+    """
+    docs = []
+    try:
+        doc = DocxDocument(file_path)
+        paragraphs = [p.text.strip() for p in doc.paragraphs if p.text.strip()]
+        full_text = "\n".join(paragraphs)
+
+        date_str = extract_date_from_string(file_path)  # 從檔名嘗試擷取年分或日期
+
+        metadata = {
+            "source": "時代力量官方文件",  # 或其他來源辨識
+            "filename": os.path.basename(file_path),
+            "date": date_str
+        }
+        if full_text.strip():
+            docs.append({"text": full_text, "metadata": metadata})
+
+    except Exception as e:
+        print(f"讀取 DOCX 檔失敗：{file_path}, {e}")
+    return docs
+
+
+def load_all_documents(data_dir: str) -> list:
+    """
+    從指定資料夾內載入所有 JSON、CSV、DOCX 檔案，並整合成一個 list。
+    回傳格式為 list[{"text": ..., "metadata": ...}, ...]
+    """
+    all_docs = []
+
+    # 搜尋 JSON
+    for json_path in glob.glob(os.path.join(data_dir, "*.json")):
+        all_docs.extend(read_json_file(json_path))
+
+    # 搜尋 CSV
+    for csv_path in glob.glob(os.path.join(data_dir, "*.csv")):
+        all_docs.extend(read_csv_file(csv_path))
+
+    # 搜尋 DOCX
+    for docx_path in glob.glob(os.path.join(data_dir, "*.docx")):
+        all_docs.extend(read_docx_file(docx_path))
+
+    return all_docs
+
+
+def chunk_documents(docs: list, chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP) -> list:
+    """
+    使用 LangChain 提供的文本切割器（RecursiveCharacterTextSplitter）進行分塊。
+    輸入: [{"text": ..., "metadata": {...}}, ...]
+    輸出: List[Document] (每個 Document 有 page_content 和 metadata)
+    """
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap
+    )
+    results = []
+    for d in docs:
+        splits = text_splitter.split_text(d["text"])
+        for chunk in splits:
+            # 將原始 metadata 帶入
+            results.append(
+                Document(
+                    page_content=chunk,
+                    metadata=d["metadata"]
+                )
+            )
+    return results
+
+
+def build_or_load_faiss_index(documents: list, index_dir=FAISS_INDEX_DIR) -> FAISS:
+    """
+    若本地已有 FAISS 索引，則直接載入；
+    若沒有，則建立並儲存到 index_dir，方便下次使用。
+    回傳 FAISS 物件。
+    """
+    # 若 index_dir 存在，就嘗試載入
+    if os.path.exists(index_dir):
+        print(f"[INFO] 發現已存在的 FAISS 索引：{index_dir}，嘗試載入...")
+        try:
+            return FAISS.load_local(index_dir, OpenAIEmbeddings(), allow_dangerous_deserialization=True)
+        except Exception as e:
+            print(f"[WARNING] 載入失敗，將重新建立索引：{e}")
+
+    # 沒有現成索引，就新建
+    print("[INFO] 建立新的 FAISS 索引...")
+    embeddings = OpenAIEmbeddings()
+
+    # 先將每個 Document 的內容和 metadata 拆開
+    texts = [doc.page_content for doc in documents]
+    metadatas = [doc.metadata for doc in documents]
+
+    # 建立向量索引
+    faiss_store = FAISS.from_texts(texts, embeddings, metadatas=metadatas)
+
+    # 儲存索引
+    faiss_store.save_local(index_dir)
+    print("[INFO] 已完成新的 FAISS 索引建立並儲存到資料夾：", index_dir)
+    return faiss_store
+
+
+def interactive_query(faiss_store: FAISS):
+    """
+    簡易互動模式，使用者可輸入問題並檢索。
+    """
+    print("\n[進入互動模式] 輸入 'exit' 結束。")
+
+    while True:
+        query = input("請輸入查詢問題: ").strip()
+        if query.lower() in ["exit", "quit", "q", "離開"]:
+            print("結束互動模式。")
+            break
+
+        # 相似度檢索
+        results = faiss_store.similarity_search(query, k=5)
+        print(f"\n[檢索到 {len(results)} 筆相似度最高的內容，以下顯示結果]\n")
+
+        for i, doc in enumerate(results, start=1):
+            source = doc.metadata.get("source", "未知來源")
+            date = doc.metadata.get("date", "未知日期")
+            filename = doc.metadata.get("filename", "未知檔名")
+            snippet = doc.page_content[:150].replace("\n", " ")
+            print(f"--- 結果 {i} ---")
+            print(f"來源: {source}")
+            print(f"日期: {date}")
+            print(f"檔名: {filename}")
+            print(f"內容摘要: {snippet}...")
+            print("-------------------------\n")
+
+def main():
+    # 1. 載入資料
+    all_docs_raw = load_all_documents(DATA_DIR)
+    if not all_docs_raw:
+        print(f"在資料夾 {DATA_DIR} 中未找到任何檔案，請確認！")
+        return
+
+    print(f"[INFO] 成功載入資料：共 {len(all_docs_raw)} 筆（未分塊）")
+
+    # 2. 分塊
+    chunked_docs = chunk_documents(all_docs_raw, CHUNK_SIZE, CHUNK_OVERLAP)
+    print(f"[INFO] 分塊後文件總數：{len(chunked_docs)}")
+
+    # 3. 建立或載入 FAISS 索引
+    faiss_store = build_or_load_faiss_index(chunked_docs, FAISS_INDEX_DIR)
+
+    # 4. 進入互動式查詢
+    interactive_query(faiss_store)
+
+
+
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+huggingface_hub==0.25.2
+dotenv
+gradio>=3.50.0
+openai>=1.3.0
+python-dotenv>=1.0.0
+faiss-cpu>=1.7.4
+numpy>=1.25.0
+sentence-transformers>=2.2.2
+tqdm>=4.65.0