🚀 OpenClaw 性能优化完全指南

// 动态选择模型
const selectModel = (taskComplexity) => {
  switch(taskComplexity) {
    case 'simple':
      return 'gpt-3.5-turbo';
    case 'medium':
      return 'gpt-4-turbo';
    case 'complex':
      return 'gpt-4o';
    default:
      return 'gpt-4-turbo';
  }
};

# 安装 Ollama（本地模型运行器）
curl -fsSL https://ollama.com/install.sh | sh

# 下载模型
ollama pull llama3.2:3b

# 在 OpenClaw 中配置
openclaw config set model.local.endpoint http://localhost:11434
openclaw config set model.local.model llama3.2:3b

const { Skill } = require('@openclaw/core');
const { LRUCache } = require('lru-cache');

class CachedSkill extends Skill {
  constructor() {
    super();
    this.cache = new LRUCache({
      max: 100,
      ttl: 1000 * 60 * 5 // 5分钟
    });
  }

  async execute(options) {
    const cacheKey = JSON.stringify(options);
    
    // 检查缓存
    if (this.cache.has(cacheKey)) {
      this.logger.info('从缓存返回结果');
      return this.cache.get(cacheKey);
    }
    
    // 执行计算
    const result = await this.compute(options);
    
    // 存入缓存
    this.cache.set(cacheKey, result);
    
    return result;
  }
}

const { SemanticCache } = require('@openclaw/cache');

class SmartSkill extends Skill {
  async init() {
    this.semCache = new SemanticCache({
      similarityThreshold: 0.95,
      maxEntries: 1000
    });
  }

  async execute(options) {
    const cached = await this.semCache.find(options.input);
    if (cached) {
      return cached;
    }
    
    const result = await this.process(options);
    await this.semCache.add(options.input, result);
    
    return result;
  }
}

class BatchProcessor {
  async processBatch(items, batchSize = 10) {
    const results = [];
    
    for (let i = 0; i < items.length; i += batchSize) {
      const batch = items.slice(i, i + batchSize);
      const batchResults = await Promise.all(
        batch.map(item => this.processItem(item))
      );
      results.push(...batchResults);
    }
    
    return results;
  }
}

const { pLimit } = require('p-limit');

class ConcurrentProcessor {
  async processWithConcurrency(items, concurrency = 5) {
    const limit = pLimit(concurrency);
    
    const tasks = items.map(item =>
      limit(() => this.processItem(item))
    );
    
    return await Promise.all(tasks);
  }
}

// 优化前
const prompt1 = `
请你帮我分析一下这段文本的情感。
我会提供一段文本，然后你需要判断它是正面、负面还是中性。
请仔细分析，然后给出你的判断。
谢谢！
`;

// 优化后
const prompt2 = `分析情感: {text}\n输出: 正面/负面/中性`;

// Token 减少: ~100 → ~20 (减少80%)

class ContextManager {
  constructor(maxTokens = 4096) {
    this.maxTokens = maxTokens;
    this.messages = [];
  }

  addMessage(message) {
    this.messages.push(message);
    this.trimIfNeeded();
  }

  trimIfNeeded() {
    const totalTokens = this.countTokens(this.messages);
    
    while (totalTokens > this.maxTokens && this.messages.length > 1) {
      // 删除最旧的消息（保留系统消息）
      if (this.messages[1].role !== 'system') {
        this.messages.shift();
      }
    }
  }
}

const { Skill } = require('@openclaw/core');

class MonitoredSkill extends Skill {
  async init() {
    this.metrics = {
      requests: 0,
      totalTime: 0,
      totalTokens: 0,
      errors: 0
    };
  }

  async execute(options) {
    const startTime = Date.now();
    
    try {
      const result = await super.execute(options);
      
      // 记录指标
      this.metrics.requests++;
      this.metrics.totalTime += Date.now() - startTime;
      this.metrics.totalTokens += result.tokens || 0;
      
      return result;
    } catch (error) {
      this.metrics.errors++;
      throw error;
    }
  }

  getStats() {
    return {
      avgResponseTime: this.metrics.totalTime / this.metrics.requests,
      avgTokensPerRequest: this.metrics.totalTokens / this.metrics.requests,
      errorRate: this.metrics.errors / this.metrics.requests
    };
  }
}