Helidon 4.4 深度解析：当 Oracle 把 LangChain4j AI Agent 能力直接内建进 Java 微服务框架

前言：Java 开发者终于不用再"看戏"了

2026年4月，Oracle 发布了 Helidon 4.4.0 版本。这不是一次普通的版本更新——它是 Java 生态在 AI Agent 时代的一个重要信号：Java 框架不再只是 AI 的旁观者，而是正在成为 AI 应用落地的核心战场。

长期以来，一提到 AI，很多 Java 开发者的第一反应是"这活儿交给 Python 干吧"。确实，在模型训练、论文复现这些领域，Python 是绝对主场。但在大模型时代真正创造商业价值的，往往不是"把模型训练出来"，而是把模型接进真实系统里——这件事，本质上是应用工程，而不是模型科研。

Helidon 4.4 的出现，让 Java 开发者终于可以在自己熟悉的框架里，直接拥有 AI Agent 能力，而不需要跳到 Python 生态去"帮忙"。

一、Helidon 是什么？为什么 Oracle 要在它身上下这么大的棋？

1.1 从 MicroProfile 到全功能微服务框架

Helidon 是 Oracle 主导开发的轻量级 Java 微服务框架，最初由 Oracle Labs 于 2018 年启动。它的设计哲学从一开始就很清晰：简单、快速、云原生。

Helidon 有两个主要 flavors：

• Helidon MP：完整支持 MicroProfile 标准，兼容 JAX-RS、CDI、JSON-P/B，适合从传统 Java EE 迁移过来的团队
• Helidon SE：现代化的函数式编程模型，轻量灵活，适合新项目快速起步

在 4.x 版本中，Helidon 做了重大架构升级——Helidon WebServer 是全球首个完全基于虚拟线程（Virtual Threads）从零开始编写的 Web 服务器。这意味着它天然支持 JDK 21+ 的虚拟线程特性，不需要任何特殊配置就能获得极高的并发性能。

1.2 Helidon 4.x 的版本策略转变

从 Helidon 4.4.0 开始，Oracle 做了一个非常重要的决定：Helidon 将改变其语义化版本控制方式，改为与 OpenJDK 保持一致的六个月发布节奏。

从 2026 年 9 月发布的 JDK 27 开始，当前的 Helidon 4.x 将变更为 Helidon 27，采用 OpenJDK 所实践的 tip 和 tail 模型。这意味着：

• Helidon 的版本号将直接对齐 Java LTS 版本
• 企业可以根据 Java 版本规划来规划 Helidon 升级路线
• 框架与 JDK 的耦合度更高，兼容性更有保障

1.3 被纳入 Java Verified Portfolio（JVP）

Oracle 还宣布 Helidon 将被纳入新的 Java Verified Portfolio（JVP）——这是一个由 Oracle 验证的 Java 工具、框架和库的精选集合。类似于红帽对 RHEL 生态中组件的验证机制，JVP 的目的是帮助企业用户在高可靠性的保障下选择开源组件。

这一信号非常明确：Helidon 不只是 Oracle 的实验性项目，而是被 Oracle 视为 Java 企业级生态的重要组成部分。

二、Helidon 4.4 核心新特性：从微服务到 AI Agent

2.1 AI Agentic Integration（AI 智能体集成）

这是 Helidon 4.4 最重磅的特性：原生 AI Agent 能力。

Helidon 4.4 官方引入了与 LangChain4j 的深度集成，使得在 Helidon 应用中构建 AI Agent 变得前所未有的简单。LangChain4j 是 Java 生态中最重要的 AI 应用开发库，它提供了：

• 支持所有主流商业和开源大语言模型（OpenAI、Anthropic、Google Gemini、Ollama 等）
• 统一的 API 接口
• 完整的 Agent 工具箱（Tools）
• RAG（检索增强生成）支持
• 多模态能力

Helidon 与 LangChain4j 的结合，让 Java 开发者可以在 Helidon 的微服务架构中直接使用 LangChain4j 的 Agent 能力，而不需要额外的适配层。

2.2 MCP 支持升级（Model Context Protocol）

Helidon 4.4 还带来了 更新的 MCP（Model Context Protocol）支持。

MCP 是 Anthropic 提出的模型上下文协议，旨在标准化 AI 模型与应用之间的交互方式。它让 AI Agent 能够安全、可控地访问外部工具和数据源——本质上是一个标准化的 Function Calling 协议。

Helidon 4.4 的 MCP 支持，意味着开发者可以将 Helidon 微服务注册为 MCP Server，让 AI Agent 直接调用微服务中的业务逻辑。MCP 协议使得工具调用变得标准化，不同的 AI Agent（无论是来自 LangChain4j 还是其他框架）都可以以相同的方式与 Helidon 服务交互。

2.3 Helidon Declarative 的全面扩展

Helidon Declarative 是 Helidon SE 中引入的控制反转（IoC）编程模型，最早在 4.3.0 版本中引入。它允许开发者用声明式的方式定义 HTTP Server Endpoint、调度、容错等核心功能。

Helidon 4.4 对 Declarative 进行了大规模扩展，新增了以下能力的声明式支持：

2.4 JSON 和 OpenTelemetry 改进

Helidon 4.4 还对 JSON 处理和 OpenTelemetry 集成进行了多项改进，使得在微服务中实现可观测性更加便捷。

三、代码实战：从零构建一个 Helidon AI Agent

3.1 项目初始化

首先，用 Helidon 提供的 Maven Archetype 创建一个新项目：

mvn -U io.helidon.archetypes:helidon-archetype-quickstart-se \
    io.helidon.archetypes:helidon-archetype-quickstart-mp

或者使用 CLI：

helidon init --type se --name helidon-ai-agent

3.2 引入 LangChain4j 依赖

在 pom.xml 中添加 LangChain4j 依赖：

<dependency>
    <groupId>io.helidon.integrations.langchain4j</groupId>
    <artifactId>helidon-langchain4j</artifactId>
    <version>4.4.0</version>
</dependency>

<!-- OpenAI 支持 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>1.0.0</version>
</dependency>

<!-- Ollama 支持（本地模型） -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-ollama</artifactId>
    <version>1.0.0</version>
</dependency>

3.3 定义 AI 工具（Tools）

这是 AI Agent 的核心能力之一——让大模型调用我们定义的 Java 方法。

package com.example.ai;

import dev.langchain4j.agent.tool.Tool;
import jakarta.inject.Singleton;
import java.time.LocalDateTime;

/**
 * 订单查询工具 - 展示如何将业务方法暴露给 AI Agent
 */
@Singleton
public class OrderService {

    @Tool("查询用户订单")
    public String queryOrders(String userId, String status) {
        // 实际项目中这里会调用数据库
        return String.format(
            "用户 %s 的订单（状态: %s）：\n" +
            "  订单号: ORD-2026-001 金额: ¥2999.00 状态: 已发货\n" +
            "  订单号: ORD-2026-002 金额: ¥158.00 状态: 处理中",
            userId, status
        );
    }

    @Tool("获取系统当前时间")
    public String getCurrentTime() {
        return LocalDateTime.now().toString();
    }

    @Tool("计算订单优惠")
    public double calculateDiscount(double originalPrice, String couponCode) {
        return switch (couponCode) {
            case "NEW_USER" -> originalPrice * 0.85; // 85折
            case "VIP" -> originalPrice * 0.70;       // 7折
            case "HOLIDAY" -> originalPrice - 50;     // 立减50
            default -> originalPrice;
        };
    }
}

3.4 构建 AI Agent

使用 LangChain4j 的 @Agent 注解和 Helidon 的依赖注入，创建一个完整的 AI Agent：

package com.example.ai;

import dev.langchain4j.service.Agent;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import io.helidon.inject.runtime.InjectRegistry;
import jakarta.enterprise.context.ApplicationScoped;

/**
 * 电商客服 AI Agent
 * 结合了工具调用、记忆管理和对话能力
 */
@ApplicationScoped
public class CustomerServiceAgent {

    private final Agent customerAgent;

    public CustomerServiceAgent(
            OrderService orderService,
            ProductCatalog productCatalog
    ) {
        this.customerAgent = Agent.builder()
            .name("电商客服小助手")
            .systemMessage("""
                你是一名专业的电商客服助手。
                你需要：
                1. 热情友好地与用户交流
                2. 根据用户需求调用相应工具
                3. 在回复中提供准确、实用的信息
                4. 如果遇到无法处理的问题，及时告知用户
                """)
            .tools(orderService, productCatalog)
            .build();
    }

    public String chat(String userMessage) {
        return customerAgent.chat(userMessage);
    }
}

3.5 创建 REST API 暴露 Agent 能力

package com.example.api;

import com.example.ai.CustomerServiceAgent;
import io.helidon.webserver.http.HttpService;
import io.helidon.webserver.http.ServerRequest;
import io.helidon.webserver.http.ServerResponse;
import io.helidon.webserver.http.MediaType;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * AI Chat REST API
 */
@ApplicationScoped
public class AiChatService implements HttpService {

    private final CustomerServiceAgent agent;
    private final ObjectMapper mapper = new ObjectMapper();

    public AiChatService(CustomerServiceAgent agent) {
        this.agent = agent;
    }

    @Override
    public void routing(Routing.Rules rules) {
        rules.post("/chat", this::handleChat);
        rules.get("/health", (req, res) -> {
            res.send("OK");
        });
    }

    private void handleChat(ServerRequest req, ServerResponse res) {
        try {
            JsonNode body = mapper.readTree(req.content().as(String.class));
            String message = body.get("message").asText();
            String userId = body.has("userId") 
                ? body.get("userId").asText() 
                : "anonymous";

            String response = agent.chat(message);

            ObjectNode responseJson = mapper.createObjectNode();
            responseJson.put("userId", userId);
            responseJson.put("message", message);
            responseJson.put("response", response);
            responseJson.put("timestamp", System.currentTimeMillis());

            res.send(responseJson);

        } catch (Exception e) {
            res.status(500);
            res.send("{\"error\": \"" + e.getMessage() + "\"}");
        }
    }
}

3.6 启动配置

Helidon 4.4 的 Declarative 配置让启动变得极其简单：

# application.yaml
server:
  port: 8080

ai:
  model:
    provider: openai          # 或 ollama
    model-name: gpt-4o
    api-key: ${OPENAI_API_KEY}
  agent:
    temperature: 0.7
    max-tokens: 2048

package com.example;

import io.helidon.webserver.WebServer;
import io.helidon.webserver.http.HttpRouting;
import com.example.api.AiChatService;

public class Main {

    public static void main(String[] args) {
        WebServer.builder()
            .routing(routing -> routing
                .register("/api", HttpRouting.builder()
                    .register(AiChatService.class)
                    .build())
                .build())
            .build()
            .start()
            .thenAccept(ws -> {
                System.out.println("Server started at: http://localhost:" 
                    + ws.port());
            });
    }
}

四、MCP 集成：让 Helidon 服务成为 AI 的"工具箱"

4.1 MCP 的核心价值

MCP（Model Context Protocol）是 2026 年 AI 领域最重要的协议之一。它的设计目标是将 AI Agent 与外部世界的交互标准化。

传统的 Function Calling 有一个问题：每个 AI 框架都有自己的实现方式。OpenAI 的 function calling 格式与 Anthropic 的 tool use 不一样，LangChain4j 又有自己的一套标准。这导致了一个困境：你在一个框架中定义的工具，换到另一个框架就没法用了。

MCP 试图解决这个问题。它定义了一套标准化的接口：

• MCP Server：暴露工具和数据源的服务器
• MCP Client：AI Agent 连接 MCP Server 的客户端
• 标准化的工具描述格式：所有 MCP Server 暴露的工具都以相同格式描述

4.2 将 Helidon 微服务暴露为 MCP Server

Helidon 4.4 支持将微服务直接暴露为 MCP Server：

package com.example.mcp;

import io.helidon.mcp.server.McpServer;
import io.helidon.mcp.server.Tool;
import io.helidon.mcp.server.McpServerBuilder;
import com.example.services.InventoryService;

/**
 * 将 Helidon 微服务注册为 MCP Server
 */
public class InventoryMcpServer {

    public static void main(String[] args) {
        InventoryService inventoryService = new InventoryService();

        McpServer server = McpServerBuilder.create()
            .name("inventory-service")
            .version("1.0.0")
            
            // 注册库存查询工具
            .tool(Tool.builder()
                .name("check_stock")
                .description("查询商品库存数量")
                .inputSchema("""
                    {
                        "type": "object",
                        "properties": {
                            "productId": {
                                "type": "string",
                                "description": "商品ID"
                            },
                            "warehouse": {
                                "type": "string",
                                "description": "仓库代码"
                            }
                        },
                        "required": ["productId"]
                    }
                    """)
                .handler(request -> {
                    String productId = request.getString("productId");
                    String warehouse = request.getStringOrDefault("warehouse", "MAIN");
                    int stock = inventoryService.checkStock(productId, warehouse);
                    return ToolResult.success(
                        String.format("商品 %s 在 %s 仓库的库存为: %d",
                            productId, warehouse, stock)
                    );
                })
                .build())
            
            // 注册订单创建工具
            .tool(Tool.builder()
                .name("create_order")
                .description("创建新订单")
                .inputSchema("""
                    {
                        "type": "object",
                        "properties": {
                            "userId": {"type": "string"},
                            "items": {
                                "type": "array",
                                "items": {
                                    "type": "object",
                                    "properties": {
                                        "productId": {"type": "string"},
                                        "quantity": {"type": "integer"}
                                    }
                                }
                            }
                        },
                        "required": ["userId", "items"]
                    }
                    """)
                .handler(request -> {
                    // 处理订单创建
                    return ToolResult.success("订单创建成功: ORD-" + System.currentTimeMillis());
                })
                .build())
            
            .build();

        server.start();
    }
}

4.3 连接 MCP Server

在 LangChain4j Agent 中连接外部 MCP Server：

// 通过 MCP 连接外部工具
McpClients mcpClients = McpClients.builder()
    .mcpServer("http://localhost:7001")  // inventory-service
    .mcpServer("http://localhost:7002")  // payment-service
    .build();

Agent agent = Agent.builder()
    .name("full-service-agent")
    .systemMessage("你是一个全能助手，可以调用库存服务和支付服务")
    .mcpClients(mcpClients)  // 从 MCP Server 获取所有可用工具
    .build();

五、Helidon Declarative 深入解析

5.1 Declarative 模型的核心优势

Helidon Declarative 是 Helidon 4.3 引入的特性，Helidon 4.4 进行了全面扩展。它的核心思想是：用注解和配置代替代码，让框架来处理底层实现。

传统的 Helidon SE 代码可能是这样的：

// 传统方式：显式编码
WebServer.builder()
    .routing(routing -> routing
        .get("/api/products", (req, res) -> {
            List<Product> products = productService.listAll();
            res.send(products);
        })
        .post("/api/orders", (req, res) -> {
            OrderRequest order = req.content().as(OrderRequest.class);
            Order created = orderService.create(order);
            res.status(201).send(created);
        }))
    .build();

使用 Declarative 后：

// Declarative 方式：声明式
@ApplicationScoped
@ApplicationPath("/api")
public class ApiApplication extends HttpApplication {

    @Inject
    private ProductService productService;

    @GET
    @Path("/products")
    public List<Product> listProducts() {
        return productService.listAll();
    }

    @POST
    @Path("/orders")
    @Produces(MediaType.APPLICATION_JSON)
    @Consumes(MediaType.APPLICATION_JSON)
    @StatusCode(201)
    public Order createOrder(OrderRequest order) {
        return orderService.create(order);
    }
}

5.2 Helidon 4.4 新增的 Declarative 能力

Metrics 声明式配置

@ApplicationScoped
public class BusinessService {

    @Timed(value = "order_processing_time", 
           description = "订单处理耗时")
    public Order processOrder(OrderRequest request) {
        // 业务逻辑
    }

    @Counted(value = "order_created_total",
             description = "创建的订单总数")
    public Order createOrder(String userId, List<OrderItem> items) {
        // ...
    }

    @Metered(value = "api_requests",
             description = "API 请求速率")
    public Response handleRequest(Request req) {
        // ...
    }
}

Security 声明式配置

@Authenticated
@Authorization("user")
@Path("/api/users")
public class UserService {

    @AllowedRoles({"admin", "manager"})
    @GET
    @Path("/{id}")
    public User getUser(@PathParam("id") String id) {
        return userRepository.findById(id);
    }

    @AllowedRoles({"admin"})
    @DELETE
    @Path("/{id}")
    public void deleteUser(@PathParam("id") String id) {
        userRepository.delete(id);
    }
}

Validation 声明式配置

@POST
@Path("/register")
public Response register(
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 20, message = "用户名长度需在3-20之间")
    String username,

    @Email(message = "邮箱格式不正确")
    String email,

    @NotBlank
    @Size(min = 6, message = "密码至少6位")
    String password
) {
    // ...
}

六、OpenTelemetry 可观测性集成

6.1 为什么可观测性对 AI Agent 至关重要

AI Agent 的行为具有高度不确定性——同样的输入可能因为模型的随机性产生不同的输出。在生产环境中，我们需要清楚知道：

• Agent 调用了哪些工具？
• 每次工具调用的输入输出是什么？
• 是否有工具调用失败？
• Agent 的响应延迟分布如何？
• 模型的 token 消耗情况

Helidon 4.4 与 OpenTelemetry 的深度集成，使得这些问题的答案触手可及。

6.2 自动追踪配置

# application.yaml
tracing:
  service: "customer-service-agent"
  exporter: otlp
  endpoint: "http://otel-collector:4317"
  
  # 追踪内容配置
  include:
    - http.requests     # HTTP 请求
    - db.queries        # 数据库查询
    - ai.agent.calls   # AI Agent 调用 ⭐
    - ai.tool.executions # 工具执行 ⭐

6.3 自定义 AI 追踪

@Singleton
public class TracingAiObserver implements AiServiceObserver {

    private final Tracer tracer;
    private final Meter meter;

    public TracingAiObserver(Tracer tracer, Meter meter) {
        this.tracer = tracer;
        this.meter = meter;
    }

    @Override
    public void onModelResponse(ModelResponse response) {
        Span span = tracer.spanBuilder("ai.model.response")
            .setAttribute("model.name", response.model())
            .setAttribute("response.tokens", response.usage().totalTokens())
            .setAttribute("response.content", 
                response.content().toString().substring(0, 100))
            .start();

        meter.counterBuilder("ai.responses.total")
            .tag("model", response.model())
            .register()
            .increment();

        span.end();
    }

    @Override
    public void onToolExecution(ToolExecution execution) {
        Span span = tracer.spanBuilder("ai.tool." + execution.toolName())
            .setAttribute("tool.name", execution.toolName())
            .setAttribute("tool.input", execution.input().toString())
            .start();

        try {
            Object result = execution.execute();
            span.setAttribute("tool.output", result.toString());
            span.setAttribute("tool.success", true);
        } catch (Exception e) {
            span.setAttribute("tool.success", false);
            span.setAttribute("tool.error", e.getMessage());
            span.recordException(e);
        } finally {
            span.end();
        }
    }
}

七、性能优化与最佳实践

7.1 虚拟线程的充分利用

Helidon WebServer 基于虚拟线程，意味着你可以用同步的代码风格写出异步的性能：

// 传统方式：回调地狱
@Get("/users/{id}/orders")
public void getUserOrders(ServerRequest req, ServerResponse res) {
    userService.findById(req.path().get("id"))
        .thenCompose(user -> orderService.findByUserId(user.getId()))
        .thenAccept(orders -> res.send(orders))
        .exceptionHandler(e -> res.status(500).send(e.getMessage()));
}

// 虚拟线程方式：同步风格，极高可读性
@Get("/users/{id}/orders")
public List<Order> getUserOrders(@PathParam("id") String userId) {
    User user = userService.findById(userId);          // 阻塞但不阻塞线程
    return orderService.findByUserId(user.getId());    // 继续同步
}

7.2 GraalVM Native Image 支持

Helidon 支持 GraalVM Native Image，可以将整个应用编译为独立的原生可执行文件：

<plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
    <configuration>
        <metadataRepository>
            <enabled>true</enabled>
        </metadataRepository>
    </configuration>
</plugin>

编译后的 AI Agent 应用可以：

• 启动时间从秒级降到毫秒级
• 内存占用减少 60-80%
• 无需 JVM 在目标机器上运行

7.3 AI Agent 的 Token 成本优化

在大模型调用中，Token 消耗是主要成本来源。以下是 Helidon 环境下的优化策略：

// 1. 使用更小的模型处理简单任务
@ApplicationScoped
public class RoutingAiAgent {

    @Inject @Named("fast-model")
    private ChatModel fastModel;  // GPT-4o-mini，处理简单查询

    @Inject @Named("smart-model")
    private ChatModel smartModel;  // GPT-4o，处理复杂任务

    public String chat(String message) {
        // 简单查询路由到小模型
        if (isSimpleQuery(message)) {
            return chatWith(fastModel, message);
        }
        // 复杂任务路由到大模型
        return chatWith(smartModel, message);
    }

    private boolean isSimpleQuery(String message) {
        // 意图识别：简单查询 vs 复杂分析
        return message.matches(".*(查询|多少钱|怎么|哪里).*")
            && message.length() < 50;
    }
}

八、架构演进：从微服务到 AI-Native 应用

8.1 Helidon AI Agent 的典型部署架构

                        ┌─────────────────────────────────────────┐
                        │            AI Gateway (可选)             │
                        │  限流 / 鉴权 / 缓存 / 负载均衡            │
                        └──────────────────┬────────────────────────┘
                                           │
                        ┌──────────────────▼────────────────────────┐
                        │         Helidon AI Agent Cluster          │
                        │  ┌─────────────┐    ┌─────────────┐       │
                        │  │  Agent #1   │    │  Agent #2   │  ...  │
                        │  │ (LangChain4j)│    │(LangChain4j)│       │
                        │  └──────┬──────┘    └──────┬──────┘       │
                        │         │                   │              │
                        │  ┌──────▼───────────────────▼──────┐      │
                        │  │       MCP Server Bus            │      │
                        │  │  (内部工具 + 外部 MCP Server)   │      │
                        │  └──────┬───────────────────┬──────┘      │
                        └─────────┼───────────────────┼──────────────┘
                                  │                   │
              ┌───────────────────┼───────────────────┼───────────────┐
              │                   │                   │               │
    ┌─────────▼─────┐  ┌─────────▼─────┐  ┌─────────▼─────┐  ┌──────▼──────┐
    │ Inventory MS  │  │  Order MS     │  │ Payment MS    │  │KnowledgeBase│
    │ (库存服务)    │  │  (订单服务)   │  │ (支付服务)   │  │  (知识库)   │
    └───────────────┘  └───────────────┘  └───────────────┘  └─────────────┘

8.2 与 Spring AI 的对比

很多 Java 开发者会问：Helidon + LangChain4j vs Spring AI，应该选哪个？

结论：如果你正在从头构建一个 AI-Native 的微服务架构，Helidon + LangChain4j 是一个非常有竞争力的选择。如果你已经有大量的 Spring Boot 存量代码，Spring AI 的集成成本更低。

九、总结：Java 在 AI 时代的重新定位

Helidon 4.4 的发布，标志着 Oracle 对 Java 在 AI 时代角色的一个清晰判断：Java 不是 AI 训练的主战场，但它是 AI 应用工程的重要战场。

LangChain4j 的深度集成、MCP 协议的原生支持、Declarative 模型的全面扩展——这些特性让 Java 开发者终于可以在自己熟悉的领域里，真正参与到 AI Agent 的构建中。

从 Helidon 4.4 中，我们可以清晰地看到几个重要趋势：

1. 框架与 AI 的融合正在加速：不再需要单独的"AI 层"，AI 能力将直接内建在微服务框架中

2. MCP 将成为标准协议：未来的 AI Agent 将通过 MCP 连接各种业务系统，Helidon 正在提前布局

3. Java 的性能优势在 AI 场景依然有效：虚拟线程、GraalVM Native Image——这些特性在需要低延迟、高并发的 AI 应用中非常有价值

4. 版本策略与 JDK 对齐：Helidon 采用与 OpenJDK 一致的发布节奏，这意味着 Java 开发者可以更平滑地升级框架

最后，我想说的是：AI Agent 时代，Java 开发者不再是旁观者。Helidon 4.4 只是开始，接下来会有更多的 Java 框架加入 AI 能力。抓住这个机会，用你熟悉的 Java，去构建真正改变世界的 AI 应用吧。

参考资源：

• Helidon 官方文档：https://helidon.io/
• LangChain4j 官方文档：https://docs.langchain4j.dev/
• Helidon 4.4.0 发布说明：https://github.com/helidon-io/helidon/releases
• Java Verified Portfolio：https://www.oracle.com/java/technologies/javase/jdk-27-html