Update app.py

app.py

@@ -12,29 +12,30 @@ from typing import List, Dict, Tuple, Optional
 import numpy as np
 
 # ==================== 配置區 ====================
-HF_TOKEN = os.environ.get("HF_TOKEN", "您的_HuggingFace_Token")
+HF_TOKEN = os.environ.get("HF_TOKEN", None) # 建議從環境變數讀取
 DATASET_REPO_ID = "Paul720810/Text-to-SQL-Softline"
-SIMILARITY_THRESHOLD = 0.75
+SIMILARITY_THRESHOLD = 0.6
 
-# 多個備用LLM模型
+# 多個備用LLM模型 (注意：在當前邏輯中並未使用)
 LLM_MODELS = [
     "https://api-inference.huggingface.co/models/gpt2",
-    "https://api-inference.huggingface.co/models/distilgpt2", 
+    "https://api-inference.huggingface.co/models/distilgpt2",
     "https://api-inference.huggingface.co/models/microsoft/DialoGPT-small"
 ]
 
 print("=" * 60)
 print("🤖 智能 Text-to-SQL 系統啟動中...")
-print("📊 模式: 讀取全部4276條數據（包含空白SQL）")
+print(f"📊 模式: 讀取全部數據（來自 {DATASET_REPO_ID}）")
 print("=" * 60)
 
-# ==================== 增強工具函數 ====================
+# ==================== 獨立工具函數 (不依賴類別實例) ====================
 def get_current_time():
+    """獲取當前時間字串"""
     return datetime.now().strftime("%H:%M:%S")
 
 def validate_sql(sql_query: str) -> Dict:
-    """驗證SQL語句的安全性"""
-    if not sql_query or sql_query.strip() == "":
+    """驗證SQL語句的語法和安全性"""
+    if not sql_query or not sql_query.strip():
         return {"valid": False, "issues": ["SQL語句為空"], "is_safe": False, "empty": True}
     
     sql_clean = sql_query.strip()
@@ -47,7 +48,7 @@ def validate_sql(sql_query: str) -> Dict:
     # 檢查危險操作
     dangerous_keywords = ['DROP', 'DELETE', 'INSERT', 'UPDATE', 'ALTER', 'TRUNCATE', 'EXEC', 'EXECUTE']
     for keyword in dangerous_keywords:
-        if f" {keyword} " in sql_upper:
+        if f" {keyword} " in f" {sql_upper} ":
             security_issues.append(f"危險操作: {keyword}")
     
     # 檢查基本語法
@@ -57,15 +58,18 @@ def validate_sql(sql_query: str) -> Dict:
     if "FROM" not in sql_upper:
         security_issues.append("缺少FROM")
     
+    is_valid = not security_issues
+    is_safe = all('危險' not in issue for issue in security_issues)
+    
     return {
-        "valid": len(security_issues) == 0,
+        "valid": is_valid,
         "issues": security_issues,
-        "is_safe": len([i for i in security_issues if '危險' in i]) == 0,
+        "is_safe": is_safe,
         "empty": False
     }
 
 def analyze_question_type(question: str) -> Dict:
-    """分析問題類型"""
+    """分析問題類型和關鍵詞"""
     question_lower = question.lower()
     
     analysis = {
@@ -79,26 +83,24 @@ def analyze_question_type(question: str) -> Dict:
     
     # 檢測關鍵詞
     keywords_sets = {
-        "sales": ["銷售", "業績", "金額", "收入", "sale", "revenue", "金額"],
-        "customer": ["客戶", "買家", "用戶", "customer", "client", "買家"],
-        "product": ["產品", "商品", "項目", "product", "item", "產品"],
-        "time": ["時間", "日期", "月份", "年", "月", "最近", "date", "month", "year", "時間"],
-        "report": ["報告", "完成", "份", "report", "complete", "報告"],
-        "count": ["多少", "幾個", "數量", "count", "how many", "多少"],
-        "comparison": ["比較", "vs", " versus", "對比", "相比", "比較"]
+        "sales": ["銷售", "業績", "金額", "收入", "sale", "revenue"],
+        "customer": ["客戶", "買家", "用戶", "customer", "client"],
+        "product": ["產品", "商品", "項目", "product", "item"],
+        "time": ["時間", "日期", "月份", "年", "月", "最近", "date", "month", "year"],
+        "report": ["報告", "完成", "份", "report", "complete"],
+        "count": ["多少", "幾個", "數量", "count", "how many"],
+        "comparison": ["比較", "vs", " versus", "對比", "相比"]
     }
     
     for category, keywords in keywords_sets.items():
-        for keyword in keywords:
-            if keyword in question_lower:
-                if category not in analysis["keywords"]:
-                    analysis["keywords"].append(category)
-    
+        if any(keyword in question_lower for keyword in keywords):
+            analysis["keywords"].append(category)
+
     # 特殊檢測
-    analysis["has_count"] = any(kw in question_lower for kw in keywords_sets["count"])
-    analysis["has_date"] = any(kw in question_lower for kw in keywords_sets["time"])
+    analysis["has_count"] = "count" in analysis["keywords"]
+    analysis["has_date"] = "time" in analysis["keywords"]
     analysis["has_group"] = any(word in question_lower for word in ["每", "各", "group", "每個"])
-    analysis["has_comparison"] = any(kw in question_lower for kw in keywords_sets["comparison"])
+    analysis["has_comparison"] = "comparison" in analysis["keywords"]
     
     # 確定主要類型
     if analysis["keywords"]:
@@ -106,57 +108,6 @@ def analyze_question_type(question: str) -> Dict:
     
     return analysis
 
-def generate_sql_from_question(question: str, analysis: Dict) -> str:
-    """根據問題分析生成智能SQL"""
-    question_lower = question.lower()
-    question_type = analysis["type"]
-    
-    # 針對常見問題模式的SQL生成
-    if "每月" in question_lower and ("完成" in question_lower or "報告" in question_lower):
-        year_match = re.search(r'(\d{4})年', question_lower)
-        year = year_match.group(1) if year_match else "2023"
-        return f"SELECT strftime('%Y-%m', completion_date) as month, COUNT(*) as report_count FROM reports WHERE strftime('%Y', completion_date) = '{year}' GROUP BY month ORDER BY month;"
-    
-    elif "銷售" in question_lower and ("最高" in question_lower or "最好" in question_lower):
-        return "SELECT product_name, SUM(sales_amount) as total_sales FROM sales GROUP BY product_name ORDER BY total_sales DESC LIMIT 10;"
-    
-    elif "客戶" in question_lower and ("訂單" in question_lower or "購買" in question_lower):
-        return "SELECT customer_name, COUNT(*) as order_count, SUM(order_amount) as total_spent FROM orders GROUP BY customer_name ORDER BY total_spent DESC;"
-    
-    elif "比較" in question_lower and ("年" in question_lower or "年份" in question_lower):
-        return "SELECT strftime('%Y', order_date) as year, COUNT(*) as order_count, SUM(order_amount) as yearly_revenue FROM orders GROUP BY year ORDER BY year;"
-    
-    elif "庫存" in question_lower and ("不足" in question_lower or "缺少" in question_lower):
-        return "SELECT product_name, stock_quantity FROM products WHERE stock_quantity < 10 ORDER BY stock_quantity ASC;"
-    
-    # 根據分析結果生成通用SQL
-    if analysis["has_count"] and analysis["has_group"] and analysis["has_date"]:
-        return "SELECT strftime('%Y-%m', date_column) as period, COUNT(*) as item_count FROM appropriate_table GROUP BY period ORDER BY period;"
-    
-    elif analysis["has_count"] and analysis["has_group"]:
-        return "SELECT category_column, COUNT(*) as count FROM appropriate_table GROUP BY category_column ORDER BY count DESC;"
-    
-    elif analysis["has_count"]:
-        return "SELECT COUNT(*) as total_count FROM appropriate_table;"
-    
-    elif analysis["has_group"]:
-        return "SELECT group_column, AVG(value_column) as average_value FROM appropriate_table GROUP BY group_column;"
-    
-    else:
-        return "SELECT * FROM appropriate_table LIMIT 10;"
-
-def repair_empty_sql(original_sql: str, user_question: str, similar_question: str) -> str:
-    """修復空白SQL"""
-    if not original_sql or original_sql.strip() == "":
-        # 分析問題並生成合適的SQL
-        analysis = analyze_question_type(user_question)
-        repaired_sql = generate_sql_from_question(user_question, analysis)
-        
-        # 添加註釋說明這是修復的SQL
-        return f"-- 根據類似問題 '{similar_question}' 修復生成的SQL\n{repaired_sql}"
-    
-    return original_sql
-
 # ==================== 完整數據加載模塊 ====================
 class CompleteDataLoader:
     def __init__(self, hf_token: str):
@@ -173,9 +124,7 @@ class CompleteDataLoader:
             raw_dataset = load_dataset(DATASET_REPO_ID, token=self.hf_token)['train']
             
             print("解析全部 messages 格式...")
-            total_count = 0
-            empty_count = 0
-            valid_count = 0
+            total_count, empty_count, valid_count = 0, 0, 0
             
             for item in raw_dataset:
                 try:
@@ -191,7 +140,7 @@ class CompleteDataLoader:
                         sql_match = re.search(r'SQL查詢:\s*(.*?)(?:\n|$)', assistant_content, re.DOTALL)
                         if sql_match:
                             sql_query = sql_match.group(1).strip()
-                            sql_query = re.sub(r'^sql\s*', '', sql_query)
+                            sql_query = re.sub(r'^sql\s*', '', sql_query, flags=re.IGNORECASE)
                             sql_query = re.sub(r'```sql|```', '', sql_query).strip()
                         else:
                             sql_query = assistant_content
@@ -210,8 +159,7 @@ class CompleteDataLoader:
                             empty_count += 1
                         if validation["valid"]:
                             valid_count += 1
-                            
-                except Exception as e:
+                except Exception:
                     continue
             
             print(f"數據加載完成: 總數 {total_count}, 有效 {valid_count}, 空白 {empty_count}")
@@ -239,13 +187,39 @@ class CompleteDataLoader:
             self.schema_data = {}
             return False
 
+# ==================== 檢索系統 ====================
+class RetrievalSystem:
+    def __init__(self):
+        try:
+            self.embedder = SentenceTransformer('all-MiniLM-L6-v2', device='cpu')
+            self.question_embeddings = None
+        except Exception as e:
+            print(f"SentenceTransformer 模型加載���敗: {e}")
+            self.embedder = None
+
+    def compute_embeddings(self, questions: List[str]) -> None:
+        if self.embedder and questions:
+            print(f"正在為 {len(questions)} 個問題計算向量...")
+            self.question_embeddings = self.embedder.encode(questions, convert_to_tensor=True, show_progress_bar=True)
+            print("向量計算完成")
+    
+    def retrieve_similar(self, user_question: str, top_k: int = 5) -> List[Dict]:
+        if self.embedder is None or self.question_embeddings is None or len(self.question_embeddings) == 0:
+            return []
+        try:
+            question_embedding = self.embedder.encode(user_question, convert_to_tensor=True)
+            hits = util.semantic_search(question_embedding, self.question_embeddings, top_k=top_k)
+            return hits[0] if hits and hits[0] else []
+        except Exception as e:
+            print(f"檢索錯誤: {e}")
+            return []
+
 # ==================== 主系統 ====================
 class CompleteTextToSQLSystem:
     def __init__(self, hf_token: str):
         self.hf_token = hf_token
         self.data_loader = CompleteDataLoader(hf_token)
         self.retrieval_system = RetrievalSystem()
-        
         self.initialize_system()
     
     def initialize_system(self):
@@ -255,20 +229,93 @@ class CompleteTextToSQLSystem:
         self.data_loader.load_complete_dataset()
         self.data_loader.load_schema()
         
-        # 為所有問題計算向量（包括空白SQL的）
+        # 為所有問題計算向量
         if self.data_loader.questions:
             self.retrieval_system.compute_embeddings(self.data_loader.questions)
         
         print(f"系統初始化完成，載入問題總數: {len(self.data_loader.questions)}")
-    
+
+    # ===== 輔助函數 (作為類別方法) =====
+    def get_available_tables(self) -> Dict:
+        """從schema中獲取所有可用的表和欄位"""
+        if not self.data_loader.schema_data:
+            return {}
+        
+        tables = {}
+        for table_name, columns_list in self.data_loader.schema_data.items():
+            if isinstance(columns_list, list):
+                column_names = [col["name"] for col in columns_list if "name" in col]
+                tables[table_name] = column_names
+        
+        return tables
+        
+    def extract_number(self, text: str, default: int = 10) -> int:
+        """從文字中提取數字"""
+        numbers = re.findall(r'\d+', text)
+        return int(numbers[0]) if numbers else default
+
+    def generate_sql_from_question(self, question: str, analysis: Dict) -> str:
+        """根據問題分析和真實Schema生成智能SQL"""
+        question_lower = question.lower()
+        available_tables = self.get_available_tables().keys()
+        
+        # 1. 每月/每日完成數量 - 使用 JobTimeline 相關表
+        if any(kw in question_lower for kw in ["每月", "每日", "昨天", "完成"]) and analysis["has_count"]:
+            group_match = re.search(r'([a-z]組)', question_lower)
+            if group_match:
+                group = group_match.group(1).replace('組', '').upper()
+                group_mapping = {'A': 'TA', 'B': 'TB', 'C': 'TC', 'D': 'TD'}
+                table_suffix = group_mapping.get(group, 'TA')
+                table_name = f"JobTimeline_{table_suffix}"
+                
+                if "昨天" in question_lower:
+                    return f"SELECT COUNT(*) as 完成數量 FROM {table_name} WHERE DATE(end_time) = DATE('now','-1 day');"
+                elif "每月" in question_lower:
+                    year_match = re.search(r'(\d{4})年?', question_lower)
+                    year = year_match.group(1) if year_match else datetime.now().strftime('%Y')
+                    return f"""SELECT strftime('%Y-%m', end_time) as 月份, COUNT(*) as 完成數量 FROM {table_name} WHERE strftime('%Y', end_time) = '{year}' AND end_time IS NOT NULL GROUP BY strftime('%Y-%m', end_time) ORDER BY 月份;"""
+            return "SELECT strftime('%Y-%m', jt.end_time) as 月份, COUNT(*) as 完成數量 FROM JobTimeline jt WHERE jt.end_time IS NOT NULL GROUP BY strftime('%Y-%m', jt.end_time) ORDER BY 月份;"
+
+        # 2. 評級分析 - 使用 TSR53SampleDescription.OverallRating
+        elif any(kw in question_lower for kw in ["評級", "rating", "等級"]) and "TSR53SampleDescription" in available_tables:
+            if any(kw in question_lower for kw in ["分佈", "統計", "多少"]):
+                return "SELECT OverallRating as 評級, COUNT(*) as 數量, ROUND(COUNT(*) * 100.0 / (SELECT COUNT(*) FROM TSR53SampleDescription), 2) as 百分比 FROM TSR53SampleDescription WHERE OverallRating IS NOT NULL GROUP BY OverallRating ORDER BY 數量 DESC;"
+            elif "fail" in question_lower or "失敗" in question_lower:
+                return "SELECT JobNo as 工作單號, ApplicantName as 申請方, OverallRating as 評級 FROM TSR53SampleDescription WHERE OverallRating = 'Fail' ORDER BY JobNo;"
+
+        # 3. 金額相���查詢 - 使用 TSR53Invoice
+        elif any(kw in question_lower for kw in ["金額", "總額", "收入", "invoice"]) and any(kw in question_lower for kw in ["最高", "最大", "top"]):
+            limit_num = self.extract_number(question_lower, default=10)
+            return f"""WITH JobTotalAmount AS (SELECT JobNo, SUM(LocalAmount) AS TotalAmount FROM (SELECT DISTINCT JobNo, InvoiceCreditNoteNo, LocalAmount FROM TSR53Invoice WHERE LocalAmount IS NOT NULL) GROUP BY JobNo) SELECT jta.JobNo as 工作單號, sd.ApplicantName as 申請方, jta.TotalAmount as 總金額 FROM JobTotalAmount jta JOIN TSR53SampleDescription sd ON sd.JobNo = jta.JobNo ORDER BY jta.TotalAmount DESC LIMIT {limit_num};"""
+
+        # 4. 公司/客戶相關查詢
+        elif any(kw in question_lower for kw in ["公司", "客戶", "申請方", "付款方"]):
+            if any(kw in question_lower for kw in ["最多", "top", "排名"]):
+                return "SELECT ApplicantName as 申請方名稱, COUNT(*) as 工作單數量 FROM TSR53SampleDescription WHERE ApplicantName IS NOT NULL GROUP BY ApplicantName ORDER BY 工作單數量 DESC LIMIT 10;"
+            return "SELECT ApplicantName as 申請方, InvoiceToName as 付款方, COUNT(*) as 工作單數量 FROM TSR53SampleDescription WHERE ApplicantName IS NOT NULL GROUP BY ApplicantName, InvoiceToName ORDER BY 工作單數量 DESC;"
+
+        # ... 其他規則可以繼續添加 ...
+
+        # 預設查詢 - 顯示基本工作單資訊
+        return "SELECT JobNo as 工作單號, ApplicantName as 申請方, InvoiceToName as 付款方, OverallRating as 評級 FROM TSR53SampleDescription LIMIT 20;"
+
+    def repair_empty_sql(self, original_sql: str, user_question: str, similar_question: str) -> str:
+        """修復空白或無效的SQL"""
+        validation = validate_sql(original_sql)
+        if not validation["valid"]:
+            analysis = analyze_question_type(user_question)
+            repaired_sql = self.generate_sql_from_question(user_question, analysis)
+            return f"-- 根據類似問題 '{similar_question}' (原SQL無效) 自動生成的查詢\n{repaired_sql}"
+        return original_sql
+
     def generate_sql(self, user_question: str) -> Tuple[str, str]:
-        """生成SQL查詢 - 處理所有數據"""
+        """主流程：生成SQL查詢"""
         log_messages = [f"⏰ {get_current_time()} 開始處理"]
         
-        if not user_question or user_question.strip() == "":
+        if not user_question or not user_question.strip():
             return "請輸入您的問題。", "錯誤: 問題為空"
         
-        # 1. 檢索最相似的問題（從所有4276條中）
+        # 1. 檢索最相似的問題
         if self.data_loader.questions:
             hits = self.retrieval_system.retrieve_similar(user_question)
             
@@ -278,119 +325,92 @@ class CompleteTextToSQLSystem:
                 corpus_id = best_hit['corpus_id']
                 similar_question = self.data_loader.questions[corpus_id]
                 original_sql = self.data_loader.sql_answers[corpus_id]
-                sql_quality = self.data_loader.sql_quality[corpus_id]
                 
-                log_messages.append(f"🔍 檢索到: '{similar_question}'")
-                log_messages.append(f"📊 相似度: {similarity_score:.3f}, 質量分數: {sql_quality:.1f}")
+                log_messages.append(f"🔍 檢索到最相似問題: '{similar_question}'")
+                log_messages.append(f"📊 相似度: {similarity_score:.3f}")
                 
                 if similarity_score > SIMILARITY_THRESHOLD:
-                    # 檢查並修復SQL（如果是空白的）
-                    validation = validate_sql(original_sql)
-                    
-                    if validation["empty"] or not validation["valid"]:
-                        log_messages.append(f"⚠️ 原始SQL需要修復: {', '.join(validation['issues'])}")
-                        log_messages.append("🛠️ 正在智能修復SQL...")
-                        
-                        repaired_sql = repair_empty_sql(original_sql, user_question, similar_question)
-                        log_messages.append("✅ 修復完成")
-                        
-                        return repaired_sql, "\n".join(log_messages)
-                    else:
-                        log_messages.append(f"✅ 相似度 > {SIMILARITY_THRESHOLD}，使用預先SQL")
-                        return original_sql, "\n".join(log_messages)
+                    repaired_sql = self.repair_empty_sql(original_sql, user_question, similar_question)
+                    log_messages.append(f"✅ 相似度高於閾值 {SIMILARITY_THRESHOLD}，採用檢索結果。")
+                    return repaired_sql, "\n".join(log_messages)
                 else:
-                    log_messages.append(f"ℹ️ 相似度 {similarity_score:.3f} 低於閾值 {SIMILARITY_THRESHOLD}")
-        
+                    log_messages.append(f"ℹ️ 相似度低於閾值 {SIMILARITY_THRESHOLD}，轉為智能生成���")
+
         # 2. 如果檢索失敗或相似度不足，智能生成SQL
-        log_messages.append("🤖 智能生成SQL...")
+        log_messages.append("🤖 找不到高相似度結果，啟用智能生成規則...")
         analysis = analyze_question_type(user_question)
-        intelligent_sql = generate_sql_from_question(user_question, analysis)
+        intelligent_sql = self.generate_sql_from_question(user_question, analysis)
         
-        log_messages.append(f"📋 問題分析: {analysis['type']}類型")
-        log_messages.append("✅ 智能生成完成")
+        log_messages.append(f"📋 問題分析: {analysis['type']} 類型, 關鍵詞: {analysis['keywords']}")
+        log_messages.append("✅ 智能生成完成。")
         
         return intelligent_sql, "\n".join(log_messages)
 
-# ==================== 其他類定義 ====================
-class LLMClient:
-    def __init__(self, hf_token: str):
-        self.hf_token = hf_token
-    
-    def call_llm_api(self, prompt: str) -> Optional[str]:
-        headers = {"Authorization": f"Bearer {self.hf_token}"}
-        payload = {"inputs": prompt, "parameters": {"max_new_tokens": 200, "temperature": 0.1}}
-        
-        for model_url in LLM_MODELS:
-            try:
-                response = requests.post(model_url, headers=headers, json=payload, timeout=15)
-                if response.status_code == 200:
-                    result = response.json()
-                    if isinstance(result, list) and len(result) > 0:
-                        return result[0]['generated_text'].strip()
-            except:
-                continue
-        return None
-
-class RetrievalSystem:
-    def __init__(self):
-        self.embedder = SentenceTransformer('all-MiniLM-L6-v2', device='cpu')
-        self.question_embeddings = None
-    
-    def compute_embeddings(self, questions: List[str]) -> None:
-        if questions:
-            print(f"正在為 {len(questions)} 個問題計算向量...")
-            self.question_embeddings = self.embedder.encode(questions, convert_to_tensor=True, show_progress_bar=False)
-            print("向量計算完成")
-    
-    def retrieve_similar(self, user_question: str, top_k: int = 5) -> List[Dict]:
-        if self.question_embeddings is None or len(self.question_embeddings) == 0:
-            return []
-        try:
-            question_embedding = self.embedder.encode(user_question, convert_to_tensor=True)
-            hits = util.semantic_search(question_embedding, self.question_embeddings, top_k=top_k)
-            return hits[0] if hits and hits[0] else []
-        except Exception as e:
-            print(f"檢索錯誤: {e}")
-            return []
-
 # ==================== 初始化系統 ====================
-print("正在初始化完整數據Text-to-SQL系統...")
-text_to_sql_system = CompleteTextToSQLSystem(HF_TOKEN)
+print("準備初始化 Text-to-SQL 系統...")
+# 檢查 HF_TOKEN 是否存在
+if HF_TOKEN is None:
+    print("\n" + "="*60)
+    print("⚠️ 警告: Hugging Face Token 未設置。")
+    print("請在環境變數中設定 HF_TOKEN 才能從私人數據集下載資料。")
+    print("="*60 + "\n")
+    # 這裡可以選擇退出或繼續，但下載會失敗
+    text_to_sql_system = None
+else:
+    text_to_sql_system = CompleteTextToSQLSystem(HF_TOKEN)
 
 # ==================== Gradio界面 ====================
-def process_query(user_question: str) -> Tuple[str, str]:
+def process_query(user_question: str) -> Tuple[str, str, str]:
+    if text_to_sql_system is None:
+        error_msg = "系統因缺少 Hugging Face Token 而未成功初始化。"
+        return "系統未初始化", error_msg, error_msg
+
     sql_result, log_message = text_to_sql_system.generate_sql(user_question)
     return sql_result, "✅ SQL生成完成", log_message
 
-with gr.Blocks(title="智能Text-to-SQL系統", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚀 智能 Text-to-SQL 系統")
-    gr.Markdown("📊 完整模式: 讀取全部4276條數據")
+with gr.Blocks(title="智慧Text-to-SQL系統", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🚀 智慧 Text-to-SQL 系統")
+    gr.Markdown("📊 **模式**: 讀取雲端數據集並結合「檢索」與「規則生成」兩種模式。")
     
     with gr.Row():
         question_input = gr.Textbox(
-            label="📝 輸入問題", 
-            placeholder="例如：2023年每月完成多少份報告", 
-            lines=2,
+            label="📝 請在此輸入您的問題", 
+            placeholder="例如：2023年每月完成多少份報告？ 或 哪個客戶的訂單總金額最高？", 
+            lines=3,
             scale=4
         )
         submit_btn = gr.Button("🚀 生成SQL", variant="primary", scale=1)
     
-    with gr.Row():
+    with gr.Accordion("🔍 結果與日誌", open=True):
         sql_output = gr.Code(
-            label="📊 生成的SQL", 
+            label="📊 生成的SQL查詢", 
             language="sql", 
-            lines=6
+            lines=8
         )
-    
-    with gr.Row():
-        debug_output = gr.Textbox(label="🔍 狀態", lines=2, interactive=False)
-        log_output = gr.Textbox(label="📋 詳細日誌", lines=4, interactive=False)
-    
+        status_output = gr.Textbox(label="🔍 執行狀態", interactive=False)
+        log_output = gr.Textbox(label="📋 詳細日誌", lines=5, interactive=False)
+    
+    # 預設範例
+    gr.Examples(
+        examples=[
+            "昨天完成了多少個工作單?",
+            "A組每月完成數量是多少？",
+            "哪個申請方的失敗評級最多？",
+            "找出總金額最高的10筆訂單",
+            "統計所有評級的分佈"
+        ],
+        inputs=question_input
+    )
+
     submit_btn.click(
         process_query, 
         inputs=question_input, 
-        outputs=[sql_output, debug_output, log_output]
+        outputs=[sql_output, status_output, log_output]
     )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    print("Gradio 介面啟動中...")
+    if text_to_sql_system is None:
+        print("無法啟動 Gradio，因為系統初始化失敗。")
+    else:
+        demo.launch(server_name="0.0.0.0", server_port=7860, share=False)