从零构建一个简单智能体：将理论真正落到代码实践#

1
import java.util.ArrayList;
2
import java.util.HashMap;
3
import java.util.List;
4
import java.util.Map;
5
import java.util.regex.Matcher;
6
import java.util.regex.Pattern;
7

8
public class ReActAgent {
9

10
    private final SiliconFlowClient llmClient;
11
    private final Map<String, Tool> toolRegistry = new HashMap<>();
12

13
    private static final String SYSTEM_PROMPT = """
14
            你是一个全能智能体。你可以使用以下工具来解决用户的问题：
15
            - WeatherTool: 输入城市名称，返回该城市的当前天气情况。
16

17
            请你务必严格按照以下格式思考和输出（格式极其重要）：
18
            Thought: 思考为了解决问题，下一步我需要做什么。
19
            Action: 决定使用的工具名称，必须是 [WeatherTool] 中的一个。如果没有工具，或者不需要工具，直接输出 Final Answer。
20
            Action Input: 传入工具的参数。
21
            Observation: 工具执行后的返回结果。（这部分由系统生成，你不需要输出）
22
            ... (上述流程可以重复多次)
23
            Final Answer: 最终回答用户的问题。
24
            """;
25

26
    public ReActAgent(SiliconFlowClient client) {
27
        this.llmClient = client;
28
    }
29

30
    public void registerTool(Tool tool) {
31
        toolRegistry.put(tool.getName(), tool);
32
    }
33

34
    public void run(String query, int maxIterations) {
35
        List<SiliconFlowClient.Message> messages = new ArrayList<>();
36
        messages.add(new SiliconFlowClient.Message("system", SYSTEM_PROMPT));
37
        messages.add(new SiliconFlowClient.Message("user", query));
38

39
        System.out.println("🚀 【任务开始】: " + query + "\n");
40
        System.out.println("----------------------------------------");
41

42
        Pattern actionPattern = Pattern.compile("Action:\\s*(.*)");
43
        Pattern inputPattern = Pattern.compile("Action Input:\\s*(.*)");
44

45
        for (int i = 0; i < maxIterations; i++) {
46
            System.out.println("🧠 [Agent 思考中...]");
47
            String response = llmClient.chat(messages);
48
            System.out.println(response);
49

50
            messages.add(new SiliconFlowClient.Message("assistant", response));
51

52
            if (response.contains("Final Answer:")) {
53
                System.out.println("----------------------------------------");
54
                System.out.println("✅ 任务圆满完成！");
55
                return;
56
            }
57

58
            Matcher actionMatcher = actionPattern.matcher(response);
59
            Matcher inputMatcher = inputPattern.matcher(response);
60

61
            if (actionMatcher.find() && inputMatcher.find()) {
62
                String toolName = actionMatcher.group(1).trim();
63
                String toolInput = inputMatcher.group(1).trim();
64

65
                String observation;
66
                if (toolRegistry.containsKey(toolName)) {
67
                    System.out.println("⚙️ [系统拦截]: 发现工具调用请求 -> 工具: [" + toolName + "], 参数: [" + toolInput + "]");
68
                    try {
69
                        observation = toolRegistry.get(toolName).execute(toolInput);
70
                    } catch (Exception e) {
71
                        observation = "执行错误: " + e.getMessage();
72
                    }
73
                } else {
74
                    observation = "错误: 未找到该工具 [" + toolName + "]";
75
                }
76

77
                System.out.println("🔍 [工具返回]: " + observation + "\n");
78
                messages.add(new SiliconFlowClient.Message("user", "Observation: " + observation));
79
            } else {
80
                System.out.println("⚠️ [系统警告]: 模型未按照要求格式输出，强制纠偏。");
81
                messages.add(new SiliconFlowClient.Message("user", "格式错误！请严格遵守 Thought / Action / Action Input 或 Final Answer 的格式规范。"));
82
            }
83
        }
84
        System.out.println("❌ 达到最大思考轮数限制 (" + maxIterations + ")，任务被系统强制熔断。");
85
    }
86

87
    public interface Tool {
88
        String getName();
89
        String execute(String input);
90
    }
91
}

1
public class AgentTest {
2
    public static void main(String[] args) {
3
        SiliconFlowClient client = new SiliconFlowClient();
4
        ReActAgent agent = new ReActAgent(client);
5

6
        agent.registerTool(new ReActAgent.Tool() {
7
            @Override
8
            public String getName() { return "WeatherTool"; }
9

10
            @Override
11
            public String execute(String input) {
12
                if (input.contains("北京")) {
13
                    return "当前气温 25℃，晴朗，适合户外活动。";
14
                } else if (input.contains("伦敦")) {
15
                    return "当前气温 15℃，阴有小雨，建议带伞。";
16
                }
17
                return "未查到该城市的天气数据。";
18
            }
19
        });
20

21
        agent.run("我想去北京旅游，帮我查查天气，并告诉我需不需要带防晒霜。", 5);
22
    }
23
}

1
import com.google.gson.Gson;
2
import com.google.gson.JsonArray;
3
import com.google.gson.JsonElement;
4
import java.util.ArrayList;
5
import java.util.List;
6

7
public class PlanAndSolveAgent {
8

9
    private final SiliconFlowClient llmClient;
10
    private final Gson gson = new Gson();
11

12
    private static final String PLANNING_PROMPT_TEMPLATE = """
13
            你是一个顶层的战略规划专家。面对用户的问题，你的任务是将其拆解为多个逻辑严密、环环相扣的执行步骤。
14
            【限制条件】
15
            你必须且只能输出一个标准的 JSON 字符串数组，不能包含任何 markdown 标记（如 ```json）、任何前导词或解释性文字。
16
            【输出示例】
17
            ["步骤1：收集A数据","步骤2：对比B数据并分析差异","步骤3：总结并输出最终结论"]
18
            现在，请拆解以下用户任务：
19
            %s
20
            """;
21

22
    private static final String SOLVING_PROMPT_TEMPLATE = """
23
            你是一个严谨的执行者。目前我们正在携手完成一个宏大任务。
24
            【原始任务】: %s
25
            【全局规划】: %s
26
            【历史已完成步骤及结果】:
27
            %s
28
            ----------------------------------------
29
            现在，请专注于执行当前步骤：【%s】
30
            请基于上述历史上下文，给出这一步的详细执行结果。
31
            """;
32

33
    public PlanAndSolveAgent(SiliconFlowClient client) {
34
        this.llmClient = client;
35
    }
36

37
    public void run(String query) {
38
        System.out.println("🚀 【Plan-and-Solve 任务启动】: " + query + "\n");
39

40
        // ==========================================
41
        // 阶段一：战略规划 (Planning Phase)
42
        // ==========================================
43
        System.out.println("📝 [Phase 1: 正在制定全局战略计划...]");
44
        String planningPrompt = String.format(PLANNING_PROMPT_TEMPLATE, query);
45
        List<SiliconFlowClient.Message> planMessages = new ArrayList<>();
46
        planMessages.add(new SiliconFlowClient.Message("user", planningPrompt));
47

48
        String rawPlanJson = llmClient.chat(planMessages).trim();
49
        List<String> planSteps = parsePlanJson(rawPlanJson);
50

51
        System.out.println("🧭 [系统生成的行军路线图]:");
52
        for (int i = 0; i < planSteps.size(); i++) {
53
            System.out.printf("  %d. %s\n", i + 1, planSteps.get(i));
54
        }
55
        System.out.println("----------------------------------------\n");
56

57
        // ==========================================
58
        // 阶段二：分步履约 (Solving Phase)
59
        // ==========================================
60
        System.out.println("🛠️ [Phase 2: 正在按照计划步步推进...]");
61
        StringBuilder contextHistory = new StringBuilder();
62

63
        for (int i = 0; i < planSteps.size(); i++) {
64
            String currentStep = planSteps.get(i);
65
            System.out.printf("\n🏃 [正在执行第 %d/%d 步]: %s\n", i + 1, planSteps.size(), currentStep);
66

67
            String solvingPrompt = String.format(
68
                    SOLVING_PROMPT_TEMPLATE,
69
                    query,
70
                    planSteps.toString(),
71
                    contextHistory.length() == 0 ? "（暂无）" : contextHistory.toString(),
72
                    currentStep
73
            );
74

75
            List<SiliconFlowClient.Message> solveMessages = new ArrayList<>();
76
            solveMessages.add(new SiliconFlowClient.Message("user", solvingPrompt));
77

78
            String stepResult = llmClient.chat(solveMessages);
79
            System.out.println("🎨 [本步产出]:\n" + stepResult);
80

81
            contextHistory.append(String.format("[已完成步骤 %d] %s -> 结果:\n%s\n\n", i + 1, currentStep, stepResult));
82
        }
83
        System.out.println("----------------------------------------");
84
        System.out.println("🏁 所有规划步骤执行完毕，长任务圆满闭环！");
85
    }
86

87
    private List<String> parsePlanJson(String rawJson) {
88
        List<String> steps = new ArrayList<>();
89
        try {
90
            if (rawJson.startsWith("```json")) {
91
                rawJson = rawJson.replace("```json", "").replace("```", "").trim();
92
            }
93
            JsonArray array = gson.fromJson(rawJson, JsonArray.class);
94
            for (JsonElement element : array) {
95
                steps.add(element.getAsString());
96
            }
97
        } catch (Exception e) {
98
            System.err.println("❌ 计划解析失败，降级采用兜底单步计划。错误原因: " + e.getMessage());
99
            steps.add("直接根据原始诉求尝试生成最终答案");
100
        }
101
        return steps;
102
    }
103
}

1
public class PlanAndSolveTest {
2
    public static void main(String[] args) {
3
        SiliconFlowClient client = new SiliconFlowClient();
4
        PlanAndSolveAgent agent = new PlanAndSolveAgent(client);
5

6
        String complexTask = "帮我撰写一份《2026年第一季度新能源汽车行业洞察短报》。" +
7
                "要求包含三个核心模块：1. 全球销量宏观大势；2. 固态电池技术的突围进展；3. 当前车企出海面临的关税壁垒挑战。";
8

9
        agent.run(complexTask);
10
    }
11
}

1
import java.util.ArrayList;
2
import java.util.List;
3
import java.util.Optional;
4

5
public class AgentMemory {
6
    public record MemoryRecord(String type, String content) {}
7
    private final List<MemoryRecord> records = new ArrayList<>();
8

9
    public void addRecord(String type, String content) {
10
        records.add(new MemoryRecord(type, content));
11
        System.out.printf("📝 记忆仓更新：成功归档一条 [%s] 类型的核心快照。\n", type);
12
    }
13

14
    public String getTrajectory() {
15
        List<String> trajectoryParts = new ArrayList<>();
16
        for (MemoryRecord record : records) {
17
            if ("execution".equals(record.type())) {
18
                trajectoryParts.add("--- 上一轮尝试的代码 ---\n" + record.content());
19
            } else if ("reflection".equals(record.type())) {
20
                trajectoryParts.add("--- 严格评审员反馈 ---\n" + record.content());
21
            }
22
        }
23
        return String.join("\n\n", trajectoryParts);
24
    }
25

26
    public Optional<String> getLastExecution() {
27
        for (int i = records.size() - 1; i >= 0; i--) {
28
            MemoryRecord r = records.get(i);
29
            if ("execution".equals(r.type())) {
30
                return Optional.of(r.content());
31
            }
32
        }
33
        return Optional.empty();
34
    }
35
}

1
import java.util.ArrayList;
2
import java.util.List;
3

4
public class ReflectionAgent {
5

6
    private final SiliconFlowClient llmClient;
7
    private final AgentMemory memory = new AgentMemory();
8
    private final int maxIterations;
9

10
    private static final String INITIAL_PROMPT_TEMPLATE = """
11
            你是一位资神的 Python 程序员。请根据以下要求，编写一个 Python 函数。
12
            你的代码必须包含完整的函数签名、文档字符串，并遵循 PEP 8 编码规范。
13
            【要求】: %s
14
            请直接输出代码，绝对不要包含任何额外的Markdown包裹框之外的文字解释。
15
            """;
16

17
    private static final String REFLECT_PROMPT_TEMPLATE = """
18
            你是一位极其严格的代码评审专家和首席算法工程师，对代码的运行时性能和空间复杂度有极致的追求。
19
            你的任务是严厉审查以下 Python 代码，并专注于找出其在【算法效率】上的致命瓶颈。
20
            # 原始任务: %s
21
            # 待审查的代码:
22
            %s
23
            请冷酷分析该代码的时间复杂度，并思考是否存在一种算法上更优的解法来带来量级上的性能提升。
24
            如果有，请清晰指出当前算法的软肋，并给出明确、具体的改进算法路线（例如提示其使用某种筛法）。
25
            【极其重要】: 只有当代码在算法、工程层面均已达到无懈可击的最优状态时，你才能回答“无需改进”。
26
            请直接输出你的反馈意见，不要带任何前导客套话。
27
            """;
28

29
    private static final String REFINE_PROMPT_TEMPLATE = """
30
            你是一位追求极致的 Python 程序员。现在你需要根据代码评审专家的专业意见，对你上一轮的代码进行彻底的重构重写。
31
            # 原始任务: %s
32
            # 你上一轮尝试的代码:
33
            %s
34
            # 评审员给你的修改意见:
35
            %s
36
            请严格基于上述反馈，生成一个完全优化后的全新版本代码。
37
            代码必须包含完整的函数签名、详细的注释，并遵循 PEP 8 规范。直接输出代码，不包含任何废话。
38
            """;
39

40
    public ReflectionAgent(SiliconFlowClient client, int maxIterations) {
41
        this.llmClient = client;
42
        this.maxIterations = maxIterations;
43
    }
44

45
    public void run(String task) {
46
        System.out.println("🚀 【Reflection 自我进化任务启动】: " + task);
47

48
        System.out.println("\n🎬 [Round 0] 正在生成初始初稿...");
49
        String initPrompt = String.format(INITIAL_PROMPT_TEMPLATE, task);
50
        String initialCode = callLLM(initPrompt);
51
        memory.addRecord("execution", initialCode);
52
        System.out.println("🤖 [初版产出]:\n" + initialCode);
53

54
        for (int i = 1; i <= maxIterations; i++) {
55
            System.out.printf("\n🔄 [进行第 %d / %d 轮自我进化循环]\n", i, maxIterations);
56

57
            System.out.println("🔍 [评审员上线]: 正在进行深度代码审计...");
58
            String lastCode = memory.getLastExecution().orElse("");
59
            String reflectPrompt = String.format(REFLECT_PROMPT_TEMPLATE, task, lastCode);
60
            String feedback = callLLM(reflectPrompt);
61
            memory.addRecord("reflection", feedback);
62
            System.out.println("👺 [批判性意见]:\n" + feedback);
63

64
            if (feedback.contains("无需改进")) {
65
                System.out.println("\n🎉 【进化终止】: 评审员认为当前代码已臻完美，无懈可击！");
66
                break;
67
            }
68

69
            System.out.println("🛠️ [程序员上线]: 接收反馈，正在进行代码重构...");
70
            String refinePrompt = String.format(REFINE_PROMPT_TEMPLATE, task, lastCode, feedback);
71
            String refinedCode = callLLM(refinePrompt);
72
            memory.addRecord("execution", refinedCode);
73
            System.out.println("✨ [进化版代码产出]:\n" + refinedCode);
74
        }
75
        System.out.println("\n🏁 【最终交付代码】:\n" + memory.getLastExecution().orElse("无产出"));
76
    }
77

78
    private String callLLM(String prompt) {
79
        List<SiliconFlowClient.Message> msgs = new ArrayList<>();
80
        msgs.add(new SiliconFlowClient.Message("user", prompt));
81
        return llmClient.chat(msgs);
82
    }
83
}