1
论文：ReAct: Synergizing Reasoning and Acting
2
      in Language Models
3
作者：Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du,
4
      Ishaan Gulrajani, Karthik Narasimhan, Yuan Cao
5
机构：Princeton University, Google Research
6
发表：ICLR 2023
7
引用：5000+ 次

1
class ReActAgent:
2
    """ReAct Agent 实现"""
3

4
    def __init__(self, llm, tools, max_iterations=10):
5
        self.llm = llm
6
        self.tools = {tool.name: tool for tool in tools}
7
        self.max_iterations = max_iterations
8

9
    def run(self, task: str) -> str:
10
        """执行 ReAct 循环"""
11
        history = []
12
        prompt = self._build_prompt(task)
13

14
        for i in range(self.max_iterations):
15
            # 1. LLM 生成 Thought 和 Action
16
            response = self.llm.generate(prompt + self._format_history(history))
17
            thought, action, action_input = self._parse_response(response)
18

19
            history.append({
20
                "thought": thought,
21
                "action": action,
22
                "action_input": action_input
23
            })
24

25
            # 2. 检查是否完成
26
            if action == "Finish":
27
                return action_input
28

29
            # 3. 执行 Action
30
            if action in self.tools:
31
                observation = self.tools[action].run(action_input)
32
            else:
33
                observation = f"Error: Unknown action {action}"
34

35
            history[-1]["observation"] = observation
36

37
        return "Maximum iterations reached"
38

39
    def _build_prompt(self, task: str) -> str:
40
        """构建 ReAct 提示词"""
41
        return f"""Answer the following questions as best you can. You have access to the following tools:
42

43
{self._format_tools()}
44

45
Use the following format:
46

47
Question: the input question you must answer
48
Thought: you should always think about what to do
49
Action: the action to take, should be one of [{self._tool_names()}]
50
Action Input: the input to the action
51
Observation: the result of the action
52
... (this Thought/Action/Action Input/Observation can repeat N times)
53
Thought: I now know the final answer
54
Final Answer: the final answer to the original input question
55

56
Begin!
57

58
Question: {task}
59
"""
60

61
    def _parse_response(self, response: str):
62
        """解析 LLM 响应"""
63
        thought = ""
64
        action = ""
65
        action_input = ""
66

67
        lines = response.strip().split("\n")
68
        for line in lines:
69
            if line.startswith("Thought:"):
70
                thought = line.replace("Thought:", "").strip()
71
            elif line.startswith("Action:"):
72
                action = line.replace("Action:", "").strip()
73
            elif line.startswith("Action Input:"):
74
                action_input = line.replace("Action Input:", "").strip()
75

76
        return thought, action, action_input

1
| 方法          | HotpotQA    | FEVER       | 特点            |
2
|---------------|-------------|-------------|------------------|
3
| Act-only      | 28.0%       | 60.9%       | 行动盲目        |
4
| Reason-only   | 29.4%       | 56.3%       | 缺乏外部信息    |
5
| ReAct         | 35.1%       | 64.0%       | 协同最优        |
6
| ReAct + Reflexion | 37.2%   | 66.5%       | 加反思更强      |
7

8
关键发现：
9
• ReAct 显著优于单一模式
10
• 推理和行动相互促进
11
• 外部信息减少幻觉

1
from dataclasses import dataclass
2
from typing import Callable, Dict, Any
3

4
@dataclass
5
class Tool:
6
    """工具定义"""
7
    name: str
8
    description: str
9
    func: Callable
10
    parameters: Dict[str, Any]  # JSON Schema
11

12
# 常用工具示例
13
search_tool = Tool(
14
    name="search",
15
    description="Search for information on the web",
16
    func=search_function,
17
    parameters={
18
        "type": "object",
19
        "properties": {
20
            "query": {
21
                "type": "string",
22
                "description": "The search query"
23
            }
24
        },
25
        "required": ["query"]
26
    }
27
)
28

29
calculate_tool = Tool(
30
    name="calculate",
31
    description="Perform mathematical calculations",
32
    func=calculate_function,
33
    parameters={
34
        "type": "object",
35
        "properties": {
36
            "expression": {
37
                "type": "string",
38
                "description": "The mathematical expression to evaluate"
39
            }
40
        },
41
        "required": ["expression"]
42
    }
43
)
44

45
lookup_tool = Tool(
46
    name="lookup",
47
    description="Look up a specific entity in a knowledge base",
48
    func=lookup_function,
49
    parameters={
50
        "type": "object",
51
        "properties": {
52
            "entity": {
53
                "type": "string",
54
                "description": "The entity to look up"
55
            }
56
        },
57
        "required": ["entity"]
58
    }
59
)

1
def reflexion_react(agent, task, max_attempts=3):
2
    """Reflexion + ReAct"""
3
    reflections = []
4

5
    for attempt in range(max_attempts):
6
        # 执行 ReAct
7
        result = agent.run(task)
8
        success = evaluate(result, task)
9

10
        if success:
11
            return result
12

13
        # 反思失败原因
14
        reflection = agent.reflect(task, result)
15
        reflections.append(reflection)
16

17
        # 更新提示词，加入反思
18
        agent.update_prompt(reflections)
19

20
    return result