Spring AI 1.0 正式发布！核心内容和智能体详解

磊哥

发布于 2025-05-22 00:19:35

1.4K00

代码可运行

运行总次数：0

代码可运行

在经历了八个里程碑式的版本之后（M1~M8），Spring AI 1.0 正式版本，终于在 2025 年 5 月 20 日正式发布了，这是另一个新高度的里程碑式的版本，标志着 Spring 生态系统正式全面拥抱人工智能技术，并且意味着 Spring AI 将会给企业带来稳定 API 支持。

1.核心特性

Spring AI 1.0 的核心是 ChatClient 接口，这是一个可移植且易于使用的 API，是与 AI 模型交互的主要接口。

它支持调用 20 多种 AI 模型，从 Anthropic 到 ZhiPu AI，并支持多模态输入和输出（当底层模型支持时）以及结构化响应（通常以 JSON 格式，便于应用程序处理输出）。

1.1 单模型ChatClient使用

在项目中只有一个模型时，创建全局的 ChatClient：

@RestController
class MyController {

    private final ChatClient chatClient;

    public MyController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/ai")
    String generation(String userInput) {
        return this.chatClient.prompt()
            .user(userInput)
            .call()
            .content();
    }
}

1.2 多模型ChatClient使用

在项目中有多个模型时，为这一个模型创建全局的 ChatClient：

// Create ChatClient instances programmatically
ChatModel myChatModel = ... // already autoconfigured by Spring Boot
ChatClient chatClient = ChatClient.create(myChatModel);

// Or use the builder for more control
ChatClient.Builder builder = ChatClient.builder(myChatModel);
ChatClient customChatClient = builder
    .defaultSystemPrompt("You are a helpful assistant.")
    .build();

1.3 不同模型类型的ChatClients

当项目中有多个模型时，为每个模型定义单独的 ChatClient：

import org.springframework.ai.chat.ChatClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ChatClientConfig {

    @Bean
    public ChatClient openAiChatClient(OpenAiChatModel chatModel) {
        return ChatClient.create(chatModel);
    }

    @Bean
    public ChatClient anthropicChatClient(AnthropicChatModel chatModel) {
        return ChatClient.create(chatModel);
    }
}

然后，您可以使用 @Qualifier 指定大模型对应的 ChatClient：

@Configuration
public class ChatClientExample {

    @Bean
    CommandLineRunner cli(
            @Qualifier("openAiChatClient") ChatClient openAiChatClient,
            @Qualifier("anthropicChatClient") ChatClient anthropicChatClient) {

        return args -> {
            var scanner = new Scanner(System.in);
            ChatClient chat;

            // Model selection
            System.out.println("\nSelect your AI model:");
            System.out.println("1. OpenAI");
            System.out.println("2. Anthropic");
            System.out.print("Enter your choice (1 or 2): ");

            String choice = scanner.nextLine().trim();

            if (choice.equals("1")) {
                chat = openAiChatClient;
                System.out.println("Using OpenAI model");
            } else {
                chat = anthropicChatClient;
                System.out.println("Using Anthropic model");
            }

            // Use the selected chat client
            System.out.print("\nEnter your question: ");
            String input = scanner.nextLine();
            String response = chat.prompt(input).call().content();
            System.out.println("ASSISTANT: " + response);

            scanner.close();
        };
    }
}

2.主要功能亮点

检索增强生成（RAG）：Spring AI 提供了便携式向量存储抽象，支持 20 种不同的向量数据库，从 Azure Cosmos DB 到 Weaviate，像常见的 Cassandra、PostgreSQL/PGVector、MongoDB Atlas、Milvus、Pinecone 和 Redis 等向量数据库存储都是支持的。还包括一个轻量级、可配置的 ETL 框架，用于将数据导入向量存储。
对话记忆：通过 ChatMemory 接口管理消息的存储和检索，支持 JDBC、Cassandra 和 Neo4j 等持久化存储。
工具调用：通过 @Tool 注解可以轻松定义工具，让 AI 模型能够获取外部信息或执行实际动作。
评估与测试：提供 Evaluator 接口和内置的 RelevancyEvaluator、FactCheckingEvaluator，帮助开发者评估 AI 生成内容的准确性和相关性。
可观测性：与 Micrometer 集成，提供模型延迟、令牌使用情况等关键指标的详细遥测数据。

3.模型上下文协议(MCP)支持

Spring AI 1.0 全面支持 Model Context Protocol (MCP)，这是一个标准化协议，使 AI 模型能够与外部工具、提示和资源进行交互。Spring AI 提供了客户端和服务器端的 MCP支持，简化了 MCP 工具的使用和创建。

最简单的 MCP 自定义服务器端实现：

@Service
public class WeatherService {

    @Tool(description = "Get weather information by city name")
    public String getWeather(String cityName) {
        // 伪代码
        return "The weather in " + cityName + " is 21°C and sunny.";
    }
}

@SpringBootApplication
public class McpServerApplication {

    private static final Logger logger = LoggerFactory.getLogger(McpServerApplication.class);

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

	@Bean
	public ToolCallbackProvider weatherTools(WeatherService weatherService) {
		return MethodToolCallbackProvider.builder().toolObjects(weatherService).build();
	}
}

最简单的 MCP 客户端核心代码实现：

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ClientController {
    @Autowired
    private ChatClient chatClient;

    @RequestMapping("/chat")
    public String chat(@RequestParam(value = "msg",defaultValue = "今天天气如何？") String msg) {
        String response = chatClient.prompt()
        .user(msg)
        .call()
        .content();
        System.out.println("响应结果: " + response);
        return response;
    }
}

4.AI Agent(智能体)支持

AI Agent 的核心是“利用 AI 模型与其环境交互，以解决用户定义的任务”。有效的 AI Agent 将规划、记忆和作相结合，以完成用户分配的任务。

Spring AI 1.0 支持两种主要类型的 Agent：

工作流驱动代理：通过预定义路径编排 LLM 和工具，一种更可控的 Agents 实现方法，其中 LLM 和工具通过预定义的路径进行编排。这些工作流是规范性的，可指导 AI 完成既定的作序列以实现可预测的结果。
自主驱动代理：允许 LLM 自主规划和执行处理步骤。这种方式代理将自己决定要调用的路径，决定使用哪些工具以及以什么顺序使用。

虽然完全自主代理的灵活性很有吸引力，但工作流为定义明确的任务提供了更好的可预测性和一致性。具体使用哪种类型，取决于您的具体要求和风险承受能力。

让我们看看 Spring AI 如何通过五种基本模式来实现这些概念，每种模式都服务于特定的用例：

4.1 Chain 工作流模式

该模式将复杂任务分解为一系列步骤，其中每个 LLM 调用都会处理前一个 LLM 调用的输出。

Chain Workflow 模式体现了将复杂任务分解为更简单、更易于管理的步骤的原则。

使用场景

具有明确顺序步骤的任务。
当您想用延迟换取更高的准确性时。
当每个步骤都基于上一步的输出时。

以下是 Spring AI 实现中的一个实际示例：

public class ChainWorkflow {
    private final ChatClient chatClient;
    private final String[] systemPrompts;

    public String chain(String userInput) {
        String response = userInput;
        for (String prompt : systemPrompts) {
            String input = String.format("{%s}\n {%s}", prompt, response);
            response = chatClient.prompt(input).call().content();
        }
        return response;
    }
}

此实现演示了几个关键原则：

每个步骤都有重点。
一个步骤的输出成为下一个步骤的输入。
该链易于扩展和维护。

4.2 并行化工作流

LLM 可以同时处理任务，并以编程方式聚合其输出。

使用场景

处理大量相似但独立的项目。
需要多个独立视角的任务。
当处理时间至关重要且任务可并行化时。

简单代码实现：

List<String> parallelResponse = new ParallelizationWorkflow(chatClient)
.parallel(
    "Analyze how market changes will impact this stakeholder group.",
    List.of(
        "Customers: ...",
        "Employees: ...",
        "Investors: ...",
        "Suppliers: ..."
    ),
    4
);

4.3 路由工作流

路由模式实现了智能任务分配，从而支持对不同类型的输入进行专门处理。

使用场景

具有不同输入类别的复杂任务。
当不同的输入需要专门处理时。
何时可以准确处理分类。

简单代码实现：

@Autowired
private ChatClient chatClient;

RoutingWorkflow workflow = new RoutingWorkflow(chatClient);

Map<String, String> routes = Map.of(
    "billing", "You are a billing specialist. Help resolve billing issues...",
    "technical", "You are a technical support engineer. Help solve technical problems...",
    "general", "You are a customer service representative. Help with general inquiries..."
);

String input = "My account was charged twice last week";
String response = workflow.route(input, routes);

4.4 编排器

使用场景

无法预先预测子任务的复杂任务。
需要不同方法或观点的任务。
需要适应性问题解决的情况。

简单实现代码：

public class OrchestratorWorkersWorkflow {
    public WorkerResponse process(String taskDescription) {
        // 1. Orchestrator analyzes task and determines subtasks
        OrchestratorResponse orchestratorResponse = // ...

        // 2. Workers process subtasks in parallel
        List<String> workerResponses = // ...

        // 3. Results are combined into final response
        return new WorkerResponse(/*...*/);
    }
}

使用示例：

ChatClient chatClient = // ... initialize chat client
OrchestratorWorkersWorkflow workflow = new OrchestratorWorkersWorkflow(chatClient);

WorkerResponse response = workflow.process(
    "Generate both technical and user-friendly documentation for a REST API endpoint"
);

System.out.println("Analysis: " + response.analysis());
System.out.println("Worker Outputs: " + response.workerResponses());

4.5 评估器-优化器

使用场景

存在明确的评估标准。
迭代优化提供可衡量的价值。
任务受益于多轮批评。

public class EvaluatorOptimizerWorkflow {
    public RefinedResponse loop(String task) {
        Generation generation = generate(task, context);
        EvaluationResponse evaluation = evaluate(generation.response(), task);
        return new RefinedResponse(finalSolution, chainOfThought);
    }
}

使用示例：

ChatClient chatClient = // ... initialize chat client
EvaluatorOptimizerWorkflow workflow = new EvaluatorOptimizerWorkflow(chatClient);

RefinedResponse response = workflow.loop(
    "Create a Java class implementing a thread-safe counter"
);

System.out.println("Final Solution: " + response.solution());
System.out.println("Evolution: " + response.chainOfThought());

5.开始使用SpringAI

开发者可以通过 Maven 中央仓库获取 Spring AI 1.0 的所有组件。使用提供的 bom 导入依赖：

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.ai</groupId>
      <artifactId>spring-ai-bom</artifactId>
      <version>1.0.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>