OpenClaw 配置 Matrix 完整教程：从技术选型到多 Agent 协作实战

Matrix:        5×3 + 5×3 + 5×2 + 4×2 + 5×2 + 4×2 + 4×3 + 4×1 + 3×2 + 3×2 + 5×3 = 127
Slack:         2×3 + 0×3 + 3×2 + 5×2 + 4×2 + 5×2 + 5×3 + 5×1 + 5×2 + 5×2 + 2×3 = 89
Discord:       2×3 + 0×3 + 2×2 + 5×2 + 4×2 + 5×2 + 4×3 + 5×1 + 5×2 + 5×2 + 1×3 = 86
WebSocket 自研：5×3 + 5×3 + 4×2 + 3×2 + 3×2 + 2×2 + 2×3 + 1×1 + 2×2 + 2×2 + 5×3 = 78

┌─────────────────────────────────────────────────────────────────┐
│                    访问层 Access Layer                          │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
│  │ Element  │  │ Desktop  │  │  Mobile  │  │   API    │       │
│  │   Web    │  │ Client   │  │  Client  │  │  Client  │       │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘       │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│                    代理层 Proxy Layer                           │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │              Nginx 反向代理 + SSL/TLS 终止                │  │
│  │                   负载均衡 + 安全防护                     │  │
│  └──────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│                   服务层 Service Layer                          │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │    Matrix    │  │  OpenClaw    │  │   Message    │         │
│  │   Conduit    │  │   Gateway    │  │   Router     │         │
│  └──────────────┘  └──────────────┘  └──────────────┘         │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│                  执行层 Execution Layer                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │    Agent     │  │    Tool      │  │   Memory     │         │
│  │    Core      │  │  Executor    │  │  Manager     │         │
│  └──────────────┘  └──────────────┘  └──────────────┘         │
│  ┌──────────────┐                                             │
│  │    Skill     │                                             │
│  │   Loader     │                                             │
│  └──────────────┘                                             │
└─────────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────────┐
│                   存储层 Storage Layer                          │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │  SQLite/     │  │    Redis     │  │   文件系统   │         │
│  │ PostgreSQL   │  │    缓存      │  │   日志配置   │         │
│  └──────────────┘  └──────────────┘  └──────────────┘         │
│  ┌──────────────┐                                             │
│  │   向量数据   │                                             │
│  │    库        │                                             │
│  └──────────────┘                                             │
└─────────────────────────────────────────────────────────────────┘

{
  "default_server_config": {
    "m.homeserver": {
      "base_url": "https://matrix.jzhix.com",
      "server_name": "jzhix.com"
    }
  }
}

server {
    listen 443 ssl http2;
    server_name matrix.jzhix.com;

    ssl_certificate /etc/letsencrypt/live/jzhix.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/jzhix.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:6167;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    location /openclaw/ {
        proxy_pass http://127.0.0.1:8080;
    }
}

[global]
name = "jzhix.com"
url = "https://matrix.jzhix.com"
address = "0.0.0.0"
port = 6167

[database]
engine = "sqlite"
path = "/var/lib/conduit/db"

[webhook]
enabled = true
url = "http://127.0.0.1:8080/api/v1/matrix/webhook"
secret = "your_webhook_secret"

name: 戴蒙
role: 技术助手
model: aliyun/qwen3.5-plus
skills:
  - coding-agent
  - tech-research-sop
  - memory-update-sop
memory:
  type: cognitive
  stores: [episodic, semantic]

用户 (Element)              Nginx              Conduit              Router              OpenClaw              Agent Core              Memory              LLM
    │                        │                    │                     │                     │                      │                    │                   │
    │ 发送消息 @damon 你好    │                    │                     │                     │                      │                    │                   │
    │───────────────────────>│                    │                     │                     │                      │                    │                   │
    │                        │ 转发请求           │                     │                     │                      │                    │                   │
    │                        │───────────────────>│                     │                     │                      │                    │                   │
    │                        │                    │ 存储消息            │                     │                      │                    │                   │
    │                        │                    │ 触发 Webhook        │                     │                      │                    │                   │
    │                        │                    │────────────────────>│                     │                      │                    │                   │
    │                        │                    │                     │ 解析消息            │                      │                    │                   │
    │                        │                    │                     │ 识别@提及           │                      │                    │                   │
    │                        │                    │                     │────────────────────>│                      │                    │                   │
    │                        │                    │                     │                     │ 查询用户上下文     │                    │                   │
    │                        │                    │                     │                     │─────────────────────>│                    │                   │
    │                        │                    │                     │                     │<─────────────────────│                    │                   │
    │                        │                    │                     │                     │ 调用 LLM            │                    │                   │
    │                        │                    │                     │                     │────────────────────────────────────────────>│                   │
    │                        │                    │                     │                     │                      │ 生成响应           │                   │
    │                        │                    │                     │                     │<────────────────────────────────────────────│                   │
    │                        │                    │                     │                     │ 返回响应文本        │                    │                   │
    │                        │                    │                     │<────────────────────│                      │                    │                   │
    │                        │                    │<────────────────────│                     │                      │                    │                   │
    │                        │<───────────────────│                     │                     │                      │                    │                   │
    │<───────────────────────│                    │                     │                     │                      │                    │                   │
    │ 显示 Agent 响应          │                    │                     │                     │                      │                    │                   │

@damon 帮我查一下 React 19 的新特性

{
  "type": "m.room.message",
  "content": {
    "msgtype": "m.text",
    "body": "@damon 帮我查一下 React 19 的新特性",
    "m.mentions": {
      "user_ids": ["@damon:jzhix.com"]
    }
  },
  "room_id": "!abc123:jzhix.com",
  "sender": "@jiangshen:jzhix.com",
  "origin_server_ts": 1709539200000
}

[webhook]
enabled = true
url = "http://127.0.0.1:8080/api/v1/matrix/webhook"
secret = "your_webhook_secret"
events = ["m.room.message"]

import re

class MessageRouter:
    def parse_message(self, event: dict) -> dict:
        content = event['content']
        body = content.get('body', '')

        # 提取@提及
        mentions = re.findall(r'@(\w+):(\S+)', body)

        # 识别目标 Agent
        target_agents = []
        for username, server in mentions:
            if username in self.config['agents']:
                target_agents.append(username)

        # 清理消息文本
        clean_text = re.sub(r'@\w+:\S+', '', body).strip()

        return {
            'room_id': event['room_id'],
            'sender': event['sender'],
            'text': clean_text,
            'target_agents': target_agents
        }

class MemoryManager:
    def get_context(self, user_id: str, room_id: str, limit: int = 10) -> list:
        query = """
            SELECT sender, body, timestamp 
            FROM messages 
            WHERE room_id = ? AND sender IN (?, ?)
            ORDER BY timestamp DESC 
            LIMIT ?
        """
        cursor = self.db.execute(query, (room_id, user_id, self.bot_user_id, limit))
        messages = cursor.fetchall()

        context = []
        for msg in reversed(messages):
            role = "user" if msg[0] == user_id else "assistant"
            context.append({"role": role, "content": msg[1]})

        return context

class AgentCore:
    async def process(self, message: dict) -> str:
        # 构建上下文
        context = self.memory.get_context(message['sender'], message['room_id'])
        messages = context + [{"role": "user", "content": message['text']}]

        # 调用 LLM
        response = await self.call_llm(messages)

        # 检查是否需要调用工具
        if self.needs_tool_call(response):
            tool_result = await self.execute_tool(response)
            response = await self.call_llm(messages + [{"role": "assistant", "content": tool_result}])

        return response

class MatrixClient:
    async def send_message(self, room_id: str, text: str):
        url = f"{self.homeserver}/_matrix/client/r0/rooms/{room_id}/send/m.room.message"
        payload = {"msgtype": "m.text", "body": text}
        headers = {"Authorization": f"Bearer {self.token}"}

        async with self.session.post(url, json=payload, headers=headers) as resp:
            return await resp.json()

routing:
  mention:
    enabled: true
    pattern: "@(\\w+)"

  keyword:
    enabled: true
    rules:
      - keywords: ["代码", "编程", "debug"]
        agent: coding-assistant
      - keywords: ["搜索", "调研", "查资料"]
        agent: research-assistant

  context:
    enabled: true
    lookback: 5

  broadcast:
    enabled: true
    trigger: "@all"

                    ┌─────────────────┐
                    │   中心 Agent    │
                    │  Coordinator    │
                    └────────┬────────┘
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
        ▼                    ▼                    ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│   编码 Agent   │   │   调研 Agent   │   │   文档 Agent   │
│   Coding      │   │   Research    │   │   Documentation│
└───────────────┘   └───────────────┘   └───────────────┘

mode: star
coordinator:
  name: 戴蒙
  role: coordinator
  model: aliyun/qwen3-max-thinking

workers:
  - name: 代码助手
    role: coding
    model: qwen3-coder-plus
    skills: [coding-agent, git-suite]

  - name: 调研助手
    role: research
    model: aliyun/qwen3.5-plus
    skills: [tech-research-sop, web_search]

  - name: 文档助手
    role: documentation
    model: aliyun/qwen3.5-plus
    skills: [humanize-ai-text, markdown-converter]

用户需求 → [需求分析] → [技术调研] → [方案设计] → [代码实现] → [测试验证] → [文档编写] → 最终交付
            Agent A      Agent B      Agent C      Agent D      Agent E      Agent F

mode: pipeline
stages:
  - name: 需求分析
    agent: analyst
    input: user_request
    output: requirements_doc
    timeout: 300

  - name: 技术调研
    agent: researcher
    input: requirements_doc
    output: research_report
    timeout: 600

  - name: 代码实现
    agent: developer
    input: research_report
    output: source_code
    timeout: 1800

  - name: 测试验证
    agent: tester
    input: source_code
    output: test_report
    timeout: 900

                    用户消息
                       │
                       ▼
                  ┌─────────┐
                  │ 路由器  │
                  └────┬────┘
                       │
         ┌─────────────┼─────────────┐
         │             │             │
         ▼             ▼             ▼
    ┌────────┐   ┌────────┐   ┌────────┐
    │Agent A │   │Agent B │   │Agent C │
    └───┬────┘   └───┬────┘   └───┬────┘
        │            │            │
        └────────────┼────────────┘
                     │
                     ▼
               ┌──────────┐
               │ 结果汇总 │
               └────┬─────┘
                    │
                    ▼
               返回用户

mode: broadcast
channel: "!broadcast:jzhix.com"
subscribers:
  - agent: coding-assistant
    topics: ["代码", "编程", "debug"]

  - agent: research-assistant
    topics: ["调研", "搜索", "对比"]

  - agent: architecture-assistant
    topics: ["架构", "设计", "选型"]

merger:
  strategy: ranked_merge
  max_results: 5
  timeout: 30

                    用户任务
                       │
                       ▼
                  ┌──────────┐
                  │ 分类器   │
                  └────┬─────┘
                       │
        ┌──────────────┼──────────────┐
        │              │              │
        ▼              ▼              ▼
   ┌────────┐    ┌────────┐    ┌────────┐
   │星型模式 │    │流水线  │    │广播模式│
   │复杂项目 │    │标准流程│    │开放问题│
   └───┬────┘    └───┬────┘    └───┬────┘
       │             │             │
       └─────────────┼─────────────┘
                     │
                     ▼
               结果返回

mode: hybrid
classifier:
  model: aliyun/qwen3.5-plus
  rules:
    - condition: "contains_keyword(['项目', '系统']) AND length > 100"
      mode: star
      reason: "复杂项目，需要多 Agent 协作"

    - condition: "contains_keyword(['教程', '文章'])"
      mode: pipeline
      reason: "标准化内容创作流程"

    - condition: "contains_keyword(['怎么选', '对比'])"
      mode: broadcast
      reason: "开放问题，需要多视角"

    - condition: "length < 50"
      mode: direct
      reason: "简单任务，直接执行"

mkdir -p /opt/openclaw/{conduit,openclaw,nginx,certs}
cd /opt/openclaw
mkdir -p conduit/config openclaw/config nginx/conf.d

cat > conduit/config/conduit.toml << 'EOF'
[global]
name = "jzhix.com"
url = "https://matrix.jzhix.com"
address = "0.0.0.0"
port = 6167
max_request_size = 20000000

[database]
engine = "sqlite"
path = "/var/lib/conduit/db"

[webhook]
enabled = true
url = "http://openclaw:8080/api/v1/matrix/webhook"
secret = "your_webhook_secret_change_this"
events = ["m.room.message"]
EOF

cat > openclaw/config/config.yaml << 'EOF'
server:
  host: 0.0.0.0
  port: 8080

matrix:
  homeserver: "https://matrix.jzhix.com"
  webhook_secret: "your_webhook_secret_change_this"
  bot_user_id: "@damon:jzhix.com"
  access_token: "CHANGE_THIS_LATER"

agents:
  - name: 戴蒙
    id: damon
    model: aliyun/qwen3.5-plus
    skills:
      - coding-agent
      - tech-research-sop
      - memory-update-sop

logging:
  level: info
  file: /var/log/openclaw/openclaw.log
EOF

cat > nginx/conf.d/matrix.conf << 'EOF'
server {
    listen 80;
    server_name matrix.jzhix.com;

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 301 https://$server_name$request_uri;
    }
}

server {
    listen 443 ssl http2;
    server_name matrix.jzhix.com;

    ssl_certificate /etc/letsencrypt/live/jzhix.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/jzhix.com/privkey.pem;

    location / {
        proxy_pass http://conduit:6167;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    location /openclaw/ {
        proxy_pass http://openclaw:8080;
    }
}
EOF

version: '3.8'

services:
  conduit:
    image: matrixconduit/conduit:latest
    container_name: conduit
    restart: unless-stopped
    volumes:
      - ./conduit/config:/etc/conduit
      - conduit_data:/var/lib/conduit
    networks:
      - openclaw_net

  openclaw:
    image: openclaw/openclaw:latest
    container_name: openclaw
    restart: unless-stopped
    volumes:
      - ./openclaw/config:/root/.openclaw/config
      - openclaw_data:/root/.openclaw/workspace
    environment:
      - SILICONFLOW_API_KEY=${SILICONFLOW_API_KEY}
      - ARK_API_KEY=${ARK_API_KEY}
    depends_on:
      - conduit
    networks:
      - openclaw_net

  nginx:
    image: nginx:alpine
    container_name: nginx
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./certs:/etc/letsencrypt
      - ./www:/var/www/certbot
    depends_on:
      - conduit
      - openclaw
    networks:
      - openclaw_net

volumes:
  conduit_data:
  openclaw_data:

networks:
  openclaw_net:
    driver: bridge

mkdir -p /opt/openclaw/certs /opt/openclaw/www/certbot

docker run --rm \
  -v /opt/openclaw/certs:/etc/letsencrypt \
  -v /opt/openclaw/www:/var/www/certbot \
  certbot/certbot \
  certonly --webroot \
  --webroot-path=/var/www/certbot \
  --email your@email.com \
  --domain matrix.jzhix.com \
  --agree-tos

cd /opt/openclaw
export SILICONFLOW_API_KEY="your_api_key_here"
export ARK_API_KEY="your_ark_api_key_here"

docker compose up -d
docker compose logs -f

# 检查服务状态
docker compose ps

# 测试 Conduit
curl https://matrix.jzhix.com/_matrix/client/versions

# 测试 OpenClaw
curl http://localhost:8080/api/v1/health

#!/bin/bash
# diagnose.sh

echo "=== OpenClaw Matrix 诊断工具 ==="

echo "1. 检查 Docker 服务..."
docker compose ps

echo "2. 检查 Conduit..."
curl -s https://matrix.jzhix.com/_matrix/client/versions | head -c 100

echo "3. 检查 OpenClaw..."
curl -s http://localhost:8080/api/v1/health

echo "4. 检查 SSL 证书..."
echo | openssl s_client -connect matrix.jzhix.com:443 2>/dev/null | openssl x509 -noout -dates

echo "5. 检查磁盘空间..."
df -h /opt/openclaw

echo "6. 检查内存使用..."
docker stats --no-stream --format "table {{.Container}}\t{{.MemUsage}}"

echo "=== 诊断完成 ==="

scenario: private_chat
trigger:
  type: direct_message
  from: "@jiangshen:jzhix.com"

response:
  mode: immediate
  context_length: 10
  model: aliyun/qwen3.5-plus

Python 实现单例模式有几种常见方法：

1. 使用装饰器：
```python
def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

class SingletonMeta(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

---

### 场景 2：群聊多 Agent 协作

**需求**：在群聊中，多个 Agent 协作完成复杂任务

**配置**：
```yaml
scenario: group_collaboration
room_id: "!project-team:jzhix.com"
mode: star

coordinator:
  name: 戴蒙
  id: damon

workers:
  - name: 代码助手
    trigger: ["代码", "实现", "写个"]

  - name: 调研助手
    trigger: ["查一下", "调研", "对比"]

  - name: 文档助手
    trigger: ["文档", "说明", "注释"]

scenario: scheduled_tasks
tasks:
  - name: morning_briefing
    cron: "0 8 * * *"
    action: send_message
    target: "!team:jzhix.com"
    content: |
      大家早！今天是 {{date}}

      📅 今日日程：{{calendar_events}}
      🌤️ 天气：{{weather}}
      📰 技术新闻：{{tech_news}}

  - name: backup_database
    cron: "0 2 * * *"
    action: exec_command
    command: "pg_dump openclaw > /backup/db_{{date}}.sql"

  - name: cleanup_logs
    cron: "0 3 * * 0"
    action: exec_command
    command: "find /var/log -name '*.log' -mtime +30 -delete"

# 手动触发测试
curl -X POST http://localhost:8080/api/v1/tasks/morning_briefing/trigger

# 查看状态
curl http://localhost:8080/api/v1/tasks/status

scenario: novel_writing
mode: pipeline

stages:
  - name: 大纲设计
    agent: outline-agent
    prompt: |
      根据主题"{{theme}}"，设计小说大纲：
      1. 世界观设定
      2. 主要角色
      3. 剧情主线
      4. 分卷规划

  - name: 章节创作
    agent: writer-agent
    prompt: |
      根据大纲，创作第{{chapter}}章：
      - 字数：3000-5000 字
      - 风格：{{style}}

  - name: 润色优化
    agent: editor-agent
    prompt: |
      润色以下文本：
      1. 消除 AI 味道
      2. 增强画面感
      3. 优化对话节奏

  - name: 封面生成
    agent: artist-agent
    prompt: |
      生成章节封面图：
      - 风格：手绘风
      - 元素：{{key_elements}}
      - 尺寸：1920x1080

# 创建新书
curl -X POST http://localhost:8080/api/v1/novel/create \
  -d '{"title": "AI 纪元", "theme": "赛博朋克"}'

# 创作第一章
curl -X POST http://localhost:8080/api/v1/novel/chapter/1/generate

# 查看进度
curl http://localhost:8080/api/v1/novel/status

scenario: health_monitor
checks:
  - name: conduit_health
    type: http
    url: "https://matrix.jzhix.com/_matrix/client/versions"
    interval: 60
    timeout: 10
    expected_status: 200

  - name: openclaw_health
    type: http
    url: "http://localhost:8080/api/v1/health"
    interval: 60
    timeout: 10
    expected_status: 200

  - name: disk_usage
    type: command
    command: "df / | tail -1 | awk '{print $5}' | sed 's/%//'"
    interval: 300
    threshold: 90

  - name: memory_usage
    type: command
    command: "free | grep Mem | awk '{print int($3/$2*100)}'"
    interval: 300
    threshold: 90

alerts:
  channel: "!ops-alerts:jzhix.com"
  mention: ["@ops:jzhix.com"]

🚨 严重告警

服务：Conduit
状态：❌ 不可用
时间：2026-03-04 10:26:15
错误：HTTP 503 Service Unavailable

@ops 请立即处理！

/opt/openclaw/
├── config/
│   ├── base.yaml          # 基础配置
│   ├── production.yaml    # 生产环境
│   ├── staging.yaml       # 测试环境
│   └── development.yaml   # 开发环境
├── secrets/
│   ├── api_keys.yaml      # API 密钥（加密存储）
│   └── certificates/      # SSL 证书
└── logs/
    ├── openclaw/
    └── conduit/

ufw default deny incoming
ufw allow 22/tcp      # SSH
ufw allow 80/tcp      # HTTP
ufw allow 443/tcp     # HTTPS
ufw enable

# /etc/ssh/sshd_config
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
MaxAuthTries 3

[security]
allow_registration = false
captcha_enabled = true
recaptcha_secret = "your_secret"

[federation]
allow = ["*"]
deny = ["spam-server.com"]

export SILICONFLOW_API_KEY="sk-..."
export ARK_API_KEY="..."

[performance]
cache_size = 1024
max_connections = 100
thread_pool_size = 8

[database]
prune_interval = 3600
retention_days = 90

worker_processes auto;
worker_rlimit_nofile 65535;

events {
    worker_connections 4096;
    use epoll;
    multi_accept on;
}

http {
    gzip on;
    gzip_types text/plain application/json;
    keepalive_timeout 65;
}

performance:
  worker_threads: 4
  max_concurrent_requests: 20
  request_timeout: 30
  cache:
    enabled: true
    type: redis
    ttl: 3600

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana:latest
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=your_password

  node_exporter:
    image: prom/node-exporter:latest
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro

groups:
  - name: openclaw_alerts
    rules:
      - alert: ConduitDown
        expr: up{job="conduit"} == 0
        for: 1m
        annotations:
          summary: "Conduit 服务不可用"

      - alert: HighMemoryUsage
        expr: node_memory_MemUsed_bytes / node_memory_MemTotal_bytes > 0.9
        for: 5m
        annotations:
          summary: "内存使用超过 90%"

services:
  conduit1:
    image: matrixconduit/conduit:latest
    volumes:
      - conduit_data1:/var/lib/conduit

  conduit2:
    image: matrixconduit/conduit:latest
    volumes:
      - conduit_data2:/var/lib/conduit

  nginx:
    image: nginx:alpine
    volumes:
      - ./nginx/haproxy.conf:/etc/nginx/nginx.conf

upstream conduit_backend {
    server conduit1:6167 weight=1;
    server conduit2:6167 weight=1;
}

server {
    location / {
        proxy_pass http://conduit_backend;
    }
}

#!/bin/bash
# backup.sh

BACKUP_DIR="/backup/openclaw"
DATE=$(date +%Y%m%d_%H%M%S)

# 备份 Conduit 数据
docker cp conduit:/var/lib/conduit $BACKUP_DIR/conduit_$DATE

# 备份 OpenClaw 配置
docker cp openclaw:/root/.openclaw/config $BACKUP_DIR/openclaw_config_$DATE

# 备份到远程
rsync -avz $BACKUP_DIR/conduit_$DATE backup@remote:/backups/

# 清理 30 天前的备份
find $BACKUP_DIR -mtime +30 -delete

docker compose ps
# conduit    Exited (1)

# 1. 查看日志
docker compose logs conduit

# 2. 检查端口占用
netstat -tlnp | grep 6167

# 3. 检查配置文件
cat conduit/config/conduit.toml

# 4. 修复权限
chown -R 1000:1000 conduit/data

# 1. 检查 Nginx 状态
docker compose ps nginx

# 2. 查看 Nginx 日志
docker compose logs nginx

# 3. 测试 HTTPS
curl -v https://matrix.jzhix.com/_matrix/client/versions

# 4. 检查 SSL 证书
echo | openssl s_client -connect matrix.jzhix.com:443 | openssl x509 -noout -dates

# 5. 检查 DNS 解析
dig matrix.jzhix.com

# 1. 检查 Webhook 配置
cat conduit/config/conduit.toml | grep webhook

# 2. 测试 Webhook 连通性
curl -X POST http://openclaw:8080/api/v1/matrix/webhook \
  -H "Content-Type: application/json" \
  -d '{"test": true}'

# 3. 查看 OpenClaw 日志
docker compose logs openclaw | grep webhook

# 4. 检查 Access Token
docker compose exec openclaw cat /root/.openclaw/config/config.yaml | grep access_token

# 1. 检查 LLM API 延迟
curl -w "@curl-format.txt" -o /dev/null -s \
  -X POST https://api.siliconflow.cn/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"model": "qwen3.5-plus", "messages": [{"role": "user", "content": "test"}]}'

# 2. 检查系统资源
docker stats --no-stream

# 3. 查看 Agent 日志
docker compose logs openclaw | grep "processing time"

# 4. 检查网络延迟
ping api.siliconflow.cn

# 1. 检查路由配置
cat /root/.openclaw/config/routing.yaml

# 2. 启用调试日志
export LOG_LEVEL=debug
docker compose restart openclaw

# 3. 查看路由日志
docker compose logs openclaw | grep "routing"

# 4. 测试路由规则
curl -X POST http://localhost:8080/api/v1/router/test \
  -d '{"text": "@damon 帮我查一下 React"}'

# 1. 监控内存使用
watch -n 1 'docker stats --no-stream'

# 2. 检查内存泄漏
docker compose exec openclaw py-spy dump --pid 1

# 3. 查看 GC 日志
docker compose logs openclaw | grep "garbage collection"

# 4. 检查缓存大小
docker compose exec openclaw redis-cli INFO memory

# 限制容器内存
services:
  openclaw:
    deploy:
      resources:
        limits:
          memory: 2G

# 定期重启服务
# 每天凌晨 3 点
docker compose restart openclaw

# 1. 停止服务
docker compose stop conduit

# 2. 检查数据库
sqlite3 /opt/openclaw/conduit/data/conduit.db "PRAGMA integrity_check;"

# 3. 查看错误日志
docker compose logs conduit | grep "database"

# 从备份恢复
cp /backup/conduit/conduit.db /opt/openclaw/conduit/data/

# 或重建数据库
rm /opt/openclaw/conduit/data/conduit.db
docker compose start conduit

# 1. 检查证书有效期
echo | openssl s_client -connect matrix.jzhix.com:443 | openssl x509 -noout -dates

# 2. 手动续期
docker run --rm \
  -v /opt/openclaw/certs:/etc/letsencrypt \
  -v /opt/openclaw/www:/var/www/certbot \
  certbot/certbot renew

# 3. 查看 Certbot 日志
docker compose logs certbot

# 添加定时任务
crontab -e
# 0 0 1 * * docker run --rm -v ... certbot renew

# 重启 Nginx 加载新证书
docker compose restart nginx

# 1. 检查联邦配置
cat conduit/config/conduit.toml | grep federation

# 2. 测试联邦连接
curl https://matrix.jzhix.com/_matrix/federation/v1/version/1

# 3. 检查 DNS SRV 记录
dig _matrix._tcp.jzhix.com SRV

# 4. 查看联邦日志
docker compose logs conduit | grep "federation"

# 开放 8448 端口（联邦通信）
ufw allow 8448/tcp

# 添加 DNS SRV 记录
_matrix._tcp.jzhix.com. 300 IN SRV 10 10 443 matrix.jzhix.com.

# 1. 检查技能目录
ls -la /root/.openclaw/skills/

# 2. 查看技能配置
cat /root/.openclaw/config/agents/damon.yaml | grep skills

# 3. 测试技能加载
docker compose exec openclaw \
  python3 -c "from openclaw.skills import load; load('coding-agent')"

# 4. 查看加载日志
docker compose logs openclaw | grep "skill"

# 技能文件缺失：重新克隆
git clone https://github.com/openclaw/skills.git /root/.openclaw/skills

# 权限问题
chown -R 1000:1000 /root/.openclaw/skills

# 依赖缺失
docker compose exec openclaw pip install -r requirements.txt