整合 Pydantic AI 框架並優化專案結構

.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+*.log
+.env.local
+.env.production
+.env.development
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Temporary files
+*.tmp
+*.temp
+temp/
+tmp/

API_KEYS_GUIDE.md

@@ -1,215 +0,0 @@
-# 🔑 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

@@ -1,225 +0,0 @@
-# 業務查詢系統使用指南
-
-## 概述
-
-本系統為您的 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. 錯誤日誌輸出
-
----
-
-**注意**: 這是一個基礎實作，您可以根據實際業務需求進行擴展和優化。

GROQ_INTEGRATION_COMPLETE.md

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

LINEBOT_OPERATION_GUIDE.md

@@ -0,0 +1,296 @@
+# LineBot 操作指南
+
+## 🤖 系統概述
+
+本 LineBot 系統整合了 Pydantic AI 框架，提供智能商品查詢、聊天和業務查詢功能。系統設計考慮了 LINE 群組使用場景，避免不必要的 AI token 消耗。
+
+## 📱 用戶操作指南
+
+### 基本指令
+
+#### 1. 聊天模式
+```
+/chat 你好！今天天氣如何？
+/chat 推薦一些好用的功能
+```
+- **用途**：一般對話、問候、非業務相關問題
+- **適用場景**：群組聊天、客戶服務
+- **AI 服務**：使用 Groq 進行自然對話
+
+#### 2. 商品查詢模式
+```
+/search iPhone 15 Pro
+/search 價格 1000-5000
+/search 庫存不足的商品
+```
+- **用途**：傳統的商品搜尋和業務查詢
+- **適用場景**：明確的商品查詢需求
+- **查詢範圍**：商品、訂單、庫存、客戶資料
+
+#### 3. 幫助指令
+```
+/help
+幫助
+說明
+```
+- **用途**：顯示系統使用說明
+- **回應**：完整的功能介紹和使用範例
+
+### 智能模式（無前綴）
+
+#### 商品推薦查詢
+```
+是否有推薦貓砂？
+有什麼狗糧推薦？
+推薦一些寵物用品
+```
+- **特點**：自動識別推薦意圖
+- **回應**：智能推薦相關商品，包含庫存資訊
+- **優勢**：更自然的對話方式
+
+#### 庫存查詢
+```
+查詢iPhone庫存
+寵物用品還有多少？
+低庫存商品有哪些？
+```
+- **特點**：自動識別庫存查詢意圖
+- **回應**：詳細的庫存狀態和警告提醒
+
+#### 一般對話
+```
+你好！
+今天天氣如何？
+謝謝你的幫助
+```
+- **特點**：自動識別為聊天意圖
+- **回應**：友善的對話回應
+
+## 🏢 管理員操作指南
+
+### 系統監控
+
+#### 1. 健康檢查
+```bash
+curl http://localhost:7860/health
+```
+**回應內容**：
+- 系統狀態
+- 資料庫連線狀態
+- 資料庫連線資訊
+
+#### 2. 路由統計
+在 LINE 中輸入：`統計` 或 `stats`
+
+**統計內容**：
+- 各模式使用次數和百分比
+- Groq 服務狀態
+- Pydantic AI 服務狀態
+
+### API 端點管理
+
+#### 1. 直接聊天 API
+```bash
+curl -X POST "http://localhost:7860/chat" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "今天天氣如何？",
+    "user_id": "admin_user"
+  }'
+```
+
+#### 2. 直接搜尋 API
+```bash
+curl -X POST "http://localhost:7860/search" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "iPhone 15",
+    "user_id": "admin_user"
+  }'
+```
+
+#### 3. 商品查詢 API
+```bash
+curl -X POST "http://localhost:7860/product-query" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "是否有推薦貓砂？",
+    "user_id": "admin_user"
+  }'
+```
+
+#### 4. 智能路由 API
+```bash
+curl -X POST "http://localhost:7860/route" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "有什麼狗糧推薦？",
+    "user_id": "admin_user"
+  }'
+```
+
+### 系統配置
+
+#### 環境變數檢查
+```bash
+# 檢查必要的環境變數
+echo $GROQ_API_KEY
+echo $DB_HOST
+echo $LINE_CHANNEL_ACCESS_TOKEN
+```
+
+#### 服務狀態檢查
+```python
+# 在 Python 中檢查服務狀態
+from backend.services.pydantic_ai_service import ProductQueryService
+from backend.services.groq_service import GroqService
+
+product_service = ProductQueryService()
+groq_service = GroqService()
+
+print(f"Pydantic AI 可用: {product_service.is_available()}")
+print(f"Groq 服務可用: {groq_service.is_available()}")
+```
+
+## 🔧 故障排除
+
+### 常見問題
+
+#### 1. 商品查詢沒有結果
+**可能原因**：
+- 資料庫中沒有相關商品
+- 關鍵字匹配不準確
+- 商品被標記為已刪除
+
+**解決方案**：
+- 檢查資料庫商品資料
+- 嘗試使用不同的關鍵字
+- 使用 `/search` 進行傳統查詢
+
+#### 2. Pydantic AI 服務不可用
+**錯誤訊息**：「商品查詢服務暫時無法使用」
+
+**解決方案**：
+- 檢查 `GROQ_API_KEY` 環境變數
+- 確認 Groq API 配額
+- 系統會自動降級到傳統搜尋
+
+#### 3. 資料庫連線失敗
+**錯誤訊息**：「資料庫連線測試失敗」
+
+**解決方案**：
+- 檢查資料庫連線參數
+- 確認資料庫服務運行狀態
+- 檢查網路連線
+
+### 日誌查看
+
+#### 應用程式日誌
+```bash
+# 查看即時日誌
+tail -f app.log
+
+# 搜尋特定錯誤
+grep "ERROR" app.log
+grep "商品查詢錯誤" app.log
+```
+
+#### 特定功能日誌
+```bash
+# Pydantic AI 相關
+grep "Pydantic AI" app.log
+
+# 路由統計
+grep "智能路由" app.log
+
+# 資料庫查詢
+grep "資料庫" app.log
+```
+
+## 📊 效能監控
+
+### API 回應時間
+- **聊天模式**：通常 1-3 秒
+- **商品查詢**：通常 2-5 秒
+- **智能路由**：通常 1-4 秒
+
+### 資源使用
+- **記憶體**：約 200-500MB
+- **CPU**：低負載時 < 10%
+- **網路**：主要是 API 調用
+
+### Token 使用監控
+- 監控 Groq API 使用量
+- 設定使用量警告
+- 考慮實施使用限制
+
+## 🚀 部署指南
+
+### 開發環境
+```bash
+# 1. 安裝依賴
+pip install -r requirements.txt
+
+# 2. 設定環境變數
+cp .env.example .env
+# 編輯 .env 文件
+
+# 3. 運行測試
+python test_pydantic_ai_integration.py
+
+# 4. 啟動服務
+uvicorn backend.main:app --host 0.0.0.0 --port 7860
+```
+
+### 生產環境
+```bash
+# 使用 Docker
+docker build -t linebot-pydantic .
+docker run -p 7860:7860 --env-file .env linebot-pydantic
+
+# 或使用 Docker Compose
+docker-compose up -d
+```
+
+### LINE Webhook 設定
+1. 在 LINE Developers Console 設定 Webhook URL
+2. URL 格式：`https://your-domain.com/webhook`
+3. 確認 SSL 憑證有效
+
+## 📋 維護檢查清單
+
+### 每日檢查
+- [ ] 系統健康狀態
+- [ ] API 回應時間
+- [ ] 錯誤日誌
+- [ ] Groq API 使用量
+
+### 每週檢查
+- [ ] 路由統計分析
+- [ ] 資料庫效能
+- [ ] 商品資料更新
+- [ ] 用戶回饋收集
+
+### 每月檢查
+- [ ] 系統效能評估
+- [ ] 功能使用分析
+- [ ] 安全性檢查
+- [ ] 備份驗證
+
+## 📞 支援聯絡
+
+### 技術問題
+- 檢查日誌文件
+- 參考故障排除指南
+- 聯絡系統管理員
+
+### 功能建議
+- 記錄用戶需求
+- 評估實施可行性
+- 規劃功能更新
+
+---
+
+**版本**：v1.0  
+**更新日期**：2025-01-12  
+**維護團隊**：開發團隊

OPENROUTER_INTEGRATION.md

@@ -1,273 +0,0 @@
-# 🚀 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

@@ -1,342 +0,0 @@
-# 🔄 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 官方文件
-
----
-
-**注意**: 遷移前請務必備份您的資料庫，並在測試環境中驗證所有功能正常運作。

PYDANTIC_AI_INTEGRATION.md

@@ -0,0 +1,227 @@
+# Pydantic AI 整合說明文件
+
+## 📋 概述
+
+本次更新整合了 Pydantic AI 框架到 LineBot 專案中，主要解決商品查詢準確性問題，特別是像 "是否有推薦貓砂?" 這類自然語言查詢。
+
+## 🎯 解決的問題
+
+### 原有問題
+- 用戶詢問 "是否有推薦貓砂?" 時，系統常常回答沒有相關資訊
+- 商品查詢意圖識別不準確
+- 缺乏智能推薦功能
+
+### 解決方案
+- 整合 Pydantic AI 框架，提供更精確的意圖識別
+- 移植 inventory 專案的查詢功能，增強商品搜尋能力
+- 新增智能商品推薦系統
+
+## 🔧 技術架構變更
+
+### 新增組件
+
+1. **Pydantic AI 服務** (`backend/services/pydantic_ai_service.py`)
+   - 商品查詢意圖分析
+   - 智能推薦系統
+   - 結構化輸出驗證
+
+2. **增強商品服務** (`backend/services/enhanced_product_service.py`)
+   - 進階商品搜尋
+   - 商品推薦功能
+   - 庫存狀態分析
+
+3. **新增依賴**
+   - `pydantic-ai[groq]`: Pydantic AI 框架
+
+### 修改組件
+
+1. **訊息路由器** (`backend/services/message_router.py`)
+   - 新增商品查詢路由邏輯
+   - 整合 Pydantic AI 意圖分析
+   - 保留原有 `/chat` 和 `/search` 功能
+
+2. **主應用** (`backend/main.py`)
+   - 新增 `/product-query` API 端點
+
+## 🚀 功能特性
+
+### 1. 智能意圖識別
+```python
+# 自動識別商品查詢意圖
+"是否有推薦貓砂?" → 商品推薦查詢 (信心度: 0.8)
+"有什麼狗糧推薦?" → 商品推薦查詢 (信心度: 0.9)
+"查詢iPhone庫存" → 庫存查詢 (信心度: 0.7)
+```
+
+### 2. 智能商品推薦
+- 基於關鍵字的商品匹配
+- 優先顯示有庫存的商品
+- 提供推薦原因說明
+
+### 3. 增強的庫存資訊
+- 實時庫存狀態顯示
+- 庫存警告提醒
+- 緊急程度分級
+
+## 📱 使用指南
+
+### LINE Bot 使用方式
+
+#### 1. 指令模式（原有功能保留）
+```
+/chat 今天天氣如何？          # 聊天模式
+/search iPhone 15 Pro        # 商品查詢模式
+/help                        # 顯示幫助
+```
+
+#### 2. 智能模式（新增功能）
+直接輸入訊息，系統自動判斷意圖：
+```
+是否有推薦貓砂？             # → 智能商品推薦
+有什麼狗糧推薦？             # → 智能商品推薦
+查詢寵物用品庫存             # → 庫存查詢
+iPhone 還有庫存嗎？          # → 庫存查詢
+你好！                      # → 聊天模式
+```
+
+### API 端點
+
+#### 1. 原有端點（保留）
+- `POST /chat`: 直接聊天
+- `POST /search`: 直接搜尋
+- `POST /route`: 智能路由
+
+#### 2. 新增端點
+- `POST /product-query`: 專門的商品查詢
+
+### API 使用範例
+
+```bash
+# 商品查詢 API
+curl -X POST "http://localhost:7860/product-query" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "是否有推薦貓砂？",
+    "user_id": "test_user"
+  }'
+
+# 智能路由 API
+curl -X POST "http://localhost:7860/route" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "message": "有什麼狗糧推薦？",
+    "user_id": "test_user"
+  }'
+```
+
+## ⚙️ 配置要求
+
+### 環境變數
+```env
+# 必需
+GROQ_API_KEY=your_groq_api_key_here
+DB_HOST=your_database_host
+DB_NAME=your_database_name
+DB_USER=your_database_user
+DB_PASSWORD=your_database_password
+
+# LINE Bot (如果使用)
+LINE_CHANNEL_ACCESS_TOKEN=your_line_token
+LINE_CHANNEL_SECRET=your_line_secret
+```
+
+### 依賴安裝
+```bash
+pip install -r requirements.txt
+```
+
+## 🧪 測試
+
+### 運行測試腳本
+```bash
+python test_pydantic_ai_integration.py
+```
+
+### 測試案例
+1. 商品推薦查詢
+2. 庫存查詢
+3. 意圖分析準確性
+4. 路由統計
+
+## 📊 路由統計
+
+系統會追蹤各種路由模式的使用情況：
+- 💬 聊天模式
+- 🔍 搜尋模式  
+- 🛍️ 商品查詢（新增）
+- 🧠 智能路由
+- ❓ 幫助模式
+- ❌ 錯誤次數
+
+查看統計：輸入 `統計` 或 `stats`
+
+## 🔄 路由邏輯
+
+```
+用戶訊息
+    ↓
+是否有前綴？
+    ├─ /chat → 聊天模式
+    ├─ /search → 搜尋模式  
+    ├─ /help → 幫助模式
+    └─ 無前綴 → 智能路由
+                    ↓
+            Pydantic AI 意圖分析
+                    ↓
+            商品查詢？(信心度>0.6)
+                ├─ 是 → 商品查詢模式
+                └─ 否 → 關鍵字分析
+                            ↓
+                    搜尋關鍵字？
+                        ├─ 是 → 搜尋模式
+                        └─ 否 → 聊天模式
+```
+
+## 🚨 注意事項
+
+### LINE 群組使用
+- **保留前綴設計**：在群組中使用 `/chat` 和 `/search` 前綴，避免所有訊息都觸發 AI
+- **智能路由**：只在私聊或明確需要時使用無前綴訊息
+
+### 效能考量
+- Pydantic AI 查詢會消耗 Groq API token
+- 建議在生產環境中監控 API 使用量
+- 可以調整意圖識別的信心度閾值
+
+### 錯誤處理
+- 當 Pydantic AI 不可用���，會自動降級到原有的搜尋功能
+- 完整的錯誤日誌記錄
+
+## 📈 預期效果
+
+### 查詢準確性提升
+- **之前**：「是否有推薦貓砂？」→ 沒有相關資訊
+- **現在**：「是否有推薦貓砂？」→ 顯示貓砂商品列表，包含庫存狀態
+
+### 用戶體驗改善
+- 更自然的對話方式
+- 智能推薦功能
+- 詳細的庫存資訊
+
+### 系統可維護性
+- 模組化設計
+- 完整的測試覆蓋
+- 清晰的錯誤處理
+
+## 🔮 未來擴展
+
+1. **多語言支援**：擴展到英文查詢
+2. **個人化推薦**：基於用戶歷史的推薦
+3. **語音查詢**：整合語音識別
+4. **圖片查詢**：支援商品圖片搜尋
+
+---
+
+**版本**：v1.0  
+**更新日期**：2025-01-12  
+**作者**：Augment Agent

another_proj_schemas.py

@@ -1,492 +0,0 @@
-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

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

backend/main.py

@@ -147,17 +147,17 @@ async def smart_route(request: dict):
     try:
         message = request.get("message", "")
         user_id = request.get("user_id", "api_user")
-        
+
         if not message:
             return {
                 "success": False,
                 "error": "訊息內容不能為空"
             }
-        
+
         # 使用智能路由
         result = message_router.route_message(message, user_id)
         return result
-        
+
     except Exception as e:
         logger.error(f"智能路由 API 錯誤: {str(e)}")
         return {
@@ -166,6 +166,41 @@ async def smart_route(request: dict):
             "text": "路由服務暫時無法使用"
         }
 
+@app.post("/product-query")
+async def product_query(request: dict):
+    """專門的商品查詢 API - 使用 Pydantic AI"""
+    try:
+        message = request.get("message", "")
+        user_id = request.get("user_id", "api_user")
+
+        if not message:
+            return {
+                "success": False,
+                "error": "查詢內容不能為空"
+            }
+
+        # 直接使用商品查詢服務
+        from backend.services.pydantic_ai_service import ProductQueryService
+        product_service = ProductQueryService()
+
+        if not product_service.is_available():
+            return {
+                "success": False,
+                "error": "商品查詢服務不可用，請檢查 GROQ_API_KEY 設定",
+                "text": "商品查詢服務暫時無法使用"
+            }
+
+        result = product_service.process_product_query_sync(message, user_id)
+        return result
+
+    except Exception as e:
+        logger.error(f"商品查詢 API 錯誤: {str(e)}")
+        return {
+            "success": False,
+            "error": str(e),
+            "text": "商品查詢服務暫時無法使用"
+        }
+
 @app.get("/stats")
 async def get_stats():
     """取得路由統計"""

backend/services/enhanced_product_service.py

@@ -0,0 +1,301 @@
+"""
+增強的商品查詢服務 - 移植自 inventory_proj_routers
+提供更精確的商品搜尋和庫存查詢功能
+"""
+
+import logging
+from typing import List, Optional, Dict, Any
+from sqlalchemy.orm import Session, joinedload
+from sqlalchemy import or_, and_, func
+from backend.database.connection import get_database_session, close_database_session
+from backend.database.models import Product, Category, PurchaseOrder, SalesOrder
+from backend.models.schemas import DatabaseResult
+
+logger = logging.getLogger(__name__)
+
+class EnhancedProductService:
+    """增強的商品查詢服務"""
+    
+    def __init__(self):
+        pass
+    
+    def search_products_advanced(
+        self, 
+        query_text: str = None, 
+        category_name: str = None,
+        warehouse: str = None,
+        include_stock_info: bool = True,
+        min_stock: int = None,
+        max_stock: int = None,
+        limit: int = 20
+    ) -> DatabaseResult:
+        """
+        進階商品搜尋功能
+        
+        Args:
+            query_text: 搜尋關鍵字（商品名稱、編號、條碼）
+            category_name: 分類名稱
+            warehouse: 倉庫名稱
+            include_stock_info: 是否包含庫存資訊
+            min_stock: 最小庫存量
+            max_stock: 最大庫存量
+            limit: 查詢限制數量
+        """
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 建立基本查詢，預載入分類資訊
+            query = db.query(Product).options(
+                joinedload(Product.category)
+            ).filter(Product.is_deleted == False)
+            
+            # 關鍵字搜尋 - 支援商品名稱、編號、條碼
+            if query_text:
+                search_terms = query_text.strip().split()
+                for term in search_terms:
+                    search_filter = or_(
+                        Product.productName.ilike(f"%{term}%"),
+                        Product.productCode.ilike(f"%{term}%"),
+                        Product.barcode.ilike(f"%{term}%")
+                    )
+                    query = query.filter(search_filter)
+            
+            # 分類篩選
+            if category_name:
+                query = query.join(Category).filter(
+                    Category.name.ilike(f"%{category_name}%")
+                )
+            
+            # 倉庫篩選
+            if warehouse:
+                query = query.filter(Product.warehouse.ilike(f"%{warehouse}%"))
+            
+            # 庫存範圍篩選
+            if min_stock is not None:
+                query = query.filter(Product.stock >= min_stock)
+            if max_stock is not None:
+                query = query.filter(Product.stock <= max_stock)
+            
+            # 執行查詢
+            products = query.limit(limit).all()
+            
+            # 轉換為字典格式
+            data = []
+            for product in products:
+                product_data = {
+                    "id": product.id,
+                    "product_code": product.productCode,
+                    "product_name": product.productName,
+                    "unit": product.unit,
+                    "warehouse": product.warehouse,
+                    "unit_weight": product.unitWeight,
+                    "barcode": product.barcode,
+                    "category_id": product.category_id,
+                    "category_name": product.category.name if product.category else None,
+                    "created_at": product.createdAt.isoformat() if product.createdAt else None,
+                    "updated_at": product.updatedAt.isoformat() if product.updatedAt else None
+                }
+                
+                # 包含庫存資訊
+                if include_stock_info:
+                    product_data.update({
+                        "current_stock": product.stock,
+                        "stock_status": self._get_stock_status(product.stock),
+                        "is_low_stock": product.stock <= 10
+                    })
+                
+                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_products_by_category(self, category_name: str, limit: int = 20) -> DatabaseResult:
+        """根據分類獲取商品"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            products = db.query(Product).join(Category).filter(
+                and_(
+                    Category.name.ilike(f"%{category_name}%"),
+                    Product.is_deleted == False
+                )
+            ).options(joinedload(Product.category)).limit(limit).all()
+            
+            data = []
+            for product in products:
+                data.append({
+                    "id": product.id,
+                    "product_code": product.productCode,
+                    "product_name": product.productName,
+                    "current_stock": product.stock,
+                    "unit": product.unit,
+                    "category_name": product.category.name if product.category else None,
+                    "warehouse": product.warehouse
+                })
+            
+            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_low_stock_products(self, threshold: int = 10) -> DatabaseResult:
+        """獲取低庫存商品"""
+        db = None
+        try:
+            db = get_database_session()
+            
+            products = db.query(Product).filter(
+                and_(
+                    Product.stock <= threshold,
+                    Product.is_deleted == False
+                )
+            ).options(joinedload(Product.category)).all()
+            
+            data = []
+            for product in products:
+                data.append({
+                    "id": product.id,
+                    "product_code": product.productCode,
+                    "product_name": product.productName,
+                    "current_stock": product.stock,
+                    "threshold": threshold,
+                    "unit": product.unit,
+                    "category_name": product.category.name if product.category else None,
+                    "warehouse": product.warehouse,
+                    "urgency_level": self._get_urgency_level(product.stock)
+                })
+            
+            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_product_recommendations(self, query_text: str, limit: int = 5) -> DatabaseResult:
+        """
+        商品推薦功能 - 基於關鍵字的智能推薦
+        特別針對像 "推薦貓砂" 這樣的查詢
+        """
+        db = None
+        try:
+            db = get_database_session()
+            
+            # 分析查詢關鍵字
+            keywords = self._extract_keywords(query_text)
+            
+            # 建立推薦查詢
+            query = db.query(Product).filter(Product.is_deleted == False)
+            
+            # 多關鍵字匹配
+            for keyword in keywords:
+                search_filter = or_(
+                    Product.productName.ilike(f"%{keyword}%"),
+                    Product.productCode.ilike(f"%{keyword}%")
+                )
+                query = query.filter(search_filter)
+            
+            # 優先顯示有庫存的商品
+            query = query.order_by(Product.stock.desc())
+            
+            products = query.options(joinedload(Product.category)).limit(limit).all()
+            
+            data = []
+            for product in products:
+                data.append({
+                    "id": product.id,
+                    "product_code": product.productCode,
+                    "product_name": product.productName,
+                    "current_stock": product.stock,
+                    "unit": product.unit,
+                    "category_name": product.category.name if product.category else None,
+                    "warehouse": product.warehouse,
+                    "recommendation_reason": f"符合關鍵字: {', '.join(keywords)}",
+                    "availability": "有庫存" if product.stock > 0 else "缺貨"
+                })
+            
+            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_stock_status(self, stock: int) -> str:
+        """獲取庫存狀態"""
+        if stock <= 0:
+            return "缺��"
+        elif stock <= 5:
+            return "庫存極低"
+        elif stock <= 10:
+            return "庫存偏低"
+        elif stock <= 50:
+            return "庫存正常"
+        else:
+            return "庫存充足"
+    
+    def _get_urgency_level(self, stock: int) -> str:
+        """獲取緊急程度"""
+        if stock <= 0:
+            return "緊急"
+        elif stock <= 3:
+            return "高"
+        elif stock <= 10:
+            return "中"
+        else:
+            return "低"
+    
+    def _extract_keywords(self, query_text: str) -> List[str]:
+        """從查詢文字中提取關鍵字"""
+        # 移除常見的查詢詞彙
+        stop_words = ['推薦', '有沒有', '是否有', '請問', '想要', '需要', '找', '查詢', '搜尋']
+        
+        # 分割並清理關鍵字
+        words = query_text.replace('?', '').replace('？', '').split()
+        keywords = [word for word in words if word not in stop_words and len(word) > 1]
+        
+        return keywords if keywords else [query_text.strip()]

backend/services/message_router.py

@@ -6,6 +6,7 @@ import logging
 from typing import Dict, Any
 from backend.services.groq_service import GroqService
 from backend.services.business_query_service import BusinessQueryService
+from backend.services.pydantic_ai_service import ProductQueryService
 
 logger = logging.getLogger(__name__)
 
@@ -15,11 +16,13 @@ class MessageRouter:
     def __init__(self):
         self.groq_service = GroqService()
         self.business_service = BusinessQueryService()
-        
+        self.product_query_service = ProductQueryService()
+
         # 路由統計
         self.route_stats = {
             "chat": 0,
-            "search": 0, 
+            "search": 0,
+            "product_query": 0,
             "help": 0,
             "smart": 0,
             "error": 0
@@ -177,14 +180,23 @@ class MessageRouter:
     def _handle_smart_routing(self, message: str, user_id: str) -> Dict[str, Any]:
         """智能路由 - 根據內容判斷意圖"""
         try:
-            # 先進行簡單的關鍵字預篩選
+            # 1. 先檢查是否為商品查詢 (使用 Pydantic AI)
+            if self.product_query_service.is_available():
+                product_intent = self.product_query_service.analyze_query_intent(message)
+
+                if product_intent["is_product_query"] and product_intent["confidence"] > 0.6:
+                    logger.info(f"智能路由 -> Pydantic AI 商品查詢 (信心度: {product_intent['confidence']})")
+                    self.route_stats["product_query"] += 1
+                    return self._handle_product_query_mode(message, user_id)
+
+            # 2. 進行簡單的關鍵字預篩選
             quick_intent = self._quick_intent_check(message)
-            
+
             if quick_intent == "search":
                 # 高信心度的搜尋關鍵字 -> 直接轉到搜尋模式
                 logger.info(f"快速意圖識別: 搜尋模式 - {message[:30]}...")
                 return self._handle_search_mode(message, user_id)
-            
+
             elif quick_intent == "help":
                 # 幫助相關 -> 轉到幫助模式
                 return self._handle_help_mode(user_id)
@@ -223,7 +235,60 @@ class MessageRouter:
             logger.error(f"智能路由處理錯誤: {str(e)}")
             # 錯誤時預設為聊天模式
             return self._handle_chat_mode(message, user_id)
-    
+
+    def _handle_product_query_mode(self, message: str, user_id: str) -> Dict[str, Any]:
+        """處理 Pydantic AI 商品查詢模式"""
+        try:
+            if not message:
+                return {
+                    "type": "text",
+                    "text": "🛍️ 請告訴我您想查詢什麼商品！\n\n範例：\n• 是否有推薦貓砂？\n• 查詢狗糧庫存\n• 有什麼寵物用品？",
+                    "mode": "product_query",
+                    "success": True
+                }
+
+            if not self.product_query_service.is_available():
+                return {
+                    "type": "text",
+                    "text": "🛍️ 商品查詢服務暫時無法使用，請稍後再試。\n\n💡 您可以嘗試使用 /search 進行基本查詢。",
+                    "mode": "product_query",
+                    "success": False,
+                    "error": "Pydantic AI 服務不可用"
+                }
+
+            # 使用同步版本避免異步複雜性
+            result = self.product_query_service.process_product_query_sync(message, user_id)
+
+            if result["success"]:
+                return {
+                    "type": "text",
+                    "text": f"🛍️ {result['text']}",
+                    "mode": "product_query",
+                    "success": True,
+                    "products_found": result.get("products_found", 0),
+                    "has_recommendations": result.get("has_recommendations", False),
+                    "user_id": user_id
+                }
+            else:
+                return {
+                    "type": "text",
+                    "text": f"🛍️ {result.get('text', '商品查詢失敗')}",
+                    "mode": "product_query",
+                    "success": False,
+                    "error": result.get("error"),
+                    "user_id": user_id
+                }
+
+        except Exception as e:
+            logger.error(f"商品查詢模式處理錯誤: {str(e)}")
+            return {
+                "type": "text",
+                "text": "🛍️ 商品查詢服務暫時無法使用，請稍後再試。",
+                "mode": "product_query",
+                "success": False,
+                "error": str(e)
+            }
+
     def _quick_intent_check(self, message: str) -> str:
         """快速意圖檢查 - 基於關鍵字"""
         message_lower = message.lower()
@@ -253,7 +318,7 @@ class MessageRouter:
 • /chat [訊息] - 聊天模式
   範例：/chat 今天天氣如何？
 
-• /search [查詢] - 商品查詢模式  
+• /search [查詢] - 商品查詢模式
   範例：/search iPhone 15 Pro
   ��例：/search 價格 1000-5000
 
@@ -262,16 +327,22 @@ class MessageRouter:
 🧠 智能模式：
 直接輸入訊息，系統會自動判斷是聊天還是查詢！
 
-💡 查詢範例：
+🛍️ 商品查詢範例（AI 智能識別）：
+• "是否有推薦貓砂？"
+• "有什麼狗糧推薦？"
+• "查詢寵物用品庫存"
 • "iPhone 還有庫存嗎？"
 • "1000到5000的商品有哪些？"
-• "我的訂單狀態如何？"
 
 💬 聊天範例：
 • "你好！"
 • "今天天氣如何？"
 • "推薦一些好用的功能"
 
+📋 其他查詢：
+• "我的訂單狀態如何？"
+• "低庫存商品有哪些？"
+
 輸入「選單」查看功能選單
 輸入「統計」查看使用統計"""
 
@@ -327,11 +398,13 @@ class MessageRouter:
 
 💬 聊天模式: {self.route_stats['chat']} ({self.route_stats['chat']/total_routes*100:.1f}%)
 🔍 搜尋模式: {self.route_stats['search']} ({self.route_stats['search']/total_routes*100:.1f}%)
+🛍️ 商品查詢: {self.route_stats['product_query']} ({self.route_stats['product_query']/total_routes*100:.1f}%)
 🧠 智能路由: {self.route_stats['smart']} ({self.route_stats['smart']/total_routes*100:.1f}%)
 ❓ 幫助模式: {self.route_stats['help']} ({self.route_stats['help']/total_routes*100:.1f}%)
 ❌ 錯誤次數: {self.route_stats['error']} ({self.route_stats['error']/total_routes*100:.1f}%)
 
-🤖 Groq 服務: {'✅ 可用' if self.groq_service.is_available() else '❌ 不可用'}"""
+🤖 Groq 服務: {'✅ 可用' if self.groq_service.is_available() else '❌ 不可用'}
+🛍️ Pydantic AI: {'✅ 可用' if self.product_query_service.is_available() else '❌ 不可用'}"""
 
         return {
             "type": "text",

backend/services/pydantic_ai_service.py

@@ -0,0 +1,426 @@
+"""
+Pydantic AI 服務 - 使用 Pydantic AI 框架整合 Groq 和商品查詢功能
+解決商品查詢準確性問題，特別是像 "是否有推薦貓砂?" 這類查詢
+"""
+
+import logging
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent, RunContext
+
+from backend.services.enhanced_product_service import EnhancedProductService
+from backend.services.database_service import DatabaseService
+from backend.config import settings
+
+logger = logging.getLogger(__name__)
+
+# 依賴注入類型
+@dataclass
+class ProductQueryDependencies:
+    """商品查詢依賴"""
+    enhanced_product_service: EnhancedProductService
+    database_service: DatabaseService
+    user_id: Optional[str] = None
+
+# 輸出模型
+class ProductQueryResult(BaseModel):
+    """商品查詢結果"""
+    intent: str = Field(description="查詢意圖")
+    response_text: str = Field(description="回應文字")
+    products_found: int = Field(description="找到的商品數量")
+    has_recommendations: bool = Field(description="是否包含推薦")
+    stock_info_included: bool = Field(description="是否包含庫存資訊")
+    search_keywords: List[str] = Field(default_factory=list, description="搜尋關鍵字")
+
+class ProductQueryService:
+    """Pydantic AI 商品查詢服務"""
+    
+    def __init__(self):
+        self.enhanced_product_service = EnhancedProductService()
+        self.database_service = DatabaseService()
+        
+        # 創建 Pydantic AI Agent
+        self.product_agent = Agent(
+            f'groq:{settings.GROQ_MODEL}',
+            deps_type=ProductQueryDependencies,
+            output_type=ProductQueryResult,
+            system_prompt=self._get_system_prompt()
+        )
+        
+        # 註冊工具
+        self._register_tools()
+    
+    def _get_system_prompt(self) -> str:
+        """系統提示詞"""
+        return """你是一個專業的商品查詢助手，專門協助用戶查詢商品資訊。
+
+你的主要任務：
+1. 理解用戶的商品查詢意圖，包括推薦、搜尋、庫存查詢等
+2. 使用適當的工具查詢商品資料庫
+3. 提供準確、有用的商品資訊回應
+
+特別注意：
+- 當用戶詢問"推薦"、"有沒有"、"是否有"時，要積極查詢相關商品
+- 優先顯示有庫存的商品
+- 提供具體的商品名稱、庫存狀況和分類資訊
+- 如果沒有找到完全匹配的商品，嘗試提供相似或相關的商品
+
+回應要求：
+- 使用繁體中文
+- 語氣友善專業
+- 資訊準確完整
+- 如果有多個商品，按庫存量排序推薦"""
+    
+    def _register_tools(self):
+        """註冊 AI Agent 工具"""
+        
+        @self.product_agent.tool
+        async def search_products(
+            ctx: RunContext[ProductQueryDependencies], 
+            query_text: str,
+            include_recommendations: bool = False
+        ) -> Dict[str, Any]:
+            """
+            搜尋商品
+            
+            Args:
+                query_text: 搜尋關鍵字
+                include_recommendations: 是否包含推薦功能
+            """
+            try:
+                if include_recommendations:
+                    # 使用推薦功能
+                    result = ctx.deps.enhanced_product_service.get_product_recommendations(
+                        query_text=query_text,
+                        limit=10
+                    )
+                else:
+                    # 使用一般搜尋
+                    result = ctx.deps.enhanced_product_service.search_products_advanced(
+                        query_text=query_text,
+                        include_stock_info=True,
+                        limit=10
+                    )
+                
+                return {
+                    "success": result.success,
+                    "products": result.data,
+                    "count": result.count,
+                    "error": result.error
+                }
+            except Exception as e:
+                logger.error(f"商品搜尋工具錯誤: {str(e)}")
+                return {
+                    "success": False,
+                    "products": [],
+                    "count": 0,
+                    "error": str(e)
+                }
+        
+        @self.product_agent.tool
+        async def get_products_by_category(
+            ctx: RunContext[ProductQueryDependencies],
+            category_name: str
+        ) -> Dict[str, Any]:
+            """
+            根據分類獲取商品
+            
+            Args:
+                category_name: 分類名稱
+            """
+            try:
+                result = ctx.deps.enhanced_product_service.get_products_by_category(
+                    category_name=category_name,
+                    limit=10
+                )
+                
+                return {
+                    "success": result.success,
+                    "products": result.data,
+                    "count": result.count,
+                    "error": result.error
+                }
+            except Exception as e:
+                logger.error(f"分類查詢工具錯誤: {str(e)}")
+                return {
+                    "success": False,
+                    "products": [],
+                    "count": 0,
+                    "error": str(e)
+                }
+        
+        @self.product_agent.tool
+        async def check_low_stock_products(
+            ctx: RunContext[ProductQueryDependencies],
+            threshold: int = 10
+        ) -> Dict[str, Any]:
+            """
+            檢查低庫存商品
+            
+            Args:
+                threshold: 庫存閾值
+            """
+            try:
+                result = ctx.deps.enhanced_product_service.get_low_stock_products(
+                    threshold=threshold
+                )
+                
+                return {
+                    "success": result.success,
+                    "products": result.data,
+                    "count": result.count,
+                    "error": result.error
+                }
+            except Exception as e:
+                logger.error(f"低庫存查詢工具錯誤: {str(e)}")
+                return {
+                    "success": False,
+                    "products": [],
+                    "count": 0,
+                    "error": str(e)
+                }
+    
+    def process_product_query_sync(self, user_message: str, user_id: str = None) -> Dict[str, Any]:
+        """
+        同步處理商品查詢 - 為了避免異步複雜性
+
+        Args:
+            user_message: 用戶訊息
+            user_id: 用戶ID
+
+        Returns:
+            查詢結果字典
+        """
+        try:
+            # 分析查詢意圖
+            intent_analysis = self.analyze_query_intent(user_message)
+
+            if not intent_analysis["is_product_query"]:
+                return {
+                    "success": False,
+                    "text": "這似乎不是商品查詢，請嘗試其他功能。",
+                    "mode": "product_query",
+                    "error": "非商品查詢意圖"
+                }
+
+            # 根據意圖類型選擇查詢方法
+            if intent_analysis["is_recommendation"]:
+                # 推薦查詢
+                result = self.enhanced_product_service.get_product_recommendations(
+                    query_text=user_message,
+                    limit=5
+                )
+            else:
+                # 一般搜尋
+                result = self.enhanced_product_service.search_products_advanced(
+                    query_text=user_message,
+                    include_stock_info=True,
+                    limit=10
+                )
+
+            # 格式化回應
+            if result.success and result.data:
+                response_text = self._format_product_response(result.data, intent_analysis)
+
+                return {
+                    "success": True,
+                    "intent": "product_query",
+                    "text": response_text,
+                    "products_found": result.count,
+                    "has_recommendations": intent_analysis["is_recommendation"],
+                    "stock_info_included": True,
+                    "search_keywords": self._extract_keywords_from_message(user_message),
+                    "mode": "product_query",
+                    "user_id": user_id
+                }
+            else:
+                return {
+                    "success": False,
+                    "text": f"抱歉，沒有找到相關商品。{result.error if result.error else ''}",
+                    "mode": "product_query",
+                    "error": result.error,
+                    "user_id": user_id
+                }
+
+        except Exception as e:
+            logger.error(f"同步商品查詢錯誤: {str(e)}")
+            return {
+                "success": False,
+                "text": f"抱歉，商品查詢時發生錯誤：{str(e)}",
+                "mode": "product_query",
+                "error": str(e),
+                "user_id": user_id
+            }
+
+    async def process_product_query(self, user_message: str, user_id: str = None) -> Dict[str, Any]:
+        """
+        處理商品查詢
+        
+        Args:
+            user_message: 用戶訊息
+            user_id: 用戶ID
+            
+        Returns:
+            查詢結果字典
+        """
+        try:
+            # 準備依賴
+            deps = ProductQueryDependencies(
+                enhanced_product_service=self.enhanced_product_service,
+                database_service=self.database_service,
+                user_id=user_id
+            )
+            
+            # 執行 AI Agent
+            result = await self.product_agent.run(user_message, deps=deps)
+            
+            # 記錄查詢
+            if user_id:
+                try:
+                    self.database_service.save_message(user_id, user_message, "product_query")
+                except Exception as e:
+                    logger.warning(f"記錄查詢失敗: {str(e)}")
+            
+            return {
+                "success": True,
+                "intent": result.output.intent,
+                "text": result.output.response_text,
+                "products_found": result.output.products_found,
+                "has_recommendations": result.output.has_recommendations,
+                "stock_info_included": result.output.stock_info_included,
+                "search_keywords": result.output.search_keywords,
+                "mode": "product_query",
+                "user_id": user_id
+            }
+            
+        except Exception as e:
+            logger.error(f"Pydantic AI 商品查詢錯誤: {str(e)}")
+            return {
+                "success": False,
+                "text": f"抱歉，商品查詢時發生錯誤：{str(e)}",
+                "mode": "product_query",
+                "error": str(e),
+                "user_id": user_id
+            }
+    
+    def is_available(self) -> bool:
+        """檢查服務是否可用"""
+        return bool(settings.GROQ_API_KEY)
+    
+    def analyze_query_intent(self, message: str) -> Dict[str, Any]:
+        """
+        分析查詢意圖 - 判斷是否為商品查詢
+        
+        Args:
+            message: 用戶訊息
+            
+        Returns:
+            意圖分析結果
+        """
+        message_lower = message.lower()
+        
+        # 商品查詢關鍵字
+        product_keywords = [
+            '推薦', '有沒有', '是否有', '商品', '產品', '貨品', 
+            '查詢', '搜尋', '找', '庫存', '存貨', '價格',
+            '貓砂', '狗糧', '寵物', '食品', '用品'  # 常見商品類別
+        ]
+        
+        # 推薦查詢關鍵字
+        recommendation_keywords = ['推薦', '建議', '介紹', '有什麼', '哪些']
+        
+        # 庫存查詢關鍵字
+        inventory_keywords = ['庫存', '存貨', '剩餘', '還有', '現貨']
+        
+        is_product_query = any(keyword in message_lower for keyword in product_keywords)
+        is_recommendation = any(keyword in message_lower for keyword in recommendation_keywords)
+        is_inventory_check = any(keyword in message_lower for keyword in inventory_keywords)
+        
+        confidence = 0.5
+        if is_product_query:
+            confidence += 0.3
+        if is_recommendation:
+            confidence += 0.2
+        if is_inventory_check:
+            confidence += 0.2
+        
+        return {
+            "is_product_query": is_product_query,
+            "is_recommendation": is_recommendation,
+            "is_inventory_check": is_inventory_check,
+            "confidence": min(confidence, 1.0),
+            "intent": "product_query" if is_product_query else "unknown"
+        }
+
+    def _format_product_response(self, products: List[Dict[str, Any]], intent_analysis: Dict[str, Any]) -> str:
+        """格式化商品查詢回應"""
+        if not products:
+            return "沒有找到相關商品。"
+
+        # 根據意圖類型調整回應風格
+        if intent_analysis["is_recommendation"]:
+            header = f"為您推薦 {len(products)} 個商品："
+        elif intent_analysis["is_inventory_check"]:
+            header = f"庫存查詢結果，找到 {len(products)} 個商品："
+        else:
+            header = f"商品搜尋結果，找到 {len(products)} 個商品："
+
+        response_lines = [header, ""]
+
+        for i, product in enumerate(products[:5], 1):  # 最多顯示5個
+            name = product.get('product_name', 'N/A')
+            stock = product.get('current_stock', 0)
+            category = product.get('category_name', '')
+            warehouse = product.get('warehouse', '')
+
+            # 庫存狀態
+            stock_status = product.get('stock_status', self._get_stock_status_text(stock))
+
+            line = f"{i}. {name}"
+            if category:
+                line += f" ({category})"
+
+            line += f"\n   庫存: {stock} - {stock_status}"
+
+            if warehouse:
+                line += f"\n   倉庫: {warehouse}"
+
+            if product.get('recommendation_reason'):
+                line += f"\n   推薦原因: {product['recommendation_reason']}"
+
+            response_lines.append(line)
+
+        if len(products) > 5:
+            response_lines.append(f"\n... 還有 {len(products) - 5} 個商品")
+
+        # 添加庫存提醒
+        low_stock_count = sum(1 for p in products if p.get('current_stock', 0) <= 10)
+        if low_stock_count > 0:
+            response_lines.append(f"\n⚠️ 其中 {low_stock_count} 個商品庫存偏低，建議盡快補貨。")
+
+        return "\n".join(response_lines)
+
+    def _get_stock_status_text(self, stock: int) -> str:
+        """獲取庫存狀態文字"""
+        if stock <= 0:
+            return "缺貨 ❌"
+        elif stock <= 5:
+            return "庫存極低 🔴"
+        elif stock <= 10:
+            return "庫存偏低 🟡"
+        elif stock <= 50:
+            return "庫存正常 🟢"
+        else:
+            return "庫存充足 ✅"
+
+    def _extract_keywords_from_message(self, message: str) -> List[str]:
+        """從訊息中提取關鍵字"""
+        # 移除常見的查詢詞彙
+        stop_words = ['推薦', '有沒有', '是否有', '請問', '想要', '需要', '找', '查詢', '搜尋', '？', '?']
+
+        # 分割並清理關鍵字
+        words = message.replace('?', '').replace('？', '').split()
+        keywords = [word for word in words if word not in stop_words and len(word) > 1]
+
+        return keywords if keywords else [message.strip()]

groq_python_test.py

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

requirements.txt

@@ -6,6 +6,7 @@ psycopg[binary]==3.1.18
 alembic
 pydantic
 pydantic-settings
+pydantic-ai[groq]
 python-multipart
 python-dotenv
 requests

setup_guide.md

@@ -1,178 +0,0 @@
-# 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_openrouter_connection.py

@@ -1,223 +0,0 @@
-#!/usr/bin/env python3
-"""
-OpenRouter API 連線測試腳本
-測試 DeepSeek V3 是否能正常連接和回應
-"""
-
-import requests
-import json
-import os
-from datetime import datetime
-
-# API 設定
-OPENROUTER_API_KEY = "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"
-OPENROUTER_MODEL = "deepseek/deepseek-chat-v3-0324:free"
-OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
-
-def test_openrouter_connection():
-    """測試 OpenRouter API 連線"""
-    
-    print("🔧 OpenRouter API 連線測試")
-    print("=" * 50)
-    print(f"⏰ 測試時間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    print(f"🔑 API Key: {OPENROUTER_API_KEY[:20]}...")
-    print(f"🤖 模型: {OPENROUTER_MODEL}")
-    print(f"🌐 API URL: {OPENROUTER_URL}")
-    print("=" * 50)
-    
-    # 設定請求標頭
-    headers = {
-        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        "Content-Type": "application/json",
-        "HTTP-Referer": "https://huggingface.co/spaces",
-        "X-Title": "OpenRouter Connection Test"
-    }
-    
-    # 測試案例
-    test_cases = [
-        {
-            "name": "基本連線測試",
-            "message": "你好，請介紹一下自己"
-        },
-        {
-            "name": "中文理解測試", 
-            "message": "請分析這句話的意圖：查詢iPhone庫存"
-        },
-        {
-            "name": "業務查詢測試",
-            "message": "如果用戶說「商品查詢」，這應該被歸類為什麼意圖？請用JSON格式回答"
-        }
-    ]
-    
-    for i, test_case in enumerate(test_cases, 1):
-        print(f"\n📝 測試 {i}: {test_case['name']}")
-        print("-" * 30)
-        
-        # 準備請求資料
-        data = {
-            "model": OPENROUTER_MODEL,
-            "messages": [
-                {
-                    "role": "system",
-                    "content": "你是 DeepSeek V3，一個強大的中文 AI 助手。請用繁體中文回應。"
-                },
-                {
-                    "role": "user",
-                    "content": test_case['message']
-                }
-            ],
-            "temperature": 0.7,
-            "max_tokens": 300
-        }
-        
-        try:
-            print(f"📤 發送請求: {test_case['message']}")
-            
-            # 發送 API 請求
-            response = requests.post(
-                OPENROUTER_URL,
-                headers=headers,
-                json=data,
-                timeout=30
-            )
-            
-            print(f"📊 狀態碼: {response.status_code}")
-            
-            if response.status_code == 200:
-                # 解析回應
-                result = response.json()
-                content = result["choices"][0]["message"]["content"]
-                
-                print(f"✅ 請求成功！")
-                print(f"🤖 DeepSeek V3 回應:")
-                print(f"   {content[:200]}{'...' if len(content) > 200 else ''}")
-                
-                # 顯示使用統計
-                if "usage" in result:
-                    usage = result["usage"]
-                    print(f"📈 Token 使用: {usage.get('total_tokens', 'N/A')} tokens")
-                
-            else:
-                print(f"❌ 請求失敗!")
-                print(f"錯誤回應: {response.text}")
-                
-        except requests.exceptions.Timeout:
-            print("❌ 請求超時 (30秒)")
-            
-        except requests.exceptions.ConnectionError:
-            print("❌ 網路連線錯誤")
-            
-        except json.JSONDecodeError:
-            print("❌ JSON 解析錯誤")
-            print(f"原始回應: {response.text}")
-            
-        except Exception as e:
-            print(f"❌ 未知錯誤: {str(e)}")
-
-def test_api_key_validity():
-    """測試 API Key 有效性"""
-    
-    print("\n🔐 API Key 有效性測試")
-    print("-" * 30)
-    
-    headers = {
-        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        "Content-Type": "application/json"
-    }
-    
-    # 簡單的測試請求
-    data = {
-        "model": OPENROUTER_MODEL,
-        "messages": [{"role": "user", "content": "test"}],
-        "max_tokens": 1
-    }
-    
-    try:
-        response = requests.post(OPENROUTER_URL, headers=headers, json=data, timeout=10)
-        
-        if response.status_code == 200:
-            print("✅ API Key 有效")
-            return True
-        elif response.status_code == 401:
-            print("❌ API Key 無效或已過期")
-            return False
-        elif response.status_code == 402:
-            print("⚠️ 餘額不足")
-            return False
-        else:
-            print(f"⚠️ 未知狀態: {response.status_code}")
-            print(f"回應: {response.text}")
-            return False
-            
-    except Exception as e:
-        print(f"❌ 測試失敗: {str(e)}")
-        return False
-
-def check_model_availability():
-    """檢查模型可用性"""
-    
-    print("\n🤖 模型可用性檢查")
-    print("-" * 30)
-    
-    # 嘗試獲取可用模型列表
-    try:
-        headers = {
-            "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        }
-        
-        response = requests.get("https://openrouter.ai/api/v1/models", headers=headers, timeout=10)
-        
-        if response.status_code == 200:
-            models = response.json()
-            
-            # 檢查 DeepSeek 模型
-            deepseek_models = [model for model in models.get('data', []) 
-                             if 'deepseek' in model.get('id', '').lower()]
-            
-            print(f"✅ 找到 {len(deepseek_models)} 個 DeepSeek 模型:")
-            for model in deepseek_models[:5]:  # 只顯示前5個
-                print(f"   - {model.get('id', 'N/A')}")
-            
-            # 檢查目標模型是否存在
-            target_model_exists = any(model.get('id') == OPENROUTER_MODEL 
-                                    for model in models.get('data', []))
-            
-            if target_model_exists:
-                print(f"✅ 目標模型 {OPENROUTER_MODEL} 可用")
-            else:
-                print(f"⚠️ 目標模型 {OPENROUTER_MODEL} 可能不可用")
-                
-        else:
-            print(f"⚠️ 無法獲取模型列表: {response.status_code}")
-            
-    except Exception as e:
-        print(f"❌ 檢查失敗: {str(e)}")
-
-def main():
-    """主函數"""
-    
-    print("🚀 開始 OpenRouter API 完整測試")
-    print("=" * 60)
-    
-    # 1. 檢查 API Key 有效性
-    if not test_api_key_validity():
-        print("\n❌ API Key 測試失敗，停止後續測試")
-        return
-    
-    # 2. 檢查模型可用性
-    check_model_availability()
-    
-    # 3. 進行完整連線測試
-    test_openrouter_connection()
-    
-    print("\n" + "=" * 60)
-    print("🎉 測試完成！")
-    print("\n💡 如果所有測試都成功，表示:")
-    print("   ✅ OpenRouter API Key 有效")
-    print("   ✅ DeepSeek V3 模型可用")
-    print("   ✅ 網路連線正常")
-    print("   ✅ API 回應正常")
-    print("\n🔧 如果業務查詢仍有問題，則確定是事件循環衝突導致的技術問題")
-
-if __name__ == "__main__":
-    main()

test_pydantic_ai_integration.py

@@ -0,0 +1,168 @@
+"""
+測試 Pydantic AI 整合 - 驗證商品查詢功能
+特別測試 "是否有推薦貓砂?" 這類查詢的準確性
+"""
+
+import asyncio
+import sys
+import os
+
+# 添加專案根目錄到 Python 路徑
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from backend.services.message_router import MessageRouter
+from backend.services.pydantic_ai_service import ProductQueryService
+from backend.services.enhanced_product_service import EnhancedProductService
+
+def test_message_router():
+    """測試訊息路由器"""
+    print("🧪 測試訊息路由器...")
+    
+    router = MessageRouter()
+    
+    # 測試案例
+    test_cases = [
+        "是否有推薦貓砂？",
+        "有什麼狗糧推薦？",
+        "查詢寵物用品庫存",
+        "iPhone 還有庫存嗎？",
+        "推薦一些好用的商品",
+        "你好！今天天氣如何？",  # 應該路由到聊天模式
+        "/help",  # 應該顯示幫助
+    ]
+    
+    for i, message in enumerate(test_cases, 1):
+        print(f"\n--- 測試案例 {i}: {message} ---")
+        try:
+            result = router.route_message(message, "test_user")
+            print(f"模式: {result.get('mode', 'unknown')}")
+            print(f"成功: {result.get('success', False)}")
+            print(f"回應: {result.get('text', 'No response')[:100]}...")
+            if result.get('products_found'):
+                print(f"找到商品數量: {result['products_found']}")
+        except Exception as e:
+            print(f"❌ 錯誤: {str(e)}")
+    
+    # 顯示統計
+    print(f"\n📊 路由統計:")
+    stats = router.get_route_statistics()
+    for mode, count in stats['stats'].items():
+        print(f"  {mode}: {count}")
+
+def test_product_query_service():
+    """測試 Pydantic AI 商品查詢服務"""
+    print("\n🛍️ 測試 Pydantic AI 商品查詢服務...")
+    
+    try:
+        service = ProductQueryService()
+        
+        if not service.is_available():
+            print("❌ Pydantic AI 服務不可用 (請檢查 GROQ_API_KEY)")
+            return
+        
+        # 測試意圖分析
+        test_messages = [
+            "是否有推薦貓砂？",
+            "有什麼狗糧推薦？",
+            "查詢iPhone庫存",
+            "今天天氣如何？",  # 非商品查詢
+        ]
+        
+        print("\n🔍 意圖分析測試:")
+        for message in test_messages:
+            intent = service.analyze_query_intent(message)
+            print(f"  '{message}' -> 商品查詢: {intent['is_product_query']}, 信心度: {intent['confidence']:.2f}")
+        
+        # 測試實際查詢
+        print("\n🛍️ 實際查詢測試:")
+        query_result = service.process_product_query_sync("是否有推薦貓砂？", "test_user")
+        
+        print(f"成功: {query_result['success']}")
+        print(f"意圖: {query_result.get('intent', 'unknown')}")
+        print(f"回應: {query_result.get('text', 'No response')}")
+        if query_result.get('products_found'):
+            print(f"找到商品: {query_result['products_found']}")
+        
+    except Exception as e:
+        print(f"❌ 測試錯誤: {str(e)}")
+
+def test_enhanced_product_service():
+    """測試增強商品服務"""
+    print("\n🔧 測試增強商品服務...")
+    
+    try:
+        service = EnhancedProductService()
+        
+        # 測試商品推薦
+        print("🎯 測試商品推薦功能:")
+        result = service.get_product_recommendations("貓砂", limit=5)
+        
+        print(f"成功: {result.success}")
+        print(f"找到商品數量: {result.count}")
+        
+        if result.success and result.data:
+            print("推薦商品:")
+            for i, product in enumerate(result.data[:3], 1):
+                print(f"  {i}. {product.get('product_name', 'N/A')} - 庫存: {product.get('current_stock', 0)}")
+        elif result.error:
+            print(f"錯誤: {result.error}")
+        
+        # 測試進階搜尋
+        print("\n🔍 測試進階搜尋功能:")
+        result = service.search_products_advanced("寵物", include_stock_info=True, limit=3)
+        
+        print(f"成功: {result.success}")
+        print(f"找到商品數量: {result.count}")
+        
+        if result.success and result.data:
+            print("搜尋結果:")
+            for i, product in enumerate(result.data, 1):
+                print(f"  {i}. {product.get('product_name', 'N/A')} - {product.get('stock_status', 'N/A')}")
+        
+    except Exception as e:
+        print(f"❌ 測試錯誤: {str(e)}")
+
+def test_database_connection():
+    """測試資料庫連接"""
+    print("\n🗄️ 測試資料庫連接...")
+    
+    try:
+        from backend.database.connection import test_database_connection
+        
+        if test_database_connection():
+            print("✅ 資料庫連接正常")
+        else:
+            print("❌ 資料庫連接失敗")
+            
+    except Exception as e:
+        print(f"❌ 資��庫測試錯誤: {str(e)}")
+
+def main():
+    """主測試函數"""
+    print("🚀 開始 Pydantic AI 整合測試\n")
+    
+    # 1. 測試資料庫連接
+    test_database_connection()
+    
+    # 2. 測試增強商品服務
+    test_enhanced_product_service()
+    
+    # 3. 測試 Pydantic AI 服務
+    test_product_query_service()
+    
+    # 4. 測試訊息路由器
+    test_message_router()
+    
+    print("\n✅ 測試完成！")
+
+if __name__ == "__main__":
+    # 檢查環境變數
+    from backend.config import settings
+    
+    print("🔧 環境檢查:")
+    print(f"  GROQ_API_KEY: {'✅ 已設定' if settings.GROQ_API_KEY else '❌ 未設定'}")
+    print(f"  DATABASE_URL: {'✅ 已設定' if settings.DATABASE_URL else '❌ 未設定'}")
+    print()
+    
+    # 執行測試
+    main()