上下文管理

让每一个 Token 都物有所值

上下文管理是 Claude Code 性能优化的核心技能。就像管理内存一样重要，高效的上下文管理不仅能提升响应速度，还能让 AI 给出更精准的答案，同时节省成本。

什么是上下文管理？

核心概念

上下文管理是指智能地控制和优化 AI 模型处理的信息量：

# 上下文管理的目标
⚡ 性能优化 - 减少处理时间，提升响应速度
💰 成本控制 - 降低 token 使用，节省 API 费用  
🎯 质量提升 - 提供最相关信息，改善输出质量
🔄 可持续性 - 支持长期对话和复杂任务

上下文的结构层次

# 上下文信息的重要性分层

🔴 核心上下文 (高优先级):
- 当前任务的直接相关信息
- 项目的关键配置和约束
- 错误信息和调试线索

🟡 支撑上下文 (中优先级):
- 项目架构和技术栈信息
- 相关的代码示例和模式
- 团队规范和最佳实践

🟢 背景上下文 (低优先级):
- 项目历史和演进过程
- 可选的技术方案对比
- 详细的实现原理解释

上下文优化策略

1. 分层加载策略 📚

# 按需加载不同层次的信息

基础层 (总是包含):
- CLAUDE.md 核心配置
- 当前任务描述
- 关键错误信息

扩展层 (按需包含):
- 相关代码文件
- 技术文档片段
- 配置文件内容

详细层 (最后考虑):
- 完整日志文件
- 历史对话记录
- 全面的文档说明

# 实际应用示例
> 修复登录 bug

第1步: 只包含基础信息
- CLAUDE.md 中的认证配置
- 错误描述
- 相关的认证模块文件

第2步: 根据需要添加扩展信息  
- 完整的错误日志
- 相关的测试用例
- API 文档

第3步: 如果还需要更多上下文
- 整个认证系统的架构
- 历史修复记录
- 详细的业务逻辑

2. 信息密度优化 🎯

# 提高信息的价值密度

❌ 低密度信息:
- 大量的注释和空行
- 重复的样板代码
- 无关的历史记录

✅ 高密度信息:
- 关键代码片段
- 精炼的配置说明
- 核心业务逻辑

# 优化前的上下文 (2000 tokens)
```javascript
/**
 * This is the main authentication service
 * It handles user login, logout, and session management
 * Created by John Doe on 2023-01-15
 * Last modified by Jane Smith on 2023-06-20
 */

const express = require('express');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');

// Database connection
const db = require('./database');

// JWT secret key
const JWT_SECRET = process.env.JWT_SECRET || 'default_secret';

// Authentication service class
class AuthService {
  // Constructor
  constructor() {
    this.tokenExpiration = '24h';
  }
  
  // Login method
  async login(email, password) {
    try {
      // Find user by email
      const user = await db.findUser({ email });
      if (!user) {
        return { success: false, message: 'User not found' };
      }
      
      // Check password
      const isValidPassword = await bcrypt.compare(password, user.password);
      if (!isValidPassword) {
        return { success: false, message: 'Invalid password' };
      }
      
      // Generate token
      const token = jwt.sign(
        { userId: user.id, email: user.email },
        JWT_SECRET,
        { expiresIn: this.tokenExpiration }
      );
      
      return { success: true, token, user };
    } catch (error) {
      console.error('Login error:', error);
      return { success: false, message: 'Internal server error' };
    }
  }
}

module.exports = AuthService;

优化后的上下文 (500 tokens)

// AuthService.js - 核心登录逻辑
class AuthService {
  async login(email, password) {
    const user = await db.findUser({ email });
    if (!user) return { success: false, message: 'User not found' };
    
    const isValid = await bcrypt.compare(password, user.password);
    if (!isValid) return { success: false, message: 'Invalid password' };
    
    const token = jwt.sign({ userId: user.id }, JWT_SECRET, { expiresIn: '24h' });
    return { success: true, token, user };
  }
}

// 当前问题: token 验证失败，用户登录后立即被登出
// 错误信息: "JsonWebTokenError: invalid signature"

### 3. 动态上下文调整 🔄

```bash
# 根据对话进展动态调整上下文

对话开始:
- 包含项目基本信息
- 当前任务描述
- 相关文件概览

对话深入:
- 移除不相关的初始信息
- 增加具体的实现细节
- 添加错误诊断信息

问题聚焦:
- 保留核心问题上下文
- 添加解决方案相关信息
- 移除外围的背景信息

# 上下文演进示例

阶段1: 项目概览 (1500 tokens)
- 项目结构说明
- 技术栈介绍  
- 主要功能模块

阶段2: 问题定位 (1200 tokens)
- 移除项目背景
- 增加错误日志
- 添加相关代码

阶段3: 解决方案 (800 tokens)
- 移除诊断信息
- 保留核心代码
- 添加修复方案

智能上下文筛选

1. 相关性评分算法 📊

# 上下文信息的相关性评分

评分维度:
- 直接相关性 (40%): 与当前任务直接相关
- 时间新近性 (25%): 最近修改或访问的信息
- 影响范围 (20%): 影响系统核心功能的信息
- 用户偏好 (15%): 基于历史使用模式

# 评分计算示例
文件: src/auth/AuthService.js
- 直接相关性: 9/10 (认证相关任务)
- 时间新近性: 7/10 (3天前修改)
- 影响范围: 9/10 (核心功能)
- 用户偏好: 8/10 (经常操作)
综合评分: 8.4/10

文件: docs/README.md  
- 直接相关性: 3/10 (通用文档)
- 时间新近性: 4/10 (1个月前)
- 影响范围: 2/10 (文档说明)
- 用户偏好: 3/10 (很少查看)
综合评分: 2.9/10

筛选策略: 只包含评分 > 7.0 的信息

2. 智能去重机制 🔄

# 避免上下文中的重复信息

重复类型检测:
- 完全相同的代码片段
- 类似的配置文件内容  
- 重复的错误信息
- 相同的依赖声明

去重策略:
- 保留最新版本的信息
- 合并相似的内容块
- 提取公共信息到摘要
- 引用而非重复完整内容

# 去重前后对比
去重前 (3000 tokens):
- package.json 完整内容 (800 tokens)
- package-lock.json 片段 (600 tokens)  
- 3个组件中的相同 import 声明 (400 tokens)
- 重复的 ESLint 配置 (200 tokens)
- 其他内容 (1000 tokens)

去重后 (1500 tokens):
- 依赖摘要: React 18.2, TypeScript 4.9 (100 tokens)
- 组件导入: 标准 React hooks 和自定义组件 (100 tokens)
- ESLint: 标准配置 + 项目特定规则 (100 tokens)
- 其他内容保持不变 (1000 tokens)
- 节省: 50% tokens

3. 上下文压缩技术 🗜️

# 在保持信息完整性的前提下压缩上下文

压缩策略:
1. 摘要提取 - 用摘要替代冗长的说明
2. 关键词保留 - 保留技术关键词，简化描述
3. 结构化表示 - 用结构化格式替代自然语言
4. 引用机制 - 建立信息引用而非重复

# 压缩示例

原始描述 (200 tokens):

这个用户认证系统使用了 JSON Web Token (JWT) 来管理用户会话。当用户成功登录后，系统会生成一个包含用户ID和邮箱信息的JWT token。这个token的有效期是24小时。在每次API请求时，客户端需要在 Authorization header中携带这个token。服务端会验证token的有效性，包括签名验证和过期时间检查。如果token无效或过期，服务端会返回401未授权状态码。


压缩后 (50 tokens):

认证: JWT (24h有效期) 登录 → 生成token (userId + email) API请求 → Authorization header验证无效/过期token → 401错误


压缩率: 75%，信息保留度: 95%

实时上下文监控

1. Token 使用监控 📊

# 实时监控上下文的token使用情况

监控指标:
- 当前token使用量
- 剩余token空间
- token使用效率
- 响应时间相关性

# 监控面板示例
=== 上下文监控面板 ===
当前对话: 修复用户认证问题
Token使用: 15,240 / 200,000 (7.6%)
响应时间: 2.3s (正常)
上下文效率: 8.2/10 (良好)

近期趋势:
📈 Token使用稳定增长
⚡ 响应时间保持稳定  
🎯 任务相关性持续提升

建议:
💡 可以添加更多相关代码文件
💡 考虑移除3天前的日志信息

2. 质量指标跟踪 📈

# 上下文质量的关键指标

质量维度:
- 相关性指数: 当前上下文与任务的匹配度
- 完整性指数: 解决问题所需信息的完备程度
- 冗余度指数: 重复和无用信息的比例
- 新鲜度指数: 信息的时效性和准确性

# 质量报告示例
上下文质量报告 - 2024-01-20 14:30
==========================================
相关性指数: 8.7/10 ✅
- 核心文件覆盖率: 95%
- 任务匹配度: 89%

完整性指数: 7.4/10 ⚠️
- 缺少测试用例文件
- API文档不完整

冗余度指数: 2.1/10 ✅ (低冗余)
- 重复信息 < 5%
- 无关信息 < 3%

新鲜度指数: 8.9/10 ✅
- 90%信息在一周内更新
- 技术栈信息准确

3. 自动优化建议 💡

# 基于监控数据的自动优化建议

优化触发条件:
- Token使用率 > 80%
- 响应时间 > 5s
- 相关性指数 < 7.0
- 冗余度指数 > 3.0

# 自动建议示例
🤖 上下文优化建议:

当前状态: Token使用率 85%，响应时间 6.2s

建议优化:
1. 🗑️ 移除过期日志 (节省 2,400 tokens)
2. 📦 压缩配置文件 (节省 800 tokens)
3. 🎯 聚焦核心代码 (移除外围文件)

预期效果:
- Token使用率降至 65%
- 响应时间降至 3.5s
- 相关性提升至 8.5/10

执行建议? [Y/n]

高级上下文管理技巧

1. 分段式上下文 🧩

# 将大型上下文分解为可管理的片段

分段策略:
- 功能模块分段: 按业务功能划分
- 文件类型分段: 代码/配置/文档分离
- 时间维度分段: 按修改时间组织
- 重要性分段: 按优先级排序

# 分段管理示例
电商系统上下文分段:

Segment-A: 用户认证模块 (3,500 tokens)
├── AuthService.js (核心逻辑)
├── auth.middleware.js (中间件)
├── auth.test.js (测试用例)
└── 相关配置和错误日志

Segment-B: 商品管理模块 (2,800 tokens)  
├── ProductService.js
├── product.routes.js
├── product.model.js
└── 相关数据库脚本

动态加载:
- 当前任务涉及认证 → 只加载 Segment-A
- 需要商品相关信息 → 动态加载 Segment-B
- 跨模块问题 → 加载多个相关段

2. 上下文快照管理 📸

# 保存和恢复上下文状态

快照类型:
- 任务启动快照: 记录初始上下文状态
- 关键决策快照: 保存重要决策时的上下文
- 错误调试快照: 记录问题发生时的完整上下文
- 解决方案快照: 保存成功解决问题时的状态

# 快照管理命令
> /context snapshot save "auth-bug-investigation"
✅ 快照已保存: auth-bug-investigation
   Token 使用: 12,450
   核心文件: 8个
   时间戳: 2024-01-20 14:30:25

> /context snapshot list
📋 可用快照:
1. auth-bug-investigation (2024-01-20 14:30)
2. payment-integration-start (2024-01-19 16:45)  
3. database-optimization (2024-01-19 10:20)

> /context snapshot restore "auth-bug-investigation"
✅ 已恢复快照: auth-bug-investigation
   上下文已回滚至问题调试开始时的状态

3. 协作式上下文共享 👥

# 团队协作中的上下文共享和管理

共享策略:
- 项目级共享: 团队共同的项目配置
- 任务级共享: 特定任务的上下文状态
- 知识级共享: 解决方案和最佳实践
- 个人级保护: 个人偏好和敏感信息

# 团队上下文管理
团队: 前端开发团队
项目: 电商平台重构

共享上下文库:
📁 project-config/
├── 项目架构文档
├── 编码规范
├── API接口定义
└── 部署配置

📁 solution-library/
├── 常见问题解决方案
├── 性能优化案例  
├── 调试技巧汇总
└── 最佳实践模板

个人上下文:
🔒 dev-preferences/
├── 个人代码风格偏好
├── 常用工具配置
├── 学习笔记
└── 任务历史记录

# 上下文同步
> /context team sync
🔄 正在同步团队共享上下文...
✅ 已更新项目配置 (3个文件)
✅ 已更新解决方案库 (2个新案例)
✅ 个人配置保持不变

同步完成: 团队上下文已是最新状态

性能优化案例分析

案例 1：大型项目的上下文优化

背景: 20万行代码的企业级应用，上下文经常溢出

优化前状态:

问题症状:
- Token 使用率经常 > 95%
- 响应时间 8-12 秒
- 经常出现上下文截断
- AI 回答质量不稳定

上下文构成:
- 项目完整结构 (15,000 tokens)
- 多个完整源文件 (45,000 tokens)
- 详细日志文件 (25,000 tokens)
- 完整配置文件 (8,000 tokens)
- 历史对话记录 (12,000 tokens)
总计: 105,000 tokens (52.5% 使用率)

优化策略实施:

第1阶段: 结构化精简
- 项目结构用目录树替代 → 节省 12,000 tokens
- 源文件提取关键函数 → 节省 30,000 tokens
- 日志过滤关键错误信息 → 节省 20,000 tokens

第2阶段: 智能分层
- 核心层: 当前任务直接相关 (15,000 tokens)
- 扩展层: 按需加载的支撑信息 (8,000 tokens)
- 背景层: 必要时的补充信息 (5,000 tokens)

第3阶段: 动态管理
- 实时相关性评分
- 自动移除过期信息
- 智能预加载相关内容

优化结果:

优化后效果:
✅ Token 使用率: 28% (降低 47%)
✅ 响应时间: 2.8 秒 (降低 75%)
✅ 上下文质量: 8.4/10 (提升 40%)
✅ 任务完成率: 92% (提升 25%)

关键改进:
- 建立了分层加载机制
- 实现了智能去重算法
- 建立了质量监控体系
- 形成了团队最佳实践

案例 2：实时协作的上下文同步

场景: 5人团队并行开发，需要实时共享上下文

挑战:

协作痛点:
- 上下文信息不一致
- 重复的问题调查
- 解决方案无法复用
- 团队知识割裂

技术难点:
- 实时同步性能要求
- 冲突检测和解决
- 个人隐私保护
- 版本控制复杂性

解决方案:

架构设计:
- 分层上下文管理
- 增量同步机制
- 冲突自动解决
- 权限精细控制

实施步骤:
1. 建立共享上下文库
2. 实现增量同步算法
3. 部署冲突检测机制
4. 配置权限管理系统

技术实现:
- 使用 WebSocket 实时通信
- Git-like 版本控制机制
- 智能合并算法
- 加密传输保护隐私

协作效果:

同步前后对比:

同步前:
❌ 重复调查时间: 40%
❌ 知识查找效率: 30%
❌ 解决方案复用: 15%
❌ 团队协作满意度: 6.2/10

同步后:
✅ 重复调查时间: 8% (降低 80%)
✅ 知识查找效率: 85% (提升 183%)
✅ 解决方案复用: 78% (提升 420%)
✅ 团队协作满意度: 8.9/10 (提升 44%)

核心价值:
- 团队知识共享效率翻倍
- 问题解决速度提升3倍
- 代码质量一致性提升
- 新人上手时间减少60%

最佳实践总结

✅ 高效上下文管理原则

分层思维 - 按重要性组织上下文信息
动态调整 - 根据任务进展调整上下文内容
质量监控 - 持续跟踪上下文质量指标
智能压缩 - 在保持信息完整性前提下优化密度
协作共享 - 建立团队级的上下文管理机制

❌ 要避免的管理陷阱

信息过载 - 盲目增加上下文而不考虑相关性
静态思维 - 不根据任务变化调整上下文内容
忽视质量 - 只关注数量而忽视信息质量
缺乏监控 - 没有建立上下文性能监控机制
孤立工作 - 不利用团队共享的上下文资源

记住：上下文管理是一门艺术，需要在信息完整性和处理效率之间找到平衡。好的上下文管理不仅能提升 AI 的工作效率，还能让你的开发工作更加顺畅和高效。

继续探索：Token 使用优化 - 深入了解如何精确控制和优化 token 的使用。

让每一个 Token 都物有所值​

什么是上下文管理？​

核心概念​

上下文的结构层次​

上下文优化策略​

1. 分层加载策略 📚​

2. 信息密度优化 🎯​

优化后的上下文 (500 tokens)

智能上下文筛选​

1. 相关性评分算法 📊​

2. 智能去重机制 🔄​

3. 上下文压缩技术 🗜️​

实时上下文监控​

1. Token 使用监控 📊​

2. 质量指标跟踪 📈​

3. 自动优化建议 💡​

高级上下文管理技巧​

1. 分段式上下文 🧩​

2. 上下文快照管理 📸​

3. 协作式上下文共享 👥​

性能优化案例分析​

案例 1：大型项目的上下文优化​

案例 2：实时协作的上下文同步​

最佳实践总结​

✅ 高效上下文管理原则​

❌ 要避免的管理陷阱​