feat: update navbar title and footer year

- Update navbar brand from "投資組合大擂台" to "智能投組大擂台"
- Update offcanvas title from "投資組合大擂台" to "智能投組大擂台"
- Update footer copyright year from 2023 to 2025

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

.dockerignore

@@ -0,0 +1,88 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Documentation
+*.md
+README.md
+LICENSE
+CHANGELOG.md
+
+# Development files
+.vscode
+.idea
+.DS_Store
+*.swp
+*.swo
+*~
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.pytest_cache
+.coverage
+htmlcov
+
+# Node.js
+node_modules
+npm-debug.log
+yarn-error.log
+package-lock.json
+package.json
+
+# Test files
+test_*.py
+*_test.py
+tests/
+.pytest_cache/
+
+# Logs
+*.log
+cleanup_duplicates.log
+sync_missing_stocks.log
+
+# Temporary files
+*.tmp
+*.bak
+*.swp
+tmp/
+temp/
+
+# IDE
+.claude/
+
+# Documentation (all the MD files you created)
+AGENTIC_RAG_DEPLOYMENT.md
+ARCHITECTURE.md
+ARCHITECTURE_CLARIFICATION.md
+CLONE_TO_GITHUB.md
+CONTEXT_PROMPT_ENGINEERING.md
+COT_COMPARISON.md
+COT_IMPLEMENTATION.md
+DEPLOYMENT_GUIDE.md
+DEPLOYMENT_STATUS.md
+DEPLOY_ON_EXISTING_SERVER.md
+DEPLOY_VIA_GITHUB.md
+FINAL_DESIGN_SUMMARY.md
+FIXES_2025-10-19.md
+QUICK_START_V2.md
+TESTING_CHECKLIST.md
+TESTING_QUICK_REFERENCE.md
+TROUBLESHOOTING.md
+V2_PROMPT_UPDATES.md
+
+# Config for other platforms
+render.yaml
+nixpacks.toml
+
+# Status files
+update_status.json

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -3,9 +3,23 @@
 __pycache__/
 .DS_Store
 .vscode/
+*.pyc
 
+# Environment and secrets
+.env
+.env.local
+
+# Dependencies
+node_modules/
 tpm/
 
+# Logs
+*.log
+
+# IDE
+.idea/
+.claude/
+
 # Distribution / packaging
 main.old.py
 postgres_runner.py

LLM_DEMO.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+LLM 投資建議功能演示
+
+展示如何使用LLM服務生成投資建議
+"""
+
+import os
+import json
+from unittest.mock import Mock
+
+# 模擬環境變數
+os.environ['OPENAI_API_KEY'] = 'sk-fake-key-for-demo'
+
+from llm_service import LLMInvestmentAdvisor
+from prompts.investment_advice import get_comprehensive_analysis_prompt
+
+
+def demo_strategy_data():
+    """模擬策略資料"""
+    return {
+        'id': 123,
+        'name': '科技成長策略',
+        'role': '最大化夏普比率',
+        'annual_ret': 0.28,  # 年化28%報酬
+        'vol': 0.22,         # 年化22%波動
+        'annual_sr': 1.95,   # 夏普比率1.95
+        'mdd': -0.15,        # 最大回落15%
+        'alpha': 0.12,       # Alpha 12%
+        'beta': 1.05,        # Beta 1.05
+        'var10': 0.08,       # 10% VaR 8%
+        'r2': 0.89,          # R-squared 89%
+        'gamma': 2.8,        # Gamma 2.8
+        'assets': ['AAPL', 'MSFT', 'GOOGL', 'NVDA', 'TSLA'],
+        'tw': False,         # 美國市場
+        'weight': {
+            'data': [[0.25, 0.20, 0.18, 0.22, 0.15]],
+            'columns': ['AAPL', 'MSFT', 'GOOGL', 'NVDA', 'TSLA'],
+            'index': ['2024-01-01']
+        }
+    }
+
+
+def demo_llm_service():
+    """演示LLM服務"""
+    print("🤖 LLM 投資建議功能演示")
+    print("=" * 50)
+
+    # 模擬策略資料
+    strategy_data = demo_strategy_data()
+
+    print("\n📊 策略概況：")
+    print(f"   策略名稱：{strategy_data['name']}")
+    print(f"   投資目標：{strategy_data['role']}")
+    print(f"   年化報酬：{strategy_data['annual_ret']:.1%}")
+    print(f"   年化波動：{strategy_data['vol']:.1%}")
+    print(f"   夏普比率：{strategy_data['annual_sr']:.2f}")
+    print(f"   最大回落：{strategy_data['mdd']:.1%}")
+    print(f"   持有資產：{', '.join(strategy_data['assets'])}")
+
+    print("\n🔧 測試 Prompt 生成...")
+    try:
+        # 直接調用函數，不使用快取
+        prompt = get_comprehensive_analysis_prompt(strategy_data)
+        print(f"   ✅ Prompt 生成成功，長度：{len(prompt)} 字符")
+        print("   📝 Prompt 預覽：")
+        print(f"   {prompt[:200]}...")
+    except Exception as e:
+        print(f"   ❌ Prompt 生成失敗：{e}")
+        print(f"   錯誤詳情：{str(e)}")
+        return
+
+    print("\n🤖 測試 LLM 服務...")
+    try:
+        # 由於是演示，我們使用模擬的OpenAI客戶端
+        advisor = LLMInvestmentAdvisor(api_key="fake-key")
+
+        # 模擬生成建議
+        demo_advice = advisor._get_fallback_advice(strategy_data)
+        print("   ✅ 建議生成成功：")
+        print("   " + "=" * 30)
+        print(f"   {demo_advice}")
+        print("   " + "=" * 30)
+
+    except Exception as e:
+        print(f"   ❌ LLM 服務測試失敗：{e}")
+
+    print("\n📝 真實使用場景：")
+    print("   1. 用戶訪問策略詳情頁面")
+    print("   2. 點擊「🤖 LLM 投資建議」區塊")
+    print("   3. 前端調用 /api/llm_advice/123")
+    print("   4. 後端查詢策略資料並生成建議")
+    print("   5. 顯示專業的投資分析報告")
+
+    print("\n⚙️  設置說明：")
+    print("   1. 設置 OPENAI_API_KEY 環境變數")
+    print("   2. 選擇合適的模型 (GPT-4 或 GPT-3.5)")
+    print("   3. 調整 prompt 模板以符合需求")
+    print("   4. 監控 API 使用量和成本")
+
+    print("\n🚀 功能特色：")
+    print("   ✅ 智能投資分析")
+    print("   ✅ 風險評估報告")
+    print("   ✅ 市場適配建議")
+    print("   ✅ 快取機制")
+    print("   ✅ 錯誤處理")
+    print("   ✅ 專業UI介面")
+
+
+def demo_prompt_templates():
+    """演示不同的Prompt模板"""
+    print("\n🔧 Prompt 模板演示")
+    print("=" * 30)
+
+    strategy_data = demo_strategy_data()
+
+    templates = [
+        ("基本分析", "basic"),
+        ("全面分析", "comprehensive"),
+        ("風險導向", "risk"),
+    ]
+
+    for name, template_type in templates:
+        print(f"\n{name}模板：")
+        try:
+            if template_type == "risk":
+                from prompts.investment_advice import get_risk_focused_prompt
+                prompt = get_risk_focused_prompt(strategy_data)
+            elif template_type == "comprehensive":
+                prompt = get_comprehensive_analysis_prompt(strategy_data)
+            else:
+                prompt = get_comprehensive_analysis_prompt(strategy_data)  # fallback
+
+            print(f"   長度：{len(prompt)} 字符")
+            print(f"   預覽：{prompt[:100]}...")
+        except Exception as e:
+            print(f"   ❌ 錯誤：{e}")
+            print(f"   錯誤詳情：{str(e)}")
+
+
+if __name__ == "__main__":
+    demo_llm_service()
+    demo_prompt_templates()
+
+    print("\n" + "=" * 50)
+    print("🎉 LLM 投資建議功能演示完成！")
+    print("📖 詳細設置說明請參閱 LLM_SETUP.md")
+    print("🧪 運行測試：python test_llm_service.py")

LLM_SETUP.md

@@ -0,0 +1,116 @@
+# LLM 投資建議功能設置指南
+
+## 功能介紹
+
+LLM 投資建議功能使用 OpenAI GPT 模型為投資組合提供專業的投資分析和建議，包括：
+- 策略績效評估
+- 風險分析
+- 市場適配性評估
+- 具體的改進建議
+
+## 設置步驟
+
+### 1. 獲取 OpenAI API 金鑰
+
+1. 前往 [OpenAI API](https://platform.openai.com/api-keys) 頁面
+2. 點擊 "Create new secret key"
+3. 複製生成的 API 金鑰
+
+### 2. 配置 API 金鑰
+
+您可以通過以下兩種方式之一設置 API 金鑰：
+
+#### 方法一：環境變數（推薦）
+```bash
+export OPENAI_API_KEY="your-api-key-here"
+```
+
+#### 方法二：修改配置檔案
+編輯 `config_openai.py` 檔案：
+```python
+OPENAI_CONFIG = {
+    'api_key': 'your-actual-api-key-here',
+    # ... 其他配置
+}
+```
+
+### 3. 安裝依賴
+
+```bash
+pip install -r requirements.txt
+```
+
+### 4. 啟動服務
+
+```bash
+docker compose up -d flask
+```
+
+### 5. 測試功能
+
+1. 訪問任意策略詳情頁面
+2. 查看「🤖 LLM 投資建議」區塊
+3. 系統會自動生成 AI 投資建議
+
+## 配置選項
+
+### OpenAI 模型選擇
+
+在 `config_openai.py` 中可以調整：
+
+```python
+OPENAI_CONFIG = {
+    'model': 'gpt-4',  # 選擇 gpt-3.5-turbo 可降低成本
+    'max_tokens': 2000,  # 最大回應長度
+    'temperature': 0.7,  # 創意程度 (0-1)
+}
+```
+
+### 快取設定
+
+```python
+CACHE_CONFIG = {
+    'enabled': True,  # 啟用快取
+    'ttl': 3600,      # 快取時間（秒）
+    'max_size': 100,  # 最大快取項目數
+}
+```
+
+## 費用估算
+
+- **GPT-4**: 約 $0.03/1K tokens
+- **GPT-3.5-turbo**: 約 $0.002/1K tokens
+
+每個投資建議約使用 1000-2000 tokens，建議選擇合適的模型以控制成本。
+
+## 故障排除
+
+### 常見問題
+
+1. **API 金鑰錯誤**
+   - 檢查 API 金鑰是否正確設置
+   - 確認金鑰沒有額外的空格
+
+2. **連接到服務失敗**
+   - 檢查 Flask 服務是否正常運行
+   - 確認防火牆設定允許內部通訊
+
+3. **生成建議失敗**
+   - 查看後端日誌確認錯誤原因
+   - 檢查 OpenAI API 額度是否充足
+
+### 檢查日誌
+
+```bash
+docker compose logs flask
+```
+
+## 進階配置
+
+如需自訂 Prompt 模板，請編輯 `prompts/investment_advice.py` 檔案中的模板函數。
+
+## 安全性注意事項
+
+- 請勿將 API 金鑰提交到版本控制系統
+- 考慮使用環境變數而非硬編碼
+- 定期輪換 API 金鑰

Procfile

@@ -1 +1 @@
-web: gunicorn main:app --preload --workers 28 --timeout 120
+web: gunicorn -w 2 -b 0.0.0.0:$PORT --timeout 120 --chdir /flask main:app

README.md

@@ -0,0 +1,74 @@
+### TPM – 投資組合大擂台
+
+#### 1) 內容概要
+- Flask + PostgreSQL + Redis 的投資策略平台，內含回測、圖表與 LLM 投資建議。
+- 前端採 Jinja SSR + Bootstrap；LLM 透過 `llm_service.py` 封裝，可切換 OpenAI/OpenRouter/Mock。
+
+#### 2) 技術棧（現況，請勿任意更換）
+- Backend: Flask 2.2, psycopg2, Flask-Caching, Plotly
+- DB/Cache: PostgreSQL, Redis
+- Frontend: Jinja, Bootstrap 5, Bootstrap Icons（避免新增其他 CSS 框架）
+- LLM: OpenAI SDK（可接 OpenRouter），支援 Mock
+- Container: Docker, docker-compose
+
+#### 3) 目錄重點
+- `main.py`: 路由與頁面組裝；禁止塞商業邏輯
+- `llm_service.py`: LLM 供應商、Prompt、重試、快取
+- `portfolio_builder.py`: 投組演算法
+- `templates/`: Jinja 模板（僅結構與少量初始化）
+- `static/js/{components,pages}/`: 前端 JS 組件與頁面邏輯
+- `sql_script/`: DB 初始化
+- `data_init/`: 資料初始化與更新腳本
+
+#### 4) 快速開始
+1) 準備 `.env`（置於專案根目錄）
+```
+LLM_PROVIDER=openrouter
+OPENROUTER_API_KEY=your_key
+OPENROUTER_MODEL=google/gemini-2.0-flash-exp:free
+LLM_TIMEOUT=60
+LLM_MAX_TOKENS=1500
+LLM_TEMPERATURE=0.6
+MOCK_LLM=false
+```
+2) 啟動容器
+```
+docker compose up -d --build --force-recreate
+```
+3) 服務連線
+- Web: http://localhost:8007
+- Postgres: container 內部名稱 `db`
+- Redis: container 內部名稱 `redis`
+
+#### 5) 開發規範（避免技術債）
+- 不動既有架構、Docker 設定與不相關功能。
+- 僅在確定「已使用」時才把套件寫入 `requirements.txt`；未用到的要移除。
+- 完成一個環節、測試通過才 commit；不要在同一個 commit 混雜多項變更。
+- 前端：避免大型 inline JS；新邏輯放 `static/js/pages/*.js` 或 `static/js/components/*.js`。
+- 後端：商業邏輯放在服務檔案（如 `llm_service.py`），`main.py` 保持輕薄。
+- LLM：僅經 `get_llm_advisor().generate_advice(strategy_id, strategy_dict)`；參數由 `.env` 控制。
+
+#### 6) 測試
+- 後端：可使用離線腳本（`MOCK_LLM=true`）進行測試。
+- 任何變更建議附最小可重現測試或腳本（避免手動點擊測試）。
+
+#### 7) 常見問題
+- 500 + LLM 失敗：確認 `.env` 已注入容器；離線測試可先設 `MOCK_LLM=true`
+- DB 連線錯誤：程式內部連線 host 應為 `db`
+- KeyError（TSLA/AAPL）：確認 `data_init` 成功寫入對應市場資料
+
+#### 8) Git / PR 規範
+- 分支命名：`feature/<area>-<short>`、`fix/<area>-<short>`
+- PR 標題：`[TPM] <Title>`；內容包含「動機 / 變更 / 風險 / 測試方式」
+- 小步提交、保持向後相容；前端改動請將 JS 抽出至 `static/js/`
+
+#### 9) 設計原則
+- 關注點分離：路由薄、服務厚；模板薄、JS 組件化
+- 僅在既有層擴展功能；避免跨層耦合
+- 可回退：大改以 feature flag 包裝，保持 simple 模式可用
+
+> 更詳細的協作規範請見 `cursor.md`。
+
+
+
+

config.py

@@ -1,26 +1,51 @@
 import os
 import time
 from datetime import datetime, date, timedelta
+from urllib.parse import urlparse
+
 # PARAMETERS
 CONFIGS = {
-    "SECRET_KEY": os.urandom(30), # Set the secret key for session authentication
+    "SECRET_KEY": os.environ.get("SECRET_KEY", os.urandom(30).hex()), # Set the secret key for session authentication
-    "PERMANENT_SESSION_LIFETIME": timedelta(minutes=60)   
+    "PERMANENT_SESSION_LIFETIME": timedelta(minutes=60)
 }
-SQL_CONFIG = dict(
+
+# PostgreSQL config - support both Railway and local Docker
+DATABASE_URL = os.environ.get('DATABASE_URL')
+if DATABASE_URL:
+    # Railway provides DATABASE_URL
+    url = urlparse(DATABASE_URL)
+    SQL_CONFIG = dict(
+        database=url.path[1:],
+        user=url.username,
+        host=url.hostname,
+        port=url.port or 5432,
+        password=url.password
+    )
+else:
+    # Local Docker fallback
+    SQL_CONFIG = dict(
         database="portfolio_platform",
         user="postgres",
         host="db",
         port="5432",
         password="thiispassword1qaz!QAZ"
-)
+    )
-CACHE_CONFIG = {
+
+# Redis config - support both Railway and local Docker
+REDIS_URL = os.environ.get('REDIS_URL')
+if REDIS_URL:
+    # Railway provides REDIS_URL
+    CACHE_CONFIG = {
+        'CACHE_TYPE': 'redis',
+        'CACHE_REDIS_URL': REDIS_URL,
+    }
+else:
+    # Local Docker fallback
+    CACHE_CONFIG = {
         'CACHE_TYPE': 'redis',
-        # 'CACHE_REDIS_USER': 'default',
         'CACHE_REDIS_HOST': 'redis',
         'CACHE_REDIS_PORT': 6379,
-        # 'CACHE_REDIS_PASSWORD': '5rP99RevPMW94rswBXAL',
+    }
-        # 'CACHE_KEY_PREFIX': 'railway_redis_'
-}
 role_map = dict(max_sharpe='最大化夏普比率',
                 max_sortino='最大化索提諾比率', 
                 min_volatility='最小化波動率', 

config_openai.py

@@ -0,0 +1,30 @@
+"""
+OpenAI API 配置
+
+請設置您的OpenAI API金鑰
+"""
+
+import os
+
+# OpenAI API 配置
+OPENAI_CONFIG = {
+    'api_key': os.getenv('OPENAI_API_KEY', 'your-api-key-here'),
+    'model': 'gpt-4',  # 可選擇 gpt-3.5-turbo 以降低成本
+    'max_tokens': 2000,
+    'temperature': 0.7,
+    'timeout': 30,  # 請求超時時間（秒）
+}
+
+# API 調用限制
+RATE_LIMITS = {
+    'requests_per_minute': 60,  # 每分鐘最大請求數
+    'max_retries': 3,          # 最大重試次數
+    'retry_delay': 2,          # 重試間隔（秒）
+}
+
+# 快取設定
+CACHE_CONFIG = {
+    'enabled': True,
+    'ttl': 3600,  # 快取時間（秒）
+    'max_size': 100,  # 最大快取項目數
+}

cursor.md

@@ -0,0 +1,60 @@
+### Purpose
+- 定義 AI 與人類協作的開發規範，避免分散、重複與難以維護的代碼。
+- 嚴格限制可修改範圍與方式，降低技術債。
+
+### Architecture Guardrails
+- Backend: 維持 Flask（單應用）+ PostgreSQL + Redis + Plotly SSR。不得引入新後端框架（如 FastAPI、Django）。
+- Frontend: 維持 Jinja SSR + Bootstrap 5。避免新增其他 CSS 框架；僅在必要時使用 jQuery（若頁面已依賴）。
+- LLM: 只能透過 `llm_service.py` 的封裝介面呼叫；前端僅呼叫既有 API。
+- DB: 目前採 `psycopg2` 直連 SQL。若要導入 ORM，需先提 RFC 並分層重構（Repository/Service 分離）。
+- Realtime: 若需 Agentic 進度，優先 SSE；如需 WebSocket，需提 RFC。禁止同時混用兩者。
+
+### Files Ownership
+- `main.py`: 僅負責路由、參數與 Response 序列化；禁止寫演算法或外部 API 邏輯。
+- `llm_service.py`: 唯一 LLM 入口；新增供應商、Prompt、重試、快取皆在此擴展。
+- `portfolio_builder.py`: 僅放投組相關演算法。
+- `templates/*.html`: 僅做結構與插值；避免大型 inline JS；頁面邏輯放 `static/js/pages/*.js`。
+- `static/js/components/*`: 前端可複用組件；不得引用非必要的全域物件。
+- `docker-compose.yml`: 僅調整現有服務設定；新增服務需提 RFC。
+- `requirements.txt`: 僅加入「已使用」的最小依賴；未使用須移除。
+
+### Frontend Rules
+- 禁止在模板中新增大型 inline JS。新邏輯放 `static/js/pages/<page>.js` 或 `static/js/components/<comp>.js`，模板只保留初始化。
+- 樣式統一 Bootstrap 5；避免再引入其他 CSS 框架；圖標統一 Bootstrap Icons。
+- Markdown：優先在後端使用 `markdown` 轉 HTML；不要寫自製 Markdown 解析器。
+
+### LLM Rules
+- 僅用 `get_llm_advisor().generate_advice(strategy_id, strategy_dict)` 封裝介面。
+- Provider/Model/Token/Timeout 由 `.env` 或 `config.py` 管理；程式內不得硬編碼。
+- 慢任務需提供 `mode=simple|agentic|auto`，預設 simple。
+- Mock 測試：支援 `MOCK_LLM=true` 的離線路徑。
+
+### Testing & Quality
+- 後端：新增/修改路由與服務需附基本單元測試或離線測試腳本（可用 `MOCK_LLM`）。
+- 前端：邏輯拆為可測的純函數；避免深層 DOM 操作耦合。
+- 風格：PEP8；命名語義化；函式不超過 ~100 行；避免深巢狀。
+- 禁留 TODO/死碼；必要時加簡短註解說明「為何存在」。
+
+### Git / PR Workflow
+- 分支：`feature/<area>-<short>`、`fix/<area>-<short>`。
+- PR 標題：`[TPM] <Title>`；內容包含「動機 / 變更 / 雙向風險 / 測試」。
+- 提交頻率：完成一個環節且測試通過才 commit；不要在同一 commit 混雜多項變更。
+- 禁止無關變更（例如排版清理與邏輯修改混在一起）。
+
+### Change Checklist (DoD)
+- 有對應文件或內嵌註解簡述「為何」。
+- 測試或腳本可重跑；離線可跑（如 LLM mock）。
+- API 相容，不破壞現有 flow。
+- 不新增全域副作用或跨層耦合。
+
+### Out-of-Scope（需先提 RFC）
+- 更換 Web 框架或引入大型基礎設施（如微服務、消息隊列）。
+- 引入新前端框架或 CSS 系統。
+- 重構資料層成 ORM。
+
+---
+本文件供 AI/協作工具與開發者遵循，若有必要變更，請先起草 RFC 並在 PR 中說明動機與回滾方案。
+
+
+
+

data_init/config.py

@@ -9,7 +9,7 @@ CONFIGS = {
 SQL_CONFIG = dict(
         database="portfolio_platform",
         user="postgres",
-        host="db",
+        host="localhost",
         port="5432",
         password="thiispassword1qaz!QAZ"
 )

data_init/data_clear&update_tw_v0.py

@@ -8,7 +8,7 @@ from tqdm import tqdm
 with open('assets_tw.json') as f:
     data_tw = json.load(f)
 #SQL　setting
-SQL_CONFIG = dict(database="portfolio_platform", user='postgres', password='thiispassword1qaz!QAZ', host='db',port ='5432')
+SQL_CONFIG = dict(database="portfolio_platform", user='postgres', password='thiispassword1qaz!QAZ', host='db', port='5432')
 
 # TW Stocks
 conn = psycopg2.connect(**SQL_CONFIG)
@@ -16,8 +16,13 @@ cursor = conn.cursor()
 cursor.execute("TRUNCATE TABLE stock_price_tw")
 print("TW stock price cleared")
 for ticker in tqdm(data_tw):
-    df = yf.download(ticker, start="2007-1-1", progress=False)
+    df = yf.download(ticker, start="2007-01-01", progress=False, threads=False)
-    value =[(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
+    if df is None or df.empty:
+        continue
+    price_col = 'Close' if 'Close' in df.columns else ('Adj Close' if 'Adj Close' in df.columns else None)
+    if price_col is None:
+        continue
+    value = [(ticker, row.name.strftime('%Y-%m-%d'), float(row[price_col])) for _, row in df.iterrows()]
     with conn:
         with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as curs:
             sql = "insert into stock_price_tw (ticker, date, price) values %s"

data_init/data_clear&update_us_v0.py

@@ -3,21 +3,27 @@ import json
 import yfinance as yf
 import numpy as np
 import psycopg2
+
 from psycopg2.extras import execute_values
 from tqdm import tqdm
 with open('assets_us.json') as f:
-    data_tw = json.load(f)
+    data_us = json.load(f)
 
 #SQL　setting
-SQL_CONFIG = dict(database="portfolio_platform", user='postgres', password='thiispassword1qaz!QAZ', host='db',port ='5432')
+SQL_CONFIG = dict(database="portfolio_platform", user='postgres', password='thiispassword1qaz!QAZ', host='db', port='5432')
 # TW Stocks
 conn = psycopg2.connect(**SQL_CONFIG)
 cursor = conn.cursor()
 cursor.execute("TRUNCATE TABLE stock_price")
 print("US stock price cleared")
-for ticker in tqdm(data_tw):
+for ticker in tqdm(data_us):
-    df = yf.download(ticker, start="2007-1-1", progress=False)
+    df = yf.download(ticker, start="2007-01-01", progress=False, threads=False)
-    value =[(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
+    if df is None or df.empty:
+        continue
+    price_col = 'Close' if 'Close' in df.columns else ('Adj Close' if 'Adj Close' in df.columns else None)
+    if price_col is None:
+        continue
+    value = [(ticker, row.name.strftime('%Y-%m-%d'), float(row[price_col])) for _, row in df.iterrows()]
     with conn:
         with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as curs:
             sql = "insert into stock_price (ticker, date, price) values %s"

data_init/data_init_tw_v0.py

@@ -5,26 +5,43 @@ import numpy as np
 import psycopg2
 from psycopg2.extras import execute_values
 from tqdm import tqdm
-with open('/flask/data_init/assets_tw.json') as f:
+from config import SQL_CONFIG
-    data_tw = json.load(f)
+import os
-
-#SQL　setting
-SQL_CONFIG = dict(database="portfolio_platform", user='postgres', password='thiispassword1qaz!QAZ', host='db',port ='5432')
 
+with open('data_init/assets_tw.json') as f:
+    data_tw = json.load(f)
 
 # TW Stocks
 conn = psycopg2.connect(**SQL_CONFIG)
 cursor = conn.cursor()
+
+# Create schema if not exists
+try:
+    cursor.execute("SELECT 1 FROM stock_price_tw LIMIT 1;")
+except psycopg2.errors.UndefinedTable:
+    print("📋 Tables not found, creating schema...")
+    conn.rollback()
+    sql_path = '/flask/sql_script/create_all.sql' if os.path.exists('/flask/sql_script/create_all.sql') else 'sql_script/create_all.sql'
+    with open(sql_path, 'r') as f:
+        cursor.execute(f.read())
+    conn.commit()
+    print("✅ Schema created successfully")
+
 cursor.execute("SELECT COUNT(*) FROM stock_price_tw;")
 row_count = cursor.fetchone()[0]
 if row_count <= 0 :
     for ticker in tqdm(data_tw):
-        df = yf.download(ticker, start="2007-1-1", progress=False)
+        df = yf.download(ticker, start="2007-01-01", progress=False, threads=False)
-        value =[(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
+        if df is None or df.empty:
+            continue
+        price_col = 'Close' if 'Close' in df.columns else ('Adj Close' if 'Adj Close' in df.columns else None)
+        if price_col is None:
+            continue
+        value = [(ticker, row.name.strftime('%Y-%m-%d'), float(row[price_col])) for _, row in df.iterrows()]
         with conn:
             with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as curs:
                 sql = "insert into stock_price_tw (ticker, date, price) values %s"
                 execute_values(curs, sql, value)
     print("Finish initialize")
 else:
-    print("DB already have data")
+    print("DB already have data")

data_init/data_init_us_v0.py

@@ -5,21 +5,27 @@ import numpy as np
 import psycopg2
 from psycopg2.extras import execute_values
 from tqdm import tqdm
-with open('/flask/data_init/assets_us.json') as f:
+from config import SQL_CONFIG
-    data_tw = json.load(f)
 
-#SQL　setting
+with open('data_init/assets_us.json') as f:
-SQL_CONFIG = dict(database="portfolio_platform", user='postgres', password='thiispassword1qaz!QAZ', host='db',port ='5432')
+    data_us = json.load(f)
 
-# TW Stocks
+# US Stocks
 conn = psycopg2.connect(**SQL_CONFIG)
 cursor = conn.cursor()
+
+# Schema already created by data_init_tw_v0.py, just check connection
 cursor.execute("SELECT COUNT(*) FROM stock_price;")
 row_count = cursor.fetchone()[0]
 if row_count <= 0 :
-    for ticker in tqdm(data_tw):
+    for ticker in tqdm(data_us):
-        df = yf.download(ticker, start="2007-1-1", progress=False)
+        df = yf.download(ticker, start="2007-01-01", progress=False, threads=False)
-        value =[(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
+        if df is None or df.empty:
+            continue
+        price_col = 'Close' if 'Close' in df.columns else ('Adj Close' if 'Adj Close' in df.columns else None)
+        if price_col is None:
+            continue
+        value = [(ticker, row.name.strftime('%Y-%m-%d'), float(row[price_col])) for _, row in df.iterrows()]
         with conn:
             with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as curs:
                 sql = "insert into stock_price (ticker, date, price) values %s"

data_init/requirements_data.txt

@@ -1,8 +1,8 @@
 pandas==1.5.3
 psycopg2==2.9.5
-requests==2.28.2
+requests==2.31
 SQLAlchemy==2.0.4
-yfinance==0.2.22
+yfinance==0.2.66
 tqdm==4.62.3
 schedule==1.2.1
 numpy==1.23.5

data_init/update_data_daily.py

@@ -11,11 +11,34 @@ import time
 from config import SQL_CONFIG
 #SQL　setting
 
+# Quick status: print the latest available dates in DB
+def print_last_update():
+    try:
+        conn = psycopg2.connect(**SQL_CONFIG)
+        cursor = conn.cursor()
+        cursor.execute("SELECT MAX(date) FROM stock_price")
+        us_last = cursor.fetchone()[0]
+        cursor.execute("SELECT MAX(date) FROM stock_price_tw")
+        tw_last = cursor.fetchone()[0]
+        print(f"Latest US date in DB: {us_last}" if us_last else "Latest US date in DB: None")
+        print(f"Latest TW date in DB: {tw_last}" if tw_last else "Latest TW date in DB: None")
+        cursor.close()
+        conn.close()
+    except Exception as e:
+        print(f"Check last update failed: {e}")
+
 def update_data():
     # Connect to the database
     conn = psycopg2.connect(**SQL_CONFIG)
     cursor = conn.cursor()
     print("Stock prices US updating")
+    # Show current latest date in table for quick verification
+    try:
+        cursor.execute("SELECT MAX(date) FROM stock_price")
+        last_overall = cursor.fetchone()[0]
+        print(f"US table current latest date: {last_overall}")
+    except Exception:
+        pass
     # Get the list of tickers
     cursor.execute("SELECT DISTINCT ticker FROM stock_price")
     tickers = [row[0] for row in cursor.fetchall()]
@@ -27,8 +50,13 @@ def update_data():
         # If the latest date is not today, update the data
         if latest_date < datetime.date.today():
             df = yf.download(ticker, start=latest_date.strftime('%Y-%m-%d'),
-                             end=datetime.date.today().strftime('%Y-%m-%d'), progress=False)
+                             end=datetime.date.today().strftime('%Y-%m-%d'), progress=False, threads=False)
-            value = [(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
+            if df is None or df.empty:
+                continue
+            price_col = 'Close' if 'Close' in df.columns else ('Adj Close' if 'Adj Close' in df.columns else None)
+            if price_col is None:
+                continue
+            value = [(ticker, df.index[i], float(df[price_col].iloc[i])) for i in range(len(df))]
             with conn:
                 with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as curs:
                     sql = "insert into stock_price (ticker, date, price) values %s"
@@ -39,6 +67,13 @@ def update_data_tw():
     conn = psycopg2.connect(**SQL_CONFIG)
     cursor = conn.cursor()
     print("Stock prices US updating")
+    # Show current latest date in table for quick verification
+    try:
+        cursor.execute("SELECT MAX(date) FROM stock_price_tw")
+        last_overall = cursor.fetchone()[0]
+        print(f"TW table current latest date: {last_overall}")
+    except Exception:
+        pass
     # Get the list of tickers
     cursor.execute("SELECT DISTINCT ticker FROM stock_price_tw")
     tickers = [row[0] for row in cursor.fetchall()]
@@ -50,17 +85,25 @@ def update_data_tw():
         # If the latest date is not today, update the data
         if latest_date < datetime.date.today():
             df = yf.download(ticker, start=latest_date.strftime('%Y-%m-%d'),
-                             end=datetime.date.today().strftime('%Y-%m-%d'), progress=False)
+                             end=datetime.date.today().strftime('%Y-%m-%d'), progress=False, threads=False)
-            value = [(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
+            if df is None or df.empty:
+                continue
+            price_col = 'Close' if 'Close' in df.columns else ('Adj Close' if 'Adj Close' in df.columns else None)
+            if price_col is None:
+                continue
+            value = [(ticker, row.name.strftime('%Y-%m-%d'), row['Close']) for _, row in df.iterrows()]
             with conn:
                 with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as curs:
                     sql = "insert into stock_price_tw (ticker, date, price) values %s"
                     execute_values(curs, sql, value)
     print("Stock prices TW updated")
+# Print once on startup
+print_last_update()
+
 # Schedule the task
 schedule.every().day.at("17:00").do(update_data)
 schedule.every().day.at("18:00").do(update_data_tw)
 # Keep the script running
 while True:
     schedule.run_pending()
-    time.sleep(1)
+    time.sleep(1)

docker-compose.yml

@@ -12,13 +12,16 @@ services:
             - db_data_new:/var/lib/postgresql/data
         networks:
             - common_network
+        ports:
+            - 5432:5432
+
     redis:
         image: redis:7.0.11-alpine
         container_name: myredis
         #        ports:
         #         - 6379:6379
         volumes:
-            - /data/redis-data:/data
+            - redis-data:/data
         networks:
             - common_network
     flask_init:
@@ -33,6 +36,18 @@ services:
         container_name: flask
         command: bash -c "cd ../flask_run ; python main.py runserver 0.0.0.0:8000"
         image: tpm-flask
+        environment:
+            - LLM_PROVIDER=openrouter
+            - OPENROUTER_API_KEY=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
+            - OPENROUTER_MODEL=google/gemini-2.0-flash-exp:free
+            - OPENROUTER_REFERER=http://localhost:8007
+            - OPENROUTER_TITLE=TPM
+            - LLM_TIMEOUT=60
+            - LLM_MAX_TOKENS=1500
+            - LLM_TEMPERATURE=0.6
+            - LLM_MAX_RETRIES=3
+            - LLM_RETRY_DELAY=2
+            - MOCK_LLM=false
         volumes:
             - flask-data:/flask_run
         depends_on:
@@ -63,7 +78,7 @@ volumes:
     db-data:
     flask-data: #    pgadmin-data:
     db_data_new:
+    redis-data:
 networks:
     common_network:
-        external:
+        driver: bridge
-            name: common_network

init_railway_db.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+One-time script to initialize Railway database from local machine.
+Run this ONCE after deploying to Railway.
+
+Usage:
+    export DATABASE_URL="postgresql://user:password@host:port/database"
+    python3 init_railway_db.py
+"""
+import os
+import sys
+
+# Check DATABASE_URL
+DATABASE_URL = os.environ.get('DATABASE_URL')
+if not DATABASE_URL:
+    print("❌ ERROR: DATABASE_URL environment variable not set")
+    print("\nGet your DATABASE_URL from Railway:")
+    print("1. Go to Railway dashboard")
+    print("2. Click on PostgreSQL service")
+    print("3. Go to 'Connect' tab")
+    print("4. Copy the 'Postgres Connection URL'")
+    print("\nThen run:")
+    print('  export DATABASE_URL="postgresql://..."')
+    print("  python3 init_railway_db.py")
+    sys.exit(1)
+
+print(f"✅ DATABASE_URL is set")
+print(f"📊 Connecting to: {DATABASE_URL.split('@')[1] if '@' in DATABASE_URL else '***'}")
+
+# Import after checking DATABASE_URL
+os.chdir('/Users/chiuyiting/Documents/GitHub/TPM')
+sys.path.insert(0, '/Users/chiuyiting/Documents/GitHub/TPM/data_init')
+
+# Now run the initialization scripts
+print("\n" + "="*60)
+print("🚀 Starting Railway Database Initialization")
+print("="*60 + "\n")
+
+print("📋 Step 1: Initializing Taiwan stock data (this will create schema)...")
+import data_init.data_init_tw_v0
+print("\n✅ Taiwan data initialized\n")
+
+print("📋 Step 2: Initializing US stock data...")
+import data_init.data_init_us_v0
+print("\n✅ US data initialized\n")
+
+print("\n" + "="*60)
+print("🎉 Railway Database Initialization Complete!")
+print("="*60)
+print("\nYour Railway app should now work properly.")
+print("Check https://nthutpm.up.railway.app")

llm_service.py

@@ -0,0 +1,418 @@
+"""
+LLM Investment Advisor Service
+
+提供投資策略的AI分析服務，包含：
+- 投資建議生成
+- 風險評估
+- 市場洞察
+- Prompt工程管理
+"""
+
+import os
+import json
+import time
+import logging
+import hashlib
+from typing import Dict, Any, Optional, Tuple
+
+from openai import OpenAI
+try:
+    from config_openai import OPENAI_CONFIG, RATE_LIMITS
+except Exception:
+    OPENAI_CONFIG = {
+        'api_key': os.environ.get('OPENAI_API_KEY') or os.environ.get('OPENROUTER_API_KEY', ''),
+        'model': os.environ.get('OPENAI_MODEL', os.environ.get('OPENROUTER_MODEL', 'gpt-4')),
+        'timeout': int(os.environ.get('LLM_TIMEOUT', '60')),
+        'max_tokens': int(os.environ.get('LLM_MAX_TOKENS', '3000')),
+        'temperature': float(os.environ.get('LLM_TEMPERATURE', '0.7'))
+    }
+    RATE_LIMITS = {
+        'max_retries': int(os.environ.get('LLM_MAX_RETRIES', '3')),
+        'retry_delay': int(os.environ.get('LLM_RETRY_DELAY', '2'))
+    }
+
+# 設定日誌
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class PromptManager:
+    """管理不同的Prompt模板"""
+
+    def __init__(self):
+        self.system_prompt = self._get_system_prompt()
+
+    def _get_system_prompt(self) -> str:
+        """系統提示詞 - 定義基金經理人專家角色"""
+        return """你是一位頂尖的基金經理人與投資策略師，擁有超過20年橫跨牛熊市的實戰經驗。你的專長是將複雜的金融數據轉化為清晰、易於理解的語言，為大眾投資者提供專業見解。
+
+你的溝通風格：
+- **權威且親切**：你的語氣充滿自信與專業，但同時讓非專業人士感到安心與信賴。
+- **教育家精神**：你會用生動的比喻來解釋關鍵指標，例如將「夏普比率」比喻為投資的「性價比」，或將「最大回落」形容為「最顛簸的一段路」。
+- **客觀中立**：你總是基於數據進行分析，同時點出潛在的盲點與風險。
+
+你的任務是根據接下來提供的策略回測數據，撰寫一份專業的投資策略分析報告。"""
+
+    def build_strategy_context(self, strategy_data: Dict[str, Any]) -> str:
+        """將策略資料轉換為結構化context，並附帶指標提示"""
+        return f"""
+策略基本資訊：
+- 策略編號：{strategy_data.get('id', 'N/A')}
+- 策略名稱：{strategy_data.get('name', 'N/A')}
+- 投資目標：{strategy_data.get('role', 'N/A')}
+- 建立時間：{strategy_data.get('date', 'N/A')}
+- 建立者：{strategy_data.get('username', 'N/A')}
+
+核心績效指標：
+- 年化報酬率：{strategy_data.get('annual_ret', 0):.2%} (衡量平均每年賺取多少利潤)
+- 年化波動率：{strategy_data.get('vol', 0):.2%} (衡量資產價值的波動風險，越高代表起伏越大)
+- 年化夏普比率：{strategy_data.get('annual_sr', 0):.2f} (衡量每一單位風險能換來多少報酬，可視為「投資CP值」)
+- 最大回落（MDD）：{strategy_data.get('mdd', 0):.2%} (衡量策略從最高點到最低點可能出現的最大虧損幅度)
+
+進階參考指標：
+- Alpha值：{strategy_data.get('alpha', 0):.4f} (相對於市場基準的超額報酬能力)
+- Beta值：{strategy_data.get('beta', 0):.4f} (與市場波動的關聯性，大於1代表比市場更敏感)
+- VaR (10天, 95%信心)：{strategy_data.get('var10', 0):.2%} (預估在未來10天內，有95%的機率虧損不會超過此比例)
+- R-squared：{strategy_data.get('r2', 0):.4f} (策略表現有多大比例可由市場表現來解釋)
+
+投資組合配置：
+- 包含資產：{', '.join(strategy_data.get('assets', []))}
+- 市場類型：{'台灣市場' if strategy_data.get('tw', True) else '美國市場'}
+"""
+
+    def get_investment_advice_prompt(self, strategy_data: Dict[str, Any],
+                                      use_cot: bool = False,
+                                      use_v2: bool = True,
+                                      risk_tolerance: str = "moderate") -> str:
+        """生成結構化投資建議報告的完整Prompt - 使用外部模板
+
+        Args:
+            strategy_data: 策略數據
+            use_cot: 是否使用 Chain-of-Thought 模式（預設 False）
+            use_v2: 是否使用 V2 Context-Aware Prompt（預設 True，推薦）
+            risk_tolerance: 風險承受度 (conservative/moderate/aggressive)
+
+        Returns:
+            完整的 prompt 字串
+        """
+        try:
+            # V2 Context-Aware Prompt (推薦，解決評價不一致問題)
+            if use_v2:
+                from prompts.investment_advice_v2 import get_context_aware_prompt, get_simplified_context_prompt
+                logger.info(f"Using V2 Context-Aware Prompt (CoT={use_cot}, risk={risk_tolerance})")
+                if use_cot:
+                    return get_context_aware_prompt(strategy_data, risk_tolerance=risk_tolerance, use_cot=True)
+                else:
+                    # 簡化版，但仍有 context
+                    return get_simplified_context_prompt(strategy_data)
+
+            # V1 Prompt (舊版，保留向後兼容)
+            elif use_cot:
+                # 使用 CoT 版本
+                from prompts.investment_advice_cot import get_cot_analysis_prompt
+                logger.info("Using V1 Chain-of-Thought prompt")
+                return get_cot_analysis_prompt(strategy_data)
+            else:
+                # 使用原版（結構化輸出）
+                from prompts.investment_advice import get_comprehensive_analysis_prompt
+                logger.info("Using V1 standard prompt")
+                return get_comprehensive_analysis_prompt(strategy_data)
+        except ImportError as e:
+            # 回退到內建模板
+            logger.warning(f"Could not import prompts module ({e}), using built-in template")
+            return self._get_builtin_prompt(strategy_data)
+
+    def _get_builtin_prompt(self, strategy_data: Dict[str, Any]) -> str:
+        """內建模板作為回退方案"""
+        context = self.build_strategy_context(strategy_data)
+        return f"""{self.system_prompt}
+
+{context}
+
+請嚴格遵循以下結構，為這份投資策略撰寫一份專業分析報告：
+
+---
+
+### **【投資策略總評：給您的執行摘要】**
+*在這部分，請用2-3句話總結這個策略的核心特點與績效等級。直接點出它適合哪一種類型的投資者。*
+
+### **【績效深度解析：白話解讀關鍵指標】**
+*在這部分，請選擇2-3個最重要的指標（例如：夏普比率、最大回落），並用生動的比喻解釋它們在此策略中的意義。*
+- **指標1**：[指標名稱] - [用比喻解釋其表現]
+- **指標2**：[指標名稱] - [用比喻解釋其表現]
+
+### **【策略的亮點與潛在風險】**
+*客觀分析此策略的優缺點。*
+- **👍 亮點 (Strengths)**：[至少列出2點，例如：在特定市場環境下表現優異、風險控制得當等]
+- **🤔 潛在風險 (Weaknesses/Risks)**：[至少列出2點，例如：資產過於集中、對利率變化敏感等]
+
+### **【給您的具體投資建議】**
+*提供清晰、可執行的建議。*
+1.  **核心觀點**：[明確指出「繼續持有」、「考慮調整」或「尋找替代方案」]
+2.  **優化建議**：[提出1-2項具體優化方向，例如：「可考慮納入 OOO 類型的資產以分散風險」或「建議將再平衡頻率調整為 X 個月一次」]
+3.  **風險管理**：[提醒投資者應該注意的市場訊號或事件]
+
+### **【未來展望與提醒】**
+*提供一個前瞻性的總結，並附上免責聲明。*
+
+---
+
+請用繁體中文回答，確保報告結構完整、語氣專業且易於理解。"""
+
+
+class LLMInvestmentAdvisor:
+    """LLM投資顧問主類"""
+
+    def __init__(self, api_key: Optional[str] = None):
+        """初始化LLM服務"""
+        provider = os.environ.get('LLM_PROVIDER', 'openai').lower()
+        base_url = None
+        default_headers = None
+
+        if provider == 'openrouter':
+            self.api_key = api_key or os.environ.get('OPENROUTER_API_KEY') or OPENAI_CONFIG.get('api_key')
+            base_url = os.environ.get('OPENROUTER_BASE_URL', 'https://openrouter.ai/api/v1')
+            self.model = os.environ.get('OPENROUTER_MODEL', OPENAI_CONFIG.get('model', 'openrouter/auto'))
+            default_headers = {
+                'HTTP-Referer': os.environ.get('OPENROUTER_REFERER', ''),
+                'X-Title': os.environ.get('OPENROUTER_TITLE', 'TPM')
+            }
+        else:
+            self.api_key = api_key or os.environ.get('OPENAI_API_KEY') or OPENAI_CONFIG.get('api_key')
+            self.model = os.environ.get('OPENAI_MODEL', OPENAI_CONFIG.get('model', 'gpt-4'))
+
+        if not self.api_key or self.api_key == 'your-api-key-here':
+            raise ValueError("LLM API key is required. Please set OPENAI_API_KEY or OPENROUTER_API_KEY.")
+
+        self.client = OpenAI(
+            api_key=self.api_key,
+            base_url=base_url,
+            timeout=OPENAI_CONFIG.get('timeout', 30),
+            default_headers=default_headers
+        )
+        self.prompt_manager = PromptManager()
+        self.max_tokens = OPENAI_CONFIG.get('max_tokens', 2000)
+        self.temperature = OPENAI_CONFIG.get('temperature', 0.7)
+
+        # 快取設定
+        self.cache: Dict[str, Tuple[str, float]] = {}
+        self.cache_timeout = 3600  # 1小時快取
+        self.mock_mode = os.environ.get('MOCK_LLM', 'false').lower() in ('1', 'true', 'yes')
+
+    def _is_cache_valid(self, cache_time: float) -> bool:
+        """檢查快取是否有效"""
+        return time.time() - cache_time < self.cache_timeout
+
+    def generate_advice(self, strategy_id: str, strategy_data: Dict[str, Any],
+                        use_cot: bool = False,
+                        use_v2: bool = True,
+                        risk_tolerance: str = "moderate") -> str:
+        """生成投資建議
+
+        Args:
+            strategy_id: 策略ID
+            strategy_data: 策略資料字典
+            use_cot: 是否使用 Chain-of-Thought 模式（預設 False）
+            use_v2: 是否使用 V2 Context-Aware Prompt（預設 True）
+            risk_tolerance: 風險承受度 (conservative/moderate/aggressive)
+
+        Returns:
+            str: 投資建議文本
+        """
+        stable_payload = json.dumps(strategy_data, sort_keys=True).encode('utf-8')
+        cache_digest = hashlib.sha256(stable_payload).hexdigest()
+        # 快取鍵包含版本和風險承受度資訊
+        cache_key = f"advice_{strategy_id}_{cache_digest}_v{2 if use_v2 else 1}_cot{use_cot}_risk{risk_tolerance}"
+
+        # 檢查快取
+        if cache_key in self.cache:
+            advice, cache_time = self.cache[cache_key]
+            if self._is_cache_valid(cache_time):
+                logger.info(f"Returning cached advice for strategy {strategy_id} (V2={use_v2}, CoT={use_cot}, risk={risk_tolerance})")
+                return advice
+
+        try:
+            # 構建prompt（根據參數選擇版本）
+            prompt = self.prompt_manager.get_investment_advice_prompt(
+                strategy_data,
+                use_cot=use_cot,
+                use_v2=use_v2,
+                risk_tolerance=risk_tolerance
+            )
+
+            # Mock 模式：不呼叫外部API
+            if self.mock_mode:
+                logger.info("MOCK_LLM enabled, returning fallback advice without external API call")
+                response = self._get_fallback_advice(strategy_data)
+            else:
+                # 調用LLM API
+                response = self._call_openai_with_retry(prompt)
+
+            # 快取結果
+            self.cache[cache_key] = (response, time.time())
+            logger.info(f"Generated new advice for strategy {strategy_id} (CoT={use_cot})")
+            return response
+
+        except Exception as e:
+            logger.error(f"Error generating advice for strategy {strategy_id}: {str(e)}")
+            return self._get_fallback_advice(strategy_data)
+
+    def clear_cache(self):
+        """清除快取"""
+        self.cache.clear()
+        logger.info("LLM advice cache cleared")
+
+    def _call_openai_with_retry(self, prompt: str) -> str:
+        """調用OpenAI API，包含重試機制
+
+        Args:
+            prompt: 完整的prompt
+
+        Returns:
+            str: API回應內容
+        """
+        max_retries = RATE_LIMITS.get('max_retries', 3)
+        retry_delay = RATE_LIMITS.get('retry_delay', 2)
+
+        for attempt in range(max_retries):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.model,
+                    messages=[
+                        {"role": "system", "content": "你是一位專業的投資顧問。"},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=self.max_tokens,
+                    temperature=self.temperature,
+                    top_p=0.9
+                )
+
+                return response.choices[0].message.content.strip()
+
+            except Exception as e:
+                status_code = getattr(e, 'status_code', None)
+                is_rate_limited = status_code == 429 or 'rate limit' in str(e).lower()
+                if attempt < max_retries - 1 and (is_rate_limited or True):
+                    wait_time = retry_delay ** attempt
+                    logger.warning(f"LLM API error, retrying in {wait_time}s... (attempt {attempt + 1}/{max_retries}): {str(e)}")
+                    time.sleep(wait_time)
+                    continue
+                logger.error(f"LLM API error after {max_retries} attempts: {str(e)}")
+                raise e
+
+    def _get_fallback_advice(self, strategy_data: Dict[str, Any]) -> str:
+        """獲取fallback投資建議 - 使用原本的詳細 prompt 結構"""
+        try:
+            # 嘗試使用 prompts/investment_advice.py 的模板
+            from prompts.investment_advice import get_comprehensive_analysis_prompt
+            # 直接返回 prompt 作為 fallback（模擬 LLM 回覆的結構）
+            prompt = get_comprehensive_analysis_prompt(strategy_data)
+            # 提取 prompt 中的策略數據部分，生成基本回覆
+            return self._generate_basic_analysis(strategy_data)
+        except ImportError:
+            return self._generate_basic_analysis(strategy_data)
+    
+    def _generate_basic_analysis(self, strategy_data: Dict[str, Any]) -> str:
+        """生成基本分析（當無法調用 LLM 時）"""
+        annual_ret = strategy_data.get('annual_ret', 0)
+        vol = strategy_data.get('vol', 0)
+        sharpe = strategy_data.get('annual_sr', 0)
+        mdd = strategy_data.get('mdd', 0)
+        alpha = strategy_data.get('alpha', 0)
+        beta = strategy_data.get('beta', 0)
+        var = strategy_data.get('var10', 0)
+        r2 = strategy_data.get('r2', 0)
+        assets = strategy_data.get('assets', [])
+        
+        # 評估表現等級
+        ret_level = "優秀" if annual_ret > 0.15 else "良好" if annual_ret > 0.08 else "一般" if annual_ret > 0 else "需改善"
+        risk_level = "低風險" if vol < 0.15 else "中風險" if vol < 0.25 else "高風險"
+        sharpe_level = "優良" if sharpe > 1.5 else "良好" if sharpe > 1.0 else "一般" if sharpe > 0.5 else "需改善"
+        
+        return f"""
+## 📊 策略總評
+這是一個{ret_level}的投資策略，年化報酬率達到{annual_ret:.1%}，屬於{risk_level}等級。策略的風險調整後報酬表現{sharpe_level}，夏普比率為{sharpe:.2f}，顯示出{"良好" if sharpe > 1.0 else "一般"}的風險管理能力。
+
+## 📈 關鍵指標深度解析
+
+### 💰 報酬表現
+- **年化報酬率**：{annual_ret:.2%} - 這個報酬率在當前市場環境下表現{'優異' if annual_ret > 0.12 else '良好' if annual_ret > 0.08 else '一般'}，{'超越' if annual_ret > 0.1 else '接近' if annual_ret > 0.05 else '低於'}市場平均水準
+- **風險調整報酬**：{sharpe:.2f} - 夏普比率{'超過1.0' if sharpe > 1.0 else '接近1.0' if sharpe > 0.8 else '低於1.0'}，表示每承擔一單位風險能獲得{'良好' if sharpe > 1.0 else '一般'}的超額報酬
+
+### ⚠️ 風險評估
+- **波動率**：{vol:.2%} - 年化波動率{'較低' if vol < 0.15 else '適中' if vol < 0.25 else '較高'}，顯示策略的穩定性{'良好' if vol < 0.2 else '一般'}
+- **最大回落**：{mdd:.2%} - 最大虧損幅度{'控制在合理範圍' if abs(mdd) < 0.1 else '需要關注'}，風險控制{'得當' if abs(mdd) < 0.15 else '有待改善'}
+- **VaR (95%)**：{var:.2%} - 在95%的信心水準下，單日最大可能虧損為{abs(var):.2%}
+
+### 📊 市場關聯性
+- **Alpha值**：{alpha:.4f} - {'正向' if alpha > 0 else '負向'}超額收益，顯示策略{'優於' if alpha > 0 else '弱於'}市場基準表現
+- **Beta值**：{beta:.2f} - 策略與市場的關聯性{'較高' if beta > 1.1 else '適中' if beta > 0.9 else '較低'}，市場波動1%時，策略預期波動{beta:.2f}%
+- **R-squared**：{r2:.2%} - 策略表現有{r2:.1%}可由市場變動解釋
+
+## 🎯 策略優劣分析
+
+### 👍 亮點優勢
+- **風險調整報酬{'優異' if sharpe > 1.5 else '良好' if sharpe > 1.0 else '一般'}**：夏普比率{sharpe:.2f}顯示策略在控制風險的同時能創造{'優質' if sharpe > 1.5 else '良好' if sharpe > 1.0 else '基本'}的報酬
+- **資產配置{'合理' if len(assets) > 3 else '需強化'}**：包含{len(assets)}個標的，{'有效' if len(assets) > 5 else '適度' if len(assets) > 3 else '需增加'}分散投資風險
+- **市場適應性**：Alpha值{alpha:.4f}顯示策略{'具有' if alpha > 0 else '缺乏'}超額收益能力
+
+### 🤔 潛在風險
+- **市場敏感度**：Beta值{beta:.2f}表示策略{'高度' if beta > 1.2 else '適度' if beta > 0.8 else '低度'}受市場波動影響
+- **回檔風險**：最大回落{mdd:.2%}顯示在極端市場情況下可能面臨{'較大' if abs(mdd) > 0.2 else '中等' if abs(mdd) > 0.1 else '有限'}的虧損
+- **集中度風險**：需要{'特別' if len(assets) < 5 else '持續'}關注資產配置是否過於集中在特定行業或地區
+
+## 💡 具體投資建議
+
+### 1. 核心觀點
+**建議**：{'✅ 繼續持有並定期調整' if annual_ret > 0.1 and sharpe > 1.0 else '⚠️ 考慮優化配置' if annual_ret > 0.05 else '❌ 需要重新評估策略'}
+
+**理由**：
+- 報酬表現{'符合' if annual_ret > 0.08 else '未達'}預期目標
+- 風險控制{'良好' if sharpe > 1.0 else '需要改善'}
+- 市場適應性{'優異' if alpha > 0.02 else '適中' if alpha > 0 else '不佳'}
+
+### 2. 優化方向
+- **資產配置調整**：可考慮納入更多{'防禦性資產（如公債、公用事業）' if vol > 0.2 else '成長性資產（如科技股、新興市場）'}以{'降低整體風險' if vol > 0.2 else '提升報酬潛力'}
+- **再平衡頻率**：建議將再平衡頻率調整為{'每月' if vol > 0.25 else '每季度' if vol > 0.15 else '每半年'}一次，以適應市場變化
+- **風險暴露管理**：{'考慮降低' if beta > 1.2 else '可適度提高' if beta < 0.8 else '維持當前'}市場Beta暴露
+
+### 3. 風險管理
+- **止損設定**：建議設定止損點在{abs(mdd)*1.3:.1%}（當前最大回落的1.3倍），避免過大虧損
+- **倉位控制**：在市場波動加劇時，{'建議降低倉位至70-80%' if vol > 0.25 else '可維持滿倉' if vol < 0.15 else '維持80-90%倉位'}
+- **監控指標**：
+  - 持續關注VaR指標，當VaR超過{abs(var)*1.5:.2%}時應考慮降低風險
+  - 密切追蹤市場波動性變化（VIX指數等）
+  - 定期檢視Alpha表現，確保策略持續創造超額收益
+
+## 🔮 未來展望
+
+基於當前市場環境和策略表現，預期未來3-6個月內：
+
+- **報酬預期**：策略將維持{'穩定增長' if sharpe > 1.2 else '波動' if sharpe > 0.8 else '震盪'}表現，年化報酬率預計在{annual_ret*0.8:.1%}至{annual_ret*1.2:.1%}之間
+- **風險展望**：市場波動性{'可能上升' if vol > 0.2 else '預期維持穩定'}，建議投資者{'提高警覺' if vol > 0.2 else '保持耐心'}
+- **調整建議**：定期檢視（建議每{'月' if vol > 0.25 else '季度'}一次）並適時調整，以應對市場變化
+
+### 關鍵提醒
+⚠️ **免責聲明**：此為基於歷史數據的模擬分析結果，過去績效不代表未來表現。實際投資請謹慎評估個人風險承受能力，並建議諮詢專業投資顧問。
+
+📝 **行動建議**：
+1. 定期監控策略表現（建議每週檢視一次）
+2. 設定明確的投資目標和停損點
+3. 保持投資組合的靈活性，適時調整
+4. 持續學習市場動態，提升投資判斷力
+
+*本分析報告生成於{strategy_data.get('name', 'N/A')}策略，僅供參考。*
+"""
+
+    # Duplicate clear_cache removed
+
+
+# 創建全域實例
+llm_advisor = None
+
+def get_llm_advisor() -> LLMInvestmentAdvisor:
+    """獲取LLM顧問實例"""
+    global llm_advisor
+    if llm_advisor is None:
+        llm_advisor = LLMInvestmentAdvisor()
+    return llm_advisor

main.py

@@ -15,6 +15,7 @@ import random
 import string
 import logging
 import numpy as np
+logger = logging.getLogger(__name__)
 import pandas as pd
 import psycopg2
 import psycopg2.extras
@@ -22,22 +23,65 @@ import plotly
 import plotly.express as px
 from portfolio_builder import MVO
 from config import *
+from llm_service import get_llm_advisor
 pd.options.plotting.backend = "plotly"
 
 
 
 app = Flask(__name__)
-app.config.from_mapping(CONFIGS)
-app.config.update(CACHE_CONFIG)
-cache = Cache(app)
 
-
+# Configure logging
-
+import sys
-# Load Assets
+logging.basicConfig(
-with open('assets_tw.json') as f:
+    stream=sys.stdout,
-    data_tw = json.load(f)
+    level=logging.INFO,
-with open('assets_us.json') as f:
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    data_us = json.load(f)
+)
+logger = logging.getLogger(__name__)
+
+try:
+    logger.info("Configuring Flask app...")
+    app.config.from_mapping(CONFIGS)
+    logger.info("Updating cache config...")
+    app.config.update(CACHE_CONFIG)
+    logger.info("Initializing cache...")
+    cache = Cache(app)
+    logger.info("Flask app initialized successfully!")
+except Exception as e:
+    logger.error(f"Failed to initialize Flask app: {e}", exc_info=True)
+    raise
+
+
+
+# Load Assets (lazy loading to avoid startup failures)
+data_tw = None
+data_us = None
+
+def load_assets():
+    global data_tw, data_us
+    if data_tw is None:
+        try:
+            with open('assets_tw.json') as f:
+                data_tw = json.load(f)
+            logger.info(f"Loaded assets_tw.json with {len(data_tw)} items")
+        except FileNotFoundError as e:
+            logger.warning(f"Assets file not found: {e}")
+            data_tw = {}
+        except Exception as e:
+            logger.error(f"Error loading assets_tw.json: {e}")
+            data_tw = {}
+
+    if data_us is None:
+        try:
+            with open('assets_us.json') as f:
+                data_us = json.load(f)
+            logger.info(f"Loaded assets_us.json with {len(data_us)} items")
+        except FileNotFoundError as e:
+            logger.warning(f"Assets file not found: {e}")
+            data_us = {}
+        except Exception as e:
+            logger.error(f"Error loading assets_us.json: {e}")
+            data_us = {}
 
 def login_required():
     if not 'username' in session:
@@ -203,6 +247,7 @@ def strategy():
     else:
         flash('使用投組功能請先登入。', 'warning')
         return redirect(url_for('login'))
+    load_assets()  # Ensure assets are loaded
     session['tw'] = 0
     return render_template('strategy_tw.html', data_us = data_us, data_tw=data_tw, stock=['TSLA'])
 
@@ -217,6 +262,7 @@ def strategy_tw():
     else:
         flash('使用投組功能請先登入。', 'warning')
         return redirect(url_for('login'))
+    load_assets()  # Ensure assets are loaded
     session['tw'] = 1
     return render_template('strategy_tw.html', data_tw=data_tw, stock=['2330.TW'])
 
@@ -369,6 +415,10 @@ def custom_post():
     else:
         flash('使用投組功能請先登入。', 'warning')
         return redirect(url_for('login'))
+
+    # Ensure plotly backend is set
+    pd.options.plotting.backend = "plotly"
+
     port = pd.read_csv(request.files['csv_file'], index_col=0, parse_dates=True)
     role = request.form.get('role')
     lookback = int(request.form.get('lookback'))
@@ -391,7 +441,7 @@ def custom_post():
 
     info = MVO.portfolio_info(np.array([1]), rets['Portfolio'].to_numpy().reshape(-1, 1), np.zeros(len(ret)-lookback))
     info['username'] = session.get('username').split('@')[0]
-    info['role'] = role_map[role]
+    info['role'] = role_map.get(role, role)
     info['id']='Custom data'
     info['name']='Custom data'
     info['date'] = '-'
@@ -492,6 +542,10 @@ def result_view():
     else:
         sid = request.args.get('strategy_id')
     strategy_id = request.args.get('strategy_id')
+
+    # Ensure plotly backend is set (fixes Railway deployment issue)
+    pd.options.plotting.backend = "plotly"
+
     sql="""select * from strategy where id=%s;"""
     conn = psycopg2.connect(**SQL_CONFIG)
     with conn:
@@ -499,9 +553,15 @@ def result_view():
             curs.execute(sql, (sid, ))
             data= curs.fetchone()
     conn.close()
+
+    # Check if strategy exists
+    if not data:
+        flash(f'策略 ID {sid} 不存在', 'warning')
+        return redirect(url_for('result'))
+
     # Processing data
     data = dict(data)
-    data['role'] = role_map[data['role']]
+    data['role'] = role_map.get(data['role'], data['role'])
     w = data['weight']
     r = data['ret']
     w = pd.DataFrame(w['data'], columns=w['columns'], index=w['index'])
@@ -524,6 +584,67 @@ def result_view():
     data['bar'] = json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
     session['currStockList'] = data['assets']
     return render_template('result_view.html', data=data)
+
+@app.route('/api/llm_advice/<int:strategy_id>')
+def llm_advice(strategy_id):
+    """LLM投資建議API
+
+    接收策略ID，返回AI生成的投資建議
+    Query parameters:
+        - cot (optional): 'true' to enable Chain-of-Thought reasoning
+    """
+    try:
+        # 驗證登入
+        if not login_required():
+            return jsonify({
+                'success': False,
+                'error': '請先登入'
+            }), 401
+
+        # 獲取CoT參數
+        use_cot = request.args.get('cot', 'false').lower() == 'true'
+
+        # 查詢策略資料
+        sql = "SELECT * FROM strategy WHERE id = %s;"
+        conn = psycopg2.connect(**SQL_CONFIG)
+        with conn:
+            with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as curs:
+                curs.execute(sql, (strategy_id,))
+                strategy_data = curs.fetchone()
+
+        conn.close()
+
+        if not strategy_data:
+            return jsonify({
+                'success': False,
+                'error': '策略不存在'
+            }), 404
+
+        # 轉換為字典並處理角色映射
+        strategy_dict = dict(strategy_data)
+        strategy_dict['role'] = role_map.get(strategy_dict['role'], strategy_dict['role'])
+
+        # 獲取LLM顧問實例
+        llm_advisor = get_llm_advisor()
+
+        # 生成投資建議（支援CoT模式）
+        advice = llm_advisor.generate_advice(str(strategy_id), strategy_dict, use_cot=use_cot)
+
+        return jsonify({
+            'success': True,
+            'advice': advice,
+            'strategy_id': strategy_id,
+            'cot_enabled': use_cot
+        })
+
+    except Exception as e:
+        logger.error(f"Error generating LLM advice for strategy {strategy_id}: {str(e)}")
+        return jsonify({
+            'success': False,
+            'error': '生成建議時發生錯誤',
+            'details': str(e)
+        }), 500
+
 @app.route('/copy_portfolio')
 def copy_portfolio():
     if login_required():
@@ -533,6 +654,7 @@ def copy_portfolio():
         return redirect(url_for('login'))
     if not 'tw' in session:
         return redirect(url_for('index'))
+    load_assets()  # Ensure assets are loaded
     session['tw'] = 0
     return render_template('strategy_tw.html', data_us = data_us, data_tw=data_tw, stock=session['currStockList'])
     

market_benchmark.py

@@ -0,0 +1,259 @@
+"""
+市場基準資料模組
+
+從資料庫取得實際的市場基準資料（台股加權指數、S&P 500）
+用於 Context Engineering 的市場環境背景
+"""
+
+import psycopg2
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+# 從 config 匯入資料庫設定
+try:
+    from config import SQL_CONFIG
+except ImportError:
+    # Fallback 設定
+    SQL_CONFIG = {
+        "database": "portfolio_platform",
+        "user": "postgres",
+        "host": "db",
+        "port": "5432",
+        "password": "thiispassword1qaz!QAZ"
+    }
+
+
+class MarketBenchmark:
+    """市場基準資料類別"""
+
+    def __init__(self):
+        """初始化市場基準資料"""
+        self.cache = {}
+        self.cache_timeout = 3600  # 1小時快取
+        self.cache_time = {}
+
+    def _is_cache_valid(self, key: str) -> bool:
+        """檢查快取是否有效"""
+        if key not in self.cache_time:
+            return False
+        return (datetime.now().timestamp() - self.cache_time[key]) < self.cache_timeout
+
+    def get_market_context(self, tw: bool = True, force_refresh: bool = False) -> Dict[str, Any]:
+        """
+        獲取市場環境背景（從資料庫計算實際數據）
+
+        Args:
+            tw: True=台灣市場，False=美國市場
+            force_refresh: 強制重新計算（不使用快取）
+
+        Returns:
+            市場環境背景字典
+        """
+        cache_key = f"market_{'tw' if tw else 'us'}"
+
+        # 檢查快取
+        if not force_refresh and self._is_cache_valid(cache_key):
+            logger.info(f"Using cached market context for {'TW' if tw else 'US'}")
+            return self.cache[cache_key]
+
+        try:
+            if tw:
+                context = self._get_tw_market_context()
+            else:
+                context = self._get_us_market_context()
+
+            # 更新快取
+            self.cache[cache_key] = context
+            self.cache_time[cache_key] = datetime.now().timestamp()
+
+            logger.info(f"Calculated market context for {'TW' if tw else 'US'}: {context}")
+            return context
+
+        except Exception as e:
+            logger.error(f"Error getting market context: {e}")
+            # Fallback 到靜態資料
+            return self._get_fallback_context(tw)
+
+    def _get_tw_market_context(self) -> Dict[str, Any]:
+        """取得台灣市場基準資料（從資料庫計算）"""
+        conn = psycopg2.connect(**SQL_CONFIG)
+
+        try:
+            # 取得 0050.TW 近期資料
+            query = """
+                SELECT date, price
+                FROM stock_price_tw
+                WHERE ticker = '0050.TW'
+                ORDER BY date DESC
+                LIMIT 1260  -- 約5年交易日
+            """
+
+            df = pd.read_sql(query, conn)
+            df = df.sort_values('date')
+            df['return'] = df['price'].pct_change()
+
+            # 計算各項指標
+            latest_price = df['price'].iloc[-1]
+            year_start_idx = max(0, len(df) - 252)  # 今年開始（約252交易日）
+            ytd_return = (latest_price / df['price'].iloc[year_start_idx]) - 1
+
+            # 近5年年化報酬
+            total_return = (latest_price / df['price'].iloc[0]) - 1
+            years = len(df) / 252
+            avg_5y_return = (1 + total_return) ** (1 / years) - 1
+
+            # 年化波動率
+            volatility = df['return'].std() * np.sqrt(252)
+
+            # 市場情緒判斷（基於近期趨勢）
+            recent_returns = df['return'].iloc[-63:].sum()  # 最近3個月
+            if recent_returns > 0.05:
+                sentiment = "bull"
+            elif recent_returns < -0.05:
+                sentiment = "bear"
+            else:
+                sentiment = "neutral"
+
+            return {
+                "market_name": "台灣加權指數（0050.TW）",
+                "ytd_return": float(ytd_return),
+                "avg_5y_return": float(avg_5y_return),
+                "current_price": float(latest_price),
+                "volatility": float(volatility),
+                "sentiment": sentiment,
+                "last_update": df['date'].iloc[-1].strftime("%Y-%m-%d"),
+                "data_points": len(df)
+            }
+
+        finally:
+            conn.close()
+
+    def _get_us_market_context(self) -> Dict[str, Any]:
+        """取得美國市場基準資料（從資料庫計算）"""
+        conn = psycopg2.connect(**SQL_CONFIG)
+
+        try:
+            # 取得 SPY 近期資料
+            query = """
+                SELECT date, price
+                FROM stock_price
+                WHERE ticker = 'SPY'
+                ORDER BY date DESC
+                LIMIT 1260  -- 約5年交易日
+            """
+
+            df = pd.read_sql(query, conn)
+            df = df.sort_values('date')
+            df['return'] = df['price'].pct_change()
+
+            # 計算各項指標
+            latest_price = df['price'].iloc[-1]
+            year_start_idx = max(0, len(df) - 252)
+            ytd_return = (latest_price / df['price'].iloc[year_start_idx]) - 1
+
+            # 近5年年化報酬
+            total_return = (latest_price / df['price'].iloc[0]) - 1
+            years = len(df) / 252
+            avg_5y_return = (1 + total_return) ** (1 / years) - 1
+
+            # 年化波動率
+            volatility = df['return'].std() * np.sqrt(252)
+
+            # 市場情緒判斷
+            recent_returns = df['return'].iloc[-63:].sum()
+            if recent_returns > 0.05:
+                sentiment = "bull"
+            elif recent_returns < -0.05:
+                sentiment = "bear"
+            else:
+                sentiment = "neutral"
+
+            return {
+                "market_name": "S&P 500（SPY）",
+                "ytd_return": float(ytd_return),
+                "avg_5y_return": float(avg_5y_return),
+                "current_price": float(latest_price),
+                "volatility": float(volatility),
+                "sentiment": sentiment,
+                "last_update": df['date'].iloc[-1].strftime("%Y-%m-%d"),
+                "data_points": len(df)
+            }
+
+        finally:
+            conn.close()
+
+    def _get_fallback_context(self, tw: bool) -> Dict[str, Any]:
+        """Fallback 靜態資料（資料庫查詢失敗時使用）"""
+        if tw:
+            return {
+                "market_name": "台灣加權指數",
+                "ytd_return": 0.18,
+                "avg_5y_return": 0.09,
+                "volatility": 0.15,
+                "sentiment": "neutral",
+                "last_update": "static",
+                "is_fallback": True
+            }
+        else:
+            return {
+                "market_name": "S&P 500",
+                "ytd_return": 0.22,
+                "avg_5y_return": 0.12,
+                "volatility": 0.14,
+                "sentiment": "bull",
+                "last_update": "static",
+                "is_fallback": True
+            }
+
+
+# 單例模式
+_market_benchmark_instance = None
+
+def get_market_benchmark() -> MarketBenchmark:
+    """獲取市場基準實例（單例）"""
+    global _market_benchmark_instance
+    if _market_benchmark_instance is None:
+        _market_benchmark_instance = MarketBenchmark()
+    return _market_benchmark_instance
+
+
+# 便利函數（向後兼容）
+def get_market_context(tw: bool = True) -> Dict[str, Any]:
+    """
+    獲取市場環境背景
+
+    此函數與 prompts/investment_advice_v2.py 中的函數簽名相同
+    可直接替換使用
+    """
+    benchmark = get_market_benchmark()
+    return benchmark.get_market_context(tw)
+
+
+if __name__ == "__main__":
+    # 測試腳本
+    import json
+
+    logging.basicConfig(level=logging.INFO)
+
+    print("="*80)
+    print("測試市場基準資料模組")
+    print("="*80)
+
+    # 測試台灣市場
+    print("\n台灣市場基準：")
+    tw_context = get_market_context(tw=True)
+    print(json.dumps(tw_context, indent=2, ensure_ascii=False))
+
+    # 測試美國市場
+    print("\n美國市場基準：")
+    us_context = get_market_context(tw=False)
+    print(json.dumps(us_context, indent=2, ensure_ascii=False))
+
+    print("\n" + "="*80)
+    print("測試完成！")
+    print("="*80)

nixpacks.toml

@@ -0,0 +1,8 @@
+[phases.setup]
+nixPkgs = ['python39']
+
+[phases.install]
+cmds = ['pip install -r requirements.txt']
+
+[start]
+cmd = 'gunicorn -w 2 -b 0.0.0.0:$PORT --timeout 120 main:app'

prompts/investment_advice.py

@@ -0,0 +1,160 @@
+"""
+投資建議相關的Prompt模板
+
+包含：
+- 基本投資建議模板
+- 進階分析模板
+- 不同市場環境的模板
+"""
+
+from typing import Dict, Any
+
+
+def get_basic_investment_prompt(strategy_data: Dict[str, Any]) -> str:
+    """基本投資建議Prompt"""
+    return f"""
+請基於以下投資策略數據，提供專業的投資建議：
+
+策略概況：
+- 年化報酬率：{strategy_data.get('annual_ret', 0):.2%}
+- 年化波動率：{strategy_data.get('vol', 0):.2%}
+- 夏普比率：{strategy_data.get('annual_sr', 0):.2f}
+- 最大回落：{strategy_data.get('mdd', 0):.2%}
+- 投資目標：{strategy_data.get('role', 'N/A')}
+
+投資組合包含：{', '.join(strategy_data.get('assets', []))}
+
+請提供：
+1. 整體表現評估
+2. 風險收益分析
+3. 改進建議
+"""
+
+
+def get_comprehensive_analysis_prompt(strategy_data: Dict[str, Any]) -> str:
+    """全面分析Prompt - 現代化結構"""
+    return f"""
+作為專業投資顧問，請對以下投資策略進行全面分析並提供建議：
+
+【策略基本資訊】
+- 策略名稱：{strategy_data.get('name', 'N/A')}
+- 投資目標：{strategy_data.get('role', 'N/A')}
+- 市場類型：{'台灣市場' if strategy_data.get('tw', True) else '美國市場'}
+
+【關鍵績效指標】
+- 年化報酬率：{strategy_data.get('annual_ret', 0):.2%}
+- 年化波動率：{strategy_data.get('vol', 0):.2%}
+- 年化夏普比率：{strategy_data.get('annual_sr', 0):.2f}
+- 最大回落（MDD）：{strategy_data.get('mdd', 0):.2%}
+- Alpha值：{strategy_data.get('alpha', 0):.4f}
+- Beta值：{strategy_data.get('beta', 0):.4f}
+- VaR (95%)：{strategy_data.get('var10', 0):.2%}
+- R-squared：{strategy_data.get('r2', 0):.4f}
+
+【投資組合配置】
+持有資產：{', '.join(strategy_data.get('assets', []))}
+權重配置：{strategy_data.get('weight', {}).get('columns', [])}
+
+【分析要求】
+請從以下面向提供詳細分析和建議：
+
+1. **績效評估**：
+   - 與市場基準比較（台灣加權指數或S&P 500）
+   - 歷史表現趨勢分析
+   - 相對表現評價
+
+2. **風險分析**：
+   - 整體風險水平評估
+   - 主要風險來源識別
+   - 風險調整後報酬分析
+
+3. **市場適配性**：
+   - 當前市場環境適配程度
+   - 經濟週期位置評估
+   - 市場波動性影響分析
+
+4. **投資建議**：
+   - 資產配置優化建議
+   - 風險管理改進方案
+   - 定期調整和再平衡建議
+
+5. **未來展望**：
+   - 未來3-6個月投資展望
+   - 潛在風險預警
+   - 操作建議和時機點
+
+---
+請用繁體中文回答，確保報告結構完整、語氣專業且易於理解。使用和格式化讓內容更生動。
+"""
+
+
+def get_risk_focused_prompt(strategy_data: Dict[str, Any]) -> str:
+    """風險導向分析Prompt"""
+    return f"""
+請重點分析以下投資策略的風險特性，並提供風險管理建議：
+
+【風險指標】
+- 年化波動率：{strategy_data.get('vol', 0):.2%}
+- 最大回落：{strategy_data.get('mdd', 0):.2%}
+- Beta值：{strategy_data.get('beta', 0):.4f}
+- VaR (10%)：{strategy_data.get('var10', 0):.2%}
+- 夏普比率：{strategy_data.get('annual_sr', 0):.2f}
+
+【風險分析要求】
+1. 評估當前風險水平（低/中/高）
+2. 識別主要風險來源
+3. 分析風險與報酬的配比
+4. 提供風險降低策略
+5. 建議風險監控指標
+
+請提供具體、可操作的風險管理建議。
+"""
+
+
+def get_market_context_prompt(strategy_data: Dict[str, Any], market_condition: str = "normal") -> str:
+    """市場環境特定Prompt"""
+    market_contexts = {
+        "bull": "目前市場處於牛市環境",
+        "bear": "目前市場處於熊市環境",
+        "volatile": "目前市場波動劇烈",
+        "normal": "目前市場環境正常"
+    }
+
+    context = market_contexts.get(market_condition, market_contexts["normal"])
+
+    return f"""
+{context}，請針對以下投資策略提供相應的投資建議：
+
+【策略資訊】
+- 年化報酬率：{strategy_data.get('annual_ret', 0):.2%}
+- 年化波動率：{strategy_data.get('vol', 0):.2%}
+- 投資目標：{strategy_data.get('role', 'N/A')}
+
+【市場適配建議】
+根據當前市場環境，請分析：
+1. 該策略在當前環境下的適配程度
+2. 可能的調整建議
+3. 風險控制措施
+4. 時機選擇建議
+
+請提供針對當前市場環境的具體操作建議。
+"""
+
+
+def build_custom_prompt(strategy_data: Dict[str, Any], analysis_type: str, **kwargs) -> str:
+    """自訂Prompt生成器
+
+    Args:
+        strategy_data: 策略資料
+        analysis_type: 分析類型 ('basic', 'comprehensive', 'risk', 'market')
+        **kwargs: 額外參數
+    """
+    templates = {
+        'basic': get_basic_investment_prompt,
+        'comprehensive': get_comprehensive_analysis_prompt,
+        'risk': get_risk_focused_prompt,
+        'market': lambda data: get_market_context_prompt(data, kwargs.get('condition', 'normal'))
+    }
+
+    template_func = templates.get(analysis_type, get_basic_investment_prompt)
+    return template_func(strategy_data)

prompts/investment_advice_v2.py

@@ -0,0 +1,630 @@
+"""
+投資建議 Prompt V2 - Context Engineering + Prompt Engineering
+
+核心改進：
+1. Context Engineering: 加入用戶背景、市場環境、評分標準
+2. Prompt Engineering: 強制一致性邏輯、嚴格輸出格式
+3. 前端整合: 支援 Markdown 渲染
+"""
+
+from typing import Dict, Any
+from datetime import datetime
+
+
+# ===== Context Engineering =====
+
+def get_market_context(tw: bool = True) -> Dict[str, Any]:
+    """
+    獲取市場環境背景（從資料庫計算實際數據）
+
+    整合：
+    - 資料庫：從 stock_price_tw (0050.TW) 和 stock_price (SPY) 計算
+    - 快取：1小時 TTL 避免重複計算
+    - Fallback：資料庫查詢失敗時使用靜態資料
+    """
+    try:
+        # 嘗試使用資料庫計算的實際市場數據
+        from market_benchmark import get_market_benchmark
+        benchmark = get_market_benchmark()
+        context = benchmark.get_market_context(tw)
+
+        # 如果是 fallback，記錄警告
+        if context.get('is_fallback'):
+            import logging
+            logging.warning(f"Using fallback market data for {'TW' if tw else 'US'}")
+
+        return context
+
+    except ImportError:
+        # market_benchmark 模組不存在，使用靜態資料
+        import logging
+        logging.warning("market_benchmark module not found, using static data")
+        return _get_static_market_context(tw)
+    except Exception as e:
+        # 其他錯誤，使用靜態資料
+        import logging
+        logging.error(f"Error loading market context: {e}, using static data")
+        return _get_static_market_context(tw)
+
+
+def _get_static_market_context(tw: bool) -> Dict[str, Any]:
+    """靜態市場資料（Fallback）"""
+    if tw:
+        return {
+            "market_name": "台灣加權指數（0050.TW）",
+            "ytd_return": 0.18,
+            "avg_5y_return": 0.09,
+            "volatility": 0.15,
+            "sentiment": "neutral",
+            "is_fallback": True
+        }
+    else:
+        return {
+            "market_name": "S&P 500（SPY）",
+            "ytd_return": 0.22,
+            "avg_5y_return": 0.12,
+            "volatility": 0.14,
+            "sentiment": "bull",
+            "is_fallback": True
+        }
+
+
+def get_investor_profile(risk_tolerance: str = "moderate") -> Dict[str, Any]:
+    """
+    投資人背景設定 (未來可從用戶資料庫讀取)
+
+    Args:
+        risk_tolerance: conservative/moderate/aggressive
+    """
+    profiles = {
+        "conservative": {
+            "label": "保守型",
+            "max_acceptable_mdd": -0.15,  # 最大可接受回落
+            "target_sharpe": 1.5,  # 目標夏普比率
+            "description": "重視資本保全，追求穩定收益"
+        },
+        "moderate": {
+            "label": "穩健型",
+            "max_acceptable_mdd": -0.25,
+            "target_sharpe": 1.0,
+            "description": "平衡風險與報酬"
+        },
+        "aggressive": {
+            "label": "積極型",
+            "max_acceptable_mdd": -0.40,
+            "target_sharpe": 0.8,
+            "description": "追求高報酬，願意承擔較高風險"
+        }
+    }
+    return profiles.get(risk_tolerance, profiles["moderate"])
+
+
+def get_evaluation_criteria() -> Dict[str, Any]:
+    """
+    明確的評分標準 (解決評價不一致問題)
+    """
+    return {
+        "sharpe_ratio": {
+            "excellent": 2.0,      # >= 2.0
+            "good": 1.5,           # >= 1.5
+            "acceptable": 1.0,     # >= 1.0
+            "poor": 0.5,           # >= 0.5
+            "very_poor": 0.0       # < 0.5
+        },
+        "annual_return": {
+            "tw": {"excellent": 0.15, "good": 0.10, "acceptable": 0.08, "poor": 0.05},
+            "us": {"excellent": 0.18, "good": 0.12, "acceptable": 0.10, "poor": 0.06}
+        },
+        "mdd": {
+            "low_risk": -0.15,     # < -15% 算低風險
+            "medium_risk": -0.25,  # -15% ~ -25%
+            "high_risk": -0.40,    # -25% ~ -40%
+            "extreme_risk": -0.40  # > -40%
+        },
+        "beta": {
+            "defensive": 0.8,      # < 0.8
+            "balanced": 1.2,       # 0.8 ~ 1.2
+            "aggressive": 1.2      # > 1.2
+        }
+    }
+
+
+# ===== Prompt Engineering =====
+
+def get_context_aware_prompt(strategy_data: Dict[str, Any],
+                              risk_tolerance: str = "moderate",
+                              use_cot: bool = True) -> str:
+    """
+    Context-Aware Prompt with Strict Evaluation Logic
+
+    Args:
+        strategy_data: 策略數據
+        risk_tolerance: 風險承受度 (conservative/moderate/aggressive)
+        use_cot: 是否使用 Chain-of-Thought
+    """
+    # 提取數據
+    annual_ret = strategy_data.get('annual_ret', 0)
+    vol = strategy_data.get('vol', 0)
+    sharpe = strategy_data.get('annual_sr', 0)
+    mdd = strategy_data.get('mdd', 0)
+    alpha = strategy_data.get('alpha', 0)
+    beta = strategy_data.get('beta', 0)
+    var10 = strategy_data.get('var10', 0)
+    r2 = strategy_data.get('r2', 0)
+    assets = strategy_data.get('assets', [])
+    name = strategy_data.get('name', 'N/A')
+    role = strategy_data.get('role', 'N/A')
+    tw = strategy_data.get('tw', True)
+
+    # Context Engineering
+    market_ctx = get_market_context(tw)
+    investor_profile = get_investor_profile(risk_tolerance)
+    criteria = get_evaluation_criteria()
+
+    # 構建評分邏輯
+    evaluation_logic = f"""
+## 評分標準與邏輯 (CRITICAL: 必須嚴格遵守)
+
+### 1. 夏普比率評級
+```python
+if sharpe >= {criteria['sharpe_ratio']['excellent']}:
+    rating = "優秀"
+    description = "風險調整後報酬表現卓越"
+elif sharpe >= {criteria['sharpe_ratio']['good']}:
+    rating = "良好"
+    description = "風險調整後報酬表現良好"
+elif sharpe >= {criteria['sharpe_ratio']['acceptable']}:
+    rating = "可接受"
+    description = "風險調整後報酬尚可"
+elif sharpe >= {criteria['sharpe_ratio']['poor']}:
+    rating = "待改善"
+    description = "風險調整後報酬偏低"
+else:
+    rating = "不佳"
+    description = "風險調整後報酬表現不佳"
+```
+
+**本策略夏普比率: {sharpe:.2f}** → 請依上述邏輯給予評級，並保持一致性。
+
+### 2. 報酬率評級 (相對於市場基準)
+- 市場基準: {market_ctx['market_name']} 近5年平均 {market_ctx['avg_5y_return']:.1%}
+- 本策略: {annual_ret:.2%}
+- 相對表現: {((annual_ret / market_ctx['avg_5y_return']) - 1) * 100:+.1f}%
+
+### 3. 風險評級
+- 最大回落: {mdd:.2%}
+- 投資人可接受範圍: {investor_profile['max_acceptable_mdd']:.1%}
+- 超出程度: {((abs(mdd) / abs(investor_profile['max_acceptable_mdd'])) - 1) * 100:+.1f}%
+
+### 4. 市場相關性
+- Beta: {beta:.2f}
+- 類型: {"防禦型 (< 0.8)" if beta < criteria['beta']['defensive'] else "均衡型 (0.8-1.2)" if beta < criteria['beta']['balanced'] else "進攻型 (> 1.2)"}
+- 預期波動: 市場變動 1%，策略預期變動 {beta:.2f}%
+
+### 5. 超額收益能力
+- Alpha: {alpha:.4f}
+- 解釋: {"創造超額收益 ✓" if alpha > 0.01 else "與市場同步 ≈" if alpha >= -0.01 else "落後市場 ✗"}
+"""
+
+    # 一致性邏輯檢查
+    consistency_check = f"""
+## 一致性邏輯檢查 (MUST FOLLOW)
+
+⚠️ **禁止自相矛盾**：
+1. 如果夏普比率評級為「優秀」，整體評價不能說「表現一般」
+2. 如果報酬率遠超市場，風險評價不能忽略這個亮點
+3. 如果 MDD 超出可接受範圍，必須在風險警示中明確指出
+
+✅ **評價優先順序**：
+1. 首先看風險調整後報酬 (夏普比率) → 這是最重要的指標
+2. 其次看絕對報酬 vs 市場基準
+3. 最後看風險承受度匹配性
+
+📊 **本策略快速判讀**：
+- 夏普 {sharpe:.2f}: {"優秀 ✓" if sharpe >= 2.0 else "良好 ✓" if sharpe >= 1.5 else "可接受 ○" if sharpe >= 1.0 else "待改善 ✗"}
+- 報酬 {annual_ret:.2%} vs 市場 {market_ctx['avg_5y_return']:.1%}: {"超越 ✓" if annual_ret > market_ctx['avg_5y_return'] * 1.2 else "接近 ○" if annual_ret > market_ctx['avg_5y_return'] * 0.8 else "落後 ✗"}
+- 風險 {mdd:.2%}: {"可接受 ✓" if abs(mdd) <= abs(investor_profile['max_acceptable_mdd']) else "偏高 ⚠️"}
+"""
+
+    # CoT 推理步驟
+    cot_steps = """
+## 推理步驟 (Chain-of-Thought)
+
+請按以下順序思考並輸出：
+
+**步驟 1: 指標解讀**
+- 先單獨解讀每個指標的絕對值
+- 再與市場基準比較
+- 最後與投資人預期比較
+
+**步驟 2: 綜合評分**
+- 根據評分標準，給出各維度評級
+- 注意保持一致性（不要有矛盾）
+- 找出最突出的優勢和劣勢
+
+**步驟 3: 情境分析**
+- 假設投入 100 萬資金
+- 最好情況能賺多少？(基於年化報酬)
+- 最壞情況會虧多少？(基於 MDD)
+- 承受 1 單位風險能換多少報酬？(基於夏普)
+
+**步驟 4: 投資建議**
+- 這個策略適合哪種投資人？
+- 在什麼市場環境下表現最好？
+- 需要做哪些調整才能更好？
+""" if use_cot else ""
+
+    # 嚴格禁止事項
+    strict_prohibitions = f"""
+## ⛔ 嚴格禁止事項 (CRITICAL - MUST FOLLOW)
+
+1. **禁止自己假設或生成市場數據**
+   - ❌ 禁止說「假設台灣加權指數同期間年化報酬率為 12%...」
+   - ❌ 禁止說「為了更精確的比較，我們需要...」
+   - ✅ **必須使用已提供的市場基準數據**: {market_ctx['market_name']} 近5年平均 {market_ctx['avg_5y_return']:.1%}
+
+2. **禁止模糊或矛盾的評價**
+   - ❌ 禁止說「優秀的投資策略...風險調整後報酬表現一般」
+   - ❌ 禁止說「良好但待改善」
+   - ✅ 必須根據夏普比率給出**明確且一致**的評級
+
+3. **禁止使用模板化語言**
+   - ❌ 禁止說「策略基本資訊回顧」「歷史表現趨勢分析」等空泛標題
+   - ✅ 必須根據**實際數據**給出具體分析
+
+4. **市場基準說明**
+   - 台灣市場: 使用 **0050.TW (元大台灣50)** 作為市場代理指標
+     - 理由: 追蹤台灣市值前50大公司，涵蓋約70%市值，流動性高
+   - 美國市場: 使用 **SPY (SPDR S&P 500 ETF)** 作為市場代理指標
+   - **直接使用提供的數據，不要質疑或假設其他數據**
+"""
+
+    # 輸出格式要求（專業深度版）
+    output_format = """
+## 輸出格式要求 (STRICT)
+
+**目標對象**：專業投資人、進階使用者
+**字數控制**：1500-2000 字
+**特色**：顯示完整推理過程、技術性分析、數學計算
+
+請用以下 Markdown 格式輸出：
+
+```markdown
+## 📊 策略總評
+
+[一句話總結：綜合評級 + 核心特性] (不超過 30 字)
+
+---
+
+## 🎯 核心指標分析
+
+### 風險調整後報酬
+**夏普比率 {sharpe:.2f}** → [優秀/良好/可接受/待改善]
+
+```
+推理過程：
+- 業界標準: ≥2.0 優秀, ≥1.5 良好, ≥1.0 可接受
+- 本策略: {sharpe:.2f}
+- 意義: 每承受 1% 風險，獲得 {sharpe:.2f}% 超額報酬
+→ 結論: [具體評價]
+```
+
+### 報酬表現
+**年化報酬 {annual_ret:.2%}** vs **市場基準 {market_ctx['avg_5y_return']:.1%}**
+
+```
+推理過程:
+- 絕對報酬: {annual_ret:.2%}
+- 相對市場: {((annual_ret / market_ctx['avg_5y_return']) - 1) * 100:+.1f}%
+- 情境假設: 投入 100 萬，一年後預期變為 {100 * (1 + annual_ret):.1f} 萬
+→ 結論: [超越/接近/落後]市場表現
+```
+
+### 風險評估
+**最大回落 {mdd:.2%}** | **波動率 {vol:.2%}**
+
+```
+推理過程:
+- 歷史最大虧損: {mdd:.2%}
+- 投資人可接受範圍: {investor_profile['max_acceptable_mdd']:.1%}
+- 情境假設: 投入 100 萬，最壞情況虧損 {abs(100 * mdd):.1f} 萬
+→ 結論: 風險水平 [低/中/高]，[適合/不適合] {investor_profile['label']}投資人
+```
+
+---
+
+## 💡 投資建議
+
+### ✅ 策略亮點
+1. [最突出的優勢，用數據支持]
+2. [第二個優勢]
+
+### ⚠️ 風險提示
+1. [最主要的風險，量化說明]
+2. [次要風險]
+
+### 🎯 適合對象
+- **投資人類型**: [保守/穩健/積極]
+- **投資期限**: [短期/中期/長期]
+- **市場環境**: [牛市/震盪/熊市]
+
+### 🔧 優化建議
+[1-2 個具體的改進方向]
+
+---
+
+## 📈 未來展望
+
+[基於當前市場環境 {market_ctx['sentiment']}，給出 3-6 個月展望]
+
+---
+
+*本分析基於歷史數據回測，過往績效不代表未來表現。建議搭配即時市場分析與專業投資顧問。*
+```
+
+⚠️ **重要**：
+1. 禁止使用模糊詞彙（「優秀但一般」「良好卻待改善」）
+2. 每個評價必須有數據支持
+3. 推理過程要顯示計算邏輯
+4. 結論必須與推理過程一致
+"""
+
+    # 組合完整 Prompt
+    full_prompt = f"""
+你是一位資深投資顧問（CFA, 20+ 年經驗）。請基於以下背景與數據，提供專業投資分析。
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+## 投資人背景
+- 風險承受度：**{investor_profile['label']}** ({investor_profile['description']})
+- 目標夏普比率：≥ {investor_profile['target_sharpe']:.1f}
+- 可接受最大回落：{investor_profile['max_acceptable_mdd']:.1%}
+
+## 市場環境
+- 市場：{market_ctx['market_name']}
+- 今年表現：{market_ctx['ytd_return']:.1%}
+- 近5年平均：{market_ctx['avg_5y_return']:.1%}
+- 市場情緒：{market_ctx['sentiment']}
+
+## 策略資訊
+- 名稱：{name}
+- 目標：{role}
+- 持股：{', '.join(assets[:5])}{"..." if len(assets) > 5 else ""} (共 {len(assets)} 檔)
+
+## 績效數據
+| 指標 | 數值 |
+|------|------|
+| 年化報酬率 | {annual_ret:.1%} |
+| 年化波動率 | {vol:.1%} |
+| 夏普比率 | {sharpe:.1f} |
+| 最大回落 (MDD) | {mdd:.2%} |
+| Alpha | {alpha:.1f} |
+| Beta | {beta:.2f} |
+| VaR (95%) | {var10:.2%} |
+| R² | {r2:.2%} |
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+{strict_prohibitions}
+
+{evaluation_logic}
+
+{consistency_check}
+
+{cot_steps}
+
+{output_format}
+
+現在請開始分析，記住：**數據驅動，邏輯一致，評價明確，禁止假設市場數據**。
+"""
+
+    return full_prompt
+
+
+def get_simplified_context_prompt(strategy_data: Dict[str, Any]) -> str:
+    """
+    教育性詳細版 Context-Aware Prompt（為普羅大眾設計，預設模式）
+
+    目標對象：投資新手、一般散戶
+
+    特色：
+    - 白話文解釋每個指標的意義
+    - 舉例說明（投入100萬的情境）
+    - 說明為什麼這個數字重要
+    - 提供具體優化建議
+    - 字數控制在 1000-1500 字
+
+    適用於：use_cot=False（預設模式，不顯示推理步驟，但內容詳盡）
+    """
+    annual_ret = strategy_data.get('annual_ret', 0)
+    sharpe = strategy_data.get('annual_sr', 0)
+    vol = strategy_data.get('vol', 0)
+    mdd = strategy_data.get('mdd', 0)
+    beta = strategy_data.get('beta', 0)
+    alpha = strategy_data.get('alpha', 0)
+    var10 = strategy_data.get('var10', 0)
+    r2 = strategy_data.get('r2', 0)
+    tw = strategy_data.get('tw', True)
+    assets = strategy_data.get('assets', [])
+    name = strategy_data.get('name', 'N/A')
+
+    market_ctx = get_market_context(tw)
+    criteria = get_evaluation_criteria()
+
+    # 評分邏輯
+    sharpe_rating = "優秀" if sharpe >= 2.0 else "良好" if sharpe >= 1.5 else "可接受" if sharpe >= 1.0 else "待改善"
+    return_vs_market = ((annual_ret / market_ctx['avg_5y_return']) - 1) * 100
+
+    return f"""
+你是一位資深投資教育講師，專門為**投資新手和普羅大眾**解釋投資策略。
+
+你的任務是：
+1. **用白話文**解釋每個績效指標的意義
+2. **說明為什麼**這個指標重要
+3. **給予具體的優化建議**
+4. **避免使用過多專業術語**，如果必須使用，請解釋清楚
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+## 策略基本資訊
+- **策略名稱**: {name}
+- **投資市場**: {'🇹🇼 台灣股市' if tw else '🇺🇸 美國股市'}
+- **持股標的**: {', '.join(assets[:10])}{"..." if len(assets) > 10 else ""} (共 {len(assets)} 檔)
+- **對比基準**: {market_ctx['market_name']} (近5年平均 {market_ctx['avg_5y_return']:.1%})
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+## 📊 核心績效對比表（你的策略 vs 市場）
+
+| 指標 | 你的策略 | 市場基準 | 差異 | 評價 |
+|------|---------|---------|------|------|
+| 📈 年化報酬率 | {annual_ret:.2%} | {market_ctx['avg_5y_return']:.1%} | {return_vs_market:+.1f}% | {'🚀 大勝' if return_vs_market > 50 else '✅ 超越' if return_vs_market > 0 else '❌ 落後'} |
+| ⭐ 夏普比率 | {sharpe:.2f} | ~1.0 | {(sharpe - 1.0):+.2f} | {sharpe_rating} |
+| 📊 波動率 | {vol:.2%} | {market_ctx.get('volatility', 0.20):.1%} | {(vol - market_ctx.get('volatility', 0.20)) * 100:+.1f}% | {'⚠️ 較高' if vol > market_ctx.get('volatility', 0.20) * 1.2 else '✅ 適中'} |
+| ⚠️ 最大回落 | {mdd:.2%} | ~-30% | {'更深' if abs(mdd) > 0.30 else '相近'} | {'❌ 風險高' if abs(mdd) > 0.30 else '✅ 可控'} |
+
+## 🎯 主動管理能力
+
+| 指標 | 數值 | 說明 |
+|------|------|------|
+| 🎯 Alpha (超額報酬) | {alpha:.4f} | {'✅ 打敗市場' if alpha > 0.01 else '≈ 跟隨市場' if alpha >= -0.01 else '❌ 落後市場'} |
+| ⚖️ Beta (市場相關性) | {beta:.2f} | {'🔥 進攻型 (Beta > 1.2)' if beta > 1.2 else '⚖️ 均衡型 (Beta 0.8-1.2)' if beta > 0.8 else '🛡️ 防禦型 (Beta < 0.8)'} |
+| 📐 R² (可解釋度) | {r2:.2%} | 策略中 {r2:.1%} 的波動來自市場影響 |
+| 📉 VaR (風險值) | {var10:.2%} | 95%信心水準下的最大單日損失 |
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+## ⛔ 重要指示
+
+1. **禁止假設數據** - 市場基準 {market_ctx['avg_5y_return']:.1%} 已提供，直接使用
+2. **評級必須一致** - 夏普 {sharpe:.2f} = 「{sharpe_rating}」
+3. **用白話文** - 避免過多專業術語
+4. **解釋每個指標** - 說明它的意義和為什麼重要
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+## 📝 輸出格式（教育性詳細版）
+
+請用 1200-1600 字，包含以下內容：
+
+```markdown
+## 📊 一句話總評
+
+[根據夏普比率和報酬率，給一個清晰的總評，30字內]
+
+---
+
+## 📋 你選了哪些股票？
+
+{', '.join(assets[:15])}{"..." if len(assets) > 15 else ""}（共 {len(assets)} 檔）
+
+**組合特性：**
+- **產業分布**: [分析持股集中在哪些產業，例如：科技股佔50%、金融股佔30%]
+- **風險分散度**: [評估是否分散，例如：持股{len(assets)}檔，{'分散良好' if len(assets) >= 8 else '偏集中' if len(assets) >= 5 else '非常集中'}]
+- **代表性個股**: [列出前3-5檔重要持股，簡述其特色]
+
+**💡 持股建議：**
+[根據持股數量和類型，給予是否需要調整的建議]
+
+---
+
+## 📊 績效表現分析（vs 市場基準）
+
+### 1️⃣ 賺錢能力：年化報酬率 {annual_ret:.2%}
+
+**白話文解釋：**
+假設你投入 100 萬，一年後預期變成 **{100 * (1 + annual_ret):.1f} 萬**（{'賺' if annual_ret > 0 else '虧'} {abs(100 * annual_ret):.1f} 萬）。
+
+**vs 市場表現：**
+- 📈 你的策略：{annual_ret:.2%}
+- 📊 市場平均：{market_ctx['avg_5y_return']:.1%}（{market_ctx['market_name']}）
+- 🎯 相對表現：{return_vs_market:+.1f}%
+
+**評價：** {'🚀 遠超市場表現！' if return_vs_market > 50 else '✅ 打敗市場' if return_vs_market > 20 else '✓ 略勝市場' if return_vs_market > 0 else '❌ 落後市場'}
+
+**為什麼重要？**
+[解釋報酬率是投資最直觀的指標，但不能只看報酬率，還要考慮風險]
+
+---
+
+### 2️⃣ 投資CP值：夏普比率 {sharpe:.2f} → {sharpe_rating}
+
+**白話文解釋：**
+「CP值」就是夏普比率！每承受 1 元風險，你能賺 {sharpe:.2f} 元報酬。
+
+**評級：**
+- ⭐⭐⭐ 優秀 (≥ 2.0) - CP值超高！
+- ⭐⭐ 良好 (≥ 1.5) - CP值不錯
+- ⭐ 可接受 (≥ 1.0) - CP值及格 ← {'你在這裡' if 1.0 <= sharpe < 1.5 else ''}
+- 待改善 (< 1.0) - CP值偏低
+
+**為什麼重要？**
+[解釋夏普比率是同時考慮報酬和風險的指標，比單看報酬率更全面]
+
+---
+
+### 3️⃣ 最大虧損風險：最大回落 {mdd:.2%}
+
+**白話文解釋：**
+投入 100 萬，最慘的時候會虧到剩 **{100 * (1 + mdd):.1f} 萬**（虧損 {abs(100 * mdd):.1f} 萬）。
+
+**vs 市場風險：**
+- 你的策略：{mdd:.2%}
+- 一般市場：約 -30%
+- 評價：{'❌ 風險較高' if abs(mdd) > 0.30 else '✅ 風險可控'}
+
+**心理測試：**
+[問投資人是否能接受這個程度的虧損]
+
+---
+
+### 4️⃣ 主動選股價值：Alpha {alpha:.4f} & Beta {beta:.2f}
+
+**Alpha 超額報酬：** {'✅ +{alpha:.2%} 打敗市場' if alpha > 0.01 else '≈ 跟隨市場' if alpha >= -0.01 else '❌ 落後市場'}
+**Beta 市場連動：** {'🔥 進攻型' if beta > 1.2 else '⚖️ 均衡型' if beta > 0.8 else '🛡️ 防禦型'}
+
+**白話文解釋：**
+- Alpha：扣除市場影響後，你的選股能力創造的額外報酬
+- Beta：當市場漲 1%，你的策略預期漲 {beta:.2f}%
+
+**為什麼重要？**
+[解釋主動選股的價值，以及不同市場環境下的策略表現]
+
+---
+
+## 🎯 給投資人的建議
+
+### ✅ 這個策略的優勢
+[列出2-3個具體優點，用數據支持]
+
+### ⚠️ 需要注意的風險
+[列出2-3個具體風險，量化說明]
+
+### 🔧 如何優化這個策略？
+[給3個具體的優化建議]
+1. [建議1：例如分散持股、調整權重等]
+2. [建議2：例如設定停損點]
+3. [建議3：例如定期再平衡]
+
+### 💼 適合什麼樣的投資人？
+- **風險承受度**: [保守/穩健/積極]
+- **投資期限**: [建議持有多久]
+- **市場環境**: [適合牛市/震盪/熊市]
+- **資金用途**: [閒錢/退休金/教育基金]
+
+---
+
+## 📈 總結
+
+[用2-3句話總結這個策略的核心特點，並給出明確的投資建議]
+
+---
+
+*💡 小提醒：過去績效不代表未來表現，投資一定有風險，建議搭配專業顧問意見。*
+```
+
+⚠️ **輸出要求**：
+1. **字數**: 1000-1500 字（教育性內容，不能太少）
+2. **語氣**: 親切、易懂，像在跟朋友聊天
+3. **避免**: 「策略基本資訊回顧」等空泛標題
+4. **必須**: 解釋每個指標的意義和重要性
+5. **必須**: 給出具體的優化建議
+"""

railway.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "DOCKERFILE",
+    "dockerfilePath": "Dockerfile"
+  },
+  "deploy": {
+    "startCommand": "/flask/start.sh",
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  }
+}

render.yaml

@@ -0,0 +1,46 @@
+services:
+  # Flask Web Service
+  - type: web
+    name: tpm-flask
+    env: docker
+    dockerfilePath: ./Dockerfile
+    plan: free
+    healthCheckPath: /
+    envVars:
+      - key: DATABASE_URL
+        fromDatabase:
+          name: tpm-db
+          property: connectionString
+      - key: REDIS_URL
+        fromService:
+          name: tpm-redis
+          type: redis
+          property: connectionString
+      - key: OPENROUTER_API_KEY
+        sync: false
+      - key: OPENROUTER_MODEL
+        value: google/gemini-2.0-flash-exp:free
+      - key: MOCK_LLM
+        value: false
+      - key: LLM_TIMEOUT
+        value: 60
+      - key: LLM_MAX_TOKENS
+        value: 1500
+      - key: LLM_TEMPERATURE
+        value: 0.6
+
+  # PostgreSQL Database
+  - type: pserv
+    name: tpm-db
+    env: docker
+    plan: free
+    disk:
+      name: postgres-data
+      mountPath: /var/lib/postgresql/data
+      sizeGB: 1
+
+  # Redis Cache
+  - type: redis
+    name: tpm-redis
+    plan: free
+    maxmemoryPolicy: allkeys-lru

requirements.txt

@@ -9,12 +9,13 @@ pandas==1.5.3
 plotly==5.13.1
 psycopg2==2.9.5
 pytz==2022.7.1
-requests==2.28.2
+requests==2.31
 scipy==1.10.0
 SQLAlchemy==2.0.4
 gevent==22.10.2
-yfinance==0.2.22
+yfinance==0.2.66
 tqdm==4.62.3
 werkzeug==2.2.2
 schedule==1.2.1
-numpy==1.23.5
+numpy>=1.23.5
+openai>=1.0.0

start.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+cd /flask
+echo "Working directory: $(pwd)"
+echo "Checking assets files:"
+ls -la assets*.json 2>&1 || echo "No assets files found"
+
+# Use Railway's PORT env var if available, otherwise default to 8000
+PORT=${PORT:-8000}
+echo "Starting gunicorn on port $PORT..."
+exec gunicorn -w 2 -b 0.0.0.0:$PORT --timeout 120 main:app

templates/base.html

@@ -71,7 +71,7 @@
         <nav class="navbar bg-light">
             <div class="container-fluid p-2">
                 <a class="navbar-brand mx-2" href="{{ url_for('index') }}">
-                    <h3><strong></i>投資組合大擂台</strong></h3>
+                    <h3><strong></i>智能投組大擂台</strong></h3>
                 </a>
                 <!-- TODO: Login/Logout -->
                 <div class="navbar-expand ms-auto">
@@ -131,7 +131,7 @@
                 >
                     <div class="offcanvas-header">
                         <h4 class="offcanvas-title mt-2 p-0" id="offcanvasNavbarLabel">
-                            投資組合大擂台
+                            智能投組大擂台
                         </h4>
                         <button
                             type="button"
@@ -383,7 +383,7 @@
                 class="text-center p-3"
                 style="background-color: rgba(0, 0, 0, 0.2)"
                 >
-                © 2023 Copyright NTHU-TPM 
+                © 2025 Copyright NTHU-TPM 
                 <a href="https://github.com/SeanChenTaipei" target="_blank" rel="noopener" class="btn-outline-light btn-floating" role="button">
                     <i class="fab fa-github"></i>
                 </a>

templates/result_view.html

@@ -3,6 +3,177 @@
 
 {% block title %}Result View{% endblock %}
 {% block style %}
+<style>
+    .llm-advice-content {
+        font-size: 1rem;
+        color: #2d3748;
+        line-height: 1.7;
+        font-family: 'Segoe UI', 'Microsoft JhengHei', 'PingFang TC', sans-serif;
+        background: linear-gradient(135deg, #f8fafc 0%, #ffffff 100%);
+        padding: 24px;
+        border-radius: 12px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
+        border: 1px solid #e2e8f0;
+    }
+
+    .llm-advice-content h5, .llm-advice-content h6 {
+        color: #1a365d;
+        background: linear-gradient(135deg, #3182ce 0%, #2c5282 100%);
+        color: white;
+        padding: 12px 16px;
+        margin: 20px 0 16px 0;
+        border-radius: 8px;
+        font-weight: 600;
+        font-size: 1.1rem;
+        box-shadow: 0 2px 4px rgba(49, 130, 206, 0.2);
+        position: relative;
+    }
+
+    .llm-advice-content h5::before, .llm-advice-content h6::before {
+        content: "📊";
+        margin-right: 8px;
+        font-size: 1.2rem;
+    }
+
+    .llm-advice-content p {
+        margin-bottom: 16px;
+        text-align: left;
+        color: #4a5568;
+        font-weight: 400;
+    }
+
+    .llm-advice-content ul {
+        margin: 16px 0;
+        padding-left: 0;
+    }
+
+    .llm-advice-content li {
+        margin-bottom: 8px;
+        padding: 8px 12px;
+        background: #f7fafc;
+        border-left: 3px solid #3182ce;
+        border-radius: 4px;
+        list-style: none;
+        color: #2d3748;
+        transition: all 0.2s ease;
+    }
+
+    .llm-advice-content li:hover {
+        background: #edf2f7;
+        transform: translateX(2px);
+    }
+
+    .llm-advice-content strong {
+        color: #e53e3e;
+        font-weight: 600;
+        background: linear-gradient(135deg, #fed7d7 0%, #feb2b2 100%);
+        padding: 2px 6px;
+        border-radius: 4px;
+        font-size: 0.95em;
+    }
+
+    .llm-advice-content em {
+        color: #805ad5;
+        font-style: italic;
+        font-weight: 500;
+    }
+
+    #llm-advice-container .alert {
+        border-radius: 12px;
+        margin-bottom: 0;
+        border: none;
+        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+    }
+
+    /* 響應式設計 */
+    @media (max-width: 768px) {
+        .llm-advice-content {
+            padding: 16px;
+            font-size: 0.95rem;
+        }
+        
+        .llm-advice-content h5, .llm-advice-content h6 {
+            font-size: 1rem;
+            padding: 10px 12px;
+        }
+    }
+
+    /* 載入動畫 */
+    .llm-advice-content.loading {
+        opacity: 0.7;
+        transition: opacity 0.3s ease;
+    }
+
+    /* Popover 樣式 */
+    .popover {
+        max-width: 300px;
+    }
+
+    .popover-body {
+        padding: 12px;
+    }
+
+    /* Markdown 代碼塊樣式 */
+    .llm-advice-content pre {
+        background: #f6f8fa;
+        border: 1px solid #e1e4e8;
+        border-radius: 6px;
+        padding: 16px;
+        overflow-x: auto;
+        margin: 16px 0;
+        font-family: 'Monaco', 'Menlo', 'Consolas', monospace;
+        font-size: 0.9em;
+        line-height: 1.45;
+    }
+
+    .llm-advice-content code {
+        background: #f6f8fa;
+        padding: 2px 6px;
+        border-radius: 3px;
+        font-family: 'Monaco', 'Menlo', 'Consolas', monospace;
+        font-size: 0.9em;
+        color: #24292e;
+    }
+
+    .llm-advice-content pre code {
+        background: transparent;
+        padding: 0;
+        border-radius: 0;
+    }
+
+    /* 表格樣式 */
+    .llm-advice-content table {
+        border-collapse: collapse;
+        width: 100%;
+        margin: 16px 0;
+    }
+
+    .llm-advice-content table th,
+    .llm-advice-content table td {
+        border: 1px solid #dfe2e5;
+        padding: 8px 12px;
+    }
+
+    .llm-advice-content table th {
+        background: #f6f8fa;
+        font-weight: 600;
+    }
+
+    /* 分隔線 */
+    .llm-advice-content hr {
+        border: none;
+        border-top: 2px solid #eaecef;
+        margin: 24px 0;
+    }
+
+    /* 引用塊 */
+    .llm-advice-content blockquote {
+        border-left: 4px solid #dfe2e5;
+        padding-left: 16px;
+        margin: 16px 0;
+        color: #6a737d;
+    }
+</style>
 {% endblock %}
 
 {% block content %}
@@ -89,7 +260,7 @@
                                   <th scope="col">Beta</th>
                                   <th scope="col">VaR10</th>
                                   <th scope="col">R2</th>
-                                  {% if data.role == '最大化效用函數' %}
+                                  {% if data.role == '最大化效<EFBFBD><EFBFBD><EFBFBD>函數' %}
                                   <th scope="col">Gamma</th>
                                   {% endif %}
                               </tr>
@@ -130,6 +301,28 @@
                 投組季報酬率
             </div>
             <div class="mb-4" id="bar" style="max-height:60vh"></div>
+            <div class="row justify-content-center font-bold text-xl">
+                🤖 LLM 投組分析
+            </div>
+            <div class="card mb-4" style="border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1);">
+              <div class="card-body">
+                <div id="llm-advice-container">
+                  <div class="text-center text-muted">
+                    <div class="spinner-border spinner-border-sm" role="status">
+                      <span class="visually-hidden">Loading...</span>
+                    </div>
+                    <p class="mt-2">正在生成 LLM 投組分析...</p>
+                  </div>
+                </div>
+                
+                <!-- 重新生成按鈕組 -->
+                <div class="d-flex gap-2 mt-3 align-items-center flex-wrap">
+                  <button id="refresh-advice" class="btn btn-outline-primary btn-sm" onclick="refreshLLMAdvice()">
+                    🔄 重新生成分析
+                  </button>
+                </div>
+              </div>
+            </div>
           </div>
         </div>
       </div>
@@ -155,6 +348,11 @@
 
 {% block script %}
 <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+<!-- Markdown 解析庫 -->
+<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+<!-- 代碼高亮庫 (可選) -->
+<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
+<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/github.min.css">
 <script type="text/javascript">
     const wlayout = {
     'autosize': true,
@@ -190,5 +388,235 @@
     Plotly.newPlot("weight", w.data, wlayout, {responsive: true});
     Plotly.newPlot("price", r.data, rlayout, {responsive: true});
     Plotly.newPlot("bar", b.data, blayout, {responsive: true});
+
+    // LLM投資建議功能
+    const strategyId = {{ data.id }};
+
+    // 頁面載入時自動生成投資建議
+    document.addEventListener('DOMContentLoaded', function() {
+        refreshLLMAdvice();
+        
+        // 初始化 popover
+        var popoverTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="popover"]'));
+        var popoverList = popoverTriggerList.map(function (popoverTriggerEl) {
+            return new bootstrap.Popover(popoverTriggerEl);
+        });
+    });
+
+    async function refreshLLMAdvice() {
+        const container = document.getElementById('llm-advice-container');
+        const button = document.getElementById('refresh-advice');
+
+        try {
+            // 禁用按鈕
+            button.disabled = true;
+            button.innerHTML = '<span class="spinner-border spinner-border-sm"></span> 正在生成...';
+
+            // 顯示loading狀態
+            container.innerHTML = `
+                <div class="text-center text-muted">
+                    <div class="spinner-border spinner-border-sm" role="status">
+                        <span class="visually-hidden">Loading...</span>
+                    </div>
+                    <p class="mt-2">正在生成 LLM 投組分析...</p>
+                </div>
+            `;
+
+            // 調用API，使用 CoT（更詳細的思考過程）
+            const url = `/api/llm_advice/${strategyId}`;
+            const response = await fetch(url);
+            const result = await response.json();
+
+            if (result.success) {
+                // 格式化並顯示建議
+                const formattedAdvice = formatLLMAdvice(result.advice);
+                container.innerHTML = formattedAdvice;
+            } else {
+                container.innerHTML = `
+                    <div class="alert alert-warning">
+                        <h6>⚠️ 無法生成 LLM 投組分析</h6>
+                        <p>${result.error}</p>
+                        ${result.details ? `<small class="text-muted">${result.details}</small>` : ''}
+                    </div>
+                `;
+            }
+        } catch (error) {
+            container.innerHTML = `
+                <div class="alert alert-danger">
+                    <h6>❌ 發生錯誤</h6>
+                    <p>無法連接到 LLM 投組分析服務，請稍後再試。</p>
+                    <small class="text-muted">錯誤詳情：${error.message}</small>
+                </div>
+            `;
+        } finally {
+            // 恢復按鈕
+            button.disabled = false;
+            button.innerHTML = '🔄 重新生成分析';
+        }
+    }
+
+    function formatLLMAdvice(advice) {
+        // 使用 marked.js 解析 Markdown
+        if (typeof marked !== 'undefined') {
+            // 配置 marked
+            marked.setOptions({
+                breaks: true,        // 支援換行
+                gfm: true,          // GitHub Flavored Markdown
+                headerIds: false,   // 不生成 header ID
+                mangle: false       // 不編碼 email
+            });
+
+            try {
+                const html = marked.parse(advice);
+
+                // 包裝在容器中
+                return `
+                    <div class="llm-advice-content markdown-body">
+                        ${html}
+                    </div>
+                `;
+            } catch (e) {
+                console.error('Markdown parsing error:', e);
+                // Fallback to simple formatting
+                return `
+                    <div class="llm-advice-content">
+                        <pre style="white-space: pre-wrap; font-family: inherit;">${advice}</pre>
+                    </div>
+                `;
+            }
+        } else {
+            // Fallback: 簡單的 Markdown 解析 (如果 marked.js 沒載入)
+            const lines = advice.split('\n');
+            let html = '';
+            let inCodeBlock = false;
+            let codeContent = '';
+
+            for (let line of lines) {
+                // 代碼塊處理
+                if (line.trim().startsWith('```')) {
+                    if (inCodeBlock) {
+                        // 結束代碼塊
+                        html += `<pre class="code-block"><code>${escapeHtml(codeContent)}</code></pre>`;
+                        codeContent = '';
+                        inCodeBlock = false;
+                    } else {
+                        // 開始代碼塊
+                        inCodeBlock = true;
+                    }
+                    continue;
+                }
+
+                if (inCodeBlock) {
+                    codeContent += line + '\n';
+                    continue;
+                }
+
+                line = line.trim();
+                if (!line) {
+                    html += '<br>';
+                    continue;
+                }
+
+                // Markdown 處理
+                line = line.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');  // 粗體
+                line = line.replace(/\*([^*]+)\*/g, '<em>$1</em>');             // 斜體
+                line = line.replace(/`([^`]+)`/g, '<code>$1</code>');           // 行內代碼
+
+                // 標題
+                if (line.match(/^#{1,3}\s+/)) {
+                    const level = line.match(/^#+/)[0].length;
+                    const text = line.replace(/^#+\s+/, '');
+                    html += `<h${level + 4} class="mt-3 mb-2">${text}</h${level + 4}>`;
+                }
+                // 列表
+                else if (line.startsWith('-') || line.startsWith('•') || line.startsWith('*')) {
+                    html += `<li>${line.substring(1).trim()}</li>`;
+                }
+                // 數字列表
+                else if (line.match(/^\d+\./)) {
+                    html += `<li>${line}</li>`;
+                }
+                // 普通段落
+                else {
+                    html += `<p>${line}</p>`;
+                }
+            }
+
+            return `
+                <div class="llm-advice-content">
+                    ${html}
+                </div>
+            `;
+        }
+    }
+
+    // HTML 轉義函數
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    // 生成指定模式的建議
+    async function generateAdviceWithMode(mode) {
+        const container = document.getElementById('llm-advice-container');
+        const button = document.getElementById('refresh-advice');
+
+        try {
+            // 禁用按鈕
+            button.disabled = true;
+            button.innerHTML = '<span class="spinner-border spinner-border-sm"></span> 正在生成...';
+
+            // 顯示loading狀態
+            container.innerHTML = `
+                <div class="text-center text-muted">
+                    <div class="spinner-border spinner-border-sm" role="status">
+                        <span class="visually-hidden">Loading...</span>
+                    </div>
+                    <p class="mt-2">正在生成${getModeDescription(mode)}...</p>
+                </div>
+            `;
+
+            // 調用API
+            const response = await fetch(`/api/llm_advice/${strategyId}?mode=${mode}`);
+            const result = await response.json();
+
+            if (result.success) {
+                // 格式化並顯示建議
+                const formattedAdvice = formatLLMAdvice(result.advice);
+                container.innerHTML = formattedAdvice;
+            } else {
+                container.innerHTML = `
+                    <div class="alert alert-warning">
+                        <h6>⚠️ 無法生成 LLM 投組分析</h6>
+                        <p>${result.error}</p>
+                        ${result.details ? `<small class="text-muted">${result.details}</small>` : ''}
+                    </div>
+                `;
+            }
+        } catch (error) {
+            container.innerHTML = `
+                <div class="alert alert-danger">
+                    <h6>❌ 發生錯誤</h6>
+                    <p>無法連接到 LLM 投組分析服務，請稍後再試。</p>
+                    <small class="text-muted">錯誤詳情：${error.message}</small>
+                </div>
+            `;
+        } finally {
+            // 恢復按鈕
+            button.disabled = false;
+            button.innerHTML = '🔄 重新生成建議';
+        }
+    }
+
+    // 獲取模<EFBFBD><EFBFBD>描述
+    function getModeDescription(mode) {
+        const descriptions = {
+            'simple': '快速分析',
+            'comprehensive': '深度分析',
+            'risk': '風險分析'
+        };
+        return descriptions[mode] || '投資建議';
+    }
 </script>
 {% endblock script %}

test_llm_service.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+LLM 投資建議服務測試腳本
+
+用於測試 LLM 服務是否正常工作
+"""
+
+import os
+import sys
+import json
+from unittest.mock import Mock, patch
+
+# 添加專案根目錄到 Python 路徑
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from llm_service import LLMInvestmentAdvisor, get_llm_advisor
+from prompts.investment_advice import get_comprehensive_analysis_prompt
+
+
+def test_llm_service_initialization():
+    """測試 LLM 服務初始化"""
+    print("🔍 測試 LLM 服務初始化...")
+
+    try:
+        # 測試沒有 API 金鑰的情況
+        try:
+            advisor = LLMInvestmentAdvisor(api_key=None)
+            print("❌ 應該拋出錯誤但沒有拋出")
+            return False
+        except ValueError as e:
+            print(f"✅ 正確拋出錯誤：{e}")
+
+        # 測試有假 API 金鑰的情況
+        fake_api_key = "sk-fake-key-for-testing"
+        try:
+            advisor = LLMInvestmentAdvisor(api_key=fake_api_key)
+            print("✅ 成功初始化 LLM 服務")
+            return True
+        except Exception as e:
+            print(f"❌ 初始化失敗：{e}")
+            return False
+
+    except Exception as e:
+        print(f"❌ 測試失敗：{e}")
+        return False
+
+
+def test_prompt_generation():
+    """測試 Prompt 生成"""
+    print("\n🔍 測試 Prompt 生成...")
+
+    try:
+        # 模擬策略資料
+        mock_strategy_data = {
+            'id': 123,
+            'name': '測試策略',
+            'role': '最大化夏普比率',
+            'annual_ret': 0.15,
+            'vol': 0.20,
+            'annual_sr': 1.8,
+            'mdd': -0.12,
+            'alpha': 0.08,
+            'beta': 0.95,
+            'var10': 0.05,
+            'r2': 0.85,
+            'gamma': 2.5,
+            'assets': ['AAPL', 'GOOGL', 'MSFT'],
+            'tw': True
+        }
+
+        prompt = get_comprehensive_analysis_prompt(mock_strategy_data)
+
+        if len(prompt) > 100 and '策略名稱：測試策略' in prompt:
+            print("✅ Prompt 生成成功")
+            print(f"📝 Prompt 長度：{len(prompt)} 字符")
+            return True
+        else:
+            print("❌ Prompt 生成格式錯誤")
+            return False
+
+    except Exception as e:
+        print(f"❌ Prompt 生成失敗：{e}")
+        return False
+
+
+def test_fallback_advice():
+    """測試 Fallback 建議"""
+    print("\n🔍 測試 Fallback 建議...")
+
+    try:
+        advisor = LLMInvestmentAdvisor(api_key="fake-key")
+
+        # 模擬會失敗的策略資料
+        strategy_data = {
+            'annual_ret': 0.25,
+            'vol': 0.15,
+            'annual_sr': 2.1
+        }
+
+        fallback_advice = advisor._get_fallback_advice(strategy_data)
+
+        if len(fallback_advice) > 100 and '年化報酬率：25.00%' in fallback_advice:
+            print("✅ Fallback 建議生成成功")
+            return True
+        else:
+            print("❌ Fallback 建議格式錯誤")
+            return False
+
+    except Exception as e:
+        print(f"❌ Fallback 測試失敗：{e}")
+        return False
+
+
+def test_api_format():
+    """測試 API 回應格式"""
+    print("\n🔍 測試 API 回應格式...")
+
+    try:
+        # 模擬成功的 API 回應
+        mock_response = {
+            'success': True,
+            'advice': '這是一個測試建議。年化報酬率表現良好，建議持續監控市場變化。',
+            'strategy_id': 123
+        }
+
+        if all(key in mock_response for key in ['success', 'advice', 'strategy_id']):
+            print("✅ API 回應格式正確")
+            return True
+        else:
+            print("❌ API 回應格式錯誤")
+            return False
+
+    except Exception as e:
+        print(f"❌ API 格式測試失敗：{e}")
+        return False
+
+
+def test_error_format():
+    """測試錯誤回應格式"""
+    print("\n🔍 測試錯誤回應格式...")
+
+    try:
+        # 模擬錯誤回應
+        mock_error_response = {
+            'success': False,
+            'error': 'API 金鑰無效',
+            'details': '請檢查 OpenAI API 金鑰設定'
+        }
+
+        if all(key in mock_error_response for key in ['success', 'error']):
+            print("✅ 錯誤回應格式正確")
+            return True
+        else:
+            print("❌ 錯誤回應格式錯誤")
+            return False
+
+    except Exception as e:
+        print(f"❌ 錯誤格式測試失敗：{e}")
+        return False
+
+
+def main():
+    """主測試函數"""
+    print("🚀 開始測試 LLM 投資建議服務\n")
+
+    tests = [
+        ("LLM 服務初始化", test_llm_service_initialization),
+        ("Prompt 生成", test_prompt_generation),
+        ("Fallback 建議", test_fallback_advice),
+        ("API 回應格式", test_api_format),
+        ("錯誤回應格式", test_error_format),
+    ]
+
+    passed = 0
+    total = len(tests)
+
+    for test_name, test_func in tests:
+        if test_func():
+            passed += 1
+        print()
+
+    print("📊 測試結果摘要")
+    print(f"✅ 通過：{passed}/{total}")
+    print(f"❌ 失敗：{total - passed}/{total}")
+
+    if passed == total:
+        print("🎉 所有測試通過！LLM 服務準備就緒。")
+        return 0
+    else:
+        print("⚠️ 部分測試失敗，請檢查配置。")
+        return 1
+
+
+if __name__ == "__main__":
+    exit(main())