AI Agent 设计模式实战：ReAct 架构详解

在 reasoning-only 模式中，智能助手专注于分析和推理，但不直接采取行动。

• 你告诉智能助手：'我明天有个会议。'
• 智能助手分析这句话，确定明天的会议时间、地点等细节。
• 它可能会提醒你：'明天下午 3 点有个会议，在公司会议室。'

在 action-only 模式中，智能助手专注于执行任务，但不做深入的推理或分析。

• 你告诉智能助手：'把我明天的会议改到上午 10 点。'
• 智能助手立即执行这个任务，将会议时间修改为上午 10 点。
• 它可能会简单确认：'您的会议已改到明天上午 10 点。'

在 ReAct 模式中，智能助手结合推理和行动，形成一个循环的感知 - 动作循环。不仅分析了你的需求（推理），还实际修改了日程安排（行动）。

• 你告诉智能助手：'我明天有个会议，但我想提前到上午 10 点。'
• 智能助手首先分析这句话，确定会议的原始时间和地点（感知阶段）。
• 然后，它更新你的日程安排，将会议时间改为上午 10 点（决策和动作执行阶段）。
• 最后，智能助手确认修改，并提供额外的信息：'您的会议已成功改到明天上午 10 点。提醒您，会议地点不变。'

二、ReAct 的实现过程

下面通过实际的源码，详细介绍 ReAct 模式的实现方法。建议在 PC 端打开阅读源代码以获得更好的体验。

第一步 准备 Prompt 模板

在实现 ReAct 模式的时候，首先需要设计一个清晰的 Prompt 模板，主要包含以下几个元素：

• 思考（Thought）：这是推理过程的文字展示，阐明我们想要 LLM 帮我们做什么，为了达成目标的前置条件是什么。
• 行动（Action）：根据思考的结果，生成与外部交互的指令文字，比如需要 LLM 进行外部搜索。
• 行动参数（Action Input）：用于展示 LLM 进行下一步行动的参数，比如 LLM 要进行外部搜索的话，行动参数就是搜索的关键词。主要是为了验证 LLM 是否能提取准确的行动参数。
• 观察（Observation）：和外部行动交互之后得到的结果，比如 LLM 进行外部搜索的话，那么观察就是搜索的结果。

Prompt 模板示例：

TOOL_DESC = """{name_for_model}: Call this tool to interact with the {name_for_human} API. What is the {name_for_human} API useful for? {description_for_model} Parameters: {parameters} Format the arguments as a JSON object."""
REACT_PROMPT = """Answer the following questions as best you can. You have access to the following tools:
{tool_descs}
Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can be repeated zero or more times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question
Begin!
Question: {query}"""

第二步 构建 Agent

一个 ReAct Agent 需要定义好以下元素：

• llm：背后使用的 LLM 大模型。
• tools：后续会用到的 Tools 集合。
• stop：什么情况下 ReAct Agent 停止循环。

class LLMSingleActionAgent {
  llm: AzureLLM
  tools: StructuredTool[]
  stop: string[]
  private _prompt: string = '{input}'
  
  constructor({ llm, tools = [], stop = [] }: LLMSingleActionAgentParams) {
    this.llm = llm
    this.tools = tools
    if (stop.length > 4)
      throw new Error('up to 4 stop sequences')
    this.stop = stop
  }
}

第三步 定义 Tools

Tools 有两个最重要的参数，name 和 description。

Name 就是函数名，description 是工具的自然语言描述，LLM 根据 description 来决定是否需要使用该工具。工具的描述应该非常明确，说明工具的功能、使用的时机以及不适用的情况。

export abstract class StructuredTool {
  name: string
  description: string
  
  constructor(name: string, description: string) {
    this.name = name
    this.description = description
  }

  abstract call(arg: string, config?: Record<string, any>): Promise<string>

  getSchema(): string {
    return `${this.declaration} | ${this.name} | ${this.description}`
  }

  abstract get declaration(): string
}

我们先简单地将两个描述信息拼接一下，为 Agent 提供 4 个算数工具：

1. Addition Tool: A tool for adding two numbers
2. Subtraction Tool: A tool for subtracting two numbers
3. Division Tool: A tool for dividing two numbers
4. Multiplication Tool: A tool for multiplying two numbers

一个很有意思的事情是，这几个算数工具函数并不需要实际的代码，大模型可以仅靠自身的推理能力就完成实际的算数运算。当然，对于更复杂的工具函数，还是需要进行详细的代码构建。

第四步 循环执行

执行器 executor 是在 Agent 的运行时，协调各个组件并指导操作。还记得 ReAct 模式的流程吗？Thought、Action、Observation、循环，Executor 的作用就是执行这个循环。

class AgentExecutor {
  agent: LLMSingleActionAgent
  tools: StructuredTool[] = []
  maxIterations: number = 15

  constructor(agent: LLMSingleActionAgent) {
    this.agent = agent
  }
  
  addTool(tools: StructuredTool | StructuredTool[]) {
    const _tools = Array.isArray(tools) ? tools : [tools]
    this.tools.push(..._tools)
  }
}

executor 会始终进行如下事件循环直到目标被解决了或者思考迭代次数超过了最大次数：

• 根据之前已经完成的所有步骤（Thought、Action、Observation）和 目标（用户的问题），规划出接下来的 Action（使用什么工具以及工具的输入）。
• 检测是否已经达成目标，即 Action 是不是 ActionFinish。是的话就返回结果，不是的话说明还有行动要完成。
• 根据 Action，执行具体的工具，等待工具返回结果。工具返回的结果就是这一轮步骤的 Observation。
• 保存当前步骤到记忆上下文，如此反复。

async call(input: promptInputs): Promise<AgentFinish> {
    const toolsByName = Object.fromEntries(
      this.tools.map(t => [t.name, t]),
    )

    const steps: AgentStep[] = []
    let iterations = 0

    while (this.shouldContinue(iterations)) {
      const output = await this.agent.plan(steps, input)
      console.log(iterations, output)

      // Check if the agent has finished
      if ('returnValues' in output)
        return output

      const actions = Array.isArray(output)
        ? output as AgentAction[]
        : [output as AgentAction]

      const newSteps = await Promise.all(
        actions.map(async (action) => {
          const tool = toolsByName[action.tool]

          if (!tool)
            throw new Error(`${action.tool} is not a valid tool, try another one.`)

          const observation = await tool.call(action.toolInput)

          return { action, observation: observation ?? '' }
        }),
      )

      steps.push(...newSteps)

      iterations++
    }

    return {
      returnValues: { output: 'Agent stopped due to max iterations.' },
      log: '',
    }
  }

第五步 实际运行

我们提出一个问题，看看 Agent 怎么通过 ReAct 方式进行解决。'一种减速机的价格是 750 元，一家企业需要购买 12 台。每台减速机运行一小时的电费是 0.5 元，企业每天运行这些减速机 8 小时。请计算企业购买及一周运行这些减速机的总花费。'

describe('agent', () => {
  const llm = new AzureLLM({
    apiKey: Config.apiKey,
    model: Config.model,
  })
  const agent = new LLMSingleActionAgent({ llm })
  agent.setPrompt(REACT_PROMPT)
  agent.addStop(agent.observationPrefix)
  agent.addTool([new AdditionTool(), new SubtractionTool(), new DivisionTool(), new MultiplicationTool()])

  const executor = new AgentExecutor(agent)
  executor.addTool([new AdditionTool(), new SubtractionTool(), new DivisionTool(), new MultiplicationTool()])
  it('test', async () => {
    const res = await executor.call({ input: '一种减速机的价格是 750 元，一家企业需要购买 12 台。每台减速机运行一小时的电费是 0.5 元，企业每天运行这些减速机 8 小时。请计算企业购买及一周运行这些减速机的总花费。' })
    expect(res).toMatchInlineSnapshot(`
      {
        "log": "Final Answer: The total cost of purchasing and operating the gearboxes for a week is 9336 yuan.",
        "returnValues": {
          "output": "The total cost of purchasing and operating the gearboxes for a week is 9336 yuan.",
        },
      }
    `)
  }, { timeout: 50000 })
})

我们来看一下 Agent 的输出，以及 Agent 在这个过程，是如何思考和行动的。可以看到，通过 Thought、Action、Observation 的循环，AI Agent 很好地一步步完成最终答案的输出。

Question: 一种减速机的价格是 750 元，一家企业需要购买 12 台。每台减速机运行一小时的电费是 0.5 元，企业每天运行这些减速机 8 小时。请计算企业购买及一周运行这些减速机的总花费
Thought: I need to calculate the total cost of purchasing and operating the gearboxes for a week.
Action: Multiplication Tool
Action Input: [750, 12]
Observation: 9000
Thought: Now I need to calculate the cost of operating the gearboxes for a day.
Action: Multiplication Tool
Action Input: [0.5, 8, 12]
Observation: 48
Thought: Now I need to calculate the cost of operating the gearboxes for a week.
Action: Multiplication Tool
Action Input: [48, 7]
Observation: 336
Thought: Now I need to calculate the total cost of purchasing and operating the gearboxes for a week.
Action: Addition Tool
Action Input: [9000, 336]
Observation: 9336

三、ReAct 模式的局限性与优化

在 AI Agent 的多种实现模式中，ReAct 模式是最早出现、也是目前使用最广泛的模式。ReAct 的核心思想就是模拟人思考和行动的过程，通过 Thought、Action、Observation 的循环，一步步解决目标问题。

尽管 ReAct 框架提出了一种非常好的思路，让现有的应用得到一次智能化的进化机会，但它也存在很多的不足：

1. 内容稳定性：首先是 LLM 大模型的通病，即产出内容不稳定。不仅仅是输出内容存在波动，也体现在对复杂问题的分析、解决上存在一定的波动。这要求我们在工程层面增加校验机制。
2. 成本问题：采用 ReAct 方式，我们是无法完全控制输入内容的。因为在任务提交给 LLM 后，LLM 对任务的拆解、循环次数是不可控的。因此存在一种可能性，过于复杂的任务导致 Token 过量消耗。在实际生产中，必须设置 max_iterations 限制，并监控 Token 使用情况。
3. 响应时间：比起大部分 API 接口毫秒级的响应，LLM 响应时间是秒级以上。在 ReAct 模式下，这个时间变得更加不可控。因为无法确定需要拆分多少步骤，需要访问多少次 LLM 模型。因此在秒级接口响应的背景下，做成同步接口显然是不合适的，需要采用异步的方式。而异步方式，又会影响用户体验，对应用场景的选择又造成了限制。

针对上述局限性，常见的优化策略包括：

• 引入缓存机制：对于相同的 Action Input，缓存 Observation 结果，避免重复调用外部工具。
• 动态工具选择：根据上下文动态过滤可用工具列表，减少 LLM 的干扰项。
• 混合模式：对于确定性高的子任务，直接使用代码执行而非调用 LLM，降低延迟和成本。

现在有很多场景已经有了非常成熟的 ReAct Agent 应用，比如智能客服、知识助手、个性化营销、智能销售助理等等。通过深入理解其底层实现，开发者可以更好地驾驭 AI 技术，构建高效可靠的智能系统。

四、总结

ReAct 模式通过 Thought、Action、Observation 的循环，实现了推理与行动的协同。本文详细介绍了其概念、实现步骤、代码结构以及潜在的限制。在实际开发中，建议结合具体业务场景，合理配置 Prompt 和工具，并关注性能与成本的平衡。