something update...

.env.example

@@ -13,6 +13,10 @@ DB_PASSWORD=your_database_password_here
 OPENROUTER_API_KEY=your_openrouter_api_key_here
 OPENROUTER_MODEL=anthropic/claude-3-haiku
 
+# Groq 設定 (主要 AI 服務，推薦)
+GROQ_API_KEY=your_groq_api_key_here
+GROQ_MODEL=qwen/qwen3-32b
+
 # 其他設定
 DEBUG=False
 LOG_LEVEL=INFO

GROQ_INTEGRATION_COMPLETE.md

@@ -0,0 +1,237 @@
+# 🚀 Groq 整合完成指南
+
+## 📋 整合概述
+
+已成功將 Groq AI 服務整合到 LINE Bot 系統中，並實現智能訊息路由功能。
+
+### ✅ 完成的功能
+
+1. **Groq 服務整合** (`backend/services/groq_service.py`)
+   - 快速 AI 推理服務
+   - 意圖分析功能
+   - 自然回應生成
+
+2. **智能訊息路由** (`backend/services/message_router.py`)
+   - 前綴指令路由
+   - 智能意圖識別
+   - 統計功能
+
+3. **新增 API 端點**
+   - `/chat` - 直接聊天
+   - `/search` - 直接搜尋
+   - `/route` - 智能路由
+   - `/stats` - 使用統計
+
+4. **LINE Bot 優化**
+   - 避免所有訊息都觸發 NLP
+   - 支援前綴指令
+   - 智能判斷聊天 vs 查詢
+
+## 🔧 環境變數設定
+
+### 新增必要變數
+```bash
+# Groq 設定 (主要 AI 服務)
+GROQ_API_KEY=your_groq_api_key_here
+GROQ_MODEL=qwen/qwen3-32b
+```
+
+### 完整環境變數
+```bash
+# LINE Bot 設定
+LINE_CHANNEL_ACCESS_TOKEN=your_line_channel_access_token_here
+LINE_CHANNEL_SECRET=your_line_channel_secret_here
+
+# PostgreSQL 資料庫設定
+DB_HOST=your_database_host_here
+DB_PORT=6543
+DB_NAME=your_database_name_here
+DB_USER=your_database_user_here
+DB_PASSWORD=your_database_password_here
+
+# Groq 設定 (主要 AI 服務，推薦)
+GROQ_API_KEY=your_groq_api_key_here
+GROQ_MODEL=qwen/qwen3-32b
+
+# OpenRouter 設定 (可選，備用)
+OPENROUTER_API_KEY=your_openrouter_api_key_here
+OPENROUTER_MODEL=anthropic/claude-3-haiku
+
+# 其他設定
+DEBUG=False
+LOG_LEVEL=INFO
+```
+
+## 📱 使用方式
+
+### LINE Bot 指令
+
+#### 1. 前綴指令模式
+```
+💬 聊天模式：
+/chat 你好，今天天氣如何？
+
+🔍 商品查詢：
+/search iPhone 15 Pro
+/search 價格 1000-5000 的商品
+
+❓ 幫助：
+/help 或 幫助
+```
+
+#### 2. 智能模式（無前綴）
+```
+🤖 系統會自動判斷：
+
+聊天類型：
+• "你好！"
+• "今天天氣如何？"
+• "推薦一些功能"
+
+查詢類型：
+• "iPhone 還有庫存嗎？"
+• "1000到5000的商品有哪些？"
+• "我的訂單狀態如何？"
+```
+
+### API 端點使用
+
+#### 直接聊天 API
+```bash
+curl -X POST http://localhost:7860/chat \
+  -H "Content-Type: application/json" \
+  -d '{"message": "你好！", "user_id": "test_user"}'
+```
+
+#### 直接搜尋 API
+```bash
+curl -X POST http://localhost:7860/search \
+  -H "Content-Type: application/json" \
+  -d '{"message": "iPhone 15", "user_id": "test_user"}'
+```
+
+#### 智能路由 API
+```bash
+curl -X POST http://localhost:7860/route \
+  -H "Content-Type: application/json" \
+  -d '{"message": "iPhone 還有庫存嗎？", "user_id": "test_user"}'
+```
+
+#### 統計 API
+```bash
+curl http://localhost:7860/stats
+```
+
+## 🧪 測試
+
+### 執行整合測試
+```bash
+python tmp_rovodev_test_groq_integration.py
+```
+
+### 測試項目
+- ✅ 健康檢查
+- ✅ 聊天 API
+- ✅ 搜尋 API  
+- ✅ 智能路由
+- ✅ 統計功能
+- ✅ LINE Webhook 模擬
+
+## 🔄 路由邏輯
+
+### 訊息處理流程
+```
+用戶訊息 → MessageRouter
+    ↓
+前綴檢查 (/chat, /search, /help)
+    ↓
+智能意圖分析 (Groq)
+    ↓
+路由到對應服務
+    ↓
+生成回應
+```
+
+### 意圖分析
+- **搜尋意圖**: 商品查詢、庫存、訂單等
+- **聊天意圖**: 問候、閒聊、一般問題
+- **幫助意圖**: 說明、指令、功能介紹
+
+## 📊 優勢
+
+### 相比 OpenRouter
+- ⚡ **速度更快**: Groq 推理速度顯著提升
+- 💰 **成本更低**: 更經濟的 API 定價
+- 🎯 **中文優化**: qwen3-32b 對中文支援更好
+
+### 智能路由優勢
+- 🎯 **精準路由**: 避免誤觸發 NLP 分析
+- 🔀 **靈活切換**: 支援指令和智能模式
+- 📈 **使用統計**: 追蹤路由效果
+
+## 🚨 注意事項
+
+### 1. API Key 安全
+- 請妥善保管 Groq API Key
+- 不要將 API Key 提交到版本控制
+
+### 2. 錯誤處理
+- Groq 服務不可用時會自動降級
+- 保持原有功能的向後相容性
+
+### 3. 效能監控
+- 使用 `/stats` 監控路由統計
+- 關注 Groq API 使用量
+
+## 🔧 故障排除
+
+### Groq 服務不可用
+```python
+# 檢查 API Key 設定
+print(settings.GROQ_API_KEY)
+
+# 檢查服務狀態
+groq_service = GroqService()
+print(groq_service.is_available())
+```
+
+### 路由統計異常
+```bash
+# 查看路由統計
+curl http://localhost:7860/stats
+```
+
+### LINE Bot 無回應
+1. 檢查 Webhook URL 設定
+2. 確認環境變數正確
+3. 查看應用程式日誌
+
+## 📈 後續優化建議
+
+1. **快取機制**: 為常見查詢添加快取
+2. **A/B 測試**: 比較不同路由策略效果
+3. **用戶偏好**: 學習用戶使用習慣
+4. **多語言支援**: 擴展到其他語言
+
+## 🎉 部署
+
+### Hugging Face Spaces
+1. 更新環境變數（加入 GROQ_API_KEY）
+2. 推送代碼更新
+3. 等待自動部署完成
+
+### 本地測試
+```bash
+# 安裝新依賴
+pip install -r requirements.txt
+
+# 設定環境變數
+export GROQ_API_KEY=your_groq_api_key
+
+# 啟動服務
+python -m uvicorn backend.main:app --reload --port 7860
+```
+
+---
+
+**🎊 整合完成！** 您的 LINE Bot 現在具備了更快速、更智能的 AI 服務能力！

backend/config.py

@@ -25,6 +25,10 @@ class Settings(BaseSettings):
     OPENROUTER_API_KEY: Optional[str] = os.getenv("OPENROUTER_API_KEY", "")
     OPENROUTER_MODEL: str = os.getenv("OPENROUTER_MODEL", "anthropic/claude-3-haiku")
     
+    # Groq 設定 (主要 AI 服務)
+    GROQ_API_KEY: Optional[str] = os.getenv("GROQ_API_KEY", "")
+    GROQ_MODEL: str = os.getenv("GROQ_MODEL", "qwen/qwen3-32b")
+    
     # 其他設定
     DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
     LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")

backend/main.py

@@ -7,6 +7,7 @@ from linebot.models import MessageEvent, TextMessage, TextSendMessage
 import logging
 from backend.services.nlp_service import NLPService
 from backend.services.database_service import DatabaseService
+from backend.services.message_router import MessageRouter
 from backend.config import settings
 from backend.database.connection import test_database_connection
 
@@ -32,6 +33,7 @@ handler = WebhookHandler(settings.LINE_CHANNEL_SECRET)
 # 服務初始化
 nlp_service = NLPService()
 db_service = DatabaseService()
+message_router = MessageRouter()
 
 @app.get("/")
 def greet_json():
@@ -65,26 +67,20 @@ async def callback(request: Request):
 
 @handler.add(MessageEvent, message=TextMessage)
 def handle_message(event):
-    """處理 LINE 訊息"""
+    """處理 LINE 訊息 - 使用新的路由系統"""
     try:
         user_message = event.message.text
         user_id = event.source.user_id
         
         logger.info(f"收到訊息: {user_message} from {user_id}")
         
-        # 使用 NLP 服務分析訊息
-        analysis_result = nlp_service.analyze_message(user_message)
-        
-        # 根據分析結果調用對應的資料庫方法
-        response_data = db_service.execute_query(analysis_result)
-        
-        # 格式化回應訊息
-        reply_message = nlp_service.format_response(response_data, analysis_result, user_message)
+        # 使用訊息路由器處理
+        response_data = message_router.route_message(user_message, user_id)
         
         # 回覆訊息
         line_bot_api.reply_message(
             event.reply_token,
-            TextSendMessage(text=reply_message)
+            TextSendMessage(text=response_data["text"])
         )
         
     except Exception as e:
@@ -94,6 +90,98 @@ def handle_message(event):
             TextSendMessage(text="抱歉，處理您的訊息時發生錯誤，請稍後再試。")
         )
 
+# 新增直接 API 端點
+@app.post("/chat")
+async def direct_chat(request: dict):
+    """直接聊天 API"""
+    try:
+        message = request.get("message", "")
+        user_id = request.get("user_id", "api_user")
+        
+        if not message:
+            return {
+                "success": False,
+                "error": "訊息內容不能為空"
+            }
+        
+        # 強制使用聊天模式
+        result = message_router._handle_chat_mode(message, user_id)
+        return result
+        
+    except Exception as e:
+        logger.error(f"直接聊天 API 錯誤: {str(e)}")
+        return {
+            "success": False,
+            "error": str(e),
+            "text": "聊天服務暫時無法使用"
+        }
+
+@app.post("/search") 
+async def direct_search(request: dict):
+    """直接搜尋 API"""
+    try:
+        message = request.get("message", "")
+        user_id = request.get("user_id", "api_user")
+        
+        if not message:
+            return {
+                "success": False,
+                "error": "查詢內容不能為空"
+            }
+        
+        # 強制使用搜尋模式
+        result = message_router._handle_search_mode(message, user_id)
+        return result
+        
+    except Exception as e:
+        logger.error(f"直接搜尋 API 錯誤: {str(e)}")
+        return {
+            "success": False,
+            "error": str(e),
+            "text": "搜尋服務暫時無法使用"
+        }
+
+@app.post("/route")
+async def smart_route(request: dict):
+    """智能路由 API"""
+    try:
+        message = request.get("message", "")
+        user_id = request.get("user_id", "api_user")
+        
+        if not message:
+            return {
+                "success": False,
+                "error": "訊息內容不能為空"
+            }
+        
+        # 使用智能路由
+        result = message_router.route_message(message, user_id)
+        return result
+        
+    except Exception as e:
+        logger.error(f"智能路由 API 錯誤: {str(e)}")
+        return {
+            "success": False,
+            "error": str(e),
+            "text": "路由服務暫時無法使用"
+        }
+
+@app.get("/stats")
+async def get_stats():
+    """取得路由統計"""
+    try:
+        stats = message_router.get_route_statistics()
+        return {
+            "success": True,
+            "data": stats
+        }
+    except Exception as e:
+        logger.error(f"統計 API 錯誤: {str(e)}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)

backend/services/groq_service.py

@@ -0,0 +1,280 @@
+"""
+Groq API 服務
+提供快速的 AI 推理功能
+"""
+
+from groq import Groq
+from backend.config import settings
+import logging
+import json
+import re
+
+logger = logging.getLogger(__name__)
+
+class GroqService:
+    """Groq AI 服務類"""
+    
+    def __init__(self):
+        self.api_key = settings.GROQ_API_KEY
+        self.model = getattr(settings, 'GROQ_MODEL', 'qwen/qwen3-32b')
+        
+        if not self.api_key:
+            logger.warning("GROQ_API_KEY 未設定，Groq 服務將無法使用")
+            self.client = None
+        else:
+            self.client = Groq(api_key=self.api_key)
+    
+    def is_available(self) -> bool:
+        """檢查 Groq 服務是否可用"""
+        return self.client is not None
+    
+    def chat_completion(self, message: str, system_prompt: str = None, temperature: float = 0.6) -> str:
+        """
+        聊天完成
+        
+        Args:
+            message: 用戶訊息
+            system_prompt: 系統提示詞
+            temperature: 溫度參數 (0.0-1.0)
+            
+        Returns:
+            AI 回應內容
+        """
+        if not self.is_available():
+            raise Exception("Groq 服務不可用，請檢查 API Key 設定")
+        
+        try:
+            messages = []
+            if system_prompt:
+                messages.append({"role": "system", "content": system_prompt})
+            messages.append({"role": "user", "content": message})
+            
+            completion = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                temperature=temperature,
+                max_completion_tokens=4096,
+                top_p=0.95,
+                reasoning_effort="default",
+                stop=None,
+            )
+            
+            return completion.choices[0].message.content
+            
+        except Exception as e:
+            logger.error(f"Groq API 調用失敗: {str(e)}")
+            raise Exception(f"AI 服務暫時無法使用: {str(e)}")
+    
+    def analyze_intent(self, message: str) -> dict:
+        """
+        分析用戶訊息意圖
+        
+        Args:
+            message: 用戶訊息
+            
+        Returns:
+            意圖分析結果
+        """
+        if not self.is_available():
+            return {
+                "intent": "unknown",
+                "confidence": 0.0,
+                "entities": {},
+                "error": "Groq 服務不可用"
+            }
+        
+        system_prompt = """你是一個意圖分析助手，分析用戶訊息的意圖。
+
+請分析用戶訊息並回傳 JSON 格式：
+{
+    "intent": "search|chat|help|order|inventory|unknown",
+    "confidence": 0.0-1.0,
+    "entities": {
+        "product": "商品名稱",
+        "action": "動作類型",
+        "price_range": "價格範圍",
+        "category": "商品分類"
+    },
+    "reasoning": "分析原因"
+}
+
+意圖類型說明：
+- search: 商品查詢、搜尋相關
+- chat: 一般聊天、問候、閒聊
+- help: 求助、說明、指令
+- order: 訂單查詢、訂單相關
+- inventory: 庫存查詢、庫存相關
+- unknown: 無法確定意圖
+
+請用繁體中文回應，並確保回傳有效的 JSON 格式。"""
+
+        try:
+            response = self.chat_completion(message, system_prompt, temperature=0.3)
+            return self._parse_intent_response(response)
+            
+        except Exception as e:
+            logger.error(f"意圖分析失敗: {str(e)}")
+            return {
+                "intent": "unknown",
+                "confidence": 0.0,
+                "entities": {},
+                "error": str(e)
+            }
+    
+    def _parse_intent_response(self, response: str) -> dict:
+        """解析意圖分析回應"""
+        try:
+            # 嘗試提取 JSON 部分
+            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            if json_match:
+                json_str = json_match.group()
+                result = json.loads(json_str)
+                
+                # 驗證必要欄位
+                if "intent" not in result:
+                    result["intent"] = "unknown"
+                if "confidence" not in result:
+                    result["confidence"] = 0.5
+                if "entities" not in result:
+                    result["entities"] = {}
+                
+                # 確保信心度在有效範圍內
+                result["confidence"] = max(0.0, min(1.0, float(result["confidence"])))
+                
+                return result
+            else:
+                # 如果沒有找到 JSON，嘗試簡單解析
+                return self._fallback_intent_parsing(response)
+                
+        except json.JSONDecodeError as e:
+            logger.warning(f"JSON 解析失敗: {str(e)}, 回應內容: {response}")
+            return self._fallback_intent_parsing(response)
+        except Exception as e:
+            logger.error(f"意圖回應解析錯誤: {str(e)}")
+            return {
+                "intent": "unknown",
+                "confidence": 0.0,
+                "entities": {},
+                "error": f"解析錯誤: {str(e)}"
+            }
+    
+    def _fallback_intent_parsing(self, response: str) -> dict:
+        """備用的意圖解析方法"""
+        response_lower = response.lower()
+        
+        # 簡單的關鍵字匹配
+        if any(keyword in response_lower for keyword in ['查詢', '搜尋', '找', '商品', '產品']):
+            return {
+                "intent": "search",
+                "confidence": 0.6,
+                "entities": {},
+                "reasoning": "關鍵字匹配: 搜尋相關"
+            }
+        elif any(keyword in response_lower for keyword in ['訂單', 'order']):
+            return {
+                "intent": "order", 
+                "confidence": 0.6,
+                "entities": {},
+                "reasoning": "關鍵字匹配: 訂單相關"
+            }
+        elif any(keyword in response_lower for keyword in ['庫存', 'inventory', '存貨']):
+            return {
+                "intent": "inventory",
+                "confidence": 0.6, 
+                "entities": {},
+                "reasoning": "關鍵字匹配: 庫存相關"
+            }
+        elif any(keyword in response_lower for keyword in ['幫助', 'help', '說明', '指令']):
+            return {
+                "intent": "help",
+                "confidence": 0.8,
+                "entities": {},
+                "reasoning": "關鍵字匹配: 幫助相關"
+            }
+        else:
+            return {
+                "intent": "chat",
+                "confidence": 0.4,
+                "entities": {},
+                "reasoning": "預設為聊天模式"
+            }
+    
+    def generate_business_response(self, query_result: dict, original_message: str) -> str:
+        """
+        根據業務查詢結果生成自然回應
+        
+        Args:
+            query_result: 業務查詢結果
+            original_message: 原始用戶訊息
+            
+        Returns:
+            自然語言回應
+        """
+        if not self.is_available():
+            return self._fallback_business_response(query_result)
+        
+        system_prompt = f"""你是一個友善的客服助手，需要根據查詢結果為用戶生成自然的回應。
+
+用戶原始訊息：{original_message}
+
+查詢結果：
+- 成功: {query_result.get('success', False)}
+- 資料筆數: {len(query_result.get('data', []))}
+- 意圖: {query_result.get('intent', 'unknown')}
+
+請用繁體中文生成一個友善、自然的回應，包含查詢結果的摘要。
+如果有具體資料，請整理成易讀的格式。
+回應長度控制在 200 字以內。"""
+
+        try:
+            # 準備查詢結果摘要
+            data_summary = self._prepare_data_summary(query_result.get('data', []))
+            full_prompt = f"{system_prompt}\n\n資料摘要：\n{data_summary}"
+            
+            response = self.chat_completion(original_message, full_prompt, temperature=0.4)
+            return response
+            
+        except Exception as e:
+            logger.error(f"生成業務回應失敗: {str(e)}")
+            return self._fallback_business_response(query_result)
+    
+    def _prepare_data_summary(self, data: list) -> str:
+        """準備資料摘要"""
+        if not data:
+            return "沒有找到相關資料"
+        
+        summary_lines = []
+        for i, item in enumerate(data[:5]):  # 最多顯示 5 筆
+            if isinstance(item, dict):
+                # 提取重要欄位
+                name = item.get('name', item.get('product_name', ''))
+                price = item.get('price', item.get('unit_price', ''))
+                stock = item.get('stock', item.get('quantity', ''))
+                
+                line_parts = []
+                if name:
+                    line_parts.append(f"名稱: {name}")
+                if price:
+                    line_parts.append(f"價格: ${price}")
+                if stock:
+                    line_parts.append(f"庫存: {stock}")
+                
+                if line_parts:
+                    summary_lines.append(f"{i+1}. {', '.join(line_parts)}")
+        
+        if len(data) > 5:
+            summary_lines.append(f"... 還有 {len(data) - 5} 筆資料")
+        
+        return '\n'.join(summary_lines) if summary_lines else "資料格式無法解析"
+    
+    def _fallback_business_response(self, query_result: dict) -> str:
+        """備用的業務回應生成"""
+        if query_result.get('success'):
+            data_count = len(query_result.get('data', []))
+            if data_count > 0:
+                return f"✅ 查詢成功！找到 {data_count} 筆相關資料。"
+            else:
+                return "✅ 查詢完成，但沒有找到符合條件的資料。"
+        else:
+            error_msg = query_result.get('error', '未知錯誤')
+            return f"❌ 查詢失敗：{error_msg}"

backend/services/message_router.py

@@ -0,0 +1,361 @@
+"""
+訊息路由器 - 根據前綴和內容智能路由訊息
+"""
+
+import logging
+from typing import Dict, Any
+from backend.services.groq_service import GroqService
+from backend.services.business_query_service import BusinessQueryService
+
+logger = logging.getLogger(__name__)
+
+class MessageRouter:
+    """訊息路由器類"""
+    
+    def __init__(self):
+        self.groq_service = GroqService()
+        self.business_service = BusinessQueryService()
+        
+        # 路由統計
+        self.route_stats = {
+            "chat": 0,
+            "search": 0, 
+            "help": 0,
+            "smart": 0,
+            "error": 0
+        }
+    
+    def route_message(self, message: str, user_id: str) -> Dict[str, Any]:
+        """
+        根據前綴和內容路由訊息
+        
+        Args:
+            message: 用戶訊息
+            user_id: 用戶ID
+            
+        Returns:
+            處理結果字典
+        """
+        try:
+            # 清理訊息
+            clean_message = message.strip()
+            
+            if not clean_message:
+                return self._handle_empty_message(user_id)
+            
+            logger.info(f"路由訊息 - 用戶: {user_id}, 內容: {clean_message[:50]}...")
+            
+            # 1. 聊天模式 - /chat 前綴
+            if clean_message.startswith('/chat '):
+                self.route_stats["chat"] += 1
+                return self._handle_chat_mode(clean_message[6:].strip(), user_id)
+            
+            # 2. 商品查詢 - /search 前綴  
+            elif clean_message.startswith('/search '):
+                self.route_stats["search"] += 1
+                return self._handle_search_mode(clean_message[8:].strip(), user_id)
+            
+            # 3. 幫助指令
+            elif clean_message.lower() in ['/help', '幫助', 'help', '說明', '指令']:
+                self.route_stats["help"] += 1
+                return self._handle_help_mode(user_id)
+            
+            # 4. 特殊指令
+            elif clean_message.lower() in ['選單', 'menu', '功能']:
+                return self._handle_menu_mode(user_id)
+            
+            elif clean_message.lower() in ['統計', 'stats', '路由統計']:
+                return self._handle_stats_mode(user_id)
+            
+            # 5. 智能路由 - 無前綴時進行意圖分析
+            else:
+                self.route_stats["smart"] += 1
+                return self._handle_smart_routing(clean_message, user_id)
+                
+        except Exception as e:
+            self.route_stats["error"] += 1
+            logger.error(f"訊息路由錯誤: {str(e)}")
+            return {
+                "type": "text",
+                "text": "❌ 系統處理訊息時發生錯誤，請稍後再試。",
+                "mode": "error",
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _handle_chat_mode(self, message: str, user_id: str) -> Dict[str, Any]:
+        """處理聊天模式"""
+        try:
+            if not message:
+                return {
+                    "type": "text",
+                    "text": "💬 請輸入您想聊的內容！\n\n範例：/chat 今天天氣如何？",
+                    "mode": "chat",
+                    "success": True
+                }
+            
+            if not self.groq_service.is_available():
+                return {
+                    "type": "text",
+                    "text": "💬 聊天服務暫時無法使用，請稍後再試。\n\n💡 您可以嘗試使用 /search 進行商品查詢。",
+                    "mode": "chat",
+                    "success": False,
+                    "error": "Groq 服務不可用"
+                }
+            
+            system_prompt = """你是一個友善的客服助手，專門協助用戶解答問題。
+請用繁體中文回應，語氣要親切自然。
+如果用戶詢問商品或業務相關問題，建議他們使用 /search 指令進行查詢。
+回應長度控制在 150 字以內。"""
+            
+            response = self.groq_service.chat_completion(message, system_prompt)
+            
+            return {
+                "type": "text",
+                "text": f"💬 {response}",
+                "mode": "chat",
+                "success": True,
+                "user_id": user_id
+            }
+            
+        except Exception as e:
+            logger.error(f"聊天模式處理錯誤: {str(e)}")
+            return {
+                "type": "text", 
+                "text": "💬 聊天服務暫時無法使用，請稍後再試。",
+                "mode": "chat",
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _handle_search_mode(self, message: str, user_id: str) -> Dict[str, Any]:
+        """處理搜尋模式"""
+        try:
+            if not message:
+                return {
+                    "type": "text",
+                    "text": "🔍 請��入您要查詢的內容！\n\n範例：\n• /search iPhone 15\n• /search 價格 1000-5000\n• /search 庫存不足的商品",
+                    "mode": "search",
+                    "success": True
+                }
+            
+            # 使用業務查詢服務
+            result = self.business_service.process_user_query(message, user_id)
+            
+            # 如果有 Groq 服務，使用它來生成更自然的回應
+            if self.groq_service.is_available() and result.get("success"):
+                try:
+                    natural_response = self.groq_service.generate_business_response(result, message)
+                    response_text = f"🔍 {natural_response}"
+                except Exception as e:
+                    logger.warning(f"Groq 回應生成失敗，使用原始回應: {str(e)}")
+                    response_text = f"🔍 {result['response_message']}"
+            else:
+                response_text = f"🔍 {result['response_message']}"
+            
+            return {
+                "type": "text",
+                "text": response_text,
+                "mode": "search", 
+                "success": result["success"],
+                "data": result.get("data", []),
+                "intent": result.get("intent", "unknown"),
+                "confidence": result.get("confidence", 0.0),
+                "user_id": user_id
+            }
+            
+        except Exception as e:
+            logger.error(f"搜尋模式處理錯誤: {str(e)}")
+            return {
+                "type": "text",
+                "text": "🔍 搜尋服務暫時無法使用，請稍後再試。", 
+                "mode": "search",
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _handle_smart_routing(self, message: str, user_id: str) -> Dict[str, Any]:
+        """智能路由 - 根據內容判斷意圖"""
+        try:
+            # 先進行簡單的關鍵字預篩選
+            quick_intent = self._quick_intent_check(message)
+            
+            if quick_intent == "search":
+                # 高信心度的搜尋關鍵字 -> 直接轉到搜尋模式
+                logger.info(f"快速意圖識別: 搜尋模式 - {message[:30]}...")
+                return self._handle_search_mode(message, user_id)
+            
+            elif quick_intent == "help":
+                # 幫助相關 -> 轉到幫助模式
+                return self._handle_help_mode(user_id)
+            
+            # 使用 Groq 進行深度意圖分析
+            if self.groq_service.is_available():
+                try:
+                    intent_result = self.groq_service.analyze_intent(message)
+                    logger.info(f"Groq 意圖分析: {intent_result}")
+                    
+                    # 根據意圖和信心度決定路由
+                    if intent_result["intent"] in ["search", "order", "inventory"] and intent_result["confidence"] > 0.6:
+                        logger.info(f"智能路由 -> 搜尋模式 (信心度: {intent_result['confidence']})")
+                        return self._handle_search_mode(message, user_id)
+                    
+                    elif intent_result["intent"] == "help" and intent_result["confidence"] > 0.7:
+                        return self._handle_help_mode(user_id)
+                    
+                    else:
+                        # 其他情況或低信心度 -> 轉到聊天模式
+                        logger.info(f"智能路由 -> 聊天模式 (意圖: {intent_result['intent']}, 信心度: {intent_result['confidence']})")
+                        return self._handle_chat_mode(message, user_id)
+                        
+                except Exception as e:
+                    logger.warning(f"Groq 意圖分析失敗，使用預設路由: {str(e)}")
+                    # 錯誤時預設為聊天模式
+                    return self._handle_chat_mode(message, user_id)
+            else:
+                # Groq 不可用時，根據簡單規則路由
+                if quick_intent == "search":
+                    return self._handle_search_mode(message, user_id)
+                else:
+                    return self._handle_chat_mode(message, user_id)
+                
+        except Exception as e:
+            logger.error(f"智能路由處理錯誤: {str(e)}")
+            # 錯誤時預設為聊天模式
+            return self._handle_chat_mode(message, user_id)
+    
+    def _quick_intent_check(self, message: str) -> str:
+        """快速意圖檢查 - 基於關鍵字"""
+        message_lower = message.lower()
+        
+        # 搜尋相關關鍵字
+        search_keywords = [
+            '查詢', '搜尋', '找', '商品', '產品', '價格', '庫存', '訂單',
+            '多少錢', '有沒有', '還有嗎', '剩多少', '存貨', '現貨',
+            'iphone', 'macbook', 'ipad', 'airpods'  # 常見商品名
+        ]
+        
+        # 幫助相關關鍵字
+        help_keywords = ['幫助', 'help', '說明', '���麼用', '指令', '功能']
+        
+        if any(keyword in message_lower for keyword in search_keywords):
+            return "search"
+        elif any(keyword in message_lower for keyword in help_keywords):
+            return "help"
+        else:
+            return "chat"
+    
+    def _handle_help_mode(self, user_id: str) -> Dict[str, Any]:
+        """處理幫助模式"""
+        help_text = """🤖 智能客服助手使用指南
+
+📝 指令模式：
+• /chat [訊息] - 聊天模式
+  範例：/chat 今天天氣如何？
+
+• /search [查詢] - 商品查詢模式  
+  範例：/search iPhone 15 Pro
+  範例：/search 價格 1000-5000
+
+• /help - 顯示此說明
+
+🧠 智能模式：
+直接輸入訊息，系統會自動判斷是聊天還是查詢！
+
+💡 查詢範例：
+• "iPhone 還有庫存嗎？"
+• "1000到5000的商品有哪些？"
+• "我的訂單狀態如何？"
+
+💬 聊天範例：
+• "你好！"
+• "今天天氣如何？"
+• "推薦一些好用的功能"
+
+輸入「選單」查看功能選單
+輸入「統計」查看使用統計"""
+
+        return {
+            "type": "text",
+            "text": help_text,
+            "mode": "help",
+            "success": True,
+            "user_id": user_id
+        }
+    
+    def _handle_menu_mode(self, user_id: str) -> Dict[str, Any]:
+        """處理選單模式"""
+        menu_text = """🏪 功能選單
+
+請選擇您需要的功能：
+
+🔍 商品查詢
+• /search [商品名稱]
+• /search 價格 [範圍]
+
+💬 智能聊天  
+• /chat [您的問題]
+
+📊 常用查詢
+• "庫存查詢"
+• "我的訂單" 
+• "低庫存商品"
+• "業務統計"
+
+❓ 說明
+• /help - 詳細說明
+• 統計 - 使用統計
+
+💡 小提示：您也可以直接輸入問題，系統會智能判斷處理方式！"""
+
+        return {
+            "type": "text",
+            "text": menu_text,
+            "mode": "menu",
+            "success": True,
+            "user_id": user_id
+        }
+    
+    def _handle_stats_mode(self, user_id: str) -> Dict[str, Any]:
+        """處理統計模式"""
+        total_routes = sum(self.route_stats.values())
+        
+        if total_routes == 0:
+            stats_text = "📊 路由統計\n\n尚無使用記錄"
+        else:
+            stats_text = f"""📊 路由統計 (總計: {total_routes})
+
+💬 聊天模式: {self.route_stats['chat']} ({self.route_stats['chat']/total_routes*100:.1f}%)
+🔍 搜尋模式: {self.route_stats['search']} ({self.route_stats['search']/total_routes*100:.1f}%)
+🧠 智能路由: {self.route_stats['smart']} ({self.route_stats['smart']/total_routes*100:.1f}%)
+❓ 幫助模式: {self.route_stats['help']} ({self.route_stats['help']/total_routes*100:.1f}%)
+❌ 錯誤次數: {self.route_stats['error']} ({self.route_stats['error']/total_routes*100:.1f}%)
+
+🤖 Groq 服務: {'✅ 可用' if self.groq_service.is_available() else '❌ 不可用'}"""
+
+        return {
+            "type": "text",
+            "text": stats_text,
+            "mode": "stats",
+            "success": True,
+            "user_id": user_id,
+            "data": self.route_stats
+        }
+    
+    def _handle_empty_message(self, user_id: str) -> Dict[str, Any]:
+        """處理空訊息"""
+        return {
+            "type": "text",
+            "text": "🤔 您似乎沒有輸入任何內容。\n\n輸入 /help 查看使用說明，或直接告訴我您需要什麼幫助！",
+            "mode": "empty",
+            "success": True,
+            "user_id": user_id
+        }
+    
+    def get_route_statistics(self) -> Dict[str, Any]:
+        """取得路由統計資訊"""
+        return {
+            "stats": self.route_stats.copy(),
+            "total": sum(self.route_stats.values()),
+            "groq_available": self.groq_service.is_available()
+        }

groq_python_test.py

@@ -0,0 +1,67 @@
+from groq import Groq
+
+GROQ_API_KEY = "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"
+
+def chat_with_groq(user_message):
+    """Send a message to Groq and get the streaming response"""
+    client = Groq(api_key=GROQ_API_KEY)
+    
+    try:
+        completion = client.chat.completions.create(
+            model="qwen/qwen3-32b",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": user_message}
+            ],
+            temperature=0.6,
+            max_completion_tokens=4096,
+            top_p=0.95,
+            reasoning_effort="default",
+            stream=True,
+            stop=None,
+        )
+        
+        print("Groq: ", end="", flush=True)
+        response_text = ""
+        
+        for chunk in completion:
+            content = chunk.choices[0].delta.content or ""
+            print(content, end="", flush=True)
+            response_text += content
+            
+        print()  # New line after response
+        return response_text
+        
+    except Exception as e:
+        return f"Error: {e}"
+
+def main():
+    """Main interactive loop"""
+    print("=== Groq Chat Bot ===")
+    print("Enter your questions, type 'quit' or 'exit' to quit")
+    print("=" * 30)
+    
+    while True:
+        try:
+            user_input = input("\nYour question: ").strip()
+            
+            if user_input.lower() in ['quit', 'exit', 'q']:
+                print("Goodbye!")
+                break
+                
+            if not user_input:
+                print("Please enter a question.")
+                continue
+                
+            print("\nThinking...")
+            chat_with_groq(user_input)
+            
+        except KeyboardInterrupt:
+            print("\n\nProgram interrupted, goodbye!")
+            break
+        except EOFError:
+            print("\n\nInput ended, goodbye!")
+            break
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -10,4 +10,5 @@ python-multipart
 python-dotenv
 requests
 openai
-httpx
+httpx
+groq

tmp_rovodev_test_groq_integration.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""
+Groq 整合測試腳本
+測試新的路由系統和 Groq 服務
+"""
+
+import requests
+import json
+import os
+from typing import Dict, Any
+
+class GroqIntegrationTester:
+    def __init__(self, base_url: str = "http://localhost:7860"):
+        self.base_url = base_url
+        self.test_results = []
+    
+    def test_health_check(self):
+        """測試健康檢查"""
+        print("🔍 測試健康檢查...")
+        try:
+            response = requests.get(f"{self.base_url}/health")
+            success = response.status_code == 200
+            result = {
+                "test": "health_check",
+                "success": success,
+                "status_code": response.status_code,
+                "response": response.json() if success else response.text
+            }
+            self.test_results.append(result)
+            print(f"✅ 健康檢查: {response.status_code}")
+            return success
+        except Exception as e:
+            print(f"❌ 健康檢查失敗: {e}")
+            self.test_results.append({
+                "test": "health_check",
+                "success": False,
+                "error": str(e)
+            })
+            return False
+    
+    def test_chat_api(self):
+        """測試聊天 API"""
+        print("\n💬 測試聊天 API...")
+        test_messages = [
+            "你好！",
+            "今天天氣如何？",
+            "請介紹一下你自己",
+            "推薦一些好用的功能"
+        ]
+        
+        for message in test_messages:
+            try:
+                response = requests.post(
+                    f"{self.base_url}/chat",
+                    json={"message": message, "user_id": "test_user"},
+                    headers={"Content-Type": "application/json"}
+                )
+                
+                success = response.status_code == 200
+                result = {
+                    "test": "chat_api",
+                    "message": message,
+                    "success": success,
+                    "status_code": response.status_code,
+                    "response": response.json() if success else response.text
+                }
+                self.test_results.append(result)
+                
+                if success:
+                    data = response.json()
+                    print(f"✅ 聊天: {message[:20]}... -> {data.get('text', '')[:50]}...")
+                else:
+                    print(f"❌ 聊天失敗: {message[:20]}... -> {response.status_code}")
+                    
+            except Exception as e:
+                print(f"❌ 聊天 API 錯誤: {e}")
+                self.test_results.append({
+                    "test": "chat_api",
+                    "message": message,
+                    "success": False,
+                    "error": str(e)
+                })
+    
+    def test_search_api(self):
+        """測試搜尋 API"""
+        print("\n🔍 測試搜尋 API...")
+        test_queries = [
+            "iPhone 15 Pro",
+            "價格 1000-5000",
+            "庫存查詢",
+            "我的訂單",
+            "低庫存商品"
+        ]
+        
+        for query in test_queries:
+            try:
+                response = requests.post(
+                    f"{self.base_url}/search",
+                    json={"message": query, "user_id": "test_user"},
+                    headers={"Content-Type": "application/json"}
+                )
+                
+                success = response.status_code == 200
+                result = {
+                    "test": "search_api",
+                    "query": query,
+                    "success": success,
+                    "status_code": response.status_code,
+                    "response": response.json() if success else response.text
+                }
+                self.test_results.append(result)
+                
+                if success:
+                    data = response.json()
+                    print(f"✅ 搜尋: {query} -> {data.get('text', '')[:50]}...")
+                else:
+                    print(f"❌ 搜尋失敗: {query} -> {response.status_code}")
+                    
+            except Exception as e:
+                print(f"❌ 搜尋 API 錯誤: {e}")
+                self.test_results.append({
+                    "test": "search_api",
+                    "query": query,
+                    "success": False,
+                    "error": str(e)
+                })
+    
+    def test_smart_routing(self):
+        """測試智能路由"""
+        print("\n🧠 測試智能路由...")
+        test_messages = [
+            # 應該路由到聊天
+            "你好，今天天氣如何？",
+            "請介紹一下你的功能",
+            
+            # 應該路由到搜尋
+            "iPhone 還有庫存嗎？",
+            "查詢價格在 2000 到 5000 的商品",
+            "我想看看訂單狀態",
+            
+            # 前綴指令
+            "/chat 你好！",
+            "/search iPhone 15",
+            "/help"
+        ]
+        
+        for message in test_messages:
+            try:
+                response = requests.post(
+                    f"{self.base_url}/route",
+                    json={"message": message, "user_id": "test_user"},
+                    headers={"Content-Type": "application/json"}
+                )
+                
+                success = response.status_code == 200
+                result = {
+                    "test": "smart_routing",
+                    "message": message,
+                    "success": success,
+                    "status_code": response.status_code,
+                    "response": response.json() if success else response.text
+                }
+                self.test_results.append(result)
+                
+                if success:
+                    data = response.json()
+                    mode = data.get('mode', 'unknown')
+                    print(f"✅ 路由: {message[:30]}... -> {mode}")
+                else:
+                    print(f"❌ 路由失敗: {message[:30]}... -> {response.status_code}")
+                    
+            except Exception as e:
+                print(f"❌ 智能路由錯誤: {e}")
+                self.test_results.append({
+                    "test": "smart_routing",
+                    "message": message,
+                    "success": False,
+                    "error": str(e)
+                })
+    
+    def test_stats_api(self):
+        """測試統計 API"""
+        print("\n📊 測試統計 API...")
+        try:
+            response = requests.get(f"{self.base_url}/stats")
+            success = response.status_code == 200
+            result = {
+                "test": "stats_api",
+                "success": success,
+                "status_code": response.status_code,
+                "response": response.json() if success else response.text
+            }
+            self.test_results.append(result)
+            
+            if success:
+                data = response.json()
+                stats = data.get('data', {}).get('stats', {})
+                total = data.get('data', {}).get('total', 0)
+                print(f"✅ 統計: 總計 {total} 次路由")
+                for mode, count in stats.items():
+                    print(f"   {mode}: {count}")
+            else:
+                print(f"❌ 統計失敗: {response.status_code}")
+                
+        except Exception as e:
+            print(f"❌ 統計 API 錯誤: {e}")
+            self.test_results.append({
+                "test": "stats_api",
+                "success": False,
+                "error": str(e)
+            })
+    
+    def test_line_webhook_simulation(self):
+        """模擬 LINE Webhook"""
+        print("\n📱 測試 LINE Webhook 模擬...")
+        test_messages = [
+            "/chat 你好！",
+            "/search iPhone",
+            "iPhone 還有庫存嗎？",
+            "幫助"
+        ]
+        
+        for message in test_messages:
+            webhook_data = {
+                "events": [
+                    {
+                        "type": "message",
+                        "message": {
+                            "type": "text",
+                            "text": message
+                        },
+                        "source": {
+                            "type": "user",
+                            "userId": "test_user_webhook"
+                        },
+                        "replyToken": "test_reply_token"
+                    }
+                ]
+            }
+            
+            try:
+                response = requests.post(
+                    f"{self.base_url}/webhook",
+                    json=webhook_data,
+                    headers={"Content-Type": "application/json"}
+                )
+                
+                success = response.status_code == 200
+                result = {
+                    "test": "line_webhook",
+                    "message": message,
+                    "success": success,
+                    "status_code": response.status_code
+                }
+                self.test_results.append(result)
+                
+                print(f"{'✅' if success else '❌'} Webhook: {message} -> {response.status_code}")
+                
+            except Exception as e:
+                print(f"❌ Webhook 錯誤: {e}")
+                self.test_results.append({
+                    "test": "line_webhook",
+                    "message": message,
+                    "success": False,
+                    "error": str(e)
+                })
+    
+    def generate_report(self):
+        """生成測試報告"""
+        print("\n" + "="*50)
+        print("📋 測試報告")
+        print("="*50)
+        
+        total_tests = len(self.test_results)
+        successful_tests = sum(1 for result in self.test_results if result.get('success', False))
+        
+        print(f"總測試數: {total_tests}")
+        print(f"���功: {successful_tests}")
+        print(f"失敗: {total_tests - successful_tests}")
+        print(f"成功率: {successful_tests/total_tests*100:.1f}%")
+        
+        # 按測試類型分組
+        test_types = {}
+        for result in self.test_results:
+            test_type = result['test']
+            if test_type not in test_types:
+                test_types[test_type] = {'total': 0, 'success': 0}
+            test_types[test_type]['total'] += 1
+            if result.get('success', False):
+                test_types[test_type]['success'] += 1
+        
+        print("\n📊 各功能測試結果:")
+        for test_type, stats in test_types.items():
+            success_rate = stats['success'] / stats['total'] * 100
+            print(f"  {test_type}: {stats['success']}/{stats['total']} ({success_rate:.1f}%)")
+        
+        # 顯示失敗的測試
+        failed_tests = [result for result in self.test_results if not result.get('success', False)]
+        if failed_tests:
+            print(f"\n❌ 失敗的測試 ({len(failed_tests)}):")
+            for result in failed_tests:
+                print(f"  - {result['test']}: {result.get('error', 'Unknown error')}")
+        
+        return {
+            'total': total_tests,
+            'successful': successful_tests,
+            'failed': total_tests - successful_tests,
+            'success_rate': successful_tests/total_tests*100,
+            'details': test_types,
+            'failed_tests': failed_tests
+        }
+
+def run_all_tests():
+    """執行所有測試"""
+    print("🚀 開始 Groq 整合測試")
+    print("="*50)
+    
+    tester = GroqIntegrationTester()
+    
+    # 執行所有測試
+    tester.test_health_check()
+    tester.test_chat_api()
+    tester.test_search_api()
+    tester.test_smart_routing()
+    tester.test_stats_api()
+    tester.test_line_webhook_simulation()
+    
+    # 生成報告
+    report = tester.generate_report()
+    
+    return report
+
+if __name__ == "__main__":
+    report = run_all_tests()
+    
+    # 保存詳細結果到文件
+    with open("tmp_rovodev_test_results.json", "w", encoding="utf-8") as f:
+        json.dump(report, f, ensure_ascii=False, indent=2)
+    
+    print(f"\n📄 詳細測試結果已保存到: tmp_rovodev_test_results.json")