diff --git a/.env.example b/.env.example
index 5529c41..bfeeb47 100644
--- a/.env.example
+++ b/.env.example
@@ -15,6 +15,8 @@ DEEPSEEK_API_KEY=your_actual_deepseek_api_key_here
 # DeepSeek API基础URL（可选，使用默认值即可）
 DEEPSEEK_BASE_URL=https://api.deepseek.com/v1
 
+# DeepSeek 模型名称，为空时取默认值 deepseek-chat
+DEEPSEEK_MODEL_NAME=deepseek-chat
 
 # ========== Tushare数据接口（可选）==========
 # Tushare Token（可选，用于获取更多金融数据）
diff --git a/.gitignore b/.gitignore
index 1dfa6a0..98fb92c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,22 @@
 .env
 /.cursor
 /openspec
-TradEnv/
\ No newline at end of file
+TradEnv/
+/.idea/inspectionProfiles/profiles_settings.xml
+/.idea/inspectionProfiles/Project_Default.xml
+/.idea/.gitignore
+/.idea/aiagents-stock.iml
+/.idea/misc.xml
+/.idea/modules.xml
+/.idea/vcs.xml
+/data/longhubang.db
+/data/low_price_bull_monitor.db
+/data/main_force_batch.db
+/data/portfolio_stocks.db
+/data/profit_growth_monitor.db
+/data/sector_strategy.db
+/data/smart_monitor.db
+/data/stock_analysis.db
+/data/stock_monitor.db
+/migrate_databases.sh
+/migrate_databases_by_size.sh
diff --git "a/AI\346\250\241\345\236\213\351\200\211\346\213\251\350\257\264\346\230\216.md" "b/AI\346\250\241\345\236\213\351\200\211\346\213\251\350\257\264\346\230\216.md"
new file mode 100644
index 0000000..ccd0e32
--- /dev/null
+++ "b/AI\346\250\241\345\236\213\351\200\211\346\213\251\350\257\264\346\230\216.md"
@@ -0,0 +1,258 @@
+# AI模型选择机制说明
+
+## 📋 问题回答
+
+### 1. 左侧的AI模型选择会全局默认生效吗？
+
+**答案：部分生效，但不完全全局**
+
+**当前状态**：
+- ✅ 模型选择器会保存到 `st.session_state.selected_model`
+- ❌ 但很多功能模块**强制使用** `config.DEEPSEEK_MODEL_NAME`（从 `.env` 文件读取），**忽略**了 `session_state` 中的选择
+- ✅ 只有部分页面（如"主力选股"）会使用页面内的模型选择
+
+**具体表现**：
+- **股票分析页面**：强制使用 `config.DEEPSEEK_MODEL_NAME`，忽略侧边栏选择
+- **批量分析功能**：强制使用 `config.DEEPSEEK_MODEL_NAME`，忽略侧边栏选择
+- **主力选股页面**：使用页面内的模型选择（不是侧边栏的）
+- **智策板块页面**：强制使用 `config.DEEPSEEK_MODEL_NAME`
+
+### 2. 如果选择其他模型，模型信息在哪里配置？
+
+**答案：两个地方**
+
+#### 位置1：模型选项列表 - `model_config.py`
+
+**文件路径**：`model_config.py`
+
+**作用**：定义所有可用的AI模型选项
+
+**内容示例**：
+```python
+model_options = {
+    "deepseek-chat": "DeepSeek Chat (默认)",
+    "deepseek-reasoner": "DeepSeek Reasoner (推理增强)",
+    "qwen-plus": "qwen-plus (阿里百炼)",
+    # ... 更多模型
+}
+```
+
+**如何添加新模型**：
+1. 在 `model_config.py` 的 `model_options` 字典中添加新项
+2. 格式：`"模型ID": "显示名称"`
+
+#### 位置2：默认模型配置 - `.env` 文件
+
+**文件路径**：`.env`（项目根目录）
+
+**作用**：设置系统默认使用的模型
+
+**配置项**：
+```bash
+DEEPSEEK_MODEL_NAME=deepseek-chat
+```
+
+**如何修改默认模型**：
+1. 编辑 `.env` 文件
+2. 修改 `DEEPSEEK_MODEL_NAME` 的值
+3. 值必须是 `model_config.py` 中 `model_options` 的键之一
+
+---
+
+## 🔍 代码实现分析
+
+### 模型选择器（侧边栏）
+
+**位置**：`app.py` 的 `model_selector()` 函数
+
+**代码**：
+```python
+def model_selector():
+    """模型选择器"""
+    st.sidebar.subheader("🤖 AI模型选择")
+    
+    # 获取配置文件中的默认模型
+    default_model = config.DEEPSEEK_MODEL_NAME
+    
+    # 从 session_state 获取当前选择
+    current_model = st.session_state.get('selected_model', default_model)
+    
+    # 显示选择框
+    selected_model = st.sidebar.selectbox(
+        "选择AI模型",
+        options=list(model_options.keys()),
+        ...
+    )
+    
+    return selected_model
+```
+
+**问题**：虽然保存到 `session_state`，但很多地方不使用它
+
+### 实际使用情况
+
+#### ❌ 不生效的地方（强制使用配置文件）
+
+**1. 股票分析页面** (`app.py` 的 `run_stock_analysis`)
+```python
+# 强制使用配置文件中的默认模型（忽略 session_state 中的旧值）
+config_model = config.DEEPSEEK_MODEL_NAME
+if config_model in model_options:
+    selected_model = config_model
+else:
+    selected_model = list(model_options.keys())[0]
+
+agents = StockAnalysisAgents(model=selected_model)  # 使用配置文件的值
+```
+
+**2. 批量分析功能** (`app.py` 的 `run_batch_analysis`)
+```python
+# 强制使用配置文件中的默认模型
+config_model = config.DEEPSEEK_MODEL_NAME
+if config_model in model_options:
+    selected_model = config_model
+else:
+    selected_model = list(model_options.keys())[0]
+```
+
+**3. 批量分析中的单个股票分析** (`app.py` 的 `analyze_single_stock_for_batch`)
+```python
+# 强制使用配置文件中的默认模型（忽略传入的旧值）
+config_model = config.DEEPSEEK_MODEL_NAME
+if selected_model is None or selected_model == "" or selected_model == "deepseek-chat":
+    selected_model = config_model
+```
+
+#### ✅ 生效的地方
+
+**1. 主力选股页面** (`main_force_ui.py`)
+```python
+# 页面内有自己的模型选择
+model = st.selectbox(
+    "选择AI模型",
+    list(app_model_options.keys()),
+    ...
+)
+
+analyzer = MainForceAnalyzer(model=model)  # 使用页面选择的值
+```
+
+---
+
+## 🔧 如何让侧边栏选择全局生效？
+
+### 方案1：修改代码使用 session_state（推荐）
+
+修改所有强制使用 `config.DEEPSEEK_MODEL_NAME` 的地方，改为优先使用 `session_state.selected_model`：
+
+```python
+# 修改前
+config_model = config.DEEPSEEK_MODEL_NAME
+selected_model = config_model
+
+# 修改后
+selected_model = st.session_state.get('selected_model', config.DEEPSEEK_MODEL_NAME)
+if selected_model not in model_options:
+    selected_model = config.DEEPSEEK_MODEL_NAME
+```
+
+**需要修改的文件**：
+1. `app.py` - `run_stock_analysis()` 函数
+2. `app.py` - `run_batch_analysis()` 函数
+3. `app.py` - `analyze_single_stock_for_batch()` 函数
+
+### 方案2：保持现状，使用配置文件
+
+**优点**：
+- 配置持久化（重启后仍然有效）
+- 不依赖 Streamlit session
+
+**缺点**：
+- 需要修改 `.env` 文件才能改变模型
+- 不能通过UI快速切换
+
+---
+
+## 📝 模型配置详细说明
+
+### model_config.py 结构
+
+```python
+model_options = {
+    # 键：模型ID（用于API调用）
+    # 值：显示名称（在UI中显示）
+    "deepseek-chat": "DeepSeek Chat (默认)",
+    "deepseek-reasoner": "DeepSeek Reasoner (推理增强)",
+    # ...
+}
+```
+
+### 添加新模型的步骤
+
+1. **确定模型ID**：从API文档获取模型标识符
+2. **添加到 model_config.py**：
+   ```python
+   model_options = {
+       # ... 现有模型
+       "new-model-id": "新模型显示名称",
+   }
+   ```
+3. **（可选）设置为默认**：在 `.env` 文件中设置
+   ```bash
+   DEEPSEEK_MODEL_NAME=new-model-id
+   ```
+
+### 当前可用的模型
+
+根据 `model_config.py`，当前支持以下模型：
+
+| 模型ID | 显示名称 | 说明 |
+|--------|----------|------|
+| `deepseek-chat` | DeepSeek Chat (默认) | 默认模型 |
+| `deepseek-reasoner` | DeepSeek Reasoner (推理增强) | 推理能力更强 |
+| `qwen-plus` | qwen-plus (阿里百炼) | 阿里云模型 |
+| `qwen-plus-latest` | qwen-plus-latest (阿里百炼) | 最新版本 |
+| `qwen-flash` | qwen-flash (阿里百炼) | 快速版本 |
+| `qwen-turbo` | qwen-turbo (阿里百炼) | 加速版本 |
+| `qwen3-max` | qwen-max (阿里百炼) | 最大版本 |
+| `qwen-long` | qwen-long (阿里百炼) | 长文本版本 |
+| `deepseek-ai/DeepSeek-R1-0528-Qwen3-8B` | DeepSeek-R1 免费(硅基流动) | 免费模型 |
+| `Qwen/Qwen2.5-7B-Instruct` | Qwen 免费(硅基流动) | 免费模型 |
+| `Pro/deepseek-ai/DeepSeek-V3.1-Terminus` | DeepSeek-V3.1-Terminus (硅基流动) | 专业版 |
+| `deepseek-ai/DeepSeek-R1` | DeepSeek-R1 (硅基流动) | R1版本 |
+| `Qwen/Qwen3-235B-A22B-Thinking-2507` | Qwen3-235B (硅基流动) | 大模型 |
+| `zai-org/GLM-4.6` | 智谱(硅基流动) | 智谱模型 |
+| `moonshotai/Kimi-K2-Instruct-0905` | Kimi (硅基流动) | Kimi模型 |
+| `Ring-1T` | 蚂蚁百灵 (硅基流动) | 蚂蚁模型 |
+| `step3` | 阶跃星辰(硅基流动) | 阶跃模型 |
+
+---
+
+## 🎯 建议
+
+### 短期方案（保持现状）
+
+1. **修改默认模型**：编辑 `.env` 文件，修改 `DEEPSEEK_MODEL_NAME`
+2. **主力选股页面**：使用页面内的模型选择（已生效）
+
+### 长期方案（推荐）
+
+修改代码，让侧边栏的模型选择真正全局生效：
+
+1. 修改 `app.py` 中所有使用模型的地方
+2. 优先使用 `st.session_state.selected_model`
+3. 如果不存在或无效，回退到 `config.DEEPSEEK_MODEL_NAME`
+
+这样可以：
+- ✅ 通过UI快速切换模型
+- ✅ 配置持久化（通过 `.env`）
+- ✅ 用户体验更好
+
+---
+
+## 📚 相关文件
+
+- **模型选项定义**：`model_config.py`
+- **默认模型配置**：`.env` 文件中的 `DEEPSEEK_MODEL_NAME`
+- **模型选择器**：`app.py` 的 `model_selector()` 函数
+- **配置文件加载**：`config.py`
diff --git a/README.md b/README.md
index 756dc13..f75cbc6 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,10 @@
 # 🤖 复合多AI智能体股票团队分析系统
 
-- 初心：在股市摸爬滚打多年，自学自编各种指标，花冤柉钱学习了各种战法各种策略，也曾入各种小班，总是赚少赔多，逐渐失去在股市玩的信心。自从去年deepseek上市，一直探索用ai辅助分析，且近日受tradingagents项目启发（感谢原作），多agent结合跟踪主力资金战法（某指每年收费6000rmb），用各种ai辅助编程，拼凑了这么个小程序，根据软件提供的辅助信息，实盘测试盈率还是挺高的，并且逐步形成了自己的交易系统，近一个月来，账户也慢慢在扰亏为盈。开源此软件的目的，就是为了使像我一样的小散，不再迷范。也许这个软件不能让你发大财，但是他能给你足够的信心。最后提醒：股市有风险，入市需谨慎！
+- 初心：在股市摸爬滚打多年，自学自编各种指标，花冤柉钱学习了各种战法各种策略，也曾入各种小班，总是赚少赔多，逐渐失去在股市玩的信心。自从去年deepseek上市，一直探索用ai辅助分析，且近日受tradingagents项目启发（感谢原作），多agent结合跟踪主力资金战法（某指每年收费6000rmb），用各种ai辅助编程，拼凑了这么个小程序，根据软件提供的辅助信息，实盘测试盈率还是挺高的，并且逐步形成了自己的交易系统，近一个月来，账户也慢慢在扰亏为盈。开源此软件的目的，就是为了使像我一样的小散，不再迷范。也许这个软件不能让你发大财，但是他能给你足够的信心。最后提醒：股市有风险，入市需谨慎！欢迎加入qq群聊，群号：1059277514
+<img width="310" height="408" alt="QQ_1766893237734" src="https://github.com/user-attachments/assets/c1087858-89cd-470a-80df-70e9ac923f0e" style="display: block; margin: 0 auto;" />
+
+**点击zread图标，查看详细文档**
+[![zread](https://img.shields.io/badge/Ask_Zread-_.svg?style=flat&color=00b0aa&labelColor=000000&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTQuOTYxNTYgMS42MDAxSDIuMjQxNTZDMS44ODgxIDEuNjAwMSAxLjYwMTU2IDEuODg2NjQgMS42MDE1NiAyLjI0MDFWNC45NjAxQzEuNjAxNTYgNS4zMTM1NiAxLjg4ODEgNS42MDAxIDIuMjQxNTYgNS42MDAxSDQuOTYxNTZDNS4zMTUwMiA1LjYwMDEgNS42MDE1NiA1LjMxMzU2IDUuNjAxNTYgNC45NjAxVjIuMjQwMUM1LjYwMTU2IDEuODg2NjQgNS4zMTUwMiAxLjYwMDEgNC45NjE1NiAxLjYwMDFaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00Ljk2MTU2IDEwLjM5OTlIMi4yNDE1NkMxLjg4ODEgMTAuMzk5OSAxLjYwMTU2IDEwLjY4NjQgMS42MDE1NiAxMS4wMzk5VjEzLjc1OTlDMS42MDE1NiAxNC4xMTM0IDEuODg4MSAxNC4zOTk5IDIuMjQxNTYgMTQuMzk5OUg0Ljk2MTU2QzUuMzE1MDIgMTQuMzk5OSA1LjYwMTU2IDE0LjExMzQgNS42MDE1NiAxMy43NTk5VjExLjAzOTlDNS42MDE1NiAxMC42ODY0IDUuMzE1MDIgMTAuMzk5OSA0Ljk2MTU2IDEwLjM5OTlaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik0xMy43NTg0IDEuNjAwMUgxMS4wMzg0QzEwLjY4NSAxLjYwMDEgMTAuMzk4NCAxLjg4NjY0IDEwLjM5ODQgMi4yNDAxVjQuOTYwMUMxMC4zOTg0IDUuMzEzNTYgMTAuNjg1IDUuNjAwMSAxMS4wMzg0IDUuNjAwMUgxMy43NTg0QzE0LjExMTkgNS42MDAxIDE0LjM5ODQgNS4zMTM1NiAxNC4zOTg0IDQuOTYwMVYyLjI0MDFDMTQuMzk4NCAxLjg4NjY0IDE0LjExMTkgMS42MDAxIDEzLjc1ODQgMS42MDAxWiIgZmlsbD0iI2ZmZiIvPgo8cGF0aCBkPSJNNCAxMkwxMiA0TDQgMTJaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00IDEyTDEyIDQiIHN0cm9rZT0iI2ZmZiIgc3Ryb2tlLXdpZHRoPSIxLjUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgo8L3N2Zz4K&logoColor=ffffff)](https://zread.ai/oficcejo/aiagents-stock)
 
 ## ⭐ 1214更新 - 净利增长策略 📈
 
diff --git a/ai_agents.py b/ai_agents.py
index 75ea06e..c6efe57 100644
--- a/ai_agents.py
+++ b/ai_agents.py
@@ -1,13 +1,30 @@
 from deepseek_client import DeepSeekClient
 from typing import Dict, Any
 import time
+import config
 
 class StockAnalysisAgents:
     """股票分析AI智能体集合"""
     
-    def __init__(self, model="deepseek-chat"):
-        self.model = model
-        self.deepseek_client = DeepSeekClient(model=model)
+    def __init__(self, model=None):
+        # 调试：打印传入的参数和配置
+        print(f"[StockAnalysisAgents.__init__] 传入参数: model={model}")
+        print(f"[StockAnalysisAgents.__init__] 配置文件中的 DEEPSEEK_MODEL_NAME: {config.DEEPSEEK_MODEL_NAME}")
+        
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                print(f"[StockAnalysisAgents.__init__] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+            else:
+                print(f"[StockAnalysisAgents.__init__] 使用配置文件中的默认模型: {self.model}")
+        else:
+            self.model = model
+            print(f"[StockAnalysisAgents.__init__] 使用传入的模型参数: {self.model}")
+        
+        print(f"[StockAnalysisAgents.__init__] ✅ 最终使用的模型: {self.model}")
+        self.deepseek_client = DeepSeekClient(model=self.model)
         
     def technical_analyst_agent(self, stock_info: Dict, stock_data: Any, indicators: Dict) -> Dict[str, Any]:
         """技术面分析智能体"""
diff --git a/app.py b/app.py
index f030097..609fec7 100644
--- a/app.py
+++ b/app.py
@@ -18,6 +18,7 @@
 from monitor_service import monitor_service
 from notification_service import notification_service
 from config_manager import config_manager
+import config
 from main_force_ui import display_main_force_selector
 from sector_strategy_ui import display_sector_strategy
 from longhubang_ui import display_longhubang
@@ -37,17 +38,52 @@ def model_selector():
     st.sidebar.markdown("---")
     st.sidebar.subheader("🤖 AI模型选择")
 
-
+    # 获取配置文件中的默认模型
+    default_model = config.DEEPSEEK_MODEL_NAME
+    
+    # 如果配置的模型不在选项中，使用列表第一个
+    if default_model not in model_options:
+        default_model = list(model_options.keys())[0]
+    
+    # 如果 session_state 中已有值，且该值在选项中，使用它；否则使用配置的默认值
+    current_model = st.session_state.get('selected_model', default_model)
+    if current_model not in model_options:
+        current_model = default_model
 
     selected_model = st.sidebar.selectbox(
         "选择AI模型",
         options=list(model_options.keys()),
+        index=list(model_options.keys()).index(current_model) if current_model in model_options else 0,
         format_func=lambda x: model_options[x],
         help="DeepSeek Reasoner提供更强的推理能力，但响应时间可能更长"
     )
 
     return selected_model
 
+
+def get_selected_model():
+    """
+    获取当前选择的AI模型
+    优先使用session_state中的选择，如果不存在或无效，则使用配置文件中的默认值
+    
+    Returns:
+        str: 模型ID
+    """
+    # 优先使用session_state中的选择
+    selected_model = st.session_state.get('selected_model')
+    
+    # 如果session_state中有值且在有效选项中，使用它
+    if selected_model and selected_model in model_options:
+        return selected_model
+    
+    # 否则使用配置文件中的默认值
+    default_model = config.DEEPSEEK_MODEL_NAME
+    if default_model in model_options:
+        return default_model
+    
+    # 如果配置文件的值也不在选项中，使用第一个选项
+    return list(model_options.keys())[0]
+
 # 自定义CSS样式 - 专业版
 st.markdown("""
 <style>
@@ -277,6 +313,10 @@ def model_selector():
 """, unsafe_allow_html=True)
 
 def main():
+    # 初始化：检查配置文件中的默认模型，如果session_state中没有或值无效，使用配置文件的值
+    if 'selected_model' not in st.session_state or st.session_state.get('selected_model') not in model_options:
+        st.session_state.selected_model = config.DEEPSEEK_MODEL_NAME if config.DEEPSEEK_MODEL_NAME in model_options else list(model_options.keys())[0]
+    
     # 顶部标题栏
     st.markdown("""
     <div class="top-nav">
@@ -410,7 +450,19 @@ def main():
 
         # 模型选择器
         selected_model = model_selector()
-        st.session_state.selected_model = selected_model
+        
+        # 如果配置文件中的默认模型发生了变化，且用户没有主动选择其他模型，更新为配置文件的值
+        config_default_model = config.DEEPSEEK_MODEL_NAME
+        if config_default_model in model_options:
+            # 如果 session_state 中的值不在有效选项中，或者配置文件的值与当前选择不同且用户未手动选择过，使用配置文件的值
+            if (selected_model not in model_options) or \
+               (st.session_state.get('selected_model') not in model_options):
+                selected_model = config_default_model
+                st.session_state.selected_model = selected_model
+            else:
+                st.session_state.selected_model = selected_model
+        else:
+            st.session_state.selected_model = selected_model
 
         st.markdown("---")
 
@@ -812,7 +864,14 @@ def parse_stock_list(stock_input):
 
     return unique_list
 
-def analyze_single_stock_for_batch(symbol, period, enabled_analysts_config=None, selected_model='deepseek-chat'):
+def analyze_single_stock_for_batch(symbol, period, enabled_analysts_config=None, selected_model=None):
+    # 使用全局模型选择（优先使用session_state，回退到配置文件）
+    # 如果传入了有效的模型参数，使用传入的值；否则使用全局选择
+    if selected_model and selected_model in model_options:
+        print(f"[analyze_single_stock_for_batch] 使用传入的模型: {selected_model}")
+    else:
+        selected_model = get_selected_model()
+        print(f"[analyze_single_stock_for_batch] 使用全局选择的模型: {selected_model}")
     """单个股票分析（用于批量分析）
 
     Args:
@@ -970,7 +1029,10 @@ def run_batch_analysis(stock_list, period, batch_mode="顺序分析"):
         'sentiment': st.session_state.get('enable_sentiment', False),
         'news': st.session_state.get('enable_news', False)
     }
-    selected_model = st.session_state.get('selected_model', 'deepseek-chat')
+    # 使用全局模型选择（优先使用session_state，回退到配置文件）
+    selected_model = get_selected_model()
+    
+    print(f"[run_batch_analysis] 使用模型: {selected_model} (来自全局选择)")
 
     # 创建进度显示
     st.subheader(f"📊 批量分析进行中 ({batch_mode})")
@@ -1242,8 +1304,11 @@ def run_stock_analysis(symbol, period):
 
         # 6. 初始化AI分析系统
         status_text.text("🤖 正在初始化AI分析系统...")
-        # 使用选择的模型
-        selected_model = st.session_state.get('selected_model', 'deepseek-chat')
+        # 使用全局模型选择（优先使用session_state，回退到配置文件）
+        selected_model = get_selected_model()
+        
+        print(f"[run_stock_analysis] 使用模型: {selected_model} (来自全局选择)")
+        
         agents = StockAnalysisAgents(model=selected_model)
         progress_bar.progress(55)
 
@@ -1661,6 +1726,25 @@ def display_history_records():
     """显示历史分析记录"""
     st.subheader("📚 历史分析记录")
 
+    # 检查是否正在查看详情，如果是，先显示详情
+    if 'viewing_record_id' in st.session_state:
+        # 添加返回按钮
+        if st.button("⬅️ 返回列表", key="back_to_list"):
+            if 'viewing_record_id' in st.session_state:
+                del st.session_state.viewing_record_id
+            if 'add_to_monitor_id' in st.session_state:
+                del st.session_state.add_to_monitor_id
+            st.rerun()
+        
+        # 显示详情
+        try:
+            display_record_detail(st.session_state.viewing_record_id)
+        except Exception as e:
+            st.error(f"❌ 显示详情时出错: {str(e)}")
+            import traceback
+            st.code(traceback.format_exc())
+        return
+
     # 获取所有记录
     records = db.get_all_records()
 
@@ -1720,11 +1804,13 @@ def display_history_records():
             with col3:
                 if st.button("👀 查看详情", key=f"view_{record['id']}"):
                     st.session_state.viewing_record_id = record['id']
+                    st.rerun()
 
             with col4:
                 if st.button("➕ 监测", key=f"add_monitor_{record['id']}"):
                     st.session_state.add_to_monitor_id = record['id']
                     st.session_state.viewing_record_id = record['id']
+                    st.rerun()
 
             # 删除按钮（新增一行）
             col5, _, _, _ = st.columns(4)
@@ -1736,10 +1822,6 @@ def display_history_records():
                     else:
                         st.error("❌ 删除失败")
 
-    # 查看详细记录
-    if 'viewing_record_id' in st.session_state:
-        display_record_detail(st.session_state.viewing_record_id)
-
 def display_add_to_monitor_dialog(record):
     """显示加入监测的对话框"""
     st.markdown("---")
@@ -1921,9 +2003,15 @@ def display_record_detail(record_id):
     st.markdown("---")
     st.subheader("📋 详细分析记录")
 
-    record = db.get_record_by_id(record_id)
-    if not record:
-        st.error("❌ 记录不存在")
+    try:
+        record = db.get_record_by_id(record_id)
+        if not record:
+            st.error("❌ 记录不存在")
+            return
+    except Exception as e:
+        st.error(f"❌ 获取记录时出错: {str(e)}")
+        import traceback
+        st.code(traceback.format_exc())
         return
 
     # 基本信息
@@ -2141,6 +2229,21 @@ def display_config_manager():
         )
         st.session_state.temp_config["DEEPSEEK_BASE_URL"] = new_base_url
 
+        st.markdown("---")
+
+        # DeepSeek Model Name
+        default_model_name = config.DEEPSEEK_MODEL_NAME
+        model_name_info = config_info.get("DEEPSEEK_MODEL_NAME", {"value": default_model_name, "description": "DeepSeek模型名称", "required": False, "type": "text"})
+        current_model_name = st.session_state.temp_config.get("DEEPSEEK_MODEL_NAME", model_name_info.get("value", default_model_name))
+
+        new_model_name = st.text_input(
+            f"🤖 {model_name_info['description']}",
+            value=current_model_name,
+            help="配置要使用的模型名称，如：deepseek-chat、deepseek-reasoner等",
+            key="input_deepseek_model_name"
+        )
+        st.session_state.temp_config["DEEPSEEK_MODEL_NAME"] = new_model_name
+
         st.info("💡 如何获取DeepSeek API密钥？\n\n1. 访问 https://platform.deepseek.com\n2. 注册/登录账号\n3. 进入API密钥管理页面\n4. 创建新的API密钥\n5. 复制密钥并粘贴到上方输入框")
 
     with tab2:
@@ -2480,6 +2583,7 @@ def display_config_manager():
 # ========== DeepSeek API配置 ==========
 DEEPSEEK_API_KEY="{current_config.get('DEEPSEEK_API_KEY', '')}"
 DEEPSEEK_BASE_URL="{current_config.get('DEEPSEEK_BASE_URL', '')}"
+DEEPSEEK_MODEL_NAME="{current_config.get('DEEPSEEK_MODEL_NAME', config.DEEPSEEK_MODEL_NAME)}"
 
 # ========== Tushare数据接口（可选）==========
 TUSHARE_TOKEN="{current_config.get('TUSHARE_TOKEN', '')}"
diff --git a/check_qmt_status.py b/check_qmt_status.py
new file mode 100755
index 0000000..0cf8ce7
--- /dev/null
+++ b/check_qmt_status.py
@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+QMT连接状态检查工具
+用于检查本地QMT客户端是否运行以及API服务地址
+"""
+
+import os
+import sys
+import socket
+import subprocess
+from datetime import datetime
+
+def check_port(host, port):
+    """检查端口是否开放"""
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(2)
+        result = sock.connect_ex((host, port))
+        sock.close()
+        return result == 0
+    except Exception as e:
+        return False, str(e)
+
+def check_process_by_name(process_names):
+    """检查进程是否运行"""
+    running_processes = []
+    
+    try:
+        if sys.platform == 'darwin':  # macOS
+            ps_command = ['ps', 'aux']
+        elif sys.platform == 'win32':  # Windows
+            ps_command = ['tasklist']
+        else:  # Linux
+            ps_command = ['ps', 'aux']
+        
+        result = subprocess.run(ps_command, capture_output=True, text=True)
+        
+        for name in process_names:
+            if name.lower() in result.stdout.lower():
+                running_processes.append(name)
+        
+        return running_processes
+    except Exception as e:
+        print(f"检查进程时出错: {e}")
+        return []
+
+def check_common_qmt_ports():
+    """检查常见的QMT端口"""
+    common_ports = [58610, 58611, 58612, 58613, 58614, 58615, 5000, 8080]
+    open_ports = []
+    
+    print("\n🔍 检查常见QMT端口...")
+    for port in common_ports:
+        if check_port('127.0.0.1', port):
+            open_ports.append(port)
+            print(f"  ✅ 端口 {port} 已开放")
+        else:
+            print(f"  ❌ 端口 {port} 未开放")
+    
+    return open_ports
+
+def check_xtquant_import():
+    """检查xtquant库是否可用"""
+    try:
+        from xtquant import xttrader, xtdata
+        print("  ✅ xtquant库已安装")
+        return True, xttrader, xtdata
+    except ImportError as e:
+        print(f"  ❌ xtquant库未安装: {e}")
+        return False, None, None
+
+def test_xtquant_connection():
+    """测试xtquant连接"""
+    try:
+        from xtquant import xttrader
+        
+        print("\n🔗 尝试连接xtquant...")
+        trader = xttrader.XtQuantTrader()
+        trader.start()
+        
+        # 尝试获取账户列表
+        try:
+            accounts = trader.query_accounts()
+            if accounts:
+                print(f"  ✅ 连接成功！找到 {len(accounts)} 个账户")
+                for acc in accounts:
+                    print(f"     - 账户ID: {acc}")
+                trader.stop()
+                return True, accounts
+            else:
+                print("  ⚠️  连接成功，但未找到账户")
+                trader.stop()
+                return True, []
+        except Exception as e:
+            print(f"  ⚠️  连接成功，但查询账户失败: {e}")
+            trader.stop()
+            return True, []
+            
+    except Exception as e:
+        print(f"  ❌ 连接失败: {e}")
+        return False, None
+
+def check_env_config():
+    """检查环境变量配置"""
+    print("\n📋 检查环境变量配置...")
+    
+    from dotenv import load_dotenv
+    load_dotenv()
+    
+    config = {
+        'MINIQMT_ENABLED': os.getenv('MINIQMT_ENABLED', '未设置'),
+        'MINIQMT_ACCOUNT_ID': os.getenv('MINIQMT_ACCOUNT_ID', '未设置'),
+        'MINIQMT_HOST': os.getenv('MINIQMT_HOST', '未设置'),
+        'MINIQMT_PORT': os.getenv('MINIQMT_PORT', '未设置'),
+    }
+    
+    for key, value in config.items():
+        if value == '未设置':
+            print(f"  ⚠️  {key}: {value}")
+        else:
+            print(f"  ✅ {key}: {value}")
+    
+    return config
+
+def main():
+    print("=" * 60)
+    print("QMT连接状态检查工具")
+    print("=" * 60)
+    print(f"检查时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    # 1. 检查QMT进程
+    print("\n1️⃣ 检查QMT进程是否运行...")
+    qmt_processes = [
+        'XtMiniQmt', 'XtMiniQmt.exe', 'QMT', 'QMT.exe',
+        'xtquant', 'xttrader', '国金证券', 'gjzq'
+    ]
+    running = check_process_by_name(qmt_processes)
+    if running:
+        print(f"  ✅ 发现运行中的QMT相关进程: {', '.join(running)}")
+    else:
+        print("  ⚠️  未发现运行中的QMT进程")
+        print("     提示: 请确保QMT客户端已启动并登录")
+    
+    # 2. 检查环境配置
+    env_config = check_env_config()
+    
+    # 3. 检查常见端口
+    open_ports = check_common_qmt_ports()
+    
+    # 4. 检查xtquant库
+    print("\n2️⃣ 检查xtquant库...")
+    has_xtquant, xttrader, xtdata = check_xtquant_import()
+    
+    # 5. 测试连接
+    if has_xtquant:
+        success, accounts = test_xtquant_connection()
+        
+        if success and accounts:
+            print("\n✅ QMT连接状态: 正常")
+            print(f"   可用账户数: {len(accounts)}")
+            if env_config['MINIQMT_ACCOUNT_ID'] != '未设置':
+                account_id = env_config['MINIQMT_ACCOUNT_ID']
+                if account_id in accounts:
+                    print(f"   ✅ 配置的账户ID '{account_id}' 在可用账户列表中")
+                else:
+                    print(f"   ⚠️  配置的账户ID '{account_id}' 不在可用账户列表中")
+                    print(f"   可用账户: {', '.join(accounts)}")
+        elif success:
+            print("\n⚠️  QMT连接状态: 已连接但无账户")
+        else:
+            print("\n❌ QMT连接状态: 连接失败")
+    else:
+        print("\n⚠️  无法测试连接（xtquant库未安装）")
+    
+    # 6. 端口总结
+    if open_ports:
+        print(f"\n📊 开放的端口: {', '.join(map(str, open_ports))}")
+        if env_config['MINIQMT_PORT'] != '未设置':
+            config_port = int(env_config['MINIQMT_PORT'])
+            if config_port in open_ports:
+                print(f"   ✅ 配置的端口 {config_port} 已开放")
+            else:
+                print(f"   ⚠️  配置的端口 {config_port} 未开放")
+                print(f"   建议使用已开放的端口: {open_ports[0]}")
+    
+    # 7. 建议
+    print("\n" + "=" * 60)
+    print("💡 建议:")
+    print("=" * 60)
+    
+    if not running:
+        print("1. 请启动QMT客户端并登录")
+    
+    if not has_xtquant:
+        print("2. 请安装xtquant库:")
+        print("   - 从QMT安装目录复制 xtquant 到 Python site-packages")
+        print("   - 或使用 pip install xtquant（如果可用）")
+    
+    if open_ports and env_config['MINIQMT_PORT'] != '未设置':
+        config_port = int(env_config['MINIQMT_PORT'])
+        if config_port not in open_ports:
+            print(f"3. 建议修改 MINIQMT_PORT 为 {open_ports[0]}")
+    
+    if env_config['MINIQMT_ACCOUNT_ID'] == '未设置':
+        print("4. 请在 .env 文件中配置 MINIQMT_ACCOUNT_ID")
+    
+    print("\n" + "=" * 60)
+
+if __name__ == "__main__":
+    main()
diff --git a/cleanup_root_databases.sh b/cleanup_root_databases.sh
new file mode 100755
index 0000000..7029a98
--- /dev/null
+++ b/cleanup_root_databases.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+# 清理根目录的数据库文件（已迁移到 data 目录）
+
+echo "🧹 清理根目录的数据库文件..."
+echo ""
+
+# 数据库文件列表
+DB_FILES=(
+    "stock_analysis.db"
+    "sector_strategy.db"
+    "low_price_bull_monitor.db"
+    "main_force_batch.db"
+    "stock_monitor.db"
+    "portfolio_stocks.db"
+    "longhubang.db"
+    "smart_monitor.db"
+    "profit_growth_monitor.db"
+)
+
+for db_file in "${DB_FILES[@]}"; do
+    if [ -f "$db_file" ]; then
+        # 检查 data 目录是否有对应的文件
+        if [ -f "data/$db_file" ]; then
+            echo "✅ 删除根目录的 $db_file (已迁移到 data 目录)"
+            rm "$db_file"
+        else
+            echo "⚠️  跳过 $db_file (data 目录不存在对应文件)"
+        fi
+    fi
+done
+
+# 清理备份文件
+if [ -f "data/main_force_batch.db.backup" ]; then
+    echo ""
+    echo "🗑️  删除备份文件: data/main_force_batch.db.backup"
+    rm "data/main_force_batch.db.backup"
+fi
+
+echo ""
+echo "✅ 清理完成！"
diff --git a/config.py b/config.py
index 5d3830b..b88c892 100644
--- a/config.py
+++ b/config.py
@@ -1,12 +1,78 @@
 import os
+from pathlib import Path
 from dotenv import load_dotenv
 
-# 加载环境变量（override=True 强制覆盖已存在的环境变量）
-load_dotenv(override=True)
+# 获取当前文件的目录
+current_dir = Path(__file__).parent.absolute()
+
+# 尝试多个可能的 .env 文件路径
+env_paths = [
+    current_dir / '.env',           # 当前目录
+    Path('.env'),                   # 工作目录
+    Path('/app/.env'),              # Docker 容器中的路径
+]
+
+env_loaded = False
+env_file_path = None
+
+# 尝试加载 .env 文件
+for env_path in env_paths:
+    if env_path.exists():
+        env_loaded = load_dotenv(env_path, override=True)
+        if env_loaded:
+            env_file_path = env_path
+            print(f"[config.py] ✅ 成功加载 .env 文件: {env_path}")
+            break
+    else:
+        print(f"[config.py] .env 文件不存在: {env_path}")
+
+# 如果都没有找到，尝试从当前目录加载（load_dotenv 的默认行为）
+if not env_loaded:
+    env_loaded = load_dotenv(override=True)
+    print(f"[config.py] 尝试默认路径加载 .env: {'成功' if env_loaded else '失败'}")
 
 # DeepSeek API配置
 DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY", "")
 DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1")
+DEEPSEEK_MODEL_NAME = os.getenv("DEEPSEEK_MODEL_NAME", "deepseek-chat")
+
+# 调试：打印配置值（隐藏敏感信息）
+print(f"[config.py] =========================================")
+print(f"[config.py] 配置加载结果:")
+print(f"[config.py]   DEEPSEEK_MODEL_NAME: {DEEPSEEK_MODEL_NAME}")
+print(f"[config.py]   DEEPSEEK_BASE_URL: {DEEPSEEK_BASE_URL}")
+print(f"[config.py]   DEEPSEEK_API_KEY: {'已设置' if DEEPSEEK_API_KEY else '未设置'}")
+print(f"[config.py]   环境变量 DEEPSEEK_MODEL_NAME: {os.getenv('DEEPSEEK_MODEL_NAME', '未设置')}")
+
+# 如果 DEEPSEEK_MODEL_NAME 仍然是默认值，尝试从 .env 文件直接读取
+if DEEPSEEK_MODEL_NAME == "deepseek-chat":
+    print("[config.py] ⚠️ 警告: DEEPSEEK_MODEL_NAME 仍然是默认值 'deepseek-chat'")
+    print("[config.py] 尝试直接读取 .env 文件...")
+    
+    # 尝试所有可能的路径
+    for env_path in env_paths:
+        if env_path.exists():
+            print(f"[config.py] 检查 .env 文件: {env_path}")
+            try:
+                with open(env_path, 'r', encoding='utf-8') as f:
+                    for line_num, line in enumerate(f, 1):
+                        line = line.strip()
+                        # 跳过空行和注释
+                        if not line or line.startswith('#'):
+                            continue
+                        if 'DEEPSEEK_MODEL_NAME' in line and '=' in line:
+                            value = line.split('=', 1)[1].strip().strip('"').strip("'")
+                            if value and value != "deepseek-chat":
+                                DEEPSEEK_MODEL_NAME = value
+                                # 更新环境变量
+                                os.environ['DEEPSEEK_MODEL_NAME'] = value
+                                print(f"[config.py] ✅ 从 .env 文件直接读取到 DEEPSEEK_MODEL_NAME: {DEEPSEEK_MODEL_NAME} (第 {line_num} 行)")
+                                break
+            except Exception as e:
+                print(f"[config.py] ❌ 读取 .env 文件失败 ({env_path}): {e}")
+    
+print(f"[config.py] 最终使用的 DEEPSEEK_MODEL_NAME: {DEEPSEEK_MODEL_NAME}")
+print(f"[config.py] =========================================")
 
 # 其他配置
 TUSHARE_TOKEN = os.getenv("TUSHARE_TOKEN", "")
diff --git a/config_manager.py b/config_manager.py
index 3881b50..94be8ce 100644
--- a/config_manager.py
+++ b/config_manager.py
@@ -26,6 +26,12 @@ def __init__(self, env_file: str = ".env"):
                 "required": False,
                 "type": "text"
             },
+            "DEEPSEEK_MODEL_NAME": {
+                "value": "deepseek-chat",
+                "description": "DeepSeek模型名称",
+                "required": False,
+                "type": "text"
+            },
             "TUSHARE_TOKEN": {
                 "value": "",
                 "description": "Tushare数据接口Token（可选）",
@@ -172,6 +178,7 @@ def write_env(self, config: Dict[str, str]) -> bool:
             lines.append("# ========== DeepSeek API配置 ==========")
             lines.append(f'DEEPSEEK_API_KEY="{config.get("DEEPSEEK_API_KEY", "")}"')
             lines.append(f'DEEPSEEK_BASE_URL="{config.get("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1")}"')
+            lines.append(f'DEEPSEEK_MODEL_NAME="{config.get("DEEPSEEK_MODEL_NAME", "deepseek-chat")}"')
             lines.append("")
             
             # Tushare配置
diff --git a/database.py b/database.py
index 07dd0db..6d72fa9 100644
--- a/database.py
+++ b/database.py
@@ -4,13 +4,28 @@
 import os
 
 class StockAnalysisDatabase:
-    def __init__(self, db_path="stock_analysis.db"):
-        """初始化数据库连接"""
-        self.db_path = db_path
+    def __init__(self, db_path=None):
+        """初始化数据库连接
+        
+        Args:
+            db_path: 数据库文件路径，如果为None，则使用data目录下的stock_analysis.db（确保持久化）
+        """
+        # 如果没有指定路径，使用data目录下的数据库文件（确保容器重启后数据不丢失）
+        if db_path is None:
+            data_dir = os.path.join(os.path.dirname(__file__), 'data')
+            # 确保data目录存在
+            if not os.path.exists(data_dir):
+                os.makedirs(data_dir, exist_ok=True)
+            self.db_path = os.path.join(data_dir, 'stock_analysis.db')
+        else:
+            self.db_path = db_path
+        
         # 确保数据库所在目录存在
         db_dir = os.path.dirname(self.db_path)
         if db_dir and not os.path.exists(db_dir):
             os.makedirs(db_dir, exist_ok=True)
+        
+        print(f"[StockAnalysisDatabase] 数据库文件路径: {self.db_path}")
         self.init_database()
     
     def init_database(self):
diff --git a/database_check_report.md b/database_check_report.md
new file mode 100644
index 0000000..5393e9e
--- /dev/null
+++ b/database_check_report.md
@@ -0,0 +1,110 @@
+# 数据库检查报告
+
+## 📊 检查结果摘要
+
+检查了 `data` 目录下的 9 个数据库文件，发现以下问题：
+
+### ⚠️ 发现的问题
+
+#### 1. **main_force_batch1.db** (6.8 MB) - 文件大但无数据
+
+**问题描述**：
+- 文件大小：6.8 MB
+- `batch_analysis_history` 表：0 条记录
+- `sqlite_sequence` 表：序列值 = 3（说明之前有3条记录被删除）
+
+**原因分析**：
+1. **文件名不匹配**：代码期望文件名是 `main_force_batch.db`，但实际存在的是 `main_force_batch1.db`
+2. **数据被删除**：从 `sqlite_sequence` 可以看出之前有3条记录，但后来被删除了
+3. **文件未收缩**：SQLite 在删除数据后不会自动收缩文件大小，所以文件仍然保持 6.8MB 的大小
+4. **可能的数据迁移**：可能数据被迁移到了其他位置，或者被清理了
+
+**影响**：
+- 代码无法找到正确的数据库文件（代码查找 `main_force_batch.db`，但实际是 `main_force_batch1.db`）
+- 浪费存储空间（6.8MB 的空文件）
+
+**建议解决方案**：
+1. 检查是否有数据需要恢复
+2. 如果有 `main_force_batch.db` 文件，确认哪个是正确的
+3. 如果 `main_force_batch1.db` 确实没有用，可以执行 `VACUUM` 收缩文件或删除
+4. 确保代码使用的文件名与实际的数据库文件名一致
+
+#### 2. **profit_growth_monitor.db** (20 KB) - 文件有大小但无数据
+
+**问题描述**：
+- 文件大小：20 KB
+- 所有表：0 条记录（`monitored_stocks`, `sqlite_sequence`, `sell_alerts`）
+
+**原因分析**：
+- 这是正常的！表结构已创建，但还没有添加监控数据
+- 20KB 是 SQLite 创建表和索引所需的最小空间
+
+**影响**：
+- 无影响，这是正常的初始化状态
+
+**建议**：
+- 无需处理，这是正常的空数据库状态
+
+---
+
+## 📋 所有数据库文件状态
+
+| 文件名 | 大小 | 状态 | 总记录数 | 说明 |
+|--------|------|------|----------|------|
+| longhubang.db | 968 KB | ✅ 正常 | 1214 | 有数据 |
+| low_price_bull_monitor.db | 20 KB | ✅ 正常 | 13 | 有数据 |
+| **main_force_batch1.db** | **6.8 MB** | **⚠️ 文件大但无数据** | **1** | **只有 sqlite_sequence，主表为空** |
+| portfolio_stocks.db | 28 KB | ✅ 正常 | 32 | 有数据 |
+| **profit_growth_monitor.db** | **20 KB** | **⚠️ 文件存在但无数据** | **0** | **表已创建但无数据（正常）** |
+| sector_strategy.db | 328 KB | ✅ 正常 | 544 | 有数据 |
+| smart_monitor.db | 316 KB | ✅ 正常 | 158 | 有数据 |
+| stock_analysis.db | 24.8 MB | ✅ 正常 | 299 | 有数据 |
+| stock_monitor.db | 20 KB | ✅ 正常 | 21 | 有数据 |
+
+---
+
+## 🔧 建议的操作
+
+### 对于 main_force_batch1.db
+
+1. **检查是否有 `main_force_batch.db` 文件**：
+   ```bash
+   ls -lh data/main_force_batch*.db
+   ```
+
+2. **如果有 `main_force_batch.db`，检查其内容**：
+   ```python
+   import sqlite3
+   conn = sqlite3.connect('data/main_force_batch.db')
+   cursor = conn.cursor()
+   cursor.execute('SELECT COUNT(*) FROM batch_analysis_history;')
+   print(f'记录数: {cursor.fetchone()[0]}')
+   conn.close()
+   ```
+
+3. **如果需要收缩 `main_force_batch1.db`**：
+   ```sql
+   VACUUM;
+   ```
+   这将把文件从 6.8MB 缩小到约 20KB
+
+4. **如果需要删除空文件**：
+   ```bash
+   rm data/main_force_batch1.db
+   ```
+   ⚠️ 注意：删除前请确认没有重要数据
+
+### 对于 profit_growth_monitor.db
+
+- **无需处理**，这是正常的空数据库状态
+- 当用户添加监控股票时，会自动添加数据
+
+---
+
+## 📝 详细检查脚本
+
+检查脚本已保存为 `check_databases.py`，可以随时运行：
+
+```bash
+python3 check_databases.py
+```
diff --git a/database_fix_recommendations.md b/database_fix_recommendations.md
new file mode 100644
index 0000000..3d18296
--- /dev/null
+++ b/database_fix_recommendations.md
@@ -0,0 +1,147 @@
+# 数据库问题分析和修复建议
+
+## 🔍 问题总结
+
+### 问题1: main_force_batch 数据库文件位置不匹配
+
+**现状**：
+- ✅ 根目录 `./main_force_batch.db` 存在，有 **3 条记录**（有数据）
+- ❌ `data/main_force_batch.db` 不存在（代码期望的路径）
+- ⚠️ `data/main_force_batch1.db` 存在，**0 条记录**，但文件大小 6.8MB（空但大）
+
+**影响**：
+- 代码配置的路径是 `data/main_force_batch.db`，但实际数据在根目录的 `main_force_batch.db`
+- 这可能导致新的批量分析数据无法正确保存或读取
+
+**修复建议**：
+
+1. **将根目录的数据库文件移动到 data 目录**：
+   ```bash
+   mv main_force_batch.db data/main_force_batch.db
+   ```
+
+2. **清理空的大文件 `data/main_force_batch1.db`**：
+   ```bash
+   # 方案1: 直接删除（如果确认没用）
+   rm data/main_force_batch1.db
+   
+   # 方案2: 先收缩再删除（如果需要保留结构）
+   sqlite3 data/main_force_batch1.db "VACUUM;"
+   rm data/main_force_batch1.db
+   ```
+
+---
+
+### 问题2: profit_growth_monitor.db 空文件
+
+**现状**：
+- ✅ 文件大小：20 KB
+- ⚠️ 所有表：0 条记录
+
+**分析**：
+- 这是**正常现象**，表结构已创建，但还没有添加监控数据
+- 20KB 是 SQLite 创建表和索引所需的最小空间
+
+**建议**：
+- 无需处理，这是正常的初始化状态
+- 当用户添加监控股票时，会自动添加数据
+
+---
+
+## 📋 详细状态
+
+### 所有数据库文件检查结果
+
+| 文件名 | 位置 | 大小 | 状态 | 记录数 | 说明 |
+|--------|------|------|------|--------|------|
+| **main_force_batch.db** | **根目录** | **6.8 MB** | **✅ 有数据** | **3** | **需要移动到 data 目录** |
+| main_force_batch.db | data/ | - | ❌ 不存在 | - | 代码期望的路径 |
+| **main_force_batch1.db** | **data/** | **6.8 MB** | **⚠️ 空但大** | **0** | **建议删除或收缩** |
+| profit_growth_monitor.db | data/ | 20 KB | ⚠️ 空（正常） | 0 | 正常初始化状态 |
+
+---
+
+## 🔧 推荐操作步骤
+
+### 步骤1: 备份现有数据（重要！）
+
+```bash
+# 备份根目录的数据库（有数据）
+cp main_force_batch.db main_force_batch.db.backup
+
+# 备份 data 目录的数据库（以防万一）
+cp data/main_force_batch1.db data/main_force_batch1.db.backup
+```
+
+### 步骤2: 移动数据库文件到正确位置
+
+```bash
+# 将根目录的数据库移动到 data 目录
+mv main_force_batch.db data/main_force_batch.db
+
+# 验证移动成功
+ls -lh data/main_force_batch.db
+```
+
+### 步骤3: 清理空的大文件
+
+```bash
+# 收缩并删除空的大文件
+sqlite3 data/main_force_batch1.db "VACUUM;"
+rm data/main_force_batch1.db
+```
+
+### 步骤4: 验证修复
+
+```python
+# 运行检查脚本验证
+python3 check_databases.py
+```
+
+---
+
+## ⚠️ 注意事项
+
+1. **在操作前一定要备份**！
+2. **确认 `main_force_batch1.db` 确实没有重要数据**（检查已确认 0 条记录）
+3. **移动文件后，重启应用**，确保新的数据会保存到正确的位置
+4. **如果应用在运行中，先停止应用再操作**
+
+---
+
+## 📊 修复后的预期结果
+
+修复后，预期结果：
+- ✅ `data/main_force_batch.db` 存在，有数据（3条记录）
+- ✅ `data/main_force_batch1.db` 已删除或收缩
+- ✅ 代码可以正确访问数据库文件
+- ✅ 新的批量分析数据会保存到正确的位置
+
+---
+
+## 🔍 验证脚本
+
+创建一个验证脚本来检查修复是否成功：
+
+```python
+import sqlite3
+import os
+
+# 检查正确的文件是否存在
+db_path = 'data/main_force_batch.db'
+if os.path.exists(db_path):
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+    cursor.execute('SELECT COUNT(*) FROM batch_analysis_history;')
+    count = cursor.fetchone()[0]
+    print(f'✅ 修复成功: {db_path} 存在，有 {count} 条记录')
+    conn.close()
+else:
+    print(f'❌ 修复失败: {db_path} 不存在')
+
+# 检查空文件是否已清理
+if not os.path.exists('data/main_force_batch1.db'):
+    print('✅ 空文件已清理')
+else:
+    print('⚠️ 空文件仍然存在')
+```
diff --git a/database_migration_summary.md b/database_migration_summary.md
new file mode 100644
index 0000000..843a9b3
--- /dev/null
+++ b/database_migration_summary.md
@@ -0,0 +1,183 @@
+# 数据库文件迁移总结
+
+## ✅ 问题已解决
+
+### 1. 错误分析
+
+**错误信息**：
+```
+no such table: batch_analysis_history
+```
+
+**原因**：
+- 代码配置的数据库路径是 `data/main_force_batch.db`
+- 但实际数据在根目录的 `main_force_batch.db`
+- `data/main_force_batch.db` 存在但是空文件（没有表结构）
+
+### 2. 解决方案
+
+1. ✅ **迁移数据库文件**：将根目录有数据的 `main_force_batch.db` 移动到 `data/` 目录
+2. ✅ **统一存储规范**：所有数据库文件现在都在 `data/` 目录下
+3. ✅ **清理重复文件**：删除根目录的空数据库文件和重复文件
+
+---
+
+## 📊 迁移结果
+
+### 迁移前状态
+
+| 文件 | 根目录 | data目录 | 状态 |
+|------|--------|----------|------|
+| main_force_batch.db | ✅ 有数据（3条） | ⚠️ 空文件 | ❌ 不匹配 |
+| stock_analysis.db | ✅ 有数据 | ✅ 有数据 | ⚠️ 重复 |
+| sector_strategy.db | ✅ 有数据 | ✅ 有数据 | ⚠️ 重复 |
+| ... | ... | ... | ... |
+
+### 迁移后状态
+
+| 文件 | 位置 | 状态 |
+|------|------|------|
+| main_force_batch.db | ✅ data/ | ✅ 有数据（3条记录） |
+| stock_analysis.db | ✅ data/ | ✅ 有数据 |
+| sector_strategy.db | ✅ data/ | ✅ 有数据 |
+| low_price_bull_monitor.db | ✅ data/ | ✅ 有数据 |
+| stock_monitor.db | ✅ data/ | ✅ 有数据 |
+| portfolio_stocks.db | ✅ data/ | ✅ 有数据 |
+| longhubang.db | ✅ data/ | ✅ 有数据 |
+| smart_monitor.db | ✅ data/ | ✅ 有数据 |
+| profit_growth_monitor.db | ✅ data/ | ✅ 有数据 |
+
+---
+
+## 🔧 执行的步骤
+
+### 步骤1: 运行迁移脚本
+
+```bash
+python3 migrate_all_databases_to_data.py
+```
+
+**结果**：
+- ✅ `main_force_batch.db` 从根目录移动到 data 目录（替换了空的 data 文件）
+- ✅ 其他数据库文件已在 data 目录，保持不变
+
+### 步骤2: 清理根目录文件
+
+```bash
+./cleanup_root_databases.sh
+```
+
+**结果**：
+- ✅ 删除根目录的所有数据库文件
+- ✅ 删除备份文件
+
+### 步骤3: 验证
+
+```bash
+# 验证 data/main_force_batch.db
+python3 -c "
+import sqlite3
+conn = sqlite3.connect('data/main_force_batch.db')
+cursor = conn.cursor()
+cursor.execute('SELECT COUNT(*) FROM batch_analysis_history;')
+print(f'记录数: {cursor.fetchone()[0]}')
+"
+```
+
+**结果**：
+- ✅ `batch_analysis_history` 表存在
+- ✅ 有 3 条记录
+- ✅ 表结构完整（9个字段）
+
+---
+
+## 📋 数据库文件存储规范
+
+### 统一规范
+
+**所有数据库文件必须存储在 `data/` 目录下**
+
+### 数据库文件列表
+
+| 数据库文件 | 用途 | 模块 |
+|-----------|------|------|
+| `data/stock_analysis.db` | 股票分析历史记录 | `database.py` |
+| `data/sector_strategy.db` | 板块策略分析 | `sector_strategy_db.py` |
+| `data/main_force_batch.db` | 主力选股批量分析 | `main_force_batch_db.py` |
+| `data/stock_monitor.db` | 股票监测 | `monitor_db.py` |
+| `data/portfolio_stocks.db` | 持仓股票 | `portfolio_db.py` |
+| `data/longhubang.db` | 龙虎榜数据 | `longhubang_db.py` |
+| `data/smart_monitor.db` | 智能盯盘 | `smart_monitor_db.py` |
+| `data/low_price_bull_monitor.db` | 低价擒牛监控 | `low_price_bull_monitor.py` |
+| `data/profit_growth_monitor.db` | 净利增长监控 | `profit_growth_monitor.py` |
+
+### 代码配置规范
+
+所有数据库类都使用统一的路径配置：
+
+```python
+def __init__(self, db_path: str = None):
+    if db_path is None:
+        import os
+        data_dir = os.path.join(os.path.dirname(__file__), 'data')
+        if not os.path.exists(data_dir):
+            os.makedirs(data_dir, exist_ok=True)
+        self.db_path = os.path.join(data_dir, 'xxx.db')
+    else:
+        self.db_path = db_path
+```
+
+---
+
+## ✅ 验证清单
+
+- [x] 所有数据库文件在 `data/` 目录
+- [x] `data/main_force_batch.db` 有正确的表结构
+- [x] `data/main_force_batch.db` 有数据（3条记录）
+- [x] 根目录没有数据库文件
+- [x] 代码可以正确访问数据库
+
+---
+
+## 🚀 下一步
+
+1. **重启应用**：确保应用使用正确的数据库文件
+2. **测试功能**：测试批量分析历史记录功能是否正常
+3. **监控日志**：检查是否有数据库路径相关的错误
+
+---
+
+## 📝 注意事项
+
+1. **备份重要**：在迁移前已自动备份空文件
+2. **数据安全**：迁移过程中数据未丢失
+3. **路径统一**：所有数据库文件现在都在 `data/` 目录
+4. **容器环境**：在 Docker 容器中，`data/` 目录应该挂载到持久化卷
+
+---
+
+## 🔍 故障排查
+
+如果仍然遇到 "no such table" 错误：
+
+1. **检查数据库路径**：
+   ```python
+   from main_force_batch_db import batch_db
+   print(batch_db.db_path)
+   ```
+
+2. **检查表是否存在**：
+   ```python
+   import sqlite3
+   conn = sqlite3.connect('data/main_force_batch.db')
+   cursor = conn.cursor()
+   cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+   print(cursor.fetchall())
+   ```
+
+3. **重新初始化表**：
+   ```python
+   from main_force_batch_db import MainForceBatchDatabase
+   db = MainForceBatchDatabase()
+   # 这会自动创建表结构
+   ```
diff --git a/deepseek_client.py b/deepseek_client.py
index 17db710..f90e952 100644
--- a/deepseek_client.py
+++ b/deepseek_client.py
@@ -2,16 +2,55 @@
 import json
 from typing import Dict, List, Any, Optional
 import config
+import logging
+import os
+
+# 配置日志
+logger = logging.getLogger(__name__)
+# 如果没有配置handler，则添加默认配置
+if not logger.handlers:
+    logging.basicConfig(
+        level=logging.INFO,
+        format='[%(asctime)s] %(levelname)s %(name)s: %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
 
 class DeepSeekClient:
     """DeepSeek API客户端"""
     
-    def __init__(self, model="deepseek-chat"):
-        self.model = model
+    def __init__(self, model=None):
+        # 调试：打印传入的参数和配置
+        logger.info(f"[DeepSeekClient.__init__] 传入参数: model={model}")
+        logger.info(f"[DeepSeekClient.__init__] 配置文件中的 DEEPSEEK_MODEL_NAME: {config.DEEPSEEK_MODEL_NAME}")
+        print(f"[DeepSeekClient.__init__] 传入参数: model={model}")
+        print(f"[DeepSeekClient.__init__] 配置文件中的 DEEPSEEK_MODEL_NAME: {config.DEEPSEEK_MODEL_NAME}")
+        print(f"[DeepSeekClient.__init__] 环境变量 DEEPSEEK_MODEL_NAME: {os.getenv('DEEPSEEK_MODEL_NAME', '未设置')}")
+        
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                logger.warning(f"[DeepSeekClient.__init__] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+                print(f"[DeepSeekClient.__init__] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+            else:
+                logger.info(f"[DeepSeekClient.__init__] 使用配置文件中的默认模型: {self.model}")
+                print(f"[DeepSeekClient.__init__] ✅ 使用配置文件中的默认模型: {self.model}")
+            # 如果配置文件的模型仍然是默认值，发出警告
+            if self.model == "deepseek-chat":
+                print(f"[DeepSeekClient.__init__] ⚠️ 警告: 模型仍然是默认值 'deepseek-chat'，请检查 .env 文件中的 DEEPSEEK_MODEL_NAME 配置")
+        else:
+            self.model = model
+            logger.info(f"[DeepSeekClient.__init__] 使用传入的模型参数: {self.model}")
+            print(f"[DeepSeekClient.__init__] 使用传入的模型参数: {self.model}")
+        
+        self.base_url = config.DEEPSEEK_BASE_URL
         self.client = openai.OpenAI(
             api_key=config.DEEPSEEK_API_KEY,
-            base_url=config.DEEPSEEK_BASE_URL
+            base_url=self.base_url
         )
+        logger.info(f"[DeepSeekClient] 初始化完成 - 最终使用的模型: {self.model}, API地址: {self.base_url}")
+        print(f"[DeepSeekClient] ✅ 初始化完成 - 最终使用的模型: {self.model}, API地址: {self.base_url}")
         
     def call_api(self, messages: List[Dict[str, str]], model: Optional[str] = None, 
                  temperature: float = 0.7, max_tokens: int = 2000) -> str:
@@ -20,9 +59,38 @@ def call_api(self, messages: List[Dict[str, str]], model: Optional[str] = None,
         model_to_use = model or self.model
         
         # 对于 reasoner 模型，自动增加 max_tokens
+        original_max_tokens = max_tokens
         if "reasoner" in model_to_use.lower() and max_tokens <= 2000:
             max_tokens = 8000  # reasoner 模型需要更多 tokens 来输出推理过程
         
+        # 计算输入消息的token估算（简单估算：字符数/4）
+        total_chars = sum(len(str(msg.get('content', ''))) for msg in messages)
+        estimated_tokens = total_chars // 4
+        
+        # 准备消息摘要（安全处理）
+        message_summaries = []
+        for msg in messages[:3]:
+            role = msg.get('role', 'unknown')
+            content = str(msg.get('content', ''))
+            if len(content) > 50:
+                content = content[:50] + '...'
+            message_summaries.append(f"{role}:{content}")
+        
+        # 输出模型调用信息（同时输出到日志和控制台）
+        log_msg = f"""
+{'=' * 60}
+[DeepSeekClient] 准备调用API
+  模型名称: {model_to_use}
+  API地址: {self.base_url}
+  消息数量: {len(messages)}
+  估算输入Token: ~{estimated_tokens}
+  温度参数: {temperature}
+  最大输出Token: {max_tokens}{f' (已从{original_max_tokens}自动调整)' if max_tokens != original_max_tokens else ''}
+  消息摘要: {message_summaries}
+{'=' * 60}"""
+        logger.info(log_msg)
+        print(log_msg)  # 同时输出到控制台，方便调试
+        
         try:
             response = self.client.chat.completions.create(
                 model=model_to_use,
@@ -31,6 +99,17 @@ def call_api(self, messages: List[Dict[str, str]], model: Optional[str] = None,
                 max_tokens=max_tokens
             )
             
+            # 输出响应信息
+            if response and hasattr(response, 'usage'):
+                usage = response.usage
+                usage_info = f"""
+[DeepSeekClient] API调用成功
+  实际输入Token: {usage.prompt_tokens if hasattr(usage, 'prompt_tokens') else 'N/A'}
+  实际输出Token: {usage.completion_tokens if hasattr(usage, 'completion_tokens') else 'N/A'}
+  总Token: {usage.total_tokens if hasattr(usage, 'total_tokens') else 'N/A'}"""
+                logger.info(usage_info)
+                print(usage_info)  # 同时输出到控制台
+            
             # 处理 reasoner 模型的响应
             message = response.choices[0].message
             
@@ -49,6 +128,8 @@ def call_api(self, messages: List[Dict[str, str]], model: Optional[str] = None,
             return result if result else "API返回空响应"
             
         except Exception as e:
+            logger.error(f"[DeepSeekClient] API调用失败: {str(e)}")
+            logger.error(f"  模型: {model_to_use}, API地址: {self.base_url}")
             return f"API调用失败: {str(e)}"
     
     def technical_analysis(self, stock_info: Dict, stock_data: Any, indicators: Dict) -> str:
diff --git a/env/__init__.py b/env/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git "a/env/miniQMT(1\347\216\257\345\242\203)\343\200\220\345\205\210\347\224\250\350\277\231\344\270\252\343\200\221-\347\273\210\347\253\257\347\216\257\345\242\203\346\243\200\346\265\213path\344\277\235\345\255\230.py" "b/env/miniQMT(1\347\216\257\345\242\203)\343\200\220\345\205\210\347\224\250\350\277\231\344\270\252\343\200\221-\347\273\210\347\253\257\347\216\257\345\242\203\346\243\200\346\265\213path\344\277\235\345\255\230.py"
new file mode 100644
index 0000000..9117446
--- /dev/null
+++ "b/env/miniQMT(1\347\216\257\345\242\203)\343\200\220\345\205\210\347\224\250\350\277\231\344\270\252\343\200\221-\347\273\210\347\253\257\347\216\257\345\242\203\346\243\200\346\265\213path\344\277\235\345\255\230.py"
@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+"""
+申请开通QMT请添加微信咨询gjquant，获取更多资料访问https://miniqmt.com/
+此代码脚本仅用于软件测试，不能用于实盘交易，以此代码进行交易本人不承担任何损失
+"""
+import sys
+import os
+import subprocess
+import importlib
+
+# ================================
+# 第一步：检查并安装必需的第三方包
+# ================================
+
+REQUIRED_PACKAGES = ['psutil', 'xtquant']
+
+def ensure_packages_installed():
+    """检查并安装所需的第三方包"""
+    for package in REQUIRED_PACKAGES:
+        try:
+            importlib.import_module(package)
+            print(f"✅ {package} 已安装")
+        except ImportError:
+            print(f"⚠️ 未找到 {package}，正在安装...")
+            try:
+                subprocess.check_call([
+                    sys.executable, "-m", "pip", "install", package
+                ])
+                print(f"✅ {package} 安装成功")
+            except subprocess.CalledProcessError as e:
+                print(f"❌ 安装 {package} 失败，请手动执行: pip install {package}")
+                sys.exit(1)
+
+# --- 在导入其他模块前先确保依赖存在 ---
+print(" 🔍 正在检查依赖环境...\n","📘 更多资料访问miniqmt.com")
+ensure_packages_installed()
+
+# === 现在可以安全导入第三方库 ===
+import psutil
+import ctypes
+from ctypes import wintypes
+
+# -----------------------------
+# 1. 检查 xtquant 模块
+# -----------------------------
+def check_xtquant():
+    """检查 xtquant 模块是否安装并获取版本"""
+    try:
+        xtquant = importlib.import_module('xtquant')
+        print("xtquant: ✅ 已安装")
+        
+        # 尝试获取版本信息
+        version = "未知版本"
+        try:
+            # 尝试通过importlib.metadata获取
+            from importlib.metadata import version as md_version
+            version = md_version('xtquant')
+        except ImportError:
+            # 回退到模块属性
+            if hasattr(xtquant, '__version__'):
+                version = xtquant.__version__
+            else:
+                # 尝试获取文件版本信息
+                try:
+                    version = get_module_file_version(xtquant)
+                except Exception:
+                    pass
+        
+        print(f"xtquant 版本: {version}")
+        return True
+    except ImportError as e:
+        print(f"xtquant: ❌ 未安装 ({e})")
+        return False
+
+def get_module_file_version(module):
+    """尝试从模块文件属性获取版本信息"""
+    file_path = module.__file__
+    if file_path.endswith('.pyc'):
+        file_path = file_path[:-1]  # 转换为.py文件
+    
+    if os.path.exists(file_path):
+        # 读取文件内容查找版本信息
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            for line in f:
+                if '__version__' in line:
+                    parts = line.split('=')
+                    if len(parts) > 1:
+                        return parts[1].strip().strip("'\"")
+    
+    # 尝试获取文件修改时间作为替代
+    mtime = os.path.getmtime(file_path)
+    from datetime import datetime
+    return f"文件修改时间: {datetime.fromtimestamp(mtime).strftime('%Y-%m-%d')}"
+
+# -----------------------------
+# 2. Windows API：获取指定 PID 的窗口标题
+# -----------------------------
+user32 = ctypes.WinDLL('user32', use_last_error=True)
+
+user32.GetWindowThreadProcessId.argtypes = (wintypes.HWND, ctypes.POINTER(wintypes.DWORD))
+user32.GetWindowTextLengthW.argtypes = (wintypes.HWND,)
+user32.GetWindowTextW.argtypes = (wintypes.HWND, wintypes.LPWSTR, ctypes.c_int)
+user32.EnumWindows.argtypes = (ctypes.WINFUNCTYPE(ctypes.c_bool, wintypes.HWND, wintypes.LPARAM), wintypes.LPARAM)
+
+def get_window_title_by_pid(pid):
+    """枚举所有窗口，找到属于指定 PID 的主窗口标题"""
+    titles = []
+
+    def callback(hwnd, lParam):
+        pid_ptr = wintypes.DWORD()
+        user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid_ptr))
+        if pid_ptr.value == pid:
+            length = user32.GetWindowTextLengthW(hwnd)
+            if length > 0:
+                buffer = ctypes.create_unicode_buffer(length + 1)
+                user32.GetWindowTextW(hwnd, buffer, length + 1)
+                title = buffer.value.strip()
+                if title:
+                    titles.append(title)
+        return True
+
+    WNDENUMPROC = ctypes.WINFUNCTYPE(ctypes.c_bool, wintypes.HWND, wintypes.LPARAM)
+    user32.EnumWindows(WNDENUMPROC(callback), 0)
+    return titles[0] if titles else None
+
+# -----------------------------
+# 3. 获取 miniQMT 安装/运行状态
+# -----------------------------
+def get_miniqmt_info():
+    """检查 miniQMT 是否运行，返回安装目录和窗口标题"""
+    for proc in psutil.process_iter(['name', 'exe', 'pid']):
+        if proc.info['name'] == 'XtMiniQmt.exe':
+            try:
+                exe_path = proc.info['exe']
+                pid = proc.info['pid']
+                install_dir = os.path.dirname(exe_path)
+                window_title = get_window_title_by_pid(pid)
+                return {
+                    'install_dir': install_dir,
+                    'process_name': window_title or f"XtMiniQmt.exe (PID: {pid})",
+                    'status': 'running'
+                }
+            except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
+                continue
+
+    # 快捷方式 fallback（可选）
+    shortcut_name = "国金证券QMT交易端.lnk"
+    desktop = os.path.expanduser("~/Desktop")
+    shortcut_path = os.path.join(desktop, shortcut_name)
+    
+    if os.path.exists(shortcut_path):
+        target = get_target_from_shortcut(shortcut_path)
+        if target and os.path.exists(target):
+            install_dir = os.path.dirname(target)
+            return {
+                'install_dir': install_dir,
+                'process_name': '未运行',
+                'status': 'installed'
+            }
+
+    return {
+        'install_dir': '未找到',
+        'process_name': '未运行',
+        'status': 'not_found'
+    }
+
+# -----------------------------
+# 4. 解析快捷方式目标
+# -----------------------------
+def get_target_from_shortcut(lnk_path):
+    cmd = f'powershell -command "$s=(New-Object -ComObject WScript.Shell).CreateShortcut(\'{lnk_path}\'); $s.TargetPath"'
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=5)
+        return result.stdout.strip() if result.returncode == 0 else None
+    except Exception:
+        return None
+
+# -----------------------------
+# 5. 提取账户名（从窗口标题）
+# -----------------------------
+def extract_account_from_title(title):
+    """从窗口标题提取账号，例如 '55011888 - 国金QMT交易端模拟 1.0.0.36251'"""
+    if title and ' - ' in title:
+        account = title.split(' - ')[0].strip()
+        if account.isdigit():
+            return account
+    return None
+
+# -----------------------------
+# 6. 保存 path.txt
+# -----------------------------
+def save_path_file(install_dir, account):
+    """生成 path.txt，路径替换 bin.x64 -> userdata_mini"""
+    try:
+        base_dir = os.path.dirname(install_dir.rstrip('\\/'))
+        userdata_path = os.path.join(base_dir, "userdata_mini")
+        
+        # 写入文件
+        with open('path.txt', 'w', encoding='utf-8') as f:
+            f.write(f"{userdata_path}\n")
+            f.write(f"{account}\n")
+        
+        print(f"✅ 已生成环境配置所需文件 path.txt：\n   {userdata_path}\n   {account}")
+    except Exception as e:
+        print(f"❌ 保存 path.txt 失败: {e}")
+
+# -----------------------------
+# 7. 主函数
+# -----------------------------
+def main():
+    print("=" * 50)
+    print("🔍 开始检查运行环境")
+    print("=" * 50)
+    
+    # 输出Python环境信息
+    print(f"Python版本: {sys.version.split()[0]}")
+    print(f"Python路径: {sys.executable}")
+    print(f"运行路径: {os.getcwd()}")
+    
+    # 检查模块
+    print("\n" + "=" * 50)
+    print("📦 xtquant 模块检查")
+    print("=" * 50)
+    xtquant_ok = check_xtquant()
+
+    # 获取 miniQMT 状态
+    print("\n" + "=" * 50)
+    print("📊 miniQMT 终端状态")
+    print("=" * 50)
+
+    miniqmt = get_miniqmt_info()
+    status_map = {
+        'running': '🟢 运行中',
+        'installed': '🟡 已安装（未运行）',
+        'not_found': '🔴 未找到'
+    }
+
+    print(f"miniQMT路径: {miniqmt['install_dir']}")
+    print(f"miniQMT窗口: {miniqmt['process_name']}")
+    print(f"状态: {status_map.get(miniqmt['status'], '未知')}")
+
+    # 建议与保存逻辑
+    print("\n" + "=" * 50)
+    print("💡 环境检测配置")
+    print("=" * 50)
+
+    if miniqmt['status'] == 'not_found':
+        print("⚠️ 未找到 miniQMT，是否登录软件？\n⚠️ 请在登录QMT终端时勾选'独立交易'。")
+    elif not xtquant_ok:
+        print("⚠️ xtquant 模块未安装 ")
+    elif miniqmt['status'] == 'running':
+        account = extract_account_from_title(miniqmt['process_name'])
+        if account:
+            print("✅ 环境准备就绪，可以开始使用 miniQMT 量化开发！")
+            print("📘 更多资料请访问：https://miniqmt.com")
+            # 保存 path.txt
+            save_path_file(miniqmt['install_dir'], account)
+        else:
+            print("⚠️ 已运行 但未登录，请检查miniQMT终端状态是否已经登录账户。")
+            print("✅ 环境正常，但未检测到登录账户，未生成环境文档 path.txt")
+    else:
+        print("🟡 miniQMT 已安装但未运行。")
+        print("⚠️ 请先启动 miniQMT 登录交易。")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git "a/env/miniQMT(2\350\264\246\346\210\267)\346\237\245\350\257\242\344\277\235\345\255\230\347\211\210.py" "b/env/miniQMT(2\350\264\246\346\210\267)\346\237\245\350\257\242\344\277\235\345\255\230\347\211\210.py"
new file mode 100644
index 0000000..7440c64
--- /dev/null
+++ "b/env/miniQMT(2\350\264\246\346\210\267)\346\237\245\350\257\242\344\277\235\345\255\230\347\211\210.py"
@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+"""
+申请开通QMT请添加微信咨询gjquant，获取更多资料访问https://miniqmt.com/
+此代码脚本仅用于软件测试，不能用于实盘交易，以此代码进行交易本人不承担任何损失
+"""
+import os
+import time
+import pandas as pd
+from xtquant.xttrader import XtQuantTrader
+from xtquant.xttype import StockAccount
+from datetime import datetime
+
+# 配置文件路径
+CONFIG_FILE = "path.txt"
+
+def load_config():
+    """加载配置文件"""
+    if os.path.exists(CONFIG_FILE):
+        with open(CONFIG_FILE, 'r') as f:
+            lines = f.readlines()
+            if len(lines) >= 2:
+                return lines[0].strip(), lines[1].strip()
+    return None, None
+
+def save_config(path, acc):
+    """保存配置文件"""
+    with open(CONFIG_FILE, 'w') as f:
+        f.write(f"{path}\n{acc}")
+
+def get_user_input(path=None):
+    """获取用户输入"""
+    print("请输入QMT配置信息(例如: D:\\QMT\\userdata_mini)")
+    if path is None:
+        path = input("QMT安装路径 ：").strip()
+    acc = input("交易账号: ").strip()
+    return path, acc
+
+def initialize_trader(path, acc):
+    """初始化交易连接"""
+    # 创建交易对象
+    session_id = int(time.time())
+    xt_trader = XtQuantTrader(path, session_id)
+
+    # 连接miniQMT终端
+    xt_trader.start()
+    connect_result = xt_trader.connect()
+    
+    if connect_result == 0:
+        print('【软件终端连接成功！】')
+    else:
+        print('【软件终端连接失败！】', '\n请运行并登录miniQMT.EXE终端。', '\n检查路径是否正确。')
+        return None, connect_result, None
+
+    # 订阅账户信息
+    account = StockAccount(acc, 'STOCK')
+    subscribe_result = xt_trader.subscribe(account)
+    if subscribe_result == 0:
+        print('【账户信息订阅成功！】')
+        return xt_trader, subscribe_result, account
+    else:
+        print('【账户信息订阅失败！】', '\n账户配置错误，检查账号是否正确。')
+        return xt_trader, subscribe_result, account
+
+def print_account_info(xt_trader, account):
+    """打印账户信息"""
+    asset = xt_trader.query_stock_asset(account)
+    print('-'*18, f'【{asset.account_id}】', '-'*18) 
+    if asset:
+        print(f"资产总额: {asset.total_asset}\n"  
+              f"持仓市值：{asset.market_value}\n"
+              f"可用资金：{asset.cash}\n"
+              f"在途资金：{asset.frozen_cash}")
+
+def get_orders_df(xt_trader, account):
+    """获取委托信息"""
+    orders = xt_trader.query_stock_orders(account)
+    if not orders:
+        return pd.DataFrame()
+    
+    orders_data = [(order.stock_code, order.order_volume, order.price, 
+                    order.order_id, order.status_msg,
+                    datetime.fromtimestamp(order.order_time).strftime('%H:%M:%S'))
+                   for order in orders]
+    return pd.DataFrame(orders_data, 
+                       columns=['证券代码', '委托数量', '委托价格', '订单编号', '委托状态', '报单时间'])
+
+def get_trades_df(xt_trader, account):
+    """获取成交信息"""
+    trades = xt_trader.query_stock_trades(account)
+    if not trades:
+        return pd.DataFrame()
+    
+    trades_data = [(trade.stock_code, trade.traded_volume, trade.traded_price,
+                    trade.traded_amount, trade.order_id, trade.traded_id,
+                    datetime.fromtimestamp(trade.traded_time).strftime('%H:%M:%S'))
+                   for trade in trades]
+    return pd.DataFrame(trades_data,
+                       columns=['证券代码', '成交数量', '成交均价', '成交金额', '订单编号', '成交编号', '成交时间'])
+
+def get_positions_df(xt_trader, account):
+    """获取持仓信息"""
+    positions = xt_trader.query_stock_positions(account)
+    if not positions:
+        return pd.DataFrame()
+    
+    positions_data = [(position.stock_code, position.volume, position.can_use_volume,
+                       position.frozen_volume, position.open_price, position.market_value,
+                       position.on_road_volume, position.yesterday_volume)
+                      for position in positions]
+    return pd.DataFrame(positions_data,
+                        columns=['证券代码', '持仓数量', '可用数量', '冻结数量', '开仓价格', 
+                                '持仓市值', '在途股份', '昨夜持股'])
+
+def print_summary_info(orders_df, trades_df, positions_df):
+    """打印汇总信息"""
+    print('-'*18, '【当日汇总】', '-'*18)
+    print(f"委托个数：{len(orders_df)}    成交个数：{len(trades_df)}    持仓数量：{len(positions_df)}")
+    
+    print('-'*18, "【订单信息】", '-'*18)
+    print(orders_df if not orders_df.empty else "无委托信息")
+
+    print('-'*18, "【成交信息】", '-'*18)
+    print(trades_df if not trades_df.empty else "无成交信息")
+
+    print('-'*18, "【持仓信息】", '-'*18)
+    print(positions_df if not positions_df.empty else "无持仓信息")
+
+def main():
+    # 尝试加载已有配置
+    saved_path, saved_acc = load_config()
+    path, acc = saved_path, saved_acc
+    
+    # 初始化变量
+    xt_trader = None
+    account = None
+    
+    # 如果配置不存在或连接失败，要求用户重新输入
+    while True:
+        if path and acc:
+            print(f"使用已保存配置：\n路径: {path}\n账号: {acc}")
+            confirm = input("请选择是否使用此配置？(Y/n): ").strip().lower()
+            if confirm == 'y' or confirm == '':
+                xt_trader, result, account = initialize_trader(path, acc)
+                if result == 0:  # 订阅成功
+                    break
+                elif result is None:  # 连接失败
+                    path, acc = None, None  # 需要重新输入全部信息
+                else:  # 仅订阅失败
+                    path = path  # 保留路径
+                    acc = None   # 仅需要重新输入账号
+        
+        # 获取新配置
+        path, acc = get_user_input(path)  # 如果path不为None，则只输入账号
+        save_config(path, acc)
+        xt_trader, result, account = initialize_trader(path, acc)
+        if result == 0:  # 订阅成功
+            break
+        
+        print("配置失败，请重新输入...\n")
+
+    # 打印账户信息
+    print_account_info(xt_trader, account)
+
+    # 获取并打印交易信息
+    orders_df = get_orders_df(xt_trader, account)
+    trades_df = get_trades_df(xt_trader, account)
+    positions_df = get_positions_df(xt_trader, account)
+    
+    # 打印汇总信息
+    print_summary_info(orders_df, trades_df, positions_df)
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/env_example.txt b/env_example.txt
index 2549f5b..5cb109f 100644
--- a/env_example.txt
+++ b/env_example.txt
@@ -6,6 +6,7 @@
 # DeepSeek API配置
 DEEPSEEK_API_KEY=your_deepseek_api_key_here
 DEEPSEEK_BASE_URL=https://api.deepseek.com/v1
+DEEPSEEK_MODEL_NAME=deepseek-chat
 
 # Tushare数据源配置（备用数据源）
 TUSHARE_TOKEN=your_tushare_token_here
diff --git a/longhubang.db b/longhubang.db
deleted file mode 100644
index f1c273b..0000000
Binary files a/longhubang.db and /dev/null differ
diff --git a/longhubang_agents.py b/longhubang_agents.py
index fba5a39..34ceab6 100644
--- a/longhubang_agents.py
+++ b/longhubang_agents.py
@@ -6,15 +6,26 @@
 from deepseek_client import DeepSeekClient
 from typing import Dict, Any, List
 import time
+import config
 
 
 class LonghubangAgents:
     """龙虎榜AI分析师集合"""
     
-    def __init__(self, model="deepseek-chat"):
-        self.model = model
-        self.deepseek_client = DeepSeekClient(model=model)
-        print(f"[智瞰龙虎] AI分析师系统初始化 (模型: {model})")
+    def __init__(self, model=None):
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                print(f"[智瞰龙虎] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+            else:
+                print(f"[智瞰龙虎] AI分析师系统初始化 - 使用配置文件中的默认模型: {self.model}")
+        else:
+            self.model = model
+            print(f"[智瞰龙虎] AI分析师系统初始化 - 使用传入的模型参数: {self.model}")
+        self.deepseek_client = DeepSeekClient(model=self.model)
+        print(f"[智瞰龙虎] AI分析师系统初始化完成 - 最终使用的模型: {self.model}")
     
     def youzi_behavior_analyst(self, longhubang_data: str, summary: Dict) -> Dict[str, Any]:
         """
diff --git a/longhubang_db.py b/longhubang_db.py
index e9db828..4991a93 100644
--- a/longhubang_db.py
+++ b/longhubang_db.py
@@ -13,14 +13,23 @@
 class LonghubangDatabase:
     """龙虎榜数据库管理类"""
     
-    def __init__(self, db_path='longhubang.db'):
+    def __init__(self, db_path=None):
         """
         初始化数据库
         
         Args:
-            db_path: 数据库文件路径
+            db_path: 数据库文件路径，如果为None，则使用data目录下的longhubang.db（确保持久化）
         """
-        self.db_path = db_path
+        # 如果没有指定路径，使用data目录下的数据库文件（确保容器重启后数据不丢失）
+        if db_path is None:
+            import os
+            data_dir = os.path.join(os.path.dirname(__file__), 'data')
+            if not os.path.exists(data_dir):
+                os.makedirs(data_dir, exist_ok=True)
+            self.db_path = os.path.join(data_dir, 'longhubang.db')
+        else:
+            self.db_path = db_path
+        print(f"[LonghubangDatabase] 数据库文件路径: {self.db_path}")
         # 初始化日志
         self.logger = logging.getLogger(__name__)
         if not self.logger.handlers:
diff --git a/longhubang_engine.py b/longhubang_engine.py
index 69ecd06..d5b825f 100644
--- a/longhubang_engine.py
+++ b/longhubang_engine.py
@@ -16,17 +16,26 @@
 class LonghubangEngine:
     """龙虎榜综合分析引擎"""
     
-    def __init__(self, model="deepseek-chat", db_path='longhubang.db'):
+    def __init__(self, model=None, db_path=None):
         """
         初始化分析引擎
         
         Args:
-            model: AI模型名称
+            model: AI模型名称（如果不传入，则使用配置文件中的默认模型）
             db_path: 数据库路径
         """
+        import config
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                print(f"[智瞰龙虎引擎] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+        else:
+            self.model = model
         self.data_fetcher = LonghubangDataFetcher()
         self.database = LonghubangDatabase(db_path)
-        self.agents = LonghubangAgents(model=model)
+        self.agents = LonghubangAgents(model=self.model)
         self.scoring = LonghubangScoring()
         # 初始化日志
         self.logger = logging.getLogger(__name__)
diff --git a/longhubang_ui.py b/longhubang_ui.py
index e10dc60..b00d5b7 100644
--- a/longhubang_ui.py
+++ b/longhubang_ui.py
@@ -13,6 +13,7 @@
 
 from longhubang_engine import LonghubangEngine
 from longhubang_pdf import LonghubangPDFGenerator
+import config
 
 
 def display_longhubang():
@@ -135,18 +136,8 @@ def display_analysis_tab():
                 help="分析最近N天的龙虎榜数据"
             )
     
-    with col3:
-        # 导入model_config.py中定义的model_options
-        from model_config import model_options as app_model_options
-        selected_model = st.selectbox(
-            "AI模型",
-            list(app_model_options.keys()),
-            format_func=lambda x: app_model_options[x],
-            help="Reasoner模型提供更强的推理能力"
-        )
-    
     # 分析按钮
-    col1, col2, col3 = st.columns([2, 2, 2])
+    col1, col2 = st.columns([2, 2])
     
     with col1:
         analyze_button = st.button("🚀 开始分析", type="primary", width='stretch')
@@ -158,6 +149,8 @@ def display_analysis_tab():
             st.success("已清除分析结果")
             st.rerun()
     
+    st.info("💡 提示：AI模型选择在左侧边栏，选择后将在所有功能中生效")
+    
     st.markdown("---")
     
     # 开始分析
@@ -166,6 +159,14 @@ def display_analysis_tab():
         if 'longhubang_result' in st.session_state:
             del st.session_state.longhubang_result
         
+        # 使用全局模型选择
+        from model_config import model_options
+        selected_model = st.session_state.get('selected_model')
+        if not selected_model or selected_model not in model_options:
+            selected_model = config.DEEPSEEK_MODEL_NAME
+            if selected_model not in model_options:
+                selected_model = list(model_options.keys())[0]
+        
         # 准备参数
         if analysis_mode == "指定日期":
             date_str = selected_date.strftime('%Y-%m-%d')
@@ -183,9 +184,18 @@ def display_analysis_tab():
             st.error(f"❌ 分析失败: {result.get('error', '未知错误')}")
 
 
-def run_longhubang_analysis(model="deepseek-chat", date=None, days=1):
+def run_longhubang_analysis(model=None, date=None, days=1):
     """运行龙虎榜分析"""
     
+    # 如果没有传入model，则使用全局模型选择
+    if model is None:
+        from model_config import model_options
+        model = st.session_state.get('selected_model')
+        if not model or model not in model_options:
+            model = config.DEEPSEEK_MODEL_NAME
+            if model not in model_options:
+                model = list(model_options.keys())[0]
+    
     # 进度显示
     progress_bar = st.progress(0)
     status_text = st.empty()
@@ -1378,6 +1388,15 @@ def run_longhubang_batch_analysis():
         results = []
         start_time = time.time()
         
+        # 使用全局模型选择（在循环外获取，避免重复）
+        from model_config import model_options
+        selected_model = st.session_state.get('selected_model')
+        if not selected_model or selected_model not in model_options:
+            import config
+            selected_model = config.DEEPSEEK_MODEL_NAME
+            if selected_model not in model_options:
+                selected_model = list(model_options.keys())[0]
+
         if analysis_mode == "sequential":
             # 顺序分析
             for i, code in enumerate(stock_codes):
@@ -1385,7 +1404,7 @@ def run_longhubang_batch_analysis():
                 progress_bar.progress((i + 1) / len(stock_codes))
                 
                 try:
-                    # 调用统一分析函数
+                    # 调用统一分析函数（使用全局模型选择）
                     result = analyze_single_stock_for_batch(
                         symbol=code,
                         period="1y",
@@ -1397,7 +1416,7 @@ def run_longhubang_batch_analysis():
                             'sentiment': False,
                             'news': False
                         },
-                        selected_model='deepseek-chat'
+                        selected_model=selected_model
                     )
                     
                     results.append({
@@ -1417,6 +1436,7 @@ def run_longhubang_batch_analysis():
             
             def analyze_one(code):
                 try:
+                    # 使用全局模型选择（已在循环外获取）
                     result = analyze_single_stock_for_batch(
                         symbol=code,
                         period="1y",
@@ -1428,7 +1448,7 @@ def analyze_one(code):
                             'sentiment': False,
                             'news': False
                         },
-                        selected_model='deepseek-chat'
+                        selected_model=selected_model
                     )
                     return {"code": code, "result": result}
                 except Exception as e:
diff --git a/low_price_bull_monitor.db b/low_price_bull_monitor.db
deleted file mode 100644
index 1f5cbc1..0000000
Binary files a/low_price_bull_monitor.db and /dev/null differ
diff --git a/low_price_bull_monitor.py b/low_price_bull_monitor.py
index 4963eb9..61dec68 100644
--- a/low_price_bull_monitor.py
+++ b/low_price_bull_monitor.py
@@ -16,15 +16,24 @@
 class LowPriceBullMonitor:
     """低价擒牛策略监控器"""
     
-    def __init__(self, db_path: str = "low_price_bull_monitor.db"):
+    def __init__(self, db_path: str = None):
         """
         初始化监控器
         
         Args:
-            db_path: 数据库文件路径
+            db_path: 数据库文件路径，如果为None，则使用data目录下的low_price_bull_monitor.db（确保持久化）
         """
         self.logger = logging.getLogger(__name__)
-        self.db_path = db_path
+        # 如果没有指定路径，使用data目录下的数据库文件（确保容器重启后数据不丢失）
+        if db_path is None:
+            import os
+            data_dir = os.path.join(os.path.dirname(__file__), 'data')
+            if not os.path.exists(data_dir):
+                os.makedirs(data_dir, exist_ok=True)
+            self.db_path = os.path.join(data_dir, 'low_price_bull_monitor.db')
+        else:
+            self.db_path = db_path
+        print(f"[LowPriceBullMonitor] 数据库文件路径: {self.db_path}")
         self._init_database()
     
     def _init_database(self):
diff --git a/main_force_analysis.py b/main_force_analysis.py
index f7de82a..902a9d5 100644
--- a/main_force_analysis.py
+++ b/main_force_analysis.py
@@ -14,14 +14,27 @@
 import time
 import json
 
+import config
+
 class MainForceAnalyzer:
     """主力选股分析器 - 批量整体分析"""
     
-    def __init__(self, model='deepseek-chat'):
+    def __init__(self, model=None):
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                print(f"[MainForceAnalyzer] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+            else:
+                print(f"[MainForceAnalyzer] 使用配置文件中的默认模型: {self.model}")
+        else:
+            self.model = model
+            print(f"[MainForceAnalyzer] 使用传入的模型参数: {self.model}")
+        print(f"[MainForceAnalyzer] ✅ 最终使用的模型: {self.model}")
         self.selector = main_force_selector
         self.fetcher = StockDataFetcher()
-        self.model = model
-        self.agents = StockAnalysisAgents(model=model)
+        self.agents = StockAnalysisAgents(model=self.model)
         self.deepseek_client = self.agents.deepseek_client
         self.raw_stocks = None
         self.final_recommendations = []
diff --git a/main_force_batch.db b/main_force_batch.db
deleted file mode 100644
index 8e5b6a2..0000000
Binary files a/main_force_batch.db and /dev/null differ
diff --git a/main_force_batch_db.py b/main_force_batch_db.py
index 55093c7..2bb5f10 100644
--- a/main_force_batch_db.py
+++ b/main_force_batch_db.py
@@ -13,9 +13,23 @@
 class MainForceBatchDatabase:
     """主力选股批量分析历史数据库管理类"""
     
-    def __init__(self, db_path: str = "main_force_batch.db"):
-        """初始化数据库连接"""
-        self.db_path = db_path
+    def __init__(self, db_path: str = None):
+        """
+        初始化数据库连接
+        
+        Args:
+            db_path: 数据库文件路径，如果为None，则使用data目录下的main_force_batch.db（确保持久化）
+        """
+        # 如果没有指定路径，使用data目录下的数据库文件（确保容器重启后数据不丢失）
+        if db_path is None:
+            import os
+            data_dir = os.path.join(os.path.dirname(__file__), 'data')
+            if not os.path.exists(data_dir):
+                os.makedirs(data_dir, exist_ok=True)
+            self.db_path = os.path.join(data_dir, 'main_force_batch.db')
+        else:
+            self.db_path = db_path
+        print(f"[MainForceBatchDatabase] 数据库文件路径: {self.db_path}")
         self._init_database()
     
     def _init_database(self):
@@ -124,26 +138,72 @@ def save_batch_analysis(
         Returns:
             记录ID
         """
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        analysis_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
-        # 清理结果数据，确保可以JSON序列化
-        cleaned_results = self._clean_results_for_json(results)
-        results_json = json.dumps(cleaned_results, ensure_ascii=False, default=str)
-        
-        cursor.execute('''
-            INSERT INTO batch_analysis_history 
-            (analysis_date, batch_count, analysis_mode, success_count, failed_count, total_time, results_json)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        ''', (analysis_date, batch_count, analysis_mode, success_count, failed_count, total_time, results_json))
-        
-        record_id = cursor.lastrowid
-        conn.commit()
-        conn.close()
-        
-        return record_id
+        try:
+            print(f"[MainForceBatchDatabase] 开始保存批量分析结果...")
+            print(f"[MainForceBatchDatabase] 数据库路径: {self.db_path}")
+            print(f"[MainForceBatchDatabase] 参数: batch_count={batch_count}, mode={analysis_mode}, success={success_count}, failed={failed_count}")
+            
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            analysis_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            
+            # 清理结果数据，确保可以JSON序列化
+            print(f"[MainForceBatchDatabase] 清理结果数据... (共 {len(results)} 条)")
+            cleaned_results = self._clean_results_for_json(results)
+            print(f"[MainForceBatchDatabase] 清理完成，开始序列化JSON...")
+            
+            results_json = json.dumps(cleaned_results, ensure_ascii=False, default=str)
+            json_size = len(results_json)
+            print(f"[MainForceBatchDatabase] JSON序列化完成，大小: {json_size} 字节")
+            
+            # 检查JSON大小（SQLite TEXT字段默认最大1GB，但为了避免问题，可以设置限制）
+            if json_size > 100 * 1024 * 1024:  # 100MB
+                print(f"[MainForceBatchDatabase] 警告: JSON数据过大 ({json_size} 字节)，可能影响性能")
+            
+            print(f"[MainForceBatchDatabase] 执行INSERT语句...")
+            cursor.execute('''
+                INSERT INTO batch_analysis_history 
+                (analysis_date, batch_count, analysis_mode, success_count, failed_count, total_time, results_json)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            ''', (analysis_date, batch_count, analysis_mode, success_count, failed_count, total_time, results_json))
+            
+            record_id = cursor.lastrowid
+            print(f"[MainForceBatchDatabase] INSERT成功，记录ID: {record_id}")
+            
+            conn.commit()
+            print(f"[MainForceBatchDatabase] 事务提交成功")
+            
+            # 验证保存是否成功
+            cursor.execute('SELECT COUNT(*) FROM batch_analysis_history WHERE id = ?', (record_id,))
+            count = cursor.fetchone()[0]
+            if count == 0:
+                raise Exception(f"保存后验证失败：记录ID {record_id} 不存在")
+            
+            print(f"[MainForceBatchDatabase] 保存验证成功，记录已存在")
+            conn.close()
+            
+            # 再次验证：查询最新的记录
+            conn2 = sqlite3.connect(self.db_path)
+            cursor2 = conn2.cursor()
+            cursor2.execute('SELECT COUNT(*) FROM batch_analysis_history')
+            total_count = cursor2.fetchone()[0]
+            conn2.close()
+            print(f"[MainForceBatchDatabase] 数据库总记录数: {total_count} 条")
+            
+            return record_id
+            
+        except Exception as e:
+            import traceback
+            error_msg = f"保存批量分析结果失败: {str(e)}\n{traceback.format_exc()}"
+            print(f"[MainForceBatchDatabase] ❌ {error_msg}")
+            if 'conn' in locals():
+                try:
+                    conn.rollback()
+                    conn.close()
+                except:
+                    pass
+            raise Exception(error_msg) from e
     
     def get_all_history(self, limit: int = 50) -> List[Dict]:
         """
@@ -155,40 +215,55 @@ def get_all_history(self, limit: int = 50) -> List[Dict]:
         Returns:
             历史记录列表
         """
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute('''
-            SELECT id, analysis_date, batch_count, analysis_mode, 
-                   success_count, failed_count, total_time, results_json, created_at
-            FROM batch_analysis_history
-            ORDER BY created_at DESC
-            LIMIT ?
-        ''', (limit,))
-        
-        rows = cursor.fetchall()
-        conn.close()
-        
-        history = []
-        for row in rows:
-            try:
-                results = json.loads(row[7])
-            except:
-                results = []
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
             
-            history.append({
-                'id': row[0],
-                'analysis_date': row[1],
-                'batch_count': row[2],
-                'analysis_mode': row[3],
-                'success_count': row[4],
-                'failed_count': row[5],
-                'total_time': row[6],
-                'results': results,
-                'created_at': row[8]
-            })
-        
-        return history
+            # 检查表是否存在
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='batch_analysis_history';")
+            if not cursor.fetchone():
+                conn.close()
+                print(f"[MainForceBatchDatabase] ⚠️ 表 batch_analysis_history 不存在，初始化数据库...")
+                self._init_database()
+                conn = sqlite3.connect(self.db_path)
+                cursor = conn.cursor()
+            
+            cursor.execute('''
+                SELECT id, analysis_date, batch_count, analysis_mode, 
+                       success_count, failed_count, total_time, results_json, created_at
+                FROM batch_analysis_history
+                ORDER BY created_at DESC
+                LIMIT ?
+            ''', (limit,))
+            
+            rows = cursor.fetchall()
+            conn.close()
+            
+            history = []
+            for row in rows:
+                try:
+                    results = json.loads(row[7])
+                except:
+                    results = []
+                
+                history.append({
+                    'id': row[0],
+                    'analysis_date': row[1],
+                    'batch_count': row[2],
+                    'analysis_mode': row[3],
+                    'success_count': row[4],
+                    'failed_count': row[5],
+                    'total_time': row[6],
+                    'results': results,
+                    'created_at': row[8]
+                })
+            
+            return history
+        except Exception as e:
+            import traceback
+            print(f"[MainForceBatchDatabase] ❌ 获取历史记录失败: {str(e)}")
+            print(traceback.format_exc())
+            raise
     
     def get_record_by_id(self, record_id: int) -> Optional[Dict]:
         """
@@ -261,39 +336,54 @@ def get_statistics(self) -> Dict:
         Returns:
             统计数据
         """
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        # 总记录数
-        cursor.execute('SELECT COUNT(*) FROM batch_analysis_history')
-        total_records = cursor.fetchone()[0]
-        
-        # 总分析股票数
-        cursor.execute('SELECT SUM(batch_count) FROM batch_analysis_history')
-        total_stocks = cursor.fetchone()[0] or 0
-        
-        # 总成功数
-        cursor.execute('SELECT SUM(success_count) FROM batch_analysis_history')
-        total_success = cursor.fetchone()[0] or 0
-        
-        # 总失败数
-        cursor.execute('SELECT SUM(failed_count) FROM batch_analysis_history')
-        total_failed = cursor.fetchone()[0] or 0
-        
-        # 平均耗时
-        cursor.execute('SELECT AVG(total_time) FROM batch_analysis_history')
-        avg_time = cursor.fetchone()[0] or 0
-        
-        conn.close()
-        
-        return {
-            'total_records': total_records,
-            'total_stocks_analyzed': total_stocks,
-            'total_success': total_success,
-            'total_failed': total_failed,
-            'average_time': round(avg_time, 2),
-            'success_rate': round(total_success / total_stocks * 100, 2) if total_stocks > 0 else 0
-        }
+        try:
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            # 检查表是否存在
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='batch_analysis_history';")
+            if not cursor.fetchone():
+                conn.close()
+                print(f"[MainForceBatchDatabase] ⚠️ 表 batch_analysis_history 不存在，初始化数据库...")
+                self._init_database()
+                conn = sqlite3.connect(self.db_path)
+                cursor = conn.cursor()
+            
+            # 总记录数
+            cursor.execute('SELECT COUNT(*) FROM batch_analysis_history')
+            total_records = cursor.fetchone()[0]
+            
+            # 总分析股票数
+            cursor.execute('SELECT SUM(batch_count) FROM batch_analysis_history')
+            total_stocks = cursor.fetchone()[0] or 0
+            
+            # 总成功数
+            cursor.execute('SELECT SUM(success_count) FROM batch_analysis_history')
+            total_success = cursor.fetchone()[0] or 0
+            
+            # 总失败数
+            cursor.execute('SELECT SUM(failed_count) FROM batch_analysis_history')
+            total_failed = cursor.fetchone()[0] or 0
+            
+            # 平均耗时
+            cursor.execute('SELECT AVG(total_time) FROM batch_analysis_history')
+            avg_time = cursor.fetchone()[0] or 0
+            
+            conn.close()
+            
+            return {
+                'total_records': total_records,
+                'total_stocks_analyzed': total_stocks,
+                'total_success': total_success,
+                'total_failed': total_failed,
+                'average_time': round(avg_time, 2),
+                'success_rate': round(total_success / total_stocks * 100, 2) if total_stocks > 0 else 0
+            }
+        except Exception as e:
+            import traceback
+            print(f"[MainForceBatchDatabase] ❌ 获取统计信息失败: {str(e)}")
+            print(traceback.format_exc())
+            raise
 
 
 # 全局数据库实例
diff --git a/main_force_history_ui.py b/main_force_history_ui.py
index a4e4015..370b145 100644
--- a/main_force_history_ui.py
+++ b/main_force_history_ui.py
@@ -44,13 +44,78 @@ def display_batch_history():
         
     except Exception as e:
         st.warning(f"⚠️ 无法获取统计信息: {str(e)}")
+        import traceback
+        st.code(traceback.format_exc())
     
     # 获取历史记录
     try:
+        # 添加调试信息（使用expander折叠，避免影响正常显示）
+        with st.expander("🔍 调试信息", expanded=False):
+            st.caption(f"📊 数据库路径: {batch_db.db_path}")
+            import os
+            if os.path.exists(batch_db.db_path):
+                db_size = os.path.getsize(batch_db.db_path)
+                st.caption(f"📊 数据库文件大小: {db_size} 字节")
+            else:
+                st.warning(f"⚠️ 数据库文件不存在: {batch_db.db_path}")
+        
         history_records = batch_db.get_all_history(limit=50)
         
         if not history_records:
             st.info("📝 暂无批量分析历史记录")
+            st.caption(f"💡 数据库文件位置: {batch_db.db_path}")
+            st.caption("💡 提示: 如果您已经运行过批量分析，请确认数据是否正确保存到数据库")
+            
+            # 提供手动检查数据库的按钮
+            if st.button("🔍 检查数据库状态"):
+                import os
+                import sqlite3
+                
+                with st.expander("📊 数据库详细信息", expanded=True):
+                    st.write(f"**数据库路径**: {batch_db.db_path}")
+                    st.write(f"**文件存在**: {'✅ 是' if os.path.exists(batch_db.db_path) else '❌ 否'}")
+                    
+                    if os.path.exists(batch_db.db_path):
+                        db_size = os.path.getsize(batch_db.db_path)
+                        st.write(f"**文件大小**: {db_size} 字节")
+                        
+                        # 尝试连接数据库并查询表
+                        try:
+                            conn = sqlite3.connect(batch_db.db_path)
+                            cursor = conn.cursor()
+                            
+                            # 检查表是否存在
+                            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='batch_analysis_history'")
+                            table_exists = cursor.fetchone() is not None
+                            st.write(f"**表存在**: {'✅ 是' if table_exists else '❌ 否'}")
+                            
+                            if table_exists:
+                                # 查询记录数
+                                cursor.execute("SELECT COUNT(*) FROM batch_analysis_history")
+                                count = cursor.fetchone()[0]
+                                st.write(f"**记录数**: {count} 条")
+                                
+                                if count > 0:
+                                    # 显示最近几条记录的信息
+                                    cursor.execute("""
+                                        SELECT id, analysis_date, batch_count, success_count, failed_count 
+                                        FROM batch_analysis_history 
+                                        ORDER BY created_at DESC 
+                                        LIMIT 5
+                                    """)
+                                    rows = cursor.fetchall()
+                                    st.write("**最近5条记录**:")
+                                    for row in rows:
+                                        st.write(f"- ID: {row[0]}, 时间: {row[1]}, 数量: {row[2]}, 成功: {row[3]}, 失败: {row[4]}")
+                            else:
+                                st.warning("⚠️ 表 'batch_analysis_history' 不存在，可能是数据库未初始化")
+                            
+                            conn.close()
+                        except Exception as e:
+                            st.error(f"❌ 查询数据库时出错: {str(e)}")
+                    else:
+                        st.warning("⚠️ 数据库文件不存在，可能是首次运行或数据库路径配置错误")
+            
             return
         
         st.markdown(f"### 📋 最近 {len(history_records)} 条记录")
diff --git a/main_force_ui.py b/main_force_ui.py
index 5477f48..51e2873 100644
--- a/main_force_ui.py
+++ b/main_force_ui.py
@@ -10,6 +10,7 @@
 from main_force_pdf_generator import display_report_download_section
 from main_force_history_ui import display_batch_history
 import pandas as pd
+import config
 
 def display_main_force_selector():
     """显示主力选股界面"""
@@ -127,16 +128,8 @@ def display_main_force_selector():
                 step=100.0
             )
 
-    # 模型选择
-    # 导入model_config.py中定义的model_options
-    from model_config import model_options as app_model_options
-    model = st.selectbox(
-        "选择AI模型",
-        list(app_model_options.keys()),
-        format_func=lambda x: app_model_options[x],
-        help="deepseek-chat速度快，deepseek-reasoner推理能力强"
-    )
-
+    st.info("💡 提示：AI模型选择在左侧边栏，选择后将在所有功能中生效")
+    
     st.markdown("---")
 
     # 开始分析按钮
@@ -144,6 +137,14 @@ def display_main_force_selector():
 
         with st.spinner("正在获取数据并分析，这可能需要几分钟..."):
 
+            # 使用全局模型选择
+            from model_config import model_options
+            model = st.session_state.get('selected_model')
+            if not model or model not in model_options:
+                model = config.DEEPSEEK_MODEL_NAME
+                if model not in model_options:
+                    model = list(model_options.keys())[0]
+
             # 创建分析器
             analyzer = MainForceAnalyzer(model=model)
 
@@ -179,171 +180,228 @@ def display_analysis_results(result: dict, analyzer):
     """显示分析结果"""
 
     st.markdown("---")
-    st.markdown("## 📊 分析结果")
-
-    # 统计信息
-    col1, col2, col3 = st.columns(3)
-
-    with col1:
-        st.metric("获取股票数", result['total_stocks'])
-
-    with col2:
-        st.metric("筛选后", result['filtered_stocks'])
+    
+    # 创建左右两列布局：左侧显示分析结果，右侧显示批量分析历史
+    col_left, col_right = st.columns([3, 1])
+    
+    with col_left:
+        st.markdown("## 📊 分析结果")
 
-    with col3:
-        st.metric("最终推荐", len(result['final_recommendations']))
+        # 统计信息
+        col1, col2, col3 = st.columns(3)
 
-    st.markdown("---")
+        with col1:
+            st.metric("获取股票数", result['total_stocks'])
 
-    # 显示AI分析师完整报告
-    if analyzer and hasattr(analyzer, 'fund_flow_analysis'):
-        display_analyst_reports(analyzer)
+        with col2:
+            st.metric("筛选后", result['filtered_stocks'])
 
-    st.markdown("---")
+        with col3:
+            st.metric("最终推荐", len(result['final_recommendations']))
 
-    # 显示推荐股票
-    if result['final_recommendations']:
-        st.markdown("### ⭐ 精选推荐")
+        st.markdown("---")
 
-        for rec in result['final_recommendations']:
-            with st.expander(
-                f"【第{rec['rank']}名】{rec['symbol']} - {rec['name']}",
-                expanded=(rec['rank'] <= 3)
-            ):
-                display_recommendation_detail(rec)
+        # 显示AI分析师完整报告
+        if analyzer and hasattr(analyzer, 'fund_flow_analysis'):
+            display_analyst_reports(analyzer)
 
-    # 显示候选股票列表
-    if analyzer and analyzer.raw_stocks is not None and not analyzer.raw_stocks.empty:
         st.markdown("---")
-        st.markdown("### 📋 候选股票列表（筛选后）")
-
-        # 选择关键列显示
-        display_cols = ['股票代码', '股票简称']
-
-        # 添加行业列
-        industry_cols = [col for col in analyzer.raw_stocks.columns if '行业' in col]
-        if industry_cols:
-            display_cols.append(industry_cols[0])
-
-        # 添加区间主力资金净流入（智能匹配）
-        main_fund_col = None
-        main_fund_patterns = [
-            '区间主力资金流向',      # 实际列名
-            '区间主力资金净流入',
-            '主力资金流向',
-            '主力资金净流入',
-            '主力净流入',
-            '主力资金'
-        ]
-        for pattern in main_fund_patterns:
-            matching = [col for col in analyzer.raw_stocks.columns if pattern in col]
-            if matching:
-                main_fund_col = matching[0]
-                break
-        if main_fund_col:
-            display_cols.append(main_fund_col)
-
-        # 添加区间涨跌幅（前复权）（智能匹配）
-        interval_pct_col = None
-        interval_pct_patterns = [
-            '区间涨跌幅:前复权', '区间涨跌幅:前复权(%)', '区间涨跌幅(%)',
-            '区间涨跌幅', '涨跌幅:前复权', '涨跌幅:前复权(%)', '涨跌幅(%)', '涨跌幅'
-        ]
-        for pattern in interval_pct_patterns:
-            matching = [col for col in analyzer.raw_stocks.columns if pattern in col]
-            if matching:
-                interval_pct_col = matching[0]
-                break
-        if interval_pct_col:
-            display_cols.append(interval_pct_col)
-
-        # 添加市值、市盈率、市净率
-        for col_name in ['总市值', '市盈率', '市净率']:
-            matching_cols = [col for col in analyzer.raw_stocks.columns if col_name in col]
-            if matching_cols:
-                display_cols.append(matching_cols[0])
-
-        # 选择存在的列
-        final_cols = [col for col in display_cols if col in analyzer.raw_stocks.columns]
-
-        # 调试信息：显示找到的列名
-        with st.expander("🔍 调试信息 - 查看数据列", expanded=False):
-            st.caption("所有可用列:")
-            cols_list = list(analyzer.raw_stocks.columns)
-            st.write(cols_list)
-            st.caption(f"\n已选择显示的列: {final_cols}")
+
+        # 显示推荐股票
+        if result['final_recommendations']:
+            st.markdown("### ⭐ 精选推荐")
+
+            for rec in result['final_recommendations']:
+                with st.expander(
+                    f"【第{rec['rank']}名】{rec['symbol']} - {rec['name']}",
+                    expanded=(rec['rank'] <= 3)
+                ):
+                    display_recommendation_detail(rec)
+
+        # 显示候选股票列表
+        if analyzer and analyzer.raw_stocks is not None and not analyzer.raw_stocks.empty:
+            st.markdown("---")
+            st.markdown("### 📋 候选股票列表（筛选后）")
+
+            # 选择关键列显示
+            display_cols = ['股票代码', '股票简称']
+
+            # 添加行业列
+            industry_cols = [col for col in analyzer.raw_stocks.columns if '行业' in col]
+            if industry_cols:
+                display_cols.append(industry_cols[0])
+
+            # 添加区间主力资金净流入（智能匹配）
+            main_fund_col = None
+            main_fund_patterns = [
+                '区间主力资金流向',      # 实际列名
+                '区间主力资金净流入',
+                '主力资金流向',
+                '主力资金净流入',
+                '主力净流入',
+                '主力资金'
+            ]
+            for pattern in main_fund_patterns:
+                matching = [col for col in analyzer.raw_stocks.columns if pattern in col]
+                if matching:
+                    main_fund_col = matching[0]
+                    break
             if main_fund_col:
-                st.success(f"✅ 找到主力资金列: {main_fund_col}")
-            else:
-                st.warning("⚠️ 未找到主力资金列")
+                display_cols.append(main_fund_col)
+
+            # 添加区间涨跌幅（前复权）（智能匹配）
+            interval_pct_col = None
+            interval_pct_patterns = [
+                '区间涨跌幅:前复权', '区间涨跌幅:前复权(%)', '区间涨跌幅(%)',
+                '区间涨跌幅', '涨跌幅:前复权', '涨跌幅:前复权(%)', '涨跌幅(%)', '涨跌幅'
+            ]
+            for pattern in interval_pct_patterns:
+                matching = [col for col in analyzer.raw_stocks.columns if pattern in col]
+                if matching:
+                    interval_pct_col = matching[0]
+                    break
             if interval_pct_col:
-                st.success(f"✅ 找到涨跌幅列: {interval_pct_col}")
-            else:
-                st.warning("⚠️ 未找到涨跌幅列")
-
-        # 显示DataFrame
-        display_df = analyzer.raw_stocks[final_cols].copy()
-        st.dataframe(display_df, width='content', height=400)
-
-        # 显示统计
-        st.caption(f"共 {len(display_df)} 只候选股票，显示 {len(final_cols)} 个字段")
-
-        # 下载按钮
-        csv = display_df.to_csv(index=False, encoding='utf-8-sig')
-        st.download_button(
-            label="📥 下载候选列表CSV",
-            data=csv,
-            file_name=f"main_force_stocks_{datetime.now().strftime('%Y%m%d')}.csv",
-            mime="text/csv"
-        )
-
-        # 批量分析功能区
-        st.markdown("---")
-
-        col_batch1, col_batch2, col_batch3 = st.columns([2, 1, 1])
-        with col_batch1:
-            st.markdown("#### 🚀 批量深度分析")
-            st.caption("对主力资金净流入TOP股票进行完整的AI团队分析，获取投资评级和关键价位")
-
-        with col_batch2:
-            batch_count = st.selectbox(
-                "分析数量",
-                options=[10, 20, 30, 50],
-                index=1,  # 默认20只
-                help="选择分析主力资金净流入前N只股票"
-            )
-
-        with col_batch3:
-            st.write("")  # 占位
-            if st.button("🚀 开始批量分析", type="primary", width='content'):
-                # 准备数据：按主力资金净流入排序
-                df_sorted = analyzer.raw_stocks.copy()
-
-                # 确保主力资金列是数值类型并排序
+                display_cols.append(interval_pct_col)
+
+            # 添加市值、市盈率、市净率
+            for col_name in ['总市值', '市盈率', '市净率']:
+                matching_cols = [col for col in analyzer.raw_stocks.columns if col_name in col]
+                if matching_cols:
+                    display_cols.append(matching_cols[0])
+
+            # 选择存在的列
+            final_cols = [col for col in display_cols if col in analyzer.raw_stocks.columns]
+
+            # 调试信息：显示找到的列名
+            with st.expander("🔍 调试信息 - 查看数据列", expanded=False):
+                st.caption("所有可用列:")
+                cols_list = list(analyzer.raw_stocks.columns)
+                st.write(cols_list)
+                st.caption(f"\n已选择显示的列: {final_cols}")
                 if main_fund_col:
-                    df_sorted[main_fund_col] = pd.to_numeric(df_sorted[main_fund_col], errors='coerce')
-                    df_sorted = df_sorted.sort_values(by=main_fund_col, ascending=False)
-
-                # 提取股票代码并去掉市场后缀（.SH, .SZ等）
-                raw_codes = df_sorted.head(batch_count)['股票代码'].tolist()
-                stock_codes = []
-                for code in raw_codes:
-                    # 去掉后缀（如果有的话）
-                    if isinstance(code, str):
-                        # 去掉 .SH, .SZ, .BJ 等后缀
-                        clean_code = code.split('.')[0] if '.' in code else code
-                        stock_codes.append(clean_code)
-                    else:
-                        stock_codes.append(str(code))
-
-                # 存储到session_state，触发批量分析
-                st.session_state.main_force_batch_codes = stock_codes
-                st.session_state.main_force_batch_trigger = True
-                st.rerun()
+                    st.success(f"✅ 找到主力资金列: {main_fund_col}")
+                else:
+                    st.warning("⚠️ 未找到主力资金列")
+                if interval_pct_col:
+                    st.success(f"✅ 找到涨跌幅列: {interval_pct_col}")
+                else:
+                    st.warning("⚠️ 未找到涨跌幅列")
+
+            # 显示DataFrame
+            display_df = analyzer.raw_stocks[final_cols].copy()
+            st.dataframe(display_df, width='content', height=400)
+
+            # 显示统计
+            st.caption(f"共 {len(display_df)} 只候选股票，显示 {len(final_cols)} 个字段")
+
+            # 下载按钮
+            csv = display_df.to_csv(index=False, encoding='utf-8-sig')
+            st.download_button(
+                label="📥 下载候选列表CSV",
+                data=csv,
+                file_name=f"main_force_stocks_{datetime.now().strftime('%Y%m%d')}.csv",
+                mime="text/csv"
+            )
 
-    # 显示PDF报告下载区域
-    if analyzer and result:
-        display_report_download_section(analyzer, result)
+            # 批量分析功能区
+            st.markdown("---")
+
+            col_batch1, col_batch2, col_batch3 = st.columns([2, 1, 1])
+            with col_batch1:
+                st.markdown("#### 🚀 批量深度分析")
+                st.caption("对主力资金净流入TOP股票进行完整的AI团队分析，获取投资评级和关键价位")
+
+            with col_batch2:
+                batch_count = st.selectbox(
+                    "分析数量",
+                    options=[10, 20, 30, 50],
+                    index=1,  # 默认20只
+                    help="选择分析主力资金净流入前N只股票"
+                )
+
+            with col_batch3:
+                st.write("")  # 占位
+                if st.button("🚀 开始批量分析", type="primary", width='content'):
+                    # 准备数据：按主力资金净流入排序
+                    df_sorted = analyzer.raw_stocks.copy()
+
+                    # 确保主力资金列是数值类型并排序
+                    if main_fund_col:
+                        df_sorted[main_fund_col] = pd.to_numeric(df_sorted[main_fund_col], errors='coerce')
+                        df_sorted = df_sorted.sort_values(by=main_fund_col, ascending=False)
+
+                    # 提取股票代码并去掉市场后缀（.SH, .SZ等）
+                    raw_codes = df_sorted.head(batch_count)['股票代码'].tolist()
+                    stock_codes = []
+                    for code in raw_codes:
+                        # 去掉后缀（如果有的话）
+                        if isinstance(code, str):
+                            # 去掉 .SH, .SZ, .BJ 等后缀
+                            clean_code = code.split('.')[0] if '.' in code else code
+                            stock_codes.append(clean_code)
+                        else:
+                            stock_codes.append(str(code))
+
+                    # 存储到session_state，触发批量分析
+                    st.session_state.main_force_batch_codes = stock_codes
+                    st.session_state.main_force_batch_trigger = True
+                    st.rerun()
+
+        # 显示PDF报告下载区域
+        if analyzer and result:
+            display_report_download_section(analyzer, result)
+    
+    # 右侧栏：显示批量分析历史
+    with col_right:
+        st.markdown("### 📚 批量分析历史")
+        st.markdown("---")
+        
+        try:
+            from main_force_batch_db import batch_db
+            
+            # 获取最近的历史记录
+            history_records = batch_db.get_all_history(limit=5)
+            
+            if history_records:
+                for idx, record in enumerate(history_records):
+                    with st.expander(
+                        f"📅 {record['analysis_date'][:10]}",
+                        expanded=(idx == 0)
+                    ):
+                        st.caption(f"**时间**: {record['analysis_date']}")
+                        st.caption(f"**模式**: {record['analysis_mode']}")
+                        st.caption(f"**总数**: {record['batch_count']} 只")
+                        st.caption(f"**成功**: {record['success_count']} 只")
+                        st.caption(f"**失败**: {record['failed_count']} 只")
+                        success_rate = (record['success_count'] / record['batch_count'] * 100) if record['batch_count'] > 0 else 0
+                        st.caption(f"**成功率**: {success_rate:.1f}%")
+                        st.caption(f"**耗时**: {record['total_time']/60:.1f} 分钟")
+                        
+                        # 加载按钮
+                        if st.button(f"🔄 加载", key=f"load_history_{record['id']}", use_container_width=True):
+                            st.session_state.main_force_batch_results = {
+                                "results": record['results'],
+                                "total": record['batch_count'],
+                                "success": record['success_count'],
+                                "failed": record['failed_count'],
+                                "elapsed_time": record['total_time'],
+                                "analysis_mode": record['analysis_mode'],
+                                "saved_to_history": True,  # 从历史记录加载，说明已经保存
+                                "save_error": None
+                            }
+                            st.success("✅ 已加载到当前结果")
+                            st.rerun()
+            else:
+                st.info("📝 暂无批量分析历史记录")
+                
+        except Exception as e:
+            st.warning(f"⚠️ 无法加载历史记录: {str(e)}")
+        
+        # 查看全部历史按钮
+        st.markdown("---")
+        if st.button("📚 查看全部历史", use_container_width=True):
+            st.session_state.main_force_view_history = True
+            st.rerun()
 
 def display_recommendation_detail(rec: dict):
     """显示单个推荐股票的详细信息"""
@@ -613,7 +671,15 @@ def run_main_force_batch_analysis():
             'sentiment': False,  # 禁用以提升速度
             'news': False  # 禁用以提升速度
         }
-        selected_model = 'deepseek-chat'
+
+        # 使用全局模型选择（优先使用侧边栏选择，回退到配置文件）
+        from model_config import model_options
+        selected_model = st.session_state.get('selected_model')
+        if not selected_model or selected_model not in model_options:
+            selected_model = config.DEEPSEEK_MODEL_NAME
+            if selected_model not in model_options:
+                selected_model = list(model_options.keys())[0]
+
         period = '1y'
 
         # 创建进度显示
@@ -721,57 +787,109 @@ def analyze_one(code):
         # 先保存到数据库历史记录（在 rerun 之前完成）
         save_success = False
         save_error = None
-        try:
-            from main_force_batch_db import batch_db
-
-            # 调试信息
-            print(f"\n{'='*60}")
-            print(f"📝 准备保存批量分析结果到历史记录")
-            print(f"{'='*60}")
-            print(f"股票代码数: {len(stock_codes)}")
-            print(f"分析模式: {analysis_mode}")
-            print(f"成功数: {success_count}")
-            print(f"失败数: {failed_count}")
-            print(f"总耗时: {elapsed_time:.2f}秒")
-            print(f"结果数: {len(results)}")
-
-            # 检查结果数据类型
-            print(f"\n检查结果数据类型:")
-            for i, result in enumerate(results[:3]):  # 只检查前3个
-                print(f"  结果 {i+1}:")
-                for key, value in list(result.items())[:5]:  # 只检查前5个字段
-                    print(f"    - {key}: {type(value).__name__}")
-
-            print(f"\n开始保存到数据库...")
-            save_start = time.time()
-
-            # 保存到数据库
-            record_id = batch_db.save_batch_analysis(
-                batch_count=len(stock_codes),
-                analysis_mode=analysis_mode,
-                success_count=success_count,
-                failed_count=failed_count,
-                total_time=elapsed_time,
-                results=results
-            )
-
-            save_elapsed = time.time() - save_start
-            print(f"✅ 批量分析结果已保存到历史记录")
-            print(f"   记录ID: {record_id}")
-            print(f"   保存耗时: {save_elapsed:.2f}秒")
-            print(f"{'='*60}\n")
-            save_success = True
-
-        except Exception as e:
-            import traceback
-            save_error = str(e)
-            print(f"\n{'='*60}")
-            print(f"⚠️ 保存历史记录失败")
-            print(f"{'='*60}")
-            print(f"错误信息: {str(e)}")
-            print(f"详细错误:")
-            print(traceback.format_exc())
-            print(f"{'='*60}\n")
+        
+        # 检查是否有结果需要保存
+        if not results or len(results) == 0:
+            print(f"⚠️ 警告: 没有结果需要保存 (results为空或长度为0)")
+            save_error = "没有分析结果需要保存"
+            st.warning("⚠️ 没有分析结果需要保存到历史记录")
+        else:
+            try:
+                from main_force_batch_db import batch_db
+
+                # 调试信息
+                print(f"\n{'='*60}")
+                print(f"📝 准备保存批量分析结果到历史记录")
+                print(f"{'='*60}")
+                print(f"股票代码数: {len(stock_codes)}")
+                print(f"分析模式: {analysis_mode}")
+                print(f"成功数: {success_count}")
+                print(f"失败数: {failed_count}")
+                print(f"总耗时: {elapsed_time:.2f}秒")
+                print(f"结果数: {len(results)}")
+
+                # 检查结果数据类型
+                print(f"\n检查结果数据类型:")
+                for i, result in enumerate(results[:3]):  # 只检查前3个
+                    print(f"  结果 {i+1}:")
+                    for key, value in list(result.items())[:5]:  # 只检查前5个字段
+                        print(f"    - {key}: {type(value).__name__}")
+
+                print(f"\n开始保存到数据库...")
+                save_start = time.time()
+
+                # 检查数据库路径（调试用）
+                print(f"数据库实例路径: {batch_db.db_path}")
+                import os
+                print(f"数据库文件存在: {os.path.exists(batch_db.db_path)}")
+                if os.path.exists(batch_db.db_path):
+                    print(f"数据库文件大小: {os.path.getsize(batch_db.db_path)} 字节")
+                else:
+                    print(f"⚠️ 警告: 数据库文件不存在！")
+                    st.error(f"❌ 数据库文件不存在: {batch_db.db_path}")
+                
+                # 保存到数据库
+                print(f"调用 save_batch_analysis...")
+                record_id = batch_db.save_batch_analysis(
+                    batch_count=len(stock_codes),
+                    analysis_mode=analysis_mode,
+                    success_count=success_count,
+                    failed_count=failed_count,
+                    total_time=elapsed_time,
+                    results=results
+                )
+
+                save_elapsed = time.time() - save_start
+                print(f"✅ 批量分析结果已保存到历史记录")
+                print(f"   记录ID: {record_id}")
+                print(f"   保存耗时: {save_elapsed:.2f}秒")
+                print(f"{'='*60}\n")
+                
+                # 验证保存是否成功（立即查询）
+                try:
+                    print(f"验证保存结果...")
+                    verify_records = batch_db.get_all_history(limit=1)
+                    if verify_records:
+                        latest_record = verify_records[0]
+                        print(f"✅ 保存验证成功：最新记录ID={latest_record.get('id')}, 时间={latest_record.get('analysis_date')}")
+                        save_success = True
+                        st.success(f"✅ 批量分析结果已保存到历史记录（记录ID: {latest_record.get('id')}）")
+                    else:
+                        print(f"⚠️ 保存验证失败：查询结果为空")
+                        save_error = "保存后查询不到记录，可能是数据库路径不一致"
+                        save_success = False
+                        st.error(f"❌ 保存验证失败：查询结果为空")
+                except Exception as verify_e:
+                    import traceback
+                    print(f"⚠️ 保存验证失败：{str(verify_e)}")
+                    print(traceback.format_exc())
+                    save_error = f"保存验证失败: {str(verify_e)}"
+                    save_success = False
+                    st.error(f"❌ 保存验证失败: {str(verify_e)}")
+                    with st.expander("🔍 查看详细错误", expanded=False):
+                        st.code(traceback.format_exc())
+
+            except Exception as e:
+                import traceback
+                save_error = str(e)
+                error_traceback = traceback.format_exc()
+                
+                print(f"\n{'='*60}")
+                print(f"⚠️ 保存历史记录失败")
+                print(f"{'='*60}")
+                print(f"错误信息: {str(e)}")
+                print(f"详细错误:")
+                print(error_traceback)
+                print(f"{'='*60}\n")
+                
+                # 在页面上也显示错误信息
+                st.error(f"❌ 保存历史记录失败: {str(e)}")
+                with st.expander("🔍 查看详细错误信息", expanded=True):
+                    st.code(error_traceback)
+        
+        # 如果save_error已设置（在验证失败时），也要显示
+        if save_error and save_success == False:
+            st.warning(f"⚠️ 保存状态异常: {save_error}")
 
         # 保存结果到session_state
         st.session_state.main_force_batch_results = {
@@ -785,6 +903,10 @@ def analyze_one(code):
             "save_error": save_error
         }
 
+        # 清除触发标志，避免重复执行
+        if 'main_force_batch_trigger' in st.session_state:
+            del st.session_state.main_force_batch_trigger
+
         time.sleep(0.5)
 
         # 重新渲染以显示结果
diff --git a/migrate_all_databases_to_data.py b/migrate_all_databases_to_data.py
new file mode 100644
index 0000000..c131fb3
--- /dev/null
+++ b/migrate_all_databases_to_data.py
@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+将所有数据库文件迁移到 data 目录
+统一数据库文件存储规范
+"""
+
+import os
+import shutil
+import sqlite3
+from pathlib import Path
+
+# 数据库文件映射（根目录 -> data目录）
+DB_FILES = [
+    'stock_analysis.db',
+    'sector_strategy.db',
+    'low_price_bull_monitor.db',
+    'main_force_batch.db',
+    'stock_monitor.db',
+    'portfolio_stocks.db',
+    'longhubang.db',
+    'smart_monitor.db',
+    'profit_growth_monitor.db',
+]
+
+def check_database_tables(db_path):
+    """检查数据库文件是否有表"""
+    if not os.path.exists(db_path):
+        return False, []
+    
+    try:
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+        tables = [row[0] for row in cursor.fetchall()]
+        conn.close()
+        return len(tables) > 0, tables
+    except Exception as e:
+        print(f"   ⚠️  检查数据库时出错: {e}")
+        return False, []
+
+def migrate_database(root_file, data_file):
+    """迁移单个数据库文件"""
+    root_path = Path(root_file)
+    data_path = Path(data_file)
+    
+    # 检查根目录文件是否存在
+    if not root_path.exists():
+        return "skip", "根目录文件不存在"
+    
+    # 检查 data 目录文件是否存在
+    if data_path.exists():
+        # 检查两个文件的内容
+        root_has_tables, root_tables = check_database_tables(str(root_path))
+        data_has_tables, data_tables = check_database_tables(str(data_path))
+        
+        root_size = root_path.stat().st_size
+        data_size = data_path.stat().st_size
+        
+        if root_has_tables and not data_has_tables:
+            # 根目录有数据，data目录没有，备份后替换
+            backup_path = data_path.with_suffix('.db.backup')
+            shutil.copy2(data_path, backup_path)
+            shutil.copy2(root_path, data_path)
+            return "replaced", f"已替换（根目录有数据，data目录为空，已备份到 {backup_path.name}）"
+        elif root_has_tables and data_has_tables:
+            # 两个都有数据，比较大小
+            if root_size > data_size:
+                # 根目录的数据更多，询问是否替换
+                backup_path = data_path.with_suffix('.db.backup')
+                shutil.copy2(data_path, backup_path)
+                shutil.copy2(root_path, data_path)
+                return "replaced", f"已替换（根目录数据更多，已备份到 {backup_path.name}）"
+            else:
+                return "skip", "data目录已有数据，跳过"
+        elif not root_has_tables and data_has_tables:
+            return "skip", "data目录已有数据，根目录为空，跳过"
+        else:
+            # 两个都为空，删除根目录的
+            return "skip", "两个都为空，跳过"
+    else:
+        # data目录不存在，直接移动
+        data_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(root_path), str(data_path))
+        return "moved", "已移动到data目录"
+
+def main():
+    """主函数"""
+    print("=" * 80)
+    print("📦 数据库文件迁移工具 - 统一到 data 目录")
+    print("=" * 80)
+    print()
+    
+    # 确保 data 目录存在
+    data_dir = Path('data')
+    data_dir.mkdir(exist_ok=True)
+    
+    results = []
+    
+    for db_file in DB_FILES:
+        root_file = Path(db_file)
+        data_file = data_dir / db_file
+        
+        print(f"📁 处理: {db_file}")
+        
+        if not root_file.exists():
+            print(f"   ✅ 根目录不存在，检查 data 目录...")
+            if data_file.exists():
+                has_tables, tables = check_database_tables(str(data_file))
+                if has_tables:
+                    print(f"   ✅ data 目录已存在且有数据（{len(tables)} 个表）")
+                    results.append((db_file, "already_in_data", "已在data目录"))
+                else:
+                    print(f"   ⚠️  data 目录存在但无表")
+                    results.append((db_file, "empty_in_data", "data目录存在但无表"))
+            else:
+                print(f"   ⚠️  两个位置都不存在")
+                results.append((db_file, "not_found", "两个位置都不存在"))
+        else:
+            # 根目录存在，进行迁移
+            status, message = migrate_database(str(root_file), str(data_file))
+            print(f"   {message}")
+            results.append((db_file, status, message))
+        
+        print()
+    
+    # 清理空的根目录数据库文件
+    print("=" * 80)
+    print("🧹 清理根目录的空数据库文件...")
+    print("=" * 80)
+    
+    for db_file in DB_FILES:
+        root_file = Path(db_file)
+        data_file = data_dir / db_file
+        
+        if root_file.exists() and data_file.exists():
+            root_has_tables, _ = check_database_tables(str(root_file))
+            data_has_tables, _ = check_database_tables(str(data_file))
+            
+            if not root_has_tables and data_has_tables:
+                # 根目录为空，data目录有数据，删除根目录的
+                try:
+                    root_file.unlink()
+                    print(f"   ✅ 已删除空文件: {db_file}")
+                except Exception as e:
+                    print(f"   ⚠️  删除失败: {db_file} - {e}")
+    
+    # 清理 main_force_batch1.db（重复文件）
+    batch1_file = data_dir / 'main_force_batch1.db'
+    if batch1_file.exists():
+        has_tables, _ = check_database_tables(str(batch1_file))
+        if not has_tables:
+            try:
+                batch1_file.unlink()
+                print(f"   ✅ 已删除空文件: main_force_batch1.db")
+            except Exception as e:
+                print(f"   ⚠️  删除失败: main_force_batch1.db - {e}")
+    
+    # 验证迁移结果
+    print()
+    print("=" * 80)
+    print("✅ 迁移完成！验证结果：")
+    print("=" * 80)
+    
+    for db_file in DB_FILES:
+        data_file = data_dir / db_file
+        if data_file.exists():
+            has_tables, tables = check_database_tables(str(data_file))
+            if has_tables:
+                print(f"   ✅ {db_file}: data目录存在，{len(tables)} 个表")
+            else:
+                print(f"   ⚠️  {db_file}: data目录存在但无表")
+        else:
+            print(f"   ❌ {db_file}: data目录不存在")
+    
+    print()
+    print("=" * 80)
+    print("📝 注意事项：")
+    print("   1. 所有数据库文件现在应该在 data 目录下")
+    print("   2. 如果根目录还有数据库文件，请手动检查并删除")
+    print("   3. 建议重启应用以确保使用正确的数据库文件")
+    print("=" * 80)
+
+if __name__ == '__main__':
+    main()
diff --git a/migrate_databases.sh b/migrate_databases.sh
new file mode 100755
index 0000000..92e5006
--- /dev/null
+++ b/migrate_databases.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+# 数据库文件迁移脚本
+# 将根目录下的数据库文件迁移到 data 目录（如果 data 目录下没有或更旧）
+
+cd "$(dirname "$0")"
+
+echo "开始迁移数据库文件到 data 目录..."
+
+# 确保 data 目录存在
+mkdir -p data
+
+# 需要迁移的数据库文件列表
+databases=(
+    "stock_analysis.db"
+    "stock_monitor.db"
+    "portfolio_stocks.db"
+    "sector_strategy.db"
+    "longhubang.db"
+    "main_force_batch.db"
+    "smart_monitor.db"
+    "low_price_bull_monitor.db"
+    "profit_growth_monitor.db"
+)
+
+for db in "${databases[@]}"; do
+    if [ -f "$db" ]; then
+        data_db="data/$db"
+        if [ ! -f "$data_db" ] || [ "$db" -nt "$data_db" ]; then
+            echo "迁移: $db -> $data_db"
+            cp "$db" "$data_db"
+            echo "  ✅ 已迁移"
+        else
+            echo "跳过: $db (data目录下已有更新版本)"
+        fi
+    else
+        echo "不存在: $db (跳过)"
+    fi
+done
+
+echo ""
+echo "迁移完成！现在可以安全地删除根目录下的数据库文件（如果确认data目录下的数据正确）。"
diff --git a/migrate_databases_by_size.sh b/migrate_databases_by_size.sh
new file mode 100755
index 0000000..814068a
--- /dev/null
+++ b/migrate_databases_by_size.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+# 数据库文件迁移脚本（按文件大小判断）
+# 将根目录下较大的数据库文件迁移到 data 目录
+
+cd "$(dirname "$0")"
+
+echo "开始迁移数据库文件到 data 目录（按文件大小判断）..."
+echo ""
+
+# 确保 data 目录存在
+mkdir -p data
+
+# 需要迁移的数据库文件列表
+databases=(
+    "stock_analysis.db"
+    "stock_monitor.db"
+    "portfolio_stocks.db"
+    "sector_strategy.db"
+    "longhubang.db"
+    "main_force_batch.db"
+    "smart_monitor.db"
+    "low_price_bull_monitor.db"
+    "profit_growth_monitor.db"
+)
+
+for db in "${databases[@]}"; do
+    if [ -f "$db" ]; then
+        data_db="data/$db"
+        root_size=$(stat -f%z "$db" 2>/dev/null || stat -c%s "$db" 2>/dev/null || echo 0)
+        
+        if [ -f "$data_db" ]; then
+            data_size=$(stat -f%z "$data_db" 2>/dev/null || stat -c%s "$data_db" 2>/dev/null || echo 0)
+            if [ "$root_size" -gt "$data_size" ]; then
+                echo "迁移: $db (根目录: $(numfmt --to=iec-i --suffix=B $root_size 2>/dev/null || echo ${root_size}B) > data目录: $(numfmt --to=iec-i --suffix=B $data_size 2>/dev/null || echo ${data_size}B))"
+                cp "$db" "$data_db"
+                echo "  ✅ 已迁移（保留根目录文件作为备份）"
+            else
+                echo "跳过: $db (data目录版本已更新或相同)"
+            fi
+        else
+            echo "迁移: $db -> $data_db"
+            cp "$db" "$data_db"
+            echo "  ✅ 已迁移"
+        fi
+    fi
+done
+
+echo ""
+echo "迁移完成！现在可以停止并重启 Docker 服务了。"
diff --git a/monitor_db.py b/monitor_db.py
index 0d9ca56..bbfaf4e 100644
--- a/monitor_db.py
+++ b/monitor_db.py
@@ -7,12 +7,28 @@
 class StockMonitorDatabase:
     """股票监测数据库管理类"""
     
-    def __init__(self, db_path: str = "stock_monitor.db"):
-        self.db_path = db_path
+    def __init__(self, db_path: str = None):
+        """
+        初始化数据库
+        
+        Args:
+            db_path: 数据库文件路径，如果为None，则使用data目录下的stock_monitor.db（确保持久化）
+        """
+        # 如果没有指定路径，使用data目录下的数据库文件（确保容器重启后数据不丢失）
+        if db_path is None:
+            data_dir = os.path.join(os.path.dirname(__file__), 'data')
+            if not os.path.exists(data_dir):
+                os.makedirs(data_dir, exist_ok=True)
+            self.db_path = os.path.join(data_dir, 'stock_monitor.db')
+        else:
+            self.db_path = db_path
+        
         # 确保数据库所在目录存在
         db_dir = os.path.dirname(self.db_path)
         if db_dir and not os.path.exists(db_dir):
             os.makedirs(db_dir, exist_ok=True)
+        
+        print(f"[StockMonitorDatabase] 数据库文件路径: {self.db_path}")
         self.init_database()
     
     def init_database(self):
diff --git a/portfolio_db.py b/portfolio_db.py
index 6b0f595..591b9e5 100644
--- a/portfolio_db.py
+++ b/portfolio_db.py
@@ -9,8 +9,12 @@
 from typing import List, Dict, Optional, Tuple
 import os
 
-# 数据库文件路径
-DB_PATH = "portfolio_stocks.db"
+# 数据库文件路径（使用data目录确保持久化）
+_data_dir = os.path.join(os.path.dirname(__file__), 'data')
+if not os.path.exists(_data_dir):
+    os.makedirs(_data_dir, exist_ok=True)
+DB_PATH = os.path.join(_data_dir, "portfolio_stocks.db")
+print(f"[PortfolioDB] 数据库文件路径: {DB_PATH}")
 
 
 class PortfolioDB:
diff --git a/portfolio_manager.py b/portfolio_manager.py
index e23e85f..b76f532 100644
--- a/portfolio_manager.py
+++ b/portfolio_manager.py
@@ -13,17 +13,30 @@
 from portfolio_db import portfolio_db
 
 
+import config
+
 class PortfolioManager:
     """持仓管理器类"""
     
-    def __init__(self, model="deepseek-chat"):
+    def __init__(self, model=None):
         """
         初始化持仓管理器
         
         Args:
-            model: AI模型（deepseek-chat 或 deepseek-reasoner）
+            model: AI模型（如果不传入，则使用配置文件中的默认模型）
         """
-        self.model = model
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                print(f"[PortfolioManager] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+            else:
+                print(f"[PortfolioManager] 使用配置文件中的默认模型: {self.model}")
+        else:
+            self.model = model
+            print(f"[PortfolioManager] 使用传入的模型参数: {self.model}")
+        print(f"[PortfolioManager] ✅ 最终使用的模型: {self.model}")
         self.db = portfolio_db
     
     # ==================== 持仓股票管理 ====================
@@ -121,7 +134,7 @@ def get_stock_count(self) -> int:
     # ==================== 单只股票分析 ====================
     
     def analyze_single_stock(self, stock_code: str, period="1y", 
-                            selected_agents: List[str] = None) -> Dict:
+                            selected_agents: List[str] = None, model: str = None) -> Dict:
         """
         分析单只股票（复用app.py中的分析逻辑）
         
@@ -129,6 +142,7 @@ def analyze_single_stock(self, stock_code: str, period="1y",
             stock_code: 股票代码
             period: 数据周期
             selected_agents: 选中的分析师列表
+            model: AI模型（如果为None，使用self.model）
             
         Returns:
             分析结果字典
@@ -141,6 +155,9 @@ def analyze_single_stock(self, stock_code: str, period="1y",
             # 导入app.py中的分析函数
             from app import analyze_single_stock_for_batch
             
+            # 使用传入的模型或默认模型
+            use_model = model if model else self.model
+            
             # 构建分析师配置
             if selected_agents is None:
                 enabled_analysts_config = {
@@ -166,7 +183,7 @@ def analyze_single_stock(self, stock_code: str, period="1y",
                 symbol=stock_code,
                 period=period,
                 enabled_analysts_config=enabled_analysts_config,
-                selected_model=self.model
+                selected_model=use_model
             )
             
             # 检查结果
@@ -191,7 +208,7 @@ def analyze_single_stock(self, stock_code: str, period="1y",
     
     def batch_analyze_sequential(self, stock_codes: List[str], period="1y",
                                  selected_agents: List[str] = None,
-                                 progress_callback=None) -> Dict:
+                                 progress_callback=None, model: str = None) -> Dict:
         """
         顺序批量分析（逐只分析）
         
@@ -219,7 +236,7 @@ def batch_analyze_sequential(self, stock_codes: List[str], period="1y",
                 progress_callback(i, len(stock_codes), code, "analyzing")
             
             try:
-                result = self.analyze_single_stock(code, period, selected_agents)
+                result = self.analyze_single_stock(code, period, selected_agents, model=model)
                 
                 if result.get("success"):
                     results.append({
@@ -266,7 +283,7 @@ def batch_analyze_sequential(self, stock_codes: List[str], period="1y",
     def batch_analyze_parallel(self, stock_codes: List[str], period="1y",
                                selected_agents: List[str] = None,
                                max_workers: int = 3,
-                               progress_callback=None) -> Dict:
+                               progress_callback=None, model: str = None) -> Dict:
         """
         并行批量分析（多线程）
         
@@ -292,7 +309,7 @@ def batch_analyze_parallel(self, stock_codes: List[str], period="1y",
         with ThreadPoolExecutor(max_workers=max_workers) as executor:
             # 提交所有任务
             future_to_code = {
-                executor.submit(self.analyze_single_stock, code, period, selected_agents): code
+                executor.submit(self.analyze_single_stock, code, period, selected_agents, model): code
                 for code in stock_codes
             }
             
@@ -351,7 +368,7 @@ def batch_analyze_parallel(self, stock_codes: List[str], period="1y",
     def batch_analyze_portfolio(self, mode="sequential", period="1y",
                                 selected_agents: List[str] = None,
                                 max_workers: int = 3,
-                                progress_callback=None) -> Dict:
+                                progress_callback=None, model: str = None) -> Dict:
         """
         批量分析所有持仓股票
         
@@ -361,6 +378,7 @@ def batch_analyze_portfolio(self, mode="sequential", period="1y",
             selected_agents: 选中的分析师列表
             max_workers: 并行模式下的最大并发数（默认3）
             progress_callback: 进度回调函数
+            model: AI模型（如果为None，使用self.model）
             
         Returns:
             批量分析结果字典
@@ -378,9 +396,9 @@ def batch_analyze_portfolio(self, mode="sequential", period="1y",
         
         # 根据模式选择分析方法
         if mode == "parallel":
-            return self.batch_analyze_parallel(stock_codes, period, selected_agents, max_workers, progress_callback)
+            return self.batch_analyze_parallel(stock_codes, period, selected_agents, max_workers, progress_callback, model=model)
         else:
-            return self.batch_analyze_sequential(stock_codes, period, selected_agents, progress_callback)
+            return self.batch_analyze_sequential(stock_codes, period, selected_agents, progress_callback, model=model)
     
     # ==================== 分析结果保存 ====================
     
diff --git a/portfolio_stocks.db b/portfolio_stocks.db
deleted file mode 100644
index 9cd4be4..0000000
Binary files a/portfolio_stocks.db and /dev/null differ
diff --git a/portfolio_ui.py b/portfolio_ui.py
index 4d8fab8..ba5b222 100644
--- a/portfolio_ui.py
+++ b/portfolio_ui.py
@@ -285,6 +285,10 @@ def display_batch_analysis():
             help="通过邮件或Webhook发送分析完成通知"
         )
     
+    st.info("💡 提示：AI模型选择在左侧边栏，选择后将在所有功能中生效")
+    
+    st.markdown("---")
+    
     # 立即分析按钮
     if st.button("🚀 立即开始分析", type="primary", width='content'):
         with st.spinner("正在批量分析持仓股票..."):
@@ -292,6 +296,15 @@ def display_batch_analysis():
             progress_bar = st.progress(0)
             status_text = st.empty()
             
+            # 使用全局模型选择
+            from model_config import model_options
+            import config
+            selected_model = st.session_state.get('selected_model')
+            if not selected_model or selected_model not in model_options:
+                selected_model = config.DEEPSEEK_MODEL_NAME
+                if selected_model not in model_options:
+                    selected_model = list(model_options.keys())[0]
+            
             # 执行批量分析
             try:
                 # 定义进度回调函数
@@ -308,7 +321,8 @@ def update_progress(current, total, code, status):
                 result = portfolio_manager.batch_analyze_portfolio(
                     mode=analysis_mode,
                     max_workers=max_workers,
-                    progress_callback=update_progress
+                    progress_callback=update_progress,
+                    model=selected_model
                 )
                 
                 # 清除进度显示
diff --git a/profit_growth_monitor.db b/profit_growth_monitor.db
deleted file mode 100644
index 193bb9e..0000000
Binary files a/profit_growth_monitor.db and /dev/null differ
diff --git a/profit_growth_monitor.py b/profit_growth_monitor.py
index 869963a..061ac08 100644
--- a/profit_growth_monitor.py
+++ b/profit_growth_monitor.py
@@ -15,14 +15,23 @@
 class ProfitGrowthMonitor:
     """净利增长策略监控数据库管理"""
     
-    def __init__(self, db_path: str = "profit_growth_monitor.db"):
+    def __init__(self, db_path: str = None):
         """
         初始化监控数据库
         
         Args:
-            db_path: 数据库文件路径
+            db_path: 数据库文件路径，如果为None，则使用data目录下的profit_growth_monitor.db（确保持久化）
         """
-        self.db_path = db_path
+        # 如果没有指定路径，使用data目录下的数据库文件（确保容器重启后数据不丢失）
+        if db_path is None:
+            import os
+            data_dir = os.path.join(os.path.dirname(__file__), 'data')
+            if not os.path.exists(data_dir):
+                os.makedirs(data_dir, exist_ok=True)
+            self.db_path = os.path.join(data_dir, 'profit_growth_monitor.db')
+        else:
+            self.db_path = db_path
+        print(f"[ProfitGrowthMonitor] 数据库文件路径: {self.db_path}")
         self.logger = logging.getLogger(__name__)
         self._init_database()
     
diff --git a/restart_service.sh b/restart_service.sh
new file mode 100755
index 0000000..909799e
--- /dev/null
+++ b/restart_service.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+# 停止并重启 Docker 服务脚本
+
+cd "$(dirname "$0")"
+
+echo "=========================================="
+echo "停止并重启 Docker 服务"
+echo "=========================================="
+echo ""
+
+# 1. 停止服务
+echo "1. 停止现有服务..."
+docker-compose down
+echo ""
+
+# 2. 重新构建（使用 --no-cache 确保使用最新代码）
+echo "2. 重新构建 Docker 镜像（这可能需要几分钟）..."
+docker-compose build --no-cache
+echo ""
+
+# 3. 启动服务
+echo "3. 启动服务..."
+docker-compose up -d
+echo ""
+
+# 4. 查看服务状态
+echo "4. 查看服务状态..."
+sleep 3
+docker-compose ps
+echo ""
+
+# 5. 查看日志
+echo "5. 查看最新日志（按 Ctrl+C 退出）..."
+echo "=========================================="
+docker-compose logs -f --tail=50
diff --git a/sector_strategy.db b/sector_strategy.db
deleted file mode 100644
index c092157..0000000
Binary files a/sector_strategy.db and /dev/null differ
diff --git a/sector_strategy_agents.py b/sector_strategy_agents.py
index 6383ba9..280aea4 100644
--- a/sector_strategy_agents.py
+++ b/sector_strategy_agents.py
@@ -6,15 +6,26 @@
 from deepseek_client import DeepSeekClient
 from typing import Dict, Any
 import time
+import config
 
 
 class SectorStrategyAgents:
     """板块策略AI智能体集合"""
     
-    def __init__(self, model="deepseek-chat"):
-        self.model = model
-        self.deepseek_client = DeepSeekClient(model=model)
-        print(f"[智策] AI智能体系统初始化 (模型: {model})")
+    def __init__(self, model=None):
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                print(f"[智策] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+            else:
+                print(f"[智策] AI智能体系统初始化 - 使用配置文件中的默认模型: {self.model}")
+        else:
+            self.model = model
+            print(f"[智策] AI智能体系统初始化 - 使用传入的模型参数: {self.model}")
+        self.deepseek_client = DeepSeekClient(model=self.model)
+        print(f"[智策] AI智能体系统初始化完成 - 最终使用的模型: {self.model}")
     
     def macro_strategist_agent(self, market_data: Dict, news_data: list) -> Dict[str, Any]:
         """
@@ -244,28 +255,53 @@ def fund_flow_analyst_agent(self, fund_flow_data: Dict, north_flow_data: Dict, s
         print("💰 资金流向分析师正在分析...")
         time.sleep(1)
         
+        # 安全转换数值类型的辅助函数
+        def safe_float(value, default=0):
+            try:
+                if isinstance(value, (int, float)):
+                    return float(value)
+                elif isinstance(value, str):
+                    # 移除千分位逗号和空格
+                    cleaned = value.replace(',', '').replace('，', '').strip()
+                    return float(cleaned) if cleaned else default
+                else:
+                    return default
+            except (ValueError, TypeError):
+                return default
+        
         # 构建资金流向数据
         fund_flow_summary = ""
         if fund_flow_data and fund_flow_data.get("today"):
             flow_list = fund_flow_data["today"]
             
             # 净流入前15
-            sorted_inflow = sorted(flow_list, key=lambda x: x["main_net_inflow"], reverse=True)
+            sorted_inflow = sorted(flow_list, key=lambda x: safe_float(x.get("main_net_inflow", 0)), reverse=True)
             fund_flow_summary = f"""
 【板块资金流向】(更新时间: {fund_flow_data.get('update_time', 'N/A')})
 
 主力资金净流入 TOP15:
 """
             for idx, item in enumerate(sorted_inflow[:15], 1):
-                fund_flow_summary += f"{idx}. {item['sector']}: {item['main_net_inflow']:.2f}万 ({item['main_net_inflow_pct']:+.2f}%) | 涨跌: {item['change_pct']:+.2f}% | 超大单: {item['super_large_net_inflow']:.2f}万\n"
+                main_net_inflow = safe_float(item.get('main_net_inflow', 0))
+                main_net_inflow_pct = safe_float(item.get('main_net_inflow_pct', 0))
+                change_pct = safe_float(item.get('change_pct', 0))
+                super_large_net_inflow = safe_float(item.get('super_large_net_inflow', 0))
+                sector = item.get('sector', 'N/A')
+                
+                fund_flow_summary += f"{idx}. {sector}: {main_net_inflow:.2f}万 ({main_net_inflow_pct:+.2f}%) | 涨跌: {change_pct:+.2f}% | 超大单: {super_large_net_inflow:.2f}万\n"
             
             # 净流出前10
-            sorted_outflow = sorted(flow_list, key=lambda x: x["main_net_inflow"])
+            sorted_outflow = sorted(flow_list, key=lambda x: safe_float(x.get("main_net_inflow", 0)))
             fund_flow_summary += f"""
 主力资金净流出 TOP10:
 """
             for idx, item in enumerate(sorted_outflow[:10], 1):
-                fund_flow_summary += f"{idx}. {item['sector']}: {item['main_net_inflow']:.2f}万 ({item['main_net_inflow_pct']:+.2f}%) | 涨跌: {item['change_pct']:+.2f}%\n"
+                main_net_inflow = safe_float(item.get('main_net_inflow', 0))
+                main_net_inflow_pct = safe_float(item.get('main_net_inflow_pct', 0))
+                change_pct = safe_float(item.get('change_pct', 0))
+                sector = item.get('sector', 'N/A')
+                
+                fund_flow_summary += f"{idx}. {sector}: {main_net_inflow:.2f}万 ({main_net_inflow_pct:+.2f}%) | 涨跌: {change_pct:+.2f}%\n"
         
         # 构建北向资金数据
         north_summary = ""
diff --git a/sector_strategy_db.py b/sector_strategy_db.py
index 38b8253..8209d5b 100644
--- a/sector_strategy_db.py
+++ b/sector_strategy_db.py
@@ -13,14 +13,23 @@
 class SectorStrategyDatabase:
     """智策板块数据库管理类"""
     
-    def __init__(self, db_path='sector_strategy.db'):
+    def __init__(self, db_path=None):
         """
         初始化数据库
         
         Args:
-            db_path: 数据库文件路径
+            db_path: 数据库文件路径，如果为None，则使用data目录下的sector_strategy.db（确保持久化）
         """
-        self.db_path = db_path
+        # 如果没有指定路径，使用data目录下的数据库文件（确保容器重启后数据不丢失）
+        if db_path is None:
+            import os
+            data_dir = os.path.join(os.path.dirname(__file__), 'data')
+            if not os.path.exists(data_dir):
+                os.makedirs(data_dir, exist_ok=True)
+            self.db_path = os.path.join(data_dir, 'sector_strategy.db')
+        else:
+            self.db_path = db_path
+        print(f"[SectorStrategyDatabase] 数据库文件路径: {self.db_path}")
         # 初始化日志
         self.logger = logging.getLogger(__name__)
         if not self.logger.handlers:
diff --git a/sector_strategy_engine.py b/sector_strategy_engine.py
index 5e39364..81668be 100644
--- a/sector_strategy_engine.py
+++ b/sector_strategy_engine.py
@@ -11,20 +11,28 @@
 import json
 import pandas as pd
 import logging
+import config
 
 
 class SectorStrategyEngine:
     """板块策略综合研判引擎"""
     
-    def __init__(self, model="deepseek-chat"):
-        self.model = model
-        self.agents = SectorStrategyAgents(model=model)
-        self.deepseek_client = DeepSeekClient(model=model)
+    def __init__(self, model=None):
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                print(f"[智策引擎] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+        else:
+            self.model = model
+        self.agents = SectorStrategyAgents(model=self.model)
+        self.deepseek_client = DeepSeekClient(model=self.model)
         self.database = SectorStrategyDatabase()
         self.logger = logging.getLogger(__name__)
         if not self.logger.handlers:
             logging.basicConfig(level=logging.INFO, format='[%(asctime)s] %(levelname)s %(name)s: %(message)s')
-        print(f"[智策引擎] 初始化完成 (模型: {model})")
+        print(f"[智策引擎] 初始化完成 - 最终使用的模型: {self.model} (传入参数: {model}, 配置默认: {config.DEEPSEEK_MODEL_NAME})")
     
     def save_raw_data_with_fallback(self, data_type, data_df, data_date=None):
         """
diff --git a/sector_strategy_scheduler.py b/sector_strategy_scheduler.py
index 60436e9..440914e 100644
--- a/sector_strategy_scheduler.py
+++ b/sector_strategy_scheduler.py
@@ -11,6 +11,7 @@
 from sector_strategy_engine import SectorStrategyEngine
 from notification_service import notification_service
 import json
+import config
 
 
 class SectorStrategyScheduler:
@@ -128,7 +129,7 @@ def _run_analysis(self):
             
             # 2. 运行AI分析
             print("[智策定时] [2/3] AI智能体分析中...")
-            engine = SectorStrategyEngine(model="deepseek-chat")
+            engine = SectorStrategyEngine(model=config.DEEPSEEK_MODEL_NAME)
             result = engine.run_comprehensive_analysis(data)
             
             if not result.get("success"):
diff --git a/sector_strategy_ui.py b/sector_strategy_ui.py
index dc5f13a..f9c70a6 100644
--- a/sector_strategy_ui.py
+++ b/sector_strategy_ui.py
@@ -18,6 +18,7 @@
 from sector_strategy_pdf import SectorStrategyPDFGenerator
 from sector_strategy_db import SectorStrategyDatabase
 from sector_strategy_scheduler import sector_strategy_scheduler
+import config
 
 
 def _parse_json_field(value, default):
@@ -112,33 +113,21 @@ def display_analysis_tab():
     
     st.markdown("---")
     
-    # 模型选择
-    col1, col2, col3 = st.columns([2, 2, 2])
+    # 分析按钮
+    col1, col2 = st.columns([2, 2])
     
     with col1:
-        # 导入model_config.py中定义的model_options
-        from model_config import model_options as app_model_options
-        selected_model = st.selectbox(
-            "AI模型",
-            list(app_model_options.keys()),
-            format_func=lambda x: app_model_options[x],
-            help="Reasoner模型提供更强的推理能力"
-        )
-    
-    with col2:
-        st.write("")
-        st.write("")
         analyze_button = st.button("🚀 开始智策分析", type="primary", width='content')
     
-    with col3:
-        st.write("")
-        st.write("")
+    with col2:
         if st.button("🔄 清除结果", width='content'):
             if 'sector_strategy_result' in st.session_state:
                 del st.session_state.sector_strategy_result
             st.success("已清除分析结果")
             st.rerun()
     
+    st.info("💡 提示：AI模型选择在左侧边栏，选择后将在所有功能中生效")
+    
     st.markdown("---")
     
     # 开始分析
@@ -147,6 +136,14 @@ def display_analysis_tab():
         if 'sector_strategy_result' in st.session_state:
             del st.session_state.sector_strategy_result
         
+        # 使用全局模型选择
+        from model_config import model_options
+        selected_model = st.session_state.get('selected_model')
+        if not selected_model or selected_model not in model_options:
+            selected_model = config.DEEPSEEK_MODEL_NAME
+            if selected_model not in model_options:
+                selected_model = list(model_options.keys())[0]
+        
         run_sector_strategy_analysis(selected_model)
     
     # 显示分析结果
@@ -261,9 +258,18 @@ def display_report_detail(report_id):
     st.info("当前版本仅提供报告摘要，详细页面已移除。")
 
 
-def run_sector_strategy_analysis(model="deepseek-chat"):
+def run_sector_strategy_analysis(model=None):
     """运行智策分析"""
     
+    # 如果没有传入model，则使用全局模型选择
+    if model is None:
+        from model_config import model_options
+        model = st.session_state.get('selected_model')
+        if not model or model not in model_options:
+            model = config.DEEPSEEK_MODEL_NAME
+            if model not in model_options:
+                model = list(model_options.keys())[0]
+    
     # 进度显示
     progress_bar = st.progress(0)
     status_text = st.empty()
diff --git a/smart_monitor.db b/smart_monitor.db
deleted file mode 100644
index 81035a3..0000000
Binary files a/smart_monitor.db and /dev/null differ
diff --git a/smart_monitor_db.py b/smart_monitor_db.py
index 7a22fd5..afee645 100644
--- a/smart_monitor_db.py
+++ b/smart_monitor_db.py
@@ -13,14 +13,23 @@
 class SmartMonitorDB:
     """智能盯盘数据库"""
     
-    def __init__(self, db_file: str = 'smart_monitor.db'):
+    def __init__(self, db_file: str = None):
         """
         初始化数据库
         
         Args:
-            db_file: 数据库文件路径
+            db_file: 数据库文件路径，如果为None，则使用data目录下的smart_monitor.db（确保持久化）
         """
-        self.db_file = db_file
+        # 如果没有指定路径，使用data目录下的数据库文件（确保容器重启后数据不丢失）
+        if db_file is None:
+            import os
+            data_dir = os.path.join(os.path.dirname(__file__), 'data')
+            if not os.path.exists(data_dir):
+                os.makedirs(data_dir, exist_ok=True)
+            self.db_file = os.path.join(data_dir, 'smart_monitor.db')
+        else:
+            self.db_file = db_file
+        print(f"[SmartMonitorDB] 数据库文件路径: {self.db_file}")
         self.logger = logging.getLogger(__name__)
         self._init_database()
     
diff --git a/smart_monitor_deepseek.py b/smart_monitor_deepseek.py
index 622fe99..db27a6e 100644
--- a/smart_monitor_deepseek.py
+++ b/smart_monitor_deepseek.py
@@ -7,25 +7,43 @@
 from typing import Dict, List, Optional
 from datetime import datetime, time
 import pytz
+import config
 
 
 class SmartMonitorDeepSeek:
     """A股智能盯盘 - DeepSeek AI决策引擎"""
 
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str = None, model: str = None):
         """
         初始化DeepSeek客户端
         
         Args:
             api_key: DeepSeek API密钥
+            base_url: API基础URL（可选，默认使用配置文件的值）
+            model: 模型名称（可选，默认使用配置文件的值）
         """
         self.api_key = api_key
-        self.base_url = "https://api.deepseek.com/v1"
+        # 如果没有传入base_url，则使用配置文件中的默认值
+        if base_url is None or base_url == "":
+            self.base_url = config.DEEPSEEK_BASE_URL
+        else:
+            self.base_url = base_url
+        # 强制使用配置文件中的默认模型
+        # 如果传入的是 None、空字符串或旧的默认值 "deepseek-chat"，都使用配置文件的值
+        if model is None or model == "" or model == "deepseek-chat":
+            self.model = config.DEEPSEEK_MODEL_NAME
+            if model == "deepseek-chat":
+                self.logger.warning(f"[SmartMonitorDeepSeek] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+                print(f"[SmartMonitorDeepSeek] ⚠️ 检测到传入的模型是旧的默认值 'deepseek-chat'，强制使用配置文件中的模型: {self.model}")
+        else:
+            self.model = model
         self.headers = {
             "Authorization": f"Bearer {api_key}",
             "Content-Type": "application/json"
         }
         self.logger = logging.getLogger(__name__)
+        self.logger.info(f"[SmartMonitorDeepSeek] 初始化完成 - 模型: {self.model}, API地址: {self.base_url}")
+        print(f"[SmartMonitorDeepSeek] 初始化完成 - 模型: {self.model}, API地址: {self.base_url}")
 
     def is_trading_time(self) -> bool:
         """
@@ -138,14 +156,14 @@ def get_trading_session(self) -> Dict:
                 'can_trade': False
             }
 
-    def chat_completion(self, messages: List[Dict], model: str = "deepseek-chat",
+    def chat_completion(self, messages: List[Dict], model: str = None,
                        temperature: float = 0.7, max_tokens: int = 2000) -> Dict:
         """
         调用DeepSeek API
         
         Args:
             messages: 对话消息列表
-            model: 模型名称
+            model: 模型名称（如果不传入，则使用配置文件中的默认模型）
             temperature: 温度参数
             max_tokens: 最大token数
             
@@ -154,8 +172,39 @@ def chat_completion(self, messages: List[Dict], model: str = "deepseek-chat",
         """
         import requests
         
+        # 如果没有传入model，则使用配置文件中的默认模型
+        model_to_use = model or self.model
+        
+        # 计算输入消息的token估算（简单估算：字符数/4）
+        total_chars = sum(len(str(msg.get('content', ''))) for msg in messages)
+        estimated_tokens = total_chars // 4
+        
+        # 准备消息摘要（安全处理）
+        message_summaries = []
+        for msg in messages[:3]:
+            role = msg.get('role', 'unknown')
+            content = str(msg.get('content', ''))
+            if len(content) > 50:
+                content = content[:50] + '...'
+            message_summaries.append(f"{role}:{content}")
+        
+        # 输出模型调用信息（同时输出到日志和控制台）
+        log_msg = f"""
+{'=' * 60}
+[SmartMonitorDeepSeek] 准备调用API
+  模型名称: {model_to_use}
+  API地址: {self.base_url}
+  消息数量: {len(messages)}
+  估算输入Token: ~{estimated_tokens}
+  温度参数: {temperature}
+  最大输出Token: {max_tokens}
+  消息摘要: {message_summaries}
+{'=' * 60}"""
+        self.logger.info(log_msg)
+        print(log_msg)  # 同时输出到控制台，方便调试
+        
         payload = {
-            "model": model,
+            "model": model_to_use,
             "messages": messages,
             "temperature": temperature,
             "max_tokens": max_tokens
@@ -169,9 +218,23 @@ def chat_completion(self, messages: List[Dict], model: str = "deepseek-chat",
                 timeout=60
             )
             response.raise_for_status()
-            return response.json()
+            result = response.json()
+            
+            # 输出响应信息
+            if result and 'usage' in result:
+                usage = result['usage']
+                usage_info = f"""
+[SmartMonitorDeepSeek] API调用成功
+  实际输入Token: {usage.get('prompt_tokens', 'N/A')}
+  实际输出Token: {usage.get('completion_tokens', 'N/A')}
+  总Token: {usage.get('total_tokens', 'N/A')}"""
+                self.logger.info(usage_info)
+                print(usage_info)  # 同时输出到控制台
+            
+            return result
         except Exception as e:
-            self.logger.error(f"DeepSeek API调用失败: {e}")
+            self.logger.error(f"[SmartMonitorDeepSeek] API调用失败: {e}")
+            self.logger.error(f"  模型: {model_to_use}, API地址: {self.base_url}")
             raise
 
     def analyze_stock_and_decide(self, stock_code: str, market_data: Dict,
diff --git a/smart_monitor_engine.py b/smart_monitor_engine.py
index 0c35798..a1d0468 100644
--- a/smart_monitor_engine.py
+++ b/smart_monitor_engine.py
@@ -15,6 +15,7 @@
 from smart_monitor_db import SmartMonitorDB
 from notification_service import notification_service  # 复用主程序的通知服务
 from config_manager import config_manager  # 复用主程序的配置管理器
+import config  # 导入config模块以使用DEEPSEEK_BASE_URL和DEEPSEEK_MODEL_NAME
 
 
 class SmartMonitorEngine:
@@ -33,23 +34,30 @@ def __init__(self, deepseek_api_key: str = None, qmt_account_id: str = None,
         self.logger = logging.getLogger(__name__)
         
         # 从配置管理器读取配置
-        config = config_manager.read_env()
+        env_config = config_manager.read_env()
         
         # DeepSeek API
         if deepseek_api_key is None:
-            deepseek_api_key = config.get('DEEPSEEK_API_KEY', '')
+            deepseek_api_key = env_config.get('DEEPSEEK_API_KEY', '')
         
         # MiniQMT配置
         if qmt_account_id is None:
-            qmt_account_id = config.get('MINIQMT_ACCOUNT_ID', '')
+            qmt_account_id = env_config.get('MINIQMT_ACCOUNT_ID', '')
         
         if use_simulator is None:
             # 如果MINIQMT_ENABLED=false，则使用模拟器
-            miniqmt_enabled = config.get('MINIQMT_ENABLED', 'false').lower() == 'true'
+            miniqmt_enabled = env_config.get('MINIQMT_ENABLED', 'false').lower() == 'true'
             use_simulator = not miniqmt_enabled
         
         # 初始化各个模块
-        self.deepseek = SmartMonitorDeepSeek(deepseek_api_key)
+        # 从config模块读取 base_url 和 model（从.env文件加载的配置）
+        deepseek_base_url = config.DEEPSEEK_BASE_URL
+        deepseek_model = config.DEEPSEEK_MODEL_NAME
+        self.deepseek = SmartMonitorDeepSeek(
+            api_key=deepseek_api_key,
+            base_url=deepseek_base_url,
+            model=deepseek_model
+        )
         self.data_fetcher = SmartMonitorDataFetcher()
         self.db = SmartMonitorDB()
         self.notification = notification_service  # 使用主程序的通知服务
diff --git a/stock_analysis.db b/stock_analysis.db
deleted file mode 100644
index 6dfc294..0000000
Binary files a/stock_analysis.db and /dev/null differ
diff --git a/stock_monitor.db b/stock_monitor.db
deleted file mode 100644
index 7d84a01..0000000
Binary files a/stock_monitor.db and /dev/null differ
diff --git a/update_env_example.py b/update_env_example.py
index 9a054dc..94b5597 100644
--- a/update_env_example.py
+++ b/update_env_example.py
@@ -18,6 +18,10 @@
 # DeepSeek API基础URL（可选，使用默认值即可）
 DEEPSEEK_BASE_URL=https://api.deepseek.com/v1
 
+# DeepSeek模型名称（可选，默认：deepseek-chat）
+# 可选模型：deepseek-chat、deepseek-reasoner等
+DEEPSEEK_MODEL_NAME=deepseek-chat
+
 
 # ========== Tushare数据接口（可选）==========
 # Tushare Token（可选，用于获取更多金融数据）