从 Prompt 到 Graph：AI 工程化的五个演进层次

前言：AI 工程化的演进之路

想象这样一个场景：

你刚开始用 AI，发现：

• 简单的提示词效果不好 → 开始学习 Prompt Engineering
• 提示词越来越长，难以管理 → 开始学习 Context Engineering
• 需要调用工具和 API → 开始学习 Harness Engineering
• 需要迭代和自我修复 → 开始学习 Loop Engineering
• 需要多个 AI 协作 → 开始学习 Graph Engineering

这不仅是工具的演进，更是工程化思维的成熟。 " 今天，我们就来对比这五个工程层次，看看它们如何一步步将 AI 从"玩具"变成"生产力工具"。

---

一、五个工程层次的定义

1.1 核心比喻

让我们用编程语言来比喻这五个层次：

Prompt Engineering   = 单参数函数
Context Engineering  = 多参数函数
Harness Engineering  = 带工具和运行环境的函数
Loop Engineering    = 带状态反馈的循环程序
Graph Engineering   = 多个程序节点组成的分布式程序

1.2 层次对比

层次	核心关注	复杂度	灵活性	控制力
Prompt Engineering	提示词优化	⭐	⭐	⭐
Context Engineering	上下文管理	⭐⭐	⭐⭐	⭐⭐
Harness Engineering	工具调用	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐
Loop Engineering	状态和迭代	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
Graph Engineering	多节点协作	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐

---

二、Prompt Engineering：单参数函数

2.1 定义

Prompt Engineering 是通过优化提示词（Prompt）来提升 AI 输出质量的工程化方法。

核心特点：

• ✅ 单参数：只关注提示词这一个参数
• ✅ 即时反馈：修改提示词，立即看到效果
• ✅ 易于上手：不需要编程知识
• ✅ 快速迭代：可以快速试验不同的提示词

类比：

def ai(prompt):
    return model.generate(prompt)

# 使用 Prompt Engineering
result = ai("写一个快速排序算法")

2.2 核心技巧

1. 角色扮演

你是一位资深 Python 开发者，请写一个快速排序算法

2. 任务分解

步骤 1：先写函数签名
步骤 2：实现核心逻辑
步骤 3：添加测试用例

3. 示例驱动

示例输入：[3, 1, 4, 1, 5, 9]
示例输出：[1, 1, 3, 4, 5, 9]
现在对 [9, 2, 6, 5, 3, 5] 进行排序

2.3 优势与局限

优势：

• ✅ 简单易学
• ✅ 即时反馈
• ✅ 门槛低

局限：

• ❌ 提示词过长会失去焦点
• ❌ 难以处理复杂任务
• ❌ 无法调用外部工具
• ❌ 无法保持状态

适用场景：

• 简单任务
• 快速原型
• 学习和实验

---

三、Context Engineering：多参数函数

3.1 定义

Context Engineering 是通过管理多个上下文参数来提升 AI 输出质量的工程化方法。

核心特点：

• ✅ 多参数：管理多个上下文参数
• ✅ 结构化：使用结构化的上下文
• ✅ 可复用：上下文模块化
• ✅ 可扩展：易于添加新的上下文

类比：

def ai(prompt, system, examples, constraints, history):
    context = {
        "system": system,
        "examples": examples,
        "constraints": constraints,
        "history": history
    }
    return model.generate(prompt, context)

# 使用 Context Engineering
result = ai(
    prompt="写一个快速排序算法",
    system="你是一位资深 Python 开发者",
    examples=[...],
    constraints="不要使用递归",
    history=[...]
)

3.2 核心技巧

1. 结构化上下文

system: 你是一位资深 Python 开发者
task: 写一个快速排序算法
requirements:
  - 使用迭代而非递归
  - 添加详细注释
  - 包含测试用例
examples:
  - input: [3, 1, 4, 1, 5, 9]
    output: [1, 1, 3, 4, 5, 9]
constraints:
  - 不使用内置排序函数
  - 时间复杂度 O(n log n)

2. 上下文模板

# 定义上下文模板
context_template = {
    "system": "你是一位{role}",
    "task": "{task}",
    "requirements": requirements,
    "examples": examples,
    "constraints": constraints
}

# 使用模板
context = context_template.format(
    role="资深 Python 开发者",
    task="写一个快速排序算法"
)

3. 上下文管理

# 管理多个上下文
contexts = {
    "coding": coding_context,
    "review": review_context,
    "testing": testing_context
}

# 选择合适的上下文
result = ai(prompt, context=contexts["coding"])

3.3 优势与局限

优势：

• ✅ 更好的控制
• ✅ 上下文可复用
• ✅ 适合中等复杂度任务

局限：

• ❌ 上下文过长会超出模型限制
• ❌ 上下文管理复杂
• ❌ 无法调用外部工具
• ❌ 无法自我修复

适用场景：

• 中等复杂度任务
• 需要多参数控制
• 需要上下文复用

---

四、Harness Engineering：带工具和运行环境的函数

4.1 定义

Harness Engineering 是通过为 AI 提供工具和运行环境来提升 AI 能力的工程化方法。

核心特点：

• ✅ 工具调用：AI 可以调用外部工具
• ✅ 运行环境：AI 可以执行代码
• ✅ 能力扩展：扩展 AI 的能力边界
• ✅ 实际应用：可以完成实际任务

类比：

def ai(prompt, tools, environment):
    # AI 可以调用工具
    if need_search(prompt):
        result = tools.search(prompt)

    # AI 可以执行代码
    if need_execute(prompt):
        result = environment.execute(code)

    return result

# 使用 Harness Engineering
tools = [search_tool, calculator_tool, file_tool]
environment = PythonEnvironment()

result = ai(
    prompt="计算斐波那契数列的前 10 项",
    tools=tools,
    environment=environment
)

4.2 核心技巧

1. 工具定义

# 定义工具
tools = {
    "search": {
        "description": "搜索互联网信息",
        "function": search_internet
    },
    "calculator": {
        "description": "执行数学计算",
        "function": calculate
    },
    "file": {
        "description": "读写文件",
        "function": file_operations
    }
}

# AI 可以调用这些工具
result = ai("今天天气怎么样", tools=tools)
# AI 会自动调用 search 工具

2. 运行环境

# 定义运行环境
class PythonEnvironment:
    def execute(self, code):
        # 沙箱执行
        result = exec_sandbox(code)
        return result

# AI 可以执行代码
result = ai(
    prompt="用 Python 计算斐波那契数列",
    environment=PythonEnvironment()
)

3. 工具链组合

# 组合多个工具
def complex_task(prompt):
    # 步骤 1：搜索
    search_result = tools.search(prompt)

    # 步骤 2：计算
    calc_result = calculator.calculate(search_result)

    # 步骤 3：保存
    file.save(calc_result)

    return calc_result

4.3 优势与局限

优势：

• ✅ 能力大幅扩展
• ✅ 可以完成实际任务
• ✅ 可以处理复杂任务

局限：

• ❌ 工具调用可能失败
• ❌ 执行环境有安全风险
• ❌ 仍然是一次性的

适用场景：

• 需要外部信息的任务
• 需要执行代码的任务
• 需要操作文件的任务

---

五、Loop Engineering：带状态反馈的循环程序

5.1 定义

Loop Engineering 是通过状态反馈和循环迭代来提升 AI 输出质量的工程化方法。

核心特点：

• ✅ 状态保持：AI 可以记住之前的状态
• ✅ 反馈循环：AI 可以根据反馈调整
• ✅ 自我修复：AI 可以发现和修复错误
• ✅ 迭代优化：AI 可以持续优化输出

类比：

def ai_loop(initial_prompt, max_iterations=5):
    state = {
        "prompt": initial_prompt,
        "result": None,
        "feedback": None,
        "iteration": 0
    }

    while state["iteration"] < max_iterations:
        # 生成输出
        state["result"] = model.generate(state["prompt"])

        # 检查质量
        state["feedback"] = evaluate(state["result"])

        # 如果满意，退出
        if state["feedback"]["quality"] > 0.9:
            break

        # 否则，调整提示词
        state["prompt"] = refine_prompt(state)
        state["iteration"] += 1

    return state["result"]

# 使用 Loop Engineering
result = ai_loop("写一个快速排序算法")

5.2 核心技巧

1. 状态管理

# 管理状态
class LoopState:
    def __init__(self):
        self.prompt = None
        self.result = None
        self.feedback = None
        self.iteration = 0
        self.history = []

    def update(self, result, feedback):
        self.result = result
        self.feedback = feedback
        self.history.append({
            "iteration": self.iteration,
            "result": result,
            "feedback": feedback
        })
        self.iteration += 1

2. 反馈机制

# 定义反馈机制
def evaluate_result(result):
    feedback = {
        "quality": 0.0,
        "issues": []
    }

    # 检查代码质量
    if not has_tests(result):
        feedback["issues"].append("缺少测试用例")
        feedback["quality"] -= 0.2

    if not has_comments(result):
        feedback["issues"].append("缺少注释")
        feedback["quality"] -= 0.1

    if has_errors(result):
        feedback["issues"].append("有语法错误")
        feedback["quality"] -= 0.5

    return feedback

3. 自我修复

# 自我修复循环
def self_repair_loop(initial_prompt):
    state = LoopState()
    state.prompt = initial_prompt

    while state.iteration < 5:
        # 生成
        result = model.generate(state.prompt)

        # 评估
        feedback = evaluate_result(result)

        # 如果质量高，退出
        if feedback["quality"] > 0.9:
            return result

        # 否则，修复
        if "有语法错误" in feedback["issues"]:
            state.prompt = f"修复以下错误：{result}"
        elif "缺少测试用例" in feedback["issues"]:
            state.prompt = f"添加测试用例：{result}"

        state.iteration += 1

    return result

5.3 优势与局限

优势：

• ✅ 可以自我修复
• ✅ 可以持续优化
• ✅ 可以处理复杂任务

局限：

• ❌ 可能陷入无限循环
• ❌ 状态管理复杂
• ❌ 需要定义评估标准

适用场景：

• 需要迭代优化的任务
• 需要自我修复的任务
• 需要保证质量的任务

---

六、Graph Engineering：多个程序节点组成的分布式程序

6.1 定义

Graph Engineering 是通过流程图的方式，将复杂任务拆解为多个节点，并明确定义节点之间的关系，从而实现多个 AI 协作工作的工程化方法。

核心特点：

• ✅ 节点化：将任务拆解为多个节点
• ✅ 关系化：明确定义节点之间的关系
• ✅ 可视化：用流程图直观展示
• ✅ 可扩展：易于添加新节点

类比：

# 定义图
graph = {
    "nodes": {
        "research": ResearchNode(),
        "plan": PlanNode(),
        "code": CodeNode(),
        "test": TestNode(),
        "deploy": DeployNode()
    },
    "edges": [
        {"from": "research", "to": "plan"},
        {"from": "plan", "to": "code"},
        {"from": "code", "to": "test"},
        {"from": "test", "to": "deploy"},
        {"from": "test", "to": "code", "condition": "failed"}
    ]
}

# 执行图
result = execute_graph(graph, input="开发用户认证系统")

6.2 核心技巧

1. 节点定义

# 定义节点
class Node:
    def __init__(self, id, ai, inputs, outputs):
        self.id = id
        self.ai = ai
        self.inputs = inputs
        self.outputs = outputs

    def execute(self, inputs):
        # 执行节点
        outputs = self.ai.execute(inputs)
        return outputs

# 使用节点
research_node = Node(
    id="research",
    ai=ResearchAI(),
    inputs=["topic"],
    outputs=["research_notes"]
)

2. 边定义

# 定义边
class Edge:
    def __init__(self, from_node, to_node, condition=None):
        self.from_node = from_node
        self.to_node = to_node
        self.condition = condition

    def can_route(self, outputs):
        if self.condition is None:
            return True
        return self.condition(outputs)

# 使用边
edge = Edge(
    from_node="test",
    to_node="code",
    condition=lambda outputs: outputs["success"] == False
)

3. 图执行

# 执行图
def execute_graph(graph, input_data):
    # 初始化
    ready_nodes = [graph["nodes"]["research"]]
    completed_nodes = []
    node_outputs = {}

    # 执行
    while ready_nodes:
        # 获取节点
        node = ready_nodes.pop(0)

        # 获取输入
        inputs = get_inputs(node, node_outputs)

        # 执行节点
        outputs = node.execute(inputs)
        node_outputs[node.id] = outputs
        completed_nodes.append(node)

        # 路由到下一个节点
        for edge in graph["edges"]:
            if edge.from_node == node.id:
                if edge.can_route(outputs):
                    ready_nodes.append(graph["nodes"][edge.to_node])

    return node_outputs

6.3 优势与局限

优势：

• ✅ 可处理超复杂任务
• ✅ 可并行执行
• ✅ 易于监控和调试

局限：

• ❌ 复杂度高
• ❌ 设计难度大
• ❌ 需要工程化思维

适用场景：

• 超复杂任务
• 需要多 AI 协作
• 需要并行处理

---

七、五个层次的深度对比

7.1 控制力对比

Prompt Engineering：

控制力：⭐
只能通过提示词控制

Context Engineering：

控制力：⭐⭐
可以通过多个参数控制

Harness Engineering：

控制力：⭐⭐⭐
可以通过工具和环境控制

Loop Engineering：

控制力：⭐⭐⭐⭐
可以通过状态和反馈控制

Graph Engineering：

控制力：⭐⭐⭐⭐⭐
可以通过节点和关系控制

7.2 复杂度对比

Prompt Engineering：

复杂度：⭐
简单，易于上手

Context Engineering：

复杂度：⭐⭐
需要管理多个参数

Harness Engineering：

复杂度：⭐⭐⭐
需要定义工具和环境

Loop Engineering：

复杂度：⭐⭐⭐⭐
需要管理状态和反馈

Graph Engineering：

复杂度：⭐⭐⭐⭐⭐
需要设计节点和关系

7.3 适用场景对比

Prompt Engineering：

适用：简单任务、快速原型、学习实验

Context Engineering：

适用：中等复杂度任务、需要多参数控制

Harness Engineering：

适用：需要外部信息、需要执行代码

Loop Engineering：

适用：需要迭代优化、需要自我修复

Graph Engineering：

适用：超复杂任务、需要多 AI 协作

---

八、如何选择？

8.1 按任务复杂度选择

简单任务：

• 写一个函数
• 生成一段文本
• 回答一个问题 → Prompt Engineering

中等任务：

• 开发一个小功能
• 写一篇短文
• 分析一个数据集 → Context Engineering

复杂任务：

• 开发一个模块
• 写一篇长文
• 处理多个文件 → Harness Engineering

超复杂任务：

• 开发一个系统
• 需要迭代优化
• 需要自我修复 → Loop Engineering

极致复杂任务：

• 开发一个产品
• 需要多 AI 协作
• 需要并行处理 → Graph Engineering

8.2 按需求选择

需求 1：快速原型 → Prompt Engineering

需求 2：稳定输出 → Context Engineering

需求 3：实际应用 → Harness Engineering

需求 4：质量保证 → Loop Engineering

需求 5：规模化 → Graph Engineering

---

九、演进之路

9.1 从低到高

Prompt Engineering
    ↓ (发现提示词不够)
Context Engineering
    ↓ (发现上下文不够)
Harness Engineering
    ↓ (发现一次性不够)
Loop Engineering
    ↓ (发现单 AI 不够)
Graph Engineering

9.2 不是替代，是演进

这五个层次不是相互替代的，而是逐步演进的：

Prompt Engineering 是基础
    ↓
Context Engineering 是扩展
    ↓
Harness Engineering 是增强
    ↓
Loop Engineering 是进化
    ↓
Graph Engineering 是成熟

9.3 实际应用中的组合

在实际应用中，这五个层次经常组合使用：

Graph Engineering (整体架构)
    ├── Node 1: Loop Engineering (自我修复)
    │   ├── Context Engineering (上下文管理)
    │   └── Harness Engineering (工具调用)
    └── Node 2: Loop Engineering (自我修复)
        ├── Context Engineering (上下文管理)
        └── Harness Engineering (工具调用)

---

十、总结

10.1 核心回顾

五个工程层次：

1. Prompt Engineering：单参数函数
2. Context Engineering：多参数函数
3. Harness Engineering：带工具和运行环境的函数
4. Loop Engineering：带状态反馈的循环程序
5. Graph Engineering：多个程序节点组成的分布式程序

演进路径：

简单 → 复杂 → 工具化 → 迭代化 → 分布化

10.2 关键要点

"从玩具到生产力工具"

这五个层次的演进，本质上是将 AI 从"玩具"变成"生产力工具"的过程。

"不是替代，是演进"

这五个层次不是相互替代的，而是逐步演进的。高层次的工程化包含低层次的工程化。

"选择合适的层次"

没有最好的层次，只有最适合的层次。根据任务的复杂度和需求选择合适的层次。

10.3 最终思考

AI 工程化的本质：

"AI 工程化不是要创造新的 AI，而是要让 AI 更好地服务于实际需求。"

演进的价值：

• Prompt Engineering：让 AI 能用
• Context Engineering：让 AI 稳定
• Harness Engineering：让 AI 实用
• Loop Engineering：让 AI 可靠
• Graph Engineering：让 AI 规模化

这就是 AI 工程化的演进之路：从 Prompt 到 Graph，一步步将 AI 从"玩具"变成"生产力工具"。

---

参考资源

• Prompt Engineering Guide：https://www.promptingguide.ai

---

如果你觉得这篇文章有帮助，欢迎点赞、转发，让更多人了解 AI 工程化的演进之路！