前言

提及AI开发，Python几乎是所有开发者的第一联想——丰富的训练框架、轻量化的原型工具、活跃的算法社区，让Python成为AI模型研发与训练的绝对主流。但在企业级AI落地场景中，Java的价值却被严重低估：国内绝大多数核心业务系统（ERP、CRM、交易平台、客服系统）均基于Java构建，将AI能力（尤其是智能体）无缝集成到现有Java生态，远比重构Python系统更具性价比、更低风险。

Java的核心定位并非“AI模型训练”，而是“AI能力的工程化落地与智能体的业务化实现”。本文将全方位拆解Java开发AI与智能体的全链路技术栈，从语言特性对比、框架选型、模型接入，到向量数据库、RAG引擎、监控工具的搭配，再结合企业实践与分级实战案例，为Java开发者提供一套可直接复用的落地指南。

image​

‍

‍

一、Java AI/智能体开发核心简介

Java AI开发的核心逻辑是“扬长避短”：避开Python擅长的模型训练环节，聚焦自身“企业级生态成熟、稳定性强、安全性高、系统集成能力突出”的优势，构建从“AI能力调用”到“智能体自主决策”的全链路落地体系。其核心架构可分为6层，各层配套核心技术栈组件如下：

  • 基础层：Java语言（JDK 11+），搭配Maven/Gradle构建工具，是全链路的开发底座；
  • 框架层：LangChain4j、Spring AI等AI专属框架，负责智能体编排、RAG引擎封装、工具调用管理；
  • 模型接入层：通过SDK、OpenAI兼容接口、私有化部署等方式，对接通义千问、即梦AI等主流大模型；
  • 数据支撑层：向量数据库（Milvus、Elasticsearch等）存储私有知识向量，Redis存储短期会话记忆；
  • 编排与工具层：RAG引擎实现“检索-增强-生成”闭环，OpenFeign、Apache Camel对接企业内部系统；
  • 运维监控层：Prometheus+Grafana监控性能，ELK收集日志，模型管理平台实现模型版本管控。

从能力演进来看，Java AI开发可分为三个阶段：基础阶段（简单模型调用，如智能问答）、进阶阶段（RAG增强，如企业知识库问答）、高级阶段（智能体开发，如自主处理业务流程），各阶段对应不同的技术栈组合，适配不同的业务需求。

‍

‍

二、Java开发AI/智能体的核心特点

1. 核心优势

  • 企业级生态闭环：Spring Boot/Spring Cloud、Redis、K8s等组件成熟，可直接复用现有Java技术栈，降低AI落地成本；
  • 系统集成能力强：天然适配企业现有Java业务系统，通过OpenFeign、Camel等工具可快速对接CRM、ERP等核心系统，为智能体提供业务执行能力；
  • 安全与合规性突出：Java沙箱机制、权限控制体系，搭配私有化部署的向量数据库与模型，可满足金融、政务等行业“数据不出域”的核心要求；
  • 稳定性与可维护性高：强类型特性、完善的异常处理机制，减少生产环境故障，配合成熟的监控工具，保障AI应用7×24小时稳定运行；
  • 私有化部署友好：通过DJL框架可实现开源模型内网推理，搭配私有化向量数据库、模型管理平台，完成全链路私有化AI落地。

2. 局限性

  • 模型训练能力薄弱：缺乏PyTorch、TensorFlow等原生训练框架，几乎不用于AI算法研发与模型训练；
  • AI开源生态丰富度低：AI相关库的更新速度、社区活跃度远不及Python，部分前沿AI能力的适配存在滞后；
  • 原型开发效率略低：相比Python“几行代码调用模型”的轻量化体验，Java需更多工程化代码封装，向量数据库、RAG引擎的集成也需额外配置。

‍

三、核心差异比较（语言/框架/组件）

🌐 语言定位：互补而非对立

对比维度 Java Python
核心定位 AI应用落地、智能体工程化、企业级集成 AI模型训练、算法研发、轻量化原型验证
核心技术栈 LangChain4j、Spring AI、通义千问SDK、Milvus、OpenFeign LangChain、PyTorch、TensorFlow、Hugging Face、Chroma
向量数据库适配 官方Java SDK完善，支持Milvus、ES等企业级组件，适配分布式部署 轻量客户端为主，适配Chroma等原型级组件，企业级部署需额外配置
RAG引擎 LangChain4j、Spring AI封装企业级RAG，支持流程编排与权限控制 LangChain原生支持轻量RAG，快速验证思路，企业级特性需额外开发
模型接入方式 SDK优先、OpenAI兼容接口，适配企业级权限管控 API调用、Hugging Face直接加载模型，快速验证多模型效果
适用场景 生产环境、企业级智能体、私有化部署、存量系统集成 算法研发、模型训练、Demo验证、科研场景

‍

image​

‍

image​

‍

‍

‍

🧰 核心组件全景图

层级 推荐方案 关键能力 企业案例
大模型接入 Spring AI（官方）
LangChain4j		 统一API、流式响应、自动重试、Prompt模板 招商银行智能投顾
向量数据库 Milvus（Java SDK）
Qdrant（gRPC Client）
Weaviate（REST Client）		 亿级向量检索、标量过滤、分布式部署 顺丰知识库检索
RAG引擎 LangChain4j RAG链
自定义Spring AI Pipeline		 文档解析→分块→嵌入→重排序→生成 某券商合规问答系统
智能体框架 JADE（FIPA标准）
LangChain4j Agent		 多Agent通信、工具调用、记忆管理 西门子产线调度
模型管理 MLflow Java Client
自定义Prometheus Exporter		 模型版本追踪、A/B测试、指标监控 蚂蚁风控模型迭代
监控告警 Micrometer + Prometheus
Arthas在线诊断		 Token消耗监控、延迟P99、异常熔断 某省政务平台
国产化支持 通义千问Java SDK
ModelScope Java Client
达梦数据库向量插件		 信创环境部署、中文优化 多家国有银行

‍

‍

Java AI核心框架对比
框架名称 核心定位 模型接入能力 向量数据库适配 RAG/智能体支持 适用场景
LangChain4j Java原生AI/智能体开发框架 支持通义千问、即梦AI、GPT等，SDK/兼容接口全覆盖 原生支持Milvus、ES、pgvector，适配企业级部署 完善的RAG引擎、工具调用、记忆管理，智能体编排能力强 企业级智能体、复杂RAG应用、私有化部署
Spring AI Spring生态AI快速集成框架 与Spring Boot无缝整合，支持通义千问（OpenAI兼容）、GPT 自动装配Milvus、ES向量存储，配置极简 轻量RAG支持，智能体能力较基础 Spring技术栈快速接入AI、轻量知识库问答
DJL Java原生模型推理框架 支持ONNX格式模型，适配通义千问开源版、Llama 2等私有化模型 需配合其他框架对接，自身无向量数据库集成能力 无原生RAG/智能体支持，专注模型推理 开源模型私有化推理、本地AI能力部署

‍

image​

‍

‍

Spring AI（推荐）

  • 定位：Spring生态原生AI框架

  • 优势：

    • 与Spring Boot深度集成，一行代码即可接入AI
    • 支持流式输出、工具调用、RAG等核心功能
    • 自动配置，减少样板代码

  • 代码示例：

    // 一行代码实现AI对话
String response = chatClient.generate("解释Java虚拟机的工作原理");

‍

LangChain4j

  • 定位：Java版LangChain，通用AI开发框架

  • 优势：

    • 功能全面，支持复杂Agent工作流
    • 灵活性高，可深度定制

  • 代码示例：

    // 构建RAG系统
Retriever<TextSegment> retriever = EmbeddingStoreRetriever.builder()
    .embeddingStore(embeddingStore)
    .embeddingModel(embeddingModel)
    .maxResults(3)
    .build();

‍

选型建议
  • 选择Spring AI的场景：现有Spring Boot项目、快速集成AI功能、团队熟悉Spring生态
  • 选择LangChain4j的场景：需要构建复杂Agent系统、多步骤推理流程、高度定制化需求

‍

模型接入方式

  1. 云端API直连（主流方式）

    • 通过Spring AI或厂商SDK（如阿里云DashScope SDK）调用云端大模型，开发快、模型新、免运维。

  2. 本地模型服务（安全/合规场景）

    • 部署Ollama、vLLM或DJL Serving，在私有环境中运行Llama、Qwen等开源模型，保障数据安全。

  3. 混合部署

    • 将敏感任务路由到本地模型，通用任务使用云端API，通过AI网关统一调度，平衡成本与安全。

‍

云API模型（推荐生产环境）
  • 通过Spring AI或厂商SDK（如阿里云DashScope SDK）调用云端大模型，开发快、模型新、免运维。
// 阿里云千问接入示例
Generation gen = new Generation();
GenerationRequest request = new GenerationRequest();
request.setModel("qwen-turbo");
request.setPrompt("你好，请介绍一下自己");
GenerationResponse response = gen.call(request);
System.out.println(response.getOutput().getText());
本地部署开源模型（成本可控）
  • 部署Ollama、vLLM或DJL Serving，在私有环境中运行Llama、Qwen等开源模型，保障数据安全。
bash# 使用Ollama部署Llama 3
ollama run llama3

‍

混合部署
  • 将敏感任务路由到本地模型，通用任务使用云端API，通过AI网关统一调度，平衡成本与安全。

‍

模型选择策略
  • 高并发、高性能：阿里云百炼、腾讯混元
  • 数据敏感、成本可控：Ollama本地部署
  • 特定领域：微调专用模型（使用Deeplearning4j）

‍

‍

向量数据库
  • 向量数据库：是智能体的“长期记忆”。Milvus、PgVector（PostgreSQL扩展）和Redis以其高性能和与Java生态的良好集成，成为主流选择。

‍

数据库 优势 适用场景 Java集成度
Milvus 高性能、分布式、云原生 大规模向量检索 高（官方Java SDK）
Qdrant 轻量、Rust编写、性能优秀 中小规模、高实时性 中（REST API）
PostgreSQL + pgvector 熟悉度高、事务支持 混合检索（向量+结构化） 高（JDBC）
Redis 内存存储、极速读写 短期记忆、缓存 高（Jedis/Lettuce）

推荐：生产环境优先选择Milvus，中小规模或混合检索场景可选择PostgreSQL+pgvector。

‍

RAG引擎与编排

LangChain4j是核心实现框架。企业级增强方案通常结合Apache Tika（文档解析）、Embedding模型和向量数据库，构建从文档摄取、向量化到智能检索的完整管道。

‍

Dify（推荐）
  • 特点：可视化LLM应用开发平台，支持RAG、Agent编排
  • 优势：无需代码即可构建复杂AI工作流，通过API与Java应用集成
  • 适用场景：快速构建企业级AI应用，多团队协作
LlamaIndex
  • 特点：专注于非结构化数据处理与索引构建
  • 优势：灵活性强，支持自定义数据加载器和索引策略
  • 适用场景：需要深度定制数据处理的场景

‍

架构示例：

Java应用 → Dify API → RAG引擎 → 向量数据库(Milvus) + 业务数据库(PostgreSQL)

‍

模型管理与监控
实验跟踪：MLflow
java// 记录实验参数和指标
mlflowClient.logParam(runId, "model", "qwen-turbo");
mlflowClient.logMetric(runId, "accuracy", 0.95);

‍

模型版本管理
  • MLflow：实验跟踪、模型版本管理、部署
  • Spring Cloud Config：配置版本管理
  • Git LFS：大模型文件版本管理

‍

监控告警体系

  • 指标监控：Micrometer + Prometheus + Grafana

    • API延迟、Token消耗、错误率、并发数

  • 日志管理：ELK Stack（Elasticsearch + Logstash + Kibana）

  • 链路追踪：Spring Cloud Sleuth + Zipkin

‍

工具链与基础设施
开发工具
  • IDE：IntelliJ IDEA（AI Assistant插件）
  • 构建工具：Maven/Gradle
  • 容器化：Docker + Kubernetes
部署与运维
  • CI/CD：Jenkins/GitLab CI
  • 服务网格：Istio（流量管理、安全）
  • Serverless：阿里云函数计算、AWS Lambda

‍

‍

四、核心应用场景

Java AI/智能体的应用场景均围绕“企业级落地”展开，核心是将AI能力与现有Java业务系统结合，解决实际业务痛点：

1. 企业私有知识库问答（RAG核心场景）

适配场景：企业内部规章制度查询、产品手册问答、运维文档检索等；技术栈核心组合：Spring AI/LangChain4j + 通义千问Embedding + Milvus/ES + Redis；核心价值：通过向量数据库存储私有文档向量，实现精准语义检索，解决大模型“不懂企业内部知识”的痛点。

2. 企业级智能客服

适配场景：客户咨询应答、订单查询、售后问题处理、工单自动创建；技术栈核心组合：LangChain4j + 通义千问qwen-max + Milvus（客服知识库） + OpenFeign（对接CRM/工单系统）；核心价值：智能体自动理解客户需求，检索知识库或调用业务系统，实现7×24小时高效客服，降低人工成本。

3. 业务决策助手

适配场景：财务报表解读、销售趋势预测、客户分层运营建议；技术栈核心组合：Spring AI + 通义千问 + Milvus（业务数据向量） + 企业BI系统集成；核心价值：智能体整合企业历史业务数据与行业知识，为管理层提供数据驱动的决策建议。

4. 私有化AI应用（金融/政务）

适配场景：银行内部风险评估、政务事项咨询、涉密数据处理；技术栈核心组合：DJL + 通义千问开源版 + 私有化Milvus + 内网K8s；核心价值：全链路内网部署，数据不流出企业，满足合规要求的同时实现AI赋能。

5. 工业智能运维助手

适配场景：设备故障预警、运维日志分析、修复方案推荐；技术栈核心组合：LangChain4j + 通义千问 + Milvus（故障案例向量） + 物联网数据集成；核心价值：智能体自动分析运维数据与故障案例，快速定位问题并给出修复建议，提升运维效率。

‍

五、头部企业应用情况

国内头部企业均已基于Java技术栈落地AI/智能体应用，核心思路是“复用现有Java生态，对接主流大模型，通过向量数据库与RAG激活私有数据”：

  • 阿里巴巴：基于Java+Spring生态构建百炼平台企业级AI应用层，通过LangChain4j封装通义千问能力，搭配Milvus向量数据库存储商家知识库，支撑淘宝、天猫商家助手的智能问答与运营建议；
  • 工商银行：采用Java+DJL+私有化Milvus向量库，部署金融专属AI助手，对接内部核心业务系统，实现客户信用评估、风险预警等场景，所有数据留存内网，满足金融合规要求；
  • 京东：基于Spring AI+通义千问+Elasticsearch向量能力，搭建供应链智能体，向量数据库存储物流、仓储、供应商数据，实现订单智能分仓、库存预警与补货建议，提升供应链效率；
  • 顺丰：通过Java+LangChain4j+Milvus开发物流异常处理智能体，向量数据库存储海量异常处理案例，智能体自动检索方案、调度配送资源，将异常件处理效率提升40%；
  • 国家电网：采用Java+私有化向量数据库+开源AI模型，开发电网巡检智能体，集成物联网设备数据，实现输电线路故障智能识别与检修方案推荐，降低人工巡检成本与安全风险。

‍

六、实战实例（从简单到复杂）

实例1：简单场景——Java调用通义千问API实现基础智能问答

场景说明：无需私有数据，仅验证模型调用能力，是AI开发的基础入门；核心技术栈：Java + 阿里百炼SDK + 通义千问qwen-turbo。

前置准备
  1. 注册阿里百炼账号，创建应用并获取API-KEY；2. 引入Maven依赖：
<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>dashscope-sdk-java</artifactId>
    <version>2.12.0</version>
</dependency>
核心代码
import com.aliyun.dashscope.ApiKey;
import com.aliyun.dashscope.aigc.generation.Generation;
import com.aliyun.dashscope.aigc.generation.GenerationParam;
import com.aliyun.dashscope.aigc.generation.GenerationResult;
import com.aliyun.dashscope.exception.ApiException;

public class QwenSimpleDemo {
    public static void main(String[] args) {
        // 配置百炼API-KEY（生产环境建议从配置中心读取，禁止硬编码）
        ApiKey.setApiKey("你的百炼API-KEY");
  
        // 初始化通义千问模型客户端
        Generation gen = new Generation();
        GenerationParam param = GenerationParam.builder()
                .model("qwen-turbo") // 轻量版，性价比高，适合基础问答
                .messages(GenerationParam.Message.builder()
                        .role("user")
                        .content("解释Java中ThreadPoolExecutor的核心参数")
                        .build())
                .resultFormat("text")
                .temperature(0.7) // 控制生成内容的创造性
                .build();
  
        // 调用模型并处理结果
        try {
            GenerationResult result = gen.call(param);
            System.out.println("通义千问回答：\n" + result.getOutput().getText());
        } catch (ApiException e) {
            System.err.println("调用失败：" + e.getMessage());
        }
    }
}
运行效果
通义千问回答：
Java中ThreadPoolExecutor的核心参数包括6个，分别作用如下：
1. corePoolSize：核心线程数，线程池长期保持的线程数量，即使空闲也不会销毁；
2. maximumPoolSize：最大线程数，线程池允许创建的最大线程数量；
3. keepAliveTime：空闲线程存活时间，核心线程外的空闲线程超过该时间会被销毁；
4. unit：keepAliveTime的时间单位（如TimeUnit.SECONDS）；
5. workQueue：任务队列，用于存放等待执行的任务；
6. threadFactory：线程工厂，用于创建新线程，可自定义线程名称、优先级等；
7. handler：拒绝策略，当任务数超过最大线程数+队列容量时的处理策略（如AbortPolicy直接抛异常）。

‍

实例2：中等场景——基于Spring AI+Milvus实现企业RAG知识库问答

场景说明：接入企业私有文档，实现“私有知识+大模型”的精准问答；核心技术栈：Spring Boot + Spring AI + 通义千问（Embedding+对话） + Milvus向量数据库。

前置准备
  1. 部署Milvus 2.4+，创建默认数据库；2. 开通百炼通义千问Embedding能力；3. 引入Maven依赖：
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.3</version>
</parent>

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring AI 对接通义千问（OpenAI兼容） -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
        <version>1.0.0-M1</version>
    </dependency>
    <!-- Spring AI 对接Milvus向量数据库 -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-milvus-store</artifactId>
        <version>1.0.0-M1</version>
    </dependency>
</dependencies>
配置文件（application.yml）
spring:
  # 通义千问配置（对接百炼OpenAI兼容接口）
  ai:
    openai:
      base-url: https://dashscope.aliyuncs.com/compatible-mode/v1
      api-key: 你的百炼API-KEY
      chat:
        model: qwen-turbo
        temperature: 0.6
      embedding:
        model: text-embedding-v1 # 通义千问官方Embedding模型
  # Milvus向量数据库配置
  milvus:
    client:
      host: localhost
      port: 19530
      username: root
      password: Milvus
      database: default
核心代码
import org.springframework.ai.document.Document;
import org.springframework.ai.embedding.EmbeddingModel;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.prompt.Prompt;
import org.springframework.ai.prompt.PromptTemplate;
import org.springframework.ai.vectorstore.MilvusVectorStore;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import java.util.List;
import java.util.Map;

@SpringBootApplication
public class SpringAIRagDemo implements CommandLineRunner {

    @Autowired
    private OpenAiChatClient chatClient;

    @Autowired
    private EmbeddingModel embeddingModel;

    // 初始化Milvus向量存储（RAG核心组件）
    @Bean
    public VectorStore vectorStore() {
        return new MilvusVectorStore(embeddingModel);
    }

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

    @Override
    public void run(String... args) throws Exception {
        VectorStore vectorStore = vectorStore();

        // 1. 模拟企业私有文档（如内部开发规范），向量化后存入Milvus
        List<Document> companyDocs = List.of(
                new Document("技海拾贝公司Java开发规范：\n1. 线程池必须使用ThreadPoolExecutor手动创建，禁止使用Executors工具类；\n2. 核心线程数根据CPU核心数设置（建议CPU核心数*2）；\n3. 拒绝策略优先使用CallerRunsPolicy，避免任务丢失；\n4. 必须指定线程工厂，自定义线程名称便于问题排查"),
                new Document("技海拾贝公司AI项目规范：\n1. 接入大模型必须使用企业级API网关，统一管控调用权限；\n2. 向量数据库优先使用Milvus，需开启索引优化检索性能；\n3. 所有API-KEY必须存入配置中心，禁止硬编码到代码中")
        );
        vectorStore.add(companyDocs);
        System.out.println("企业私有文档已完成向量化并存入Milvus");

        // 2. 用户提问，从Milvus检索相似私有知识
        String userQuestion = "我们公司Java项目创建线程池有哪些要求？";
        List<Document> relatedDocs = vectorStore.similaritySearch(userQuestion);
        System.out.println("检索到相关规范：" + relatedDocs.get(0).getContent());

        // 3. 构造Prompt，结合私有知识调用通义千问
        PromptTemplate template = new PromptTemplate("""
                你是公司内部AI助手，仅基于下方提供的企业规范回答问题，禁止编造信息。
                企业规范：{docs}
                用户问题：{question}
                """);
        Prompt prompt = template.create(Map.of(
                "docs", relatedDocs.stream().map(Document::getContent).reduce("", String::concat),
                "question", userQuestion
        ));

        // 4. 输出精准回答
        String answer = chatClient.call(prompt).getResult().getOutput().getContent();
        System.out.println("RAG精准回答：\n" + answer);
    }
}
运行效果
企业私有文档已完成向量化并存入Milvus
检索到相关规范：技海拾贝公司Java开发规范：
1. 线程池必须使用ThreadPoolExecutor手动创建，禁止使用Executors工具类；
2. 核心线程数根据CPU核心数设置（建议CPU核心数*2）；
3. 拒绝策略优先使用CallerRunsPolicy，避免任务丢失；
4. 必须指定线程工厂，自定义线程名称便于问题排查
RAG精准回答：
根据公司Java开发规范，创建线程池需遵循以下要求：
1. 必须使用ThreadPoolExecutor手动创建，禁止使用Executors工具类；
2. 核心线程数需根据CPU核心数设置，建议为CPU核心数的2倍；
3. 拒绝策略优先选择CallerRunsPolicy，可避免任务丢失；
4. 必须指定线程工厂，通过自定义线程名称方便后续问题排查。

‍

实例3：复杂场景——基于LangChain4j+Milvus+Redis开发企业级智能体

场景说明：实现“短期会话记忆+长期向量记忆+工具调用”的智能体，对接CRM系统查询客户信息；核心技术栈：LangChain4j + 通义千问 + Milvus（长期记忆） + Redis（短期记忆） + OpenFeign（工具调用）。

前置准备
  1. 部署Redis、Milvus；2. 引入Maven依赖：
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-core</artifactId>
    <version>0.32.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>0.32.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-milvus</artifactId>
    <version>0.32.0</version>
</dependency>
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-redis</artifactId>
    <version>0.32.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>3.2.3</version>
</dependency>
核心代码
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.memory.chat.ChatMemory;
import dev.langchain4j.memory.chat.RedisChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.rag.content.retriever.ContentRetriever;
import dev.langchain4j.rag.content.retriever.MilvusContentRetriever;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.milvus.MilvusEmbeddingStore;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class LangChain4jAgentDemo {
    // 百炼平台配置
    private static final String DASH_SCOPE_API_KEY = "你的百炼API-KEY";
    private static final String DASH_SCOPE_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";

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

        // 1. 初始化通义千问模型（核心决策引擎）
        ChatLanguageModel qwenModel = OpenAiChatModel.builder()
                .baseUrl(DASH_SCOPE_BASE_URL)
                .apiKey(DASH_SCOPE_API_KEY)
                .modelName("qwen-turbo")
                .temperature(0.1) // 智能体决策更稳定
                .build();

        // 2. 初始化Milvus向量存储（长期记忆：企业知识库+客户案例）
        EmbeddingStore embeddingStore = MilvusEmbeddingStore.builder()
                .host("localhost")
                .port(19530)
                .username("root")
                .password("Milvus")
                .collectionName("company_long_term_memory")
                .build();
        // 长期记忆检索器
        ContentRetriever longTermRetriever = MilvusContentRetriever.builder()
                .embeddingStore(embeddingStore)
                .embeddingModel(qwenModel)
                .maxResults(2)
                .build();

        // 3. 初始化Redis短期会话记忆（记住当前对话上下文）
        ChatMemory shortTermMemory = RedisChatMemory.builder()
                .redisUri("redis://localhost:6379")
                .ttl(3600) // 记忆有效期1小时
                .build();

        // 4. 构建智能体（整合模型、短期记忆、长期记忆、工具）
        CompanyCustomerAgent agent = AiServices.builder(CompanyCustomerAgent.class)
                .chatLanguageModel(qwenModel)
                .chatMemory(shortTermMemory)
                .contentRetriever(longTermRetriever)
                .build();

        // 测试智能体能力
        System.out.println("=== 第一次对话（调用工具查询客户） ===");
        System.out.println(agent.chat("查询客户ID为C202601的客户信息"));

        System.out.println("\n=== 第二次对话（利用短期记忆） ===");
        System.out.println(agent.chat("这位客户的合作时长是多久？"));

        System.out.println("\n=== 第三次对话（结合长期记忆） ===");
        System.out.println(agent.chat("给这位客户推荐合适的合作方案"));
    }

    // 定义智能体接口（包含工具调用能力）
    interface CompanyCustomerAgent {
        String chat(String message);

        // 工具1：对接CRM系统查询客户信息（@Tool注解标记，智能体自动识别）
        @Tool("查询客户详细信息，参数为客户ID")
        default String queryCustomerInfo(String customerId) {
            // 实际场景：通过OpenFeign调用企业CRM系统接口
            return "客户ID：" + customerId + "，姓名：李总，企业：XX科技，合作时长：2年，客户等级：VIP，历史合作金额：120万";
        }

        // 工具2：生成客户合作方案（基于长期记忆中的案例）
        @Tool("为客户生成合作方案，参数为客户ID")
        default String generateCooperationPlan(String customerId) {
            // 实际场景：结合Milvus中的相似客户案例生成方案
            return "客户ID：" + customerId + "（VIP等级）合作方案：\n1. 升级年度服务套餐，享8折优惠；\n2. 赠送2次定制化AI培训服务；\n3. 专属客户经理1对1对接，响应时间≤2小时";
        }
    }
}
运行效果
=== 第一次对话（调用工具查询客户） ===
客户ID：C202601，姓名：李总，企业：XX科技，合作时长：2年，客户等级：VIP，历史合作金额：120万

=== 第二次对话（利用短期记忆） ===
这位客户（C202601，李总）的合作时长为2年。

=== 第三次对话（结合长期记忆） ===
为客户C202601（李总，XX科技，VIP等级）推荐以下合作方案：
1. 升级年度服务套餐，享8折优惠；
2. 赠送2次定制化AI培训服务；
3. 专属客户经理1对1对接，响应时间≤2小时

‍

生产级智能体系统（完整架构）

// 1. 智能体核心服务
@Service
public class ProductionAgent {

    @Autowired
    private ChatModel chatModel;

    @Autowired
    private VectorStore vectorStore;

    @Autowired
    private ToolRegistry toolRegistry;

    @Autowired
    private MemoryManager memoryManager;

    @Autowired
    private MonitoringService monitoring;

    public AgentResponse process(AgentRequest request) {
        // 记录开始时间
        long startTime = System.currentTimeMillis();
        String requestId = UUID.randomUUID().toString();

        try {
            // 1. 检索相关上下文（RAG）
            List<Document> context = vectorStore.similaritySearch(
                request.getUserQuery(), 5
            );

            // 2. 获取历史对话（短期记忆）
            List<Message> history = memoryManager.getHistory(
                request.getSessionId(), 10
            );

            // 3. 获取长期记忆（相关历史会话）
            List<Memory> longTermMemory = memoryManager.getLongTermMemory(
                request.getUserId(), request.getUserQuery()
            );

            // 4. 构建系统提示
            String systemPrompt = buildSystemPrompt(
                context, history, longTermMemory,
                toolRegistry.getAvailableTools()
            );

            // 5. 调用模型
            Prompt prompt = new Prompt(
                request.getUserQuery(),
                Map.of("system", systemPrompt)
            );

            ChatResponse response = chatModel.call(prompt);

            // 6. 处理工具调用
            if (response.hasToolCalls()) {
                List<ToolCall> toolCalls = response.getToolCalls();
                List<ToolResult> toolResults = toolRegistry.execute(toolCalls);

                // 7. 生成最终响应
                return generateFinalResponse(response, toolResults);
            }

            // 8. 更新记忆
            memoryManager.addConversation(
                request.getSessionId(),
                request.getUserId(),
                request.getUserQuery(),
                response.getContent()
            );

            // 9. 记录监控指标
            monitoring.recordMetric(
                requestId,
                "success",
                System.currentTimeMillis() - startTime,
                response.getUsage().getTotalTokens()
            );

            return AgentResponse.success(response.getContent());

        } catch (Exception e) {
            // 10. 异常处理与监控
            monitoring.recordError(requestId, e);
            return AgentResponse.error("处理失败: " + e.getMessage());
        }
    }

    private String buildSystemPrompt(List<Document> context,
                                     List<Message> history,
                                     List<Memory> longTermMemory,
                                     List<ToolInfo> tools) {
        // 构建详细的系统提示，包含：
        // 1. 角色设定
        // 2. 上下文信息
        // 3. 工具说明
        // 4. 约束条件
        // 5. 输出格式
        // 这里省略具体实现
        return "你是一个专业的Java AI助手，负责回答技术问题...";
    }
}

// 2. 工具注册与执行器
@Component
public class ToolRegistry {

    private final Map<String, ToolExecutor> tools = new ConcurrentHashMap<>();
    private final List<ToolInfo> toolInfos = new ArrayList<>();

    @PostConstruct
    public void init() {
        // 注册内置工具
        registerTool("weather", new WeatherTool());
        registerTool("calculator", new CalculatorTool());
        registerTool("database", new DatabaseTool());
        registerTool("code_analyzer", new CodeAnalyzerTool());
    }

    public void registerTool(String name, ToolExecutor executor) {
        tools.put(name, executor);
        toolInfos.add(new ToolInfo(name, executor.getDescription()));
    }

    public List<ToolResult> execute(List<ToolCall> toolCalls) {
        return toolCalls.parallelStream()
            .map(call -> {
                ToolExecutor executor = tools.get(call.getName());
                if (executor == null) {
                    return new ToolResult(call.getName(), "工具不存在");
                }
                return executor.execute(call.getArgs());
            })
            .collect(Collectors.toList());
    }

    public List<ToolInfo> getAvailableTools() {
        return Collections.unmodifiableList(toolInfos);
    }
}

// 3. 工具实现示例
@Service
public class DatabaseTool implements ToolExecutor {

    @Override
    public ToolResult execute(Map<String, Object> args) {
        String query = (String) args.get("query");
        String type = (String) args.get("type");

        try {
            // 执行数据库查询
            List<Map<String, Object>> results = executeQuery(query, type);
            return new ToolResult("database", results);
        } catch (Exception e) {
            return new ToolResult("database", "查询失败: " + e.getMessage());
        }
    }

    private List<Map<String, Object>> executeQuery(String query, String type) {
        // 实际数据库查询逻辑
        // 支持SQL、MongoDB、Redis等
        return new ArrayList<>();
    }

    @Override
    public String getDescription() {
        return "执行数据库查询，支持SQL和NoSQL查询";
    }
}

// 4. 监控服务
@Service
public class MonitoringService {

    @Autowired
    private MeterRegistry meterRegistry;

    private final Timer requestTimer;
    private final Counter errorCounter;
    private final DistributionSummary tokenSummary;

    public MonitoringService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;

        this.requestTimer = Timer.builder("ai.agent.request.duration")
            .description("AI智能体请求处理时间")
            .register(meterRegistry);

        this.errorCounter = Counter.builder("ai.agent.errors")
            .description("AI智能体错误计数")
            .register(meterRegistry);

        this.tokenSummary = DistributionSummary.builder("ai.agent.token.usage")
            .description("Token使用量分布")
            .register(meterRegistry);
    }

    public void recordMetric(String requestId, String status, long duration, int tokens) {
        requestTimer.record(duration, TimeUnit.MILLISECONDS);
        tokenSummary.record(tokens);

        // 记录到日志
        log.info("请求{}处理完成，状态：{}，耗时：{}ms，Token：{}",
            requestId, status, duration, tokens);
    }

    public void recordError(String requestId, Exception e) {
        errorCounter.increment();
        log.error("请求{}处理失败", requestId, e);
    }
}

‍

七、结束语

Java并非AI开发的“旁观者”，而是企业级AI落地的“核心载体”。从简单的模型调用到复杂的智能体开发，Java凭借成熟的生态、稳定的性能和强大的系统集成能力，让AI能力真正融入企业业务核心——而向量数据库、RAG引擎、专业AI框架的搭配，更是让Java AI从“通用对话”升级为“业务赋能”的关键。

本文覆盖的技术栈选型、企业实践与实战案例，仅为Java AI开发的入门指南。在实际落地过程中，你还会遇到向量数据库性能调优、智能体决策精度提升、模型调用成本控制、企业级监控体系搭建等核心问题。

关注公众号「技海拾贝」，后续还会持续更新Java AI最新技术动态与实战案例。

‍

37650874dcbf494a87fabcdce3ea6180​

‍

‍

# 人工智能 # java # python
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

无 Root 权限搞定！远程服务器配置 Claude Code 中转教程（终端/插件）

avatar AtomGit开源社区
cover

【含安装包】深度实测 OpenClaw 2.7.9，本地 AI 自动化安装避坑完整指南

avatar AtomGit开源社区

After Effects (AE)2026超详细保姆级下载安装教程 附软件功能详解（新手零基础适用）

这次2026版本直接把3D功能拉满了，内置了立方体、球体这些基础的参数化模型，还支持Substance 3D材质，灯光能投射阴影，渲染出来的效果和专业3D软件几乎没差别。我试了一下，用它抠一个带半透明效果的logo，一键就能搞定，效果比以前手动调参数自然多了。以前预览视频的时候，生成的临时文件占了我好大一块硬盘空间。我用它预览了一个5分钟的动画，生成的临时文件只有以前的十分之一大小，再也不用频繁清

avatar AtomGit开源社区