Organs (器官): 多智能体系统与应用
"整体大于部分之和。" — 亚里士多德
从 Cells 到 Organs
我们的旅程已经从 atoms(单个提示)到 molecules(带示例的提示)再到 cells(会话记忆)。现在我们来到了 organs — 多个上下文 cells 协调工作以完成复杂任务的系统。
┌─────────────────────────────────┐
│ ORGAN │
│ │
┌───────────┐ │ ┌─────┐ ┌─────┐ │
│ │ │ │Cell │◄─────►│Cell │ │
│ Input │─────►│ └─────┘ └─────┘ │
│ │ │ ▲ ▲ │
└───────────┘ │ │ │ │ ┌───────────┐
│ ▼ ▼ │ │ │
│ ┌─────┐ ┌─────┐ │─────►│ Output │
│ │Cell │◄─────►│Cell │ │ │ │
│ └─────┘ └─────┘ │ └───────────┘
│ │
└─────────────────────────────────┘就像生物器官由专门的细胞和谐工作组成一样,我们的上下文器官编排多个 LLM cells 来解决超出任何单个上下文能力的问题。
为什么我们需要 Organs: 单一上下文的局限性
即使是最复杂的上下文 cell 也有固有的局限性:
┌─────────────────────────────────────────────────────────────────┐
│ 单一上下文局限性 │
├─────────────────────────────────────────────────────────────────┤
│ ✗ 上下文窗口大小限制 │
│ ✗ 无并行处理 │
│ ✗ 单一视角/推理方法 │
│ ✗ 有限的工具使用能力 │
│ ✗ 复杂度上限(推理深度) │
│ ✗ 单点故障 │
└─────────────────────────────────────────────────────────────────┘Organs 通过专业化、并行化和编排克服了这些局限性。
Organ 的解剖结构
一个上下文 organ 有几个关键组件:
┌───────────────────────────────────────────────────────────────────────────┐
│ │
│ ┌─────────────────┐ │
│ │ │ │
│ │ Orchestrator │ 协调 cells,管理工作流和信息 │
│ │ │ │
│ └─────────────────┘ │
│ │ ▲ │
│ │ │ │
│ ▼ │ │
│ ┌─────────────────┐ │
│ │ │ │
│ │ Shared Memory │ 所有人都可以访问的中央信息仓库 │
│ │ │ │
│ └─────────────────┘ │
│ │ ▲ │
│ │ │ │
│ ▼ │ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Specialist │ │ Specialist │ │ Specialist │ ... │ │
│ │ │ Cell #1 │ │ Cell #2 │ │ Cell #3 │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────┘让我们探索每个组件:
1. Orchestrator (编排器)
orchestrator 是 organ 的"大脑",负责:
┌───────────────────────────────────────────────────────────────┐
│ ORCHESTRATOR 职责 │
├───────────────────────────────────────────────────────────────┤
│ ◆ 任务分解 │
│ ◆ Cell 选择和排序 │
│ ◆ 信息路由 │
│ ◆ 冲突解决 │
│ ◆ 进度监控 │
│ ◆ 输出综合 │
└───────────────────────────────────────────────────────────────┘orchestrator 可以是:
- 基于规则的: 遵循预定的工作流
- LLM 驱动的: 使用 LLM 自身来协调
- 混合式: 结合固定规则和动态适应
2. Shared Memory (共享记忆)
organ 的记忆系统使 cells 之间能够进行信息流动:
┌───────────────────────────────────────────────────────────────┐
│ 共享记忆类型 │
├───────────────────────────────────────────────────────────────┤
│ ◆ Working Memory: 当前任务状态和中间结果 │
│ ◆ Knowledge Base: 事实、检索的信息、参考资料 │
│ ◆ Process Log: 动作和推理步骤的历史记录 │
│ ◆ Output Buffer: 综合的结果和结论 │
└───────────────────────────────────────────────────────────────┘记忆管理在 organs 中变得更加关键,因为总信息量超过了任何单一上下文窗口。
3. Specialist Cells (专业 Cells)
organ 中的每个 cell 都有专门的角色:
╭──────────────────────────╮ ╭──────────────────────────╮ ╭──────────────────────────╮
│ 🔍 RESEARCHER │ │ 🧠 REASONER │ │ 📊 EVALUATOR │
│ │ │ │ │ │
│ 角色: 信息收集 │ │ 角色: 分析、推理 │ │ 角色: 评估质量 │
│ 和综合 │ │ 和得出结论 │ │ 验证事实、发现错误 │
│ │ │ │ │ │
│ 上下文: 搜索结果、 │ │ 上下文: 事实、相关 │ │ 上下文: 声明、输出、 │
│ 知识库访问 │ │ 信息、规则 │ │ 标准、证据 │
╰──────────────────────────╯ ╰──────────────────────────╯ ╰──────────────────────────╯
╭──────────────────────────╮ ╭──────────────────────────╮ ╭──────────────────────────╮
│ 🛠️ TOOL USER │ │ 🖋️ WRITER │ │ 🗣️ USER INTERFACE │
│ │ │ │ │ │
│ 角色: 执行外部工具、 │ │ 角色: 创建清晰、 │ │ 角色: 与用户交互、 │
│ API、代码 │ │ 精良的最终内容 │ │ 澄清、个性化 │
│ │ │ │ │ │
│ 上下文: 工具文档、输入 │ │ 上下文: 内容大纲、 │ │ 上下文: 用户历史、 │
│ 参数、结果 │ │ 事实、风格指南 │ │ 偏好、查询 │
╰──────────────────────────╯ ╰──────────────────────────╯ ╰──────────────────────────╯这些只是示例 — cells 可以针对任何任务或领域进行专业化。
控制流模式: Organs 如何处理信息
不同的 organs 使用不同的信息流模式:
┌───────────────────────────────────┐ ┌───────────────────────────────────┐
│ SEQUENTIAL (PIPELINE) │ │ PARALLEL (MAP-REDUCE) │
├───────────────────────────────────┤ ├───────────────────────────────────┤
│ │ │ │
│ ┌─────┐ ┌─────┐ ┌─────┐ │ │ ┌─────┐ │
│ │ │ │ │ │ │ │ │ ┌────►│Cell │────┐ │
│ │Cell │───►│Cell │───►│Cell │ │ │ │ └─────┘ │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ └─────┘ └─────┘ └─────┘ │ │ ┌─────┐ ┌─────┐ │
│ │ │ │ │ │ │ │
│ 适用于: 具有明确依赖关系 │ │ │Split│ │Merge│ │
│ 的逐步过程 │ │ │ │ │ │ │
│ │ │ └─────┘ └─────┘ │
│ │ │ │ │ │
│ │ │ │ ┌─────┐ │ │
│ │ │ └────►│Cell │────┘ │
│ │ │ └─────┘ │
│ │ │ │
│ │ │ 适用于: 可以并行 │
│ │ │ 处理的独立子任务 │
└───────────────────────────────────┘ └───────────────────────────────────┘
┌───────────────────────────────────┐ ┌───────────────────────────────────┐
│ FEEDBACK LOOP │ │ HIERARCHICAL │
├───────────────────────────────────┤ ├───────────────────────────────────┤
│ │ │ ┌─────┐ │
│ ┌─────┐ ┌─────┐ ┌─────┐ │ │ │Boss │ │
│ │ │ │ │ │ │ │ │ │Cell │ │
│ │Cell │───►│Cell │───►│Cell │ │ │ └─────┘ │
│ │ │ │ │ │ │ │ │ │ │
│ └─────┘ └─────┘ └─────┘ │ │ ┌─────────┴─────────┐ │
│ ▲ │ │ │ │ │ │
│ └──────────────────────┘ │ │ ┌─────┐ ┌─────┐ │
│ │ │ │Team │ │Team │ │
│ 适用于: 迭代优化、 │ │ │Lead │ │Lead │ │
│ 质量改进循环 │ │ └─────┘ └─────┘ │
│ │ │ │ │ │
│ │ │ ┌─────┴─────┐ ┌─────┴─────┐ │
│ │ │ │ │ │ │ │ │ │
│ │ │ │Cell │Cell │ │Cell │Cell │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ └─────┴─────┘ └─────┴─────┘ │
│ │ │ │
│ │ │ 适用于: 需要多级 │
│ │ │ 协调的复杂任务 │
└───────────────────────────────────┘ └───────────────────────────────────┘模式的选择取决于任务结构、并行化潜力和复杂度。
ReAct: 基础 Organ 模式
最强大的 organ 模式之一是 ReAct (Reasoning + Acting):
┌───────────────────────────────────────────────────────────────────────────┐
│ │
│ ReAct 模式 │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ │ │ │ │ │ │
│ │ Thought │─────►│ Action │─────►│ Observation │─────┐ │
│ │ │ │ │ │ │ │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ ▲ │ │
│ └───────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────┘每个循环包括:
- Thought (思考): 对当前状态进行推理并决定做什么
- Action (行动): 执行工具、API 调用或信息检索
- Observation (观察): 接收和解释结果
- 重复直到任务完成
这种模式实现了推理和工具使用的强大组合。
简单的 Organ 实现
这是一个具有三个专业 cells 的顺序 organ 的基本实现:
python
class ContextOrgan:
"""一个具有多个专业 cells 的简单上下文 organ。"""
def __init__(self, llm_service):
"""使用 LLM 服务初始化 organ。"""
self.llm = llm_service
self.shared_memory = {}
# 初始化专业 cells
self.cells = {
"researcher": self._create_researcher_cell(),
"reasoner": self._create_reasoner_cell(),
"writer": self._create_writer_cell()
}
def _create_researcher_cell(self):
"""创建专门用于信息收集的 cell。"""
system_prompt = """你是一个研究专家。
你的工作是收集和组织关于某个主题的相关信息。
专注于事实准确性和全面覆盖。
用标题和要点清楚地组织你的发现。"""
return {
"system_prompt": system_prompt,
"memory": [],
"max_turns": 3
}
def _create_reasoner_cell(self):
"""创建专门用于分析和推理的 cell。"""
system_prompt = """你是一个分析推理专家。
你的工作是分析信息、识别模式并得出逻辑结论。
考虑多个视角并评估证据的强度。
清楚地说明你的推理过程和你做出的任何假设。"""
return {
"system_prompt": system_prompt,
"memory": [],
"max_turns": 3
}
def _create_writer_cell(self):
"""创建专门用于内容创作的 cell。"""
system_prompt = """你是一个写作专家。
你的工作是创建清晰、引人入胜、结构良好的内容。
根据目标受众和目的调整你的风格。
专注于清晰度、连贯性和适当的格式。"""
return {
"system_prompt": system_prompt,
"memory": [],
"max_turns": 3
}
def _build_context(self, cell_name, input_text):
"""为特定 cell 构建上下文。"""
cell = self.cells[cell_name]
context = f"{cell['system_prompt']}\n\n"
# 添加与此 cell 相关的共享记忆
if cell_name in self.shared_memory:
context += "相关信息:\n"
context += self.shared_memory[cell_name]
context += "\n\n"
# 添加 cell 的对话历史
if cell["memory"]:
context += "之前的交流:\n"
for exchange in cell["memory"]:
context += f"输入: {exchange['input']}\n"
context += f"输出: {exchange['output']}\n\n"
# 添加当前输入
context += f"输入: {input_text}\n输出:"
return context
def _call_cell(self, cell_name, input_text):
"""用给定输入调用特定 cell。"""
context = self._build_context(cell_name, input_text)
# 调用 LLM
response = self.llm.generate(context)
# 更新 cell 记忆
self.cells[cell_name]["memory"].append({
"input": input_text,
"output": response
})
# 如果需要修剪记忆
if len(self.cells[cell_name]["memory"]) > self.cells[cell_name]["max_turns"]:
self.cells[cell_name]["memory"] = self.cells[cell_name]["memory"][-self.cells[cell_name]["max_turns"]:]
return response
def process_query(self, query):
"""通过整个 organ 处理查询。"""
# 步骤 1: 研究阶段
research_prompt = f"研究以下主题: {query}"
research_results = self._call_cell("researcher", research_prompt)
# 更新共享记忆
self.shared_memory["reasoner"] = f"研究发现:\n{research_results}"
# 步骤 2: 分析阶段
analysis_prompt = f"分析关于以下主题的研究发现: {query}"
analysis_results = self._call_cell("reasoner", analysis_prompt)
# 更新共享记忆
self.shared_memory["writer"] = f"分析结果:\n{analysis_results}"
# 步骤 3: 内容创作阶段
writing_prompt = f"创建关于 {query} 的综合回应"
final_content = self._call_cell("writer", writing_prompt)
return {
"research": research_results,
"analysis": analysis_results,
"final_output": final_content
}这个简单的 organ 遵循顺序管道模式,信息从研究流向分析再流向内容创作。
高级 Organ 模式
让我们探索一些更复杂的 organ 架构:
Tool-Using Agent (工具使用智能体): 瑞士军刀
┌───────────────────────────────────────────────────────────────────────────┐
│ 工具使用智能体 ORGAN │
│ │
│ ┌─────────────────┐ │
│ │ │ │
│ │ Agent Cell │◄─────────── 用户查询 │
│ │ (Orchestrator) │ │
│ │ │ │
│ └─────────────────┘ │
│ │ ▲ │
│ │ │ │
│ ▼ │ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 工具选择和使用 │ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │ │ Web │ │ Database │ │ Calendar │ │ Code │ ... │ │
│ │ │ Search │ │ Query │ │ Access │ │ Execution│ │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │ ▲ │
│ │ │ │
│ ▼ │ │
│ ┌─────────────────┐ │
│ │ │ │
│ │ Result │────────────► 最终响应 │
│ │ Synthesis │ │
│ │ │ │
│ └─────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────┘这种模式使 LLM 能够选择和使用各种工具来完成任务,类似于现代 LLM API 中流行的"函数调用"功能。
Debate Organ (辩论器官): 多视角
┌───────────────────────────────────────────────────────────────────────────┐
│ 辩论 ORGAN │
│ │
│ ┌─────────────────┐ │
│ │ │ │
│ │ Moderator │◄─────────── 问题/主题 │
│ │ Cell │ │
│ │ │ │
│ └─────────────────┘ │
│ │ │
│ └─┬─────────────┬─────────────────┬─────────────┐ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ │ │ │ │ │ │ │ │
│ │ Perspective │ │ Perspective │ │ Perspective │ │ Perspective │ │
│ │ Cell A │ │ Cell B │ │ Cell C │ │ Cell D │ │
│ │ │ │ │ │ │ │ │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │ │ │ │ │
│ └─────────────┴─────────────────┴─────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 多轮辩论 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ │ │
│ │ Synthesis │────────────► 最终响应 │
│ │ Cell │ │
│ │ │ │
│ └─────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────┘这种模式在多个视角之间创建结构化辩论,从而实现更彻底和平衡的分析。
Recursive Organ (递归器官): 分形组合
┌───────────────────────────────────────────────────────────────────────────┐
│ 递归 ORGAN │
│ (Organs 中的 Organs) │
│ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 研究 ORGAN │ │
│ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Topic │───────►│ Source │────────►│Synthesis│ │ │
│ │ │ Analysis│ │ Gather │ │ │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 推理 ORGAN │ │
│ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Fact │───────►│ Critical│────────►│Inference│ │ │
│ │ │ Check │ │ Analysis│ │ Drawing │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ 输出 ORGAN │ │
│ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Content │───────►│ Style │────────►│ Final │ │ │
│ │ │ Planning│ │ Adapting│ │ Editing │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────┘这种分形方法支持复杂的分层处理,每个子 organ 处理整体任务的不同方面。
实际应用
上下文 organs 支持用简单的上下文结构无法实现的复杂应用:
┌───────────────────────────────────────────────────────────────┐
│ 基于 ORGAN 的应用 │
├───────────────────────────────────────────────────────────────┤
│ ◆ 研究助手: 多阶段研究和综合 │
│ ◆ 代码生成: 设计、实现、测试、文档 │
│ ◆ 内容创作: 研究、大纲、起草、编辑 │
│ ◆ 自主智能体: 规划、执行、反思 │
│ ◆ 数据分析: 收集、清理、分析、可视化 │
│ ◆ 复杂问题解决: 分解和逐步执行 │
│ ◆ 交互式学习: 个性化教育系统 │
└───────────────────────────────────────────────────────────────┘每个应用都受益于不同 cells 协同工作的专业性质。
优化 Organ 性能
几个因素影响上下文 organs 的有效性:
┌─────────────────────────────────────────────────────────────────────┐
│ ORGAN 优化因素 │
├─────────────────────────────────────────────────────────────────────┤
│ ◆ 专业化清晰度: 每个 cell 的角色定义有多清晰 │
│ ◆ 记忆管理: 高效的信息存储和检索 │
│ ◆ 编排逻辑: 协调系统的有效性 │
│ ◆ 错误处理: 当 cells 产生不正确输出时的鲁棒性 │
│ ◆ 反馈机制: 从结果中学习和改进的能力 │
│ ◆ 任务分解: 将问题分解为子任务的效果 │
└─────────────────────────────────────────────────────────────────────┘平衡这些因素需要仔细的测量和迭代。
测量 Organ 有效性
与所有上下文工程一样,测量是关键:
┌──────────────────────────────────────────────────────────┐
│ ORGAN 指标 │ 目标 │
├──────────────────────────────────┼───────────────────────┤
│ 端到端准确性 │ >90% │
├──────────────────────────────────┼───────────────────────┤
│ 总 Token 使用量 │ <单上下文的 50% │
├──────────────────────────────────┼───────────────────────┤
│ 延迟(完整管道) │ <每步 5 秒 │
├──────────────────────────────────┼───────────────────────┤
│ 错误恢复率 │ >80% │
├──────────────────────────────────┼───────────────────────┤
│ 上下文窗口利用率 │ >70% │
└──────────────────────────────────┴───────────────────────┘跟踪这些指标有助于识别瓶颈和优化机会。
涌现属性: Organs 的魔力
上下文 organs 最迷人的方面是它们的涌现属性 — 源自整个系统而非任何单个 cell 的能力:
┌─────────────────────────────────────────────────────────────────────┐
│ ORGANS 的涌现属性 │
├─────────────────────────────────────────────────────────────────────┤
│ ◆ 处理大于任何单一上下文窗口的问题 │
│ ◆ 通过专门的验证 cells 进行自我纠正 │
│ ◆ 超出单提示能力的复杂多步推理 │
│ ◆ 在处理过程中对新信息的适应性 │
│ ◆ 多个视角导致更平衡的分析 │
│ ◆ 对单个 cell 故障的弹性 │
│ ◆ 通过专业化获得的特定领域专业知识 │
└─────────────────────────────────────────────────────────────────────┘这些涌现能力支持用简单的上下文结构无法实现的全新类别的应用。
超越上下文窗口: 突破大小限制
organs 最强大的好处之一是能够处理远超任何单一上下文窗口的信息:
┌───────────────────────────────────────────────────────────────────────────┐
│ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ │ │ │ │ │ │
│ │ Orchestrator │────►│ Summarization │────►│ Long Document │ │
│ │ Cell │ │ Cell │ │ (200+ 页) │ │
│ │ │ │ │ │ │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
│ │ ▲ │
│ │ │ │
│ ▼ │ │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ │ │ │ │
│ │ Chunk Router │────►│ Analysis Cells │ │
│ │ Cell │ │ (每块 1 个) │ │
│ │ │ │ │ │
│ └─────────────────┘ └─────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────┘这种架构通过以下方式处理几乎无限长度的文档:
- 将文档分块为可管理的片段
- 并行处理每个块
- 聚合和综合结果
认知架构: 从 Organs 到 Systems
在最高层次上,organs 可以组合成完整的认知架构或"系统":
┌───────────────────────────────────────────────────────────────────────────┐
│ 完整的认知架构 │
│ │
│ ┌───────────────────────┐ ┌───────────────────────┐ │
│ │ │ │ │ │
│ │ Perception │ │ Reasoning │ │
│ │ Organ System │◄────────►│ Organ System │ │
│ │ │ │ │ │
│ └───────────────────────┘ └───────────────────────┘ │
│ ▲ ▲ │
│ │ │ │
│ │ │ │
│ ▼ ▼ │
│ ┌───────────────────────┐ ┌───────────────────────┐ │
│ │ │ │ │ │
│ │ Memory │◄────────►│ Action │ │
│ │ Organ System │ │ Organ System │ │
│ │ │ │ │ │
│ └───────────────────────┘ └───────────────────────┘ │
│ │
└───────────────────────────────────────────────────────────────────────────┘这种方法反映了人类认知理论,感知、推理、记忆和行动的专门系统协同工作以创建统一的智能。
实现功能性 Organ: 代码示例
让我们实现一个更复杂的内容创作 organ:
python
class ContentCreationOrgan:
"""用于创建高质量内容的多 cell organ。"""
def __init__(self, llm_service):
"""使用 LLM 服务初始化 organ。"""
self.llm = llm_service
self.shared_memory = {}
# 创建专业 cells
self.cells = {
"planner": self._create_cell("""你是一个内容规划专家。
你的工作是为内容创作创建详细的大纲。
将主题分解为逻辑部分,有清晰的标题和副标题。
考虑目标受众、目的和要涵盖的要点。"""),
"researcher": self._create_cell("""你是一个研究专家。
你的工作是收集和组织关于某个主题的相关信息。
专注于事实准确性,尽可能引用来源。
突出关键统计数据、示例和支持证据。"""),
"writer": self._create_cell("""你是一个内容写作专家。
你的工作是根据大纲和研究创建引人入胜、结构良好的内容。
根据目标受众和目的调整你的风格。
专注于清晰度、流畅性和引人入胜的叙述。"""),
"editor": self._create_cell("""你是一个编辑专家。
你的工作是完善和改进现有内容。
检查清晰度、连贯性、语法和风格问题。
在保持原始语气和信息的同时提出改进建议。"""),
"fact_checker": self._create_cell("""你是一个事实核查专家。
你的工作是验证内容中的事实声明。
标记任何可疑或不准确的陈述。
尽可能提供带有参考的更正。""")
}
def _create_cell(self, system_prompt):
"""使用给定的系统提示创建 cell。"""
return {
"system_prompt": system_prompt,
"memory": [],
"max_turns": 3
}
def _build_context(self, cell_name, input_text):
"""为特定 cell 构建上下文。"""
cell = self.cells[cell_name]
context = f"{cell['system_prompt']}\n\n"
# 添加与此 cell 相关的共享记忆
if cell_name in self.shared_memory:
context += "相关信息:\n"
context += self.shared_memory[cell_name]
context += "\n\n"
# 添加 cell 的对话历史
if cell["memory"]:
context += "之前的交流:\n"
for exchange in cell["memory"]:
context += f"输入: {exchange['input']}\n"
context += f"输出: {exchange['output']}\n\n"
# 添加当前输入
context += f"输入: {input_text}\n输出:"
return context
def _call_cell(self, cell_name, input_text):
"""用给定输入调用特定 cell。"""
context = self._build_context(cell_name, input_text)
# 调用 LLM
response = self.llm.generate(context)
# 更新 cell 记忆
self.cells[cell_name]["memory"].append({
"input": input_text,
"output": response
})
# 如果需要修剪记忆
if len(self.cells[cell_name]["memory"]) > self.cells[cell_name]["max_turns"]:
self.cells[cell_name]["memory"] = self.cells[cell_name]["memory"][-self.cells[cell_name]["max_turns"]:]
return response
def create_content(self, topic, audience="general", content_type="article", depth="comprehensive"):
"""创建关于给定主题的内容。"""
# 步骤 1: 内容规划
plan_prompt = f"""为关于'{topic}'的{content_type}创建详细大纲。
目标受众: {audience}
深度: {depth}
包括主要部分、子部分以及每个部分要涵盖的要点。"""
content_plan = self._call_cell("planner", plan_prompt)
# 更新共享记忆
self.shared_memory["researcher"] = f"内容计划:\n{content_plan}"
# 步骤 2: 研究阶段
research_prompt = f"""研究以下{content_type}主题:
'{topic}'
基于此内容计划:
{content_plan}
收集每个部分的关键事实、统计数据、示例和支持证据。"""
research_findings = self._call_cell("researcher", research_prompt)
# 更新共享记忆
self.shared_memory["writer"] = f"内容计划:\n{content_plan}\n\n研究发现:\n{research_findings}"
# 步骤 3: 写作阶段
writing_prompt = f"""为{audience}受众撰写关于'{topic}'的{content_type}。
遵循此内容计划:
{content_plan}
融入这些研究发现:
{research_findings}
创建一篇{depth}的作品,在涵盖所有要点的同时吸引读者。"""
draft_content = self._call_cell("writer", writing_prompt)
# 步骤 4: 事实核查
fact_check_prompt = f"""审查此{content_type}草稿的事实准确性:
{draft_content}
标记任何可疑声明,验证关键事实,如需要提出更正建议。"""
fact_check_results = self._call_cell("fact_checker", fact_check_prompt)
# 更新共享记忆
self.shared_memory["editor"] = f"草稿内容:\n{draft_content}\n\n事实核查结果:\n{fact_check_results}"
# 步骤 5: 编辑阶段
editing_prompt = f"""编辑和完善此{content_type}草稿:
{draft_content}
考虑这些事实核查结果:
{fact_check_results}
改进清晰度、流畅性和风格,同时修复任何确定的事实问题。"""
final_content = self._call_cell("editor", editing_prompt)
return {
"content_plan": content_plan,
"research_findings": research_findings,
"draft_content": draft_content,
"fact_check_results": fact_check_results,
"final_content": final_content
}这个实现演示了:
- 针对内容创作不同方面的专业 cells
- 信息通过 organ 的顺序流动
- 共享记忆在 cells 之间传递信息
- 从规划到完成内容的完整管道
Organ 设计的挑战
构建有效的 organs 面临几个挑战:
┌─────────────────────────────────────────────────────────────────────┐
│ ORGAN 设计挑战 │
├─────────────────────────────────────────────────────────────────────┤
│ ◆ 错误传播: 错误可能在系统中级联 │
│ ◆ 协调开销: 编排增加了复杂性和延迟 │
│ ◆ 信息瓶颈: 关键细节可能在 cells 之间丢失 │
│ ◆ 调试困难: 复杂的交互可能难以追踪 │
│ ◆ 成本扩展: 多次 LLM 调用增加了总 token 成本 │
│ ◆ 系统设计复杂性: 需要仔细规划和测试 │
└─────────────────────────────────────────────────────────────────────┘解决这些挑战需要仔细的设计、测试和监控。
Organ 工程最佳实践
从复杂 organs 的经验中,涌现出几个最佳实践:
┌──────────────────────────────────────────────────────────────────────┐
│ ORGAN 工程最佳实践 │
├──────────────────────────────────────────────────────────────────────┤
│ ✓ 从简单开始: 从最小的 organs 开始,根据需要增加复杂性 │
│ ✓ 测量 Cell 性能: 首先单独测试每个 cell │
│ ✓ 明确契约: 定义 cells 之间清晰的输入/输出格式 │
│ ✓ 全面日志记录: 跟踪所有 cell 间通信 │
│ ✓ 容错性: 设计 cells 处理意外输入 │
│ ✓ 验证 Cells: 添加专门的 cells 来检查输出 │
│ ✓ 渐进增强: 先构建基本功能,然后添加 │
│ ✓ 尽可能并行: 识别并并行化独立任务 │
└──────────────────────────────────────────────────────────────────────┘遵循这些实践会导致更健壮和有效的 organ 系统。
从理论到实践: 完整示例
为了将所有内容结合在一起,让我们考虑一个完整的数据分析 organ 系统:
┌─────────────────────────────────────────────────────────────────────────────┐
│ 数据分析 ORGAN 系统 │
│ │
│ ┌─────────────┐ │
│ │ │ ┌──────────────────────┐ │
│ │ User Query │─────────────────────►│ Query Understanding │ │
│ │ │ │ Cell │ │
│ └─────────────┘ └──────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────┐ │
│ │ 数据处理 Organ │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ │ │ │ │ │
│ │ │ Data │────►│ Cleaning │ │ │
│ │ │ Loading │ │ Cell │ │ │
│ │ │ │ │ │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ │ │ │ │ │
│ │ │ Feature │◄────┤ Validation │ │ │
│ │ │ Engineering │ │ Cell │ │ │
│ │ │ │ │ │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │ │
│ └─────────┼────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────┐ │
│ │ 分析 Organ │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ │ │ │ │ │
│ │ │ Statistical │────►│ Insight │ │ │
│ │ │ Analysis │ │ Generation │ │ │
│ │ │ │ │ │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ │ │ │ │ │
│ │ │ Visualization◄────┤ Verification│ │ │
│ │ │ Cell │ │ Cell │ │ │
│ │ │ │ │ │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │ │
│ └─────────┼────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────┐ │
│ │ │ │
│ │ Reporting Cell │ │
│ │ │ │
│ └──────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────┐ │
│ │ │ │
│ │ Final Report │ │
│ │ │ │
│ └──────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘这个系统说明了多个 organs 如何协同工作以创建完整的工作流,从原始数据到最终见解。
超越人类能力: Organs 所能实现的
上下文 organs 最令人兴奋的方面是它们能够实现超越人类专家所能实现的能力:
┌─────────────────────────────────────────────────────────────────────┐
│ 超人类能力 │
├─────────────────────────────────────────────────────────────────────┤
│ ◆ 并行处理: 同时分析许多文档 │
│ ◆ 多样化专业知识: 结合来自多个领域的知识 │
│ ◆ 一致的质量: 保持峰值性能而不疲劳 │
│ ◆ 规模: 处理人类无法管理的信息量 │
│ ◆ 多个视角: 同时从多个角度检查问题 │
│ ◆ 完美记忆: 保留和利用所有相关信息 │
└─────────────────────────────────────────────────────────────────────┘这些能力为 AI 应用开辟了全新的可能性。
关键要点
- 上下文 organs 组合多个专业 cells 来解决复杂问题
- 编排 协调 cells 之间的信息流
- 共享记忆 实现整个 organ 的有效通信
- 控制流模式 决定 cells 如何交互(顺序、并行等)
- 涌现属性 源自 cells 的交互,创造超越任何单个 cell 的能力
- 突破上下文限制 实现几乎无限信息的处理
- 最佳实践 帮助解决 organ 设计和实现的挑战
练习
- 为特定任务设计一个简单的双 cell organ
- 实现一个基本的 orchestrator 来协调 cell 交互
- 向现有 organ 添加验证 cell 以提高准确性
- 在同一任务上尝试不同的控制流模式
- 测量 cell 专业化带来的性能提升
下一步
你现在已经完成了基础系列,探索了从 atoms 到 organs 的完整演进。从这里,你可以:
- 深入
10_guides_zero_to_hero/中的实践指南来实现这些概念 - 探索
20_templates/中可重用的模板以快速实现 - 研究
30_examples/中的完整示例以了解这些原则的实际应用 - 参考
40_reference/中的详细文档以获得更深入的理解 - 继续阅读基础系列的高级部分: 继续到 05_cognitive_tools.md →
你选择的路径取决于你的学习风格和目标。无论你选择哪个方向,你现在已经具备了成为熟练上下文工程师所需的基础知识。
深入探讨: 上下文工程的未来
随着上下文工程的发展,几个新兴趋势正在塑造这个领域:
┌─────────────────────────────────────────────────────────────────────┐
│ 新兴趋势 │
├─────────────────────────────────────────────────────────────────────┤
│ ◆ 自动 Organ 生成: LLM 设计自己的 organs │
│ ◆ 自适应专业化: 根据任务需求进化的 Cells │
│ ◆ 混合模型 Organs: 结合不同的模型类型和大小 │
│ ◆ 人在回路 Organs: 与人类输入的协作系统 │
│ ◆ 持久 Organ 系统: 具有不断进化状态的长期运行智能体 │
│ ◆ 标准化 Cell 接口: 即插即用的组件生态系统 │
└─────────────────────────────────────────────────────────────────────┘这些发展承诺在未来提供更强大和灵活的上下文工程能力。