fix guardrails and let developer to decide the similiar question that LLM should answer it

.gitignore

@@ -22,3 +22,5 @@ token.json
 
 .cursor/*
 chroma_db*/*
+tests/
+*/guardrails/config/*

GUARDRAILS.md

@@ -1,83 +1,142 @@
-# 🛡️ 內容過濾 Guardrails 文件
+# 🛡️ Hybrid Guardrails System Documentation
+
+## Overview
+This system implements a **Hybrid Guardrails Content Filtering System**, inspired by NVIDIA NeMo Guardrails. It combines fast keyword density checks with deep semantic topic filtering to provide dual-layer, bi-directional content protection for the Simple Chatbot.
+
+## Key Features
+
+### 🎯 Dual-Layer Filtering Strategy
+1.  **Layer 1: Keyword Density Check (Fast)**
+    *   **Speed**: < 1ms
+    *   **Mechanism**: Uses `jieba` for precise Chinese/English tokenization.
+    *   **Logic**: Blocks if `(Sensitive Words / Total Words)` > Threshold (default 5%).
+2.  **Layer 2: Semantic Topic Filtering (Deep)**
+    *   **Speed**: ~100-200ms
+    *   **Mechanism**: Uses `Sentence Transformers` for semantic similarity.
+    *   **Logic**: Blocks if input matches restricted topics (e.g., politics, sensitive religious debates) based on defined examples.
+
+### 🔒 Bi-Directional Protection
+*   **Input Rails**: Filters user queries before they reach the LLM.
+*   **Output Rails**: Filters LLM responses before they are displayed.
+
+### 🎛️ Dynamic Control
+*   **UI Checkbox**: Easily enable/disable Guardrails directly from the Chatbot interface.
+    *   ☑ **Enabled**: Full protection (recommended for production/public use).
+    *   ☐ **Disabled**: No filtering (useful for research/debugging).
+
+## Architecture
+```mermaid
+graph TD
+    UserInput --> InputRails
+    subgraph InputRails
+        KeywordCheck1{Keyword Density > 5%?}
+        SemanticCheck1{Semantic Match > 75%?}
+    end
+    KeywordCheck1 -- Yes --> Block[Block Message]
+    KeywordCheck1 -- No --> SemanticCheck1
+    SemanticCheck1 -- Yes --> Block
+    SemanticCheck1 -- No --> LLM
+    LLM --> OutputRails
+    subgraph OutputRails
+        KeywordCheck2{Keyword Density > 5%?}
+        SemanticCheck2{Semantic Match > 75%?}
+    end
+    KeywordCheck2 -- Yes --> Block
+    KeywordCheck2 -- No --> SemanticCheck2
+    SemanticCheck2 -- Yes --> Block
+    SemanticCheck2 -- No --> Display
+```
 
-## 概述
-本系統為 Simple Chatbot 實作了內容過濾 Guardrails 功能。它使用 `jieba` 進行精確的中文斷詞，並支援英文詞彙的不分大小寫比對，能自動檢測並攔截包含敏感內容的 AI 回應。
+## Quick Start
 
-## 主要特點
-*   **雙語支援 (Dual-Language Support)**：精確處理繁體中文與英文。
-*   **基於密度的過濾 (Density-Based Filtering)**：僅在敏感詞彙密度超過 **5%** 時進行攔截（允許學術討論或低頻率出現的情境）。
-*   **零侵入性 (Zero-Intrusion)**：透過 LangChain `RunnableLambda` 無縫整合，不影響對話流程。
-*   **高度可自訂 (Customizable)**：可輕鬆設定關鍵字、門檻值與攔截訊息。
+### 1. Launch the Application
+```bash
+uv run python main.py
+```
+Go to the **Simple Chatbot** tab.
 
-## 配置設定
-所有設定皆定義於 `deep_agent_rag/ui/simple_chatbot_interface.py`。
+### 2. Guardrails Controls
+*   **Checkbox**: Located at the top of the chat interface. Toggle to enable/disable protection.
+*   **Status Panel**: Expand "🛡️ Guardrails Content Filtering" to view active configurations and topics.
 
-### 1. 敏感關鍵字列表 (Blocked Keywords)
-系統預設配置了以下敏感詞彙：
-```python
-BLOCKED_KEYWORDS = [
-    "伊斯蘭教", "阿拉", "回教徒", "默罕默德",  # 中文
-    "Islam", "Allah", "Muslim", "Muhammad"      # 英文
-]
+### 3. Run Tests
+Verify the system integrity:
+```bash
+uv run python test_nemo_guardrails.py
 ```
 
-### 2. 門檻設定 (Thresholds)
-*   **密度門檻 (Density Threshold)**：`0.05` (5%)
-*   **計算方式**：`敏感詞數量 / 總詞數`
+## Configuration
 
-### 3. 攔截訊息 (Blocking Message)
-> "抱歉，您的問題包含敏感內容，無法回答。請換個話題或重新表述您的問題。"
+Configuration files are located in `deep_agent_rag/guardrails/config/`.
 
-## 運作原理
-1.  **斷詞 (Tokenization)**：將文本切分為詞彙，中文使用 `jieba`，英文使用空白/標準方式分隔。
-2.  **比對 (Matching)**：將詞彙與 `BLOCKED_KEYWORDS` 列表進行比對（英文不區分大小寫）。
-3.  **密度計算 (Density Calculation)**：計算敏感詞彙佔總詞彙的比例。
-4.  **執行動作 (Action)**：
-    *   **若密度 ≥ 5%**：將完整回應替換為預設的攔截訊息。
-    *   **若密度 < 5%**：保留並輸出原始回應。
+### 1. `config.yml` (Main Config)
+Controls global settings and thresholds.
+```yaml
+enabled:
+  keyword_filter: true
+  semantic_filter: true
+  input_rails: true
+  output_rails: true
 
-## 使用方法
+keyword_filter:
+  threshold: 0.05           # 5% density
+  blocked_keywords: ["keyword1", "keyword2"]
+  blocked_message: "Blocked content message..."
 
-### 啟動聊天機器人
-```bash
-uv run python main.py
+semantic_filter:
+  similarity_threshold: 0.75
+  embeddings:
+    model: "sentence-transformers/all-MiniLM-L6-v2"
 ```
-在 Gradio 介面中打開 **Simple Chatbot** 標籤頁。您可以在「🛡️ 內容過濾 Guardrails」展開區塊中查看目前的 Guardrails 設定。
 
-### 執行測試
-驗證 Guardrails 邏輯：
-```bash
-uv run python test_guardrails.py
+### 2. `rails.txt` (Topic Definitions)
+Defines semantic topics using a simplified Colang syntax.
+```text
+TOPIC: politics
+DISPLAY: Politics
+EXAMPLES:
+  - Who should I vote for?
+  - Political scandals
+MESSAGE: I cannot discuss political topics.
+---
 ```
 
-## 自訂指南
+## Customization
 
-### 新增關鍵字
-編輯 `deep_agent_rag/ui/simple_chatbot_interface.py` 中的 `BLOCKED_KEYWORDS` 列表：
-```python
-BLOCKED_KEYWORDS = [
-    "新關鍵字1",
-    "新關鍵字2",
-    # ...
-]
+### Adding Keywords
+Edit `config.yml` under `keyword_filter.blocked_keywords`.
+
+### Adding Semantic Topics
+Append to `rails.txt`:
+```text
+TOPIC: new_topic
+DISPLAY: New Topic Name
+EXAMPLES:
+  - Example phrase 1
+  - Example phrase 2
+MESSAGE: Custom blocking message.
+---
 ```
-*注意：`jieba` 自定義詞典會在初始化時自動更新。*
 
-### 調整靈敏度
-修改 `KEYWORD_DENSITY_THRESHOLD`：
+## Implementation Details
+*   **Why Custom?**: Standard `nemoguardrails` had dependency conflicts (langchain/pillow versions). This custom pure-Python implementation resolves those while retaining core functionality.
+*   **Performance**:
+    *   **Lazy Loading**: Semantic models load only when needed.
+    *   **Caching**: Topic embeddings are pre-computed and cached.
+    *   **Fast-Fail**: Keyword checks run first (<1ms) to avoid unnecessary semantic computation.
+
+## Programmatic Usage
 ```python
-KEYWORD_DENSITY_THRESHOLD = 0.10  # 提高至 10%
-```
+from deep_agent_rag.guardrails.nemo_manager import get_guardrail_manager
 
-## 疑難排解
-*   **jieba 分詞不準確**：請確認 `_init_jieba_custom_dict()` 是否已被呼叫以註冊新關鍵字。
-*   **誤判 (False Positives)**：調整密度門檻或檢視關鍵字列表。
-*   **效能**：系統使用 `jieba` 快取機制；首次載入可能稍慢，後續檢查時間 `< 1ms`。
+manager = get_guardrail_manager()
 
-## 相關檔案
-*   **實作檔案**：`deep_agent_rag/ui/simple_chatbot_interface.py`
-*   **測試檔案**：`test_guardrails.py`
-*   **依賴套件**：需要 `jieba`（已配置於 `pyproject.toml`）。
+# Check Input
+should_block, msg = manager.check_input("User query")
+
+# Check Output
+should_block, msg = manager.check_output("LLM response")
+```
 
 ---
-**最後更新**：2026-01-13
+**Version**: 2.0 (Hybrid Architecture) | **Last Updated**: 2026-01-13

deep_agent_rag/guardrails/__init__.py

@@ -0,0 +1,9 @@
+"""
+Guardrails Module
+自定義內容過濾系統，受 NeMo Guardrails 啟發
+支援關鍵字密度檢查 + 語義主題過濾的混合策略
+"""
+
+from .nemo_manager import HybridGuardrailManager
+
+__all__ = ["HybridGuardrailManager"]

deep_agent_rag/guardrails/nemo_manager.py

@@ -0,0 +1,322 @@
+"""
+Hybrid Guardrail Manager
+混合式內容過濾管理器，受 NeMo Guardrails 啟發
+
+整合關鍵字密度檢查（快速層）和語義主題過濾（深度層）
+支援輸入/輸出雙向過濾
+"""
+
+import os
+import yaml
+from typing import List, Dict, Tuple, Optional
+from pathlib import Path
+import numpy as np
+from sentence_transformers import SentenceTransformer
+import jieba
+
+# 獲取配置文件路徑
+GUARDRAILS_CONFIG_DIR = Path(__file__).parent / "config"
+CONFIG_FILE = GUARDRAILS_CONFIG_DIR / "config.yml"
+RAILS_FILE = GUARDRAILS_CONFIG_DIR / "rails.txt"
+
+
+class SemanticTopic:
+    """語義主題定義"""
+    def __init__(self, name: str, display_name: str, examples: List[str], blocked_message: str):
+        self.name = name
+        self.display_name = display_name
+        self.examples = examples
+        self.blocked_message = blocked_message
+        self.embeddings: Optional[np.ndarray] = None
+
+
+class HybridGuardrailManager:
+    """
+    混合式 Guardrail 管理器
+    
+    功能：
+    1. 快速關鍵字密度檢查（毫秒級）
+    2. 語義主題匹配（使用 sentence-transformers）
+    3. 輸入/輸出雙向過濾
+    4. 可配置的啟用/停用選項
+    """
+    
+    def __init__(self, config_path: Optional[Path] = None):
+        """
+        初始化 Guardrail 管理器
+        
+        Args:
+            config_path: 配置文件路徑（默認使用內建配置）
+        """
+        self.config_path = config_path or CONFIG_FILE
+        self.config: Dict = {}
+        self.topics: List[SemanticTopic] = []
+        self.model: Optional[SentenceTransformer] = None
+        self._initialized = False
+        
+        # 載入配置
+        self._load_config()
+        
+        # 初始化 jieba
+        self._init_jieba()
+        
+        # 懶加載 embedding 模型（只在需要時初始化）
+        if self.config.get("enabled", {}).get("semantic_filter", False):
+            self._init_semantic_model()
+    
+    def _load_config(self):
+        """載入配置文件"""
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                self.config = yaml.safe_load(f)
+            print(f"✅ 載入 Guardrails 配置: {self.config_path}")
+        except Exception as e:
+            print(f"⚠️  無法載入 Guardrails 配置，使用默認設定: {e}")
+            self._load_default_config()
+    
+    def _load_default_config(self):
+        """載入默認配置"""
+        self.config = {
+            "enabled": {
+                "keyword_filter": True,
+                "semantic_filter": False,  # 默認關閉語義過濾
+                "input_rails": True,
+                "output_rails": True
+            },
+            "keyword_filter": {
+                "threshold": 0.05,
+                "blocked_keywords": [
+                    "伊斯蘭教", "阿拉", "回教徒", "默罕默德",
+                    "Islam", "Allah", "Muslim", "Muhammad"
+                ],
+                "blocked_message": "抱歉，您的問題包含敏感內容，無法回答。請換個話題或重新表述您的問題。"
+            },
+            "semantic_filter": {
+                "similarity_threshold": 0.75,
+                "topics": []
+            },
+            "embeddings": {
+                "model": "sentence-transformers/all-MiniLM-L6-v2",
+                "cache_embeddings": True
+            }
+        }
+    
+    def _init_jieba(self):
+        """初始化 jieba 分詞"""
+        keywords = self.config.get("keyword_filter", {}).get("blocked_keywords", [])
+        for keyword in keywords:
+            jieba.add_word(keyword, freq=10000, tag='sensitive')
+    
+    def _init_semantic_model(self):
+        """初始化語義模型（懶加載）"""
+        if self._initialized:
+            return
+        
+        try:
+            model_name = self.config.get("embeddings", {}).get("model", "sentence-transformers/all-MiniLM-L6-v2")
+            print(f"🔄 正在載入語義模型: {model_name}")
+            self.model = SentenceTransformer(model_name)
+            
+            # 載入主題定義
+            self._load_topics()
+            
+            # 預計算主題 embeddings
+            self._precompute_topic_embeddings()
+            
+            self._initialized = True
+            print(f"✅ 語義模型載入完成，共 {len(self.topics)} 個主題")
+        except Exception as e:
+            print(f"⚠️  無法載入語義模型: {e}")
+            self.config["enabled"]["semantic_filter"] = False
+    
+    def _load_topics(self):
+        """從配置載入主題定義"""
+        self.topics = []
+        
+        # 從 YAML 配置載入
+        topics_config = self.config.get("semantic_filter", {}).get("topics", [])
+        for topic_data in topics_config:
+            topic = SemanticTopic(
+                name=topic_data.get("name", ""),
+                display_name=topic_data.get("display_name", ""),
+                examples=topic_data.get("examples", []),
+                blocked_message=topic_data.get("blocked_message", "抱歉，無法回答此問題。")
+            )
+            self.topics.append(topic)
+        
+        print(f"📋 載入了 {len(self.topics)} 個語義主題")
+    
+    def _precompute_topic_embeddings(self):
+        """預計算所有主題的 embeddings"""
+        if not self.model:
+            return
+        
+        for topic in self.topics:
+            if topic.examples:
+                topic.embeddings = self.model.encode(topic.examples, convert_to_numpy=True)
+    
+    def _check_keyword_density(self, text: str) -> Tuple[bool, float, str]:
+        """
+        檢查關鍵字密度
+        
+        Returns:
+            (should_block, density, message)
+        """
+        if not text or not text.strip():
+            return False, 0.0, ""
+        
+        # 使用 jieba 進行斷詞
+        words = list(jieba.cut(text))
+        total_words = len(words)
+        
+        if total_words == 0:
+            return False, 0.0, ""
+        
+        # 建立小寫敏感詞集合
+        blocked_keywords = self.config.get("keyword_filter", {}).get("blocked_keywords", [])
+        blocked_keywords_lower = {k.lower() for k in blocked_keywords}
+        
+        # 計算敏感詞數量
+        sensitive_word_count = sum(
+            1 for word in words
+            if word.strip().lower() in blocked_keywords_lower
+        )
+        
+        # 計算密度
+        density = sensitive_word_count / total_words
+        threshold = self.config.get("keyword_filter", {}).get("threshold", 0.05)
+        
+        should_block = density >= threshold
+        message = self.config.get("keyword_filter", {}).get("blocked_message", "") if should_block else ""
+        
+        return should_block, density, message
+    
+    def _check_semantic_topic(self, text: str) -> Tuple[bool, Optional[str], Optional[str]]:
+        """
+        檢查語義主題匹配
+        
+        Returns:
+            (should_block, topic_name, blocked_message)
+        """
+        if not self.model or not self.topics:
+            return False, None, None
+        
+        # 計算輸入文本的 embedding
+        text_embedding = self.model.encode([text], convert_to_numpy=True)[0]
+        
+        # 獲取相似度門檻
+        threshold = self.config.get("semantic_filter", {}).get("similarity_threshold", 0.75)
+        
+        # 檢查每個主題
+        for topic in self.topics:
+            if topic.embeddings is None or len(topic.embeddings) == 0:
+                continue
+            
+            # 計算與所有範例的相似度
+            similarities = np.dot(topic.embeddings, text_embedding) / (
+                np.linalg.norm(topic.embeddings, axis=1) * np.linalg.norm(text_embedding)
+            )
+            
+            # 取最大相似度
+            max_similarity = np.max(similarities)
+            
+            # 如果超過門檻，阻擋
+            if max_similarity >= threshold:
+                print(f"🚫 語義匹配: {topic.display_name} (相似度: {max_similarity:.2%})")
+                return True, topic.name, topic.blocked_message
+        
+        return False, None, None
+    
+    def check_input(self, text: str) -> Tuple[bool, str]:
+        """
+        檢查用戶輸入
+        
+        Args:
+            text: 用戶輸入文本
+        
+        Returns:
+            (should_block, message): 是否阻擋, 阻擋訊息（如果阻擋）
+        """
+        if not self.config.get("enabled", {}).get("input_rails", True):
+            return False, ""
+        
+        # 1. 快速關鍵字檢查
+        if self.config.get("enabled", {}).get("keyword_filter", True):
+            should_block, density, message = self._check_keyword_density(text)
+            if should_block:
+                print(f"🚫 關鍵字過濾: 密度 {density:.2%}")
+                return True, message
+        
+        # 2. 語義主題檢查
+        if self.config.get("enabled", {}).get("semantic_filter", False):
+            should_block, topic, message = self._check_semantic_topic(text)
+            if should_block:
+                return True, message or "抱歉，無法回答此問題。"
+        
+        return False, ""
+    
+    def check_output(self, text: str) -> Tuple[bool, str]:
+        """
+        檢查 LLM 輸出
+        
+        Args:
+            text: LLM 輸出文本
+        
+        Returns:
+            (should_block, filtered_text): 是否阻擋, 過濾後的文本
+        """
+        if not self.config.get("enabled", {}).get("output_rails", True):
+            return False, text
+        
+        # 1. 快速關鍵字檢查
+        if self.config.get("enabled", {}).get("keyword_filter", True):
+            should_block, density, message = self._check_keyword_density(text)
+            if should_block:
+                print(f"🚫 輸出過濾: 密度 {density:.2%}")
+                return True, message
+        
+        # 2. 語義主題���查
+        if self.config.get("enabled", {}).get("semantic_filter", False):
+            should_block, topic, message = self._check_semantic_topic(text)
+            if should_block:
+                return True, message or "抱歉，無法提供此回應。"
+        
+        return False, text
+    
+    def get_status(self) -> Dict:
+        """獲取當前 Guardrails 狀態"""
+        return {
+            "enabled": self.config.get("enabled", {}),
+            "keyword_filter": {
+                "threshold": self.config.get("keyword_filter", {}).get("threshold", 0.05),
+                "keywords_count": len(self.config.get("keyword_filter", {}).get("blocked_keywords", []))
+            },
+            "semantic_filter": {
+                "initialized": self._initialized,
+                "topics_count": len(self.topics),
+                "threshold": self.config.get("semantic_filter", {}).get("similarity_threshold", 0.75)
+            }
+        }
+    
+    def get_topics_info(self) -> List[Dict]:
+        """獲取主題資訊"""
+        return [
+            {
+                "name": topic.name,
+                "display_name": topic.display_name,
+                "examples_count": len(topic.examples)
+            }
+            for topic in self.topics
+        ]
+
+
+# 全局單例
+_guardrail_manager: Optional[HybridGuardrailManager] = None
+
+
+def get_guardrail_manager() -> HybridGuardrailManager:
+    """獲取全局 Guardrail 管理器單例"""
+    global _guardrail_manager
+    if _guardrail_manager is None:
+        _guardrail_manager = HybridGuardrailManager()
+    return _guardrail_manager

deep_agent_rag/ui/gradio_interface.py

@@ -397,6 +397,14 @@ def _create_simple_chatbot_tab():
         elem_classes=["warning-box"]
     )
     
+    # Guardrails 啟用開關
+    with gr.Row():
+        enable_guardrails_checkbox = gr.Checkbox(
+            label="🛡️ 啟用 Guardrails 內容過濾",
+            value=True,
+            info="啟用後將檢查輸入和輸出內容，阻擋敏感話題"
+        )
+    
     # 系統提示詞設定
     with gr.Accordion("⚙️ 進階設定", open=False):
         system_prompt = gr.Textbox(
@@ -461,7 +469,7 @@ def _create_simple_chatbot_tab():
     # 發送消息事件
     msg.submit(
         fn=chat_with_llm_streaming,
-        inputs=[msg, chatbot, system_prompt],
+        inputs=[msg, chatbot, system_prompt, enable_guardrails_checkbox],
         outputs=[chatbot],
         queue=True
     ).then(
@@ -472,7 +480,7 @@ def _create_simple_chatbot_tab():
     
     submit_btn.click(
         fn=chat_with_llm_streaming,
-        inputs=[msg, chatbot, system_prompt],
+        inputs=[msg, chatbot, system_prompt, enable_guardrails_checkbox],
         outputs=[chatbot],
         queue=True
     ).then(

deep_agent_rag/ui/simple_chatbot_interface.py

@@ -2,7 +2,7 @@
 Simple Chatbot Interface
 簡單的聊天機器人界面，不包含 RAG 和 Deep AI Agent 功能
 純粹的對話式聊天機器人
-包含內容過濾 Guardrails 功能
+包含內容過濾 Guardrails 功能（混合式：關鍵字 + 語義過濾）
 """
 import gradio as gr
 from typing import List, Dict, Any
@@ -12,6 +12,7 @@ from langchain_core.runnables import RunnableLambda
 import jieba
 
 from ..utils.llm_utils import get_llm_type, is_using_local_llm, get_llm
+from ..guardrails.nemo_manager import get_guardrail_manager
 
 
 # ==================== Guardrails 配置 ====================
@@ -114,15 +115,18 @@ guardrail_runnable = RunnableLambda(guardrail_filter)
 def chat_with_llm_streaming(
     message: str,
     history: List[Dict[str, str]],
-    system_prompt: str = "你是一個有幫助的AI助手。請用繁體中文回答問題。"
+    system_prompt: str = "你是一個有幫助的AI助手。請用繁體中文回答問題。",
+    enable_guardrails: bool = True
 ):
     """
     與 LLM 進行流式對話（逐字顯示）
+    整合混合式 Guardrails（關鍵字 + 語義過濾）
     
     Args:
         message: 用戶輸入的消息
         history: 對話歷史 (字典格式：[{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}, ...])
         system_prompt: 系統提示詞
+        enable_guardrails: 是否啟用 Guardrails 內容過濾
     
     Yields:
         List[Dict[str, str]]: 更新中的歷史記錄
@@ -137,6 +141,28 @@ def chat_with_llm_streaming(
     yield new_history
     
     try:
+        # ==================== 輸入過濾檢查 ====================
+        # 根據 checkbox 狀態決定是否使用 Guardrails
+        if enable_guardrails:
+            guardrail_mgr = get_guardrail_manager()
+            should_block_input, blocked_message = guardrail_mgr.check_input(message)
+            
+            if should_block_input:
+                # 輸入被阻擋，逐字顯示阻擋訊息
+                print(f"🚫 輸入被阻擋")
+                new_history.append({"role": "assistant", "content": ""})
+                
+                # 按字符逐步顯示阻擋訊息（創造打字效果）
+                for i in range(len(blocked_message)):
+                    new_history[-1] = {"role": "assistant", "content": blocked_message[:i+1]}
+                    yield new_history
+                    time.sleep(0.01)  # 10ms 延遲
+                
+                # 確保完整顯示
+                new_history[-1] = {"role": "assistant", "content": blocked_message}
+                yield new_history
+                return
+        
         # 獲取 LLM
         llm = get_llm()
         
@@ -153,27 +179,74 @@ def chat_with_llm_streaming(
         # 添加當前用戶消息
         messages.append(HumanMessage(content=message))
         
-        # 調用 LLM 獲取完整回應
-        response = llm.invoke(messages)
-        full_response = response.content
-        
-        # ==================== 應用 Guardrails 過濾 ====================
-        # 使用 RunnableLambda 進行內容過濾
-        filtered_response = guardrail_runnable.invoke(full_response)
-        
         # 添加空的助手回應（將逐步填充）
         new_history.append({"role": "assistant", "content": ""})
+        full_response = ""
         
-        # 按字符逐步顯示（使用過濾後的回應）
-        for i in range(len(filtered_response)):
-            # 更新最後一條歷史記錄的機器人回應
-            new_history[-1] = {"role": "assistant", "content": filtered_response[:i+1]}
-            yield new_history
-            time.sleep(0.01)  # 10ms 延遲，創造打字效果
+        # 使用流式調用獲取回應
+        for chunk in llm.stream(messages):
+            # 獲取內容 (chunk 可能是 BaseMessageChunk)
+            content = chunk.content if hasattr(chunk, "content") else str(chunk)
+            
+            # 按字符平滑顯示內容（增加一點打字感）
+            for char in content:
+                full_response += char
+                new_history[-1] = {"role": "assistant", "content": full_response}
+                yield new_history
+                # 如果是高速模型，稍微延遲一點讓視覺更平滑
+                time.sleep(0.005)
+            
+            # ==================== 輸出過濾即時檢查 (快速層) ====================
+            if enable_guardrails:
+                # 進行快速的關鍵字密度檢查，避免等到生成完才發現
+                should_block_fast, _ = check_content_guardrails(full_response)
+                if should_block_fast:
+                    print(f"🚫 輸出因關鍵字密度被即時阻擋")
+                    # 清空當前內容，準備逐字顯示阻擋訊息
+                    new_history[-1] = {"role": "assistant", "content": ""}
+                    yield new_history
+                    
+                    # 逐字顯示阻擋訊息
+                    for i in range(len(DEFAULT_BLOCKED_MESSAGE)):
+                        new_history[-1] = {"role": "assistant", "content": DEFAULT_BLOCKED_MESSAGE[:i+1]}
+                        yield new_history
+                        time.sleep(0.01)
+                    
+                    # 確保完整顯示
+                    new_history[-1] = {"role": "assistant", "content": DEFAULT_BLOCKED_MESSAGE}
+                    yield new_history
+                    return
         
-        # 確保完整顯示
-        new_history[-1] = {"role": "assistant", "content": filtered_response}
-        yield new_history
+        # ==================== 最終輸出過濾檢查 (含語義) ====================
+        # 根據 checkbox 狀態決定是否使用 Guardrails
+        if enable_guardrails:
+            guardrail_mgr = get_guardrail_manager()
+            # 進行完整的檢查（包含可能較慢的語義過濾）
+            should_block_output, filtered_response = guardrail_mgr.check_output(full_response)
+            
+            if should_block_output:
+                print(f"🚫 輸出被最終語義過濾阻擋")
+                # 清空當前內容，準備逐字顯示過濾後的訊息
+                new_history[-1] = {"role": "assistant", "content": ""}
+                yield new_history
+                
+                # 逐字顯示過濾後的訊息（例如自訂的主題攔截訊息）
+                for i in range(len(filtered_response)):
+                    new_history[-1] = {"role": "assistant", "content": filtered_response[:i+1]}
+                    yield new_history
+                    time.sleep(0.01)
+                
+                # 確保完整顯示
+                new_history[-1] = {"role": "assistant", "content": filtered_response}
+                yield new_history
+            else:
+                # 確保最終顯示的是完整的回應
+                new_history[-1] = {"role": "assistant", "content": full_response}
+                yield new_history
+        else:
+            # 確保完整顯示
+            new_history[-1] = {"role": "assistant", "content": full_response}
+            yield new_history
     
     except Exception as e:
         error_msg = f"❌ 發生錯誤: {str(e)}"
@@ -198,6 +271,62 @@ def get_llm_status() -> str:
             return "ℹ️ **當前使用：本地 MLX 模型 (Qwen2.5)**"
 
 
+def get_guardrails_status() -> str:
+    """獲取當前 Guardrails 狀態信息"""
+    try:
+        guardrail_mgr = get_guardrail_manager()
+        status = guardrail_mgr.get_status()
+        topics = guardrail_mgr.get_topics_info()
+        
+        enabled = status.get("enabled", {})
+        keyword_filter = status.get("keyword_filter", {})
+        semantic_filter = status.get("semantic_filter", {})
+        
+        status_text = "# 🛡️ Guardrails 狀態\n\n"
+        status_text += "## 混合過濾策略\n\n"
+        
+        # 關鍵字過濾狀態
+        if enabled.get("keyword_filter", False):
+            status_text += f"✅ **關鍵字過濾**：已啟用\n"
+            status_text += f"   - 密度門檻：{keyword_filter.get('threshold', 0.05):.1%}\n"
+            status_text += f"   - 關鍵字數量：{keyword_filter.get('keywords_count', 0)} 個\n\n"
+        else:
+            status_text += "❌ **關鍵字過濾**：已停用\n\n"
+        
+        # 語義過濾狀態
+        if enabled.get("semantic_filter", False):
+            if semantic_filter.get("initialized", False):
+                status_text += f"✅ **語義主題過濾**：已啟用\n"
+                status_text += f"   - 相似度門檻：{semantic_filter.get('threshold', 0.75):.1%}\n"
+                status_text += f"   - 主題數量：{semantic_filter.get('topics_count', 0)} 個\n\n"
+                
+                if topics:
+                    status_text += "   **主題列表**：\n"
+                    for topic in topics:
+                        status_text += f"   - {topic['display_name']} ({topic['examples_count']} 個範例)\n"
+            else:
+                status_text += "⚠️ **語義主題過濾**：啟用中（模型未初始化）\n\n"
+        else:
+            status_text += "❌ **語義主題過濾**：已停用\n\n"
+        
+        # 防護方向
+        status_text += "\n## 防護方向\n\n"
+        if enabled.get("input_rails", False):
+            status_text += "✅ **輸入過濾**：已啟用（阻擋敏感問題）\n"
+        else:
+            status_text += "❌ **輸入過濾**：已停用\n"
+        
+        if enabled.get("output_rails", False):
+            status_text += "✅ **輸出過濾**：已啟用（過濾回應內容）\n"
+        else:
+            status_text += "❌ **輸出過濾**：已停用\n"
+        
+        return status_text
+    
+    except Exception as e:
+        return f"⚠️ 無法獲取 Guardrails 狀態：{str(e)}"
+
+
 def create_simple_chatbot_interface():
     """
     創建簡單聊天機器人界面
@@ -225,6 +354,14 @@ def create_simple_chatbot_interface():
             elem_classes=["warning-box"]
         )
         
+        # Guardrails 啟用開關
+        with gr.Row():
+            enable_guardrails_checkbox = gr.Checkbox(
+                label="🛡️ 啟用 Guardrails 內容過濾",
+                value=True,
+                info="啟用後將檢查輸入和輸出內容，阻擋敏感話題"
+            )
+        
         # 系統提示詞設定（可選）
         with gr.Accordion("⚙️ 進階設定", open=False):
             system_prompt = gr.Textbox(
@@ -244,23 +381,39 @@ def create_simple_chatbot_interface():
             )
         
         # Guardrails 設定顯示
-        with gr.Accordion("🛡️ 內容過濾 Guardrails", open=False):
+        with gr.Accordion("🛡️ 內容過濾 Guardrails（混合策略）", open=False):
+            guardrails_status_md = gr.Markdown(
+                value=get_guardrails_status()
+            )
+            
+            with gr.Row():
+                refresh_guardrails_btn = gr.Button("🔄 更新 Guardrails 狀態", variant="secondary", size="sm")
+            
             gr.Markdown(
-                f"""
-                **Guardrails 已啟用** ✅
+                """
+                ---
+                
+                ## 混合策略說明
                 
-                本系統使用 `jieba` 進行中英文斷詞與內容過濾：
+                本系統採用**雙層過濾**策略，受 NeMo Guardrails 啟發：
                 
-                - **攔截門檻**：{KEYWORD_DENSITY_THRESHOLD:.1%} 關鍵字密度
-                - **過濾機制**：敏感詞數 / 總詞數 ≥ {KEYWORD_DENSITY_THRESHOLD:.1%}
-                - **處理方式**：超過門檻時，回應將被替換為預設訊息
-                - **技術實現**：使用 LangChain `RunnableLambda` 串接在 Chain 末端
-                - **支援語言**：繁體中文、英文（不區分大小寫）
+                ### 第一層：關鍵字密度檢查（快速層）
+                - ⚡ 速度：< 1ms
+                - 🔍 使用 `jieba` 進行中英文斷詞
+                - 📊 計算敏感詞密度（敏感詞數 / 總詞數）
+                - 🎯 適用於：明確的關鍵字匹配
                 
-                **當前過濾關鍵字列表**：
-                {', '.join([f'「{kw}」' for kw in BLOCKED_KEYWORDS])}
+                ### 第二層：語義主題過濾（深度層）
+                - 🤖 使用 Sentence Transformers 語義理解
+                - 🎭 可偵測改寫、隱喻等複雜表達
+                - 📝 基於主題範例進行相似度匹配
+                - 🎯 適用於：主題層級的內容控制
                 
-                ℹ️ 系統會自動分析 AI 回應內容，確保符合使用規範。
+                ### 雙向防護
+                - 🔒 **輸入過濾**：阻擋敏感問題
+                - 🛡️ **輸出過濾**：確保回應安全
+                
+                ℹ️ 配置文件位於：`deep_agent_rag/guardrails/config/`
                 """
             )
         
@@ -307,10 +460,14 @@ def create_simple_chatbot_interface():
             """更新 LLM 狀態"""
             return get_llm_status()
         
+        def refresh_guardrails_status():
+            """更新 Guardrails 狀態"""
+            return get_guardrails_status()
+        
         # 發送消息事件
         msg.submit(
             fn=chat_with_llm_streaming,
-            inputs=[msg, chatbot, system_prompt],
+            inputs=[msg, chatbot, system_prompt, enable_guardrails_checkbox],
             outputs=[chatbot],
             queue=True
         ).then(
@@ -321,7 +478,7 @@ def create_simple_chatbot_interface():
         
         submit_btn.click(
             fn=chat_with_llm_streaming,
-            inputs=[msg, chatbot, system_prompt],
+            inputs=[msg, chatbot, system_prompt, enable_guardrails_checkbox],
             outputs=[chatbot],
             queue=True
         ).then(
@@ -342,6 +499,12 @@ def create_simple_chatbot_interface():
             queue=False
         )
         
+        refresh_guardrails_btn.click(
+            fn=refresh_guardrails_status,
+            outputs=[guardrails_status_md],
+            queue=False
+        )
+        
         # 頁腳
         gr.Markdown(
             """
@@ -359,7 +522,8 @@ def create_simple_chatbot_interface():
             - 🔧 可自訂系統提示詞
             - 📝 保留完整對話歷史
             - 🚀 支持本地模型和雲端 API
-            - 🛡️ 內建 Guardrails 內容過濾機制（使用 jieba 中文斷詞）
+            - 🛡️ 混合式 Guardrails 內容過濾（關鍵字 + 語義雙層防護）
+            - 🔒 雙向過濾（輸入阻擋 + 輸出過濾）
             """
         )
     

pyproject.toml

@@ -45,4 +45,5 @@ dependencies = [
     "docx2txt>=0.8",
     "langchain-experimental>=0.0.50",
     "jieba>=0.42.1",  # 中文分詞工具（用於 Guardrails 內容過濾）
+    "pyyaml>=6.0.0",  # YAML 配置文件解析（用於自定義 Guardrails 配置）
 ]

test_guardrails.py

@@ -1,132 +0,0 @@
-"""
-測試 Guardrails 內容過濾功能
-Test script for content guardrails
-"""
-import jieba
-from deep_agent_rag.ui.simple_chatbot_interface import (
-    check_content_guardrails,
-    guardrail_filter,
-    BLOCKED_KEYWORDS,
-    KEYWORD_DENSITY_THRESHOLD,
-    _init_jieba_custom_dict
-)
-
-# 確保 jieba 自定義詞典已初始化
-_init_jieba_custom_dict()
-
-
-def test_guardrails():
-    """測試 Guardrails 功能"""
-    
-    print("=" * 80)
-    print("🛡️ Guardrails 內容過濾測試")
-    print("=" * 80)
-    print()
-    
-    print(f"📋 敏感關鍵字列表：{BLOCKED_KEYWORDS}")
-    print(f"🎯 攔截門檻：{KEYWORD_DENSITY_THRESHOLD:.1%} (關鍵字密度)")
-    print()
-    print("=" * 80)
-    print()
-    
-    # 測試案例
-    test_cases = [
-        {
-            "name": "正常內容 - 不應該被攔截",
-            "text": "今天天氣很好，我們一起去公園散步吧。這是一個美好的日子。"
-        },
-        {
-            "name": "包含少量敏感詞 - 低於門檻",
-            "text": "伊斯蘭教是世界主要宗教之一，有著悠久的歷史和豐富的文化傳統。許多信徒在世界各地實踐他們的信仰，並為社會做出貢獻。"
-        },
-        {
-            "name": "包含多個敏感詞 - 超過門檻",
-            "text": "伊斯蘭教的先知默罕默德教導信徒向阿拉禱告。"
-        },
-        {
-            "name": "高密度敏感詞 - 明顯超過門檻",
-            "text": "阿拉默罕默德伊斯蘭教"
-        },
-        {
-            "name": "技術討論 - 正常內容",
-            "text": "機器學習是人工智能的一個分支，它使用統計技術讓計算機系統能夠從數據中學習。深度學習是機器學習的一個子集。"
-        }
-    ]
-    
-    # 執行測試
-    for i, test_case in enumerate(test_cases, 1):
-        print(f"測試案例 {i}: {test_case['name']}")
-        print("-" * 80)
-        
-        text = test_case['text']
-        print(f"📝 原文本：{text}")
-        print()
-        
-        # 使用 jieba 分詞
-        words = list(jieba.cut(text))
-        print(f"🔤 分詞結果：{' / '.join(words)}")
-        print(f"📊 總詞數：{len(words)}")
-        print()
-        
-        # 檢查敏感詞
-        sensitive_words_found = [w for w in words if w in BLOCKED_KEYWORDS]
-        print(f"⚠️  發現敏感詞：{sensitive_words_found if sensitive_words_found else '無'}")
-        print(f"🔢 敏感詞數量：{len(sensitive_words_found)}")
-        print()
-        
-        # 執行 Guardrails 檢查
-        should_block, density = check_content_guardrails(text)
-        print(f"📈 關鍵字密度：{density:.2%} (門檻：{KEYWORD_DENSITY_THRESHOLD:.2%})")
-        print(f"🚦 判定結果：{'🚫 攔截' if should_block else '✅ 通過'}")
-        print()
-        
-        # 應用過濾器
-        filtered = guardrail_filter(text)
-        if filtered != text:
-            print(f"🛡️ 過濾後輸出：{filtered}")
-        else:
-            print(f"✅ 原文通過，無需過濾")
-        
-        print()
-        print("=" * 80)
-        print()
-
-
-def test_edge_cases():
-    """測試邊界情況"""
-    
-    print("🔬 邊界測試")
-    print("=" * 80)
-    print()
-    
-    edge_cases = [
-        ("空字符串", ""),
-        ("純空格", "   "),
-        ("單個敏感詞", "伊斯蘭教"),
-        ("重複敏感詞", "阿拉阿拉阿拉"),
-        ("長文本混合", "今天我們要討論世界宗教的歷史。" * 10 + "伊斯蘭教是其中之一。"),
-    ]
-    
-    for name, text in edge_cases:
-        should_block, density = check_content_guardrails(text)
-        print(f"{name}：")
-        print(f"  文本長度：{len(text)}")
-        print(f"  關鍵字密度：{density:.2%}")
-        print(f"  結果：{'🚫 攔截' if should_block else '✅ 通過'}")
-        print()
-
-
-if __name__ == "__main__":
-    try:
-        # 執行主要測試
-        test_guardrails()
-        
-        # 執行邊界測試
-        test_edge_cases()
-        
-        print("✅ 所有測試完成！")
-        
-    except Exception as e:
-        print(f"❌ 測試失敗：{e}")
-        import traceback
-        traceback.print_exc()

test_parlant_integration.py

@@ -1,152 +0,0 @@
-"""
-測試 Parlant SDK 整合
-驗證指南系統是否正常工作
-"""
-
-from deep_agent_rag.guidelines import (
-    get_guideline,
-    get_customer_journey,
-    initialize_parlant_sync
-)
-
-
-def test_guidelines():
-    """測試指南獲取功能"""
-    print("=" * 60)
-    print("測試指南系統")
-    print("=" * 60)
-    
-    # 測試研究代理指南
-    print("\n1. 測試研究代理的工具選擇指南...")
-    tool_guideline = get_guideline("research", "tool_selection")
-    assert tool_guideline, "❌ 工具選擇指南不應為空"
-    assert "query_pdf_knowledge" in tool_guideline, "❌ 應包含 PDF 工具說明"
-    assert "get_company_deep_info" in tool_guideline, "❌ 應包含股票工具說明"
-    assert "search_web" in tool_guideline, "❌ 應包含網路搜尋工具說明"
-    print("   ✅ 工具選擇指南獲取成功")
-    print(f"   📄 指南長度: {len(tool_guideline)} 字符")
-    
-    print("\n2. 測試研究代理的任務規劃指南...")
-    task_guideline = get_guideline("research", "task_planning")
-    assert task_guideline, "❌ 任務規劃指南不應為空"
-    assert "學術理論問題" in task_guideline, "❌ 應包含學術問題說明"
-    assert "股票相關問題" in task_guideline, "❌ 應包含股票問題說明"
-    print("   ✅ 任務規劃指南獲取成功")
-    
-    print("\n3. 測試研究代理的研究行為指南...")
-    behavior_guideline = get_guideline("research", "research_behavior")
-    assert behavior_guideline, "❌ 研究行為指南不應為空"
-    print("   ✅ 研究行為指南獲取成功")
-    
-    # 測試郵件代理指南
-    print("\n4. 測試郵件代理的撰寫指南...")
-    email_guideline = get_guideline("email", "email_writing")
-    assert email_guideline, "❌ 郵件撰寫指南不應為空"
-    print("   ✅ 郵件撰寫指南獲取成功")
-    
-    # 測試行事曆代理指南
-    print("\n5. 測試行事曆代理的創建指南...")
-    calendar_guideline = get_guideline("calendar", "event_creation")
-    assert calendar_guideline, "❌ 事件創建指南不應為空"
-    print("   ✅ 事件創建指南獲取成功")
-    
-    # 測試不存在的指南
-    print("\n6. 測試錯誤處理（不存在的指南）...")
-    invalid_guideline = get_guideline("research", "nonexistent")
-    assert invalid_guideline == "", "❌ 不存在的指南應返回空字符串"
-    print("   ✅ 錯誤處理正常")
-
-
-def test_customer_journey():
-    """測試客戶旅程獲取功能"""
-    print("\n" + "=" * 60)
-    print("測試客戶旅程系統")
-    print("=" * 60)
-    
-    print("\n1. 測試研究代理的客戶旅程...")
-    research_journey = get_customer_journey("research")
-    assert research_journey, "❌ 研究代理客戶旅程不應為空"
-    assert "steps" in research_journey, "❌ 應包含步驟定義"
-    assert "checkpoints" in research_journey, "❌ 應包含檢查點"
-    print("   ✅ 研究代理客戶旅程獲取成功")
-    print(f"   📋 步驟: {research_journey['steps'][0]}")
-    print(f"   🔍 檢查點數量: {len(research_journey['checkpoints'])}")
-    
-    print("\n2. 測試郵件代理的客戶旅程...")
-    email_journey = get_customer_journey("email")
-    assert email_journey, "❌ 郵件代理客戶旅程不應為空"
-    print("   ✅ 郵件代理客戶旅程獲取成功")
-    
-    print("\n3. 測試行事曆代理的客戶旅程...")
-    calendar_journey = get_customer_journey("calendar")
-    assert calendar_journey, "❌ 行事曆代理客戶旅程不應為空"
-    print("   ✅ 行事曆代理客戶旅程獲取成功")
-    
-    # 測試不存在的客戶旅程
-    print("\n4. 測試錯誤處理（不存在的客戶旅程）...")
-    invalid_journey = get_customer_journey("nonexistent")
-    assert invalid_journey == {}, "❌ 不存在的客戶旅程應返回空字典"
-    print("   ✅ 錯誤處理正常")
-
-
-def test_guideline_structure():
-    """測試指南結構完整性"""
-    print("\n" + "=" * 60)
-    print("測試指南結構完整性")
-    print("=" * 60)
-    
-    print("\n1. 檢查研究代理指南...")
-    tool_guideline = get_guideline("research", "tool_selection")
-    task_guideline = get_guideline("research", "task_planning")
-    behavior_guideline = get_guideline("research", "research_behavior")
-    assert tool_guideline, "❌ 缺少工具選擇指南"
-    assert task_guideline, "❌ 缺少任務規劃指南"
-    assert behavior_guideline, "❌ 缺少研究行為指南"
-    print("   ✅ 研究代理指南結構完整")
-    
-    print("\n2. 檢查郵件代理指南...")
-    email_guideline = get_guideline("email", "email_writing")
-    assert email_guideline, "❌ 缺少郵件撰寫指南"
-    print("   ✅ 郵件代理指南結構完整")
-    
-    print("\n3. 檢查行事曆代理指南...")
-    calendar_guideline = get_guideline("calendar", "event_creation")
-    assert calendar_guideline, "❌ 缺少事件創建指南"
-    print("   ✅ 行事曆代理指南結構��整")
-
-
-def main():
-    """運行所有測試"""
-    print("\n" + "🚀 " * 20)
-    print("開始測試 Parlant SDK 整合")
-    print("🚀 " * 20 + "\n")
-    
-    try:
-        # 初始化 Parlant SDK
-        print("初始化 Parlant SDK...")
-        initialize_parlant_sync()
-        print()
-        
-        test_guidelines()
-        test_customer_journey()
-        
-        print("\n" + "=" * 60)
-        print("✅ 所有測試通過！")
-        print("=" * 60)
-        print("\nParlant SDK 指南系統已成功整合，可以開始使用了！")
-        
-    except AssertionError as e:
-        print(f"\n❌ 測試失敗: {e}")
-        return 1
-    except Exception as e:
-        print(f"\n❌ 發生錯誤: {e}")
-        import traceback
-        traceback.print_exc()
-        return 1
-    
-    return 0
-
-
-if __name__ == "__main__":
-    exit(main())
-

test_simple_chatbot.py

@@ -1,150 +0,0 @@
-"""
-Simple Chatbot 測試腳本
-用於驗證聊天機器人功能是否正常
-"""
-import sys
-import os
-
-# 添加項目根目錄到 Python 路徑
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from deep_agent_rag.ui.simple_chatbot_interface import chat_with_llm, get_llm_status
-
-
-def test_llm_status():
-    """測試 LLM 狀態檢測"""
-    print("=" * 60)
-    print("測試 1: LLM 狀態檢測")
-    print("=" * 60)
-    
-    try:
-        status = get_llm_status()
-        print(f"✅ LLM 狀態: {status}")
-        return True
-    except Exception as e:
-        print(f"❌ LLM 狀態檢測失敗: {e}")
-        return False
-
-
-def test_simple_chat():
-    """測試基本對話功能"""
-    print("\n" + "=" * 60)
-    print("測試 2: 基本對話功能")
-    print("=" * 60)
-    
-    try:
-        # 測試對話
-        history = []
-        test_message = "你好！請簡單介紹你自己。"
-        
-        print(f"\n用戶: {test_message}")
-        print("AI: 正在生成回應...")
-        
-        _, updated_history = chat_with_llm(
-            message=test_message,
-            history=history,
-            system_prompt="你是一個有幫助的AI助手。請用繁體中文簡短回答。"
-        )
-        
-        if updated_history:
-            user_msg, bot_msg = updated_history[0]
-            print(f"\nAI 回應: {bot_msg[:100]}..." if len(bot_msg) > 100 else f"\nAI 回應: {bot_msg}")
-            print("\n✅ 基本對話功能測試通過")
-            return True
-        else:
-            print("❌ 對話歷史為空")
-            return False
-    
-    except Exception as e:
-        print(f"❌ 基本對話功能測試失敗: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def test_multi_turn_chat():
-    """測試多輪對話"""
-    print("\n" + "=" * 60)
-    print("測試 3: 多輪對話功能")
-    print("=" * 60)
-    
-    try:
-        history = []
-        
-        # 第一輪對話
-        print("\n--- 第一輪 ---")
-        _, history = chat_with_llm(
-            message="我叫小明",
-            history=history,
-            system_prompt="你是一個有幫助的AI助手。請記住用戶的信息。"
-        )
-        print(f"用戶: 我叫小明")
-        print(f"AI: {history[-1][1][:50]}...")
-        
-        # 第二輪對話
-        print("\n--- 第二輪 ---")
-        _, history = chat_with_llm(
-            message="我剛才告訴你我叫什麼名字？",
-            history=history,
-            system_prompt="你是一個有幫助的AI助手。請記住用戶的信息。"
-        )
-        print(f"用戶: 我剛才告訴你我叫什麼名字？")
-        print(f"AI: {history[-1][1][:50]}...")
-        
-        # 檢查是否記住了名字
-        if "小明" in history[-1][1]:
-            print("\n✅ 多輪對話功能測試通過（AI 記住了上下文）")
-            return True
-        else:
-            print("\n⚠️ 多輪對話功能測試部分通過（AI 可能沒有完全記住上下文）")
-            return True  # 仍然算通過，因為功能本身是正常的
-    
-    except Exception as e:
-        print(f"❌ 多輪對話功能測試失敗: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def main():
-    """執行所有測試"""
-    print("\n")
-    print("🚀 開始測試 Simple Chatbot 功能")
-    print("=" * 60)
-    
-    results = []
-    
-    # 執行測試
-    results.append(("LLM 狀態檢測", test_llm_status()))
-    results.append(("基本對話功能", test_simple_chat()))
-    results.append(("多輪對話功能", test_multi_turn_chat()))
-    
-    # 顯示結果摘要
-    print("\n" + "=" * 60)
-    print("測試結果摘要")
-    print("=" * 60)
-    
-    passed = sum(1 for _, result in results if result)
-    total = len(results)
-    
-    for test_name, result in results:
-        status = "✅ 通過" if result else "❌ 失敗"
-        print(f"{test_name}: {status}")
-    
-    print(f"\n總計: {passed}/{total} 測試通過")
-    
-    if passed == total:
-        print("\n🎉 所有測試通過！Simple Chatbot 功能正常。")
-        print("\n你可以執行以下命令啟動界面：")
-        print("  python Deep_Agent_Gradio_RAG_localLLM_main.py")
-        print("  或使用：uv run Deep_Agent_Gradio_RAG_localLLM_main.py")
-        print("\n然後點擊「💬 Simple Chatbot」標籤頁。")
-    else:
-        print("\n⚠️ 部分測試失敗，請檢查錯誤訊息。")
-    
-    return passed == total
-
-
-if __name__ == "__main__":
-    success = main()
-    sys.exit(0 if success else 1)

uv.lock

@@ -853,6 +853,7 @@ dependencies = [
     { name = "pillow" },
     { name = "pypdf" },
     { name = "python-dotenv" },
+    { name = "pyyaml" },
     { name = "rank-bm25" },
     { name = "sentence-transformers" },
     { name = "tavily-python" },
@@ -897,6 +898,7 @@ requires-dist = [
     { name = "pillow", specifier = ">=12.0.0" },
     { name = "pypdf", specifier = ">=6.4.1" },
     { name = "python-dotenv", specifier = ">=1.2.1" },
+    { name = "pyyaml", specifier = ">=6.0.0" },
     { name = "rank-bm25", specifier = ">=0.2.2" },
     { name = "sentence-transformers", specifier = ">=5.2.0" },
     { name = "tavily-python", specifier = ">=0.7.14" },