AI 智能体构建教程：从概念到实战实现

欢迎来到本教程，我们将深入探讨AI智能体的构建方法，帮助您掌握如何开发具有自主决策能力的AI系统。本教程聚焦于核心概念、关键技术和实战项目，通过逐步引导，确保您能理解和实现一个高效的AI智能体。主要内容包括AI智能体的概念、关键技术（如CoT思维链和ReAct模式）、多种应用方式、OpenManus框架的原理、自主实现智能体、工作流编排以及A2A协议。让我们一步步开始吧！

1. AI 智能体概念与特点

AI智能体（Agent）是一种能够感知环境、进行推理并采取行动以实现特定目标的系统。它模拟人类智能，具备自主性、适应性和学习能力。核心特点包括：

• 自主决策：智能体独立分析输入并生成输出，无需人为干预。
• 环境交互：通过传感器感知环境，并通过执行器执行动作，例如在游戏中移动角色或处理数据。
• 目标导向：基于预设目标优化行为，如最大化收益或最小化误差。
• 学习能力：利用机器学习算法（如强化学习）从经验中改进决策。

例如，一个简单的智能体模型可表示为状态-动作映射：给定状态 $s$，智能体选择动作 $a$ 以最大化奖励 $r$。公式化表示为： $$ \arg\max_a Q(s,a) $$ 其中 $Q(s,a)$ 是动作值函数。

2. 智能体实现关键技术

实现高效AI智能体依赖于多种核心技术，包括CoT（Chain-of-Thought）思维链和ReAct（Reasoning and Acting）模式。这些技术帮助智能体进行复杂推理和行动规划。

• CoT思维链：通过逐步推理链处理问题，提升决策准确性。例如，解决数学问题时，智能体先分解步骤：

  • 输入问题：计算 $x + y = 10$ 和 $x - y = 2$ 的解。
  • 推理链：设方程1为 $x + y = 10$，方程2为 $x - y = 2$。相加得 $2x = 12$，所以 $x = 6$；代入得 $y = 4$。
  • 输出结果：$x=6$, $y=4$。

• ReAct模式：结合推理（Reasoning）和行动（Acting），使智能体在动态环境中自适应。ReAct框架包括：

  • 观察：获取环境状态。
  • 思考：推理最佳行动。
  • 行动：执行决策。
  • 反馈：评估结果并学习。

例如，在游戏AI中，ReAct循环可表示为：

def react_cycle(state):
    while not goal_achieved(state):
        observation = sense_environment(state)
        reasoning = think(observation)  # 基于CoT推理
        action = decide_action(reasoning)
        state = take_action(action, state)
        learn_from_feedback(state)  # 更新模型
    return state

这些技术显著提升智能体的泛化能力和效率，实测显示错误率降低30%以上。

3. AI 智能体核心实现

思考 → 行动 → 观察结果 → 再思考（在循环中完成）

1、BaseAgent

public String run(String userPrompt) {
    // 1. 状态和输入校验
    if (this.state != AgentState.IDLE) { ... }
    if (StringUtil.isBlank(userPrompt)) { ... }

    // 2. 状态更新和消息记录
    state = AgentState.RUNNING;
    messageList.add(new UserMessage(userPrompt));

    List<String> results = new ArrayList<>();
    try {
        // 3. 主循环：步数控制 + 状态检查
        for (int i = 0; i < maxSteps && state != AgentState.FINISHED; i++) {
            int stepNumber = i + 1;
            currentStep = stepNumber;
            log.info("Executing step " + stepNumber + "/" + maxSteps);

            String stepResult = step();   // 调用子类实现的单步逻辑
            String result = "Step " + stepNumber + ": " + stepResult;
            results.add(result);
        }

        // 4. 循环结束处理
        if (currentStep >= maxSteps) {
            state = AgentState.FINISHED;
            results.add("Terminated: Reached max steps (" + maxSteps + ")");
        }
        return String.join("\n", results);
    } catch (Exception e) {
        state = AgentState.ERROR;
        log.error("Error executing agent", e);
        return "执行错误" + e.getMessage();
    } finally {
        this.cleanup();   // 5. 清理资源
    }
}

2、开发 ReActAgent 类

• 继承自 BaseAgent：继承了父类的状态管理、消息列表、步数控制等基础能力，并重写 step() 方法，融入 ReAct 逻辑。

    
  @EqualsAndHashCode(callSuper = true)  
  @Data  
  public abstract class ReActAgent extends BaseAgent {  
    
        
      public abstract boolean think();  
    
        
      public abstract String act();  
    
        
      @Override  
      public String step() {  
          try {  
              boolean shouldAct = think();  
              if (!shouldAct) {  
                  return "思考完成 - 无需行动";  
              }  
              return act();  
          } catch (Exception e) {  
              
              e.printStackTrace();  
              return "步骤执行失败: " + e.getMessage();  
          }  
      }  
  }
  

  3、开发 ToolCallAgent 类

  @EqualsAndHashCode(callSuper = true)  
  @Data  
  @Slf4j  
  public class ToolCallAgent extends ReActAgent {  
    
      
      private final ToolCallback[] availableTools;  
    
      
      private ChatResponse toolCallChatResponse;  
    
      
      private final ToolCallingManager toolCallingManager;  
    
      
      private final ChatOptions chatOptions;  
    
      public ToolCallAgent(ToolCallback[] availableTools) {  
          super();  
          this.availableTools = availableTools;  
          this.toolCallingManager = ToolCallingManager.builder().build();  
          
          this.chatOptions = DashScopeChatOptions.builder()  
                  .withProxyToolCalls(true)  
                  .build();  
      }  
  }
  

  千万别忘了⁠，我们还需要定义一‌个终止工具，让智能​体可以自行决定任‎务结束。

  1）在 tools 包下新建 TerminateTool：

  public class TerminateTool {  
    
      @Tool(description = """  
              Terminate the interaction when the request is met OR if the assistant cannot proceed further with the task.  
              "When you have finished all the tasks, call this tool to end the work.  
              """)  
      public String doTerminate() {  
          return "任务结束";  
      }  
  }
  

• 2）修改 ToolRegistration，注册中止工具：

  TerminateTool terminateTool = new TerminateTool();  
    
  return ToolCallbacks.from(  
          fileOperationTool,  
          webSearchTool,  
          webScrapingTool,  
          resourceDownloadTool,  
          terminalOperationTool,  
          pdfGenerationTool,  
          terminateTool  
  );
  

  3）完善 ⁠act 方法，当调‌用了终止工具时，修​改 agent 的‎状态为 “已结束”‌：

  ToolResponseMessage toolResponseMessage = (ToolResponseMessage) CollUtil.getLast(toolExecutionResult.conversationHistory());  
  String results = toolResponseMessage.getResponses().stream()  
          .map(response -> "工具 " + response.name() + " 完成了它的任务！结果: " + response.responseData())  
          .collect(Collectors.joining("\n"));  
  
  boolean terminateToolCalled = toolResponseMessage.getResponses().stream()  
          .anyMatch(response -> "doTerminate".equals(response.name()));  
  if (terminateToolCalled) {  
      setState(AgentState.FINISHED);  
  }  
  log.info(results);  
  return results;
  

  4、开发 YuManus 类

  YuManus 是⁠可以直接提供给其他方法调用的 AI‌ 超级智能体实例，继承自 Tool​CallAgent，需要给智能体设‎置各种参数，比如对话客户端 cha‌tClient、工具调用列表等。

  @Component  
  public class YuManus extends ToolCallAgent {  
    
      public YuManus(ToolCallback[] allTools, ChatModel dashscopeChatModel) {  
          super(allTools);  
          this.setName("yuManus");  
          String SYSTEM_PROMPT = """  
                  You are YuManus, an all-capable AI assistant, aimed at solving any task presented by the user.  
                  You have various tools at your disposal that you can call upon to efficiently complete complex requests.  
                  """;  
          this.setSystemPrompt(SYSTEM_PROMPT);  
          String NEXT_STEP_PROMPT = """  
                  Based on user needs, proactively select the most appropriate tool or combination of tools.  
                  For complex tasks, you can break down the problem and use different tools step by step to solve it.  
                  After using each tool, clearly explain the execution results and suggest the next steps.  
                  If you want to stop the interaction at any point, use the `terminate` tool/function call.  
                  """;  
          this.setNextStepPrompt(NEXT_STEP_PROMPT);  
          this.setMaxSteps(20);  
          
          ChatClient chatClient = ChatClient.builder(dashscopeChatModel)  
                  .defaultAdvisors(new MyLoggerAdvisor())  
                  .build();  
          this.setChatClient(chatClient);  
      }  
  }
  

  整体架构分层

我们把智能体拆成几个层次，每一层解决不同的问题：

1. 基础层（BaseAgent）—— 提供骨架

• 负责整个执行流程的驱动（run 方法）；

• 管理状态（空闲、运行中、完成、错误）；

• 控制最大步数，防止无限循环；

• 维护对话历史（消息列表），供后续步骤使用；

• 定义抽象方法 step()，让子类实现具体的单步逻辑。

这一层就像汽车的底盘和发动机，保证了车子能跑，但具体怎么跑由上层决定。

2. 思考-行动层（ReActAgent）—— 拆分每一步

• 继承自 BaseAgent，将单步 step() 拆成两个阶段：

  • think()：根据当前状态（对话历史、工具结果等）进行推理，决定是否需要行动；

  • act()：如果 think() 说要行动，就执行具体动作。

• step() 方法按照“先思考，后行动”的顺序调用它们，并把结果返回给上层循环。

这就像一个人做事：先动脑子想“我要做什么”，然后动手去做。

3. 工具调用层（ToolCallAgent）—— 让 AI 能用工具

• 继承自 ReActAgent，具体实现 think() 和 act()，让 AI 能够调用外部工具。

• think() 的实现：

  • 将当前对话历史（包括系统提示、用户消息、上一步的工具结果）发送给大语言模型（LLM）；

  • 同时告诉 LLM 当前有哪些工具可用（名称、描述、参数格式）；

  • LLM 返回的内容可能包含文本回答，也可能包含工具调用请求（比如“我要调用天气工具，参数是北京”）；

  • 如果返回了工具调用，就保存这些请求，并返回 true 告诉上层需要执行 act()；否则返回 false。

• act() 的实现：

  • 取出上一步保存的工具调用请求；

  • 通过工具管理器（ToolCallingManager）实际执行对应的工具（例如调用天气 API）；

  • 将工具执行的结果封装成一条“工具消息”加入对话历史；

  • 返回执行结果的描述。

• 此外，还加入了死循环检测：如果发现 AI 连续多次输出相同内容，就在下一轮思考前注入一条提示，引导它改变策略。

这一层让 AI 从一个“只会说话”的模型，变成了一个“会动手”的智能体。

4. 具体业务层（如 YuManus）—— 组装配置

• 继承 ToolCallAgent，在构造函数中设置：

  • 可用的工具列表（通过依赖注入传入）；

  • 系统提示词（定义角色和能力）；

  • 下一步提示词（指导 AI 如何拆解任务）；

  • 最大步数（例如 20）；

  • 聊天客户端（绑定具体的 LLM 模型和日志组件）。

• 这一层就像给汽车装上方向盘、座椅和导航，变成一辆可以开的车。

5. 总结

AI 超级智能体是一个由循环驱动的、能够调用外部工具的自主系统。它通过“思考（调用 LLM 决定下一步）→ 行动（执行工具或生成回答）→ 观察（记录结果到记忆）”的反复迭代，逐步完成复杂任务，并内置了状态控制、步数限制、死循环检测等机制来保证稳定运行。

生成前端程序提示词

你是一位专业的前端开发，请帮我根据下列信息来生成对应的前端项目代码。

## 需求

1）主页：用于切换不同的应用

2）页面 1：AI 恋爱大师应用。页面风格为聊天室，上方是聊天记录（用户信息在右边，AI 信息在左边），下方是输入框，进入页面后自动生成一个聊天室 id，用于区分不同的会话。通过 SSE 的方式调用 doChatWithLoveAppSse 接口，实时显示对话内容。

3）页面 2：AI 超级智能体应用。页面风格同页面 1，但是调用 doChatWithManus 接口，也是实时显示对话内容。

## 技术选型

1. Vue3 项目
2. Axios 请求库

## 后端接口信息

接口地址前缀：http://localhost:8123/api

## SpringBoot 后端接口代码

@RestController
@RequestMapping("/ai")
public class AiController {

    @GetMapping(value = "/love_app/chat/sse", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> doChatWithLoveAppSse(String message, String chatId) {
        return loveApp.doChatByStream(message, chatId);
    }

    @GetMapping("/manus/chat")
    public SseEmitter doChatWithManus(String message) {
        YuManus yuManus = new YuManus(allTools, dashscopeChatModel);
        return yuManus.runStream(message);
    }
}