Java与AI-Agent开发技术栈

发表于 分类于 ，
Java + AI Agent 开发所需的技术栈详解，涵盖后端框架、大模型集成、MCP协议、向量数据库等核心组件

Java 与 AI Agent 开发技术栈

概述

随着大语言模型（LLM）的快速发展，AI Agent（智能体）已成为 AI 应用的重要形态。Java 作为企业级开发的主流语言，拥有丰富的生态系统和强大的工程化能力，是构建生产级 AI Agent 的理想选择。

本文系统梳理 Java + AI Agent 开发所需的技术栈，帮助开发者快速构建智能化的企业应用。

一、后端核心框架

1.1 Spring Boot

Spring Boot 是 Java 后端开发的基础框架，AI Agent 的后端服务通常基于 Spring Boot 构建。

核心特性

  • 快速构建 Spring 应用
  • 自动配置（Auto-Configuration）
  • 嵌入式服务器（Tomcat/Jetty）
  • 丰富的starter生态

AI相关starter

1
2
3
4
5
<!-- Spring AI (官方AI集成框架) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

1.2 Spring AI

Spring AI 是 Spring 官方提供的 AI 集成框架，简化了大模型与 Java 应用的集成。

核心功能

  • 多模型支持（OpenAI、Claude、Azure OpenAI、本地模型等）
  • 统一的 API 抽象
  • Prompt 模板管理
  • Function Calling / Tool Calling
  • RAG 支持

支持的模型

模型类型 支持的模型
OpenAI GPT-4o、GPT-4o-mini、o1
Anthropic Claude 3.5、Claude 3
Google Gemini 1.5、Gemini Pro
开源模型 Ollama、本地部署的模型

基本使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@RestController
public class AiController {
    
    private final ChatClient chatClient;
    
    public AiController(ChatClient.Builder builder) {
        this.chatClient = builder
            .defaultSystem("你是一个有用的AI助手")
            .build();
    }
    
    @GetMapping("/chat")
    public String chat(@RequestParam String message) {
        return chatClient.prompt()
            .user(message)
            .call()
            .content();
    }
}

二、大模型集成

2.1 LangChain4j

LangChain4j 是 Java 版的 LangChain，提供了构建 AI 应用的标准化组件。

核心模块

模块 功能
AI Services 简化 AI 调用，注解驱动
Prompt Templates 动态 Prompt 模板
Memory 对话记忆管理
Tools 工具/函数调用
RAG 检索增强生成
Chain 链式调用

AI Services 示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public interface Assistant {
    String chat(String message);
    String chatWithContext(String userId, String message);
}

@AiService
public interface LegalAssistant extends Assistant {
    
    @SystemMessage("你是一个法律顾问，请提供专业的法律建议。")
    String chat(String message);
    
    @UserMessage("用户{userId}问: {message}")
    String chatWithContext(String userId, String message);
}

2.2 ChatGPT / Claude SDK

OpenAI Java SDK

1
2
3
4
5
<dependency>
    <groupId>com.theokanning.openai-gpt3-java</groupId>
    <artifactId>service</artifactId>
    <version>0.18.2</version>
</dependency>

Anthropic Java SDK

1
2
3
4
5
<dependency>
    <groupId>com.sleepycat</groupId>
    <artifactId>anthropic-java</artifactId>
    <version>0.8.0</version>
</dependency>

三、MCP 协议（Model Context Protocol）

3.1 什么是 MCP？

MCP（Model Context Protocol） 是 Anthropic 提出的模型上下文协议，用于标准化 AI 模型与外部工具/数据源的连接。

核心概念

  • MCP Host：运行 AI 应用的程序
  • MCP Client：在 Host 内与 MCP Server 通信
  • MCP Server：提供工具、资源、提示词的服务端
  • Transport：通信协议（stdio、HTTP/SSE）

MCP 与 Function Calling 的区别

维度 Function Calling MCP
标准化 厂商私有协议 开放标准
适用范围 单模型 多模型通用
资源类型 仅工具 工具+资源+提示词
生态 依赖模型厂商 独立生态

3.2 Java MCP SDK

核心依赖

1
2
3
4
5
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-mcp</artifactId>
    <version>1.0.0-M4</version>
</dependency>

MCP Server 示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MyMcpServer {
    
    @Tool(name = "search_database", description = "搜索数据库中的记录")
    public List<String> searchDatabase(@ToolParam("查询条件") String query) {
        // 实现搜索逻辑
        return database.search(query);
    }
    
    @Tool(name = "send_email", description = "发送邮件")
    public void sendEmail(
        @ToolParam("收件人") String to,
        @ToolParam("主题") String subject,
        @ToolParam("内容") String content
    ) {
        emailService.send(to, subject, content);
    }
}

3.3 MCP 生态工具

工具 类型 说明
FS MCP 文件系统 读写本地文件
GitHub MCP API集成 操作 GitHub 仓库
Postgres MCP 数据库 PostgreSQL 操作
Slack/Discord MCP 消息 发送消息
Browser MCP 浏览器 网页访问/爬取
Memory MCP 知识库 持久化记忆

四、向量数据库

4.1 什么是向量数据库？

向量数据库专门用于存储和检索高维向量（Embedding），是 RAG 架构的核心组件。

4.2 主流向量数据库对比

数据库 类型 特点 Java支持
Milvus 云原生开源 高性能、万亿级向量 ✅ 成熟
Qdrant 开源 Rust实现、高可用 ✅ 成熟
Chroma 轻量开源 简单易用、本地优先 ✅ 良好
Weaviate 云原生开源 混合搜索、GraphQL ✅ 良好
Pinecone 云服务 全托管、免运维 ✅ 良好
**Pgvector PostgreSQL扩展 兼容现有DB、简单场景 ✅ 成熟

4.3 Java 集成示例

Spring Data Vector（Spring AI）

1
2
3
4
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-embedding</artifactId>
</dependency>

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@RestController
public class RagController {
    
    private final VectorStore vectorStore;
    private final ChatClient chatClient;
    
    public RagController(VectorStore vectorStore, ChatClient chatClient) {
        this.vectorStore = vectorStore;
        this.chatClient = chatClient;
    }
    
    // 文档入库
    @PostMapping("/ingest")
    public void ingestDocument(@RequestParam String text) {
        vectorStore.add(List.of(new Document(text)));
    }
    
    // RAG 问答
    @GetMapping("/rag-chat")
    public String ragChat(@RequestParam String question) {
        List<Document> relevantDocs = vectorStore.similaritySearch(question);
        
        String context = relevantDocs.stream()
            .map(Document::getContent)
            .collect(Collectors.joining("\n"));
        
        return chatClient.prompt()
            .system("基于以下上下文回答：" + context)
            .user(question)
            .call()
            .content();
    }
}

五、Agent 开发框架

5.1 Java Agent 框架对比

框架 特点 适用场景
LangChain4j 功能全面、生态成熟 通用 Agent
Spring AI Agent Spring 生态集成 Spring 项目
**AutoGPT Java 单Agent自主执行 实验/学习
**CrewAI Java 多Agent协作 复杂任务流

5.2 LangChain4j Agent 示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 定义工具
public class WeatherTools {
    @Tool("获取城市天气")
    public String getWeather(@P("城市名称") String city) {
        return "北京今天晴，25度";
    }
}

// 构建 Agent
ChatLanguageModel model = OpenAiChatModel.builder()
    .apiKey("your-api-key")
    .build();

Agent agent = Agent.builder()
    .name("助手")
    .prompt("你是一个有用的助手，可以回答问题和使用工具。")
    .tools(new WeatherTools())
    .chatLanguageModel(model)
    .build();

ChatMemory memory = MessageWindowChatMemory.withMaxMessages(10);
ExecutorService executor = Executors.newSingleThreadExecutor();

ChatAgent chatAgent = ChatAgent.builder()
    .agent(agent)
    .chatMemory(memory)
    .executorService(executor)
    .build();

// 对话
String response = chatAgent.chat("北京天气怎么样？");
System.out.println(response);

5.3 ReAct 模式

ReAct（Reasoning + Acting） 是 Agent 的核心决策模式：

1
Thought（思考） → Action（行动） → Observation（观察） → ...

LangChain4j 内置支持 ReAct：

1
2
3
4
5
6
7
8
9
ChatLanguageModel model = OpenAiChatModel.builder()
    .apiKey(System.getenv("OPENAI_API_KEY"))
    .build();

ReActAgent agent = ReActAgent.builder()
    .chatLanguageModel(model)
    .tools(List.of(new Calculator(), new WeatherTools()))
    .maxIterations(10)
    .build();

六、Skills 技能系统

6.1 什么是 Skills？

Skills（技能） 是 Agent 调用工具/执行任务的能力单元，是比 MCP 更上层的抽象。

Skills vs MCP

维度 MCP Skills
层级 协议层 应用层
粒度 原子工具 复合技能
用途 工具调用 任务执行
生态 工具市场 技能市场

6.2 Java Skills 实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Skill(name = "文档摘要", description = "对一篇文章生成摘要")
public class SummarizeSkill {
    
    private final ChatClient chatClient;
    
    public SummarizeSkill(ChatClient chatClient) {
        this.chatClient = chatClient;
    }
    
    @Execute
    public String execute(@Param("content") String content,
                         @Param("maxLength") Integer maxLength) {
        return chatClient.prompt()
            .system("你是一个专业的文档摘要助手，请用简洁的语言总结以下内容：")
            .user("内容：\n" + content)
            .call()
            .content();
    }
}

6.3 Skills 编排

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Skill(name = "研究助手", description = "完成一项研究任务")
public class ResearchSkill {
    
    @SkillReference("网络搜索")
    private SearchSkill searchSkill;
    
    @SkillReference("文档摘要")
    private SummarizeSkill summarizeSkill;
    
    @SkillReference("文档写作")
    private WriteSkill writeSkill;
    
    public String research(String topic) {
        // 1. 搜索相关信息
        List<String> results = searchSkill.search(topic);
        
        // 2. 摘要每条结果
        List<String> summaries = results.stream()
            .map(summarizeSkill::execute)
            .toList();
        
        // 3. 整理成报告
        return writeSkill.write(topic, summaries);
    }
}

七、RAG 完整架构

7.1 RAG 工作流程

1
2
3
4
5
6
7
8
9
10
11
12
13
┌─────────────────────────────────────────────────────────┐
│                      RAG 架构                            │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   文档输入 ──→ 文本分割 ──→ Embedding ──→ 向量存储      │
│                           ↓                             │
│                        原始文本存储                       │
│                                                         │
│   用户查询 ──→ Embedding ──→ 向量检索 ──→ 混合排序       │
│                           ↓                             │
│   上下文构建 ──→ Prompt 组装 ──→ LLM 生成 ──→ 回答     │
│                                                         │
└─────────────────────────────────────────────────────────┘

7.2 Java RAG 实现

文档处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Configuration
public class RagConfig {
    
    @Bean
    public DocumentReader documentReader() {
        return new TextDocumentReader();
    }
    
    @Bean
    public TextSplitter textSplitter() {
        return new TokenTextSplitter(500, 100);
    }
    
    @Bean
    public EmbeddingModel embeddingModel() {
        return new OpenAiEmbeddingModel(
            OpenAiApi.withApiKey(System.getenv("OPENAI_API_KEY"))
        );
    }
    
    @Bean
    public VectorStore vectorStore(EmbeddingModel model) {
        return new InMemoryVectorStore(model);
    }
}

RAG 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Service
public class RagService {
    
    private final DocumentReader reader;
    private final TextSplitter splitter;
    private final EmbeddingModel embeddingModel;
    private final VectorStore vectorStore;
    private final ChatClient chatClient;
    
    // 文档入库
    public void ingest(String filePath) {
        Document doc = reader.read(filePath);
        List<Document> chunks = splitter.split(doc);
        vectorStore.add(chunks);
    }
    
    // RAG 问答
    public String query(String question) {
        // 1. 检索相关文档
        List<Document> docs = vectorStore.similaritySearch(question, 5);
        
        // 2. 构建上下文
        String context = docs.stream()
            .map(d -> "【文档】" + d.getContent())
            .collect(Collectors.joining("\n\n"));
        
        // 3. 生成回答
        return chatClient.prompt()
            .system("基于以下上下文回答用户问题，如果上下文不足，请如实说明。\n\n" + context)
            .user(question)
            .call()
            .content();
    }
}

八、开发工具链

8.1 IDE 推荐

IDE 特点
IntelliJ IDEA Java 开发首选，AI 插件丰富
VS Code 轻量，配合 Spring Tools 也不错
Cursor AI 原生 IDE，代码补全强大

8.2 AI 相关插件

插件 功能
GitHub Copilot 代码补全
Alibaba Cloud AI 国内模型集成
Continue 开源 AI 代码助手
Spring AI Spring AI 官方支持

8.3 测试工具

工具 用途
Postman API 测试
Silicon Flow API 调试
Portkey LLM 调用追踪

九、部署与运维

9.1 Docker 部署

1
2
3
4
5
FROM eclipse-temurin:21-jdk-alpine
WORKDIR /app
COPY target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

9.2 云服务选型

云服务 特点
阿里云 百炼、通义、魔搭
百度智能云 文心、AgentBuilder
Azure OpenAI GPT 全家桶
AWS Bedrock Claude、Mistral

9.3 监控与日志

组件 工具
日志 ELK Stack、Loki
监控 Prometheus + Grafana
链路追踪 SkyWalking、Zipkin

十、学习路径建议

入门路线

1
2
3
4
5
6
7
8
9
10
11
第一阶段：Java 基础 + Spring Boot
    ↓
第二阶段：大模型入门（Prompt Engineering）
    ↓
第三阶段：Spring AI / LangChain4j 集成
    ↓
第四阶段：RAG 实战（向量数据库 + Embedding）
    ↓
第五阶段：MCP 协议 + Agent 开发
    ↓
第六阶段：Skills 编排 + 生产部署

推荐学习资源

资源类型 推荐
官方文档 Spring AI Docs、LangChain4j Docs
开源项目 Spring AI Samples、LangChain4j Examples
视频课程 B站 AI + Java 系列
社区 Spring AI GitHub Issues、AI Java 开发者社群

总结

Java + AI Agent 开发技术栈可分为以下几个层次：

层次 组件 作用
基础层 Spring Boot Web 服务基础
AI层 Spring AI / LangChain4j 大模型集成
协议层 MCP 标准化工具调用
存储层 向量数据库 语义检索
应用层 Agent / Skills 智能任务执行
运维层 Docker / K8s 部署运维

掌握这些技术栈，开发者可以快速构建企业级的 AI 应用，从简单的 AI 助手到复杂的自主 Agent 系统。

💡 后续学习

  • Spring AI 官方文档与示例
  • LangChain4j GitHub 仓库
  • MCP 官方规范与实现
  • RAG 技术深度实践