20K Java+AI 岗位2025-2026最热考点 — Spring AI是Java生态AI应用开发的标准框架,MCP是连接AI与外部世界的协议标准。覆盖Spring AI 2.0架构、ChatClient/Advisors/VectorStore、MCP Server/Client、Tool Calling、Multi-Agent、Observability。
应用层: ChatClient / ChatModel
编排层: Advisors(拦截器链) + Tool Calling
集成层: VectorStore / Embedding / Image / Audio
传输层: OpenAI/Azure/Ollama/Bedrock/ZhiPu等Provider
| 维度 | Spring AI | LangChain4j |
|---|---|---|
| 生态 | Spring生态,无缝集成Boot | 独立框架,轻量接入 |
| 模型支持 | OpenAI/Azure/Ollama/Bedrock等 | 更多Provider覆盖 |
| 向量库 | Milvus/Redis/PgVector/Chroma等 | 更多选择 |
| MCP | 原生支持(官方实现) | 社区支持 |
| 编排 | Advisor链式架构 | Chain/Agent模式 |
| 适用 | Spring Boot项目首选 | 轻量/非Spring项目 |
选型建议:Spring Boot项目用Spring AI,非Spring项目或需要更多Provider选LangChain4j。
// 构建ChatClient
ChatClient chatClient = ChatClient.builder(chatModel)
.defaultSystem("你是Java技术专家,回答要简洁准确")
.defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))
.build();
// 同步调用
String response = chatClient.prompt()
.user("什么是AQS?请简要说明")
.call()
.content();
// 流式调用
Flux<String> stream = chatClient.prompt()
.user("解释Java线程池核心参数")
.stream()
.content();
核心要点:ChatClient是高层API,底层委托给ChatModel。支持同步/流式两种调用模式,defaultSystem设置系统提示,defaultAdvisors注册拦截器。
Model接口层级:
Model<TReq, TRes>
├── ChatModel → 文本对话(GPT-4o/Qwen/DeepSeek)
├── EmbeddingModel → 文本向量化(text-embedding-3)
├── ImageModel → 图片生成(DALL-E/Stable Diffusion)
├── AudioModel → 语音处理(Whisper/TTS)
└── ToolCallingModel → 工具调用(函数调用能力)
call()方法,各Provider实现具体逻辑spring.ai.openai.chat.options.model配置切换模型
spring:
ai:
openai:
api-key: ${OPENAI_API_KEY}
base-url: https://api.openai.com # 可换成国内代理
chat:
options:
model: gpt-4o
temperature: 0.7
max-tokens: 2048
embedding:
options:
model: text-embedding-3-small
# 国产模型配置示例(智谱AI)
zhipuai:
api-key: ${ZHIPU_API_KEY}
chat:
options:
model: glm-4-plus
多Provider切换:改spring.ai.*前缀即可。OpenAI/ZhiPu/Ollama/Azure/Bedrock配置结构类似。生产环境api-key走配置中心或环境变量,不硬编码。
public class LoggingAdvisor implements CallAroundAdvisor {
@Override
public String getName() {
return "LoggingAdvisor";
}
@Override
public int getOrder() {
return 100; // 数字越小优先级越高
}
@Override
public AdvisedResponse aroundCall(AdvisedRequest request,
CallAroundAdvisorChain chain) {
log.info("[AI请求] user: {}", request.userText());
long start = System.currentTimeMillis();
AdvisedResponse response = chain.nextAroundCall(request);
long cost = System.currentTimeMillis() - start;
String content = response.response().getResult().getOutput().getText();
log.info("[AI响应] cost={}ms, content={}", cost,
content.length() > 200 ? content.substring(0, 200) + "..." : content);
return response;
}
}
关键点:实现CallAroundAdvisor接口,chain.nextAroundCall()调用下一个Advisor。getOrder()控制执行顺序。
| Advisor | 作用 | 典型场景 |
|---|---|---|
| MessageChatMemoryAdvisor | 对话记忆管理 | 多轮对话保持上下文 |
| SimpleLoggerAdvisor | 请求/响应日志 | 开发调试 |
| SafeGuardAdvisor | 安全过滤 | 防止敏感信息泄露 |
| QuestionAnswerAdvisor | RAG检索增强 | 基于文档的问答 |
| RetryAdvisor | 重试机制 | 模型调用失败自动重试 |
组合使用:多个Advisor按order值排序,形成完整的处理链。生产环境通常组合记忆+日志+安全+RAG。
@Bean
ChatClient chatClient(ChatModel model) {
// 开发环境用内存存储
ChatMemory memory = new InMemoryChatMemory();
// 生产环境用Redis持久化
// ChatMemory memory = new RedisChatMemory(redisTemplate);
return ChatClient.builder(model)
.defaultSystem("你是客服助手")
.defaultAdvisors(new MessageChatMemoryAdvisor(memory))
.build();
}
// 调用时指定会话ID,自动维护历史
String response = chatClient.prompt()
.user("我想查一下我的订单")
.advisors(a -> a.param("chat_memory_conversation_id", "user-123"))
.call()
.content();
原理:MessageChatMemoryAdvisor在请求前从存储加载历史消息,在响应后将新消息存入存储。conversationId隔离不同会话。
请求方向(正序):
LoggingAdvisor → MemoryAdvisor → SafeGuardAdvisor → LLM
响应方向(倒序):
LLM → SafeGuardAdvisor → MemoryAdvisor → LoggingAdvisor
类似Filter链:
A.before → B.before → C.before → 实际调用 → C.after → B.after → A.after
@Tool注解声明式定义工具
// 定义工具类
@Service
public class OrderTools {
@Tool(description = "查询用户订单列表,返回订单摘要信息")
public List<OrderVO> queryOrders(
@ToolParam(description = "用户ID") Long userId,
@ToolParam(description = "订单状态:PAID/SHIPPED/COMPLETED") String status) {
return orderService.findByUserAndStatus(userId, status);
}
@Tool(description = "取消指定订单")
public String cancelOrder(
@ToolParam(description = "订单号") String orderId,
@ToolParam(description = "取消原因") String reason) {
orderService.cancel(orderId, reason);
return "订单" + orderId + "已取消";
}
}
// 注册到ChatClient
ChatClient chatClient = ChatClient.builder(model)
.defaultTools(orderTools)
.build();
// 用户问"帮我查一下用户1001的待发货订单"→LLM自动调用queryOrders(1001, "PAID")
1. 用户: "北京今天天气怎么样?"
2. LLM决策: 需要调用getWeather工具,参数={city: "北京"}
3. 应用执行: getWeather("北京") → "晴天,25°C"
4. 工具结果返回LLM
5. LLM生成最终回答: "北京今天天气晴朗,气温25度,适合外出。"
@Service
public class DatabaseTools {
private final JdbcTemplate jdbcTemplate;
@Tool(description = "执行SQL查询,返回JSON结果。仅支持SELECT语句。")
public String executeQuery(
@ToolParam(description = "SQL查询语句,只允许SELECT") String sql) {
// 安全校验:只允许SELECT
String trimmed = sql.trim().toUpperCase();
if (!trimmed.startsWith("SELECT")) {
return "错误:只允许查询操作(SELECT)";
}
// 禁止危险操作
if (trimmed.contains("DROP") || trimmed.contains("DELETE") ||
trimmed.contains("UPDATE") || trimmed.contains("INSERT")) {
return "错误:检测到不允许的SQL操作";
}
try {
List<Map<String, Object>> result = jdbcTemplate.queryForList(sql);
return new ObjectMapper().writeValueAsString(result);
} catch (Exception e) {
return "查询执行失败:" + e.getMessage();
}
}
}
离线写入流程:
文档(Document) → TextSplitter(分块) → EmbeddingModel(向量化) → VectorStore(存储)
在线查询流程:
用户问题 → Embedding(向量化) → VectorStore.similaritySearch(检索)
→ QuestionAnswerAdvisor(注入上下文) → LLM(生成回答)
// 配置PgVector向量库
@Bean
VectorStore vectorStore(JdbcTemplate jdbcTemplate, EmbeddingModel embeddingModel) {
return new PgVectorStore(jdbcTemplate, embeddingModel);
}
// 添加文档
List<Document> documents = List.of(
new Document("Java并发编程中,synchronized是内置锁...", Map.of("source", "java-guide")),
new Document("volatile保证可见性但不保证原子性...", Map.of("source", "juc-notes"))
);
vectorStore.add(documents);
// 相似度检索
List<Document> results = vectorStore.similaritySearch(
SearchRequest.builder()
.query("Java锁机制")
.topK(5)
.similarityThreshold(0.7)
.build()
);
// results即为与"Java锁机制"最相关的5个文档片段
| 向量库 | 特点 | 适用场景 |
|---|---|---|
| PgVector | PostgreSQL扩展,SQL生态 | 已有PG库的项目首选 |
| Milvus | 高性能分布式 | 大规模向量检索 |
| Redis | 基于RediSearch | 缓存+向量一体化 |
| Chroma | 轻量级Python向量库 | 开发测试 |
| Pinecone | 全托管云服务 | 免运维场景 |
| Weaviate | 语义搜索引擎 | 复杂语义查询 |
| Elasticsearch | 向量+全文混合检索 | 已有ES基础设施 |
Java项目推荐:PgVector(简单)或Milvus(大规模)。
// 1. 读取文档
DocumentReader reader = new TextReader(new ClassPathResource("docs/java-guide.txt"));
// PDF文档: new PagePdfDocumentReader(resource)
// Word文档: new WordDocumentReader(resource)
// 2. 文档分块
TextSplitter splitter = new TokenTextSplitter(
800, // 每块最大Token数
200, // 相邻块重叠Token数
5, // 最小块大小
10000, // 最大块大小
true // 是否保留分隔符
);
// 3. 处理并存储
List<Document> documents = splitter.apply(reader.get());
vectorStore.add(documents);
// 完整Pipeline
@Bean
ETLPipeline etlPipeline(DocumentReader reader, TextSplitter splitter, VectorStore store) {
return new ETLPipeline(reader, splitter, store);
}
@Bean
ChatClient ragChatClient(ChatModel model, VectorStore store) {
return ChatClient.builder(model)
.defaultSystem("基于以下参考信息回答问题,如果参考信息中没有相关内容,请说明。")
.defaultAdvisors(new QuestionAnswerAdvisor(store))
.build();
}
// 调用:自动检索相关文档注入上下文
String answer = chatClient.prompt()
.user("什么是Java的CAS操作?")
.call()
.content();
// QuestionAnswerAdvisor自动:
// 1.将"什么是CAS"向量化
// 2.从VectorStore检索相关文档
// 3.注入到Prompt上下文
// 4.LLM基于上下文生成回答
| 概念 | 说明 | 类比 |
|---|---|---|
| MCP Server | 提供工具/资源/提示的服务端 | Web API服务 |
| MCP Client | 连接MCP Server的客户端 | HTTP客户端 |
| Tools | Server暴露的可调用函数 | REST接口 |
| Resources | Server暴露的数据资源 | 文件/数据源 |
| Prompts | Server暴露的Prompt模板 | 模板引擎 |
| Transport | 通信方式 | HTTP/TCP |
@Configuration
public class McpServerConfig {
@Bean
public McpSyncServer mcpServer() {
return McpServer.sync()
.serverInfo("order-tools", "1.0.0")
.tool(queryOrderTool())
.tool(createOrderTool())
.resource(orderSchemaResource())
.prompt(orderQueryPrompt())
.build();
}
private McpServerFeatures.SyncToolSpecification queryOrderTool() {
return new McpServerFeatures.SyncToolSpecification(
new Tool("queryOrder", "根据订单号查询订单详情",
// JSON Schema定义参数
"""{"type":"object","properties":{
"orderId":{"type":"string","description":"订单号"}
},"required":["orderId"]}"""),
(exchange, args) -> {
String orderId = (String) args.get("orderId");
Order order = orderService.findById(orderId);
return new CallToolResult(List.of(
new TextContent(objectMapper.writeValueAsString(order))
));
}
);
}
}
@Configuration
public class McpClientConfig {
@Bean
public SyncMcpClient mcpClient() {
return SyncMcpClient.builder()
.transport(new HttpMcpTransport(
"http://localhost:3000/mcp"))
.build();
}
// 自动发现Server的工具并注册为Spring AI Tool
@Bean
public ToolCallbackProvider mcpToolProvider(SyncMcpClient client) {
// 连接Server,获取所有工具定义
var tools = client.listTools();
// 转换为Spring AI ToolCallback
return SyncMcpToolCallbackProvider.builder()
.mcpClient(client)
.build();
}
}
关键:MCP Client连接Server后,自动发现其工具,并注册为Spring AI的Tool,无缝集成。
| 维度 | Function Calling | MCP |
|---|---|---|
| 定义者 | 各模型厂商(OpenAI/Google等) | Anthropic提出,开放标准 |
| 范围 | 单模型接口规范 | 跨厂商跨应用协议 |
| 能力 | 只有函数调用 | 工具+资源+提示 |
| 通信 | API调用 | stdio/SSE/HTTP |
| 复用性 | 绑定模型 | 一次开发,多AI应用复用 |
| 生态 | 各厂商自定义 | 统一标准,生态丰富 |
结论:Function Calling是单厂商能力,MCP是行业标准。两者互补,不冲突。
| Transport | 方式 | 适用场景 |
|---|---|---|
| stdio | 本地进程标准输入输出 | IDE插件、CLI工具 |
| SSE | HTTP Server-Sent Events | Web应用(旧版) |
| Streamable HTTP | 无状态HTTP请求 | 新版推荐,支持无状态部署 |
# stdio方式(本地进程)
spring:
ai:
mcp:
client:
stdio:
servers-configuration: classpath:mcp-servers.json
# HTTP方式(远程服务)
spring:
ai:
mcp:
client:
http:
base-url: http://localhost:3000/mcp
选型:本地工具用stdio,远程服务用Streamable HTTP。
<!-- pom.xml添加依赖 -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-mcp-server-spring-boot-starter</artifactId>
</dependency>
# application.yml
spring:
ai:
mcp:
server:
name: my-tools-server
version: 1.0.0
type: SYNC
sse-message-endpoint: /mcp/messages
// 自动将@Tool方法暴露为MCP Tools
@Service
public class MyTools {
@Tool(description = "获取当前时间")
public String getCurrentTime() {
return LocalDateTime.now().toString();
}
}
// 无需额外配置,Starter自动完成MCP Server注册
// 定义输出结构(支持Record/POJO)
record OrderInfo(
String orderId,
String status,
BigDecimal amount,
LocalDateTime createTime
) {}
// 调用并自动映射
OrderInfo order = chatClient.prompt()
.user("提取订单信息:订单号12345,已发货,金额99.9元,2025-01-15下单")
.call()
.entity(OrderInfo.class);
// order.orderId() == "12345"
// order.status() == "已发货"
// order.amount() == 99.9
// 支持List输出
record MovieReview(String title, int rating, String comment) {}
List<MovieReview> reviews = chatClient.prompt()
.user("分析这三部电影的评价...")
.call()
.entity(new ParameterizedTypeReference<List<MovieReview>>() {});
// 1. 使用BeanOutputConverter显式控制
BeanOutputConverter<OrderInfo> converter =
new BeanOutputConverter<>(OrderInfo.class);
String response = chatClient.prompt()
.user(u -> u.text("提取订单信息:{info}\n{format}")
.param("info", "订单号12345,已发货,99.9元")
.param("format", converter.getFormat()))
.call()
.content();
OrderInfo order = converter.convert(response);
// 2. 配合重试保证成功率
// 3. Schema约束越严格,成功率越高(必填字段、枚举值)
// 4. Prompt中明确格式要求和示例
// 情感分析
enum Sentiment { POSITIVE, NEGATIVE, NEUTRAL }
Sentiment sentiment = chatClient.prompt()
.user("分析情感:这个产品质量很好,物流也快")
.call()
.entity(Sentiment.class);
// → POSITIVE
// 文本分类
enum Category { TECH, FINANCE, SPORTS, ENTERTAINMENT, OTHER }
Category category = chatClient.prompt()
.user("分类:苹果发布新款MacBook Pro")
.call()
.entity(Category.class);
// → TECH
底层原理:Spring AI将Enum转成JSON Schema的enum约束,LLM被限制只能输出合法枚举值。
监控体系:
Spring AI → Micrometer → Prometheus → Grafana
核心指标:
ai.chat.tokens.input → 输入Token数
ai.chat.tokens.output → 输出Token数
ai.chat.latency → 调用延迟
ai.chat.errors → 错误次数
ai.tool.call.latency → 工具调用延迟
ai.tool.call.errors → 工具调用错误
@Component
public class TokenUsageAdvisor implements CallAroundAdvisor {
private final MeterRegistry meterRegistry;
@Override
public AdvisedResponse aroundCall(AdvisedRequest request,
CallAroundAdvisorChain chain) {
AdvisedResponse response = chain.nextAroundCall(request);
Usage usage = response.response().getMetadata().getUsage();
// 记录Token指标
meterRegistry.counter("ai.tokens.input",
"model", request.model()).increment(usage.getPromptTokens());
meterRegistry.counter("ai.tokens.output",
"model", request.model()).increment(usage.getGenerationTokens());
// 计算成本(以GPT-4o为例)
double cost = usage.getPromptTokens() * 0.0000025
+ usage.getGenerationTokens() * 0.00001;
meterRegistry.counter("ai.cost.usd",
"model", request.model()).increment(cost);
return response;
}
}
| 告警项 | 阈值 | 原因 |
|---|---|---|
| Token用量突增 | 日用量超均值3倍 | 成本失控/Prompt注入攻击 |
| P99延迟 | > 5秒 | 用户体验差/模型过载 |
| 错误率 | > 5% | 模型不可用/配置错误 |
| 幻觉率 | 抽检发现率>10% | RAG检索质量差/Prompt问题 |
| 工具调用失败率 | > 3% | 下游服务异常 |
"我们用Spring AI 2.0搭建AI中台。ChatClient + Advisor架构统一管理对话流程,Advisor链实现记忆/日志/RAG/安全四大增强。VectorStore用Milvus存储文档Embedding,支持千万级向量检索。Tool Calling让Agent调用订单/库存等内部API,实现业务自动化。MCP协议标准化工具注册和发现,各部门服务统一MCP Server化。Observability做Token监控和成本管控,月度成本降低40%。"
@Tool注解声明式定义,自动注册| 场景 | 推荐模型 | 理由 |
|---|---|---|
| 通用对话 | GPT-4o | 综合能力最强 |
| 企业合规 | Azure OpenAI | 数据不训练、SLA保障 |
| 国内替代 | 智谱GLM-4 / DeepSeek-V3 | 无需翻墙、性价比高 |
| 本地部署 | Ollama + Qwen2.5 | 数据不出内网 |
| 性价比 | DeepSeek-V3 | 效果接近GPT-4,价格1/10 |
| 代码场景 | Claude 3.5 Sonnet | 代码理解/生成最强 |
Spring AI统一接口,切换只改配置:spring.ai.openai.chat.options.model=xxx
测试金字塔:
┌──────────────┐
│ LLM-as-Judge │ ← 自动化质量评估(少量)
├──────────────┤
│ Golden Set │ ← 回归测试集(中等)
├──────────────┤
│ Mock LLM │ ← 单元测试(大量)
└──────────────┘
企业AI中台架构:
┌─────────────────────────────────┐
│ Spring Boot 应用 │
│ ┌───────────────────────────┐ │
│ │ Spring AI ChatClient │ │
│ │ + Advisor Chain │ │
│ └──────────┬────────────────┘ │
│ │ │
│ ┌──────────▼────────────────┐ │
│ │ MCP Client │ │
│ │ (工具发现 + 调用路由) │ │
│ └──┬───────┬───────┬───────┘ │
└─────┼───────┼───────┼──────────┘
│ │ │
┌────▼──┐ ┌─▼───┐ ┌─▼──────┐
│订单 │ │库存 │ │知识库 │
│MCP │ │MCP │ │MCP │
│Server │ │Server│ │Server │
└───────┘ └─────┘ └────────┘
┌─────────────────────────────┐
│ Milvus(VectorStore) │
│ Prometheus(Observability) │
└─────────────────────────────┘
| 方案 | 存储 | 适用场景 | 特点 |
|---|---|---|---|
| InMemoryChatMemory | 内存 | 开发测试 | 重启丢失 |
| RedisChatMemory | Redis | 生产环境 | 高性能持久化 |
| JdbcChatMemory | 数据库 | 需要持久化 | 可查询可审计 |
| WindowedChatMemory | 装饰器 | 控制Token | 只保留最近N轮 |
| SummarizingChatMemory | 装饰器 | 长对话 | 旧消息压缩为摘要 |
// 组合使用:Redis存储 + 窗口限制 + 摘要压缩
ChatMemory memory = new SummarizingChatMemory(
new WindowedChatMemory(
new RedisChatMemory(redisTemplate),
10 // 最近10轮
),
chatModel // 用LLM做摘要
);
// 1. Feature Flag控制新旧Prompt
@Value("${ai.prompt.version:v1}")
private String promptVersion;
// 2. 模型路由(A/B分流)
public ChatModel routeModel(String userId) {
if (abTestService.inGroup(userId, "experimental")) {
return gpt4oModel; // 实验组:新模型
}
return deepSeekModel; // 对照组:稳定模型
}
// 3. 灰度策略
// - 按用户ID哈希分流(5% → 10% → 50% → 100%)
// - 按地域/租户/业务线灰度
// 4. 效果对比Dashboard
// - 对比两组的:回答质量评分 / Token消耗 / 用户满意度
// 图片生成
ImageResponse image = chatClient.prompt()
.user("画一只JavaLogo风格的猫")
.call()
.image(); // ImageModel: DALL-E / Stable Diffusion
// 语音转文字(Whisper)
AudioTranscriptionResponse transcription = audioModel.transcribe(
new AudioTranscriptionPrompt(new ClassPathResource("meeting.wav"))
);
// 文字转语音(TTS)
byte[] speech = audioModel.synthesize(
new AudioSynthesisPrompt("欢迎使用AI助手")
);
// 多模态输入(图片理解)
String response = chatClient.prompt()
.user(u -> u.text("描述这张图片的内容")
.media(Media.ImageMimeType.PNG, imageResource))
.call()
.content();
@Component
public class FaultToleranceAdvisor implements CallAroundAdvisor {
@Override
public AdvisedResponse aroundCall(AdvisedRequest request,
CallAroundAdvisorChain chain) {
try {
return chain.nextAroundCall(request);
} catch (ModelClientException e) {
// 模型不可用 → 降级到备用模型
log.warn("主模型不可用,降级到备用模型: {}", e.getMessage());
return callWithFallback(request);
} catch (TokenLimitExceededException e) {
// Token超限 → 截断上下文重试
log.warn("Token超限,截断上下文重试");
return callWithTruncatedContext(request);
}
}
}
// 工具调用失败 → 重试+默认值
@Retryable(maxAttempts = 3, fallbackMethod = "defaultWeather")
@Tool(description = "查询天气")
public String getWeather(String city) { ... }
public String defaultWeather(String city) {
return "暂时无法获取天气信息";
}
// 流式输出(SSE推送到前端)
@GetMapping(value = "/chat/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamChat(@RequestParam String message) {
return chatClient.prompt()
.user(message)
.stream()
.content();
}
// 前端接收(JavaScript)
const eventSource = new EventSource("/chat/stream?message=解释Java线程池");
eventSource.onmessage = (event) => {
document.getElementById("response").textContent += event.data;
};
// 流式结构化输出
Flux<OrderInfo> orderStream = chatClient.prompt()
.user("提取订单列表")
.stream()
.entities(OrderInfo.class);
// 输入Guardrail:防止Prompt注入
public class InputGuardrailAdvisor implements CallAroundAdvisor {
private static final List<String> DANGEROUS_PATTERNS = List.of(
"ignore previous instructions",
"system:",
"你是一个"
);
@Override
public AdvisedResponse aroundCall(AdvisedRequest request,
CallAroundAdvisorChain chain) {
String userText = request.userText().toLowerCase();
for (String pattern : DANGEROUS_PATTERNS) {
if (userText.contains(pattern)) {
throw new GuardrailException("检测到潜在的Prompt注入: " + pattern);
}
}
return chain.nextAroundCall(request);
}
}
// 输出Guardrail:过滤PII和有害内容
// 使用正则匹配手机号/身份证号并脱敏
// 使用LLM评估输出安全性(输出有害概率>阈值则拦截)
// 1. RelevanceAdvisor - 评估检索相关性
@Bean
ChatClient evalChatClient(ChatModel model, VectorStore store) {
return ChatClient.builder(model)
.defaultAdvisors(
QuestionAnswerAdvisor.builder(store)
.relevanceThreshold(0.7) // 相关性阈值
.build()
)
.build();
}
// 2. LLM-as-Judge评分
record EvalResult(double relevance, double accuracy, double safety, String feedback) {}
EvalResult eval = chatClient.prompt()
.user(u -> u.text("""
评估以下回答的质量:
问题:{question}
回答:{answer}
参考答案:{reference}
从相关性(0-1)、准确性(0-1)、安全性(0-1)三个维度评分。
""")
.param("question", question)
.param("answer", answer)
.param("reference", reference))
.call()
.entity(EvalResult.class);
// 3. 自动化评估Pipeline:批量跑Golden Set → 生成评估报告
推广路径:
1. 工具MCP Server化:各部门将API封装为MCP Server
2. 统一注册中心:MCP Registry(类似Nacos),管理所有Server
3. 版本管理:Server版本化,Client按需升级
4. 权限控制:OAuth2鉴权 + 工具级别授权
5. 监控Dashboard:工具调用量/延迟/错误率可视化
示例架构:
MCP Registry (注册中心)
├── order-service v2.1 (订单工具)
├── inventory-service v1.5 (库存工具)
├── knowledge-service v3.0 (知识库工具)
└── notification-service v1.0 (通知工具)
AI应用 → MCP Client → Registry发现 → 调用具体Server
// 1. 模型路由 - 简单问题用小模型
public ChatModel routeByComplexity(String question) {
if (question.length() < 50 && !question.contains("分析")) {
return deepSeekModel; // 便宜模型处理简单问题
}
return gpt4oModel; // 复杂问题用强模型
}
// 2. 语义缓存 - 相似问题不重复调LLM
@Component
public class SemanticCacheAdvisor implements CallAroundAdvisor {
@Override
public AdvisedResponse aroundCall(AdvisedRequest request,
CallAroundAdvisorChain chain) {
// 将问题向量化,在缓存中查找相似问题
float[] embedding = embeddingModel.embed(request.userText());
CacheEntry cached = cacheService.findSimilar(embedding, 0.95);
if (cached != null) {
return cached.getResponse(); // 缓存命中,省一次LLM调用
}
AdvisedResponse response = chain.nextAroundCall(request);
cacheService.put(embedding, response);
return response;
}
}
// 3. Token优化:精简Prompt、压缩历史、限制输出长度
// 4. 批量处理:非实时任务走Batch API,成本降50%
// 5. 监控告警:日Token消耗超预算自动通知
| 方向 | 说明 | 预期 |
|---|---|---|
| Multi-Agent编排 | 多Agent协作框架(类似CrewAI) | 2025-2026重点 |
| MCP生态扩展 | 更多工具MCP Server化 | 持续增长 |
| Agent Workflow DSL | 声明式Agent工作流定义 | 社区提案中 |
| Observability增强 | 更细粒度的Tracing/Metrics | 持续完善 |
| Java AI标准JSR | JDK层面标准化AI接口 | 长期目标 |
| 流式Agent | 流式Tool Calling + 流式推理 | 已在开发 |
| 本地模型优化 | 更好的Ollama/ONNX集成 | 持续改进 |
Spring AI三核心:ChatClient(对话)、Advisor(拦截增强)、Tool Calling(工具调用)
MCP三要素:Tools(函数)、Resources(数据)、Prompts(模板)
RAG四步:Reader → Splitter → Embedding → VectorStore
工程化四件套:Observability监控、Guardrails安全、Structured Output格式、Cost Control成本