SpringAI构建智能体Manus：CoT与ReAct实践-AI智能范式网

SpringAI构建智能体Manus：CoT与ReAct实践

橙心橙怡·2026-08-23·阅读 22 GEO检测（免费）

SpringAI智能体开发CoT

|难度：普通|阅读约 24 分钟

1. 项目概述：基于SpringAI构建智能体Manus

作为一名长期从事AI应用开发的工程师，我最近完成了一个基于SpringAI框架的智能体项目Manus。这个项目让我深刻体会到，现代AI开发已经从简单的问答系统进化到了能够自主规划、执行复杂任务的智能体时代。

Manus智能体的核心能力包括：

多轮对话记忆与上下文管理
知识库检索增强（RAG）
工具调用与任务执行
流式响应输出

在实际开发过程中，我发现SpringAI框架极大地简化了AI能力的集成，特别是其统一的API设计和丰富的生态支持，让开发者可以专注于业务逻辑而非底层对接。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 智能体核心技术解析

2.1 CoT思维链实现

CoT（Chain of Thought）是让AI像人类一样分步思考的关键技术。在Manus项目中，我通过以下方式实现了CoT：

java复制public class CotReasoningService {
    private static final String COT_PROMPT = """
        你是一个专注于分步推理的助手。对于每个问题，请遵循以下步骤：
        1. 问题分解：将复杂问题拆分为更小的可管理部分
        2. 逐步思考：详细思考每个部分，展示推理过程
        3. 综合结论：整合各部分思考形成完整解决方案
        4. 提供答案：给出最终简洁答案
        
        你的响应应该遵循以下格式：
        思考：[详细思考过程，包括问题分解、每一步的推理和分析]
        答案：[基于思考过程的最终答案，清晰简洁]
        """;

    public String reason(String question) {
        // 构建包含CoT提示的消息链
        List<Message> messages = new ArrayList<>();
        messages.add(new SystemMessage(COT_PROMPT));
        messages.add(new UserMessage(question));
        
        // 调用模型获取响应
        return chatModel.call(new Prompt(messages))
               .getResult()
               .getOutput()
               .getText();
    }
}

实际使用中发现，明确的步骤指示和输出格式要求能显著提升模型推理质量。建议在系统提示中详细说明期望的思考过程。

2.2 Agent Loop工作机制

Agent Loop是智能体自主执行的核心机制。我设计了一个带状态管理的循环控制器：

java复制public class AgentLoopController {
    private static final int MAX_ITERATIONS = 10;
    
    public String executeTask(String initialTask) {
        StringBuilder executionLog = new StringBuilder();
        String currentState = initialTask;
        int iteration = 0;
        
        while (iteration < MAX_ITERATIONS && !"COMPLETED".equals(currentState)) {
            iteration++;
            
            // 1. 推理下一步行动
            String thought = reasonNextStep(currentState);
            executionLog.append("Step ").append(iteration)
                       .append(" - Thought: ").append(thought).append("\n");
            
            // 2. 执行动作
            String actionResult = executeAction(thought);
            executionLog.append("Step ").append(iteration)
                       .append(" - Action Result: ").append(actionResult).append("\n");
            
            // 3. 更新状态
            currentState = evaluateState(actionResult);
        }
        
        if (iteration >= MAX_ITERATIONS) {
            executionLog.append("Reached maximum iterations: ").append(MAX_ITERATIONS);
        }
        
        return executionLog.toString();
    }
    
    // 其他辅助方法...
}

关键设计考虑：

设置最大迭代次数防止无限循环
每个循环包含推理→执行→状态评估三个阶段
详细记录执行过程便于调试

2.3 ReAct模式实现

ReAct模式结合了推理(Reason)和行动(Act)的循环。这是我的实现方案：

java复制public class ReActEngine {
    public String processTask(String taskDescription) {
        String observation = taskDescription;
        StringBuilder processLog = new StringBuilder();
        
        for (int step = 1; step <= 5; step++) {
            // 推理阶段
            String thought = "基于当前信息，下一步应该：" + 
                           reasoner.generateThought(observation);
            processLog.append("Step ").append(step)
                     .append(" Thought: ").append(thought).append("\n");
            
            // 行动阶段
            String action = actionPlanner.determineAction(thought);
            processLog.append("Step ").append(step)
                     .append(" Action: ").append(action).append("\n");
            
            // 观察阶段
            observation = toolExecutor.execute(action);
            processLog.append("Step ").append(step)
                     .append(" Observation: ").append(observation).append("\n");
            
            if (isTaskComplete(observation)) {
                processLog.append("Task completed successfully after ")
                         .append(step).append(" steps");
                break;
            }
        }
        
        return processLog.toString();
    }
}

实际应用中发现，良好的工具描述和清晰的行动指示对ReAct效果至关重要。建议为每个工具编写详细的说明文档。

3. SpringAI集成实践

3.1 基础环境配置

首先需要在项目中引入SpringAI依赖：

xml复制<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
    <version>1.0.0</version>
</dependency>

配置文件示例（application.yml）：

yaml复制ai:
  dashscope:
    api-key: your-api-key
    chat:
      options:
        model: qwen3-max
    embedding:
      options:
        model: text-embedding-v4
        dimensions: 1024

3.2 记忆系统实现

智能体的记忆功能通过ChatMemory接口实现。我选择Redis作为持久化存储：

java复制@Configuration
public class MemoryConfig {
    
    @Bean
    public ChatMemory chatMemory(RedisTemplate<String, Object> redisTemplate) {
        return new RedisChatMemory(redisTemplate) {
            @Override
            public void add(String conversationId, Message message) {
                // 限制最大历史消息数
                if (getMessages(conversationId).size() >= 20) {
                    removeOldestMessage(conversationId);
                }
                super.add(conversationId, message);
            }
        };
    }
}

生产环境中需要注意：

设置合理的消息过期时间

限制单会话历史消息数量

考虑敏感信息的存储安全

3.3 知识库集成（RAG）

完整的RAG实现包括文档处理、向量存储和检索增强：

java复制@Configuration
@Slf4j
public class RAGConfig {
    
    @Bean
    public VectorStore vectorStore(EmbeddingModel embeddingModel) {
        // 使用PGVector作为生产级向量数据库
        return PgVectorStore.builder(jdbcTemplate, embeddingModel)
                .dimensions(1024)
                .distanceType(COSINE_DISTANCE)
                .initializeSchema(true)
                .build();
    }
    
    @Bean
    public CommandLineRunner initKnowledgeBase(
            VectorStore vectorStore, 
            ResourcePatternResolver resourceResolver) {
        return args -> {
            // 加载并处理文档
            List<Document> documents = new PdfDocumentLoader(resourceResolver)
                    .load("classpath:knowledge/*.pdf");
                    
            // 文本分块处理
            List<Document> chunks = new TextSplitter()
                    .splitDocuments(documents, 512);
                    
            // 存入向量库
            vectorStore.add(chunks);
            log.info("Loaded {} document chunks into vector store", chunks.size());
        };
    }
}

4. 工具调用深度实践

4.1 工具定义与注册

SpringAI支持通过注解方式定义工具：

java复制@Slf4j
public class FileTools {
    
    @Tool(name = "file_reader", description = "读取文件内容")
    public String readFile(
            @ToolParam(description = "文件路径") String path) {
        try {
            return FileUtils.readFileToString(new File(path), StandardCharsets.UTF_8);
        } catch (IOException e) {
            log.error("文件读取失败: {}", path, e);
            return "读取文件失败: " + e.getMessage();
        }
    }
    
    @Tool(name = "file_writer", description = "写入文件内容")
    public String writeFile(
            @ToolParam(description = "文件路径") String path,
            @ToolParam(description = "要写入的内容") String content) {
        try {
            FileUtils.writeStringToFile(new File(path), content, StandardCharsets.UTF_8);
            return "文件写入成功";
        } catch (IOException e) {
            log.error("文件写入失败: {}", path, e);
            return "写入文件失败: " + e.getMessage();
        }
    }
}

4.2 安全工具调用

对于高风险工具（如终端命令执行），必须实施严格的安全控制：

java复制public class SecureTerminalTool {
    
    private static final List<String> ALLOWED_COMMANDS = 
        List.of("ls", "pwd", "date", "whoami");
    
    @Tool(name = "terminal", description = "执行终端命令")
    public String executeCommand(
            @ToolParam(description = "要执行的命令") String command) {
        
        // 命令白名单验证
        if (!isCommandAllowed(command)) {
            return "错误: 不允许执行该命令";
        }
        
        try {
            Process process = Runtime.getRuntime().exec(command);
            String result = IOUtils.toString(process.getInputStream(), StandardCharsets.UTF_8);
            int exitCode = process.waitFor();
            
            return exitCode == 0 ? result : "命令执行失败，退出码: " + exitCode;
        } catch (Exception e) {
            return "命令执行出错: " + e.getMessage();
        }
    }
    
    private boolean isCommandAllowed(String command) {
        return ALLOWED_COMMANDS.stream()
                .anyMatch(cmd -> command.trim().startsWith(cmd));
    }
}

4.3 工具组合调用

智能体可以自动组合多个工具完成任务：

java复制public String researchAndSummarize(String topic) {
    // 1. 搜索网络信息
    String searchResults = toolExecutor.execute("web_search", 
        Map.of("query", "最新关于 " + topic + " 的技术发展"));
    
    // 2. 提取关键信息
    String extractedInfo = toolExecutor.execute("info_extractor",
        Map.of("content", searchResults));
    
    // 3. 生成摘要报告
    String summary = toolExecutor.execute("summarizer",
        Map.of("text", extractedInfo, "length", "500字"));
    
    // 4. 保存为PDF
    String pdfPath = "/reports/" + topic + ".pdf";
    toolExecutor.execute("pdf_generator",
        Map.of("content", summary, "output_path", pdfPath));
    
    return "报告已生成并保存为: " + pdfPath;
}

5. 生产环境注意事项

5.1 性能优化

缓存策略：对频繁访问的知识库内容实现缓存

java复制@Cacheable(value = "knowledgeCache", key = "#query")
public List<Document> retrieveKnowledge(String query) {
    // 向量检索逻辑
}

异步处理：耗时操作使用异步非阻塞

java复制@Async
public CompletableFuture<String> asyncToolCall(String toolName, Map<String, Object> params) {
    return CompletableFuture.completedFuture(
        toolExecutor.execute(toolName, params)
    );
}

5.2 安全防护

输入验证：对所有用户输入进行严格过滤

java复制public String sanitizeInput(String input) {
    return StringEscapeUtils.escapeHtml4(input)
            .replaceAll("[\\r\\n\\t]", "");
}

访问控制：基于角色的工具访问权限

java复制@PreAuthorize("hasRole('ADMIN')")
@Tool(name = "admin_tool", description = "管理员工具")
public String adminOperation() {
    // 敏感操作
}

5.3 监控与日志

详细日志记录：

java复制@Aspect
@Component
@Slf4j
public class ToolLoggingAspect {
    
    @Around("@annotation(org.springframework.ai.tool.Tool)")
    public Object logToolExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        String toolName = ((MethodSignature)joinPoint.getSignature()).getMethod()
                .getAnnotation(Tool.class).name();
        
        log.info("工具调用开始 - {}: 参数 {}", toolName, joinPoint.getArgs());
        long start = System.currentTimeMillis();
        
        try {
            Object result = joinPoint.proceed();
            log.info("工具调用成功 - {}: 耗时 {}ms", 
                    toolName, System.currentTimeMillis() - start);
            return result;
        } catch (Exception e) {
            log.error("工具调用失败 - {}: {}", toolName, e.getMessage());
            throw e;
        }
    }
}

性能指标收集：

java复制@Bean
public MeterRegistryCustomizer<MeterRegistry> metricsCommonTags() {
    return registry -> registry.config().commonTags(
            "application", "manus-agent",
            "region", System.getenv("REGION")
    );
}

6. 项目演进方向

在实际开发过程中，我发现以下几个值得深入优化的方向：

动态工具加载：实现工具的热插拔，无需重启即可添加新工具

java复制public void registerDynamicTool(ToolDefinition tool) {
    toolRegistry.register(tool);
    updateModelToolList();
}

多智能体协作：构建多个专业智能体协同工作的系统

java复制public String collaborativeTask(String task) {
    String plan = plannerAgent.createPlan(task);
    return executorAgent.executePlan(plan);
}

强化学习优化：基于用户反馈自动优化工具使用策略

java复制public void learnFromFeedback(String sessionId, boolean positive) {
    reinforcementLearner.recordOutcome(
        sessionId, 
        positive ? REWARD : PENALTY
    );
}

可视化开发界面：为非技术用户提供智能体编排界面

这个项目让我深刻认识到，现代AI应用开发已经进入了"智能体时代"。通过SpringAI框架，我们可以相对轻松地构建出具备复杂能力的智能系统。但同时也面临着工具安全、系统稳定性和持续优化等挑战。