系统安装

1，制作系统启动U盘，下载系统ubuntu-server 24.04lts.ios镜像

ubuntu 24.04 (noble) 配置如下

deb https://mirrors.aliyun.com/ubuntu/ noble main restricted universe multiverse
deb-src https://mirrors.aliyun.com/ubuntu/ noble main restricted universe multiverse

deb https://mirrors.aliyun.com/ubuntu/ noble-security main restricted universe multiverse
deb-src https://mirrors.aliyun.com/ubuntu/ noble-security main restricted universe multiverse

deb https://mirrors.aliyun.com/ubuntu/ noble-updates main restricted universe multiverse
deb-src https://mirrors.aliyun.com/ubuntu/ noble-updates main restricted universe multiverse

# deb https://mirrors.aliyun.com/ubuntu/ noble-proposed main restricted universe multiverse
# deb-src https://mirrors.aliyun.com/ubuntu/ noble-proposed main restricted universe multiverse

deb https://mirrors.aliyun.com/ubuntu/ noble-backports main restricted universe multiverse
deb-src https://mirrors.aliyun.com/ubuntu/ noble-backports main restricted universe multiverse
使用U盘写入软件：

硬件清单：

--i7-14700KF

--RTX 4080 16G

--DDR5 32G (建议64G起步)

--SSD 2T NVMe

--HDD 6Tx2 sate

--inte 2.5G

1、Rufus工具

下载地址：Rufus - 轻松创建 USB 启动盘

2、BalenaEtcher

下载地址：balenaEtcher - Flash OS images to SD cards & USB drives

3、UltraISO（如果以上两种都无法启动，可以使用第三种，这种兼容性最好。）

下载地址：UltraISO - ISO CD DVD image creator, editor and ISZ DMG DAA UIF to ISO converter - UltraISO can extract/create/edit/convert CD and DVD image files directly, make bootable CDs and convert ISZ DMG DAA UIF to ISO.

写入好U盘系统，开始安装到物理机上面；

根据现有的系统硬件和自盘进行分区。

最佳结构：

2TB NVMe SSD

├── EFI

├── /

├── /var/lib/docker

├── /opt/ai-models

├── /var/lib/postgresql

├── /var/lib/redis

└── /workspace

6TB HDDx2

disk1 --第一个6T硬盘

disk2 --第二个6T硬盘

└── /data

        ├── market_data

        ├── backtests

        ├── logs

        ├── snapshots

        ├── archives

        └── backups

当前安装界面操作（现在执行）

1. 确认分区（你已经做到了）：

   • /boot/efi 1GB FAT32 ✅

   • / 1.818TB EXT4 ✅

   • 两块 6TB HDD 显示为 Available Devices，未被选中 ✅

2. 触发安装：

   • 按 TAB 键，直到光标移动到下方的 Done

   • 按 ENTER

3. 确认破坏性操作：

   • 系统弹出 Confirm destructive action 或 Write changes to disk?

   • 选择 Continue

   • 按 ENTER

4. 后续安装过程中的关键选项：

   • 务必勾选 Install OpenSSH Server

   • （可选）Featured Server Snaps 可以先不选

   • 设置你的用户名/密码（建议与你 Mac mini 上的用户名相同，方便 rsync/scp）

5. 等待安装完成 → 系统重启 → 拔掉 U盘 → 登录

---

二、安装完成后立即执行的命令（登录 Ubuntu 后）

登录后用以下命令确认磁盘状态，并严格按顺序操作：

bash

# 1. 确认磁盘和分区（请把输出发给我）
lsblk

# 2. 更新系统
sudo apt update && sudo apt upgrade -y

# 3. 安装常用工具
sudo apt install -y net-tools curl wget git vim htop tmux

然后把 lsblk 的结果，（很可能是 /dev/sda 和 /dev/sdb 或 /dev/nvme1n1、/dev/nvme2n1）给出精确的挂载命令。

---

三、挂载两块 6TB HDD 到 /data（等你的 lsblk 输出后执行）

届时我将提供类似以下的安全挂载步骤（不会格式化，保留原有数据）：

bash

# 示例（实际名称以 lsblk 为准）
sudo mkdir -p /data/disk1 /data/disk2
sudo mount /dev/sda1 /data/disk1   # 假设第一个6TB的分区1
sudo mount /dev/sdb1 /data/disk2   # 假设第二个6TB的分区1

# 自动挂载（编辑 fstab）
sudo blkid /dev/sda1   # 复制 UUID
sudo nano /etc/fstab
# 添加两行：
# UUID=xxx  /data/disk1  ext4  defaults  0  2
# UUID=yyy  /data/disk2  ext4  defaults  0  2

---

四、后续安装计划（按顺序）

等你确认 /data 挂载成功后，我会依次提供精确命令：

步骤	任务	预计命令数
1	挂载 6TB HDD	5 条
2	安装 NVIDIA 驱动 (RTX 4080)	4 条
3	安装 CUDA + nvidia-smi 验证	6 条
4	安装 Docker + NVIDIA Container Toolkit	8 条
5	部署 Ollama + Qwen	5 条
6	部署 Redis + PostgreSQL	6 条
7	部署 LangGraph + OpenClaw（需先确认代码来源）	待定

---

五、重要提醒（为了你后面少踩坑）

• 不要在安装过程中手动创建 /data 或 /opt/ai-models 分区 —— 安装程序可能会自动格式化。

• 不要勾选任何与 LVM、磁盘加密、ZFS 相关的选项 —— 保持简单 ext4。

• 两块 6TB HDD 在安装界面保持为 Available Devices 是完全正确的。

查看当前磁盘状态

bash

# 查看所有磁盘和分区
sudo lsblk

# 查看未挂载的磁盘
sudo fdisk -l | grep "Disk /dev/sd"

你应该能看到：

• /dev/sda 或 /dev/sdb - 已经挂载到 /data1 的那块

• 另一块 - 未挂载的 6TB 硬盘

2️⃣ 格式化第二块硬盘（如果还没格式化）

bash

# 先确认设备名（假设是 /dev/sdb）
sudo lsblk

# 如果是全新未格式化的，创建分区表并格式化
sudo parted /dev/sdb mklabel gpt
sudo parted /dev/sdb mkpart primary ext4 0% 100%
sudo mkfs.ext4 /dev/sdb1

# 查看新分区的 UUID
sudo blkid /dev/sdb1

3️⃣ 创建挂载点并挂载

bash

# 创建挂载目录
sudo mkdir -p /data2

# 临时挂载测试
sudo mount /dev/sdb1 /data2

# 验证挂载成功
df -h /data2

4️⃣ 设置开机自动挂载

bash

# 获取 UUID
sudo blkid /dev/sdb1

# 输出示例：/dev/sdb1: UUID="xxxx-xxxx" TYPE="ext4"
# 复制这个 UUID

# 编辑 fstab
sudo nano /etc/fstab

添加以下行（替换成你的 UUID）：

bash

UUID=你的UUID /data2 ext4 defaults 0 2

fstab 格式说明：

• UUID=xxx - 用 UUID 更稳定

• /data2 - 挂载点

• ext4 - 文件系统类型

• defaults - 默认挂载参数

• 0 - dump 备份（0=不备份）

• 2 - fsck 检查顺序（2=在根分区后检查）

保存退出：Ctrl+O → Enter → Ctrl+X

5️⃣ 验证配置

bash

# 测试 fstab 配置是否正确
sudo mount -a

# 检查是否挂载成功
df -h | grep data2

# 查看所有挂载点
lsblk

📁 创建目录结构

bash

# 在 data2 上创建规划好的目录
sudo mkdir -p /data2/archives
sudo mkdir -p /data2/snapshots  
sudo mkdir -p /data2/backups
sudo mkdir -p /data2/logs_longterm

# 设置权限（让你的用户可写）
sudo chown -R $USER:$USER /data2

✅ 最终检查

bash

# 查看完整的磁盘布局
lsblk

# 应该看到类似：
# sda (第一块6TB)
# └─sda1  /data1
# sdb (第二块6TB)  
# └─sdb1  /data2
# nvme0n1 (2TB SSD)
# ├─nvme0n1p1 /boot/efi
# ├─nvme0n1p2 /
# ├─nvme0n1p3 /var/lib/docker
# ├─nvme0n1p4 /opt/ai-models
# └─nvme0n1p5 /workspace

# 查看磁盘使用情况
df -h

📝 可选：创建软链接方便访问

如果想让常用目录更方便访问：

bash

# 在 /data2 上创建归档，并在 /data1 里做个软链接
ln -s /data2/archives /data1/archives_backup

# 或在 home 目录创建快捷方式
ln -s /data2 /home/$USER/data2

🎯 验证写入权限

bash

# 测试写入
echo "test" | sudo tee /data2/test.txt
cat /data2/test.txt
sudo rm /data2/test.txt

# 测试用户权限
touch /data2/test_user.txt
rm /data2/test_user.txt

现在两块 6TB 硬盘都挂好了：

• /data1 - 主数据盘

• /data2 - 备份/归档盘

接下来需要配置什么？比如：

• 安装 Docker 环境

• 配置 Ollama 模型路径

• 设置自动备份脚本

• 安装量化交易相关软件

我会根据实际设备名立即给出挂载两块 6TB 硬盘到 /data 的精确命令，保证不丢失原有数据。

下一步：

1. 安装 NVIDIA 驱动 + CUDA

2. 安装 Docker

3. 部署 Ollama + Qwen

安装nvde 驱动

第一步：安装 NVIDIA 驱动 + CUDA

1. 安装 NVIDIA 驱动 & CUDA：

   bash

   sudo apt update && sudo apt upgrade -y
   sudo ubuntu-drivers install --gpgpu  # 自动安装推荐驱动
   sudo apt install nvidia-cuda-toolkit  # 安装CUDA工具包
   sudo reboot

   

重启后运行 nvidia-smi 验证。

下一步安装docker

使用国内镜像源

方法一：使用阿里云 Docker 镜像源（推荐）

bash

# 使用阿里云的 Docker GPG 密钥
curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# 添加阿里云 Docker 仓库
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 更新并安装
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

方法二：使用清华源（备选）

如果阿里云也不行，换清华源：

bash

# 使用清华源的 GPG 密钥
curl -fsSL https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# 添加清华源仓库
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 更新并安装
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

方法三：直接使用 Ubuntu 官方源（最简单，版本可能稍旧）

bash

# 直接使用 Ubuntu 自带的 Docker 包
sudo apt install -y docker.io docker-compose

# 这种方式缺点：版本可能不是最新的，但对大多数场景够用

✅ 验证安装

无论用哪种方法，安装完成后：

bash

# 将用户加入 docker 组
sudo usermod -aG docker $USER

# 刷新组权限（或者重新登录）
newgrp docker

# 验证 Docker 是否正常工作
docker --version
docker run hello-world

# 如果需要 GPU 支持，安装 nvidia-docker
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

继续安装 Docker

bash

# 1. 将用户加入 docker 组（如果还没做）
sudo usermod -aG docker $USER
newgrp docker

# 2. 验证 Docker 安装
docker --version
docker compose version

# 3. 测试 Docker 运行（可选）
docker run --rm hello-world

直接执行方法一（阿里云源），你的系统已经配置了阿里云的 Ubuntu 源，说明阿里云连接稳定，用它的 Docker 源也最可靠。

安装 Ollama

bash

# 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh
如果官网网络不稳定就切换到国内
curl -fsSL https://cnb.cool/hex/ollama/-/git/raw/main/install.sh | sh


# 配置模型路径到 SSD 分区
sudo systemctl stop ollama
sudo mkdir -p /opt/ai-models/ollama
sudo chown -R ollama:ollama /opt/ai-models/ollama

# 修改 Ollama 启动服务配置
sudo mkdir -p /etc/systemd/system/ollama.service.d
echo '[Service]
Environment="OLLAMA_MODELS=/opt/ai-models/ollama"
Environment="OLLAMA_HOST=0.0.0.0"' | sudo tee /etc/systemd/system/ollama.service.d/override.conf

# 重载并启动
sudo systemctl daemon-reload
sudo systemctl start ollama
sudo systemctl enable ollama

# 创建模型目录
sudo mkdir -p /opt/ai-models/ollama
sudo chown -R ollama:ollama /opt/ai-models/ollama

# 如果 Ollama 已经在运行，重启使配置生效
sudo systemctl restart ollama


# 验证
ollama --version
ollama list

🐍 安装 Python 环境

bash

# 安装 Python 和基础包
sudo apt install -y python3 python3-pip python3-venv python3-dev

# 安装数据科学和 AI 库
pip3 install --user --upgrade pip
====================================================
完整路径配置
# 回到用户目录
cd ~

# 创建虚拟环境
python3 -m venv ai-trading-env

# 激活
source ~/ai-trading-env/bin/activate

# 升级 pip
pip install --upgrade pip

# 安装 PyTorch (CUDA)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# 安装其他包
pip install numpy pandas matplotlib seaborn jupyter
pip install transformers datasets accelerate
pip install langgraph langchain langchain-community
pip install ccxt backtrader pandas-ta
pip install redis psycopg2-binary

# 验证
python -c "import torch; print(f'CUDA: {torch.cuda.is_available()}')"
==========================================================================


# 验证 CUDA
python3 -c "import torch; print(f'CUDA: {torch.cuda.is_available()}'); print(f'GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"None\"}')"

如果以上安装比较慢或者中断，请切换国内清华源

网络超时，下载速度太慢。使用国内镜像源来解决。

🔧 配置 pip 国内镜像源

bash

# 在当前虚拟环境中，临时使用清华源安装
pip install --upgrade pip -i https://pypi.tuna.tsinghua.edu.cn/simple

# 安装 numpy（使用清华源）
pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

# 配置永久镜像源（推荐）
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
pip config set global.trusted-host pypi.tuna.tsinghua.edu.cn

📦 批量安装所有包（使用镜像）

bash

# 使用清华源安装所有包
pip install \
  torch torchvision torchaudio \
  numpy pandas matplotlib seaborn jupyter \
  transformers datasets accelerate \
  langgraph langchain langchain-community \
  ccxt backtrader pandas-ta \
  redis psycopg2-binary \
  -i https://pypi.tuna.tsinghua.edu.cn/simple

📁 创建项目目录结构

bash

# 在 SSD 上创建工作目录
mkdir -p /workspace/{ai-trading,notebooks,langgraph,openclaw,scripts}

# 在 HDD 上创建数据目录
mkdir -p /data/{market_data/{spot,futures,orderbook},backtests/{results,logs},snapshots,redis,postgresql}
mkdir -p /data2/{backups/{daily,weekly,models},archives/{2024,2025},logs_longterm}

# 创建软链接
ln -sf /workspace ~/workspace
ln -sf /data ~/data
ln -sf /data2 ~/data2

# 设置权限
chown -R $USER:$USER /workspace /data /data2

🚀 测试 AI 环境

bash

# 下载一个轻量级模型测试
ollama pull qwen2.5:4b

# 运行测试（这会下载约 2.5GB 模型）
ollama run qwen2.5:4b "介绍一下 AI 量化交易的基本概念"

# 或者用更小的模型快速验证
ollama pull tinyllama
echo "Hello, AI trading server!" | ollama run tinyllama

🐳 启动基础服务（Docker 容器）

bash

# 创建 Docker 网络
docker network create ai-net

# PostgreSQL（交易数据存储）
docker run -d \
  --name postgres \
  --network ai-net \
  -e POSTGRES_PASSWORD=your_strong_password \
  -e POSTGRES_DB=trading \
  -v /data/postgresql:/var/lib/postgresql/data \
  -p 5432:5432 \
  --restart unless-stopped \
  postgres:16

# Redis（缓存和消息队列）
docker run -d \
  --name redis \
  --network ai-net \
  -v /data/redis:/data \
  -p 6379:6379 \
  --restart unless-stopped \
  redis:alpine --requirepass your_redis_password

# 查看运行状态
docker ps

================

# 创建 Docker 网络
docker network create ai-net

# 启动 PostgreSQL
docker run -d \
  --name postgres \
  --network ai-net \
  -e POSTGRES_PASSWORD=trading123 \
  -e POSTGRES_DB=trading \
  -v /data/postgresql:/var/lib/postgresql/data \
  -p 5432:5432 \
  --restart unless-stopped \
  postgres:16

# 启动 Redis

docker run -d \
  --name redis \
  --network ai-net \
  -v /data/redis:/data \
  -p 6379:6379 \
  --restart unless-stopped \
  redis:alpine \
  redis-server --requirepass trading123

# 查看运行状态
docker ps

================

🔥 配置环境变量

bash

# 添加到 .bashrc
cat >> ~/.bashrc << 'EOF'

# AI Trading Environment
export HF_HOME=/opt/ai-models/huggingface
export TRANSFORMERS_CACHE=/opt/ai-models/huggingface/transformers
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_ORIGINS="*"

# Paths
export WORKSPACE=/workspace
export DATA_DIR=/data
export DATA2_DIR=/data2
export AI_MODELS=/opt/ai-models

# Database
export POSTGRES_HOST=localhost
export POSTGRES_DB=trading
export POSTGRES_USER=postgres
export POSTGRES_PASSWORD=your_strong_password
export REDIS_HOST=localhost
export REDIS_PASSWORD=your_redis_password

# Aliases
alias dkps='docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"'
alias dklog='docker logs -f'
alias ollama-list='ollama list'
alias nvtop='nvtop'  # 需要 sudo apt install nvtop
EOF

# 创建 HuggingFace 缓存目录
mkdir -p /opt/ai-models/huggingface

# 生效配置
source ~/.bashrc

✅ 验证完整环境

bash

# 1. 检查所有服务
systemctl status ollama --no-pager
docker ps
nvidia-smi

# 2. 检查磁盘挂载
df -h | grep -E "/data|/workspace|/opt/ai-models"

# 3. 测试 Python 导入
python3 -c "import torch, pandas, langgraph; print('All imports OK')"

# 4. 测试数据库连接
docker exec postgres pg_isready -U postgres
docker exec redis redis-cli -a your_redis_password ping

📊 安装监控工具（可选）

bash

# 安装 nvtop（GPU 监控）
sudo apt install -y nvtop

# 安装 htop（CPU/内存监控）
sudo apt install -y htop

# 安装 nvitop（更现代的 GPU 监控）
pip3 install --user nvitop

🎯 现在环境已就绪

你的服务器现在拥有：

• ✅ Docker + GPU 支持

• ✅ Ollama 本地大模型

• ✅ Python + PyTorch + CUDA

• ✅ PostgreSQL + Redis

• ✅ 完整的目录结构

下一步建议：

1. 运行 ollama pull qwen2.5:7b 下载更大的模型

2. 配置 Jupyter 远程访问

3. 开始部署 LangGraph 或 OpenClaw

📓 1. 配置 Jupyter 远程访问

安装并配置 Jupyter Lab

bash

# 激活虚拟环境
source ~/ai-trading-env/bin/activate

# 安装 Jupyter Lab 扩展
pip install jupyterlab jupyterlab-git jupyterlab-code-formatter
pip install jupyter-server-proxy

# 生成配置文件
jupyter lab --generate-config

# 设置密码（推荐）
python -c "from jupyter_server.auth import passwd; print(passwd('your_password_here'))"
# 保存输出的密码哈希值

# 创建 Jupyter 配置
cat > ~/.jupyter/jupyter_lab_config.py << 'EOF'
# Jupyter Lab 配置
c.ServerApp.ip = '0.0.0.0'
c.ServerApp.port = 8888
c.ServerApp.open_browser = False
c.ServerApp.allow_origin = '*'
c.ServerApp.allow_remote_access = True
c.ServerApp.token = ''  # 留空，使用密码
c.ServerApp.password = 'argon2:$argon2id$v=19$m=10240,t=10,p=8$...'  # 替换为上面生成的哈希
c.ServerApp.root_dir = '/workspace'
c.ServerApp.notebook_dir = '/workspace/notebooks'

# 启用扩展
c.ExtensionApp.default_url = '/lab'
c.LabApp.extensions_enabled = {
    'jupyterlab-git': True,
    'jupyterlab-code-formatter': True,
}

# 资源限制
c.ServerApp.max_buffer_size = 1024 * 1024 * 1024  # 1GB
EOF

# 创建 notebook 目录
mkdir -p /workspace/notebooks

# 创建启动脚本
cat > ~/start_jupyter.sh << 'EOF'
#!/bin/bash
source ~/ai-trading-env/bin/activate

# 检查是否已在运行
if pgrep -f "jupyter-lab" > /dev/null; then
    echo "Jupyter Lab 已在运行"
    ps aux | grep jupyter-lab | grep -v grep
else
    echo "启动 Jupyter Lab..."
    nohup jupyter lab --config=~/.jupyter/jupyter_lab_config.py > /tmp/jupyter.log 2>&1 &
    sleep 3
    echo "✓ Jupyter Lab 已启动"
    echo "访问地址: http://192.168.10.137:8888"
    echo "日志: tail -f /tmp/jupyter.log"
fi
EOF

chmod +x ~/start_jupyter.sh

# 启动 Jupyter
./start_jupyter.sh

🚀 2. 下载更大的 AI 模型

下载 Qwen2.5 7B 模型

bash

# 临时开启代理（如果需要）
export HTTP_PROXY=http://127.0.0.1:7890
export HTTPS_PROXY=http://127.0.0.1:7890

# 下载 Qwen2.5 7B 模型（约 4-5GB，时间较长）
ollama pull qwen2.5:7b

# 或者下载其他推荐模型
ollama pull qwen2.5:14b  # 如果内存足够

# 查看已下载模型
ollama list

# 测试模型
ollama run qwen2.5:7b "介绍一下量化交易的核心策略"

🔧 3. 部署 LangGraph 高级工作流

bash

# 安装最新 LangGraph 组件
source ~/ai-trading-env/bin/activate
pip install langgraph-sdk langgraph-cli

# 创建完整的交易工作流
cat > /workspace/langgraph/advanced_workflow.py << 'EOF'
#!/usr/bin/env python3
"""高级 AI 量化交易工作流"""
from typing import TypedDict, List, Annotated, Dict
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.postgres import PostgresSaver
from langchain_ollama import ChatOllama
import operator
import pandas as pd
import numpy as np
from datetime import datetime
import json

# 定义状态
class TradingState(TypedDict):
    messages: Annotated[List[str], operator.add]
    session_id: str
    symbol: str
    market_data: Dict
    technical_indicators: Dict
    sentiment: str
    risk_analysis: Dict
    strategy: str
    signal: str
    confidence: float
    order: Dict
    executed: bool

class AdvancedTradingAgent:
    """高级交易智能体"""
    
    def __init__(self, model="qwen2.5:7b"):
        self.llm = ChatOllama(model=model, base_url="http://localhost:11434", temperature=0.3)
        
    def fetch_data(self, state: TradingState):
        """获取市场数据（模拟）"""
        print(f"📊 获取 {state['symbol']} 市场数据...")
        
        # 生成模拟数据
        np.random.seed(hash(state['session_id']) % 2**32)
        df = pd.DataFrame({
            'timestamp': pd.date_range(end=datetime.now(), periods=100, freq='1H'),
            'close': 50000 + np.cumsum(np.random.randn(100) * 500),
            'volume': np.random.uniform(100, 10000, 100)
        })
        
        return {
            "market_data": df.tail(20).to_dict(),
            "messages": [f"✓ 获取到 {len(df)} 条K线数据"]
        }
    
    def calculate_indicators(self, state: TradingState):
        """计算技术指标"""
        df = pd.DataFrame(state['market_data'])
        
        # 计算各项指标
        indicators = {
            'sma_20': df['close'].rolling(20).mean().iloc[-1],
            'sma_50': df['close'].rolling(50).mean().iloc[-1] if len(df) >= 50 else df['close'].mean(),
            'rsi': self._calculate_rsi(df['close']),
            'volatility': df['close'].pct_change().std() * np.sqrt(252),
            'volume_trend': df['volume'].rolling(20).mean().iloc[-1] / df['volume'].mean()
        }
        
        return {
            "technical_indicators": indicators,
            "messages": [f"📈 技术指标: RSI={indicators['rsi']:.1f}, 波动率={indicators['volatility']:.2%}"]
        }
    
    def analyze_sentiment(self, state: TradingState):
        """AI 情绪分析"""
        prompt = f"""
        基于以下市场数据进行分析:
        - 交易对: {state['symbol']}
        - RSI: {state['technical_indicators']['rsi']:.1f}
        - 波动率: {state['technical_indicators']['volatility']:.2%}
        
        请给出市场情绪判断（乐观/中性/悲观）和简要理由。
        """
        
        response = self.llm.invoke(prompt)
        sentiment = "乐观" if "乐观" in response.content else "悲观" if "悲观" in response.content else "中性"
        
        return {
            "sentiment": sentiment,
            "messages": [f"💭 市场情绪: {sentiment}"]
        }
    
    def assess_risk(self, state: TradingState):
        """风险评估"""
        indicators = state['technical_indicators']
        
        # 风险评分（0-100）
        risk_score = 0
        risk_score += min(indicators['volatility'] * 100, 40)  # 波动风险
        risk_score += (70 - indicators['rsi']) / 70 * 30 if indicators['rsi'] < 70 else 0  # RSI风险
        risk_score += (1 - indicators['volume_trend']) * 30 if indicators['volume_trend'] < 1 else 0
        
        risk_level = "低" if risk_score < 30 else "中" if risk_score < 70 else "高"
        
        return {
            "risk_analysis": {
                "score": risk_score,
                "level": risk_level,
                "factors": {
                    "volatility": indicators['volatility'],
                    "volume_trend": indicators['volume_trend']
                }
            },
            "messages": [f"⚠️ 风险等级: {risk_level} (评分: {risk_score:.1f})"]
        }
    
    def generate_strategy(self, state: TradingState):
        """AI 生成交易策略"""
        prompt = f"""
        根据以下分析生成交易策略:
        - RSI: {state['technical_indicators']['rsi']:.1f}
        - 情绪: {state['sentiment']}
        - 风险等级: {state['risk_analysis']['level']}
        
        请给出具体的交易决策（买入/卖出/持有），仓位建议（0-100%），止损位和止盈位。
        """
        
        response = self.llm.invoke(prompt)
        
        # 解析策略（简化版）
        if "买入" in response.content:
            signal = "BUY"
            confidence = 70
        elif "卖出" in response.content:
            signal = "SELL"
            confidence = 70
        else:
            signal = "HOLD"
            confidence = 50
        
        return {
            "strategy": response.content,
            "signal": signal,
            "confidence": confidence,
            "messages": [f"🎯 交易信号: {signal} (置信度: {confidence}%)"]
        }
    
    def execute_order(self, state: TradingState):
        """执行交易（模拟）"""
        if state['signal'] != "HOLD" and state['confidence'] > 60:
            order = {
                "action": state['signal'],
                "symbol": state['symbol'],
                "quantity": state['confidence'] / 100,  # 仓位基于置信度
                "timestamp": datetime.now().isoformat(),
                "status": "simulated"
            }
            return {
                "order": order,
                "executed": True,
                "messages": [f"✅ 已执行{order['action']}订单: {order['quantity']:.2%}仓位"]
            }
        else:
            return {
                "executed": False,
                "messages": ["⏸️ 未执行交易（信号不足）"]
            }
    
    def _calculate_rsi(self, prices, period=14):
        """计算 RSI"""
        delta = prices.diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
        rs = gain / loss
        rsi = 100 - (100 / (1 + rs))
        return rsi.iloc[-1]
    
    def create_workflow(self):
        """创建 LangGraph 工作流"""
        workflow = StateGraph(TradingState)
        
        # 添加节点
        workflow.add_node("fetch_data", self.fetch_data)
        workflow.add_node("calculate_indicators", self.calculate_indicators)
        workflow.add_node("analyze_sentiment", self.analyze_sentiment)
        workflow.add_node("assess_risk", self.assess_risk)
        workflow.add_node("generate_strategy", self.generate_strategy)
        workflow.add_node("execute_order", self.execute_order)
        
        # 定义边
        workflow.set_entry_point("fetch_data")
        workflow.add_edge("fetch_data", "calculate_indicators")
        workflow.add_edge("calculate_indicators", "analyze_sentiment")
        workflow.add_edge("analyze_sentiment", "assess_risk")
        workflow.add_edge("assess_risk", "generate_strategy")
        workflow.add_edge("generate_strategy", "execute_order")
        workflow.add_edge("execute_order", END)
        
        # 添加 PostgreSQL 检查点（状态持久化）
        checkpointer = PostgresSaver.from_conn_string(
            "postgresql://postgres:trading123@localhost:5432/trading"
        )
        
        return workflow.compile(checkpointer=checkpointer)
    
    def run(self, symbol="BTC/USDT", session_id=None):
        """运行完整交易智能体"""
        if session_id is None:
            session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
        
        print(f"🤖 启动高级交易智能体")
        print(f"会话: {session_id}")
        print(f"交易对: {symbol}")
        print("=" * 60)
        
        initial_state = {
            "messages": [],
            "session_id": session_id,
            "symbol": symbol,
            "market_data": {},
            "technical_indicators": {},
            "sentiment": "",
            "risk_analysis": {},
            "strategy": "",
            "signal": "",
            "confidence": 0.0,
            "order": {},
            "executed": False
        }
        
        config = {"configurable": {"thread_id": session_id}}
        workflow = self.create_workflow()
        result = workflow.invoke(initial_state, config=config)
        
        print("\n" + "=" * 60)
        print("📊 最终分析结果:")
        print(f"信号: {result.get('signal', 'N/A')}")
        print(f"置信度: {result.get('confidence', 0):.1f}%")
        if result.get('executed'):
            print(f"订单: {result.get('order', {})}")
        
        return result

if __name__ == "__main__":
    agent = AdvancedTradingAgent(model="qwen2.5:7b")
    result = agent.run("BTC/USDT")
EOF

# 测试运行
python /workspace/langgraph/advanced_workflow.py

📋 4. 创建 OpenClaw 配置文件

bash

# 创建 OpenClaw 配置
mkdir -p /workspace/openclaw
cat > /workspace/openclaw/config.yaml << 'EOF'
# OpenClaw 量化交易框架配置

# 交易所配置
exchanges:
  binance:
    enabled: true
    testnet: true
    api_key: YOUR_API_KEY
    secret_key: YOUR_SECRET_KEY
    
  okx:
    enabled: false
    testnet: true

# 交易策略
strategies:
  - name: "AI_Momentum"
    type: "ml_based"
    model: "qwen2.5:7b"
    symbols: ["BTC/USDT", "ETH/USDT"]
    timeframe: "1h"
    
  - name: "MeanReversion"
    type: "statistical"
    model: "llama3.2:3b"
    symbols: ["BTC/USDT"]
    timeframe: "15m"

# 风险管理
risk_management:
  max_position_size: 0.1  # 最大仓位 10%
  max_daily_loss: 0.05    # 最大日亏损 5%
  stop_loss: 0.02         # 止损 2%
  take_profit: 0.04       # 止盈 4%

# AI 配置
ai:
  ollama_url: http://localhost:11434
  default_model: qwen2.5:7b
  fallback_model: llama3.2:3b
  sentiment_enabled: true

# 数据存储
database:
  postgresql: postgresql://postgres:trading123@localhost:5432/trading
  redis: redis://:trading123@localhost:6379/0
  
# 日志
logging:
  level: INFO
  output: /workspace/logs/openclaw.log
EOF

# 创建运行脚本
cat > /workspace/openclaw/run.py << 'EOF'
#!/usr/bin/env python3
"""OpenClaw 主运行脚本"""
import yaml
import logging
from datetime import datetime

with open('/workspace/openclaw/config.yaml', 'r') as f:
    config = yaml.safe_load(f)

logging.basicConfig(
    level=getattr(logging, config['logging']['level']),
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(config['logging']['output']),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)

if __name__ == "__main__":
    logger.info("OpenClaw 启动中...")
    logger.info(f"配置加载完成: {datetime.now()}")
    # 这里添加主逻辑

✅ 5. 启动所有服务

bash

# 创建一键启动脚本
cat > ~/start_all_services.sh << 'EOF'
#!/bin/bash
echo "🚀 启动所有 AI 交易服务..."

# 启动 Docker 服务
echo "启动 Docker 容器..."
docker start postgres redis pgweb pgadmin4 2>/dev/null

# 启动 Jupyter
echo "启动 Jupyter Lab..."
~/start_jupyter.sh

# 检查 Ollama
echo "检查 Ollama..."
if ! pgrep -f "ollama serve" > /dev/null; then
    sudo systemctl start ollama
fi

# 显示状态
echo ""
echo "✅ 服务启动完成！"
echo ""
echo "📊 访问地址："
echo "  - Jupyter Lab: http://192.168.10.137:8888"
echo "  - pgAdmin: http://192.168.10.137:8080"
echo "  - pgweb: http://192.168.10.137:8081"
echo ""
echo "🤖 AI 模型："
ollama list
echo ""
echo "💡 使用命令："
echo "  - quant-status : 查看服务状态"
echo "  - quant-run    : 运行 AI 策略"
echo "  - quant-gpu    : 查看 GPU 状态"
EOF

chmod +x ~/start_all_services.sh
./start_all_services.sh

🎯 最终验证

bash

# 查看所有服务状态
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

# 测试 AI 模型
ollama run qwen2.5:7b "解释量化交易中的均值回归策略"

# 运行高级工作流
source ~/ai-trading-env/bin/activate
python /workspace/langgraph/advanced_workflow.py

最后使用docker安装openclaw