← 返回文章列表

iFlow CLI AI Coding 最佳实践(四):上下文工程篇

2024-08-25·3 分钟阅读

iFlow CLI AI Coding 最佳实践(四):上下文工程篇

前言

在 AI Coding 中,上下文工程(Context Engineering) 是决定 AI 表现的关键因素。如果说 Prompt Engineering 是教 AI 如何思考,那么 Context Engineering 就是告诉 AI 在什么环境下思考。

本篇将深入探讨 iFlow CLI 中的上下文工程实践,帮助你让 AI 更好地理解你的项目和需求。

什么是上下文工程?

定义

上下文工程是指在 AI 交互过程中,通过系统化的方法管理和优化提供给 AI 的上下文信息,以提升 AI 输出的质量和相关性。

为什么重要?

┌─────────────────────────────────────────────────────────┐
│                上下文质量 vs AI 表现                      │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  上下文质量        AI 表现                               │
│                                                         │
│  低 ○─────────────────────────────────────○ 高          │
│     │                    ▲                    │          │
│     │                    │                    │          │
│     │    ┌───────────────────────────┐       │          │
│     │    │   质量差的上下文:         │       │          │
│     │    │   - 信息不足               │       │          │
│     │    │   - 信息过载               │       │          │
│     │    │   - 信息不相关             │       │          │
│     │    │   - 信息过时               │       │          │
│     │    │                           │       │          │
│     │    │   结果:                   │       │          │
│     │    │   - 幻觉增加               │       │          │
│     │    │   - 理解偏差               │       │          │
│     │    │   - 输出质量下降           │       │          │
│     │    └───────────────────────────┘       │          │
│     │                                         │          │
│     │    ┌───────────────────────────┐       │          │
│     │    │   质量好的上下文:         │       │          │
│     │    │   - 信息完整               │       │          │
│     │    │   - 信息精准               │       │          │
│     │    │   - 信息相关               │       │          │
│     │    │   - 信息及时               │       │          │
│     │    │                           │       │          │
│     │    │   结果:                   │       │          │
│     │    │   - 理解准确               │       │          │
│     │    │   - 输出高质量             │       │          │
│     │    │   - 效率提升               │       │          │
│     │    └───────────────────────────┘       │          │
│                                                         │
└─────────────────────────────────────────────────────────┘

五种上下文工程方法

iFlow CLI 实现了五种核心的上下文工程方法:

1. 持久化记忆(Persistent Memory)

将重要信息持久化存储,避免重复输入和遗忘。

Todo 列表管理

# AI 自动创建任务列表
用户: 重构用户认证模块

AI: 我来帮你重构认证模块。首先规划任务:

📋 任务列表:
┌────┬─────────────────────────┬──────────┐
│ ID │ 任务                    │ 状态     │
├────┼─────────────────────────┼──────────┤
│ 1  │ 分析现有认证逻辑        │ 进行中   │
│ 2  │ 设计新的认证架构        │ 待处理   │
│ 3  │ 实现 JWT 工具类         │ 待处理   │
│ 4  │ 更新认证中间件          │ 待处理   │
│ 5  │ 编写测试用例            │ 待处理   │
└────┴─────────────────────────┴──────────┘

正在执行任务 1...

优势

  • 长任务不会遗忘
  • 进度可视化
  • 可随时恢复

Memory 系统

iFlow CLI 的 Memory 系统可以存储项目相关的知识:

~/.iflow/memory/
├── project-knowledge.md    # 项目知识
├── coding-standards.md     # 编码规范
├── api-conventions.md      # API 约定
└── common-patterns.md      # 常用模式

配置 Memory

# 让 AI 记住项目规范
> 记住:这个项目使用 ESLint + Prettier,禁止使用 var,
> 所有变量必须先定义后使用

AI: 已将编码规范添加到 Memory,后续代码生成将遵循这些规则。

2. 隔离上下文(Context Isolation)

通过 SubAgent 机制,为子任务创建独立的上下文窗口。

工作原理

┌─────────────────────────────────────────────────────────┐
│                    主 Agent 上下文                       │
│                                                         │
│  用户: 分析项目并添加单元测试                            │
│                                                         │
│  ┌─────────────────────────────────────────────────┐   │
│  │              SubAgent (独立上下文)               │   │
│  │                                                 │   │
│  │  任务:分析代码结构                              │   │
│  │  上下文:仅包含必要的代码文件                    │   │
│  │  输出:分析报告                                  │   │
│  │                                                 │   │
│  └─────────────────────────────────────────────────┘   │
│                      ↓                                  │
│  ┌─────────────────────────────────────────────────┐   │
│  │              SubAgent (独立上下文)               │   │
│  │                                                 │   │
│  │  任务:生成测试用例                              │   │
│  │  上下文:仅包含目标函数和测试框架信息            │   │
│  │  输出:测试文件                                  │   │
│  │                                                 │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
└─────────────────────────────────────────────────────────┘

使用场景

# 代码审查(隔离执行)
> 使用 code-review agent 审查 src/auth.ts

# 测试生成(隔离执行)
> 使用 test-generator agent 为 src/utils 生成测试

# 文档生成(隔离执行)
> 使用 doc-writer agent 生成 API 文档

优势

  • 避免上下文污染
  • 提高专业度
  • 减少幻觉

3. 召回上下文(Context Recall)

高效地从大量信息中检索相关内容。

搜索功能

# 代码搜索
> 搜索项目中所有使用 useEffect 的地方

# 文档召回
> 搜索 Next.js App Router 的数据获取方式

# 历史召回
> 回忆上次我们讨论的认证方案

DeepWiki 集成

iFlow CLI 支持 DeepWiki 自动文档生成:

# 安装 DeepWiki
> 安装 deepwiki-rs MCP 工具

# 生成文档
> 为这个项目生成 AI 友好的文档

AI: 正在分析代码结构... 正在生成文档...

已创建以下文档:
- docs/architecture.md    # 架构说明
- docs/modules/           # 模块文档
- docs/apis/              # API 文档

向量召回 vs Agent 搜索

方法优势劣势适用场景
向量召回快速、精确需要预处理已索引的大规模文档
Agent 搜索灵活、智能较慢动态、复杂的查询
DeepWiki自动化需要配置项目文档管理

4. 压缩上下文(Context Compression)

当上下文达到阈值时,自动压缩以保留关键信息。

自动压缩机制

┌─────────────────────────────────────────────────────────┐
│                    上下文压缩流程                        │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  上下文使用量                                           │
│                                                         │
│  100% ┤                                                │
│       │                                                │
│   70% ┤ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ 触发压缩     │
│       │                     │                          │
│       │                     ↓                          │
│       │    ┌────────────────────────────────┐          │
│       │    │ 压缩策略:                      │          │
│       │    │ 1. 保留任务关键信息             │          │
│       │    │ 2. 保留决策记录                 │          │
│       │    │ 3. 保留代码片段                 │          │
│       │    │ 4. 压缩历史对话                 │          │
│       │    │ 5. 删除冗余信息                 │          │
│       │    └────────────────────────────────┘          │
│       │                     │                          │
│       │                     ↓                          │
│   30% ┤ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ 压缩完成     │
│       │                                                │
│     0% └──────────────────────────────────────→ 时间    │
│                                                         │
└─────────────────────────────────────────────────────────┘

压缩类型

有损压缩

  • 删除重复信息
  • 概括长对话
  • 提取关键点

可回溯压缩

  • 保存完整日志到文件
  • 上下文保留摘要
  • 需要时可回溯查看
# 查看压缩历史
> 显示上下文压缩历史

# 回溯查看完整信息
> 回溯第 3 次压缩前的完整对话

5. 加强上下文(Context Enhancement)

对重要信息进行强调,确保 AI 聚焦关键内容。

任务强调

# 强调当前任务
> 重点:确保所有 API 都有错误处理

AI: 收到,我会特别关注错误处理。在生成代码时:
- 每个 API 都会有 try-catch
- 返回统一的错误格式
- 记录错误日志

环境变化强调

# Git 分支切换时自动强调
[检测到分支切换: main → feature/auth]

AI: 注意到你切换到了 feature/auth 分支。
我将关注认证相关的实现。

优先级设置

# 设置上下文优先级
> 优先级设置:
> 1. 安全性(最高)
> 2. 性能
> 3. 代码可读性
> 4. 功能完整性

AI: 已记录优先级,后续决策将按此顺序权衡。

实践案例

案例 1:大型项目分析

# 场景:分析一个包含 500+ 文件的项目

用户: /init

AI: 检测到大型项目,将采用分层次上下文策略:

第 1 层:项目概览
- package.json(技术栈)
- 目录结构(架构)
- README.md(项目说明)

第 2 层:核心模块
- 入口文件
- 核心配置
- 主要组件

第 3 层:按需加载
- 具体功能实现
- 工具函数
- 测试文件

正在分析...

✅ 已生成 IFLOW.md
✅ 已识别 12 个核心模块
✅ 已建立代码关系图

案例 2:长周期任务

# 场景:一个需要多天完成的任务

第 1 天:
用户: 开始实现支付系统,创建任务规划

AI: 已创建支付系统实现计划:
📋 任务列表(8 个任务)
✅ 已保存到 Memory

第 2 天:
用户: 继续昨天的支付系统任务

AI: 恢复任务上下文:
📋 当前进度:任务 3/8
📌 当前任务:实现支付回调处理
✅ 已加载相关代码上下文

继续执行...

案例 3:多任务并行

# 场景:同时处理多个功能

用户: 一边优化首页性能,一边开发新功能

AI: 我来帮你管理这两个并行任务:

📌 任务 A:首页性能优化
- 使用独立的上下文
- 聚焦性能指标

📌 任务 B:新功能开发
- 使用独立的上下文
- 聚焦功能实现

两个任务互不干扰,我会根据你的输入自动切换上下文。

上下文工程最佳实践

1. 合理使用 /init

# ✅ 推荐:进入项目后首先运行
cd my-project
iflow
> /init

# ❌ 不推荐:频繁重复运行
> /init  # 已有 IFLOW.md,不需要重复

2. 定期清理对话

# 完成一个大任务后
> /clear

# 开始新任务时
> 现在开始新的任务:添加用户管理功能

3. 善用 Memory

# 存储项目特定知识
> 记住这个项目的 API 响应格式:
> {
>   "code": number,
>   "data": any,
>   "message": string
> }

# 存储编码规范
> 记住:所有函数都需要 JSDoc 注释

4. 分层组织上下文

优先级层次:
1. 当前任务(最高优先级)
2. 项目规范
3. 代码上下文
4. 历史对话(最低优先级)

5. 监控上下文使用

# 检查当前上下文状态
> 显示当前上下文统计

AI: 上下文统计:
- Token 使用:45,000 / 128,000 (35%)
- 文件数量:12
- 任务进度:3/5
- 压缩次数:0

小结

上下文工程是 AI Coding 的核心技术之一,掌握它可以显著提升 AI 的表现:

  • 持久化记忆:让 AI 不遗忘重要信息
  • 隔离上下文:避免信息污染
  • 召回上下文:高效检索相关信息
  • 压缩上下文:在有限空间内保留关键信息
  • 加强上下文:确保 AI 聚焦重点

在下一篇中,我们将探讨 SubAgent 和 MCP,这是扩展 iFlow CLI 能力的关键机制。


相关链接

上一篇iFlow CLI AI Coding 最佳实践(三):核心功能篇

下一篇iFlow CLI AI Coding 最佳实践(五):SubAgent 与 MCP 篇

分享: