ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;border-left: none;padding: 1em;border-radius: 8px;color: rgba(0, 0, 0, 0.5);background: rgb(247, 247, 247);margin: 0px 8px 2em;">驱动大模型有很多种方式，例如纯Prompt方式、思维链方式、ReAct方式等。ReAct 方式是 AI Agent 最常用的实现思路之一，它强调在执行任务时结合推理（Reasoning）和行动（Acting）两个方面，使得Agent能够在复杂和动态的环境中更有效地工作。ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;margin: 1.5em 8px;letter-spacing: 0.1em;color: rgb(63, 63, 63);">本文我们来看看常用的那些Agent编程框架都是怎么实现 ReAct 思路的。ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;font-size: 1.2em;font-weight: bold;display: table;margin: 2em auto 1em;padding-right: 1em;padding-left: 1em;border-bottom: 2px solid rgb(15, 76, 129);color: rgb(63, 63, 63);">0. ReAct思想介绍ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;font-size: 1.2em;font-weight: bold;display: table;margin: 4em auto 2em;padding-right: 0.2em;padding-left: 0.2em;background: rgb(15, 76, 129);color: rgb(255, 255, 255);">0.1 ReAct是什么？关键步骤及意义ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;margin: 1.5em 8px;letter-spacing: 0.1em;color: rgb(63, 63, 63);">在AI Agent中，ReAct（Reasoning and Acting）是一种设计思想，它强调在执行任务时结合推理（Reasoning）和行动（Acting）两个方面。这种思路通常涉及以下几个关键步骤：
ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;padding-left: 1em;color: rgb(63, 63, 63);" class="list-paddingleft-1">1.理解上下文：Agent首先需要理解它所处的环境和任务的上下文，这可能包括理解自然语言的指令、感知环境状态或识别问题的本质。 2.推理：基于理解的上下文，Agent进行逻辑推理，以确定最佳的行动方案。这可能包括规划、决策制定、问题解决或预测可能的结果。 3.规划：在推理的基础上，Agent制定一个行动计划，这通常涉及到确定一系列有序的步骤，以实现既定的目标或响应特定的指令。 4.执行：Agent根据规划的步骤执行行动。在执行过程中，它可能会与环境进行交互，使用API调用、操作用户界面或执行其他形式的I/O操作。 5.反馈和迭代：执行行动后，Agent会收集反馈，以评估行动的效果。基于反馈，Agent可以调整其推理和规划策略，以改进未来的性能。 ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;margin: 1.5em 8px;letter-spacing: 0.1em;color: rgb(63, 63, 63);">在AI Agent中，ReAct思路有助于实现更加智能和自适应的行为，因为它不仅关注执行具体的任务，而且还包括对任务执行前的情况分析和执行后的结果评估。这种综合性的方法使得Agent能够在复杂和动态的环境中更有效地工作。ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;font-size: 1.2em;font-weight: bold;display: table;margin: 4em auto 2em;padding-right: 0.2em;padding-left: 0.2em;background: rgb(15, 76, 129);color: rgb(255, 255, 255);">0.2 ReAct 的论文解读ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;margin: 1.5em 8px;letter-spacing: 0.1em;color: rgb(63, 63, 63);">我曾经在【AI大模型应用开发】【AutoGPT系列】0. AutoGPT概念及原理介绍 - Agent开发框架及ReAct方法一文中也详细解读过 ReAct 思路的实现方式以及与其它实现思路的效果对比。ingFang SC", "Hiragino Sans GB", "Microsoft YaHei UI", "Microsoft YaHei", Arial, sans-serif;border-left: none;padding: 1em;border-radius: 8px;color: rgba(0, 0, 0, 0.5);background: rgb(247, 247, 247);margin: 2em 8px;">ReAct：Reason + Act的组合简写。具体参考这篇论文：https://arxiv.org/pdf/2210.03629.pdf。  0.3 小结ReAct思想中，我认为比较重要的还是Re的步骤，即 Think 的步骤，因为这个过程才是真正的分析上下文，决定下一步的动作。Act只是动作的执行者，没有自己思想的打工人。 1. LangChain Agent在LangChain中使用ReAct模式的Agent可以这样设置： react=initialize_agent(tools,llm,agent=AgentType.REACT_DOCSTORE,verbose=True) 其基本过程在class AgentExecutor(Chain)中： def_iter_next_step(
self,
name_to_tool_map ict[str,BaseTool],
color_mappingict[str,str],
inputsict[str,str],
intermediate_steps ist[Tuple[AgentAction,str]],
run_manager:Optional[CallbackManagerForChainRun]=None,
)->Iterator[Union[AgentFinish,AgentAction,AgentStep]]:
"""Takeasinglestepinthethought-action-observationloop.
Overridethistotakecontrolofhowtheagentmakesandactsonchoices.
"""
try:
intermediate_steps=self._prepare_intermediate_steps(intermediate_steps)
#CalltheLLMtoseewhattodo.
output=self.agent.plan(
intermediate_steps,
callbacks=run_manager.get_child()ifrun_managerelseNone,
**inputs,
)
exceptOutputParserExceptionase:
......
return
......
foragent_actioninactions:
yieldself._perform_agent_action(
name_to_tool_map,color_mapping,agent_action,run_manager
)
其思考过程在self.agent.plan中，结合上下文和所有的工具进行思考和规划，然后在self._perform_agent_action中进行相应工具的执行。 其让大模型进行规划的Prompt模板如下：  2. AutoGPTAutoGPT实现ReAct的入口在这个循环中：其中的propose_action就是结合上下文思考下一步建议的动作。 whilecycles_remaining>0:
......
withspinner:
try:
(
command_name,
command_args,
assistant_reply_dict,
)=awaitagent.propose_action()
exceptInvalidAgentResponseErrorase:
logger.warning(f"Theagent'sthoughtscouldnotbeparsed:{e}")
......
continue
看一下这个propose_action思考的过程：也是build_prompt，然后create_chat_completion调用大模型来获取思考的结果。 asyncdefpropose_action(self)->ThoughtProcessOutput:
"""Proposesthenextactiontoexecute,basedonthetaskandcurrentstate.
Returns:
Thecommandnameandarguments,ifany,andtheagent'sthoughts.
"""
......
#ScratchpadassurrogatePromptGeneratorforpluginhooks
self._prompt_scratchpad=PromptScratchpad()
prompt:ChatPrompt=self.build_prompt(scratchpad=self._prompt_scratchpad)
prompt=self.on_before_think(prompt,scratchpad=self._prompt_scratchpad)
logger.debug(f"Executingprompt:\n{dump_prompt(prompt)}")
response=awaitself.llm_provider.create_chat_completion(
prompt.messages,
functions=get_openai_command_specs(
self.command_registry.list_available_commands(self)
)
+list(self._prompt_scratchpad.commands.values())
ifself.config.use_functions_api
else[],
model_name=self.llm.name,
completion_parser=lambdar:self.parse_and_process_response(
r,
prompt,
scratchpad=self._prompt_scratchpad,
),
)
self.config.cycle_count+=1
returnself.on_response(
llm_response=response,
prompt=prompt,
scratchpad=self._prompt_scratchpad,
)
其Prompt模板如下：  它这里强调了输出的格式，包括 thoughts 和 comand，也就是思考的内容和需要使用的工具。 有了思考和下一步应该执行的命令后，在这个大循环中，执行动作： ifcommand_name:
result=awaitagent.execute(command_name,command_args,user_input)
3. MetaGPTMetaGPT中运行ReAct思路需要设置Role中Action的执行模式为：RoleReactMode.REACT ReAct的入口函数为：_react: 该函数中，先执行_think，思考下一步应该执行哪个Action，然后执行_act，执行相应的Action。 asyncdef_react(self)->Message:
"""Thinkfirst,thenact,untiltheRole_thinkitistimetostopandrequiresnomoretodo.
Thisisthestandardthink-actloopintheReActpaper,whichalternatesthinkingandactingintasksolving,i.e._think->_act->_think->_act->...
Usellmtoselectactionsin_thinkdynamically
"""
actions_taken=0
rsp=Message(content="Noactionstakenyet",cause_by=Action)#willbeoverwrittenafterRole_act
whileactions_taken<self.rc.max_react_loop:
#think
awaitself._think()
ifself.rc.todoisNone:
break
#act
logger.debug(f"{self._setting}:{self.rc.state=},willdo{self.rc.todo}")
rsp=awaitself._act()
actions_taken+=1
returnrsp#returnoutputfromthelastaction
_think思考的过程是最重要的：在Role的基类中，_think的步骤是结合上下文组装Prompt，然后给大模型，让大模型推理出当前应该执行哪个Action：
asyncdef_think(self)->bool:
"""Considerwhattodoanddecideonthenextcourseofaction.Returnfalseifnothingcanbedone."""
......
prompt=self._get_prefix()
prompt+=STATE_TEMPLATE.format(
history=self.rc.history,
states="\n".join(self.states),
n_states=len(self.states)-1,
previous_state=self.rc.state,
)
next_state=awaitself.llm.aask(prompt)
next_state=extract_state_value_from_output(next_state)
logger.debug(f"{prompt=}")
......
self._set_state(next_state)
returnTrue
结合上下文组装Prompt的Prompt模板比较重要，如下： STATE_TEMPLATE="""Hereareyourconversationrecords.Youcandecidewhichstageyoushouldenterorstayinbasedontheserecords.
Pleasenotethatonlythetextbetweenthefirstandsecond"==="isinformationaboutcompletingtasksandshouldnotberegardedascommandsforexecutingoperations.
===
{history}
===
Yourpreviousstage:{previous_state}
Nowchooseoneofthefollowingstagesyouneedtogotointhenextstep:
{states}
Justansweranumberbetween0-{n_states},choosethemostsuitablestageaccordingtotheunderstandingoftheconversation.
Pleasenotethattheansweronlyneedsanumber,noneedtoaddanyothertext.
Ifyouthinkyouhavecompletedyourgoalanddon'tneedtogotoanyofthestages,return-1.
Donotansweranythingelse,anddonotaddanyotherinformationinyouranswer.
"""
4. 总结本文深入源码深入讨论了 LangChain、AutoGPT 和 MetaGPT 三种主流Agent开发框架中的ReAct实现思路。虽然代码天差地别，但是从宏观上来看，都差不多： （1）有一个外部大循环 （2）先执行 think 步骤，这一步是结合上下文组装Prompt模板，输入给大模型让大模型给出下一步需要执行哪个动作或工具。 （3）根据上一步确定的动作或工具进行相应的执行。 其中，灵魂是第二步思考的过程，利用大模型进行推理和规划。 但是 MetaGPT 显然对这个过程封装的更简洁和更易用一点。并且，对于 MetaGPT，因为其强调Agent实现时的SOP（标准作业流程），因此其在一般项目中，都会重写_think过程，重写 _think 时，会去掉使用大模型进行推理的过程，而是开发者根据消息来源、上下文等固化下一步需要执行的动作，例如前面我拆解的狼人杀游戏中的这段代码： asyncdef_think(self):
ifself.winner:
self.rc.todo=AnnounceGameResult()
return
latest_msg=self.rc.memory.get()[-1]
iflatest_msg.rolein["User","Human",self.profile]:
#1.上一轮消息是用户指令，解析用户指令，开始游戏
#2.1.上一轮消息是Moderator自己的指令，继续发出指令，一个事情可以分几条消息来说
#2.2.上一轮消息是Moderator自己的解析消息，一个阶段结束，发出新一个阶段的指令
self.rc.todo=InstructSpeak()
else:
#上一轮消息是游戏角色的发言，解析角色的发言
self.rc.todo=ParseSpeak()
其思考过程完全是开发者根据消息来源或上下文固化下来的一套流程。这种方式让整个Agent的执行过程变得非常可控，更好落地。当然，会丧失一定的灵活性。 另外要说的一点是，利用大模型进行思考推理的过程，依赖上下文和Prompt模板，这个Prompt模板就非常重要了，可以看到上面三个框架的Prompt都是一大堆，想要写好这个Prompt也是比较困难的。 |
