.dockerignore

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

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

.gitignore

@@ -3,23 +3,9 @@
 __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

@@ -1,148 +0,0 @@
-#!/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

@@ -1,116 +0,0 @@
-# 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 -w 2 -b 0.0.0.0:$PORT --timeout 120 --chdir /flask main:app
+web: gunicorn main:app --preload --workers 28 --timeout 120

README.md

@@ -1,74 +0,0 @@
-### 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,51 +1,26 @@
 import os
 import time
 from datetime import datetime, date, timedelta
-from urllib.parse import urlparse
-
 # PARAMETERS
 CONFIGS = {
-    "SECRET_KEY": os.environ.get("SECRET_KEY", os.urandom(30).hex()), # Set the secret key for session authentication
+    "SECRET_KEY": os.urandom(30), # Set the secret key for session authentication
     "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

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

@@ -1,60 +0,0 @@
-### 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="localhost",
+        host="db",
         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,13 +16,8 @@ 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-01-01", progress=False, threads=False)
+    df = yf.download(ticker, start="2007-1-1", progress=False)
-    if df is None or df.empty:
+    value =[(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
-        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,27 +3,21 @@ 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_us = json.load(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)
 cursor = conn.cursor()
 cursor.execute("TRUNCATE TABLE stock_price")
 print("US stock price cleared")
-for ticker in tqdm(data_us):
+for ticker in tqdm(data_tw):
-    df = yf.download(ticker, start="2007-01-01", progress=False, threads=False)
+    df = yf.download(ticker, start="2007-1-1", progress=False)
-    if df is None or df.empty:
+    value =[(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
-        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,39 +5,22 @@ import numpy as np
 import psycopg2
 from psycopg2.extras import execute_values
 from tqdm import tqdm
-from config import SQL_CONFIG
+with open('/flask/data_init/assets_tw.json') as f:
-import os
-
-with open('data_init/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')
+
+
 # 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-01-01", progress=False, threads=False)
+        df = yf.download(ticker, start="2007-1-1", progress=False)
-        if df is None or df.empty:
+        value =[(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
-            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_init_us_v0.py

@@ -5,27 +5,21 @@ import numpy as np
 import psycopg2
 from psycopg2.extras import execute_values
 from tqdm import tqdm
-from config import SQL_CONFIG
+with open('/flask/data_init/assets_us.json') as f:
+    data_tw = json.load(f)
 
-with open('data_init/assets_us.json') as f:
+#SQL　setting
-    data_us = json.load(f)
+SQL_CONFIG = dict(database="portfolio_platform", user='postgres', password='thiispassword1qaz!QAZ', host='db',port ='5432')
 
-# US Stocks
+# TW 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_us):
+    for ticker in tqdm(data_tw):
-        df = yf.download(ticker, start="2007-01-01", progress=False, threads=False)
+        df = yf.download(ticker, start="2007-1-1", progress=False)
-        if df is None or df.empty:
+        value =[(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
-            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.31
+requests==2.28.2
 SQLAlchemy==2.0.4
-yfinance==0.2.66
+yfinance==0.2.22
 tqdm==4.62.3
 schedule==1.2.1
 numpy==1.23.5

data_init/update_data_daily.py

@@ -11,34 +11,11 @@ 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()]
@@ -50,13 +27,8 @@ 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, threads=False)
+                             end=datetime.date.today().strftime('%Y-%m-%d'), progress=False)
-            if df is None or df.empty:
+            value = [(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
-                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"
@@ -67,13 +39,6 @@ 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()]
@@ -85,21 +50,13 @@ 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, threads=False)
+                             end=datetime.date.today().strftime('%Y-%m-%d'), progress=False)
-            if df is None or df.empty:
+            value = [(ticker, df.index[i], df['Close'][i]) for i in range(len(df))]
-                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)

docker-compose.yml

@@ -12,16 +12,13 @@ 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:
-            - redis-data:/data
+            - /data/redis-data:/data
         networks:
             - common_network
     flask_init:
@@ -36,18 +33,6 @@ 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:
@@ -78,7 +63,7 @@ volumes:
     db-data:
     flask-data: #    pgadmin-data:
     db_data_new:
-    redis-data:
 networks:
     common_network:
-        driver: bridge
+        external:
+            name: common_network

init_railway_db.py

@@ -1,51 +0,0 @@
-#!/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

@@ -1,418 +0,0 @@
-"""
-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,7 +15,6 @@ import random
 import string
 import logging
 import numpy as np
-logger = logging.getLogger(__name__)
 import pandas as pd
 import psycopg2
 import psycopg2.extras
@@ -23,65 +22,22 @@ 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
+
-logging.basicConfig(
+# Load Assets
-    stream=sys.stdout,
+with open('assets_tw.json') as f:
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-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")
+with open('assets_us.json') as f:
-        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:
@@ -247,7 +203,6 @@ 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'])
 
@@ -262,7 +217,6 @@ 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'])
 
@@ -415,10 +369,6 @@ 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'))
@@ -441,7 +391,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.get(role, role)
+    info['role'] = role_map[role]
     info['id']='Custom data'
     info['name']='Custom data'
     info['date'] = '-'
@@ -542,10 +492,6 @@ 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:
@@ -553,15 +499,9 @@ 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.get(data['role'], data['role'])
+    data['role'] = role_map[data['role']]
     w = data['weight']
     r = data['ret']
     w = pd.DataFrame(w['data'], columns=w['columns'], index=w['index'])
@@ -584,67 +524,6 @@ 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():
@@ -654,7 +533,6 @@ 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

@@ -1,259 +0,0 @@
-"""
-市場基準資料模組
-
-從資料庫取得實際的市場基準資料（台股加權指數、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

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

@@ -1,160 +0,0 @@
-"""
-投資建議相關的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

@@ -1,630 +0,0 @@
-"""
-投資建議 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

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

render.yaml

@@ -1,46 +0,0 @@
-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,13 +9,12 @@ pandas==1.5.3
 plotly==5.13.1
 psycopg2==2.9.5
 pytz==2022.7.1
-requests==2.31
+requests==2.28.2
 scipy==1.10.0
 SQLAlchemy==2.0.4
 gevent==22.10.2
-yfinance==0.2.66
+yfinance==0.2.22
 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

@@ -1,10 +0,0 @@
-#!/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)"
                 >
-                © 2025 Copyright NTHU-TPM 
+                © 2023 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,177 +3,6 @@
 
 {% 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 %}
@@ -260,7 +89,7 @@
                                   <th scope="col">Beta</th>
                                   <th scope="col">VaR10</th>
                                   <th scope="col">R2</th>
-                                  {% if data.role == '最大化效<EFBFBD><EFBFBD><EFBFBD>函數' %}
+                                  {% if data.role == '最大化效用函數' %}
                                   <th scope="col">Gamma</th>
                                   {% endif %}
                               </tr>
@@ -301,28 +130,6 @@
                 投組季報酬率
             </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>
@@ -348,11 +155,6 @@
 
 {% 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,
@@ -388,235 +190,5 @@
     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

@@ -1,195 +0,0 @@
-#!/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())