最近在技术社区看到一个很有意思的讨论： “目前世界最前沿的AI，只是来测测推箱子、移红点等？” 这个问题看似简单，实则触及了当前AI发展的一个核心矛盾——我们拥有了能生成高清视频、编写复杂代码、进行多轮深度对话的巨型模型，但它们在解决一些经典的、对人类而言“简单”的规划或推理问题时，却常常表现不佳。

这不禁让许多开发者，尤其是刚接触AI应用开发的朋友感到困惑：我们费尽心思调参、微调、构建复杂的工作流，难道只是为了解决一个“推箱子”游戏？AI的能力边界究竟在哪里？作为技术实践者，我们该如何理解并利用这些前沿AI模型，尤其是像Spring AI、Cursor、DeepSeek这类能直接集成到开发流程中的工具？

本文将从一个工程实战的视角，深入探讨这个问题。我们会拆解“推箱子”和“移红点”这类问题对AI模型构成的独特挑战，并以此为契机，系统性地梳理如何利用当前主流的AI开发框架（如Spring AI Alibaba）和AI编程工具（如Cursor、DeepSeek），来构建真正能解决实际业务问题的AI应用。无论你是想了解AI推理的底层逻辑，还是希望将AI能力快速集成到Spring Boot项目中，这篇文章都将提供从理论到代码的完整路径。

1. 背景与核心概念：为什么“简单”问题反而难住了AI？

在深入代码之前，我们首先要理解问题的本质。 “推箱子”（Sokoban）和“移红点”（常指滑块拼图或路径规划问题） 属于经典的规划问题。它们的特点是什么？

  1. 状态空间巨大 ：即使是一个很小的棋盘，所有可能的棋子排列组合（状态）数量也是天文数字。
  2. 需要多步推理和规划 ：解决它不能只靠单步反应，必须前瞻多步，形成一个动作序列。
  3. 依赖符号逻辑和规则 ：每一步都必须严格遵守游戏规则（比如箱子只能推不能拉）。

对于人类来说，我们可以通过观察整体格局、运用抽象的空间推理能力，快速制定一个大致计划。然而，对于大多数基于深度学习的 前沿AI模型（尤其是大语言模型LLM） 来说，这恰恰是它们的短板。

  • LLM的本质是“关联预测” ：它们通过在大量文本数据上学习到的统计规律，预测下一个最可能的词或token。它们擅长模仿、组合已知模式，但在需要严格逻辑演绎、从头开始进行长链条推理的任务上，容易“翻车”。
  • 缺乏内部世界模型 ：当前的LLM更像是一个极其博学的“直觉反应者”，而不是一个拥有内部模拟和规划能力的“思考者”。让它们解决推箱子问题，相当于让一位语言学家去解一道需要严格步骤的数学证明题，他可能知道所有相关的数学名词和定理，但未必能组织出正确的证明序列。

因此，用最前沿的AI来“测测”这些问题， 其目的绝非大材小用，而是一种重要的“能力基准测试” 。它测试的是AI在以下方面的能力：

  • 复杂推理 ：能否理解复杂约束并进行多步思考。
  • 规划能力 ：能否生成并评估一个有序的动作序列。
  • 对规则的理解与遵守 ：能否严格遵循给定的、不可违背的规则。

理解了这一点，我们就能明白，社区中热议的 Spring AI 、 AI Agent 、 Cursor 等工具，其终极目标正是为了弥补大模型在这些方面的不足，让AI不仅能“说”，更能“做”和“规划”。

2. 环境准备与版本说明

在开始构建一个能处理规划类问题的AI应用之前，我们需要搭建开发环境。本文将使用 Spring AI 作为集成框架，因为它提供了与多种大模型（OpenAI, Ollama, 阿里云灵积等）的标准接口，非常适合在Java生态中快速构建AI功能。

基础环境：

  • 操作系统 ：Windows 10/11, macOS, 或 Linux (Ubuntu 20.04+)
  • Java ：JDK 17 或 21 (推荐17，长期支持版)
  • 构建工具 ：Maven 3.6+ 或 Gradle 7.x
  • IDE ：IntelliJ IDEA (推荐，对Spring Boot支持好) 或 VS Code

核心依赖版本： 本文示例基于 Spring Boot 3.2.x 和 Spring AI 0.8.1 (截至2024年初的稳定版本)。Spring AI版本迭代较快，请以官方文档为准。

<!-- 在 pom.xml 中的依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.4</version>
    <relativePath/>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring AI 核心依赖 -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        <version>0.8.1</version>
    </dependency>
    <!-- 如果需要连接阿里云等国内模型，可使用对应的starter -->
    <!-- <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-alibaba-spring-boot-starter</artifactId>
        <version>0.8.1</version>
    </dependency> -->
</dependencies>

模型服务准备： 你需要一个可访问的大模型API。可以选择：

  1. OpenAI ：需准备API Key。
  2. Ollama (本地运行)：在本地启动Ollama服务，运行如 llama3 、 qwen 等模型。
  3. 阿里云灵积 ：需准备阿里云账号和API Key。

本文将使用 Ollama 本地模型 进行演示，以方便本地测试且无需网络费用。

3. 核心原理拆解：从LLM调用到规划智能体

单纯调用LLM的Chat接口无法解决规划问题。我们需要引入更高级的模式。Spring AI提供了一些抽象，但理解其背后的设计模式至关重要。

3.1 思维链与提示工程

对于简单推理，我们可以通过 提示工程 引导LLM。例如，让模型“逐步思考”。但这对于推箱子这类复杂问题，成功率有限。

// 一个简单的提示工程示例（伪代码）
String prompt = """
        你是一个推箱子游戏专家。请解决以下关卡。
        地图（#代表墙，@代表玩家，$代表箱子，.代表目标点）：
        #####
        #@$.#
        #####
        请给出一步一步的移动序列（上，下，左，右）。请先分析再给出答案。
        """;
// 调用 model.call(prompt)...

3.2 AI Agent（智能体）模式

这是解决复杂问题的关键。一个Agent通常包含：

  • 工具 ：Agent可以调用的外部函数，如“移动玩家”、“判断是否胜利”。
  • 规划器 ：决定调用哪个工具、以什么顺序调用的组件。
  • 记忆 ：保存当前状态和历史动作。
  • 执行引擎 ：协调以上组件运行。

Spring AI 0.8.x 提供了 Agent 、 Tool 等基础抽象，但构建一个完整的规划Agent仍需一定工作量。

3.3 ReAct (Reason + Act) 框架

这是实现Agent的经典范式。让模型循环进行： 思考 -> 决定行动 -> 执行行动 -> 观察结果 -> 再思考 。

思考：我需要把箱子推到目标点。玩家现在在(1,1)，箱子在(1,2)。我可以先向右移动。
行动：调用 movePlayer(“右”)
观察：玩家移动到(1,2)，箱子被推到(1,3)。
思考：现在箱子在目标点旁边，我需要移动到箱子左侧推它上目标。
...

我们需要用代码实现这个循环，并用LLM驱动“思考”部分。

4. 完整实战：构建一个解决“移红点”问题的AI智能体

让我们用一个更具体的问题来实战：“移红点”可以简化为一个 滑块拼图 问题，例如经典的8数码问题（8-puzzle）。我们将构建一个Spring Boot应用，集成Ollama本地模型，并实现一个能解决此问题的AI Agent。

项目目标 ：给定一个3x3拼图的乱序状态，AI Agent能输出一系列移动步骤，使其恢复为有序状态。

4.1 创建项目结构与基础配置

使用 Spring Initializr 创建一个新项目，或直接使用上面的 pom.xml 。

配置文件 application.yml ： 

spring:
  ai:
    openai:
      # 如果使用Ollama，base-url指向本地服务
      base-url: http://localhost:11434
      api-key: ollama # Ollama不需要真实key，但属性不能为空
      chat:
        options:
          model: llama3:8b # 指定Ollama中已拉取的模型名称
          temperature: 0.1 # 低温度，使输出更确定，适合推理任务

启动类 AiPuzzleApplication.java ： 

package com.example.aipuzzle;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AiPuzzleApplication {
    public static void main(String[] args) {
        SpringApplication.run(AiPuzzleApplication.class, args);
    }
}

4.2 定义领域模型与工具

首先，定义拼图的状态和操作。

1. 拼图状态类 PuzzleState.java ： 

package com.example.aipuzzle.domain;

import lombok.Data;
import java.util.Arrays;

@Data
public class PuzzleState {
    // 用3x3二维数组表示拼图，0代表空格
    private int[][] board = new int[3][3];

    public PuzzleState(int[][] board) {
        // 深拷贝
        this.board = new int[3][3];
        for (int i = 0; i < 3; i++) {
            this.board[i] = Arrays.copyOf(board[i], 3);
        }
    }

    // 找到空格（0）的位置
    public int[] findBlank() {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] == 0) {
                    return new int[]{i, j};
                }
            }
        }
        return null;
    }

    // 判断是否为目标状态（有序）
    public boolean isGoal() {
        int counter = 1;
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i == 2 && j == 2) {
                    if (board[i][j] != 0) return false;
                } else {
                    if (board[i][j] != counter++) return false;
                }
            }
        }
        return true;
    }

    // 复制当前状态
    public PuzzleState copy() {
        return new PuzzleState(this.board);
    }
}

2. 移动操作工具类 PuzzleMoveTool.java ： 这是一个Spring AI Tool 的实现，代表Agent可以执行的动作。

package com.example.aipuzzle.tool;

import com.example.aipuzzle.domain.PuzzleState;
import org.springframework.ai.tool.Tool;
import org.springframework.stereotype.Component;
import java.util.Map;

@Component
public class PuzzleMoveTool implements Tool {

    @Override
    public String getName() {
        return “puzzle_move”;
    }

    @Override
    public String getDescription() {
        return “移动拼图中的空格。输入应为JSON字符串，包含 ‘direction’ 键，其值必须是 ‘up’, ‘down’, ‘left’, ‘right’ 之一，表示移动方向。”;
    }

    @Override
    public String execute(Map<String, Object> arguments) {
        // 在实际Agent中，这里会接收当前状态并执行移动。
        // 此处为简化，仅返回一个说明。
        String direction = (String) arguments.get(“direction”);
        return String.format(“已执行移动：%s。请告诉我移动后的新拼图状态（3x3矩阵）。”, direction);
    }
}

4.3 实现核心规划Agent服务

这是最复杂的部分。我们将实现一个简化版的ReAct Agent。在实际复杂场景中，可以考虑使用 Spring AI 的 ReActAgent 或 Chain 等更高阶抽象。

规划服务 PuzzleSolverService.java ： 

package com.example.aipuzzle.service;

import com.example.aipuzzle.domain.PuzzleState;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.Generation;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
@RequiredArgsConstructor
public class PuzzleSolverService {

    private final ChatClient chatClient;

    // 一个启发式的解决尝试，结合LLM进行决策（简化版）
    public String solveWithAI(PuzzleState initialState) {
        PuzzleState currentState = initialState;
        StringBuilder solution = new StringBuilder();
        int stepLimit = 50; // 防止无限循环
        int step = 0;

        while (!currentState.isGoal() && step < stepLimit) {
            step++;
            // 1. 构建提示词，让LLM基于当前状态建议一个移动方向
            String promptTemplate = “””
                    你是一个拼图问题解决专家。当前3x3拼图状态如下（0代表空格）：
                    {board}
                    目标状态是：
                    [1, 2, 3]
                    [4, 5, 6]
                    [7, 8, 0]
                    空格可以与其上下左右的数字交换。请只从 [‘up’， ‘down’， ‘left’， ‘right’] 中选择一个最可能接近目标的移动方向。
                    只输出一个单词，不要任何解释。
                    “””;

            String boardStr = formatBoard(currentState.getBoard());
            Prompt prompt = new PromptTemplate(promptTemplate)
                    .create(Map.of(“board”, boardStr));

            // 2. 调用LLM获取决策
            Generation generation = chatClient.prompt(prompt)
                    .call()
                    .content();
            String suggestedDirection = generation.getText().trim().toLowerCase();

            log.info(“步骤{}: AI建议移动方向: {}”, step, suggestedDirection);

            // 3. 模拟执行移动（这里简化，实际需验证移动合法性并更新状态）
            // 此处应调用一个真正的移动函数来更新currentState
            // PuzzleState newState = simulateMove(currentState, suggestedDirection);
            // if (newState != null) { currentState = newState; }

            solution.append(String.format(“步骤%d: 移动空格 %s\n”, step, suggestedDirection));

            // 4. 简化：我们假设AI每次都能给出合法移动。实际项目需要验证和状态回滚。
            // 为防止文章过长，我们在此处跳出循环，展示流程。
            if (step > 5) {
                solution.append(“（演示限制，已中断循环）\n”);
                break;
            }
        }

        if (currentState.isGoal()) {
            solution.append(“\n成功！拼图已解决。”);
        } else {
            solution.append(String.format(“\n未在%d步内解决。”, stepLimit));
        }
        return solution.toString();
    }

    private String formatBoard(int[][] board) {
        StringBuilder sb = new StringBuilder();
        for (int[] row : board) {
            sb.append(Arrays.toString(row)).append(“\n”);
        }
        return sb.toString();
    }
}

4.4 创建控制器与测试接口

控制器 PuzzleController.java ： 

package com.example.aipuzzle.controller;

import com.example.aipuzzle.domain.PuzzleState;
import com.example.aipuzzle.service.PuzzleSolverService;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping(“/api/puzzle”)
public class PuzzleController {

    private final PuzzleSolverService solverService;

    public PuzzleController(PuzzleSolverService solverService) {
        this.solverService = solverService;
    }

    @PostMapping(“/solve”)
    public String solvePuzzle(@RequestBody int[][] initialBoard) {
        // 简单验证输入
        if (initialBoard == null || initialBoard.length != 3 || initialBoard[0].length != 3) {
            return “错误：请输入有效的3x3矩阵。”;
        }
        PuzzleState initialState = new PuzzleState(initialBoard);
        return solverService.solveWithAI(initialState);
    }

    @GetMapping(“/demo”)
    public String demo() {
        // 一个经典的8数码难题初始状态
        int[][] demoBoard = {
                {1, 2, 3},
                {4, 0, 6},
                {7, 5, 8}
        };
        PuzzleState initialState = new PuzzleState(demoBoard);
        return solverService.solveWithAI(initialState);
    }
}

4.5 运行与验证

  1. 启动Ollama服务 ：确保已安装Ollama，并在终端运行 ollama run llama3:8b 来拉取并运行模型。
  2. 启动Spring Boot应用 ：运行 AiPuzzleApplication 的main方法。
  3. 测试接口 ：
    • 打开浏览器或使用Postman，访问 GET http://localhost:8080/api/puzzle/demo 。
    • 你将看到控制台输出AI建议的移动步骤，以及接口返回的解决过程字符串。

预期输出示例： 

步骤1: AI建议移动方向: right
步骤2: AI建议移动方向: down
步骤3: AI建议移动方向: left
步骤4: AI建议移动方向: up
（演示限制，已中断循环）
未在50步内解决。

注意 ：由于我们使用了通用的LLM进行决策，并且模拟部分被简化，它可能无法真正解决难题。但这完整演示了将AI集成到规划循环中的工作流程。要获得可靠解，需要更专业的规划算法（如A*搜索）或更强大的规划专用模型。

5. 常见问题与排查思路

在集成AI进行规划类应用开发时，你会遇到一些典型问题。

问题现象 可能原因 排查思路与解决方案
连接Ollama失败，报连接超时 1. Ollama服务未启动。
2. application.yml 中 base-url 配置错误。
3. 防火墙或端口占用。		 1. 终端执行 ollama serve 确保服务运行。
2. 检查配置是否为 http://localhost:11434 。
3. 使用 curl http://localhost:11434/api/tags 测试Ollama API是否可达。
调用Chat API返回401或403错误 1. 使用了OpenAI等在线服务但API Key错误或过期。
2. 未正确配置API Key。		 1. 检查API Key的有效性。
2. 确保在配置文件中正确设置了 spring.ai.openai.api-key 或对应模型服务的key。
LLM的输出不符合预期，不遵循指令 1. 提示词（Prompt）设计不清晰。
2. 模型温度（temperature）参数过高，导致输出随机。
3. 模型能力不足。		 1. 优化提示词，使用更明确的指令、格式示例（Few-shot）。
2. 将 temperature 调低（如0.1）。
3. 尝试更强大的模型（如 llama3:70b , qwen:14b ）。
Agent陷入死循环，无法解决问题 1. ReAct循环缺少终止条件或状态验证。
2. LLM的“思考”步骤无法产生有效计划。
3. 工具执行结果反馈不准确。		 1. 严格设置最大步数限制。
2. 在提示词中加强约束，要求模型评估当前状态与目标的距离。
3. 确保工具函数返回精确、可解析的环境状态。
性能慢，响应时间长 1. 本地模型计算资源不足。
2. 每次调用都发送大量上下文历史。
3. 网络延迟（使用云端API时）。		 1. 使用更小的量化模型（如 llama3:8b-instruct-q4_0 ）。
2. 优化提示词，减少不必要的上下文。
3. 考虑使用流式响应或异步调用。

6. 最佳实践与工程建议

将前沿AI用于解决实际问题，而不仅仅是“测试”，需要遵循良好的工程实践。

1. 明确问题边界，不迷信LLM 对于推箱子、8数码这类有明确最优解的问题， 传统算法（如A 、BFS）在效率和可靠性上远超当前LLM *。AI的角色应该是：

  • 复杂约束的理解者 ：当规则用自然语言描述且非常复杂时，用LLM解析。
  • 高层策略规划师 ：在庞大状态空间中，用LLM提出启发性的子目标。
  • 与传统算法结合 ：用LLM生成启发式函数的权重，或对算法搜索结果进行解释和排序。

2. 设计稳健的Agent架构

  • 状态管理是核心 ：必须有一个唯一、准确的来源记录当前环境状态（如游戏棋盘）。所有工具操作都必须基于此状态并返回更新后的状态。
  • 工具设计要原子化 ：每个工具功能应单一、明确。例如，“移动玩家”和“判断胜利”应该是两个独立的工具。
  • 引入验证层 ：在工具执行前，验证动作的合法性（如移动是否出界）。在LLM输出被使用前，验证其格式是否符合预期。

3. 提示工程系统化

  • 使用模板 ：像上面示例一样，使用 PromptTemplate 管理复杂的提示词，避免字符串拼接。
  • 提供示例 ：在提示词中提供1-2个完整的输入输出示例（Few-shot Learning），能极大提升模型输出格式的稳定性。
  • 指定输出格式 ：明确要求模型以JSON、列表或特定关键词格式输出，便于程序解析。

4. 利用更专业的框架和模式

  • LangChain / LangChain4j ：提供了比Spring AI更成熟、更丰富的Agent、Chain、Memory实现。对于复杂Agent，可以考虑使用。
  • ReAct框架 ：严格按照“Thought -> Action -> Observation”的循环构建Agent，这是经过验证的有效模式。
  • Tree of Thoughts (ToT) 或 Graph of Thoughts (GoT) ：对于极其复杂的规划问题，可以研究这些更高级的提示框架，让模型进行多路径推理和评估。

5. 开发与运维考量

  • 成本控制 ：记录Token消耗，对于规划任务，迭代调用LLM的成本可能很高。设置预算和调用次数上限。
  • 可观测性 ：记录每一次LLM调用和工具执行的输入输出，这是调试Agent行为的关键。
  • 降级方案 ：当AI Agent多次尝试失败后，应有回退机制，例如切换到传统的确定性算法。

回到最初的问题：“目前世界最前沿的AI，只是来测测推箱子，移红点等？” 答案显然是否定的。这些“简单”问题是对AI 规划与推理能力 的试金石，是推动AI向更通用、更可靠方向发展的关键挑战。

作为开发者，我们的任务不是等待一个能解决所有问题的“全能AI”，而是利用现有的强大模型（如通过Spring AI集成的各类模型），结合传统的软件工程智慧（清晰的架构、稳健的算法、细致的验证），去构建能够解决特定领域实际问题的 混合智能系统 。

从本文的实战可以看出，即使是一个简化版的拼图求解Agent，也涉及了模型集成、提示工程、流程控制、状态管理等多个环节。这正是当前AI应用开发的核心： 将大模型的“认知”能力，嵌入到可控、可预测的软件流程中 。

下一步，你可以：

  1. 完善本文的Agent ：实现真正的棋盘状态模拟和合法性校验，让它可以运行一个完整的8数码问题。
  2. 尝试更复杂的环境 ：用类似架构去尝试解决“推箱子”关卡，定义“墙”、“箱子”、“目标”等更丰富的工具。
  3. 集成专业规划库 ：将LLM与 java.util.concurrent 或专门的搜索算法库结合，让LLM提供高级指导，让传统算法负责精确搜索。
  4. 探索Spring AI高级特性 ：深入研究 ReActAgent 、 Chain 、 VectorStore 等组件，构建更强大的应用。

AI不是魔术，它是我们工具箱中一件前所未有的、强大的新工具。理解它的能力边界，并用扎实的工程方法去驾驭它，才是我们当前最值得投入精力的方向。

Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

AI结合RPA：快速实现业务流程离线落地的完整工程方案

avatar AI编程社区

`claude-video /watch`：给 Claude 装上“眼睛“看视频的工程实现与边界分析

"总结整个视频"在帧稀疏时效果其实一般，因为 Claude 可能根本没看到关键帧。

avatar AI编程社区
cover

从 PHP 到 AI + Golang，程序员自救转型手记（三十九）：前端上传组件实现

avatar AI编程社区