first commit

.env.example

@@ -0,0 +1,18 @@
+# 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
+
+# OpenRouter 設定 (可選，用於進階 NLP)
+OPENROUTER_API_KEY=your_openrouter_api_key_here
+OPENROUTER_MODEL=anthropic/claude-3-haiku
+
+# 其他設定
+DEBUG=False
+LOG_LEVEL=INFO

API_KEYS_GUIDE.md

@@ -0,0 +1,215 @@
+# 🔑 API Keys 取得指南
+
+本文件詳細說明如何取得所有必要的 API Keys 來運行 LINE Bot 系統。
+
+## 📋 必要的 API Keys
+
+### 1. LINE Bot API Keys
+
+#### 步驟 1: 建立 LINE Developers 帳號
+1. 前往 [LINE Developers Console](https://developers.line.biz/)
+2. 使用 LINE 帳號登入
+3. 同意開發者條款
+
+#### 步驟 2: 建立 Provider
+1. 點擊 "Create a new provider"
+2. 輸入 Provider 名稱 (例如: "我的公司")
+3. 點擊 "Create"
+
+#### 步驟 3: 建立 Messaging API Channel
+1. 在 Provider 頁面點擊 "Create a Messaging API channel"
+2. 填寫以下資訊：
+   - **Channel name**: 您的 Bot 名稱
+   - **Channel description**: Bot 描述
+   - **Category**: 選擇適合的類別
+   - **Subcategory**: 選擇子類別
+3. 上傳 Channel icon (可選)
+4. 同意條款並點擊 "Create"
+
+#### 步驟 4: 取得 API Keys
+1. 進入剛建立的 Channel
+2. 前往 "Basic settings" 頁籤：
+   - 複製 **Channel secret** → 這是您的 `LINE_CHANNEL_SECRET`
+3. 前往 "Messaging API" 頁籤：
+   - 點擊 "Issue" 按鈕產生 Channel access token
+   - 複製 **Channel access token** → 這是您的 `LINE_CHANNEL_ACCESS_TOKEN`
+
+#### 步驟 5: 設定 Webhook (部署後執行)
+1. 在 "Messaging API" 頁籤中
+2. 設定 **Webhook URL**: `https://你的用戶名-你的空間名稱.hf.space/webhook`
+3. 啟用 "Use webhook"
+4. 關閉 "Auto-reply messages" (可選)
+
+### 2. Supabase API Keys
+
+#### 步驟 1: 建立 Supabase 帳號
+1. 前往 [Supabase](https://supabase.com/)
+2. 點擊 "Start your project"
+3. 使用 GitHub 或 Google 帳號註冊
+
+#### 步驟 2: 建立新專案
+1. 點擊 "New project"
+2. 選擇組織 (或建立新組織)
+3. 填寫專案資訊：
+   - **Name**: 專案名稱
+   - **Database Password**: 設定強密碼
+   - **Region**: 選擇最近的區域 (建議: Southeast Asia)
+4. 點擊 "Create new project"
+5. 等待專案建立完成 (約 2-3 分鐘)
+
+#### 步驟 3: 取得 API Keys
+1. 在專案 Dashboard 中
+2. 前往左側選單的 "Settings" → "API"
+3. 複製以下資訊：
+   - **URL** → 這是您的 `SUPABASE_URL`
+   - **anon public** key → 這是您的 `SUPABASE_KEY`
+
+#### 步驟 4: 建立資料表
+1. 前往左側選單的 "SQL Editor"
+2. 複製 `setup_guide.md` 中的 SQL 語句
+3. 點擊 "RUN" 執行
+
+## 🚀 可選的 API Keys
+
+### 3. OpenRouter API Keys (進階 NLP 功能)
+
+#### 步驟 1: 建立 OpenRouter 帳號
+1. 前往 [OpenRouter](https://openrouter.ai/)
+2. 點擊 "Sign Up"
+3. 使用 Google 或 GitHub 帳號註冊
+
+#### 步驟 2: 充值帳戶
+1. 前往 [Credits 頁面](https://openrouter.ai/credits)
+2. 點擊 "Add Credits"
+3. 選擇充值金額 (建議先充值 $5-10 測試)
+4. 完成付款
+
+#### 步驟 3: 建立 API Key
+1. 前往 [API Keys 頁面](https://openrouter.ai/keys)
+2. 點擊 "Create Key"
+3. 輸入 Key 名稱 (例如: "LINE Bot")
+4. 複製產生的 API Key → 這是您的 `OPENROUTER_API_KEY`
+
+#### 步驟 4: 選擇模型
+根據您的需求和預算選擇模型：
+
+| 模型 | 成本 | 適用場景 | 設定值 |
+|------|------|----------|--------|
+| Claude 3 Haiku | 最低 | 日常查詢 | `anthropic/claude-3-haiku` |
+| GPT-3.5 Turbo | 中等 | 平衡使用 | `openai/gpt-3.5-turbo` |
+| Claude 3 Sonnet | 較高 | 複雜查詢 | `anthropic/claude-3-sonnet` |
+
+## 🔧 環境變數設定
+
+### Hugging Face Spaces 設定
+
+1. 前往您的 Hugging Face Spaces 專案
+2. 點擊 "Settings" 頁籤
+3. 在 "Repository secrets" 區域新增以下變數：
+
+```bash
+# 必要設定
+LINE_CHANNEL_ACCESS_TOKEN=你的_LINE_Channel_Access_Token
+LINE_CHANNEL_SECRET=你的_LINE_Channel_Secret
+SUPABASE_URL=你的_Supabase_專案_URL
+SUPABASE_KEY=你的_Supabase_Anon_Key
+
+# 可選設定 (進階 NLP)
+OPENROUTER_API_KEY=你的_OpenRouter_API_Key
+OPENROUTER_MODEL=anthropic/claude-3-haiku
+
+# 其他設定
+DEBUG=False
+LOG_LEVEL=INFO
+```
+
+### 本地開發設定
+
+建立 `.env` 檔案：
+
+```bash
+cp .env.example .env
+```
+
+編輯 `.env` 檔案並填入您的 API Keys。
+
+## ✅ 驗證設定
+
+### 1. 測試 LINE Bot
+```bash
+# 檢查 LINE Channel 設定
+curl -H "Authorization: Bearer YOUR_CHANNEL_ACCESS_TOKEN" \
+     https://api.line.me/v2/bot/info
+```
+
+### 2. 測試 Supabase
+```bash
+# 檢查 Supabase 連線
+curl "YOUR_SUPABASE_URL/rest/v1/" \
+     -H "apikey: YOUR_SUPABASE_KEY"
+```
+
+### 3. 測試 OpenRouter
+```bash
+# 檢查 OpenRouter API
+curl https://openrouter.ai/api/v1/models \
+     -H "Authorization: Bearer YOUR_OPENROUTER_KEY"
+```
+
+## 🔒 安全性注意事項
+
+1. **絕不在程式碼中硬編碼 API Keys**
+2. **使用環境變數儲存敏感資訊**
+3. **定期輪換 API Keys**
+4. **監控 API 使用量和成本**
+5. **設定適當的權限和限制**
+
+## 💰 成本估算
+
+### LINE Bot
+- **免費額度**: 每月 1,000 則訊息
+- **付費方案**: 超過免費額度後按量計費
+
+### Supabase
+- **免費方案**: 
+  - 500MB 資料庫
+  - 50MB 檔案儲存
+  - 2GB 頻寬
+- **Pro 方案**: $25/月起
+
+### OpenRouter
+- **按使用量計費**
+- **Claude 3 Haiku**: ~$0.25/1M input tokens
+- **建議預算**: $5-20/月 (中小型應用)
+
+## 🆘 常見問題
+
+### Q: LINE Bot 無法回應訊息
+A: 檢查以下項目：
+1. Channel Access Token 是否正確
+2. Webhook URL 是否設定正確
+3. 應用程式是否正常運行
+
+### Q: Supabase 連線失敗
+A: 檢查以下項目：
+1. URL 和 API Key 是否正確
+2. 資料表是否已建立
+3. 網路連線是否正常
+
+### Q: OpenRouter 回應錯誤
+A: 檢查以下項目：
+1. API Key 是否有效
+2. 帳戶餘額是否充足
+3. 模型名稱是否正確
+
+## 📞 技術支援
+
+如果您在設定過程中遇到問題：
+
+1. **LINE Bot**: [LINE Developers 文件](https://developers.line.biz/en/docs/)
+2. **Supabase**: [Supabase 文件](https://supabase.com/docs)
+3. **OpenRouter**: [OpenRouter 文件](https://openrouter.ai/docs)
+
+---
+
+**提醒**: 請妥善保管您的 API Keys，避免洩露給他人使用。

BUSINESS_QUERY_GUIDE.md

@@ -0,0 +1,225 @@
+# 業務查詢系統使用指南
+
+## 概述
+
+本系統為您的 LINE 官方帳號提供了智能業務查詢功能，用戶可以透過自然語言詢問商品、庫存、訂單等業務資訊。系統整合了 Pydantic AI 進行語意分析，並提供友善的中文回應。
+
+## 系統架構
+
+```
+LINE 用戶訊息 → LINE Bot Service → Business Query Service → NLP Service + Database Service → 回應用戶
+```
+
+### 核心組件
+
+1. **NLP Service** (`backend/services/nlp_service.py`)
+   - 自然語言處理和意圖識別
+   - 實體提取和信心度計算
+   - 支援業務相關的查詢模式
+
+2. **Database Service** (`backend/services/database_service.py`)
+   - 資料庫查詢操作
+   - 業務專用查詢方法
+   - 支援商品、庫存、訂單等查詢
+
+3. **Business Query Service** (`backend/services/business_query_service.py`)
+   - 整合 NLP 和資料庫服務
+   - 統一的查詢處理入口
+   - 格式化回應訊息
+
+4. **LINE Bot Service** (`backend/services/line_bot_service.py`)
+   - 處理 LINE 平台的訊息
+   - 用戶管理和對話流程
+   - 快速回覆按鈕生成
+
+## 支援的查詢類型
+
+### 1. 商品查詢
+**用戶可以這樣問：**
+- "查詢商品 iPhone"
+- "有什麼筆記型電腦"
+- "商品價格查詢"
+- "找找看有沒有滑鼠"
+
+**系統回應範例：**
+```
+找到商品：
+名稱：iPhone 14 Pro
+描述：最新款智慧型手機
+價格：$35,900
+類別：手機
+```
+
+### 2. 庫存查詢
+**用戶可以這樣問：**
+- "庫存查詢 iPhone"
+- "筆記型電腦還有多少"
+- "查詢存貨狀況"
+- "iPhone 的庫存"
+
+**系統回應範例：**
+```
+庫存資訊：
+商品：iPhone 14 Pro
+目前庫存：25 件
+類別：手機
+價格：$35,900
+```
+
+### 3. 訂單查詢
+**用戶可以這樣問：**
+- "我的訂單"
+- "查詢訂單狀態"
+- "訂單編號 ORD001"
+- "購買記錄"
+
+**系統回應範例：**
+```
+找到 3 筆訂單：
+1. ORD001 - 已出貨 - $15,000
+2. ORD002 - 處理中 - $8,500
+3. ORD003 - 已完成 - $12,300
+```
+
+### 4. 低庫存警告
+**用戶可以這樣問：**
+- "低庫存商品"
+- "缺貨商品查詢"
+- "庫存不足的商品"
+
+**系統回應範例：**
+```
+⚠️ 發現 3 個低庫存商品：
+1. iPhone 13 - 剩餘：5 件
+2. MacBook Air - 剩餘：2 件
+3. AirPods Pro - 剩餘：8 件
+```
+
+### 5. 業務統計
+**用戶可以這樣問：**
+- "業務摘要"
+- "統計報表"
+- "總計資料"
+- "業務狀況"
+
+**系統回應範例：**
+```
+📊 業務摘要：
+商品總數：156 個
+訂單總數：89 筆
+用戶總數：45 人
+低庫存商品：3 個
+統計時間：2024-01-15T10:30:00
+```
+
+## 特殊指令
+
+### 幫助指令
+- `help`, `幫助`, `說明`, `指令`
+
+### 選單指令
+- `menu`, `選單`, `功能`
+
+## 快速開始
+
+### 1. 測試業務查詢功能
+```bash
+python tmp_rovodev_test_business_query.py
+```
+
+### 2. 測試 LINE Bot 整合
+```bash
+python tmp_rovodev_test_line_integration.py
+```
+
+### 3. 在您的應用中使用
+
+```python
+from backend.services.line_bot_service import LineBotService
+
+# 初始化服務
+line_service = LineBotService()
+
+# 處理用戶訊息
+response = line_service.handle_text_message(
+    user_id="U1234567890",
+    message_text="查詢商品 iPhone",
+    display_name="張小明"
+)
+
+print(response['text'])  # 系統回應
+```
+
+## 自訂擴展
+
+### 1. 新增查詢類型
+
+在 `nlp_service.py` 中新增意圖模式：
+
+```python
+self.business_intent_patterns = {
+    # 現有模式...
+    "new_query_type": [
+        r"新查詢.*模式",
+        r"特殊.*查詢"
+    ]
+}
+```
+
+在 `database_service.py` 中新增對應方法：
+
+```python
+def new_query_method(self, param1: str = None) -> DatabaseResult:
+    """新的查詢方法"""
+    # 實作查詢邏輯
+    pass
+```
+
+### 2. 自訂回應格式
+
+在 `nlp_service.py` 中修改格式化方法：
+
+```python
+def _format_custom_response(self, data: List[Dict[str, Any]]) -> str:
+    """自訂回應格式"""
+    # 實作自訂格式
+    pass
+```
+
+### 3. 整合其他資料源
+
+您可以修改 `database_service.py` 來連接其他資料庫或 API：
+
+```python
+def search_external_data(self, query: str) -> DatabaseResult:
+    """查詢外部資料源"""
+    # 連接外部 API 或資料庫
+    pass
+```
+
+## 注意事項
+
+1. **資料庫結構**: 目前的實作基於現有的 `Product`, `Order`, `User` 模型。如果您的資料庫結構不同，請相應調整查詢方法。
+
+2. **權限控制**: 系統目前允許所有查詢。在生產環境中，建議實作適當的權限控制。
+
+3. **效能考量**: 對於大量資料，建議加入分頁和快取機制。
+
+4. **錯誤處理**: 系統已包含基本的錯誤處理，但建議根據實際需求進一步完善。
+
+## 參考資料
+
+- `another_proj_schemas.py`: 包含完整的業務模型定義
+- `backend/database/models.py`: 資料庫模型定義
+- `backend/models/schemas.py`: API 回應模型定義
+
+## 技術支援
+
+如需��術支援或功能擴展，請參考：
+1. 測試腳本中的使用範例
+2. 各服務類別的文檔字串
+3. 錯誤日誌輸出
+
+---
+
+**注意**: 這是一個基礎實作，您可以根據實際業務需求進行擴展和優化。

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.12-slim
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

OPENROUTER_INTEGRATION.md

@@ -0,0 +1,273 @@
+# 🚀 OpenRouter 整合文件
+
+## 📋 概述
+
+本專案已整合 OpenRouter API 來提供進階的自然語言處理功能，包括：
+- 更精確的意圖識別
+- 智能實體提取
+- 自然的回應生成
+
+## 🔧 設定方式
+
+### 1. 取得 OpenRouter API Key
+
+1. 前往 [OpenRouter 官網](https://openrouter.ai/)
+2. 註冊帳號並登入
+3. 前往 [API Keys 頁面](https://openrouter.ai/keys)
+4. 建立新的 API Key
+5. 複製 API Key 備用
+
+### 2. 環境變數設定
+
+在 Hugging Face Spaces 的 Settings 中新增以下環境變數：
+
+```bash
+# 必要設定
+OPENROUTER_API_KEY=your_openrouter_api_key_here
+
+# 可選設定 (預設值已設定)
+OPENROUTER_MODEL=anthropic/claude-3-haiku
+```
+
+### 3. 支援的模型
+
+OpenRouter 支援多種 AI 模型，您可以根據需求選擇：
+
+#### 推薦模型 (成本效益佳)
+- `anthropic/claude-3-haiku` (預設) - 快速、便宜
+- `openai/gpt-3.5-turbo` - 平衡性能與成本
+- `meta-llama/llama-2-70b-chat` - 開源選項
+
+#### 高性能模型
+- `anthropic/claude-3-sonnet` - 更好的理解能力
+- `openai/gpt-4` - 最佳性能
+- `anthropic/claude-3-opus` - 最高品質
+
+#### 設定範例
+```bash
+# 使用 GPT-3.5 Turbo
+OPENROUTER_MODEL=openai/gpt-3.5-turbo
+
+# 使用 Claude 3 Sonnet
+OPENROUTER_MODEL=anthropic/claude-3-sonnet
+```
+
+## 🎯 功能特色
+
+### 1. 進階意圖識別
+
+OpenRouter 整合後，系統能更準確地識別用戶意圖：
+
+```python
+# 範例輸入
+"幫我找一下價格在一千到五千之間的手機"
+
+# 基礎 NLP (規則引擎)
+{
+    "intent": "search_product",
+    "confidence": 0.6,
+    "entities": {"min_price": 1000, "max_price": 5000}
+}
+
+# 進階 NLP (OpenRouter)
+{
+    "intent": "search_product",
+    "confidence": 0.9,
+    "entities": {
+        "min_price": 1000,
+        "max_price": 5000,
+        "category": "手機",
+        "product_type": "電子產品"
+    }
+}
+```
+
+### 2. 智能回應生成
+
+系統會根據查詢結果生成更自然的回應：
+
+```python
+# 基礎回應
+"找到 3 筆商品資料。"
+
+# 進階回應 (OpenRouter)
+"我為您找到了 3 款符合條件的手機：
+1. iPhone 15 Pro - NT$ 35,900
+2. Samsung Galaxy S24 - NT$ 28,900  
+3. Google Pixel 8 - NT$ 24,900
+
+這些都在您的預算範圍內，您想了解哪一款的詳細資訊呢？"
+```
+
+## 🔄 降級機制
+
+系統具有完整的降級機制：
+
+1. **優先使用 OpenRouter**: 如果 API Key 可用且正常運作
+2. **自動降級**: 如果 OpenRouter 失敗，自動使用基礎規則引擎
+3. **錯誤處理**: 完整的錯誤日誌和異常處理
+
+```python
+# 在程式碼中的實作
+def analyze_message(self, message: str, use_advanced: bool = True):
+    if use_advanced and self.openrouter_service.api_key:
+        try:
+            # 嘗試使用 OpenRouter
+            return advanced_analysis
+        except Exception as e:
+            logger.warning(f"進階 NLP 分析失敗，使用基礎分析: {str(e)}")
+    
+    # 降級到基礎規則引擎
+    return basic_analysis
+```
+
+## 💰 成本考量
+
+### 模型成本比較 (每 1M tokens)
+
+| 模型 | 輸入成本 | 輸出成本 | 適用場景 |
+|------|----------|----------|----------|
+| claude-3-haiku | $0.25 | $1.25 | 日常查詢 |
+| gpt-3.5-turbo | $0.50 | $1.50 | 平衡使用 |
+| claude-3-sonnet | $3.00 | $15.00 | 複雜查詢 |
+| gpt-4 | $10.00 | $30.00 | 高精度需求 |
+
+### 成本優化建議
+
+1. **使用 claude-3-haiku** 作為預設模型 (成本最低)
+2. **設定合理的 token 限制** (max_tokens: 300-500)
+3. **監控使用量** 透過 OpenRouter Dashboard
+4. **考慮快取機制** 對常見查詢進行快取
+
+## 🛠️ 開發與測試
+
+### 本地測試
+
+```bash
+# 設定環境變數
+export OPENROUTER_API_KEY="your_key_here"
+export OPENROUTER_MODEL="anthropic/claude-3-haiku"
+
+# 執行測試
+python test_api.py
+```
+
+### API 測試範例
+
+```python
+# 測試進階 NLP
+from backend.services.openrouter_service import OpenRouterService
+
+service = OpenRouterService()
+result = await service.analyze_intent_advanced("查詢用戶張三的訂單")
+print(result)
+```
+
+## 🔍 監控與除錯
+
+### 日誌監控
+
+系統會記錄以下資訊：
+
+```python
+# 成功使用 OpenRouter
+logger.info("使用 OpenRouter 進行進階分析")
+
+# 降級到基礎引擎
+logger.warning("進階 NLP 分析失敗，使用基礎分析")
+
+# API 錯誤
+logger.error("OpenRouter API 錯誤: 401 Unauthorized")
+```
+
+### 常見問題
+
+1. **API Key 無效**
+   - 檢查 API Key 是否正確
+   - 確認 OpenRouter 帳戶餘額
+
+2. **模型不存在**
+   - 檢查模型名稱是否正確
+   - 參考 OpenRouter 模型列表
+
+3. **請求超時**
+   - 檢查網路連線
+   - 考慮增加 timeout 設定
+
+## 📈 效能優化
+
+### 1. 異步處理
+
+```python
+# 使用 asyncio 避免阻塞
+async def analyze_intent_advanced(self, message: str):
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(...)
+```
+
+### 2. 錯誤重試
+
+```python
+# 實作重試機制
+for attempt in range(3):
+    try:
+        result = await openrouter_request()
+        break
+    except Exception as e:
+        if attempt == 2:
+            raise e
+        await asyncio.sleep(1)
+```
+
+### 3. 快取策略
+
+```python
+# 快取常見查詢結果
+@lru_cache(maxsize=100)
+def cached_analysis(message_hash: str):
+    return analysis_result
+```
+
+## 🚀 進階功能
+
+### 1. 自訂提示詞
+
+您可以修改 `openrouter_service.py` 中的提示詞來優化特定領域的表現：
+
+```python
+def _build_analysis_prompt(self, message: str):
+    # 自訂您的提示詞
+    prompt = f"""
+    您是一個專業的電商客服助手...
+    """
+```
+
+### 2. 多語言支援
+
+```python
+# 支援多語言分析
+def analyze_message_multilingual(self, message: str, language: str = "zh"):
+    prompt = self._build_multilingual_prompt(message, language)
+```
+
+### 3. 上下文記憶
+
+```python
+# 維護對話上下文
+def analyze_with_context(self, message: str, conversation_history: List[str]):
+    context = {"history": conversation_history}
+    return await self.analyze_intent_advanced(message, context)
+```
+
+## 📞 技術支援
+
+如果您在整合 OpenRouter 時遇到問題：
+
+1. 檢查 [OpenRouter 文件](https://openrouter.ai/docs)
+2. 查看系統日誌檔案
+3. 參考本專案的 `test_api.py` 進行測試
+4. 確認環境變數設定正確
+
+---
+
+**注意**: OpenRouter 是付費服務，請根據您的使用量選擇適合的模型和方案。

POSTGRESQL_MIGRATION_GUIDE.md

@@ -0,0 +1,342 @@
+# 🔄 PostgreSQL 直連遷移指南
+
+本文件說明如何從 Supabase SDK 遷移到 PostgreSQL 直連的詳細步驟和注意事項。
+
+## 📋 遷移概述
+
+### 變更內容
+- ✅ 移除 Supabase Python SDK 依賴
+- ✅ 新增 SQLAlchemy + psycopg 直連
+- ✅ 重構資料庫服務層
+- ✅ 新增 ORM 模型定義
+- ✅ 支援 Alembic 資料庫遷移
+
+### 優勢
+- 🚀 **更好的效能**: 直連減少中間層開銷
+- 🔧 **更多控制**: 完整的 SQL 查詢控制
+- 📊 **ORM 支援**: SQLAlchemy 提供強大的 ORM 功能
+- 🔄 **遷移管理**: Alembic 提供版本化的資料庫遷移
+- 🛡️ **連線池**: 自動連線池管理
+
+## 🔑 環境變數更新
+
+### 舊的 Supabase 設定
+```bash
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your-anon-key
+```
+
+### 新的 PostgreSQL 設定
+```bash
+DB_HOST=db.your-project.supabase.co
+DB_PORT=6543
+DB_NAME=postgres
+DB_USER=postgres
+DB_PASSWORD=your-database-password
+```
+
+## 🔍 如何取得 PostgreSQL 連線資訊
+
+### 從 Supabase Dashboard 取得
+
+1. **登入 Supabase Dashboard**
+   - 前往 [Supabase Dashboard](https://supabase.com/dashboard)
+   - 選擇您的專案
+
+2. **取得連線資訊**
+   - 前往 "Settings" → "Database"
+   - 在 "Connection info" 區域找到：
+     - **Host**: `db.your-project-ref.supabase.co`
+     - **Port**: `6543` (PostgreSQL 直連埠)
+     - **Database**: `postgres`
+     - **User**: `postgres`
+     - **Password**: 您設定的資料庫密碼
+
+3. **連線字串範例**
+   ```
+   postgresql://postgres:your-password@db.your-project-ref.supabase.co:6543/postgres
+   ```
+
+### 從其他 PostgreSQL 提供商取得
+
+如果您使用其他 PostgreSQL 服務：
+- **AWS RDS**: 在 RDS Console 中查看端點資訊
+- **Google Cloud SQL**: 在 Cloud Console 中查看連線詳情
+- **Azure Database**: 在 Azure Portal 中查看連線字串
+- **Railway/Render**: 在專案設定中查看資料庫資訊
+
+## 🛠️ 部署步驟
+
+### 1. 更新環境變數
+
+在 Hugging Face Spaces 的 Settings 中更新：
+
+```bash
+# 移除舊的 Supabase 設定
+# SUPABASE_URL=...
+# SUPABASE_KEY=...
+
+# 新增 PostgreSQL 設定
+DB_HOST=db.your-project-ref.supabase.co
+DB_PORT=6543
+DB_NAME=postgres
+DB_USER=postgres
+DB_PASSWORD=your-database-password
+
+# 其他設定保持不變
+LINE_CHANNEL_ACCESS_TOKEN=your-line-token
+LINE_CHANNEL_SECRET=your-line-secret
+OPENROUTER_API_KEY=your-openrouter-key
+OPENROUTER_MODEL=anthropic/claude-3-haiku
+```
+
+### 2. 初始化資料庫
+
+部署後，執行資料庫初始化：
+
+```bash
+# 在容器中執行
+python -m backend.database.init_db
+```
+
+或者透過 API 端點觸發初始化（如果實作了相關端點）。
+
+### 3. 驗證連線
+
+檢查健康檢查端點：
+```bash
+curl https://your-space-url.hf.space/health
+```
+
+應該會看到：
+```json
+{
+  "status": "healthy",
+  "message": "LINE Bot API is operational", 
+  "database": "connected",
+  "database_url": "postgresql://your-host:6543/postgres"
+}
+```
+
+## 📊 資料庫模型對應
+
+### 新的 SQLAlchemy 模型
+
+```python
+# backend/database/models.py
+
+class User(Base):
+    __tablename__ = "users"
+    user_id = Column(String(255), primary_key=True)
+    name = Column(String(255))
+    email = Column(String(255))
+    # ... 其他欄位
+
+class Product(Base):
+    __tablename__ = "products"
+    product_id = Column(Integer, primary_key=True)
+    name = Column(String(255), nullable=False)
+    price = Column(DECIMAL(10, 2), nullable=False)
+    # ... 其他欄位
+```
+
+### 資料表關聯
+
+```python
+# 一對多關聯
+class User(Base):
+    orders = relationship("Order", back_populates="user")
+
+class Order(Base):
+    user = relationship("User", back_populates="orders")
+    order_items = relationship("OrderItem", back_populates="order")
+```
+
+## 🔄 API 變更
+
+### 查詢方式變更
+
+#### 舊的 Supabase 方式
+```python
+result = supabase.table("users").select("*").eq("name", "張三").execute()
+```
+
+#### 新的 SQLAlchemy 方式
+```python
+db = get_database_session()
+users = db.query(User).filter(User.name == "張三").all()
+```
+
+### 錯誤處理改進
+
+```python
+def database_operation():
+    db = None
+    try:
+        db = get_database_session()
+        # 資料庫操作
+        result = db.query(User).all()
+        db.commit()
+        return result
+    except Exception as e:
+        if db:
+            db.rollback()
+        logger.error(f"資料庫操作失敗: {str(e)}")
+        raise
+    finally:
+        if db:
+            close_database_session(db)
+```
+
+## 🚀 效能優化
+
+### 連線池設定
+
+```python
+# backend/database/connection.py
+engine = create_engine(
+    settings.DATABASE_URL,
+    pool_size=10,          # 連線池大小
+    max_overflow=20,       # 最大溢出連線
+    pool_pre_ping=True,    # 連線前檢查
+    pool_recycle=3600,     # 1小時後回收連線
+)
+```
+
+### 查詢優化
+
+```python
+# 使用 eager loading 避免 N+1 查詢
+from sqlalchemy.orm import joinedload
+
+users_with_orders = db.query(User).options(
+    joinedload(User.orders)
+).all()
+
+# 使用索引優化查詢
+# 在模型中定義索引
+class User(Base):
+    __tablename__ = "users"
+    name = Column(String(255), index=True)  # 建立索引
+```
+
+## 🔧 開發工具
+
+### Alembic 遷移
+
+```bash
+# 初始化 Alembic
+alembic init alembic
+
+# 建立遷移檔案
+alembic revision --autogenerate -m "Initial migration"
+
+# 執行遷移
+alembic upgrade head
+
+# 回滾遷移
+alembic downgrade -1
+```
+
+### 本地開發
+
+```bash
+# 安裝依賴
+pip install -r requirements.txt
+
+# 設定環境變數
+export DB_HOST=localhost
+export DB_PORT=5432
+export DB_NAME=linebot_dev
+export DB_USER=postgres
+export DB_PASSWORD=password
+
+# 初始化資料庫
+python -m backend.database.init_db
+
+# 執行應用程式
+uvicorn backend.main:app --reload --port 7860
+```
+
+## 🛡️ 安全性考量
+
+### 連線安全
+
+1. **使用 SSL 連線**
+   ```python
+   DATABASE_URL = f"postgresql+psycopg://{user}:{password}@{host}:{port}/{db}?sslmode=require"
+   ```
+
+2. **限制資料庫權限**
+   - 建立專用的應用程式使用者
+   - 只授予必要的資料表權限
+   - 定期輪換密碼
+
+3. **連線字串保護**
+   - 使用環境變數儲存敏感資訊
+   - 避免在日誌中記錄連線字串
+   - 使用密碼管理工具
+
+## 📈 監控與除錯
+
+### 日誌設定
+
+```python
+# 啟用 SQLAlchemy 日誌
+engine = create_engine(
+    settings.DATABASE_URL,
+    echo=settings.DEBUG,  # 在 DEBUG 模式下顯示 SQL
+)
+```
+
+### 效能監控
+
+```python
+import time
+from functools import wraps
+
+def monitor_db_performance(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        execution_time = time.time() - start_time
+        logger.info(f"{func.__name__} 執行時間: {execution_time:.2f}秒")
+        return result
+    return wrapper
+```
+
+## 🚨 常見問題
+
+### Q: 連線失敗怎麼辦？
+A: 檢查以下項目：
+1. 主機名稱和埠號是否正確
+2. 使用者名稱和密碼是否正確
+3. 資料庫是否允許外部連線
+4. 防火牆設定是否正確
+
+### Q: 效能比 Supabase SDK 慢？
+A: 可能原因：
+1. 連線池設定不當
+2. 查詢未優化
+3. 缺少適當的索引
+4. 網路延遲問題
+
+### Q: 如何處理資料庫遷移？
+A: 使用 Alembic：
+1. 建立遷移腳本
+2. 在部署前測試遷移
+3. 備份資料庫
+4. 執行遷移
+
+## 📞 技術支援
+
+如果遇到問題：
+1. 檢查應用程式日誌
+2. 驗證環境變數設定
+3. 測試資料庫連線
+4. 參考 SQLAlchemy 官方文件
+
+---
+
+**注意**: 遷移前請務必備份您的資料庫，並在測試環境中驗證所有功能正常運作。

README.md

@@ -1,12 +1,39 @@
 ---
 title: Linebot Pydantic Fastapi
-emoji: 🔥
-colorFrom: red
-colorTo: pink
+emoji: 🤖
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
 license: mit
-short_description: practice pydantic
+short_description: LINE Bot with FastAPI, Pydantic, and Supabase for natural language database queries
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤖 LINE Bot + FastAPI + Pydantic + Supabase
+
+智能 LINE Bot，支援自然語言查詢資料庫功能。
+
+## ✨ 功能特色
+
+- 🔍 **自然語言查詢**: 支援中文自然語言查詢資料庫
+- 📊 **多種查詢類型**: 用戶、商品、訂單查詢及統計分析
+- 🚀 **FastAPI 框架**: 高效能 Web API
+- 📝 **Pydantic 驗證**: 強型別資料驗證
+- 🗄️ **Supabase 資料庫**: PostgreSQL 雲端資料庫
+- 💬 **LINE Bot 整合**: 完整的 LINE 訊息處理
+
+## 🚀 快速開始
+
+1. 設定環境變數（詳見 `setup_guide.md`）
+2. 建立 Supabase 資料表
+3. 設定 LINE Bot Webhook
+4. 開始使用！
+
+## 📖 使用範例
+
+- "查詢用戶 張三"
+- "找價格 1000 到 5000 的商品"
+- "統計訂單數量"
+- "我的訂單狀態"
+
+詳細設定說明請參考 [setup_guide.md](./setup_guide.md)

alembic.ini

@@ -0,0 +1,115 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version number format.  This value is passed to the
+# "strftime" function from the Python standard library.
+# see https://docs.python.org/library/datetime.html#strftime-strptime-behavior
+# for a list of codes that can be used in this string.
+# version_num_format = %%(year)d%%(month).2d%%(day).2d_%%(hour).2d%%(minute).2d
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses
+# os.pathsep. If this key is omitted entirely, it falls back to the legacy
+# behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

another_proj_schemas.py

@@ -0,0 +1,492 @@
+from pydantic import BaseModel, EmailStr, Field
+from typing import List, Optional, Union
+from datetime import datetime, date
+import enum
+
+# Import Enum types from models.py to be used in Pydantic schemas
+# This avoids redefining them and ensures consistency.
+# We might need to adjust models.py if enums are defined in a way that's hard to import directly
+# For now, let's assume we can import them or we'll redefine for Pydantic if necessary.
+# For simplicity in this step, I'll redefine them here. If issues arise, we can refactor.
+
+class UserRole(str, enum.Enum):
+    ADMIN = "ADMIN"
+    USER = "USER"
+
+class TransactionType(str, enum.Enum):
+    PURCHASE = "PURCHASE"
+    SELL = "SELL"
+
+class TransactionStatus(str, enum.Enum):
+    PENDING = "PENDING"
+    PROCESSING = "PROCESSING" # Added PROCESSING status
+    COMPLETED = "COMPLETED"
+    CANCELLED = "CANCELLED"
+
+# CustomerType 和 PaymentCategory 改為字串類型，支援動態值
+# PaymentMethod 改為支援動態字串，如 "月結30天", "下收" 等
+
+# Base and Read schemas for Category
+class CategoryBase(BaseModel):
+    name: str
+
+class CategoryCreate(CategoryBase):
+    pass
+
+class Category(CategoryBase): # For Read operations
+    id: int
+
+    class Config:
+        from_attributes = True
+
+# Base and Read schemas for Product - 根據客戶 Excel 欄位重新設計
+class ProductBase(BaseModel):
+    productCode: str = Field(..., description="貨品編號，必須唯一")
+    productName: str = Field(..., description="貨品名稱")
+    unit: str = Field(..., description="單位（箱、盒等）")
+    warehouse: Optional[str] = None  # 倉別
+    unitWeight: Optional[float] = None  # 單位重量(KG)
+    barcode: Optional[str] = None  # 條碼編號
+    category_id: int = Field(..., description="類別ID")
+
+class ProductCreate(ProductBase):
+    pass
+
+# For Read operations
+class Product(ProductBase):
+    id: int
+    stock: int = Field(default=0, description="庫存數量")  # 添加庫存欄位
+    is_deleted: bool = Field(default=False, description="是否已刪除")
+    deleted_at: Optional[datetime] = None
+    deleted_by: Optional[int] = None
+    createdAt: datetime
+    updatedAt: Optional[datetime] = None
+    category: Optional[Category] = None  # 包含類別詳細資訊
+
+    class Config:
+        from_attributes = True
+
+# Schemas for updating a product (all fields optional)
+class ProductUpdate(BaseModel):
+    productCode: Optional[str] = None
+    productName: Optional[str] = None
+    unit: Optional[str] = None
+    warehouse: Optional[str] = None
+    unitWeight: Optional[float] = None
+    barcode: Optional[str] = None
+    category_id: Optional[int] = None
+    stock: Optional[int] = Field(None, ge=0, description="庫存數量，必須大於等於0")  # 添加庫存更新
+
+
+# Base and Read schemas for Supplier
+class SupplierBase(BaseModel):
+    name: str
+    contactInfo: Optional[str] = None
+    address: Optional[str] = None
+
+class SupplierCreate(SupplierBase):
+    pass
+
+class Supplier(SupplierBase): # For Read operations
+    id: int
+
+    class Config:
+        from_attributes = True
+
+# Base and Read schemas for Customer
+class CustomerBase(BaseModel):
+    customerType: str
+    salesPersonId: Optional[str] = None
+    salesPersonName: Optional[str] = None
+    customerCode: str = Field(..., description="客戶編號，必須唯一")
+    customerName: str = Field(..., description="客戶名稱")
+    contactPerson: Optional[str] = None
+    invoiceTitle: Optional[str] = None
+    taxId: Optional[str] = None
+    phoneNumber: Optional[str] = None
+    faxNumber: Optional[str] = None
+    deliveryAddress: Optional[str] = None
+    businessHours: Optional[str] = None
+    paymentMethod: Optional[str] = None
+    paymentCategory: Optional[str] = None
+    creditLimit: Optional[float] = 0.0
+
+class CustomerCreate(CustomerBase):
+    pass
+
+class CustomerUpdate(BaseModel):
+    customerType: Optional[str] = None
+    salesPersonId: Optional[str] = None
+    salesPersonName: Optional[str] = None
+    customerCode: Optional[str] = None
+    customerName: Optional[str] = None
+    contactPerson: Optional[str] = None
+    invoiceTitle: Optional[str] = None
+    taxId: Optional[str] = None
+    phoneNumber: Optional[str] = None
+    faxNumber: Optional[str] = None
+    deliveryAddress: Optional[str] = None
+    businessHours: Optional[str] = None
+    paymentMethod: Optional[str] = None
+    paymentCategory: Optional[str] = None
+    creditLimit: Optional[float] = None
+
+class Customer(CustomerBase): # For Read operations
+    id: int
+    createdDate: datetime
+    updatedAt: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+# Base and Read schemas for User
+class UserBase(BaseModel):
+    name: Optional[str] = None
+    email: EmailStr
+    phoneNumber: Optional[str] = None
+    role: Optional[UserRole] = UserRole.USER
+
+class UserCreate(UserBase):
+    password: str = Field(..., min_length=4) # Example: make password required on create
+
+class UserUpdate(BaseModel): # For updating user profile
+    name: Optional[str] = None
+    email: Optional[EmailStr] = None
+    phoneNumber: Optional[str] = None
+    role: Optional[UserRole] = None
+    # Role and password updates might be handled by separate, more secure endpoints or admin functions
+
+class User(UserBase): # For Read operations (e.g., /users/current)
+    id: int
+    createdAt: datetime
+    # Do not include password in responses
+
+    class Config:
+        from_attributes = True
+
+
+# Schemas for TransactionProductAssociation (enhanced with pricing information)
+class TransactionProductAssociationBase(BaseModel):
+    product_id: int
+    quantity: Optional[int] = 1
+    unit_price: Optional[float] = None
+    line_total: Optional[float] = None
+    notes: Optional[str] = None
+
+class TransactionProductAssociationCreate(TransactionProductAssociationBase):
+    pass
+
+class TransactionProductAssociation(TransactionProductAssociationBase): # For Read
+    # Include product details for complete information
+    product: Optional[Product] = None
+
+    class Config:
+        from_attributes = True
+
+
+# Base and Read schemas for Transaction
+class TransactionBase(BaseModel):
+    totalProducts: int
+    totalPrice: float
+    transactionType: TransactionType
+    transactionStatus: Optional[TransactionStatus] = TransactionStatus.PENDING
+    description: Optional[str] = None
+    note: Optional[str] = None
+    user_id: Optional[int] = None # Assuming user_id is set based on authenticated user
+    supplier_id: Optional[int] = None
+    customer_id: Optional[int] = None # For sell transactions
+    # For creating transactions, the frontend might send a list of products involved
+    # This needs to align with how api.service.ts sends data for purchase/sell
+    # For example: products_involved: List[TransactionProductAssociationCreate]
+
+class TransactionCreate(TransactionBase):
+    # The frontend's purchaseProduct/sellProduct takes a 'body'. We need to match that structure.
+    # If 'body' contains a list of product IDs and quantities:
+    products_involved: List[TransactionProductAssociationCreate]
+
+
+class Transaction(TransactionBase): # For Read operations
+    id: int
+    createdAt: datetime
+    updatedAt: Optional[datetime] = None
+    user: Optional[User] = None # Nested user details
+    supplier: Optional[Supplier] = None # Nested supplier details
+    customer: Optional[Customer] = None # Nested customer details for sell transactions
+    products: List[TransactionProductAssociation] # List of products involved in the transaction
+
+    class Config:
+        from_attributes = True
+
+# Schema for updating transaction status (as per frontend api.service.ts)
+class TransactionStatusUpdate(BaseModel):
+    status: TransactionStatus # Frontend sends JSON.stringify(status) - need to ensure this matches
+
+# Schemas for Authentication
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    email: Optional[str] = None
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+
+# 採購單相關的枚舉類型
+class PurchaseOrderStatus(str, enum.Enum):
+    DRAFT = "DRAFT"           # 草稿
+    PENDING = "PENDING"       # 待處理
+    CONFIRMED = "CONFIRMED"   # 已確認
+    RECEIVED = "RECEIVED"     # 已收貨
+    CANCELLED = "CANCELLED"   # 已取消
+
+class PaymentStatus(str, enum.Enum):
+    UNPAID = "UNPAID"         # 未付款
+    PARTIAL = "PARTIAL"       # 部分付款
+    PAID = "PAID"             # 已付款
+
+class TaxType(str, enum.Enum):
+    INCLUSIVE = "INCLUSIVE"   # 含稅
+    EXCLUSIVE = "EXCLUSIVE"   # 未稅
+    ADDITIONAL = "ADDITIONAL" # 外加稅
+
+# 入庫單相關的枚舉類型
+class GoodsReceiptStatus(str, enum.Enum):
+    DRAFT = "DRAFT"           # 草稿
+    PENDING = "PENDING"       # 待處理
+    COMPLETED = "COMPLETED"   # 已完成
+    CANCELLED = "CANCELLED"   # 已取消
+
+class WarehouseType(str, enum.Enum):
+    MAIN = "MAIN"             # 主倉
+    RAW_MATERIAL = "RAW_MATERIAL"  # 原料倉
+    FINISHED_GOODS = "FINISHED_GOODS"  # 成品倉
+    QUARANTINE = "QUARANTINE" # 檢疫倉
+    DAMAGED = "DAMAGED"       # 損壞品倉
+
+# 銷售單相關的枚舉類型
+class SalesOrderStatus(str, enum.Enum):
+    DRAFT = "DRAFT"           # 草稿
+    CONFIRMED = "CONFIRMED"   # 已確認
+    SHIPPED = "SHIPPED"       # 已出貨
+    DELIVERED = "DELIVERED"   # 已送達
+    CANCELLED = "CANCELLED"   # 已取消
+
+class PaymentTerm(str, enum.Enum):
+    CASH = "CASH"             # 現金
+    MONTHLY = "MONTHLY"       # 月結
+    TRANSFER = "TRANSFER"     # 轉帳
+    CREDIT_CARD = "CREDIT_CARD"  # 信用卡
+    CHECK = "CHECK"           # 支票
+
+
+# 採購明細項目 schemas
+class PurchaseOrderItemBase(BaseModel):
+    product_id: int = Field(..., description="產品ID")
+    quantity: int = Field(..., gt=0, description="數量，必須大於0")
+    unit_price: float = Field(..., ge=0, description="單價，必須大於等於0")
+    notes: Optional[str] = None
+
+class PurchaseOrderItemCreate(PurchaseOrderItemBase):
+    pass
+
+class PurchaseOrderItemUpdate(BaseModel):
+    product_id: Optional[int] = None
+    quantity: Optional[int] = Field(None, gt=0)
+    unit_price: Optional[float] = Field(None, ge=0)
+    notes: Optional[str] = None
+
+class PurchaseOrderItem(PurchaseOrderItemBase):
+    id: int
+    line_total: float  # 小計 (數量 × 單價)
+    product: Optional[Product] = None  # 包含產品詳細資訊
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+
+# 採購單主檔 schemas
+class PurchaseOrderBase(BaseModel):
+    purchase_date: date = Field(..., description="採購日期")
+    expected_delivery_date: Optional[date] = None
+    supplier_id: int = Field(..., description="供應商ID")
+    notes: Optional[str] = None
+    tax_type: TaxType = TaxType.INCLUSIVE
+    tax_rate: float = Field(0.05, ge=0, le=1, description="稅率，0-1之間")
+    payment_method: Optional[str] = None
+
+class PurchaseOrderCreate(PurchaseOrderBase):
+    items: List[PurchaseOrderItemCreate] = Field(..., min_items=1, description="採購明細，至少要有一項")
+
+class PurchaseOrderUpdate(BaseModel):
+    purchase_date: Optional[date] = None
+    expected_delivery_date: Optional[date] = None
+    supplier_id: Optional[int] = None
+    status: Optional[PurchaseOrderStatus] = None
+    notes: Optional[str] = None
+    tax_type: Optional[TaxType] = None
+    tax_rate: Optional[float] = Field(None, ge=0, le=1)
+    payment_method: Optional[str] = None
+    payment_status: Optional[PaymentStatus] = None
+
+class PurchaseOrder(PurchaseOrderBase):
+    id: int
+    po_number: str  # 採購單號
+    purchaser_id: int
+    status: PurchaseOrderStatus
+    subtotal: float  # 小計
+    tax_amount: float  # 稅額
+    total_amount: float  # 含稅總額
+    payment_status: PaymentStatus
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    # 關聯資料
+    purchaser: Optional[User] = None
+    supplier: Optional[Supplier] = None
+    items: List[PurchaseOrderItem] = []
+
+    class Config:
+        from_attributes = True
+
+
+# 入庫明細項目 schemas
+class GoodsReceiptItemBase(BaseModel):
+    purchase_order_item_id: int = Field(..., description="採購明細ID")
+    product_id: int = Field(..., description="產品ID")
+    ordered_quantity: int = Field(..., gt=0, description="採購數量")
+    received_quantity: int = Field(..., ge=0, description="實到數量，必須大於等於0")
+    storage_location: Optional[str] = None
+    notes: Optional[str] = None
+
+class GoodsReceiptItemCreate(GoodsReceiptItemBase):
+    pass
+
+class GoodsReceiptItemUpdate(BaseModel):
+    purchase_order_item_id: Optional[int] = None  # 需要用來識別明細項目
+    product_id: Optional[int] = None              # 需要用來識別產品
+    received_quantity: Optional[int] = Field(None, ge=0)
+    storage_location: Optional[str] = None
+    notes: Optional[str] = None
+
+class GoodsReceiptItem(GoodsReceiptItemBase):
+    id: int
+    product: Optional[Product] = None  # 包含產品詳細資訊
+    purchase_order_item: Optional[PurchaseOrderItem] = None  # 包含採購明細資訊
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+
+# 入庫單主檔 schemas
+class GoodsReceiptBase(BaseModel):
+    receipt_date: date = Field(..., description="入庫日期")
+    purchase_order_id: int = Field(..., description="採購單ID")
+    warehouse_type: WarehouseType = WarehouseType.MAIN
+    warehouse_location: Optional[str] = None
+    notes: Optional[str] = None
+
+class GoodsReceiptCreate(GoodsReceiptBase):
+    items: List[GoodsReceiptItemCreate] = Field(..., min_items=1, description="入庫明細，至少要有一項")
+
+class GoodsReceiptUpdate(BaseModel):
+    receipt_date: Optional[date] = None
+    warehouse_type: Optional[WarehouseType] = None
+    warehouse_location: Optional[str] = None
+    status: Optional[GoodsReceiptStatus] = None
+    notes: Optional[str] = None
+    items: Optional[List[GoodsReceiptItemUpdate]] = None  # 新增入庫明細更新
+
+class GoodsReceipt(GoodsReceiptBase):
+    id: int
+    gr_number: str  # 入庫單號
+    warehouse_staff_id: int
+    status: GoodsReceiptStatus
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    # 關聯資料
+    warehouse_staff: Optional[User] = None
+    purchase_order: Optional[PurchaseOrder] = None
+    items: List[GoodsReceiptItem] = []
+
+    class Config:
+        from_attributes = True
+
+
+# 銷售明細項目 schemas
+class SalesOrderItemBase(BaseModel):
+    product_id: int = Field(..., description="產品ID")
+    quantity: int = Field(..., gt=0, description="數量，必須大於0")
+    unit_price: float = Field(..., ge=0, description="單價，必須大於等於0")
+    notes: Optional[str] = None
+
+class SalesOrderItemCreate(SalesOrderItemBase):
+    pass
+
+class SalesOrderItemUpdate(BaseModel):
+    product_id: Optional[int] = None
+    quantity: Optional[int] = Field(None, gt=0)
+    unit_price: Optional[float] = Field(None, ge=0)
+    notes: Optional[str] = None
+
+class SalesOrderItem(SalesOrderItemBase):
+    id: int
+    line_total: float  # 小計 (數量 × 單價)
+    product: Optional[Product] = None  # 包含產品詳細資訊
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+
+# 銷售單主檔 schemas
+class SalesOrderBase(BaseModel):
+    sales_date: date = Field(..., description="銷售日期")
+    customer_id: int = Field(..., description="客戶ID")
+    payment_term: PaymentTerm = PaymentTerm.CASH
+    notes: Optional[str] = None
+    tax_type: TaxType = TaxType.INCLUSIVE
+    tax_rate: float = Field(0.05, ge=0, le=1, description="稅率，0-1之間")
+    discount_rate: float = Field(0.0, ge=0, le=1, description="折扣率，0-1之間")
+
+class SalesOrderCreate(SalesOrderBase):
+    items: List[SalesOrderItemCreate] = Field(..., min_items=1, description="銷售明細，至少要有一項")
+
+class SalesOrderUpdate(BaseModel):
+    sales_date: Optional[date] = None
+    customer_id: Optional[int] = None
+    payment_term: Optional[PaymentTerm] = None
+    status: Optional[SalesOrderStatus] = None
+    notes: Optional[str] = None
+    tax_type: Optional[TaxType] = None
+    tax_rate: Optional[float] = Field(None, ge=0, le=1)
+    discount_rate: Optional[float] = Field(None, ge=0, le=1)
+    items: Optional[List[SalesOrderItemUpdate]] = None  # 銷售明細更新
+
+class SalesOrder(SalesOrderBase):
+    id: int
+    so_number: str  # 銷售單號
+    salesperson_id: int
+    status: SalesOrderStatus
+    subtotal: float  # 小計
+    tax_amount: float  # 稅額
+    discount_amount: float  # 折扣金額
+    total_amount: float  # 實收總額
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+    # 關聯資料
+    salesperson: Optional[User] = None
+    customer: Optional[Customer] = None
+    items: List[SalesOrderItem] = []
+
+    class Config:
+        from_attributes = True

app.py

@@ -0,0 +1,7 @@
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/")
+def greet_json():
+    return {"Hello": "World!"}

backend/config.py

@@ -0,0 +1,36 @@
+import os
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+class Settings(BaseSettings):
+    """應用程式設定"""
+    
+    # LINE Bot 設定
+    LINE_CHANNEL_ACCESS_TOKEN: str = os.getenv("LINE_CHANNEL_ACCESS_TOKEN", "")
+    LINE_CHANNEL_SECRET: str = os.getenv("LINE_CHANNEL_SECRET", "")
+    
+    # 資料庫設定 (PostgreSQL 直連)
+    DB_HOST: str = os.getenv("DB_HOST", "")
+    DB_PORT: str = os.getenv("DB_PORT", "6543")
+    DB_NAME: str = os.getenv("DB_NAME", "")
+    DB_USER: str = os.getenv("DB_USER", "")
+    DB_PASSWORD: str = os.getenv("DB_PASSWORD", "")
+    
+    # SQLAlchemy 資料庫 URL
+    @property
+    def DATABASE_URL(self) -> str:
+        return f"postgresql+psycopg://{self.DB_USER}:{self.DB_PASSWORD}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}"
+    
+    # OpenRouter 設定 (用於自然語言處理)
+    OPENROUTER_API_KEY: Optional[str] = os.getenv("OPENROUTER_API_KEY", "")
+    OPENROUTER_MODEL: str = os.getenv("OPENROUTER_MODEL", "anthropic/claude-3-haiku")
+    
+    # 其他設定
+    DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+settings = Settings()

backend/database/connection.py

@@ -0,0 +1,59 @@
+"""
+資料庫連線管理
+"""
+
+from sqlalchemy import create_engine, text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, Session
+from backend.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+# SQLAlchemy 設定
+engine = create_engine(
+    settings.DATABASE_URL,
+    echo=settings.DEBUG,  # 在 DEBUG 模式下顯示 SQL 語句
+    pool_size=10,
+    max_overflow=20,
+    pool_pre_ping=True,  # 連線前檢查
+    pool_recycle=3600,   # 1小時後回收連線
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+def get_database_session() -> Session:
+    """取得資料庫 session"""
+    db = SessionLocal()
+    try:
+        return db
+    except Exception as e:
+        db.close()
+        raise e
+
+def close_database_session(db: Session):
+    """關閉資料庫 session"""
+    try:
+        db.close()
+    except Exception as e:
+        logger.error(f"關閉資料庫 session 時發生錯誤: {str(e)}")
+
+def test_database_connection() -> bool:
+    """測試資料庫連線"""
+    try:
+        with engine.connect() as connection:
+            result = connection.execute(text("SELECT 1"))
+            return result.fetchone()[0] == 1
+    except Exception as e:
+        logger.error(f"資料庫連線測試失敗: {str(e)}")
+        return False
+
+# 依賴注入函數，用於 FastAPI
+def get_db():
+    """FastAPI 依賴注入函數"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

backend/database/init_db.py

@@ -0,0 +1,155 @@
+"""
+資料庫初始化腳本
+使用 SQLAlchemy 建立資料表和插入範例資料
+"""
+
+from sqlalchemy import create_engine
+from backend.database.connection import Base, engine
+from backend.database.models import User, Product, Order, OrderItem, LineMessage, UserSession
+from backend.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+def create_tables():
+    """建立所有資料表"""
+    try:
+        logger.info("開始建立資料表...")
+        Base.metadata.create_all(bind=engine)
+        logger.info("資料表建立完成！")
+        return True
+    except Exception as e:
+        logger.error(f"建立資料表失敗: {str(e)}")
+        return False
+
+def insert_sample_data():
+    """插入範例資料"""
+    from backend.database.connection import SessionLocal
+    
+    db = SessionLocal()
+    try:
+        logger.info("開始插入範例資料...")
+        
+        # 檢查是否已有資料
+        existing_products = db.query(Product).count()
+        if existing_products > 0:
+            logger.info("資料表已有資料，跳過範例資料插入")
+            return True
+        
+        # 插入範例商品
+        sample_products = [
+            Product(
+                name="iPhone 15 Pro",
+                description="最新款 iPhone，配備 A17 Pro 晶片",
+                price=35900,
+                stock=50,
+                category="手機"
+            ),
+            Product(
+                name="MacBook Air M2",
+                description="輕薄筆記型電腦，搭載 M2 晶片",
+                price=37900,
+                stock=30,
+                category="筆電"
+            ),
+            Product(
+                name="AirPods Pro",
+                description="主動降噪無線耳機",
+                price=7490,
+                stock=100,
+                category="耳機"
+            ),
+            Product(
+                name="iPad Air",
+                description="輕薄平板電腦，適合工作和娛樂",
+                price=18900,
+                stock=25,
+                category="平板"
+            ),
+            Product(
+                name="Apple Watch Series 9",
+                description="智慧手錶，健康監測功能",
+                price=12900,
+                stock=40,
+                category="穿戴裝置"
+            )
+        ]
+        
+        for product in sample_products:
+            db.add(product)
+        
+        # 插入範例用戶
+        sample_users = [
+            User(
+                user_id="U001",
+                name="張小明",
+                email="ming@example.com",
+                display_name="小明"
+            ),
+            User(
+                user_id="U002", 
+                name="李小華",
+                email="hua@example.com",
+                display_name="小華"
+            ),
+            User(
+                user_id="U003",
+                name="王小美",
+                email="mei@example.com", 
+                display_name="小美"
+            )
+        ]
+        
+        for user in sample_users:
+            db.add(user)
+        
+        # 提交變更
+        db.commit()
+        logger.info("範例資料插入完成！")
+        return True
+        
+    except Exception as e:
+        db.rollback()
+        logger.error(f"插入範例資料失敗: {str(e)}")
+        return False
+    finally:
+        db.close()
+
+def init_database():
+    """初始化資料庫"""
+    logger.info("=== 開始初始化資料庫 ===")
+    
+    # 建立資料表
+    if not create_tables():
+        logger.error("資料表建立失敗，停止初始化")
+        return False
+    
+    # 插入範例資料
+    if not insert_sample_data():
+        logger.error("範例資料插入失敗")
+        return False
+    
+    logger.info("=== 資料庫初始化完成 ===")
+    return True
+
+def drop_all_tables():
+    """刪除所有資料表（謹慎使用）"""
+    try:
+        logger.warning("正在刪除所有資料表...")
+        Base.metadata.drop_all(bind=engine)
+        logger.warning("所有資料表已刪除！")
+        return True
+    except Exception as e:
+        logger.error(f"刪除資料表失敗: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1 and sys.argv[1] == "--drop":
+        # 刪除並重建資料表
+        drop_all_tables()
+        init_database()
+    else:
+        # 正常初始化
+        init_database()

backend/database/models.py

@@ -0,0 +1,226 @@
+"""
+SQLAlchemy 資料庫模型 - 基於進銷存系統
+"""
+
+from sqlalchemy import Column, Integer, String, Text, DECIMAL, Boolean, DateTime, ForeignKey, JSON, Date, Float, Enum
+from sqlalchemy.sql import func
+from sqlalchemy.orm import relationship
+from backend.database.connection import Base
+import enum
+
+# 枚舉類型定義
+class UserRole(str, enum.Enum):
+    ADMIN = "ADMIN"
+    USER = "USER"
+
+class TransactionType(str, enum.Enum):
+    PURCHASE = "PURCHASE"
+    SELL = "SELL"
+
+class TransactionStatus(str, enum.Enum):
+    PENDING = "PENDING"
+    PROCESSING = "PROCESSING"
+    COMPLETED = "COMPLETED"
+    CANCELLED = "CANCELLED"
+
+class PurchaseOrderStatus(str, enum.Enum):
+    DRAFT = "DRAFT"
+    PENDING = "PENDING"
+    CONFIRMED = "CONFIRMED"
+    RECEIVED = "RECEIVED"
+    CANCELLED = "CANCELLED"
+
+class SalesOrderStatus(str, enum.Enum):
+    DRAFT = "DRAFT"
+    CONFIRMED = "CONFIRMED"
+    SHIPPED = "SHIPPED"
+    DELIVERED = "DELIVERED"
+    CANCELLED = "CANCELLED"
+
+class PaymentStatus(str, enum.Enum):
+    UNPAID = "UNPAID"
+    PARTIAL = "PARTIAL"
+    PAID = "PAID"
+
+# 基礎模型
+class User(Base):
+    """用戶模型"""
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255))
+    email = Column(String(255), unique=True, nullable=False)
+    phoneNumber = Column(String(50))
+    role = Column(Enum(UserRole), default=UserRole.USER)
+    createdAt = Column(DateTime(timezone=True), server_default=func.now())
+    
+    # 關聯
+    purchase_orders = relationship("PurchaseOrder", back_populates="purchaser")
+    sales_orders = relationship("SalesOrder", back_populates="salesperson")
+
+class Category(Base):
+    """商品類別模型"""
+    __tablename__ = "categories"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255), nullable=False)
+    
+    # 關聯
+    products = relationship("Product", back_populates="category")
+
+class Product(Base):
+    """商品模型"""
+    __tablename__ = "products"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    productCode = Column(String(100), unique=True, nullable=False)
+    productName = Column(String(255), nullable=False)
+    unit = Column(String(50), nullable=False)
+    warehouse = Column(String(100))
+    unitWeight = Column(Float)
+    barcode = Column(String(100))
+    category_id = Column(Integer, ForeignKey("categories.id"))
+    stock = Column(Integer, default=0)
+    is_deleted = Column(Boolean, default=False)
+    deleted_at = Column(DateTime(timezone=True))
+    deleted_by = Column(Integer)
+    createdAt = Column(DateTime(timezone=True), server_default=func.now())
+    updatedAt = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # 關聯
+    category = relationship("Category", back_populates="products")
+    purchase_order_items = relationship("PurchaseOrderItem", back_populates="product")
+    sales_order_items = relationship("SalesOrderItem", back_populates="product")
+
+class Supplier(Base):
+    """供應商模型"""
+    __tablename__ = "suppliers"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String(255), nullable=False)
+    contactInfo = Column(Text)
+    address = Column(Text)
+    
+    # 關聯
+    purchase_orders = relationship("PurchaseOrder", back_populates="supplier")
+
+class Customer(Base):
+    """客戶模型"""
+    __tablename__ = "customers"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    customerType = Column(String(100))
+    salesPersonId = Column(String(100))
+    salesPersonName = Column(String(255))
+    customerCode = Column(String(100), unique=True, nullable=False)
+    customerName = Column(String(255), nullable=False)
+    contactPerson = Column(String(255))
+    invoiceTitle = Column(String(255))
+    taxId = Column(String(50))
+    phoneNumber = Column(String(50))
+    faxNumber = Column(String(50))
+    deliveryAddress = Column(Text)
+    businessHours = Column(String(255))
+    paymentMethod = Column(String(100))
+    paymentCategory = Column(String(100))
+    creditLimit = Column(Float, default=0.0)
+    createdDate = Column(DateTime(timezone=True), server_default=func.now())
+    updatedAt = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # 關聯
+    sales_orders = relationship("SalesOrder", back_populates="customer")
+
+class PurchaseOrder(Base):
+    """採購單模型"""
+    __tablename__ = "purchase_orders"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    po_number = Column(String(100), unique=True, nullable=False)
+    purchase_date = Column(Date, nullable=False)
+    expected_delivery_date = Column(Date)
+    supplier_id = Column(Integer, ForeignKey("suppliers.id"))
+    purchaser_id = Column(Integer, ForeignKey("users.id"))
+    status = Column(Enum(PurchaseOrderStatus), default=PurchaseOrderStatus.DRAFT)
+    subtotal = Column(Float, default=0.0)
+    tax_amount = Column(Float, default=0.0)
+    total_amount = Column(Float, default=0.0)
+    payment_status = Column(Enum(PaymentStatus), default=PaymentStatus.UNPAID)
+    notes = Column(Text)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # 關聯
+    supplier = relationship("Supplier", back_populates="purchase_orders")
+    purchaser = relationship("User", back_populates="purchase_orders")
+    items = relationship("PurchaseOrderItem", back_populates="purchase_order")
+
+class PurchaseOrderItem(Base):
+    """採購單明細模型"""
+    __tablename__ = "purchase_order_items"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    purchase_order_id = Column(Integer, ForeignKey("purchase_orders.id"))
+    product_id = Column(Integer, ForeignKey("products.id"))
+    quantity = Column(Integer, nullable=False)
+    unit_price = Column(Float, nullable=False)
+    line_total = Column(Float, nullable=False)
+    notes = Column(Text)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # 關聯
+    purchase_order = relationship("PurchaseOrder", back_populates="items")
+    product = relationship("Product", back_populates="purchase_order_items")
+
+class SalesOrder(Base):
+    """銷售單模型"""
+    __tablename__ = "sales_orders"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    so_number = Column(String(100), unique=True, nullable=False)
+    sales_date = Column(Date, nullable=False)
+    customer_id = Column(Integer, ForeignKey("customers.id"))
+    salesperson_id = Column(Integer, ForeignKey("users.id"))
+    status = Column(Enum(SalesOrderStatus), default=SalesOrderStatus.DRAFT)
+    subtotal = Column(Float, default=0.0)
+    tax_amount = Column(Float, default=0.0)
+    discount_amount = Column(Float, default=0.0)
+    total_amount = Column(Float, default=0.0)
+    notes = Column(Text)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # 關聯
+    customer = relationship("Customer", back_populates="sales_orders")
+    salesperson = relationship("User", back_populates="sales_orders")
+    items = relationship("SalesOrderItem", back_populates="sales_order")
+
+class SalesOrderItem(Base):
+    """銷售單明細模型"""
+    __tablename__ = "sales_order_items"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    sales_order_id = Column(Integer, ForeignKey("sales_orders.id"))
+    product_id = Column(Integer, ForeignKey("products.id"))
+    quantity = Column(Integer, nullable=False)
+    unit_price = Column(Float, nullable=False)
+    line_total = Column(Float, nullable=False)
+    notes = Column(Text)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # 關聯
+    sales_order = relationship("SalesOrder", back_populates="items")
+    product = relationship("Product", back_populates="sales_order_items")
+
+# LINE Bot 相關模型
+class LineMessage(Base):
+    """LINE 訊息記錄模型"""
+    __tablename__ = "line_messages"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(String(255))
+    message = Column(Text, nullable=False)
+    message_type = Column(String(50), default="text")
+    timestamp = Column(DateTime(timezone=True), server_default=func.now())
+    processed = Column(Boolean, default=False)

backend/main.py

@@ -0,0 +1,99 @@
+import os
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from linebot import LineBotApi, WebhookHandler
+from linebot.exceptions import InvalidSignatureError
+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.config import settings
+from backend.database.connection import test_database_connection
+
+# 設定日誌
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="LINE Bot API", version="1.0.0")
+
+# CORS 設定
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# LINE Bot 初始化
+line_bot_api = LineBotApi(settings.LINE_CHANNEL_ACCESS_TOKEN)
+handler = WebhookHandler(settings.LINE_CHANNEL_SECRET)
+
+# 服務初始化
+nlp_service = NLPService()
+db_service = DatabaseService()
+
+@app.get("/")
+def greet_json():
+    return {"Hello": "LINE Bot API is running!"}
+
+@app.get("/health")
+def health_check():
+    # 檢查資料庫連線
+    db_status = "connected" if test_database_connection() else "disconnected"
+    
+    return {
+        "status": "healthy", 
+        "message": "LINE Bot API is operational",
+        "database": db_status,
+        "database_url": f"postgresql://{settings.DB_HOST}:{settings.DB_PORT}/{settings.DB_NAME}"
+    }
+
+@app.post("/webhook")
+async def callback(request: Request):
+    """LINE Bot Webhook 端點"""
+    signature = request.headers.get('X-Line-Signature', '')
+    body = await request.body()
+    
+    try:
+        handler.handle(body.decode('utf-8'), signature)
+    except InvalidSignatureError:
+        logger.error("Invalid signature")
+        raise HTTPException(status_code=400, detail="Invalid signature")
+    
+    return {"status": "ok"}
+
+@handler.add(MessageEvent, message=TextMessage)
+def handle_message(event):
+    """處理 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)
+        
+        # 回覆訊息
+        line_bot_api.reply_message(
+            event.reply_token,
+            TextSendMessage(text=reply_message)
+        )
+        
+    except Exception as e:
+        logger.error(f"處理訊息時發生錯誤: {str(e)}")
+        line_bot_api.reply_message(
+            event.reply_token,
+            TextSendMessage(text="抱歉，處理您的訊息時發生錯誤，請稍後再試。")
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

backend/models/schemas.py

@@ -0,0 +1,66 @@
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+from enum import Enum
+
+class QueryType(str, Enum):
+    """查詢類型枚舉"""
+    SEARCH = "search"
+    CREATE = "create"
+    UPDATE = "update"
+    DELETE = "delete"
+    ANALYTICS = "analytics"
+    UNKNOWN = "unknown"
+
+class NLPAnalysisRequest(BaseModel):
+    """NLP 分析請求模型"""
+    message: str = Field(..., description="用戶輸入的訊息")
+    user_id: Optional[str] = Field(None, description="用戶ID")
+    context: Optional[Dict[str, Any]] = Field(default_factory=dict, description="上下文資訊")
+
+class NLPAnalysisResult(BaseModel):
+    """NLP 分析結果模型"""
+    query_type: QueryType = Field(..., description="查詢類型")
+    intent: str = Field(..., description="用戶意圖")
+    entities: Dict[str, Any] = Field(default_factory=dict, description="提取的實體")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="信心度")
+    parameters: Dict[str, Any] = Field(default_factory=dict, description="查詢參數")
+    
+class DatabaseQuery(BaseModel):
+    """資料庫查詢模型"""
+    table_name: str = Field(..., description="資料表名稱")
+    operation: str = Field(..., description="操作類型")
+    conditions: Optional[Dict[str, Any]] = Field(default_factory=dict, description="查詢條件")
+    data: Optional[Dict[str, Any]] = Field(default_factory=dict, description="要操作的資料")
+    limit: Optional[int] = Field(None, description="查詢限制數量")
+    offset: Optional[int] = Field(None, description="查詢偏移量")
+
+class DatabaseResult(BaseModel):
+    """資料庫查詢結果模型"""
+    success: bool = Field(..., description="是否成功")
+    data: Optional[List[Dict[str, Any]]] = Field(default_factory=list, description="查詢結果資料")
+    count: Optional[int] = Field(None, description="結果數量")
+    error: Optional[str] = Field(None, description="錯誤訊息")
+    
+class LineMessage(BaseModel):
+    """LINE 訊息模型"""
+    user_id: str = Field(..., description="用戶ID")
+    message: str = Field(..., description="訊息內容")
+    timestamp: datetime = Field(default_factory=datetime.now, description="時間戳記")
+    message_type: str = Field(default="text", description="訊息類型")
+
+class UserProfile(BaseModel):
+    """用戶資料模型"""
+    user_id: str = Field(..., description="用戶ID")
+    display_name: Optional[str] = Field(None, description="顯示名稱")
+    status_message: Optional[str] = Field(None, description="狀態訊息")
+    picture_url: Optional[str] = Field(None, description="頭像URL")
+    created_at: datetime = Field(default_factory=datetime.now, description="建立時間")
+    updated_at: datetime = Field(default_factory=datetime.now, description="更新時間")
+
+class APIResponse(BaseModel):
+    """API 回應模型"""
+    success: bool = Field(..., description="是否成功")
+    message: str = Field(..., description="回應訊息")
+    data: Optional[Any] = Field(None, description="回應資料")
+    error: Optional[str] = Field(None, description="錯誤訊息")

backend/services/business_query_service.py

@@ -0,0 +1,169 @@
+"""
+業務查詢服務 - 整合 NLP 分析和資料庫查詢
+用於處理 LINE 用戶的自然語言業務查詢
+"""
+
+import logging
+from typing import Dict, Any, Optional
+from backend.services.nlp_service import NLPService
+from backend.services.database_service import DatabaseService
+from backend.models.schemas import DatabaseResult
+
+logger = logging.getLogger(__name__)
+
+class BusinessQueryService:
+    """業務查詢服務 - 整合自然語言處理和資料庫查詢"""
+    
+    def __init__(self):
+        self.nlp_service = NLPService()
+        self.db_service = DatabaseService()
+    
+    def process_user_query(self, user_message: str, user_id: str = None) -> Dict[str, Any]:
+        """
+        處理用戶查詢的主要入口點
+        
+        Args:
+            user_message: 用戶的自然語言查詢
+            user_id: 用戶ID（可選）
+            
+        Returns:
+            包含查詢結果和格式化回應的字典
+        """
+        try:
+            # 1. 使用 NLP 服務分析用戶查詢
+            analysis_result = self.nlp_service.analyze_business_query(user_message, user_id)
+            
+            logger.info(f"NLP 分析結果 - 意圖: {analysis_result.intent}, 信心度: {analysis_result.confidence}")
+            
+            # 2. 根據分析結果執行對應的資料庫查詢
+            db_result = self._execute_database_query(analysis_result)
+            
+            # 3. 格式化回應訊息
+            response_message = self.nlp_service.format_response_message(db_result, analysis_result.intent)
+            
+            # 4. 儲存查詢記錄（如果有用戶ID）
+            if user_id:
+                self.db_service.save_message(user_id, user_message, "query")
+            
+            return {
+                "success": db_result.success,
+                "intent": analysis_result.intent,
+                "confidence": analysis_result.confidence,
+                "entities": analysis_result.entities,
+                "response_message": response_message,
+                "data": db_result.data,
+                "count": db_result.count,
+                "error": db_result.error
+            }
+            
+        except Exception as e:
+            logger.error(f"處理用戶查詢時發生錯誤: {str(e)}")
+            return {
+                "success": False,
+                "intent": "unknown",
+                "confidence": 0.0,
+                "entities": {},
+                "response_message": f"抱歉，處理您的查詢時發生錯誤：{str(e)}",
+                "data": [],
+                "count": 0,
+                "error": str(e)
+            }
+    
+    def _execute_database_query(self, analysis_result) -> DatabaseResult:
+        """根據 NLP 分析結果執行對應的資料庫查詢"""
+        try:
+            method_name = analysis_result.parameters.get("method")
+            
+            if method_name == "search_products":
+                return self.db_service.search_products(
+                    query_text=analysis_result.parameters.get("query_text"),
+                    category=analysis_result.parameters.get("category"),
+                    limit=analysis_result.parameters.get("limit", 10)
+                )
+            
+            elif method_name == "check_inventory":
+                return self.db_service.check_inventory(
+                    product_name=analysis_result.parameters.get("product_name"),
+                    category=analysis_result.parameters.get("category")
+                )
+            
+            elif method_name == "search_orders":
+                return self.db_service.search_orders(
+                    user_id=analysis_result.parameters.get("user_id"),
+                    status=analysis_result.parameters.get("status"),
+                    limit=analysis_result.parameters.get("limit", 10)
+                )
+            
+            elif method_name == "get_low_stock_products":
+                return self.db_service.get_low_stock_products(
+                    threshold=analysis_result.parameters.get("threshold", 10)
+                )
+            
+            elif method_name == "get_business_summary":
+                return self.db_service.get_business_summary()
+            
+            else:
+                # 使用通用的自然語言查詢處理
+                return self.db_service.process_natural_language_query(
+                    analysis_result.parameters.get("query_text", ""),
+                    analysis_result.parameters.get("user_id")
+                )
+                
+        except Exception as e:
+            logger.error(f"執行資料庫查詢時發生錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"資料庫查詢失敗: {str(e)}"
+            )
+    
+    def get_query_suggestions(self, user_id: str = None) -> List[str]:
+        """提供查詢建議"""
+        suggestions = [
+            "查詢商品 iPhone",
+            "庫存查詢 筆記型電腦",
+            "我的訂單",
+            "低庫存商品",
+            "業務統計摘要",
+            "查詢客戶資料",
+            "今天的銷售報表"
+        ]
+        return suggestions
+    
+    def get_help_message(self) -> str:
+        """取得幫助訊息"""
+        help_text = """
+🤖 智能查詢助手使用說明：
+
+📦 商品查詢：
+• "查詢商品 iPhone"
+• "有什麼筆記型電腦"
+• "商品價格查詢"
+
+📊 庫存查詢：
+• "庫存查詢 iPhone"
+• "筆記型電腦還有多少"
+• "查詢存貨狀況"
+
+📋 訂單查詢：
+• "我的訂單"
+• "查詢訂單狀態"
+• "訂單編號 ORD001"
+
+⚠️ 庫存警告：
+• "低庫存商品"
+• "缺貨商品查詢"
+
+📈 業務統計：
+• "業務摘要"
+• "統計報表"
+• "總計資料"
+
+💡 您可以用自然語言提問，系統會智能理解您的需求！
+        """
+        return help_text.strip()
+
+    def validate_user_permissions(self, user_id: str, query_type: str) -> bool:
+        """驗證用戶權限（可根據需要擴展）"""
+        # 這裡可以根據用戶角色和查詢類型來驗證權限
+        # 目前先返回 True，允許所有查詢
+        return True

backend/services/database_service.py

@@ -0,0 +1,765 @@
+import os
+from typing import Dict, Any, List, Optional
+from sqlalchemy.orm import Session
+from sqlalchemy import text, and_, or_
+from backend.models.schemas import NLPAnalysisResult, DatabaseResult, QueryType
+from backend.config import settings
+from backend.database.connection import get_database_session, close_database_session
+from backend.database.models import User, Product, Order, OrderItem, LineMessage, UserSession
+import logging
+
+logger = logging.getLogger(__name__)
+
+class DatabaseService:
+    """資料庫服務"""
+    
+    def __init__(self):
+        self.model_mapping = {
+            "users": User,
+            "products": Product,
+            "orders": Order,
+            "order_items": OrderItem,
+            "line_messages": LineMessage,
+            "user_sessions": UserSession
+        }
+        
+        # 定義資料表結構
+        self.table_schemas = {
+            "users": {
+                "model": User,
+                "searchable": ["name", "email", "display_name"]
+            },
+            "orders": {
+                "model": Order,
+                "searchable": ["order_id", "status"]
+            },
+            "products": {
+                "model": Product,
+                "searchable": ["name", "category", "description"]
+            },
+            "line_messages": {
+                "model": LineMessage,
+                "searchable": ["message", "user_id"]
+            },
+            "order_items": {
+                "model": OrderItem,
+                "searchable": []
+            },
+            "user_sessions": {
+                "model": UserSession,
+                "searchable": ["user_id"]
+            }
+        }
+
+    def execute_query(self, analysis_result: NLPAnalysisResult) -> DatabaseResult:
+        """執行資料庫查詢"""
+        try:
+            query_type = analysis_result.query_type
+            parameters = analysis_result.parameters
+            
+            if query_type == QueryType.SEARCH:
+                return self._execute_search(parameters)
+            elif query_type == QueryType.CREATE:
+                return self._execute_create(parameters)
+            elif query_type == QueryType.UPDATE:
+                return self._execute_update(parameters)
+            elif query_type == QueryType.DELETE:
+                return self._execute_delete(parameters)
+            elif query_type == QueryType.ANALYTICS:
+                return self._execute_analytics(parameters)
+            else:
+                return DatabaseResult(
+                    success=False,
+                    error="不支援的查詢類型"
+                )
+                
+        except Exception as e:
+            logger.error(f"資料庫查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"資料庫查詢失敗: {str(e)}"
+            )
+
+    def _execute_search(self, parameters: Dict[str, Any]) -> DatabaseResult:
+        """執行搜尋查詢"""
+        table_name = parameters.get("table", "users")
+        conditions = parameters.get("conditions", {})
+        limit = parameters.get("limit", 10)
+        offset = parameters.get("offset", 0)
+        
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 取得對應的模型
+            model = self.table_schemas.get(table_name, {}).get("model")
+            if not model:
+                return DatabaseResult(
+                    success=False,
+                    error=f"不支援的資料表: {table_name}"
+                )
+            
+            # 建立查詢
+            query = db.query(model)
+            
+            # 添加條件
+            for field, value in conditions.items():
+                if hasattr(model, field):
+                    column = getattr(model, field)
+                    
+                    if isinstance(value, dict):
+                        # 處理範圍查詢
+                        if "gte" in value:
+                            query = query.filter(column >= value["gte"])
+                        if "lte" in value:
+                            query = query.filter(column <= value["lte"])
+                        if "gt" in value:
+                            query = query.filter(column > value["gt"])
+                        if "lt" in value:
+                            query = query.filter(column < value["lt"])
+                    else:
+                        # 處理精確匹配或模糊搜尋
+                        searchable_fields = self.table_schemas.get(table_name, {}).get("searchable", [])
+                        if field in searchable_fields:
+                            query = query.filter(column.ilike(f"%{value}%"))
+                        else:
+                            query = query.filter(column == value)
+            
+            # 添加限制和偏移
+            query = query.offset(offset).limit(limit)
+            
+            # 執行查詢
+            results = query.all()
+            
+            # 轉換為字典格式
+            data = []
+            for result in results:
+                item = {}
+                for column in result.__table__.columns:
+                    value = getattr(result, column.name)
+                    # 處理特殊類型
+                    if hasattr(value, 'isoformat'):  # datetime
+                        item[column.name] = value.isoformat()
+                    elif isinstance(value, (int, float, str, bool)) or value is None:
+                        item[column.name] = value
+                    else:
+                        item[column.name] = str(value)
+                data.append(item)
+            
+            return DatabaseResult(
+                success=True,
+                data=data,
+                count=len(data)
+            )
+            
+        except Exception as e:
+            logger.error(f"搜尋查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"搜尋失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def _execute_create(self, parameters: Dict[str, Any]) -> DatabaseResult:
+        """執行建立查詢"""
+        table_name = parameters.get("table", "users")
+        data = parameters.get("data", {})
+        
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 取得對應的模型
+            model = self.table_schemas.get(table_name, {}).get("model")
+            if not model:
+                return DatabaseResult(
+                    success=False,
+                    error=f"不支援的資料表: {table_name}"
+                )
+            
+            # 建立新記錄
+            new_record = model(**data)
+            db.add(new_record)
+            db.commit()
+            db.refresh(new_record)
+            
+            # 轉換為字典格式
+            result_data = {}
+            for column in new_record.__table__.columns:
+                value = getattr(new_record, column.name)
+                if hasattr(value, 'isoformat'):  # datetime
+                    result_data[column.name] = value.isoformat()
+                elif isinstance(value, (int, float, str, bool)) or value is None:
+                    result_data[column.name] = value
+                else:
+                    result_data[column.name] = str(value)
+            
+            return DatabaseResult(
+                success=True,
+                data=[result_data],
+                count=1
+            )
+            
+        except Exception as e:
+            if db:
+                db.rollback()
+            logger.error(f"建立查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"建立失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def _execute_update(self, parameters: Dict[str, Any]) -> DatabaseResult:
+        """執行更新查詢"""
+        table_name = parameters.get("table", "users")
+        conditions = parameters.get("conditions", {})
+        data = parameters.get("data", {})
+        
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 取得對應的模型
+            model = self.table_schemas.get(table_name, {}).get("model")
+            if not model:
+                return DatabaseResult(
+                    success=False,
+                    error=f"不支援的資料表: {table_name}"
+                )
+            
+            # 建立查詢
+            query = db.query(model)
+            
+            # 添加條件
+            for field, value in conditions.items():
+                if hasattr(model, field):
+                    column = getattr(model, field)
+                    query = query.filter(column == value)
+            
+            # 執行更新
+            updated_count = query.update(data)
+            db.commit()
+            
+            # 取得更新後的資料
+            updated_records = query.all()
+            
+            # 轉換為字典格式
+            result_data = []
+            for record in updated_records:
+                item = {}
+                for column in record.__table__.columns:
+                    value = getattr(record, column.name)
+                    if hasattr(value, 'isoformat'):  # datetime
+                        item[column.name] = value.isoformat()
+                    elif isinstance(value, (int, float, str, bool)) or value is None:
+                        item[column.name] = value
+                    else:
+                        item[column.name] = str(value)
+                result_data.append(item)
+            
+            return DatabaseResult(
+                success=True,
+                data=result_data,
+                count=updated_count
+            )
+            
+        except Exception as e:
+            if db:
+                db.rollback()
+            logger.error(f"更新查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"更新失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def _execute_delete(self, parameters: Dict[str, Any]) -> DatabaseResult:
+        """執行刪除查詢"""
+        table_name = parameters.get("table", "users")
+        conditions = parameters.get("conditions", {})
+        
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 取得對應的模型
+            model = self.table_schemas.get(table_name, {}).get("model")
+            if not model:
+                return DatabaseResult(
+                    success=False,
+                    error=f"不支援的資料表: {table_name}"
+                )
+            
+            # 建立查詢
+            query = db.query(model)
+            
+            # 添加條件
+            for field, value in conditions.items():
+                if hasattr(model, field):
+                    column = getattr(model, field)
+                    query = query.filter(column == value)
+            
+            # 先取得要刪除的記錄
+            records_to_delete = query.all()
+            
+            # 轉換為字典格式
+            result_data = []
+            for record in records_to_delete:
+                item = {}
+                for column in record.__table__.columns:
+                    value = getattr(record, column.name)
+                    if hasattr(value, 'isoformat'):  # datetime
+                        item[column.name] = value.isoformat()
+                    elif isinstance(value, (int, float, str, bool)) or value is None:
+                        item[column.name] = value
+                    else:
+                        item[column.name] = str(value)
+                result_data.append(item)
+            
+            # 執行刪除
+            deleted_count = query.delete()
+            db.commit()
+            
+            return DatabaseResult(
+                success=True,
+                data=result_data,
+                count=deleted_count
+            )
+            
+        except Exception as e:
+            if db:
+                db.rollback()
+            logger.error(f"刪除查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"刪除失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def _execute_analytics(self, parameters: Dict[str, Any]) -> DatabaseResult:
+        """執行分析查詢"""
+        table_name = parameters.get("table", "users")
+        
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 取得對應的模型
+            model = self.table_schemas.get(table_name, {}).get("model")
+            if not model:
+                return DatabaseResult(
+                    success=False,
+                    error=f"不支援的資料表: {table_name}"
+                )
+            
+            # 執行計數查詢
+            total_count = db.query(model).count()
+            
+            # 取得範例資料
+            sample_records = db.query(model).limit(5).all()
+            
+            # 轉換範例資料為字典格式
+            sample_data = []
+            for record in sample_records:
+                item = {}
+                for column in record.__table__.columns:
+                    value = getattr(record, column.name)
+                    if hasattr(value, 'isoformat'):  # datetime
+                        item[column.name] = value.isoformat()
+                    elif isinstance(value, (int, float, str, bool)) or value is None:
+                        item[column.name] = value
+                    else:
+                        item[column.name] = str(value)
+                sample_data.append(item)
+            
+            analytics_data = [{
+                "table": table_name,
+                "count": total_count,
+                "data_sample": sample_data
+            }]
+            
+            return DatabaseResult(
+                success=True,
+                data=analytics_data,
+                count=1
+            )
+            
+        except Exception as e:
+            logger.error(f"分析查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"分析失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def save_message(self, user_id: str, message: str, message_type: str = "text") -> bool:
+        """儲存訊息記錄"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            new_message = LineMessage(
+                user_id=user_id,
+                message=message,
+                message_type=message_type
+            )
+            
+            db.add(new_message)
+            db.commit()
+            return True
+            
+        except Exception as e:
+            if db:
+                db.rollback()
+            logger.error(f"儲存訊息錯誤: {str(e)}")
+            return False
+        finally:
+            if db:
+                close_database_session(db)
+
+    def get_user_profile(self, user_id: str) -> Optional[Dict[str, Any]]:
+        """取得用戶資料"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            user = db.query(User).filter(User.user_id == user_id).first()
+            if not user:
+                return None
+            
+            # 轉換為字典格式
+            user_data = {}
+            for column in user.__table__.columns:
+                value = getattr(user, column.name)
+                if hasattr(value, 'isoformat'):  # datetime
+                    user_data[column.name] = value.isoformat()
+                elif isinstance(value, (int, float, str, bool)) or value is None:
+                    user_data[column.name] = value
+                else:
+                    user_data[column.name] = str(value)
+            
+            return user_data
+            
+        except Exception as e:
+            logger.error(f"取得用戶資料錯誤: {str(e)}")
+            return None
+        finally:
+            if db:
+                close_database_session(db)
+
+    def create_user_profile(self, user_data: Dict[str, Any]) -> bool:
+        """建立用戶資料"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            new_user = User(**user_data)
+            db.add(new_user)
+            db.commit()
+            return True
+            
+        except Exception as e:
+            if db:
+                db.rollback()
+            logger.error(f"建立用戶資料錯誤: {str(e)}")
+            return False
+        finally:
+            if db:
+                close_database_session(db)
+
+    # ==================== 業務專用查詢方法 ====================
+    
+    def search_products(self, query_text: str = None, category: str = None, 
+                       warehouse: str = None, limit: int = 10) -> DatabaseResult:
+        """商品查詢 - 支援自然語言查詢"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 建立基本查詢
+            query = db.query(Product)
+            
+            # 如果有查詢文字，進行模糊搜尋
+            if query_text:
+                search_filter = or_(
+                    Product.name.ilike(f"%{query_text}%"),
+                    Product.description.ilike(f"%{query_text}%")
+                )
+                query = query.filter(search_filter)
+            
+            # 類別篩選
+            if category:
+                query = query.filter(Product.category.ilike(f"%{category}%"))
+            
+            # 執行查詢
+            products = query.limit(limit).all()
+            
+            # 轉換為字典格式
+            data = []
+            for product in products:
+                product_data = {
+                    "id": product.id,
+                    "name": product.name,
+                    "description": product.description,
+                    "price": float(product.price) if product.price else 0.0,
+                    "category": product.category,
+                    "stock": product.stock if hasattr(product, 'stock') else 0,
+                    "created_at": product.created_at.isoformat() if product.created_at else None
+                }
+                data.append(product_data)
+            
+            return DatabaseResult(
+                success=True,
+                data=data,
+                count=len(data)
+            )
+            
+        except Exception as e:
+            logger.error(f"商品查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"商品查詢失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def check_inventory(self, product_name: str = None, category: str = None) -> DatabaseResult:
+        """庫存查詢"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 建立查詢
+            query = db.query(Product)
+            
+            # 根據商品名稱查詢
+            if product_name:
+                query = query.filter(Product.name.ilike(f"%{product_name}%"))
+            
+            # 類別篩選
+            if category:
+                query = query.filter(Product.category.ilike(f"%{category}%"))
+            
+            products = query.all()
+            
+            # 準備庫存資料
+            inventory_data = []
+            for product in products:
+                stock_info = {
+                    "product_name": product.name,
+                    "category": product.category,
+                    "current_stock": product.stock if hasattr(product, 'stock') else 0,
+                    "price": float(product.price) if product.price else 0.0,
+                    "description": product.description,
+                    "last_updated": product.updated_at.isoformat() if product.updated_at else None
+                }
+                inventory_data.append(stock_info)
+            
+            return DatabaseResult(
+                success=True,
+                data=inventory_data,
+                count=len(inventory_data)
+            )
+            
+        except Exception as e:
+            logger.error(f"庫存查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"庫存查詢失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def search_orders(self, user_id: str = None, status: str = None, limit: int = 10) -> DatabaseResult:
+        """訂單查詢"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            query = db.query(Order)
+            
+            # 用戶篩選
+            if user_id:
+                query = query.filter(Order.user_id == user_id)
+            
+            # 狀態篩選
+            if status:
+                query = query.filter(Order.status.ilike(f"%{status}%"))
+            
+            orders = query.limit(limit).all()
+            
+            # 轉換為字典格式
+            order_data = []
+            for order in orders:
+                order_info = {
+                    "order_id": order.order_id,
+                    "user_id": order.user_id,
+                    "status": order.status,
+                    "total_amount": float(order.total_amount) if order.total_amount else 0.0,
+                    "created_at": order.created_at.isoformat() if order.created_at else None,
+                    "updated_at": order.updated_at.isoformat() if order.updated_at else None
+                }
+                order_data.append(order_info)
+            
+            return DatabaseResult(
+                success=True,
+                data=order_data,
+                count=len(order_data)
+            )
+            
+        except Exception as e:
+            logger.error(f"訂單查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"訂單查詢失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def get_low_stock_products(self, threshold: int = 10) -> DatabaseResult:
+        """低庫存商品查詢"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 查詢庫存低於閾值的商品
+            # 注意：這裡假設 Product 模型有 stock 欄位，需要根據實際情況調整
+            query = db.query(Product)
+            if hasattr(Product, 'stock'):
+                query = query.filter(Product.stock <= threshold)
+            
+            low_stock_products = query.all()
+            
+            data = []
+            for product in low_stock_products:
+                product_data = {
+                    "product_name": product.name,
+                    "current_stock": product.stock if hasattr(product, 'stock') else 0,
+                    "category": product.category,
+                    "price": float(product.price) if product.price else 0.0,
+                    "status": "庫存不足"
+                }
+                data.append(product_data)
+            
+            return DatabaseResult(
+                success=True,
+                data=data,
+                count=len(data)
+            )
+            
+        except Exception as e:
+            logger.error(f"低庫存查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"低庫存查詢失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def get_business_summary(self) -> DatabaseResult:
+        """業務摘要統計"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 基本統計
+            total_products = db.query(Product).count()
+            total_orders = db.query(Order).count()
+            total_users = db.query(User).count()
+            
+            # 計算低庫存商品數量
+            low_stock_count = 0
+            if hasattr(Product, 'stock'):
+                low_stock_count = db.query(Product).filter(Product.stock <= 10).count()
+            
+            # 準備摘要資料
+            summary_data = [{
+                "total_products": total_products,
+                "total_orders": total_orders,
+                "total_users": total_users,
+                "low_stock_items": low_stock_count,
+                "report_date": datetime.now().isoformat()
+            }]
+            
+            return DatabaseResult(
+                success=True,
+                data=summary_data,
+                count=1
+            )
+            
+        except Exception as e:
+            logger.error(f"業務摘要查詢錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"業務摘要查詢失敗: {str(e)}"
+            )
+        finally:
+            if db:
+                close_database_session(db)
+
+    def process_natural_language_query(self, user_message: str, user_id: str = None) -> DatabaseResult:
+        """處理自然語言查詢的統一入口"""
+        try:
+            # 簡單的關鍵字匹配來判斷查詢意圖
+            message_lower = user_message.lower()
+            
+            # 商品查詢
+            if any(keyword in message_lower for keyword in ['商品', '產品', '貨品', '物品']):
+                if any(keyword in message_lower for keyword in ['庫存', '存貨', '剩餘']):
+                    # 庫存查詢
+                    product_name = self._extract_product_name(user_message)
+                    return self.check_inventory(product_name=product_name)
+                else:
+                    # 一般商品查詢
+                    product_name = self._extract_product_name(user_message)
+                    return self.search_products(query_text=product_name)
+            
+            # 訂單查詢
+            elif any(keyword in message_lower for keyword in ['訂單', '訂購', '購買']):
+                return self.search_orders(user_id=user_id)
+            
+            # 低庫存查詢
+            elif any(keyword in message_lower for keyword in ['低庫存', '缺貨', '不足']):
+                return self.get_low_stock_products()
+            
+            # 統計查詢
+            elif any(keyword in message_lower for keyword in ['統計', '摘要', '總計', '報表']):
+                return self.get_business_summary()
+            
+            else:
+                # 預設進行商品搜尋
+                return self.search_products(query_text=user_message)
+                
+        except Exception as e:
+            logger.error(f"自然語言查詢處理錯誤: {str(e)}")
+            return DatabaseResult(
+                success=False,
+                error=f"查詢處理失敗: {str(e)}"
+            )
+
+    def _extract_product_name(self, message: str) -> str:
+        """從訊息中提取商品名稱"""
+        # 簡單的商品名稱提取邏輯
+        # 移除常見的查詢關鍵字
+        keywords_to_remove = ['查詢', '搜尋', '找', '商品', '產品', '庫存', '有沒有', '請問']
+        
+        cleaned_message = message
+        for keyword in keywords_to_remove:
+            cleaned_message = cleaned_message.replace(keyword, '')
+        
+        return cleaned_message.strip()

backend/services/line_bot_service.py

@@ -0,0 +1,246 @@
+"""
+LINE Bot 服務 - 整合業務查詢功能
+處理來自 LINE 官方帳號的用戶訊息
+"""
+
+import logging
+from typing import Dict, Any, Optional
+from backend.services.business_query_service import BusinessQueryService
+from backend.services.database_service import DatabaseService
+
+logger = logging.getLogger(__name__)
+
+class LineBotService:
+    """LINE Bot 服務類"""
+    
+    def __init__(self):
+        self.business_query_service = BusinessQueryService()
+        self.db_service = DatabaseService()
+    
+    def handle_text_message(self, user_id: str, message_text: str, display_name: str = None) -> Dict[str, Any]:
+        """
+        處理 LINE 用戶的文字訊息
+        
+        Args:
+            user_id: LINE 用戶ID
+            message_text: 用戶發送的訊息內容
+            display_name: 用戶顯示名稱（可選）
+            
+        Returns:
+            包含回應訊息和相關資料的字典
+        """
+        try:
+            # 記錄用戶訊息
+            logger.info(f"收到來自用戶 {user_id} 的訊息: {message_text}")
+            
+            # 檢查是否為特殊指令
+            if message_text.lower() in ['help', '幫助', '說明', '指令']:
+                return self._handle_help_command(user_id)
+            
+            elif message_text.lower() in ['menu', '選單', '功能']:
+                return self._handle_menu_command(user_id)
+            
+            # 確保用戶資料存在
+            self._ensure_user_profile(user_id, display_name)
+            
+            # 處理業務查詢
+            query_result = self.business_query_service.process_user_query(message_text, user_id)
+            
+            # 準備回應
+            response = {
+                "type": "text",
+                "text": query_result["response_message"],
+                "user_id": user_id,
+                "success": query_result["success"],
+                "intent": query_result["intent"],
+                "confidence": query_result["confidence"]
+            }
+            
+            # 如果查詢成功且有資料，可以添加快速回覆按鈕
+            if query_result["success"] and query_result["data"]:
+                response["quick_reply"] = self._generate_quick_reply_buttons(query_result["intent"])
+            
+            return response
+            
+        except Exception as e:
+            logger.error(f"處理 LINE 訊息時發生錯誤: {str(e)}")
+            return {
+                "type": "text",
+                "text": "抱歉，系統暫時無法處理您的請求，請稍後再試。",
+                "user_id": user_id,
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _handle_help_command(self, user_id: str) -> Dict[str, Any]:
+        """處理幫助指令"""
+        help_message = self.business_query_service.get_help_message()
+        
+        return {
+            "type": "text",
+            "text": help_message,
+            "user_id": user_id,
+            "success": True,
+            "intent": "help"
+        }
+    
+    def _handle_menu_command(self, user_id: str) -> Dict[str, Any]:
+        """處理選單指令"""
+        menu_message = """
+🏪 智能查詢系統主選單
+
+請選擇您需要的功能：
+
+1️⃣ 商品查詢
+   輸入：查詢商品 [商品名稱]
+
+2️⃣ 庫存查詢  
+   輸入：庫存查詢 [商品名稱]
+
+3️⃣ 訂單查詢
+   輸入：我的訂單
+
+4️⃣ 低庫存警告
+   輸入：低庫存商品
+
+5️⃣ 業務統計
+   輸入：業務摘要
+
+💡 您也可以直接用自然語言提問！
+例如：「iPhone 還有多少庫存？」
+
+輸入「幫助」查看詳細說明
+        """
+        
+        return {
+            "type": "text", 
+            "text": menu_message.strip(),
+            "user_id": user_id,
+            "success": True,
+            "intent": "menu",
+            "quick_reply": {
+                "items": [
+                    {"type": "action", "action": {"type": "message", "label": "商品查詢", "text": "查詢商品"}},
+                    {"type": "action", "action": {"type": "message", "label": "庫存查詢", "text": "庫存查詢"}},
+                    {"type": "action", "action": {"type": "message", "label": "我的訂單", "text": "我的訂單"}},
+                    {"type": "action", "action": {"type": "message", "label": "低庫存", "text": "低庫存商品"}},
+                    {"type": "action", "action": {"type": "message", "label": "業務統計", "text": "業務摘要"}}
+                ]
+            }
+        }
+    
+    def _ensure_user_profile(self, user_id: str, display_name: str = None):
+        """確保用戶資料存在於資料庫中"""
+        try:
+            # 檢查用戶是否已存在
+            existing_user = self.db_service.get_user_profile(user_id)
+            
+            if not existing_user:
+                # 建立新用戶資料
+                user_data = {
+                    "user_id": user_id,
+                    "display_name": display_name or f"用戶_{user_id[:8]}",
+                    "created_at": "now()"
+                }
+                
+                success = self.db_service.create_user_profile(user_data)
+                if success:
+                    logger.info(f"已建立新用戶資料: {user_id}")
+                else:
+                    logger.warning(f"建立用戶資料失敗: {user_id}")
+                    
+        except Exception as e:
+            logger.error(f"處理用戶資料時發生錯誤: {str(e)}")
+    
+    def _generate_quick_reply_buttons(self, intent: str) -> Dict[str, Any]:
+        """根據查詢意圖生成快速回覆按鈕"""
+        
+        if intent == "product_search":
+            return {
+                "items": [
+                    {"type": "action", "action": {"type": "message", "label": "查看庫存", "text": "庫存查詢"}},
+                    {"type": "action", "action": {"type": "message", "label": "相關商品", "text": "查詢商品"}},
+                    {"type": "action", "action": {"type": "message", "label": "主選單", "text": "選單"}}
+                ]
+            }
+        
+        elif intent == "inventory_check":
+            return {
+                "items": [
+                    {"type": "action", "action": {"type": "message", "label": "低庫存警告", "text": "低庫存商品"}},
+                    {"type": "action", "action": {"type": "message", "label": "商品詳情", "text": "查詢商品"}},
+                    {"type": "action", "action": {"type": "message", "label": "主選單", "text": "選單"}}
+                ]
+            }
+        
+        elif intent == "order_search":
+            return {
+                "items": [
+                    {"type": "action", "action": {"type": "message", "label": "業務統計", "text": "業務摘要"}},
+                    {"type": "action", "action": {"type": "message", "label": "主選單", "text": "選單"}}
+                ]
+            }
+        
+        else:
+            return {
+                "items": [
+                    {"type": "action", "action": {"type": "message", "label": "商品查詢", "text": "查詢商品"}},
+                    {"type": "action", "action": {"type": "message", "label": "庫存查詢", "text": "庫存查詢"}},
+                    {"type": "action", "action": {"type": "message", "label": "主選單", "text": "選單"}}
+                ]
+            }
+    
+    def handle_postback_action(self, user_id: str, postback_data: str) -> Dict[str, Any]:
+        """處理 Postback 動作（按鈕點擊等）"""
+        try:
+            # 解析 postback 資料
+            if postback_data.startswith("query_"):
+                query_type = postback_data.replace("query_", "")
+                
+                if query_type == "products":
+                    return self.handle_text_message(user_id, "查詢商品")
+                elif query_type == "inventory":
+                    return self.handle_text_message(user_id, "庫存查詢")
+                elif query_type == "orders":
+                    return self.handle_text_message(user_id, "我的訂單")
+                elif query_type == "summary":
+                    return self.handle_text_message(user_id, "業務摘要")
+            
+            # 預設回應
+            return self._handle_menu_command(user_id)
+            
+        except Exception as e:
+            logger.error(f"處理 Postback 動作時發生錯誤: {str(e)}")
+            return {
+                "type": "text",
+                "text": "抱歉，無法處理此操作。",
+                "user_id": user_id,
+                "success": False,
+                "error": str(e)
+            }
+    
+    def get_user_activity_summary(self, user_id: str, days: int = 7) -> Dict[str, Any]:
+        """取得用戶活動摘要"""
+        try:
+            # 這裡可以實作用戶活動統計
+            # 例如：查詢次數、常用功能等
+            
+            summary = {
+                "user_id": user_id,
+                "period_days": days,
+                "total_queries": 0,  # 從資料庫查詢
+                "most_used_features": [],  # 最常使用的功能
+                "last_activity": None  # 最後活動時間
+            }
+            
+            return {
+                "success": True,
+                "data": summary
+            }
+            
+        except Exception as e:
+            logger.error(f"取得用戶活動摘要時發生錯誤: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }

backend/services/nlp_service.py

@@ -0,0 +1,653 @@
+import re
+import json
+from typing import Dict, Any, List
+from backend.models.schemas import NLPAnalysisResult, QueryType, DatabaseResult
+from backend.config import settings
+from backend.services.openrouter_service import OpenRouterService
+import logging
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+class NLPService:
+    """自然語言處理服務"""
+    
+    def __init__(self):
+        self.openrouter_service = OpenRouterService()
+        self.business_intent_patterns = {
+            "product_search": [
+                r"查詢.*商品|找.*商品|搜尋.*商品|商品.*資料",
+                r"商品.*查詢|商品.*搜尋|產品.*查詢|產品.*搜尋",
+                r"有什麼.*商品|商品.*價格|產品.*價格"
+            ],
+            "inventory_check": [
+                r"庫存.*查詢|查詢.*庫存|庫存.*多少|剩餘.*數量",
+                r"存貨.*查詢|查詢.*存貨|還有.*多少|庫存.*狀況",
+                r".*庫存|.*存貨|.*剩餘"
+            ],
+            "order_search": [
+                r"查詢.*訂單|找.*訂單|搜尋.*訂單|訂單.*資料",
+                r"訂單.*查詢|訂單.*搜尋|訂單.*狀態|我的.*訂單",
+                r"訂單編號|購買.*記錄"
+            ],
+            "customer_search": [
+                r"查詢.*客戶|找.*客戶|搜尋.*客戶|客戶.*資料",
+                r"客戶.*查詢|客戶.*搜尋|客戶.*聯絡"
+            ],
+            "low_stock_alert": [
+                r"低庫存|缺貨|庫存.*不足|存貨.*不足",
+                r"快.*沒有|即將.*缺貨|庫存.*警告"
+            ],
+            "business_summary": [
+                r"統計|分析|報表|數據|摘要",
+                r"總計|總數|多少.*筆|幾.*筆|業務.*狀況"
+            ]
+        }
+        self.intent_patterns = {
+            "search_user": [
+                r"查詢.*用戶|找.*用戶|搜尋.*用戶|用戶.*資料",
+                r"用戶.*查詢|用戶.*搜尋|用戶.*找",
+                r"誰是|哪個用戶|用戶名.*是"
+            ],
+            "search_order": [
+                r"查詢.*訂單|找.*訂單|搜尋.*訂單|訂單.*資料",
+                r"訂單.*查詢|訂單.*搜尋|訂單.*狀態",
+                r"我的訂單|訂單編號"
+            ],
+            "search_product": [
+                r"查詢.*商品|找.*商品|搜尋.*商品|商品.*資料",
+                r"商品.*查詢|商品.*搜尋|產品.*查詢",
+                r"有什麼.*商品|商品.*價格"
+            ],
+            "create_order": [
+                r"建立.*訂單|新增.*訂單|下訂|購買",
+                r"我要.*買|我想.*買|訂購"
+            ],
+            "update_profile": [
+                r"更新.*資料|修改.*資料|變更.*資料",
+                r"更新.*個人|修改.*個人|個人.*資料"
+            ],
+            "analytics": [
+                r"統計|分析|報表|數據",
+                r"總計|總數|多少.*筆|幾.*筆"
+            ]
+        }
+        
+        self.entity_patterns = {
+            "user_id": r"用戶ID[：:]?\s*([A-Za-z0-9]+)",
+            "user_name": r"用戶名[：:]?\s*([^\s]+)|名字[：:]?\s*([^\s]+)",
+            "order_id": r"訂單[編號ID][：:]?\s*([A-Za-z0-9\-]+)",
+            "product_name": r"商品[：:]?\s*([^\s]+)|產品[：:]?\s*([^\s]+)",
+            "price_range": r"價格.*?(\d+).*?到.*?(\d+)|(\d+).*?元.*?到.*?(\d+).*?元",
+            "date_range": r"(\d{4}[-/]\d{1,2}[-/]\d{1,2})",
+            "number": r"(\d+)"
+        }
+
+    def analyze_message(self, message: str, use_advanced: bool = True) -> NLPAnalysisResult:
+        """分析用戶訊息"""
+        try:
+            # 如果啟用進階分析且有 OpenRouter API Key
+            if use_advanced and self.openrouter_service.api_key:
+                try:
+                    # 使用 asyncio 執行異步分析
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    advanced_result = loop.run_until_complete(
+                        self.openrouter_service.analyze_intent_advanced(message)
+                    )
+                    loop.close()
+                    
+                    if not advanced_result.get("fallback", False):
+                        return NLPAnalysisResult(
+                            query_type=QueryType(advanced_result.get("query_type", "unknown")),
+                            intent=advanced_result.get("intent", "unknown"),
+                            entities=advanced_result.get("entities", {}),
+                            confidence=advanced_result.get("confidence", 0.5),
+                            parameters=advanced_result.get("parameters", {})
+                        )
+                except Exception as e:
+                    logger.warning(f"進階 NLP 分析失敗，使用基礎分析: {str(e)}")
+            
+            # 使用基礎規則引擎分析
+            return self._basic_analyze_message(message)
+            
+        except Exception as e:
+            logger.error(f"NLP 分析錯誤: {str(e)}")
+            return NLPAnalysisResult(
+                query_type=QueryType.UNKNOWN,
+                intent="unknown",
+                entities={},
+                confidence=0.0,
+                parameters={}
+            )
+    
+    def _basic_analyze_message(self, message: str) -> NLPAnalysisResult:
+        """基礎訊息分析（規則引擎）"""
+        # 清理訊息
+        cleaned_message = self._clean_message(message)
+        
+        # 識別意圖
+        intent, confidence = self._identify_intent(cleaned_message)
+        
+        # 提取實體
+        entities = self._extract_entities(cleaned_message)
+        
+        # 確定查詢類型
+        query_type = self._determine_query_type(intent)
+        
+        # 生成查詢參數
+        parameters = self._generate_parameters(intent, entities)
+        
+        return NLPAnalysisResult(
+            query_type=query_type,
+            intent=intent,
+            entities=entities,
+            confidence=confidence,
+            parameters=parameters
+        )
+
+    def _clean_message(self, message: str) -> str:
+        """清理訊息"""
+        # 移除多餘空白
+        message = re.sub(r'\s+', ' ', message.strip())
+        return message
+
+    def _identify_intent(self, message: str) -> tuple[str, float]:
+        """識別用戶意圖"""
+        best_intent = "unknown"
+        best_score = 0.0
+        
+        for intent, patterns in self.intent_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern, message, re.IGNORECASE):
+                    score = len(re.findall(pattern, message, re.IGNORECASE)) / len(message.split())
+                    if score > best_score:
+                        best_score = score
+                        best_intent = intent
+        
+        # 如果沒有匹配到任何模式，設定基本信心度
+        confidence = max(best_score, 0.3) if best_intent != "unknown" else 0.1
+        
+        return best_intent, min(confidence, 1.0)
+
+    def _extract_entities(self, message: str) -> Dict[str, Any]:
+        """提取實體"""
+        entities = {}
+        
+        for entity_type, pattern in self.entity_patterns.items():
+            matches = re.findall(pattern, message, re.IGNORECASE)
+            if matches:
+                if entity_type == "price_range":
+                    # 處理價格範圍
+                    for match in matches:
+                        if isinstance(match, tuple):
+                            prices = [p for p in match if p]
+                            if len(prices) >= 2:
+                                entities["min_price"] = int(prices[0])
+                                entities["max_price"] = int(prices[1])
+                elif entity_type == "user_name":
+                    # 處理用戶名（可能有多個捕獲組）
+                    for match in matches:
+                        if isinstance(match, tuple):
+                            name = next((n for n in match if n), None)
+                            if name:
+                                entities[entity_type] = name
+                        else:
+                            entities[entity_type] = match
+                else:
+                    entities[entity_type] = matches[0] if isinstance(matches[0], str) else matches[0][0]
+        
+        return entities
+
+    def _determine_query_type(self, intent: str) -> QueryType:
+        """確定查詢類型"""
+        if intent.startswith("search_"):
+            return QueryType.SEARCH
+        elif intent.startswith("create_"):
+            return QueryType.CREATE
+        elif intent.startswith("update_"):
+            return QueryType.UPDATE
+        elif intent.startswith("delete_"):
+            return QueryType.DELETE
+        elif intent == "analytics":
+            return QueryType.ANALYTICS
+        else:
+            return QueryType.UNKNOWN
+
+    def _generate_parameters(self, intent: str, entities: Dict[str, Any]) -> Dict[str, Any]:
+        """生成查詢參數"""
+        parameters = {}
+        
+        # 根據意圖設定表名
+        if "user" in intent:
+            parameters["table"] = "users"
+        elif "order" in intent:
+            parameters["table"] = "orders"
+        elif "product" in intent:
+            parameters["table"] = "products"
+        
+        # 設定查詢條件
+        conditions = {}
+        if "user_id" in entities:
+            conditions["user_id"] = entities["user_id"]
+        if "user_name" in entities:
+            conditions["name"] = entities["user_name"]
+        if "order_id" in entities:
+            conditions["order_id"] = entities["order_id"]
+        if "product_name" in entities:
+            conditions["name"] = entities["product_name"]
+        if "min_price" in entities and "max_price" in entities:
+            conditions["price"] = {
+                "gte": entities["min_price"],
+                "lte": entities["max_price"]
+            }
+        
+        if conditions:
+            parameters["conditions"] = conditions
+        
+        # 設定限制
+        if "number" in entities:
+            parameters["limit"] = min(int(entities["number"]), 50)  # 最多50筆
+        else:
+            parameters["limit"] = 10  # 預設10筆
+        
+        return parameters
+
+    def format_response(self, db_result: DatabaseResult, analysis_result: NLPAnalysisResult, user_message: str = "", use_advanced: bool = True) -> str:
+        """格式化回應訊息"""
+        try:
+            # 如果啟用進階回應且有 OpenRouter API Key
+            if use_advanced and user_message and self.openrouter_service.api_key:
+                try:
+                    # 準備查詢結果資料
+                    query_result = {
+                        "success": db_result.success,
+                        "data": db_result.data,
+                        "count": db_result.count,
+                        "error": db_result.error
+                    }
+                    
+                    # 使用 asyncio 執行異步回應生成
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    advanced_response = loop.run_until_complete(
+                        self.openrouter_service.generate_response(query_result, user_message)
+                    )
+                    loop.close()
+                    
+                    if advanced_response and len(advanced_response.strip()) > 0:
+                        return advanced_response
+                except Exception as e:
+                    logger.warning(f"進階回應生成失敗，使用基礎格式: {str(e)}")
+            
+            # 使用基礎格式化
+            return self._basic_format_response(db_result, analysis_result)
+                
+        except Exception as e:
+            logger.error(f"格式化回應錯誤: {str(e)}")
+            return "資料處理時發生錯誤，請稍後再試。"
+    
+    def _basic_format_response(self, db_result: DatabaseResult, analysis_result: NLPAnalysisResult) -> str:
+        """基礎回應格式化"""
+        if not db_result.success:
+            return f"抱歉，查詢時發生錯誤：{db_result.error}"
+        
+        if not db_result.data:
+            return "沒有找到相關資料。"
+        
+        intent = analysis_result.intent
+        data = db_result.data
+        
+        if intent.startswith("search_user"):
+            return self._format_user_response(data)
+        elif intent.startswith("search_order"):
+            return self._format_order_response(data)
+        elif intent.startswith("search_product"):
+            return self._format_product_response(data)
+        elif intent == "analytics":
+            return self._format_analytics_response(data)
+        else:
+            return f"找到 {len(data)} 筆資料。"
+
+    def _format_user_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化用戶查詢回應"""
+        if len(data) == 1:
+            user = data[0]
+            return f"用戶資料：\n名稱：{user.get('name', 'N/A')}\nID：{user.get('user_id', 'N/A')}\n電子郵件：{user.get('email', 'N/A')}"
+        else:
+            response = f"找到 {len(data)} 位用戶：\n"
+            for i, user in enumerate(data[:5], 1):  # 最多顯示5筆
+                response += f"{i}. {user.get('name', 'N/A')} (ID: {user.get('user_id', 'N/A')})\n"
+            if len(data) > 5:
+                response += f"... 還有 {len(data) - 5} 筆資料"
+            return response
+
+    def _format_order_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化訂單查詢回應"""
+        if len(data) == 1:
+            order = data[0]
+            return f"訂單資料：\n訂單編號：{order.get('order_id', 'N/A')}\n狀態：{order.get('status', 'N/A')}\n金額：${order.get('total_amount', 'N/A')}"
+        else:
+            response = f"找到 {len(data)} 筆訂單：\n"
+            for i, order in enumerate(data[:5], 1):
+                response += f"{i}. {order.get('order_id', 'N/A')} - ${order.get('total_amount', 'N/A')}\n"
+            if len(data) > 5:
+                response += f"... 還有 {len(data) - 5} 筆資料"
+            return response
+
+    def _format_product_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化商品查詢回應"""
+        if len(data) == 1:
+            product = data[0]
+            return f"商品資料：\n名稱：{product.get('name', 'N/A')}\n價格：${product.get('price', 'N/A')}\n庫存：{product.get('stock', 'N/A')}"
+        else:
+            response = f"找到 {len(data)} 項商品：\n"
+            for i, product in enumerate(data[:5], 1):
+                response += f"{i}. {product.get('name', 'N/A')} - ${product.get('price', 'N/A')}\n"
+            if len(data) > 5:
+                response += f"... 還有 {len(data) - 5} 筆���料"
+            return response
+
+    def _format_analytics_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化分析回應"""
+        if data and len(data) > 0:
+            if 'count' in data[0]:
+                return f"統計結果：共 {data[0]['count']} 筆資料"
+            else:
+                return f"分析結果：找到 {len(data)} 筆相關資料"
+        return "無統計資料"
+
+    def analyze_business_query(self, message: str, user_id: str = None) -> NLPAnalysisResult:
+        """分析業務相關的自然語言查詢"""
+        try:
+            # 檢測查詢意圖
+            intent = self._detect_business_intent(message)
+            
+            # 提取實體
+            entities = self._extract_business_entities(message, intent)
+            
+            # 根據意圖設定查詢類型和參數
+            query_type, parameters = self._build_query_parameters(intent, entities, user_id)
+            
+            # 計算信心度
+            confidence = self._calculate_confidence(message, intent, entities)
+            
+            return NLPAnalysisResult(
+                query_type=query_type,
+                intent=intent,
+                entities=entities,
+                confidence=confidence,
+                parameters=parameters
+            )
+            
+        except Exception as e:
+            logger.error(f"業務查詢分析錯誤: {str(e)}")
+            return NLPAnalysisResult(
+                query_type=QueryType.UNKNOWN,
+                intent="unknown",
+                entities={},
+                confidence=0.0,
+                parameters={}
+            )
+
+    def _detect_business_intent(self, message: str) -> str:
+        """檢測業務查詢意圖"""
+        message_lower = message.lower()
+        
+        # 檢查業務相關的意圖模式
+        for intent, patterns in self.business_intent_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern, message_lower):
+                    return intent
+        
+        # 如果沒有匹配到業務意圖，使用原有的意圖檢測
+        for intent, patterns in self.intent_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern, message_lower):
+                    return intent
+        
+        return "general_search"
+
+    def _extract_business_entities(self, message: str, intent: str) -> Dict[str, Any]:
+        """提取業務相關實體"""
+        entities = {}
+        
+        # 商品名稱提取
+        product_patterns = [
+            r"商品[：:]?\s*([^\s，。！？]+)",
+            r"產品[：:]?\s*([^\s，。！？]+)",
+            r"貨品[：:]?\s*([^\s，。！？]+)"
+        ]
+        
+        for pattern in product_patterns:
+            match = re.search(pattern, message)
+            if match:
+                entities["product_name"] = match.group(1)
+                break
+        
+        # 如果沒有明確的商品名稱，嘗試提取關鍵字
+        if "product_name" not in entities:
+            # 移除查詢關鍵字後的剩餘內容可能是商品名稱
+            keywords_to_remove = ['查詢', '搜尋', '找', '商品', '產品', '庫存', '有沒有', '請問', '的', '嗎']
+            cleaned_message = message
+            for keyword in keywords_to_remove:
+                cleaned_message = cleaned_message.replace(keyword, '')
+            
+            cleaned_message = cleaned_message.strip()
+            if cleaned_message and len(cleaned_message) > 0:
+                entities["search_text"] = cleaned_message
+        
+        # 客戶相關實體
+        customer_patterns = [
+            r"客戶[：:]?\s*([^\s，。！？]+)",
+            r"客戶編號[：:]?\s*([A-Za-z0-9]+)",
+            r"客戶名稱[：:]?\s*([^\s，。！？]+)"
+        ]
+        
+        for pattern in customer_patterns:
+            match = re.search(pattern, message)
+            if match:
+                entities["customer_info"] = match.group(1)
+                break
+        
+        # 訂單相關實體
+        order_patterns = [
+            r"訂單[編號ID][：:]?\s*([A-Za-z0-9\-]+)",
+            r"訂單[：:]?\s*([A-Za-z0-9\-]+)"
+        ]
+        
+        for pattern in order_patterns:
+            match = re.search(pattern, message)
+            if match:
+                entities["order_id"] = match.group(1)
+                break
+        
+        # 數量相關實體
+        quantity_patterns = [
+            r"(\d+)\s*個",
+            r"(\d+)\s*件",
+            r"(\d+)\s*箱",
+            r"數量[：:]?\s*(\d+)"
+        ]
+        
+        for pattern in quantity_patterns:
+            match = re.search(pattern, message)
+            if match:
+                entities["quantity"] = int(match.group(1))
+                break
+        
+        # 狀態相關實體
+        status_keywords = {
+            "待處理": ["待處理", "pending"],
+            "已確認": ["已確認", "confirmed"],
+            "已出貨": ["已出貨", "shipped"],
+            "已完成": ["已完成", "completed"],
+            "已取消": ["已取消", "cancelled"]
+        }
+        
+        message_lower = message.lower()
+        for status, keywords in status_keywords.items():
+            if any(keyword in message_lower for keyword in keywords):
+                entities["status"] = status
+                break
+        
+        return entities
+
+    def _build_query_parameters(self, intent: str, entities: Dict[str, Any], user_id: str = None) -> tuple:
+        """根據意圖和實體建立查詢參數"""
+        
+        if intent == "product_search":
+            return QueryType.SEARCH, {
+                "method": "search_products",
+                "query_text": entities.get("product_name") or entities.get("search_text"),
+                "category": entities.get("category"),
+                "limit": 10
+            }
+        
+        elif intent == "inventory_check":
+            return QueryType.SEARCH, {
+                "method": "check_inventory",
+                "product_name": entities.get("product_name") or entities.get("search_text"),
+                "category": entities.get("category")
+            }
+        
+        elif intent == "order_search":
+            return QueryType.SEARCH, {
+                "method": "search_orders",
+                "user_id": user_id,
+                "order_id": entities.get("order_id"),
+                "status": entities.get("status"),
+                "limit": 10
+            }
+        
+        elif intent == "low_stock_alert":
+            return QueryType.SEARCH, {
+                "method": "get_low_stock_products",
+                "threshold": 10
+            }
+        
+        elif intent == "business_summary":
+            return QueryType.ANALYTICS, {
+                "method": "get_business_summary"
+            }
+        
+        else:
+            # 預設為商品搜尋
+            return QueryType.SEARCH, {
+                "method": "search_products",
+                "query_text": entities.get("search_text") or entities.get("product_name"),
+                "limit": 10
+            }
+
+    def _calculate_confidence(self, message: str, intent: str, entities: Dict[str, Any]) -> float:
+        """計算查詢信心度"""
+        confidence = 0.5  # 基礎信心度
+        
+        # 如果有明確的意圖匹配，增加信心度
+        if intent in self.business_intent_patterns:
+            confidence += 0.3
+        
+        # 如果提取到實體，增加信心度
+        if entities:
+            confidence += 0.2 * len(entities)
+        
+        # 如果訊息長度適中，增加信心度
+        if 2 <= len(message) <= 50:
+            confidence += 0.1
+        
+        return min(confidence, 1.0)
+
+    def format_response_message(self, result: DatabaseResult, intent: str) -> str:
+        """格式化回應訊息"""
+        if not result.success:
+            return f"抱歉，查詢時發生錯誤：{result.error}"
+        
+        if not result.data or result.count == 0:
+            return "沒有找到相關資料。"
+        
+        # 根據不同的查詢意圖格式化回應
+        if intent == "product_search":
+            return self._format_product_response(result.data)
+        elif intent == "inventory_check":
+            return self._format_inventory_response(result.data)
+        elif intent == "order_search":
+            return self._format_order_response(result.data)
+        elif intent == "low_stock_alert":
+            return self._format_low_stock_response(result.data)
+        elif intent == "business_summary":
+            return self._format_summary_response(result.data)
+        else:
+            return self._format_general_response(result.data)
+
+    def _format_product_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化商品查詢回應"""
+        if len(data) == 1:
+            product = data[0]
+            return f"找到商品：\n" \
+                   f"名稱：{product.get('name', 'N/A')}\n" \
+                   f"描述：{product.get('description', 'N/A')}\n" \
+                   f"價格：${product.get('price', 0)}\n" \
+                   f"類別：{product.get('category', 'N/A')}"
+        else:
+            response = f"找到 {len(data)} 個商品：\n"
+            for i, product in enumerate(data[:5], 1):
+                response += f"{i}. {product.get('name', 'N/A')} - ${product.get('price', 0)}\n"
+            if len(data) > 5:
+                response += f"... 還有 {len(data) - 5} 個商品"
+            return response
+
+    def _format_inventory_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化庫存查詢回應"""
+        if len(data) == 1:
+            item = data[0]
+            return f"庫存資訊：\n" \
+                   f"商品：{item.get('product_name', 'N/A')}\n" \
+                   f"目前庫存：{item.get('current_stock', 0)} 件\n" \
+                   f"類別：{item.get('category', 'N/A')}\n" \
+                   f"價格：${item.get('price', 0)}"
+        else:
+            response = f"找到 {len(data)} 個商品的庫存：\n"
+            for i, item in enumerate(data[:5], 1):
+                response += f"{i}. {item.get('product_name', 'N/A')} - 庫存：{item.get('current_stock', 0)}\n"
+            return response
+
+    def _format_order_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化訂單查詢回應"""
+        if len(data) == 1:
+            order = data[0]
+            return f"訂單資訊：\n" \
+                   f"訂單編號：{order.get('order_id', 'N/A')}\n" \
+                   f"狀態：{order.get('status', 'N/A')}\n" \
+                   f"總金額：${order.get('total_amount', 0)}\n" \
+                   f"建立時間：{order.get('created_at', 'N/A')}"
+        else:
+            response = f"找到 {len(data)} 筆訂單：\n"
+            for i, order in enumerate(data[:5], 1):
+                response += f"{i}. {order.get('order_id', 'N/A')} - {order.get('status', 'N/A')} - ${order.get('total_amount', 0)}\n"
+            return response
+
+    def _format_low_stock_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化低庫存警告回應"""
+        if not data:
+            return "目前沒有低庫存商品。"
+        
+        response = f"⚠️ 發現 {len(data)} 個低庫存商品：\n"
+        for i, item in enumerate(data[:10], 1):
+            response += f"{i}. {item.get('product_name', 'N/A')} - 剩餘：{item.get('current_stock', 0)} 件\n"
+        return response
+
+    def _format_summary_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化業務摘要回應"""
+        if data:
+            summary = data[0]
+            return f"📊 業務摘要：\n" \
+                   f"商品總數：{summary.get('total_products', 0)} 個\n" \
+                   f"訂單總數：{summary.get('total_orders', 0)} 筆\n" \
+                   f"用戶總數：{summary.get('total_users', 0)} 人\n" \
+                   f"低庫存商品：{summary.get('low_stock_items', 0)} 個\n" \
+                   f"統計時間：{summary.get('report_date', 'N/A')}"
+        return "無法取得業務摘要資料。"
+
+    def _format_general_response(self, data: List[Dict[str, Any]]) -> str:
+        """格式化一般查詢回應"""
+        return f"找到 {len(data)} 筆資料。"

backend/services/openrouter_service.py

@@ -0,0 +1,241 @@
+"""
+OpenRouter API 服務
+用於進階自然語言處理功能
+"""
+
+import httpx
+import json
+from typing import Dict, Any, Optional
+from backend.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+class OpenRouterService:
+    """OpenRouter API 服務類"""
+    
+    def __init__(self):
+        self.api_key = settings.OPENROUTER_API_KEY
+        self.model = settings.OPENROUTER_MODEL
+        self.base_url = "https://openrouter.ai/api/v1"
+        self.headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://huggingface.co/spaces",
+            "X-Title": "LINE Bot NLP Service"
+        }
+    
+    async def analyze_intent_advanced(self, message: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        使用 OpenRouter 進行進階意圖分析
+        
+        Args:
+            message: 用戶訊息
+            context: 上下文資訊
+            
+        Returns:
+            分析結果字典
+        """
+        if not self.api_key:
+            logger.warning("OpenRouter API Key 未設定，使用基礎 NLP 服務")
+            return self._fallback_analysis(message)
+        
+        try:
+            prompt = self._build_analysis_prompt(message, context)
+            
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(
+                    f"{self.base_url}/chat/completions",
+                    headers=self.headers,
+                    json={
+                        "model": self.model,
+                        "messages": [
+                            {
+                                "role": "system",
+                                "content": "你是一個專業的中文自然語言處理助手，專門分析用戶查詢意圖並提取相關實體。請以 JSON 格式回應。"
+                            },
+                            {
+                                "role": "user",
+                                "content": prompt
+                            }
+                        ],
+                        "temperature": 0.1,
+                        "max_tokens": 500
+                    }
+                )
+            
+            if response.status_code == 200:
+                result = response.json()
+                content = result["choices"][0]["message"]["content"]
+                
+                try:
+                    # 嘗試解析 JSON 回應
+                    analysis = json.loads(content)
+                    return self._validate_analysis_result(analysis)
+                except json.JSONDecodeError:
+                    logger.error(f"無法解析 OpenRouter 回應: {content}")
+                    return self._fallback_analysis(message)
+            else:
+                logger.error(f"OpenRouter API 錯誤: {response.status_code}")
+                return self._fallback_analysis(message)
+                
+        except Exception as e:
+            logger.error(f"OpenRouter 服務錯誤: {str(e)}")
+            return self._fallback_analysis(message)
+    
+    def _build_analysis_prompt(self, message: str, context: Dict[str, Any] = None) -> str:
+        """建構分析提示詞"""
+        context_info = ""
+        if context:
+            context_info = f"\n上下文資訊: {json.dumps(context, ensure_ascii=False)}"
+        
+        prompt = f"""
+請分析以下中文訊息的意圖和實體：
+
+訊息: "{message}"{context_info}
+
+請以以下 JSON 格式回應：
+{{
+    "intent": "查詢意圖類型 (search_user/search_product/search_order/create_order/update_profile/analytics/unknown)",
+    "confidence": 0.0-1.0之間的信心度,
+    "entities": {{
+        "user_id": "提取的用戶ID",
+        "user_name": "提取的用戶名稱",
+        "product_name": "提取的商品名稱",
+        "order_id": "提取的訂單ID",
+        "min_price": 最低價格數字,
+        "max_price": 最高價格數字,
+        "category": "商品類別",
+        "number": 數量
+    }},
+    "query_type": "search/create/update/delete/analytics",
+    "parameters": {{
+        "table": "目標資料表名稱",
+        "conditions": "查詢條件",
+        "limit": 查詢限制數量
+    }}
+}}
+
+範例：
+- "查詢用戶張三" → intent: "search_user", entities: {{"user_name": "張三"}}
+- "找價格1000到5000的手機" → intent: "search_product", entities: {{"min_price": 1000, "max_price": 5000, "category": "手機"}}
+- "統計訂單數量" → intent: "analytics", query_type: "analytics"
+"""
+        return prompt
+    
+    def _validate_analysis_result(self, analysis: Dict[str, Any]) -> Dict[str, Any]:
+        """驗證分析結果"""
+        # 確保必要欄位存在
+        required_fields = ["intent", "confidence", "entities", "query_type"]
+        for field in required_fields:
+            if field not in analysis:
+                analysis[field] = self._get_default_value(field)
+        
+        # 驗證信心度範圍
+        if not 0 <= analysis.get("confidence", 0) <= 1:
+            analysis["confidence"] = 0.5
+        
+        # 確保實體是字典
+        if not isinstance(analysis.get("entities"), dict):
+            analysis["entities"] = {}
+        
+        return analysis
+    
+    def _get_default_value(self, field: str) -> Any:
+        """取得欄位預設值"""
+        defaults = {
+            "intent": "unknown",
+            "confidence": 0.1,
+            "entities": {},
+            "query_type": "unknown",
+            "parameters": {}
+        }
+        return defaults.get(field, None)
+    
+    def _fallback_analysis(self, message: str) -> Dict[str, Any]:
+        """備用分析方法"""
+        return {
+            "intent": "unknown",
+            "confidence": 0.1,
+            "entities": {},
+            "query_type": "unknown",
+            "parameters": {},
+            "fallback": True
+        }
+    
+    async def generate_response(self, query_result: Dict[str, Any], user_message: str) -> str:
+        """
+        使用 OpenRouter 生成更自然的回應
+        
+        Args:
+            query_result: 資料庫查詢結果
+            user_message: 用戶原始訊息
+            
+        Returns:
+            生成的回應文字
+        """
+        if not self.api_key:
+            return self._generate_simple_response(query_result)
+        
+        try:
+            prompt = f"""
+請根據以下資訊生成一個友善、自然的中文回應：
+
+用戶訊息: "{user_message}"
+查詢結果: {json.dumps(query_result, ensure_ascii=False)}
+
+要求：
+1. 回應要簡潔明瞭
+2. 使用友善的語調
+3. 如果有資料，要清楚呈現重要資訊
+4. 如果沒有資料，要給出建議
+5. 回應長度控制在 200 字以內
+
+範例格式：
+- 找到資料時：「找到 X 筆資料：[列出重要資訊]」
+- 沒有資料時：「很抱歉，沒有找到相關資料，您可以嘗試...」
+"""
+            
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(
+                    f"{self.base_url}/chat/completions",
+                    headers=self.headers,
+                    json={
+                        "model": self.model,
+                        "messages": [
+                            {
+                                "role": "system",
+                                "content": "你是一個友善的客服助手，專門幫助用戶理解查詢結果。"
+                            },
+                            {
+                                "role": "user",
+                                "content": prompt
+                            }
+                        ],
+                        "temperature": 0.3,
+                        "max_tokens": 300
+                    }
+                )
+            
+            if response.status_code == 200:
+                result = response.json()
+                generated_response = result["choices"][0]["message"]["content"].strip()
+                return generated_response
+            else:
+                logger.error(f"OpenRouter 回應生成錯誤: {response.status_code}")
+                return self._generate_simple_response(query_result)
+                
+        except Exception as e:
+            logger.error(f"OpenRouter 回應生成失敗: {str(e)}")
+            return self._generate_simple_response(query_result)
+    
+    def _generate_simple_response(self, query_result: Dict[str, Any]) -> str:
+        """簡單回應生成"""
+        if query_result.get("success"):
+            data_count = len(query_result.get("data", []))
+            if data_count > 0:
+                return f"找到 {data_count} 筆相關資料。"
+            else:
+                return "沒有找到相關資料。"
+        else:
+            return "查詢時發生錯誤，請稍後再試。"

backend/utils/database_init.py

@@ -0,0 +1,149 @@
+"""
+資料庫初始化腳本
+用於在 Supabase 中建立必要的資料表
+"""
+
+from supabase import create_client
+from backend.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+# SQL 建表語句
+CREATE_TABLES_SQL = {
+    "users": """
+    CREATE TABLE IF NOT EXISTS users (
+        user_id VARCHAR(255) PRIMARY KEY,
+        name VARCHAR(255),
+        email VARCHAR(255),
+        display_name VARCHAR(255),
+        picture_url TEXT,
+        status_message TEXT,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+    );
+    """,
+    
+    "products": """
+    CREATE TABLE IF NOT EXISTS products (
+        product_id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        price DECIMAL(10,2) NOT NULL,
+        stock INTEGER DEFAULT 0,
+        category VARCHAR(100),
+        image_url TEXT,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+    );
+    """,
+    
+    "orders": """
+    CREATE TABLE IF NOT EXISTS orders (
+        order_id VARCHAR(255) PRIMARY KEY,
+        user_id VARCHAR(255) REFERENCES users(user_id),
+        total_amount DECIMAL(10,2) NOT NULL,
+        status VARCHAR(50) DEFAULT 'pending',
+        shipping_address TEXT,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+    );
+    """,
+    
+    "order_items": """
+    CREATE TABLE IF NOT EXISTS order_items (
+        id SERIAL PRIMARY KEY,
+        order_id VARCHAR(255) REFERENCES orders(order_id),
+        product_id INTEGER REFERENCES products(product_id),
+        quantity INTEGER NOT NULL,
+        unit_price DECIMAL(10,2) NOT NULL,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+    );
+    """,
+    
+    "line_messages": """
+    CREATE TABLE IF NOT EXISTS line_messages (
+        id SERIAL PRIMARY KEY,
+        user_id VARCHAR(255),
+        message TEXT NOT NULL,
+        message_type VARCHAR(50) DEFAULT 'text',
+        timestamp TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        processed BOOLEAN DEFAULT FALSE
+    );
+    """,
+    
+    "user_sessions": """
+    CREATE TABLE IF NOT EXISTS user_sessions (
+        id SERIAL PRIMARY KEY,
+        user_id VARCHAR(255) REFERENCES users(user_id),
+        session_data JSONB,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+    );
+    """
+}
+
+# 範例資料
+SAMPLE_DATA = {
+    "products": [
+        {
+            "name": "iPhone 15 Pro",
+            "description": "最新款 iPhone，配備 A17 Pro 晶片",
+            "price": 35900,
+            "stock": 50,
+            "category": "手機"
+        },
+        {
+            "name": "MacBook Air M2",
+            "description": "輕薄筆記型電腦，搭載 M2 晶片",
+            "price": 37900,
+            "stock": 30,
+            "category": "筆電"
+        },
+        {
+            "name": "AirPods Pro",
+            "description": "主動降噪無線耳機",
+            "price": 7490,
+            "stock": 100,
+            "category": "耳機"
+        }
+    ]
+}
+
+def init_database():
+    """初始化資料庫"""
+    try:
+        supabase = create_client(settings.SUPABASE_URL, settings.SUPABASE_KEY)
+        
+        logger.info("開始初始化資料庫...")
+        
+        # 建立資料表
+        for table_name, sql in CREATE_TABLES_SQL.items():
+            try:
+                logger.info(f"建立資料表: {table_name}")
+                # 注意：Supabase 的 Python 客戶端可能不直接支援 SQL 執行
+                # 您需要在 Supabase Dashboard 的 SQL Editor 中執行這些 SQL
+                print(f"\n=== {table_name.upper()} TABLE SQL ===")
+                print(sql)
+                
+            except Exception as e:
+                logger.error(f"建立資料表 {table_name} 失敗: {str(e)}")
+        
+        # 插入範例資料
+        logger.info("插入範例資料...")
+        for table_name, data in SAMPLE_DATA.items():
+            try:
+                result = supabase.table(table_name).insert(data).execute()
+                logger.info(f"成功插入 {len(result.data)} 筆資料到 {table_name}")
+            except Exception as e:
+                logger.warning(f"插入範例資料到 {table_name} 失敗: {str(e)}")
+        
+        logger.info("資料庫初始化完成！")
+        return True
+        
+    except Exception as e:
+        logger.error(f"資料庫初始化失敗: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    init_database()

backend/utils/line_utils.py

@@ -0,0 +1,155 @@
+"""
+LINE Bot 相關工具函數
+"""
+
+from linebot.models import (
+    TextSendMessage, QuickReply, QuickReplyButton, MessageAction,
+    FlexSendMessage, BubbleContainer, BoxComponent, TextComponent,
+    ButtonComponent, URIAction
+)
+from typing import List, Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+class LineMessageBuilder:
+    """LINE 訊息建構器"""
+    
+    @staticmethod
+    def create_quick_reply_message(text: str, quick_reply_items: List[Dict[str, str]]) -> TextSendMessage:
+        """建立快速回覆訊息"""
+        quick_reply_buttons = []
+        
+        for item in quick_reply_items:
+            button = QuickReplyButton(
+                action=MessageAction(
+                    label=item["label"],
+                    text=item["text"]
+                )
+            )
+            quick_reply_buttons.append(button)
+        
+        quick_reply = QuickReply(items=quick_reply_buttons)
+        
+        return TextSendMessage(
+            text=text,
+            quick_reply=quick_reply
+        )
+    
+    @staticmethod
+    def create_product_flex_message(products: List[Dict[str, Any]]) -> FlexSendMessage:
+        """建立商品展示的 Flex 訊息"""
+        contents = []
+        
+        for product in products[:10]:  # 最多顯示10個商品
+            bubble = BubbleContainer(
+                body=BoxComponent(
+                    layout="vertical",
+                    contents=[
+                        TextComponent(
+                            text=product.get("name", "商品名稱"),
+                            weight="bold",
+                            size="lg"
+                        ),
+                        TextComponent(
+                            text=f"NT$ {product.get('price', 0):,}",
+                            size="md",
+                            color="#ff5551"
+                        ),
+                        TextComponent(
+                            text=f"庫存: {product.get('stock', 0)}",
+                            size="sm",
+                            color="#aaaaaa"
+                        )
+                    ]
+                ),
+                footer=BoxComponent(
+                    layout="vertical",
+                    contents=[
+                        ButtonComponent(
+                            action=MessageAction(
+                                label="查看詳情",
+                                text=f"查詢商品 {product.get('name', '')}"
+                            ),
+                            style="primary"
+                        )
+                    ]
+                )
+            )
+            contents.append(bubble)
+        
+        return FlexSendMessage(
+            alt_text="商品列表",
+            contents={
+                "type": "carousel",
+                "contents": [bubble.as_json_dict() for bubble in contents]
+            }
+        )
+    
+    @staticmethod
+    def create_help_message() -> TextSendMessage:
+        """建立說明訊息"""
+        help_text = """
+🤖 歡迎使用智能查詢機器人！
+
+📝 支援的查詢類型：
+• 用戶查詢：「查詢用戶 張三」
+• 訂單查詢：「查詢訂單 ORD001」
+• 商品查詢：「查詢商品 iPhone」
+• 價格範圍：「價格 1000 到 5000 的商品」
+• 統計分析：「統計用戶數量」
+
+💡 使用範例：
+• 「找用戶名叫王小明的資料」
+• 「我的訂單狀態如何」
+• 「有什麼手機商品」
+• 「總共有多少筆訂單」
+
+❓ 如需協助，請輸入「幫助」或「說明」
+        """
+        
+        quick_reply_items = [
+            {"label": "查詢用戶", "text": "查詢用戶"},
+            {"label": "查詢訂單", "text": "查詢訂單"},
+            {"label": "查詢商品", "text": "查詢商品"},
+            {"label": "統計資料", "text": "統計"}
+        ]
+        
+        return LineMessageBuilder.create_quick_reply_message(help_text, quick_reply_items)
+    
+    @staticmethod
+    def create_error_message(error_msg: str = None) -> TextSendMessage:
+        """建立錯誤訊息"""
+        default_msg = "抱歉，我無法理解您的訊息。請輸入「幫助」查看使用說明。"
+        text = error_msg if error_msg else default_msg
+        
+        quick_reply_items = [
+            {"label": "幫助", "text": "幫助"},
+            {"label": "重新開始", "text": "開始"}
+        ]
+        
+        return LineMessageBuilder.create_quick_reply_message(text, quick_reply_items)
+
+def get_user_display_name(line_bot_api, user_id: str) -> str:
+    """取得用戶顯示名稱"""
+    try:
+        profile = line_bot_api.get_profile(user_id)
+        return profile.display_name
+    except Exception as e:
+        logger.error(f"取得用戶資料失敗: {str(e)}")
+        return "用戶"
+
+def validate_line_signature(body: bytes, signature: str, channel_secret: str) -> bool:
+    """驗證 LINE Webhook 簽名"""
+    import hashlib
+    import hmac
+    import base64
+    
+    hash_value = hmac.new(
+        channel_secret.encode('utf-8'),
+        body,
+        hashlib.sha256
+    ).digest()
+    
+    expected_signature = base64.b64encode(hash_value).decode('utf-8')
+    return hmac.compare_digest(signature, expected_signature)

requirements.txt

@@ -0,0 +1,13 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+line-bot-sdk==3.5.0
+sqlalchemy==2.0.23
+psycopg==3.1.13
+alembic==1.13.0
+pydantic==2.5.0
+pydantic-settings==2.1.0
+python-multipart==0.0.6
+python-dotenv==1.0.0
+requests==2.31.0
+openai==1.3.0
+httpx==0.25.2

setup_guide.md

@@ -0,0 +1,178 @@
+# LINE Bot + FastAPI + Supabase 設定指南
+
+## 🚀 快速開始
+
+### 1. 必要的 API Keys 和設定
+
+您需要準備以下 API Keys 和設定：
+
+#### LINE Developers Console
+1. 前往 [LINE Developers Console](https://developers.line.biz/)
+2. 建立新的 Provider 和 Messaging API Channel
+3. 取得以下資訊：
+   - `Channel Access Token` (長期)
+   - `Channel Secret`
+
+#### Supabase
+1. 前往 [Supabase](https://supabase.com/)
+2. 建立新專案
+3. 取得以下資訊：
+   - `Project URL`
+   - `Anon/Public Key`
+
+#### OpenRouter (可選)
+1. 前往 [OpenRouter](https://openrouter.ai/)
+2. 註冊帳號並取得 `API Key` (用於進階 NLP 功能)
+3. 選擇適合的模型 (預設: anthropic/claude-3-haiku)
+
+### 2. Hugging Face Spaces 環境變數設定
+
+在 Hugging Face Spaces 的 Settings 中設定以下環境變數：
+
+```
+LINE_CHANNEL_ACCESS_TOKEN=你的_LINE_Channel_Access_Token
+LINE_CHANNEL_SECRET=你的_LINE_Channel_Secret
+SUPABASE_URL=你的_Supabase_專案_URL
+SUPABASE_KEY=你的_Supabase_Anon_Key
+OPENROUTER_API_KEY=你的_OpenRouter_API_Key (可選)
+OPENROUTER_MODEL=anthropic/claude-3-haiku (可選)
+DEBUG=False
+LOG_LEVEL=INFO
+```
+
+### 3. Supabase 資料庫設定
+
+在 Supabase Dashboard 的 SQL Editor 中執行以下 SQL：
+
+```sql
+-- 建立用戶表
+CREATE TABLE IF NOT EXISTS users (
+    user_id VARCHAR(255) PRIMARY KEY,
+    name VARCHAR(255),
+    email VARCHAR(255),
+    display_name VARCHAR(255),
+    picture_url TEXT,
+    status_message TEXT,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- 建立商品表
+CREATE TABLE IF NOT EXISTS products (
+    product_id SERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    description TEXT,
+    price DECIMAL(10,2) NOT NULL,
+    stock INTEGER DEFAULT 0,
+    category VARCHAR(100),
+    image_url TEXT,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- 建立訂單表
+CREATE TABLE IF NOT EXISTS orders (
+    order_id VARCHAR(255) PRIMARY KEY,
+    user_id VARCHAR(255) REFERENCES users(user_id),
+    total_amount DECIMAL(10,2) NOT NULL,
+    status VARCHAR(50) DEFAULT 'pending',
+    shipping_address TEXT,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- 建立訂單項目表
+CREATE TABLE IF NOT EXISTS order_items (
+    id SERIAL PRIMARY KEY,
+    order_id VARCHAR(255) REFERENCES orders(order_id),
+    product_id INTEGER REFERENCES products(product_id),
+    quantity INTEGER NOT NULL,
+    unit_price DECIMAL(10,2) NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- 建立訊息記錄表
+CREATE TABLE IF NOT EXISTS line_messages (
+    id SERIAL PRIMARY KEY,
+    user_id VARCHAR(255),
+    message TEXT NOT NULL,
+    message_type VARCHAR(50) DEFAULT 'text',
+    timestamp TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    processed BOOLEAN DEFAULT FALSE
+);
+
+-- 建立用戶會話表
+CREATE TABLE IF NOT EXISTS user_sessions (
+    id SERIAL PRIMARY KEY,
+    user_id VARCHAR(255) REFERENCES users(user_id),
+    session_data JSONB,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+-- 插入範例商品資料
+INSERT INTO products (name, description, price, stock, category) VALUES
+('iPhone 15 Pro', '最新款 iPhone，配備 A17 Pro 晶片', 35900, 50, '手機'),
+('MacBook Air M2', '輕薄筆記型電腦，搭載 M2 晶片', 37900, 30, '筆電'),
+('AirPods Pro', '主動降噪無線耳機', 7490, 100, '耳機');
+```
+
+### 4. LINE Bot Webhook 設定
+
+1. 部署到 Hugging Face Spaces 後，取得您的應用程式 URL
+2. 在 LINE Developers Console 中設定 Webhook URL：
+   ```
+   https://你的用戶名-你的空間名稱.hf.space/webhook
+   ```
+3. 啟用 Webhook 和 Auto-reply messages
+
+### 5. 測試功能
+
+部署完成後，您可以測試以下功能：
+
+#### 用戶查詢
+- "查詢用戶 張三"
+- "找用戶名叫王小明的資料"
+
+#### 商品查詢
+- "查詢商品 iPhone"
+- "有什麼手機商品"
+- "價格 1000 到 5000 的商品"
+
+#### 訂單查詢
+- "查詢訂單 ORD001"
+- "我的訂單狀態如何"
+
+#### 統計分析
+- "統計用戶數量"
+- "總共有多少筆訂單"
+
+#### 說明功能
+- "幫助"
+- "說明"
+
+## 🔧 本地開發
+
+如果要在本地開發：
+
+1. 複製專案
+2. 建立 `.env` 檔案（參考 `.env.example`）
+3. 安裝依賴：`pip install -r requirements.txt`
+4. 執行：`python -m uvicorn backend.main:app --reload --port 7860`
+5. 使用 ngrok 建立公開 URL 用於 LINE Webhook 測試
+
+## 📝 架構說明
+
+- **FastAPI**: Web 框架和 API 端點
+- **Pydantic**: 資料驗證和序列化
+- **LINE Bot SDK**: 處理 LINE 訊息
+- **Supabase**: PostgreSQL 資料庫
+- **NLP Service**: 自然語言處理和意圖識別
+- **Database Service**: 資料庫操作抽象層
+
+## 🚨 注意事項
+
+1. 確保所有環境變數都��確設定
+2. Supabase 資料表必須先建立
+3. LINE Bot Webhook URL 必須是 HTTPS
+4. 測試時注意 LINE 訊息的回應時間限制（30秒）

test_api.py

@@ -0,0 +1,103 @@
+"""
+API 測試腳本
+用於測試 LINE Bot 的各種功能
+"""
+
+import requests
+import json
+from typing import Dict, Any
+
+class APITester:
+    def __init__(self, base_url: str = "http://localhost:7860"):
+        self.base_url = base_url
+    
+    def test_health_check(self):
+        """測試健康檢查端點"""
+        try:
+            response = requests.get(f"{self.base_url}/health")
+            print(f"Health Check: {response.status_code}")
+            print(f"Response: {response.json()}")
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Health check failed: {e}")
+            return False
+    
+    def test_root_endpoint(self):
+        """測試根端點"""
+        try:
+            response = requests.get(f"{self.base_url}/")
+            print(f"Root Endpoint: {response.status_code}")
+            print(f"Response: {response.json()}")
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Root endpoint test failed: {e}")
+            return False
+    
+    def simulate_line_message(self, message: str, user_id: str = "test_user"):
+        """模擬 LINE 訊息"""
+        # 這是一個簡化的 LINE webhook 格式
+        webhook_data = {
+            "events": [
+                {
+                    "type": "message",
+                    "message": {
+                        "type": "text",
+                        "text": message
+                    },
+                    "source": {
+                        "type": "user",
+                        "userId": user_id
+                    },
+                    "replyToken": "test_reply_token"
+                }
+            ]
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/webhook",
+                json=webhook_data,
+                headers={"Content-Type": "application/json"}
+            )
+            print(f"LINE Message Test: {response.status_code}")
+            print(f"Message: {message}")
+            return response.status_code == 200
+        except Exception as e:
+            print(f"LINE message test failed: {e}")
+            return False
+
+def run_tests():
+    """執行所有測試"""
+    tester = APITester()
+    
+    print("=== API 測試開始 ===\n")
+    
+    # 測試基本端點
+    print("1. 測試根端點...")
+    tester.test_root_endpoint()
+    print()
+    
+    print("2. 測試健康檢查...")
+    tester.test_health_check()
+    print()
+    
+    # 測試各種訊息
+    test_messages = [
+        "查詢用戶 張三",
+        "找訂單 ORD001",
+        "查詢商品 iPhone",
+        "價格 1000 到 5000 的商品",
+        "統計用戶數量",
+        "幫助"
+    ]
+    
+    print("3. 測試 LINE 訊息處理...")
+    for i, message in enumerate(test_messages, 1):
+        print(f"3.{i} 測試訊息: {message}")
+        tester.simulate_line_message(message)
+        print()
+    
+    print("=== 測試完成 ===")
+
+if __name__ == "__main__":
+    run_tests()