🧠 Context Engineering 高级教程

🎬 开篇：Token的战争

凌晨3点27分，我盯着Agent的输出——前三段话在重复自己之前说的话。

不是Agent变笨了。是它的上下文被"我没有告诉过你"的信息塞满了。就像一个人面前堆了100本书，你问他"我的钥匙在哪"，他得先从书堆里爬出来。

Context Engineering——管好Agent能"看到"的东西，让每一分Token都花在刀刃上。

📖 什么是 Context Engineering？

Context Engineering 是有策略地管理Agent的上下文窗口，确保Agent始终有足够且相关的信息来做出好的决策。核心问题就一个：

"给Agent看什么，才能让它做出最好的回答？"

Token预算管理

// 假设你的上下文窗口是128K tokens
const CONTEXT_BUDGET = {
  systemPrompt:   { limit: 2000,   current: 0 },
  conversation:   { limit: 80000,  current: 0 },
  tools:          { limit: 10000,  current: 0 },
  memory:         { limit: 15000,  current: 0 },
  currentTask:    { limit: 21000,  current: 0 },
  // 总预算：128K
};

// Token计数（近似）
function countTokens(text) {
  // 中文约1.5 tokens/字，英文约0.75 tokens/字
  // 用tiktoken或简单估算
  return Math.ceil(text.length * 0.75);
}

// 预算检查
function withinBudget(section, text) {
  const tokens = countTokens(text);
  if (tokens > CONTEXT_BUDGET[section].limit) {
    console.warn(`${section} 超过预算: ${tokens}/${CONTEXT_BUDGET[section].limit}`);
    return false;
  }
  return true;
}

📐 三层记忆架构

不要把所有信息塞进上下文，使用分层记忆：

// memory-manager.js
class MemoryManager {
  constructor() {
    this.shortTerm = [];  // 当前会话（~5k tokens）
    this.mediumTerm = []; // 近期重要信息（~20k tokens）
    this.longTerm = new Map(); // 知识库（索引式存储）
  }

  async add(entry) {
    // 1. 短期记忆优先
    this.shortTerm.push(entry);
    this.shortTerm = await this.summarizeToFit(
      this.shortTerm, 
      { maxTokens: 5000 }
    );
    
    // 2. 重要的移入中期记忆
    if (entry.importance > 0.7) {
      this.mediumTerm.push({
        ...entry,
        timestamp: Date.now()
      });
      this.mediumTerm.sort((a, b) => b.importance - a.importance);
      this.mediumTerm = this.mediumTerm.slice(0, 50);
    }
    
    // 3. 关键知识存入长期记忆
    if (entry.importance > 0.9) {
      this.longTerm.set(entry.key, {
        ...entry,
        lastAccessed: Date.now()
      });
    }
  }

  async getRelevant(query, limit = { short: 5, medium: 10 }) {
    // 按相关性检索各层记忆
    const relevant = {
      short: this.shortTerm.slice(-limit.short),
      medium: this.mediumTerm
        .filter(m => this.relevanceScore(m, query) > 0.5)
        .slice(0, limit.medium),
      long: Array.from(this.longTerm.values())
        .filter(m => this.relevanceScore(m, query) > 0.7)
        .slice(0, 5)
    };
    
    return relevant;
  }
  
  relevanceScore(memory, query) {
    // 简化的相关性打分（实际可以用embedding）
    const keywords = query.toLowerCase().split(' ');
    const text = (memory.content || '').toLowerCase();
    return keywords.filter(k => text.includes(k)).length / keywords.length;
  }
}

🔧 上下文压缩技术

1. 自动摘要

async function compressContext(conversation, maxTokens) {
  // 对话太长时自动压缩
  while (countTokens(conversation.join('\n')) > maxTokens) {
    const oldest = conversation.shift();
    const summary = await summarizeDialog(oldest);
    conversation.unshift(`[摘要] ${summary}`);
  }
  return conversation;
}

async function summarizeDialog(text) {
  // 用AI简化对话内容
  // 可以用OpenClaw的Agent调用更小的模型来做
  const prompt = `简化以下内容，保留关键信息：\n\n${text}`;
  const response = await openclaw.invoke({
    model: 'gpt-4o-mini', // 便宜的模型来做压缩
    messages: [{ role: 'user', content: prompt }],
    temperature: 0.3,
    maxTokens: 200
  });
  return response.content;
}

2. 结构化上下文注入

// 结构化上下文，而非纯文本
function buildContext({
  userInfo,
  currentTask,
  relevantMemories,
  toolsAvailable
}) {
  return {
    system: `你是妙趣AI的运营助手。以下是上下文：`,
    sections: [
      {
        type: 'user',
        content: `用户：${userInfo.name}\n偏好：${userInfo.prefs.join(', ')}`,
        tokenBudget: 200
      },
      {
        type: 'task',
        content: `当前任务：${currentTask}\n目标：${currentTask.goal}`,
        tokenBudget: 500
      },
      {
        type: 'memory',
        content: relevantMemories.map(m => 
          `- ${m.timestamp}: ${m.content}`
        ).join('\n'),
        tokenBudget: 3000
      },
      {
        type: 'tools',
        content: toolsAvailable.map(t => 
          `${t.name}: ${t.description}`
        ).join('\n'),
        tokenBudget: 1000
      }
    ]
  };
}

// 优于把所有信息混在一起
// ❌ 错误: 无序拼接
// ✅ 正确: 结构化 + 标记边界

📊 上下文优化清单

// 每次 Agent 调用的检查点
async function optimizeContext(context) {
  // 1. 去重
  context = removeDuplicates(context);
  
  // 2. 排序：最重要的放最后（模型更容易记住）
  context.sort((a, b) => a.priority - b.priority);
  
  // 3. 截断：超出预算的部分移入记忆
  if (countTokens(context) > MAX_TOKENS) {
    const excess = context.splice(0, context.length - MAX_ENTRIES);
    await memory.store(excess);
  }
  
  // 4. 标记关键信息
  context = context.map(item => ({
    ...item,
    content: item.important 
      ? `【关键】${item.content}` 
      : item.content
  }));
  
  return context;
}

🛠️ 实战：为Agent设计上下文策略

场景：电商客服Agent

const customerServiceContext = {
  // 系统提示（固定，占2K）
  system: `你是XX电商AI客服。回复简洁、友好、高效。`,
  
  // 订单上下文（动态，占1K）
  orderInfo: () => getCurrentOrder(),
  
  // 用户历史（摘要化，占3K）
  userHistory: async (userId) => {
    const history = await fetchUserHistory(userId);
    return summarizeUserHistory(history); // 摘要而非完整历史
  },
  
  // 商品知识（按需注入，占2K）
  productKnowledge: async (productId) => {
    const product = await fetchProduct(productId);
    return formatProductInfo(product); // 只注入当前相关商品
  },
  
  // 政策知识（按需注入，占1K）
  policies: (type) => policyDB.get(type) || '参考通用政策',
  
  // 工具列表（动态，占2K）
  tools: (available) => available.map(t => t.signature).join('\n')
};

🔗 相关资源

🎭 结语

世界上有一种工程叫Context Engineering——它不是教你写更好的提示词，而是教你不要浪费Agent的"注意力"。

就像你不会给一个新人50本书说"你慢慢看"，你只会给他当前任务最需要的3页。Context Engineering就是这"3页"的艺术。