~/.openclaw/skills/
├── my-skill/
│   ├── SKILL.md          # 技能定义文件（核心）
│   ├── _meta.json        # 元数据
│   ├── scripts/          # 脚本文件
│   └── references/       # 参考资料

用户消息 → Agent 语义匹配 → 加载对应 SKILL.md → Agent 根据指令执行 → 调用脚本/工具/API

uv tool install "browser-use[cli]"

# 检查邮箱
node scripts/imap.js check
node scripts/imap.js check --account qq  # 指定账号

# 搜索邮件
node scripts/imap.js search --query "关键词"

# 获取邮件详情
node scripts/imap.js fetch --uid 1234

# 下载附件
node scripts/imap.js download --uid 1234

# 列出邮箱文件夹
node scripts/imap.js list-mailboxes

# 发送邮件
node scripts/smtp.js send --to "target@example.com" --subject "主题" --body "内容"

IMAP_HOST=imap.163.com
IMAP_PORT=993
IMAP_USER=your@email.com
IMAP_PASS=your_password
IMAP_TLS=true

SMTP_HOST=smtp.163.com
SMTP_PORT=465
SMTP_USER=your@email.com
SMTP_PASS=your_password
SMTP_TLS=true

# 查看热门市场
python3 scripts/polymarket.py trending

# 搜索特定事件
python3 scripts/polymarket.py search --query "election"

# 查看市场详情
python3 scripts/polymarket.py market --id "市场ID"

# 查看股票价格
python3 scripts/stock_analysis.py price --ticker AAPL

# 查看财务数据
python3 scripts/stock_analysis.py financials --ticker AAPL

# 管理自选股
python3 scripts/watchlist.py add AAPL
python3 scripts/watchlist.py list

# 获取字幕
python3 scripts/get_transcript.py --url "https://youtube.com/watch?v=VIDEO_ID"

# 指定语言
python3 scripts/get_transcript.py --url "视频URL" --lang zh

/gh-issues owner/repo --label bug --limit 5

openclaw skills check

# 通用方式
curl -L -o /tmp/skill.zip "https://wry-manatee-359.convex.site/api/v1/download?slug=技能名"
unzip -o /tmp/skill.zip -d ~/.openclaw/skills/技能名/

# 如果有 npm 依赖
cd ~/.openclaw/skills/技能名 && npm install

# 如果有 Python 依赖
pip3 install 依赖包名

rm -rf ~/.openclaw/skills/技能名
openclaw gateway restart

mkdir -p ~/.openclaw/skills/my-skill/{scripts,references}

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

# 安装必要工具
sudo apt install -y git curl build-essential

# 安装 Node.js（OpenClaw 需要 Node 22+）
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs

# 验证
node -v  # v22.x+
npm -v

curl -fsSL --proto '=https' --tlsv1.2 https://openclaw.ai/install.sh | bash

openclaw --version
# OpenClaw 2026.x.x

# 启动 Gateway（首次会引导你配置）
openclaw gateway start

# 查看当前配置
openclaw status

openclaw gateway start    # 启动
openclaw gateway stop     # 停止
openclaw gateway restart  # 重启
openclaw gateway status   # 状态检查

# 克隆飞书扩展
git clone https://github.com/openclaw-lark/openclaw-lark.git ~/.openclaw/extensions/openclaw-lark
cd ~/.openclaw/extensions/openclaw-lark
npm install

# 通用安装方式
curl -L -o /tmp/skill.zip "https://wry-manatee-359.convex.site/api/v1/download?slug=技能名"
unzip -o /tmp/skill.zip -d ~/.openclaw/skills/技能名/
cd ~/.openclaw/skills/技能名 && npm install  # 如果需要

# 安装
curl -L -o /tmp/imap-smtp-email.zip "https://wry-manatee-359.convex.site/api/v1/download?slug=imap-smtp-email"
unzip -o /tmp/imap-smtp-email.zip -d ~/.openclaw/skills/imap-smtp-email
cd ~/.openclaw/skills/imap-smtp-email && npm install

IMAP_HOST=imap.163.com
IMAP_PORT=993
IMAP_USER=your@email.com
IMAP_PASS=your_password
IMAP_TLS=true

SMTP_HOST=smtp.163.com
SMTP_PORT=465
SMTP_USER=your@email.com
SMTP_PASS=your_password
SMTP_TLS=true

pip3 install requests
# 下载安装（同上方式）

pip3 install yfinance
# 下载安装

pip3 install youtube-transcript-api

npm install -g @steipete/summarize
# 配置 API Key（支持智谱）
export Z_AI_API_KEY="your_key"

uv tool install browser-use

openclaw skills check

# 安装 Claude Code
npm install -g @anthropic-ai/claude-code

# 验证
claude --version

claude --dangerously-skip-permissions -p "你的指令"

echo 'export NODE_COMPILE_CACHE=/var/tmp/openclaw-compile-cache' >> ~/.bashrc
echo 'mkdir -p /var/tmp/openclaw-compile-cache' >> ~/.bashrc
source ~/.bashrc

sudo systemctl edit openclaw

[Service]
Environment=OPENCLAW_NO_RESPAWN=1
Environment=NODE_COMPILE_CACHE=/var/tmp/openclaw-compile-cache
Restart=always
RestartSec=2
TimeoutStartSec=90

gh auth login

export GITHUB_TOKEN="your_token"

ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'your_password';
FLUSH PRIVILEGES;

cd /Users/heyaohua/Server
git clone https://github.com/langgenius/dify.git
cd dify/docker

# 复制环境变量模板
cp .env.example .env

# 编辑环境变量文件
vim .env

# 启动所有服务
docker-compose up -d

# 检查服务状态
docker-compose ps

# 使用 Homebrew 安装
brew install cloudflared

cloudflared tunnel login

# 创建名为 dify-tunnel 的隧道
cloudflared tunnel create dify-tunnel

tunnel: e5e75674-d270-4201-ab9e-ea858c091d91
credentials-file: /Users/heyaohua/.cloudflared/e5e75674-d270-4201-ab9e-ea858c091d91.json

ingress:
  - hostname: dify.yourdomain.com
    service: http://127.0.0.1:80
  - service: http_status:404

# 为域名创建 DNS 记录（如果不存在）
cloudflared tunnel route dns dify-tunnel dify.yourdomain.com

# 设置 DNS 解析并启动隧道
cd /Users/heyaohua/Server/Dify/docker
GODNS=1.1.1.1 cloudflared tunnel --config config.yaml run

cloudflared service install

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
        <dict>
                <key>Label</key>
                <string>com.cloudflare.cloudflared</string>
                <key>ProgramArguments</key>
                <array>
                        <string>/opt/homebrew/bin/cloudflared</string>
                        <string>tunnel</string>
                        <string>--config</string>
                        <string>/Users/heyaohua/Server/Dify/docker/config.yaml</string>
                        <string>run</string>
                </array>
                <key>RunAtLoad</key>
                <true/>
                <key>StandardOutPath</key>
                <string>/Users/heyaohua/Library/Logs/com.cloudflare.cloudflared.out.log</string>
                <key>StandardErrorPath</key>
                <string>/Users/heyaohua/Library/Logs/com.cloudflare.cloudflared.err.log</string>
                <key>KeepAlive</key>
                <dict>
                        <key>SuccessfulExit</key>
                        <false/>
                </dict>
                <key>ThrottleInterval</key>
                <integer>5</integer>
                <key>EnvironmentVariables</key>
                <dict>
                        <key>GODNS</key>
                        <string>1.1.1.1</string>
                </dict>
        </dict>
</plist>

# 复制配置文件到 LaunchAgents 目录
cp com.cloudflare.cloudflared.plist /Users/heyaohua/Library/LaunchAgents/

# 卸载旧服务（如果存在）
launchctl unload /Users/heyaohua/Library/LaunchAgents/com.cloudflare.cloudflared.plist

# 加载新服务
launchctl bootstrap gui/$(id -u) /Users/heyaohua/Library/LaunchAgents/com.cloudflare.cloudflared.plist

# 检查服务是否运行
launchctl list | grep cloudflared

# 查看服务日志
tail -f /Users/heyaohua/Library/Logs/com.cloudflare.cloudflared.err.log

launchctl bootstrap gui/$(id -u) /Users/heyaohua/Library/LaunchAgents/com.cloudflare.cloudflared.plist

launchctl bootout gui/$(id -u) /Users/heyaohua/Library/LaunchAgents/com.cloudflare.cloudflared.plist

launchctl list | grep cloudflared

# 查看输出日志
tail -f /Users/heyaohua/Library/Logs/com.cloudflare.cloudflared.out.log

# 查看错误日志
tail -f /Users/heyaohua/Library/Logs/com.cloudflare.cloudflared.err.log

# 临时使用 Cloudflare DNS
GODNS=1.1.1.1 cloudflared tunnel --config config.yaml run

# 检查端口占用
lsof -i :80

# 检查 Docker 服务状态
docker-compose ps

App(写) ─────────►  Primary(主)
                ╲
                 ╲ WAL Stream
                  ╲
App(读) ───────────► Standby1(从)
                   ► Standby2(从)

               +-------------------+
               |    pgbouncer      |  连接池（减少连接抖动）
               +-------------------+
                        │
                 +--------------+
                 |   Pgpool-II  |  SQL解析级读写分离/健康检查/故障转移脚本
                 +--------------+
                     │     │
                (Write)   (Read)
                     │     │
                   Primary  ──┬── Standby1
                              └── Standby2

        +-------------------+
        | Patroni + etcd    |  主从编排/自动故障切换/仲裁
        +-------------------+

# 基础
listen_addresses = '*'
port = 5432

# 复制/WAL
wal_level = replica
max_wal_senders = 10
max_wal_size = 4GB
min_wal_size = 1GB
wal_keep_size = 1024MB

# 半同步（可选）
# synchronous_commit = on
# synchronous_standby_names = 'FIRST 1 (standby1, standby2)'

# 性能观测（推荐开启）
shared_preload_libraries = 'pg_stat_statements'
pg_stat_statements.max = 10000
pg_stat_statements.track = all

# 归档（如采用 pgBackRest 则由其接管）
# archive_mode = on
# archive_command = 'test ! -f /var/backup/%f && cp %p /var/backup/%f'

# 允许业务访问
host    all             appuser         10.0.0.0/16           scram-sha-256

# 允许复制连接（repl 角色）
host    replication     repl            10.0.0.0/16           scram-sha-256

CREATE ROLE repl WITH REPLICATION LOGIN PASSWORD 'REPLACE_WITH_REPL_PASSWORD';

pg_basebackup -h 10.0.0.10 -p 5432 -U repl \
  -D /var/lib/postgresql/17/data -X stream -C -S standby1_slot -R -P

SELECT pid, application_name, client_addr, state, sync_state, sent_lsn, write_lsn, flush_lsn, replay_lsn
FROM pg_stat_replication;

SELECT now() - pg_last_xact_replay_timestamp() AS standby_delay;

recovery_min_apply_delay = '5min'

# 监听
listen_addresses = '0.0.0.0'
port = 9999

# 后端节点（node_id 从 0 开始）
backend_hostname0 = '10.0.0.10'   # primary
backend_port0     = 5432
backend_weight0   = 1
backend_flag0     = 'ALWAYS_PRIMARY'

backend_hostname1 = '10.0.0.11'   # standby1
backend_port1     = 5432
backend_weight1   = 1
backend_flag1     = 'ALLOW_TO_FAILOVER'

backend_hostname2 = '10.0.0.12'   # standby2
backend_port2     = 5432
backend_weight2   = 1
backend_flag2     = 'ALLOW_TO_FAILOVER'

# 读写分离与负载
load_balance_mode = on                 # 允许 SELECT 负载到从库
statement_level_load_balance = on      # 语句级平衡（谨慎与事务特性）
replication_mode = off                 # 非多主
master_slave_mode = on
master_slave_sub_mode = 'stream'       # Streaming Replication

# 健康检查
health_check_period = 5
health_check_timeout = 3
health_check_user = 'pgpool'           # 仅用于健康检查的低权账号
health_check_password = '***'

# 主从跟随（当主切换时，更新路由）
follow_primary_command = '/usr/local/bin/pgpool-follow-primary %d %h %p %D %m %H %M %P %r %R'

# 会话保持与函数黑名单（避免副作用语句被当作读）
black_function_list = 'nextval,setval'
white_function_list = ''

# 日志
log_per_node_statement = off
log_statement = off

host    all     all     10.0.0.0/16     scram-sha-256

admin:SCRAM-SHA-256$<hash>

frontend pg_write
  bind *:5000
  default_backend pg_primary

backend pg_primary
  option tcp-check
  server primary 10.0.0.10:5432 check

frontend pg_read
  bind *:5001
  default_backend pg_standbys

backend pg_standbys
  balance roundrobin
  option tcp-check
  server s1 10.0.0.11:5432 check
  server s2 10.0.0.12:5432 check

scope: pg-cluster
name: pg01

restapi:
  listen: 0.0.0.0:8008
  connect_address: 10.0.0.10:8008

etcd:
  hosts: 10.0.0.20:2379,10.0.0.21:2379,10.0.0.22:2379

postgresql:
  listen: 0.0.0.0:5432
  connect_address: 10.0.0.10:5432
  data_dir: /var/lib/postgresql/17/data
  bin_dir: /usr/lib/postgresql/17/bin
  parameters:
    wal_level: replica
    max_wal_senders: 10
    wal_keep_size: 1024MB
    shared_preload_libraries: pg_stat_statements
  authentication:
    replication:
      username: repl
      password: REPLACE_WITH_REPL_PASSWORD
    superuser:
      username: postgres
      password: REPLACE_WITH_SUPERUSER_PASSWORD
  pg_hba:
  - host all all 0.0.0.0/0 scram-sha-256
  - host replication repl 0.0.0.0/0 scram-sha-256

synchronous_mode: false   # 如需半同步置 true，并配置 standby 优先级

pg_ctl -D /var/lib/postgresql/17/data promote

pg_ctl -D /var/lib/postgresql/17/data stop
rm -rf /var/lib/postgresql/17/data/*
pg_basebackup -h NEW_PRIMARY -U repl -D /var/lib/postgresql/17/data -X stream -R -P -C -S oldprimary_slot
pg_ctl -D /var/lib/postgresql/17/data start

-- 创建逻辑槽（如需逻辑复制）
SELECT * FROM pg_create_logical_replication_slot('app_slot', 'pgoutput');

-- 查看复制槽
SELECT slot_name, slot_type, active, restart_lsn FROM pg_replication_slots;

BEGIN READ ONLY;  -- 强制在主库读（通过路由或角色策略）
SELECT ...;
COMMIT;

-- 主库查看复制
SELECT * FROM pg_stat_replication;

-- WAL 生成量
SELECT date_trunc('hour', now()) AS ts,
       pg_wal_lsn_diff(pg_current_wal_lsn(), '0/0')/1024/1024/1024 AS wal_gb;

-- 从库延迟
SELECT now() - pg_last_xact_replay_timestamp() AS standby_delay;

[global]
repo1-path=/var/lib/pgbackrest
repo1-retention-full=7
start-fast=y

[pg]
pg1-path=/var/lib/postgresql/17/data
pg1-port=5432

CREATE PUBLICATION mypub FOR TABLE public.users, public.orders;

CREATE SUBSCRIPTION mysub
  CONNECTION 'host=10.0.0.10 dbname=app user=repl password=REPLACE_WITH_REPL_PASSWORD'
  PUBLICATION mypub;

version: '3.8'
services:
  primary:
    image: postgres:17
    environment:
      POSTGRES_PASSWORD: REPLACE_WITH_SUPERUSER_PASSWORD
    ports:
      - '5432:5432'
    volumes:
      - primary_data:/var/lib/postgresql/data

  standby1:
    image: postgres:17
    depends_on:
      - primary
    environment:
      POSTGRES_PASSWORD: REPLACE_WITH_SUPERUSER_PASSWORD
    command: >
      bash -lc "pg_basebackup -h primary -U postgres -D /var/lib/postgresql/data -R -P && docker-entrypoint.sh postgres"
    volumes:
      - standby1_data:/var/lib/postgresql/data

volumes:
  primary_data: {}
  standby1_data: {}

/bin/sh: 1: lsb_release: command not found
/bin/sh: 1: apt-key: command not found

# 不使用包管理器安装，改为源码编译
RUN cd /tmp && \
    git clone https://github.com/timescale/timescaledb.git && \
    cd timescaledb && \
    git checkout 2.13.0 && \
    ./bootstrap && \
    cd build && \
    make && \
    make install

fatal error: gssapi/gssapi.h: No such file or directory

RUN apt-get update && apt-get install -y \
    build-essential \
    postgresql-server-dev-15 \
    cmake \
    git \
    wget \
    ca-certificates \
    libkrb5-dev \
    libgssapi-krb5-2 \
    && rm -rf /var/lib/apt/lists/*

server closed the connection unexpectedly
This probably means the server terminated abnormally
before or while processing the request.

# 使用 pgvector 0.5.1 版本，避免段错误
RUN cd /tmp && \
    wget https://github.com/pgvector/pgvector/archive/v0.5.1.tar.gz && \
    tar -xzf v0.5.1.tar.gz && \
    cd pgvector-0.5.1 && \
    make && \
    make install

ERROR: could not load library "timescaledb":
shared_preload_libraries not configured

RUN echo "shared_preload_libraries = 'timescaledb'" >> /usr/share/postgresql/postgresql.conf.sample

ERROR: extension "postgis" has no installation candidate

RUN apt-get install -y \
    postgresql-15-postgis-3 \
    postgresql-15-postgis-3-scripts

connection to server at "localhost" (::1), port 5432 failed: Connection refused

docker port postgres-all-extensions
# 应该显示: 5432/tcp -> 0.0.0.0:5432

docker ps
# 检查容器是否正常运行

docker logs postgres-all-extensions
# 查看启动日志，确认数据库已就绪

FATAL: password authentication failed for user "postgres"

docker-compose down
sudo rm -rf ./data/pgdata/*
docker-compose up -d

docker exec postgres-all-extensions env | grep POSTGRES

# 确保 .env 文件在正确位置且格式正确
POSTGRES_PASSWORD=your_password

initdb: error: could not create directory "/var/lib/postgresql/data": Permission denied

# 修改目录权限
sudo chown -R 999:999 ./data/pgdata
# 或者删除目录让 Docker 自动创建
sudo rm -rf ./data/pgdata

# 确保配置文件可读
chmod 644 config/postgresql.conf
chmod 644 config/pg_hba.conf

# 等待更长时间再进行连接测试
sleep 15 && docker exec postgres-all-extensions psql -U postgres -c "SELECT 1;"

# 在 docker-compose.yml 中添加资源限制
deploy:
  resources:
    limits:
      memory: 2G
    reservations:
      memory: 1G

-- 增加共享缓冲区
ALTER SYSTEM SET shared_buffers = '256MB';
-- 调整工作内存
ALTER SYSTEM SET work_mem = '4MB';
-- 重载配置
SELECT pg_reload_conf();

-- 为向量查询创建索引
CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops);
-- 为时序数据创建索引
CREATE INDEX ON sensor_data (time DESC);

volumes:
  - ./data/pgdata:/var/lib/postgresql/data

FATAL: database files are incompatible with server

docker exec postgres-old pg_dumpall -U postgres > backup.sql

sudo rm -rf ./data/pgdata/*

docker-compose up -d
# 等待启动完成后
docker exec -i postgres-all-extensions psql -U postgres < backup.sql

# 查看容器日志
docker logs postgres-all-extensions -f

# 查看 PostgreSQL 日志
docker exec postgres-all-extensions tail -f /var/log/postgresql/postgresql.log

# 进入容器
docker exec -it postgres-all-extensions bash

# 查看进程状态
ps aux | grep postgres

# 检查扩展安装
psql -U postgres -c "\dx"

# 测试端口连通性
telnet localhost 5432

# 使用 Docker 网络测试
docker run --rm --network host postgres:15 pg_isready -h localhost -p 5432

PgSQL/
├── .env                          # 环境变量配置
├── Dockerfile                    # PostgreSQL 镜像构建文件
├── docker-compose.yml            # Docker Compose 配置
├── README.md                     # 项目说明
├── config/                       # 配置文件目录
│   ├── pg_hba.conf              # 客户端认证配置
│   └── postgresql.conf          # PostgreSQL 主配置
├── data/                        # 数据持久化目录
│   └── pgdata/                  # PostgreSQL 数据目录
├── init-scripts/                # 初始化脚本
│   └── 01-install-extensions.sql # 扩展安装脚本
├── logs/                        # 日志目录
└── test-examples.sql            # 测试示例

mkdir -p ~/Server/PgSQL
cd ~/Server/PgSQL

# PostgreSQL 数据库配置
POSTGRES_DB=devdb
POSTGRES_USER=postgres
POSTGRES_PASSWORD=your_secure_password
POSTGRES_PORT=5432

# 注意：请修改 POSTGRES_PASSWORD 为您的实际密码
# 建议使用强密码，包含大小写字母、数字和特殊字符

docker build -t postgres-all-extensions:latest .

docker-compose up -d

# 检查容器状态
docker ps

# 连接数据库验证扩展
docker exec postgres-all-extensions psql -U postgres -d devdb -c "SELECT extname, extversion FROM pg_extension WHERE extname IN ('timescaledb', 'postgis', 'vector') ORDER BY extname;"

FROM postgres:15

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    build-essential \
    postgresql-server-dev-15 \
    cmake \
    git \
    wget \
    ca-certificates \
    postgresql-15-postgis-3 \
    postgresql-15-postgis-3-scripts \
    libkrb5-dev \
    libgssapi-krb5-2 \
    && rm -rf /var/lib/apt/lists/*

# 安装 pgvector (预编译版本，避免段错误)
RUN cd /tmp && \
    wget https://github.com/pgvector/pgvector/archive/v0.5.1.tar.gz && \
    tar -xzf v0.5.1.tar.gz && \
    cd pgvector-0.5.1 && \
    make && \
    make install

# 安装 TimescaleDB (从源码编译)
RUN cd /tmp && \
    git clone https://github.com/timescale/timescaledb.git && \
    cd timescaledb && \
    git checkout 2.13.0 && \
    ./bootstrap && \
    cd build && \
    make && \
    make install

# 配置 PostgreSQL
RUN echo "shared_preload_libraries = 'timescaledb'" >> /usr/share/postgresql/postgresql.conf.sample

# 复制初始化脚本
COPY init-scripts/ /docker-entrypoint-initdb.d/

EXPOSE 5432

version: '3.8'

services:
  postgres-all-extensions:
    image: postgres-all-extensions:latest
    container_name: postgres-all-extensions
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    ports:
      - "5432:5432"
    volumes:
      - ./data/pgdata:/var/lib/postgresql/data
      - ./config/postgresql.conf:/etc/postgresql/postgresql.conf
      - ./config/pg_hba.conf:/etc/postgresql/pg_hba.conf
      - ./logs:/var/log/postgresql
    networks:
      - postgres-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 30s
      timeout: 10s
      retries: 3

networks:
  postgres-network:
    driver: bridge

-- 创建几何数据
SELECT ST_AsText(ST_MakePoint(-71.064544, 42.28787));

-- 空间查询示例
CREATE TABLE locations (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    geom GEOMETRY(POINT, 4326)
);

INSERT INTO locations (name, geom) VALUES
('Boston', ST_SetSRID(ST_MakePoint(-71.0589, 42.3601), 4326));

-- 创建向量表
CREATE TABLE items (
    id SERIAL PRIMARY KEY,
    embedding VECTOR(3)
);

-- 插入向量数据
INSERT INTO items (embedding) VALUES
('[1,2,3]'),
('[4,5,6]');

-- 向量相似度查询
SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

-- 创建时序表
CREATE TABLE sensor_data (
    time TIMESTAMPTZ NOT NULL,
    sensor_id INTEGER,
    temperature DOUBLE PRECISION,
    humidity DOUBLE PRECISION
);

-- 转换为超表
SELECT create_hypertable('sensor_data', 'time');

-- 插入时序数据
INSERT INTO sensor_data VALUES
(NOW(), 1, 23.5, 65.2),
(NOW() - INTERVAL '1 hour', 1, 22.8, 64.1);

Host: localhost
Port: 5432
Database: devdb (或 postgres)
Username: postgres
Password: [您在.env中设置的密码]

# 使用 Docker 容器内的 psql
docker exec -it postgres-all-extensions psql -U postgres -d devdb

# 使用外部 psql (需要安装 PostgreSQL 客户端)
PGPASSWORD=your_password psql -h localhost -p 5432 -U postgres -d devdb

# 启动服务
docker-compose up -d

# 停止服务
docker-compose down

# 重启服务
docker-compose restart

# 查看日志
docker-compose logs -f

# 备份数据库
docker exec postgres-all-extensions pg_dump -U postgres devdb > backup.sql

# 恢复数据库
docker exec -i postgres-all-extensions psql -U postgres devdb < backup.sql

# 查看容器资源使用
docker stats postgres-all-extensions

# 查看数据库连接
docker exec postgres-all-extensions psql -U postgres -c "SELECT * FROM pg_stat_activity;"

# 安装 DrissionPage
pip install DrissionPage

# 安装备选方案（可选）
pip install playwright
pip install selenium

from DrissionPage import ChromiumPage

# 创建页面对象
page = ChromiumPage()

# 访问淘宝
page.get('https://www.taobao.com')

# 搜索商品
search_box = page.ele('#q')
search_box.input('手机')
search_box.after().click()

# 获取商品信息
products = page.eles('.item')
for product in products:
    title = product.ele('.title').text
    price = product.ele('.price').text
    print(f"{title}: {price}")

from DrissionPage import ChromiumPage
from crawler.gateway.proxy_server import ProxyServer

class TaobaoAutomator:
    def __init__(self):
        # 启动代理服务器
        self.proxy_server = ProxyServer()

        # 配置 DrissionPage 使用代理
        self.page = ChromiumPage()
        self.page.set.proxy(f'127.0.0.1:{self.proxy_server.port}')

    def search_products(self, keyword):
        # 实现搜索逻辑
        pass

<property>
  <name>yarn.scheduler.capacity.root.interactive.capacity</name>
  <value>30</value>
</property>
<property>
  <name>yarn.scheduler.capacity.root.batch.capacity</name>
  <value>70</value>
</property>

# 在 Impala 配置文件中添加
--admission_control_slots=16
--admission_control_stale_topic_threshold_ms=30000
--queue_wait_timeout_ms=60000

-- 创建高内存资源池
ALTER RESOURCE POOL high_mem_pool SET MAX_MEM=200GB, MAX_QUERIES=5;

-- 创建标准资源池
ALTER RESOURCE POOL standard_pool SET MAX_MEM=100GB, MAX_QUERIES=10;

-- 创建轻量级资源池
ALTER RESOURCE POOL light_pool SET MAX_MEM=50GB, MAX_QUERIES=20;

-- 在查询中指定资源池
SET REQUEST_POOL=high_mem_pool;
SELECT * FROM large_table WHERE complex_condition;

-- 或者在连接时指定
-- impala-shell -i hostname:21000 --request_pool=standard_pool

-- 设置单查询内存限制
SET MEM_LIMIT=8g;  -- 单查询可用内存上限

-- 设置查询超时
SET QUERY_TIMEOUT_S=3600;  -- 1小时超时

-- 设置批处理大小
SET BATCH_SIZE=1024;

# Impala Daemon → Configuration → Query Options
--default_query_options=MEM_LIMIT=8GB,QUERY_TIMEOUT_S=3600

-- 启用运行时过滤
SET RUNTIME_FILTER_MODE=GLOBAL;

-- 优化 Join 策略
SET DISABLE_CODEGEN=false;
SET NUM_NODES=0;  -- 自动选择节点数

-- 控制并行度
SET NUM_SCANNER_THREADS=4;
SET MT_DOP=4;  -- 多线程并行度

<!-- hive-site.xml -->
<property>
  <name>hive.llap.daemon.memory.per.instance.mb</name>
  <value>16384</value>  <!-- 16GB per LLAP daemon -->
</property>

<property>
  <name>hive.llap.daemon.num.executors</name>
  <value>8</value>  <!-- 每个 daemon 的执行器数量 -->
</property>

<property>
  <name>hive.llap.io.memory.size</name>
  <value>8192</value>  <!-- IO 缓存大小 -->
</property>

<property>
  <name>hive.llap.daemon.vcpus.per.instance</name>
  <value>8</value>  <!-- 每个实例的虚拟CPU数 -->
</property>

<!-- tez-site.xml -->
<property>
  <name>tez.am.resource.memory.mb</name>
  <value>4096</value>  <!-- Application Master 内存 -->
</property>

<property>
  <name>tez.task.resource.memory.mb</name>
  <value>2048</value>  <!-- 单个任务内存 -->
</property>

<property>
  <name>tez.am.container.reuse.enabled</name>
  <value>true</value>  <!-- 启用容器复用 -->
</property>

<property>
  <name>tez.am.container.idle.release-timeout-min.millis</name>
  <value>10000</value>  <!-- 容器空闲释放时间 -->
</property>

<!-- capacity-scheduler.xml -->
<property>
  <name>yarn.scheduler.capacity.root.batch.maximum-applications</name>
  <value>50</value>  <!-- 批处理队列最大应用数 -->
</property>

<property>
  <name>yarn.scheduler.capacity.root.batch.maximum-am-resource-percent</name>
  <value>0.3</value>  <!-- AM 资源占比限制 -->
</property>

<property>
  <name>yarn.scheduler.capacity.root.interactive.user-limit-factor</name>
  <value>2</value>  <!-- 用户资源倍数限制 -->
</property>

-- 启用向量化执行
SET hive.vectorized.execution.enabled=true;
SET hive.vectorized.execution.reduce.enabled=true;

-- 优化 Join 策略
SET hive.auto.convert.join=true;
SET hive.mapjoin.smalltable.filesize=25000000;

-- 启用 CBO（基于成本的优化器）
SET hive.cbo.enable=true;
SET hive.compute.query.using.stats=true;

-- 控制并行度
SET hive.exec.parallel=true;
SET hive.exec.parallel.thread.number=8;

{
  "dashboard": {
    "title": "Impala & Hive Resource Monitor",
    "panels": [
      {
        "title": "Impala Memory Usage",
        "type": "graph",
        "targets": [
          {
            "expr": "impala_daemon_mem_rss / impala_daemon_mem_limit * 100",
            "legendFormat": "Memory Usage %"
          }
        ]
      },
      {
        "title": "YARN Queue Utilization",
        "type": "graph",
        "targets": [
          {
            "expr": "yarn_queue_used_capacity{queue=\"interactive\"}",
            "legendFormat": "Interactive Queue"
          },
          {
            "expr": "yarn_queue_used_capacity{queue=\"batch\"}",
            "legendFormat": "Batch Queue"
          }
        ]
      }
    ]
  }
}

# Prometheus 告警规则
groups:
- name: impala_alerts
  rules:
  - alert: ImpalaHighMemoryUsage
    expr: impala_daemon_mem_rss / impala_daemon_mem_limit > 0.9
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Impala daemon memory usage is high"
      description: "Memory usage is {{ $value }}%"

  - alert: ImpalaQueryQueueHigh
    expr: impala_admission_controller_queue_size > 10
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "Impala query queue is too long"
      description: "Queue size: {{ $value }}"

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Impala 查询性能分析脚本
用于识别和分析耗时/耗内存的查询
"""

import impala.dbapi
import pandas as pd
from datetime import datetime, timedelta

def analyze_slow_queries(host='localhost', port=21000, days=7):
    """
    分析慢查询

    Args:
        host: Impala 主机地址
        port: Impala 端口
        days: 分析最近几天的查询
    """
    conn = impala.dbapi.connect(host=host, port=port)
    cursor = conn.cursor()

    # 查询最近的慢查询
    query = f"""
    SELECT
        query_id,
        user,
        default_db,
        statement,
        start_time,
        end_time,
        duration_ms,
        rows_produced,
        peak_memory_usage
    FROM sys.impala_query_log
    WHERE start_time >= NOW() - INTERVAL {days} DAYS
        AND duration_ms > 60000  -- 超过1分钟的查询
    ORDER BY duration_ms DESC
    LIMIT 50
    """

    cursor.execute(query)
    results = cursor.fetchall()

    # 转换为 DataFrame 进行分析
    df = pd.DataFrame(results, columns=[
        'query_id', 'user', 'default_db', 'statement',
        'start_time', 'end_time', 'duration_ms',
        'rows_produced', 'peak_memory_usage'
    ])

    # 分析结果
    print("=== 慢查询分析报告 ===")
    print(f"分析时间范围: 最近 {days} 天")
    print(f"慢查询总数: {len(df)}")
    print(f"平均执行时间: {df['duration_ms'].mean()/1000:.2f} 秒")
    print(f"最大内存使用: {df['peak_memory_usage'].max()/1024/1024/1024:.2f} GB")

    # 按用户统计
    user_stats = df.groupby('user').agg({
        'query_id': 'count',
        'duration_ms': 'mean',
        'peak_memory_usage': 'max'
    }).round(2)

    print("\n=== 用户查询统计 ===")
    print(user_stats)

    # 识别需要优化的查询
    high_memory_queries = df[df['peak_memory_usage'] > 10*1024*1024*1024]  # 超过10GB
    print(f"\n=== 高内存查询 (>10GB): {len(high_memory_queries)} 条 ===")

    for _, query in high_memory_queries.iterrows():
        print(f"Query ID: {query['query_id']}")
        print(f"User: {query['user']}")
        print(f"Memory: {query['peak_memory_usage']/1024/1024/1024:.2f} GB")
        print(f"Duration: {query['duration_ms']/1000:.2f} seconds")
        print(f"Statement: {query['statement'][:100]}...")
        print("-" * 50)

    conn.close()
    return df

def get_query_profile(query_id, host='localhost', port=21000):
    """
    获取查询的详细执行计划

    Args:
        query_id: 查询ID
        host: Impala 主机地址
        port: Impala 端口
    """
    conn = impala.dbapi.connect(host=host, port=port)
    cursor = conn.cursor()

    cursor.execute(f"PROFILE {query_id}")
    profile = cursor.fetchall()

    print(f"=== Query Profile for {query_id} ===")
    for line in profile:
        print(line[0])

    conn.close()

if __name__ == "__main__":
    # 分析最近7天的慢查询
    df = analyze_slow_queries()

    # 如果有高内存查询，获取详细的执行计划
    if len(df) > 0:
        top_query_id = df.iloc[0]['query_id']
        get_query_profile(top_query_id)

-- 查询优化检查清单

-- 1. 检查表统计信息是否最新
SHOW TABLE STATS your_table;
COMPUTE STATS your_table;

-- 2. 检查分区剪裁是否生效
EXPLAIN SELECT * FROM partitioned_table WHERE partition_col = 'value';

-- 3. 检查列裁剪是否生效
EXPLAIN SELECT col1, col2 FROM large_table WHERE condition;

-- 4. 检查 Join 策略
SET EXPLAIN_LEVEL=2;
EXPLAIN SELECT * FROM table1 t1 JOIN table2 t2 ON t1.id = t2.id;

-- 5. 优化大表 Join
-- 使用 broadcast join 对小表
SET RUNTIME_FILTER_MODE=GLOBAL;
SELECT /*+ BROADCAST(small_table) */
  *
FROM large_table
JOIN small_table ON large_table.id = small_table.id;

-- 6. 使用分区 Join
SELECT *
FROM partitioned_table1 pt1
JOIN partitioned_table2 pt2
  ON pt1.partition_key = pt2.partition_key
  AND pt1.join_key = pt2.join_key
WHERE pt1.partition_key = 'specific_partition';

#!/bin/bash
# 检查 Impala 和 Hive 版本兼容性

echo "=== 组件版本信息 ==="
echo "Impala Version:"
impala-shell --version

echo "\nHive Version:"
hive --version

echo "\nHadoop Version:"
hadoop version

echo "\nYARN Version:"
yarn version

# 检查关键配置
echo "\n=== 关键配置检查 ==="
echo "YARN 调度器类型:"
hadoop conf -get yarn.resourcemanager.scheduler.class

echo "\nImpala Admission Control:"
impala-shell -q "SHOW CONFIG" | grep admission

echo "\nHive LLAP 状态:"
hive --service llap --instances

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
自动检查 Impala/Hive 相关组件的补丁状态
"""

import subprocess
import re
from packaging import version

def check_component_version(component_name, current_version, min_recommended_version):
    """
    检查组件版本是否满足最低推荐版本

    Args:
        component_name: 组件名称
        current_version: 当前版本
        min_recommended_version: 最低推荐版本
    """
    try:
        if version.parse(current_version) >= version.parse(min_recommended_version):
            print(f"✅ {component_name}: {current_version} (推荐版本: {min_recommended_version})")
            return True
        else:
            print(f"⚠️  {component_name}: {current_version} (需要升级到: {min_recommended_version})")
            return False
    except Exception as e:
        print(f"❌ {component_name}: 版本检查失败 - {e}")
        return False

def get_impala_version():
    """获取 Impala 版本"""
    try:
        result = subprocess.run(['impala-shell', '--version'],
                              capture_output=True, text=True)
        version_match = re.search(r'version (\d+\.\d+\.\d+)', result.stdout)
        return version_match.group(1) if version_match else "unknown"
    except:
        return "unknown"

def get_hive_version():
    """获取 Hive 版本"""
    try:
        result = subprocess.run(['hive', '--version'],
                              capture_output=True, text=True)
        version_match = re.search(r'Hive (\d+\.\d+\.\d+)', result.stdout)
        return version_match.group(1) if version_match else "unknown"
    except:
        return "unknown"

def main():
    """主函数"""
    print("=== 组件版本检查 ===")

    # 定义最低推荐版本
    min_versions = {
        'Impala': '3.4.0',
        'Hive': '3.1.2',
        'Hadoop': '3.2.0'
    }

    # 检查各组件版本
    impala_version = get_impala_version()
    hive_version = get_hive_version()

    results = []
    results.append(check_component_version('Impala', impala_version, min_versions['Impala']))
    results.append(check_component_version('Hive', hive_version, min_versions['Hive']))

    # 输出总结
    print("\n=== 检查结果 ===")
    if all(results):
        print("✅ 所有组件版本都满足推荐要求")
    else:
        print("⚠️  部分组件需要升级，请参考官方升级指南")
        print("   - Impala: https://impala.apache.org/docs/build.html")
        print("   - Hive: https://hive.apache.org/downloads.html")

if __name__ == "__main__":
    main()

-- 问题查询示例
SELECT *
FROM large_table1 lt1
JOIN large_table2 lt2 ON lt1.id = lt2.id;

-- 优化方案
-- 1. 添加过滤条件
SELECT *
FROM large_table1 lt1
JOIN large_table2 lt2 ON lt1.id = lt2.id
WHERE lt1.date_col >= '2024-01-01';

-- 2. 使用分区 Join
SELECT *
FROM large_table1 lt1
JOIN large_table2 lt2
  ON lt1.id = lt2.id
  AND lt1.partition_col = lt2.partition_col
WHERE lt1.partition_col = 'specific_partition';

-- 3. 分阶段处理
CREATE TABLE temp_result AS
SELECT lt1.id, lt1.col1, lt2.col2
FROM large_table1 lt1
JOIN (
  SELECT id, col2
  FROM large_table2
  WHERE filter_condition
) lt2 ON lt1.id = lt2.id;

-- 问题查询
SELECT
  high_cardinality_col,
  COUNT(*),
  SUM(large_numeric_col),
  AVG(another_col)
FROM huge_table
GROUP BY high_cardinality_col;

-- 优化方案
-- 1. 增加预聚合
CREATE TABLE pre_aggregated AS
SELECT
  partition_col,
  high_cardinality_col,
  COUNT(*) as cnt,
  SUM(large_numeric_col) as sum_val
FROM huge_table
WHERE date_col >= '2024-01-01'
GROUP BY partition_col, high_cardinality_col;

-- 2. 使用窗口函数替代
SELECT
  high_cardinality_col,
  COUNT(*) OVER (PARTITION BY high_cardinality_col) as cnt
FROM huge_table
WHERE sample_condition;

#!/bin/bash
# Impala OOM 应急处理脚本

echo "=== Impala OOM 应急处理 ==="
echo "时间: $(date)"

# 1. 检查当前运行的查询
echo "\n1. 检查当前运行查询..."
impala-shell -q "SHOW QUERIES" | head -20

# 2. 检查资源使用情况
echo "\n2. 检查资源使用情况..."
echo "内存使用:"
free -h
echo "\nCPU 使用:"
top -bn1 | head -10

# 3. 检查 YARN 队列状态
echo "\n3. 检查 YARN 队列状态..."
yarn queue -status interactive
yarn queue -status batch

# 4. 取消长时间运行的查询
echo "\n4. 检查长时间运行的查询..."
impala-shell -q "
SELECT query_id, user, duration_ms/1000 as duration_sec, statement
FROM sys.impala_query_log
WHERE end_time IS NULL
  AND start_time < NOW() - INTERVAL 10 MINUTES
ORDER BY start_time
" | while read query_id user duration statement; do
    if [ "$duration" -gt 600 ]; then  # 超过10分钟
        echo "发现长时间运行查询: $query_id (用户: $user, 时长: ${duration}秒)"
        echo "语句: ${statement:0:100}..."
        read -p "是否取消此查询? (y/N): " confirm
        if [ "$confirm" = "y" ] || [ "$confirm" = "Y" ]; then
            impala-shell -q "CANCEL '$query_id'"
            echo "已取消查询: $query_id"
        fi
    fi
done

# 5. 临时调整资源限制
echo "\n5. 临时调整资源限制..."
read -p "是否临时降低内存限制? (y/N): " adjust_mem
if [ "$adjust_mem" = "y" ] || [ "$adjust_mem" = "Y" ]; then
    echo "设置临时内存限制为 4GB..."
    impala-shell -q "SET MEM_LIMIT=4GB"
fi

# 6. 重启 Impala 服务（最后手段）
echo "\n6. 服务重启选项..."
read -p "是否需要重启 Impala 服务? (y/N): " restart_service
if [ "$restart_service" = "y" ] || [ "$restart_service" = "Y" ]; then
    echo "重启 Impala 服务..."
    sudo systemctl restart impala-server
    sudo systemctl restart impala-state-store
    sudo systemctl restart impala-catalog
    echo "Impala 服务已重启"
fi

echo "\n=== 应急处理完成 ==="

#!/bin/bash
# Impala 预防性维护脚本

echo "=== Impala 预防性维护 ==="
echo "开始时间: $(date)"

# 1. 更新表统计信息
echo "\n1. 更新表统计信息..."
impala-shell -f - <<EOF
-- 更新所有表的统计信息
SHOW DATABASES;
EOF

# 获取所有数据库和表
impala-shell -q "SHOW DATABASES" --delimited | while read db; do
    if [ "$db" != "_impala_builtins" ]; then
        echo "处理数据库: $db"
        impala-shell -q "USE $db; SHOW TABLES" --delimited | while read table; do
            echo "  更新表统计: $db.$table"
            impala-shell -q "COMPUTE STATS $db.$table" 2>/dev/null || echo "    跳过: $db.$table"
        done
    fi
done

# 2. 清理查询日志
echo "\n2. 清理历史查询日志..."
impala-shell -q "
DELETE FROM sys.impala_query_log
WHERE start_time < NOW() - INTERVAL 30 DAYS
" 2>/dev/null || echo "查询日志清理跳过"

# 3. 检查磁盘空间
echo "\n3. 检查磁盘空间..."
df -h | grep -E '(hdfs|/var|/tmp)'

# 4. 检查服务状态
echo "\n4. 检查服务状态..."
sudo systemctl status impala-server impala-state-store impala-catalog

# 5. 生成维护报告
echo "\n5. 生成维护报告..."
cat > /tmp/impala_maintenance_report_$(date +%Y%m%d).txt <<EOF
Impala 维护报告
生成时间: $(date)

=== 系统资源状态 ===
$(free -h)

=== 磁盘使用情况 ===
$(df -h)

=== 服务状态 ===
$(sudo systemctl status impala-server --no-pager -l)

=== 最近查询统计 ===
$(impala-shell -q "SELECT COUNT(*) as total_queries, AVG(duration_ms)/1000 as avg_duration_sec FROM sys.impala_query_log WHERE start_time >= NOW() - INTERVAL 1 DAY" --delimited)

EOF

echo "维护报告已生成: /tmp/impala_maintenance_report_$(date +%Y%m%d).txt"
echo "\n=== 预防性维护完成 ==="

# 安装Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# 拉取模型
ollama pull llama3.1:8b
ollama pull mistral:7b
ollama pull qwen2.5:32b

# 运行模型
ollama run llama3.1:8b

# API调用示例
curl http://localhost:11434/api/generate \
  -d '{
    "model": "llama3.1:8b",
    "prompt": "为什么天空是蓝色的？",
    "stream": false
  }'

# LM Studio Python SDK示例
from lm_studio import LMStudio

# 初始化客户端
client = LMStudio()

# 列出可用模型
models = client.list_models()
print(f"可用模型: {models}")

# 加载模型
model = client.load_model("mistral-7b-instruct")

# 生成文本
response = model.generate(
    prompt="解释机器学习的基本概念",
    max_tokens=500,
    temperature=0.7
)

print(response.text)

# AnythingLLM使用示例
from anythingllm import AnythingLLM
from anythingllm.models import load_model
from anythingllm.utils import quantize_model

# 加载和量化模型
model = load_model(
    model_path="./models/llama-7b.gguf",
    device="cuda",
    quantization="int4"
)

# 创建AnythingLLM实例
llm = AnythingLLM(
    model=model,
    max_tokens=2048,
    temperature=0.8
)

# RAG集成示例
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings

# 创建向量存储
embeddings = HuggingFaceEmbeddings()
vectorstore = Chroma(
    embedding_function=embeddings,
    persist_directory="./chroma_db"
)

# 检索增强生成
def rag_query(question):
    # 检索相关文档
    docs = vectorstore.similarity_search(question, k=3)
    context = "\n".join([doc.page_content for doc in docs])

    # 生成回答
    prompt = f"基于以下上下文回答问题：\n{context}\n\n问题：{question}"
    response = llm.generate(prompt)

    return response

# 使用RAG系统
answer = rag_query("什么是深度学习？")
print(answer)

# Docker部署Ollama
docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v ollama:/root/.ollama \
  ollama/ollama

# 拉取企业常用模型
docker exec ollama ollama pull llama3.1:8b
docker exec ollama ollama pull qwen2.5:32b
docker exec ollama ollama pull mistral:7b

# 配置负载均衡
# nginx.conf
upstream ollama_backend {
    server 127.0.0.1:11434;
    server 127.0.0.1:11435;
    server 127.0.0.1:11436;
}

server {
    listen 80;
    location /api/ {
        proxy_pass http://ollama_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

# LM Studio团队配置脚本
import json
import os

# 团队模型配置
team_config = {
    "models": [
        {
            "name": "llama3.1-8b-instruct",
            "path": "./models/llama3.1-8b-instruct.gguf",
            "description": "通用对话模型",
            "tags": ["general", "chat"]
        },
        {
            "name": "mistral-7b-code",
            "path": "./models/mistral-7b-code.gguf",
            "description": "代码生成专用",
            "tags": ["code", "programming"]
        }
    ],
    "settings": {
        "max_tokens": 2048,
        "temperature": 0.7,
        "gpu_layers": 32
    }
}

# 保存配置
with open("team_config.json", "w") as f:
    json.dump(team_config, f, indent=2)

print("团队配置已保存")

# AnythingLLM研究环境配置
from anythingllm import AnythingLLM
from anythingllm.experiments import ExperimentTracker
from anythingllm.utils import ModelBenchmark

class ResearchEnvironment:
    def __init__(self):
        self.models = {}
        self.tracker = ExperimentTracker()
        self.benchmark = ModelBenchmark()

    def load_model(self, name, path, config=None):
        """加载研究模型"""
        model = AnythingLLM.load(
            path=path,
            config=config or {}
        )
        self.models[name] = model
        return model

    def run_experiment(self, experiment_name, model_name, test_data):
        """运行实验"""
        model = self.models[model_name]
        results = []

        for data in test_data:
            response = model.generate(data["prompt"])
            result = {
                "input": data["prompt"],
                "output": response,
                "expected": data.get("expected"),
                "metrics": self.benchmark.evaluate(response, data.get("expected"))
            }
            results.append(result)

        # 记录实验结果
        self.tracker.log_experiment(
            name=experiment_name,
            model=model_name,
            results=results
        )

        return results

    def compare_models(self, model_names, test_data):
        """模型对比实验"""
        comparison = {}

        for model_name in model_names:
            results = self.run_experiment(
                f"comparison_{model_name}",
                model_name,
                test_data
            )
            comparison[model_name] = results

        return comparison

# 使用示例
env = ResearchEnvironment()

# 加载多个模型进行对比
env.load_model("llama", "./models/llama-7b.gguf")
env.load_model("mistral", "./models/mistral-7b.gguf")
env.load_model("qwen", "./models/qwen-7b.gguf")

# 运行对比实验
test_data = [
    {"prompt": "解释量子计算的基本原理", "expected": "量子计算利用量子力学原理..."},
    {"prompt": "写一个Python快速排序算法", "expected": "def quicksort(arr)..."}
]

results = env.compare_models(["llama", "mistral", "qwen"], test_data)
print("实验结果:", results)

# 使用transformers库部署Qwen3
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 加载模型
model_name = "Qwen/Qwen3-8B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

# 对话函数
def chat_with_qwen3(message, history=[], thinking_mode=False):
    messages = history + [{"role": "user", "content": message}]

    # 添加思维模式提示
    if thinking_mode:
        system_msg = "请使用思维模式，展示你的推理过程。"
        messages.insert(0, {"role": "system", "content": system_msg})

    # 应用聊天模板
    input_ids = tokenizer.apply_chat_template(
        messages,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to(model.device)

    # 生成回答
    with torch.no_grad():
        outputs = model.generate(
            input_ids,
            max_new_tokens=2000,
            do_sample=True,
            temperature=0.7,
            top_p=0.9,
            pad_token_id=tokenizer.eos_token_id
        )

    response = tokenizer.decode(
        outputs[0][input_ids.shape[-1]:],
        skip_special_tokens=True
    )

    return response

# 使用示例
# 普通模式
response = chat_with_qwen3("请解释深度学习的基本概念")
print("普通模式:", response)

# 思维模式
response = chat_with_qwen3(
    "解决这个数学问题：如果一个数的平方等于它的两倍，这个数是多少？",
    thinking_mode=True
)
print("思维模式:", response)