logo

AgentScope Java大模型落地实践

作者:半吊子全栈工匠2026.11.17 03:21浏览量:1

简介:本文面向Java开发者,讲解AgentScope Java大模型工程化落地:用Spring Boot装配模型、工具、Agent、Memory与Workflow,并覆盖参数校验、流式输出、结构化输出、密钥管理、排错和入门路线,帮助构建可测试、可运维的AI应用。

本文面向 Java 开发者,聚焦“Java 大模型应用工程化”。文中会把 AgentScope 相关能力抽象为 Model、Agent、Tool、Memory、Workflow 五类通用组件;由于不同版本官方 API、GAV 坐标和类名可能变化,本文不写死具体依赖坐标,而是给出可落地、可替换、可验证的 Spring Boot 实现思路。若你所在团队已确认官方 SDK 坐标,可直接将本文示例中的 HTTP 调用替换为官方客户端。

TL;DR:先建立可落地的判断标准

很多 Java 后端接入大模型时,第一步并不是学习某个框架,而是先明确:这是一个“一次性脚本”,还是一个“可运营的服务”。

如果目标只是本地试验,直接调用 HTTP 接口即可;如果目标是进入客服、研发助手、数据分析、订单处理等业务场景,就必须考虑:

  • 密钥如何管理,如何避免硬编码;
  • JSON 如何校验,如何防止模型输出非法结构;
  • 超时、重试、熔断如何设计;
  • 流式输出如何消费,如何取消;
  • 工具调用如何授权,如何审计;
  • 上下文如何控制,如何防止 Token 膨胀;
  • 多 Agent 如何编排,如何设置最大步数与失败兜底。

本文的目标不是让读者背 API,而是给出一套 Java 团队可以直接复用的工程化方法:用 Spring Boot 装配模型接入层,用工具封装业务动作,用 Agent 调度模型与工具,用 Memory 管理会话,用 Workflow 组织多角色协作。

一、为什么 Java 开发者需要组件化

Java 开发者接入大模型,常见障碍不是“会不会调用 HTTP”,而是工程化能力不足。

直接调用模型接口,看起来门槛很低,但很快会遇到这些问题:

  • 密钥需要注入,不能提交到 Git;
  • 请求需要超时,失败需要重试;
  • 模型返回的 JSON 可能缺字段、类型错误或包含多余文本;
  • 流式响应需要按 SSE 解析,还要处理中断和取消;
  • 工具调用需要参数校验、权限控制和审计日志;
  • 上下文需要裁剪、摘要或脱敏;
  • 多 Agent 协作需要状态机、最大步数和失败回退。

如果只写一个聊天机器人,简单的请求-响应还能勉强支撑;但进入真实业务后,就必须把模型调用、工具执行、记忆管理和工作流拆解成可维护组件。

组件化的价值在于:让 Java 团队把精力放在业务规则、工具设计和治理能力上,而不是反复处理模型协议、重试逻辑和异常分支。

二、组件地图:先理解职责,再查 API

AgentScope Java 或类似大模型应用框架,通常会围绕以下五类能力组织代码。需要注意的是,不同框架和版本的命名可能不同,本文将其作为通用抽象;落地时应以官方文档中的实际类名和初始化参数为准。

组件 通用职责 Java 开发者关注点
Model 封装模型调用 模型名称、密钥、超时、重试、流式响应、结构化输出
Agent 调度模型与工具 系统提示词、工具列表、最大步数、终止条件、上下文回填
Tool 封装外部能力 参数校验、权限控制、幂等、超时、异常兜底、审计
Memory 保存会话上下文 会话隔离、Token 预算、摘要、截断、敏感信息脱敏
Workflow 编排多个 Agent 状态流转、阶段输入输出、最大步数、失败回退

这里有一个关键表述需要澄清:Agent 本身并不是“决定调用哪个工具”的主体。更准确地说,由模型(LLM)根据工具描述和用户意图决定是否调用某个工具,Agent 或调度器负责调用模型、收集结果、回填工具返回值,并继续下一轮推理。

例如,一个研发助手 Agent 可以调用代码检索工具、缺陷查询工具和文档生成工具;一个运营 Agent 可以调用订单查询、库存查询和消息通知工具。Java 团队真正需要重点设计的,不是模型内部推理,而是工具边界、权限模型、异常兜底和状态流转。

三、Spring Boot 工程结构与依赖示意

下面给出一个典型 Spring Boot 工程结构。示例采用框架中立方式:模型接入层通过 OpenAI-compatible 接口实现,便于后续替换为 AgentScope 官方客户端或其他模型网关。

  1. src/main/java/com/example/agent/
  2. ├── AgentApplication.java
  3. ├── AgentController.java
  4. ├── OrderService.java
  5. └── config/
  6. src/main/resources/
  7. ├── application.yml
  8. └── application-prod.yml

Maven 依赖示意如下。这里不引入未核验的 AgentScope 坐标,避免把可能变化的 GAV 当作事实。若你已经通过官方渠道确认 AgentScope Java 的依赖坐标,可以用 dependencyManagement 统一锁定版本。

  1. <parent>
  2. <groupId>org.springframework.boot</groupId>
  3. <artifactId>spring-boot-starter-parent</artifactId>
  4. <version>3.3.5</version>
  5. </parent>
  6. <properties>
  7. <java.version>17</java.version>
  8. </properties>
  9. <dependencies>
  10. <dependency>
  11. <groupId>org.springframework.boot</groupId>
  12. <artifactId>spring-boot-starter-web</artifactId>
  13. </dependency>
  14. <dependency>
  15. <groupId>org.springframework.boot</groupId>
  16. <artifactId>spring-boot-starter-validation</artifactId>
  17. </dependency>
  18. </dependencies>

配置文件中,模型地址、密钥、模型名称和超时不应写死,而应通过环境变量或配置中心注入:

  1. model:
  2. base-url: ${MODEL_BASE_URL:https://api.openai.com/v1}
  3. api-key: ${MODEL_API_KEY}
  4. model-name: ${MODEL_NAME:gpt-4o-mini}
  5. timeout-seconds: ${MODEL_TIMEOUT_SECONDS:30}

密钥管理建议如下:

  • 本地开发使用环境变量,禁止提交到 Git;
  • 生产环境通过 KMS、Secrets Manager、Vault 或企业配置中心注入;
  • 密钥遵循最小权限原则,只允许调用指定模型或指定工具;
  • 建立密钥轮转机制,避免长期固定密钥;
  • 日志中不得输出完整密钥、Token、完整请求体或敏感参数。

如果企业使用统一模型网关,可以把 base-url 和 api-key 指向网关,由网关负责模型路由、计费、限流和审计。这样做的好处是接入层可替换,避免业务代码绑定某一家模型服务。

四、可运行的 Spring Boot 最小示例:带工具调用的 Agent

下面给出一个可编译、可运行的最小示例。该示例不依赖具体 AgentScope 官方 API,而是用 Spring Boot、RestClient 和 OpenAI-compatible 工具调用协议,演示“模型决定调用工具,调度器执行工具并回填结果”的核心闭环。

示例假设模型服务支持类似 OpenAI 的 /chat/completions 接口和 tool_calls 字段。如果目标模型不支持该协议,可以改为 JSON 模式或自定义协议。

  1. package com.example.agent;
  2. import com.fasterxml.jackson.databind.ObjectMapper;
  3. import jakarta.validation.Valid;
  4. import jakarta.validation.constraints.NotBlank;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.boot.SpringApplication;
  7. import org.springframework.boot.autoconfigure.SpringBootApplication;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.http.client.SimpleClientHttpRequestFactory;
  10. import org.springframework.stereotype.Service;
  11. import org.springframework.web.bind.annotation.*;
  12. import org.springframework.web.client.RestClient;
  13. import java.util.*;
  14. import java.util.regex.Pattern;
  15. @SpringBootApplication
  16. public class AgentApplication {
  17. public static void main(String[] args) {
  18. SpringApplication.run(AgentApplication.class, args);
  19. }
  20. @Bean
  21. RestClient modelClient(RestClient.Builder builder,
  22. @Value("${model.base-url}") String baseUrl,
  23. @Value("${model.api-key}") String apiKey,
  24. @Value("${model.timeout-seconds}") long timeoutSeconds) {
  25. SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
  26. factory.setConnectTimeout(3000);
  27. factory.setReadTimeout((int) timeoutSeconds * 1000);
  28. return builder
  29. .baseUrl(baseUrl)
  30. .defaultHeader("Authorization", "Bearer " + apiKey)
  31. .requestFactory(factory)
  32. .build();
  33. }
  34. }
  35. @Service
  36. class OrderService {
  37. String queryStatus(String orderId) {
  38. if (!Pattern.matches("[A-Z0-9]{6,32}", orderId)) {
  39. throw new IllegalArgumentException("订单号格式不合法");
  40. }
  41. // 实际项目应替换为数据库查询或远程订单服务调用
  42. return "{\"orderId\":\"" + orderId + "\",\"status\":\"PAID\"}";
  43. }
  44. }
  45. @RestController
  46. class AgentController {
  47. private final RestClient restClient;
  48. private final String modelName;
  49. private final OrderService orderService;
  50. private final ObjectMapper objectMapper = new ObjectMapper();
  51. AgentController(RestClient restClient,
  52. @Value("${model.model-name}") String modelName,
  53. OrderService orderService) {
  54. this.restClient = restClient;
  55. this.modelName = modelName;
  56. this.orderService = orderService;
  57. }
  58. record ChatRequest(@NotBlank String message) {}
  59. @PostMapping("/agent/chat")
  60. String chat(@Valid @RequestBody ChatRequest request) {
  61. List<Map<String, Object>> messages = new ArrayList<>();
  62. messages.add(Map.of(
  63. "role", "system",
  64. "content", "你是Java助手,回答简洁,必要时调用queryOrder工具。"
  65. ));
  66. messages.add(Map.of(
  67. "role", "user",
  68. "content", request.message()
  69. ));
  70. for (int step = 0; step < 3; step++) {
  71. Map<String, Object> body = Map.of(
  72. "model", modelName,
  73. "messages", messages,
  74. "tools", List.of(orderToolSchema()),
  75. "tool_choice", "auto"
  76. );
  77. Map<?, ?> response = restClient.post()
  78. .uri("/chat/completions")
  79. .body(body)
  80. .retrieve()
  81. .body(Map.class);
  82. if (response == null) {
  83. return "模型未返回内容";
  84. }
  85. List<?> choices = (List<?>) response.get("choices");
  86. if (choices == null || choices.isEmpty()) {
  87. return "模型未返回选项";
  88. }
  89. Map<?, ?> first = (Map<?, ?>) choices.get(0);
  90. Map<String, Object> message = (Map<String, Object>) first.get("message");
  91. messages.add(message);
  92. Object toolCallsRaw = message.get("tool_calls");
  93. if (toolCallsRaw == null) {
  94. Object content = message.get("content");
  95. return content == null ? "未生成内容" : content.toString();
  96. }
  97. List<?> toolCalls = (List<?>) toolCallsRaw;
  98. for (Object toolCallRaw : toolCalls) {
  99. Map<String, Object> toolCall = (Map<String, Object>) toolCallRaw;
  100. Map<String, Object> function = (Map<String, Object>) toolCall.get("function");
  101. String name = String.valueOf(function.get("name"));
  102. String argsJson = String.valueOf(function.get("arguments"));
  103. String result;
  104. try {
  105. if (!"queryOrder".equals(name)) {
  106. result = "不支持的工具";
  107. } else {
  108. String orderId = objectMapper.readTree(argsJson).path("orderId").asText();
  109. result = Pattern.matches("[A-Z0-9]{6,32}", orderId)
  110. ? orderService.queryStatus(orderId)
  111. : "订单号格式不合法";
  112. }
  113. } catch (Exception e) {
  114. result = "工具执行失败";
  115. }
  116. messages.add(Map.of(
  117. "role", "tool",
  118. "tool_call_id", String.valueOf(toolCall.get("id")),
  119. "content", result
  120. ));
  121. }
  122. }
  123. return "达到最大工具调用步数";
  124. }
  125. private Map<String, Object> orderToolSchema() {
  126. Map<String, Object> orderIdProp = Map.of(
  127. "type", "string",
  128. "description", "订单号,6到32位大写字母或数字"
  129. );
  130. Map<String, Object> parameters = Map.of(
  131. "type", "object",
  132. "properties", Map.of("orderId", orderIdProp),
  133. "required", List.of("orderId"),
  134. "additionalProperties", false
  135. );
  136. Map<String, Object> function = Map.of(
  137. "name", "queryOrder",
  138. "description", "根据订单号查询订单状态",
  139. "parameters", parameters
  140. );
  141. return Map.of(
  142. "type", "function",
  143. "function", function
  144. );
  145. }
  146. }

启动后,可以用以下请求验证:

  1. curl -X POST http://localhost:8080/agent/chat \
  2. -H "Content-Type: application/json" \
  3. -d '{"message":"请帮我查询订单ABC123456的状态"}'

这段示例中,orderService 通过构造函数注入;如果需要在 controller 中增加日志,可以注入 Spring 的 ObservationRegistry,或在类中定义 SLF4J Logger。示例为了聚焦主流程,没有展开日志字段。

这个示例表达的核心不是“Agent 很神奇”,而是工程结构:模型负责理解意图,调度器负责调用工具和回填结果,业务服务负责真正执行查询。后续如果你接入 AgentScope Java 官方组件,可以把 RestClient 替换为官方 Model 客户端,把 orderToolSchema 和 orderService 包装为官方 Tool 组件,但整体边界保持不变。

五、模型接入与选型:先列核验清单

很多入门者会问:应该选哪个模型?更合理的做法是先明确任务类型,再建立核验清单。

场景 重点指标
对话问答 响应质量、指令遵循、表达稳定性
工具调用 函数调用稳定性、参数抽取准确率、JSON 合法率
长文档分析 上下文长度、长文召回、摘要质量
代码生成 代码能力、编译通过率、安全性
生产系统 延迟、价格、限流、合规、可观测性

对于 Java 后端来说,建议优先验证三件事:

  1. 是否能稳定返回结构化结果;
  2. 是否支持工具调用或等价的函数调用协议;
  3. 是否便于统一接入、计量、限流和回滚。

如果企业同时评估多个模型服务,可以通过统一模型网关做模型发现、价格与性能对比,再结合业务场景选择。统一模型网关的价值不在于替读者“包办选型”,而在于让接入层可替换、调用可计量、策略可回滚。

选型时不应只看参数规模,还应确认:

  • 是否支持 JSON Schema 或结构化输出;
  • 是否支持流式响应和取消机制;
  • 是否提供错误码、限流信息和用量统计;
  • 是否满足企业数据合规、内容安全和审计要求;
  • 是否有清晰计费口径,避免仅按“看起来便宜”决策。

六、流式输出与结构化输出:补齐首段承诺

首段提到流式输出、结构化输出和上下文控制,这里给出最小示意。注意,不同模型服务的流式协议和结构化输出字段不同,以下示例为通用伪代码,实际接入时以官方文档为准。

1. 流式输出消费

流式输出的重点是:增量解析、结束条件、取消处理和异常中断。

  1. // 伪代码:表达流式消费思路,不可直接复制为生产代码
  2. webClient.post()
  3. .uri("/chat/completions")
  4. .bodyValue(request)
  5. .retrieve()
  6. .bodyToFlux(String.class)
  7. .map(this::parseSseChunk)
  8. .takeUntil(this::isDone)
  9. .doOnCancel(() -> log.info("用户取消流式请求"))
  10. .onErrorResume(e -> Flux.just("流式响应中断,请稍后重试"))
  11. .subscribe(chunk -> sseEmitter.send(chunk));

实际工程中需要额外处理:

  • 客户端断开时主动取消请求,避免无效 Token 消耗;
  • 连续多次解析失败时熔断,避免无限重试;
  • 记录首包延迟、总耗时和结束原因;
  • 对工具调用流中的增量参数做拼接和校验。

2. 结构化输出解析

如果业务要求模型返回固定结构,例如工单分类、风险标签或订单摘要,应优先使用 JSON Schema 或结构化输出能力,并用 Java 侧校验兜底。

  1. {
  2. "model": "your-model",
  3. "messages": [
  4. {"role": "system", "content": "只返回JSON"},
  5. {"role": "user", "content": "请判断这句工单的优先级"}
  6. ],
  7. "response_format": {
  8. "type": "json_schema",
  9. "json_schema": {
  10. "name": "ticket_priority",
  11. "schema": {
  12. "type": "object",
  13. "properties": {
  14. "priority": {"type": "string", "enum": ["P0", "P1", "P2"]}
  15. },
  16. "required": ["priority"],
  17. "additionalProperties": false
  18. }
  19. }
  20. }
  21. }

Java 侧应使用 Jackson 解析,并通过 Bean Validation 或自定义校验器确认字段合法。不要直接把模型输出当作可信业务数据写入数据库。

七、Memory:会话隔离与截断

Memory 的关键不是“保存所有对话”,而是“在预算内保存有效上下文”。

建议至少包含三个控制点:

  1. 按 sessionId 隔离,避免不同用户或不同租户串话;
  2. 按 Token 预算截断,超长时做摘要或滑动窗口;
  3. 对手机号、身份证号、邮箱等个人信息做脱敏或最小化。

伪代码示意:

  1. // 伪代码:Memory 截断与脱敏
  2. class MemoryService {
  3. void addMessage(String sessionId, Message message) {
  4. String safeContent = maskPii(message.content());
  5. Memory memory = store.get(sessionId);
  6. memory.add(new Message(message.role(), safeContent));
  7. if (memory.estimateTokens() > tokenBudget) {
  8. memory.summarizeOldMessages();
  9. memory.dropOldestTurns(keepRecentTurns);
  10. }
  11. store.put(sessionId, memory);
  12. }
  13. }

在实际项目中,Memory 可以与业务库、Redis、向量库结合。例如:

  • 短期会话上下文放 Redis,设置 TTL;
  • 长期知识放向量库,按权限过滤后检索;
  • 用户敏感信息不进入向量库,或先做不可逆脱敏。

八、多智能体协作:从单 Agent 开始

多智能体并不是越多越好。初期建议先用单 Agent 加工具完成闭环,再逐步引入规划者、执行者、审核者等角色。

一个常见的研发助手工作流可以是:

  1. 规划 Agent:拆解用户需求;
  2. 检索 Agent:查找文档、代码或工单;
  3. 执行 Agent:生成补丁、测试或报告;
  4. 审核 Agent:检查格式、风险和合规性。

在 Java 实现中,可以用 Workflow 统一编排,并设置最大步数、超时和终止条件,避免 Agent 陷入循环。

  1. // 伪代码:工作流编排
  2. Workflow workflow = Workflow.builder()
  3. .name("dev-assistant-workflow")
  4. .maxSteps(6)
  5. .timeoutSeconds(120)
  6. .onFailure("returnLastSafeResult")
  7. .steps(List.of(
  8. planAgent,
  9. retrieveAgent,
  10. executeAgent,
  11. reviewAgent
  12. ))
  13. .build();

多智能体系统的难点不在“对话”,而在状态管理、任务边界和失败恢复。建议为每个阶段定义明确输入输出:

  • 规划阶段输出任务列表;
  • 检索阶段输出证据摘要;
  • 执行阶段输出变更内容;
  • 审核阶段输出风险结论。

只有状态清晰,后续才能做日志追踪、失败重试和人工接管。

九、生产化:可观测、成本与安全

当 Agent 进入生产环境,必须补齐治理能力。

1. 可观测性

至少记录:

  • 每次模型调用的 requestId 或 traceId;
  • 每次工具调用的入参摘要、出参状态、耗时;
  • Token 消耗、首包延迟、总耗时;
  • 失败原因、重试次数、降级路径。

注意:日志不要记录完整密钥、完整用户隐私数据或完整模型输出,除非有脱敏和权限控制。

2. 安全边界

生产化安全建议至少覆盖三条:

  • 检索结果、工具返回、网页内容和用户输入都可能包含提示词注入内容,需要来源标识、内容隔离和系统提示词约束;
  • 进入模型上下文前,对手机号、身份证号、地址、邮箱等个人信息做脱敏或最小化;
  • 对生成内容做审核与审计留痕,尤其是客服回复、代码生成、营销文案和自动化操作。

3. 成本控制

长上下文、多轮对话和多 Agent 协作都会增加 Token 消耗。建议:

  • 高频简单任务优先路由到轻量模型;
  • 复杂推理任务再调用能力更强的模型;
  • 对重复查询结果增加缓存,但设置 TTL 和失效策略;
  • 对长上下文进行摘要、截断或检索增强,减少无效 Token;
  • 对模型调用建立预算告警,避免异常流量造成成本失控。

需要强调:模型路由、缓存和成本控制必须基于真实评测、压测与计费口径,不应承诺具体降幅或性能提升。不同业务的数据分布、提示词长度、工具调用频率和模型价格都会影响结果。

十、Java 大模型框架怎么选?

下面是一个简化的选型参考。具体项目应以官方文档、License、社区活跃度和企业内测结果为准。

框架/方向 典型定位 适用场景
AgentScope 面向多智能体与组件化 Agent 编排 需要 Agent、工具、工作流组合的项目
Spring AI Spring 生态的模型接入与 AI 应用抽象 已深度使用 Spring Boot 的团队
LangChain4j Java 生态的 LLM、RAG、工具与 Agent 编排 需要较多集成示例和中间件适配的项目

选型时建议做一个小型 PoC,用真实业务样本验证:

  • 是否能稳定调用模型;
  • 是否支持流式;
  • 是否支持工具调用;
  • 是否支持结构化输出;
  • 是否有足够的异常处理和可观测能力。

不要只看“是否流行”,而要看它能否接入你现有的权限体系、日志体系、配置中心和发布流程。

十一、推荐入门路线与验收标准

如果你刚接触 Java 大模型应用,可以按以下路线推进:

  1. 跑通单模型对话
    验收标准:能通过环境变量注入密钥,调用 /agent/chat 返回模型内容。

  2. 加入一个工具
    验收标准:模型能够根据用户问题调用 queryOrder,且参数错误时能返回兜底话术。

  3. 接入企业知识库
    验收标准:能通过 RAG 检索文档片段,并将引用来源返回给用户。

  4. 引入多 Agent 协作
    验收标准:规划、检索、执行、审核四个阶段有明确输入输出,且失败时能回退。

  5. 补齐日志、监控、权限和成本管理
    验收标准:每次调用可追踪 traceId,可统计 Token,可配置预算告警。

这个路线的好处是每一步都能验证,不会一开始就陷入复杂框架细节。

十二、常见报错排查清单

排查时建议按“现象 → 可能原因 → 排查动作”进行,而不是只看一句“检查配置”。

现象 可能原因 排查动作
401 鉴权失败 API Key 过期、环境变量未注入、权限不足 检查 ${MODEL_API_KEY} 是否存在,确认密钥是否属于目标模型
429 限流 QPS 超限、并发过高、租户配额不足 检查并发数、QPS、租户配额,增加排队、退避或降级
400 上下文超长 历史消息过多、长文档未截断 检查上下文长度、裁剪策略,必要时做摘要或检索增强
模型超时 网络出口、代理、超时配置过短 检查网络连通性、代理、超时和重试策略
工具超时 下游服务慢、熔断缺失 检查下游健康状态,增加熔断、超时和兜底话术
工具参数错误 JSON Schema 不匹配、类型转换失败、空值 检查参数 description、必填字段、枚举值和类型约束
结构化输出解析失败 模型返回非 JSON、字段缺失、枚举非法 增加 JSON Schema、重试、修复提示词和 Jackson 容错解析
流式中断/连接重置 网络抖动、客户端断开、服务端超时 检查 SSE 解析、取消机制、错误恢复和重试策略
工具返回空导致 Agent 空转 工具无结果、Agent 未设置终止条件 增加空结果兜底、最大步数和重复动作检测

排错时尽量保留 traceId、requestId、工具名、耗时和错误码,但不要记录完整敏感请求体。

十三、常见问题

AgentScope Java 是什么?

可以理解为面向 Java 生态的大模型应用组件化思路,用于组织模型调用、Agent、工具、记忆和工作流,使 AI 能力更接近传统 Java 服务。具体 API 和依赖坐标请以官方文档为准。

Java 项目如何选型模型?

先看任务类型,再看结构化输出、工具调用、上下文长度、延迟、价格、限流和合规能力。建议用真实业务样本做小规模评测,而不是只看参数规模。

如何做工具权限控制?

工具应使用独立低权限账号,只读优先;写操作需审批;删除、转账、发布等高风险动作禁止模型直接触发。所有工具调用应记录审计日志。

如何接入企业知识库?

可先通过 RAG 检索文档片段,再将检索结果作为上下文交给 Agent。Java 侧需要关注文档切分、向量检索、权限过滤、引用溯源和缓存失效。

十四、资料与推广说明

  • AgentScope Java 官方仓库与文档:请以官方发布页为准。引入依赖前,应核对 Maven 坐标、版本、API 签名、权限模型和许可证。本文不写死未核验坐标,是为了避免版本漂移和误导。
  • 推广说明:如需了解模型服务统一接入、计费与调用管理,可访问百度智能云词元所:https://cloud.baidu.com/product-s/token_exchange.html 。本文仅将其作为模型接入层示例,不构成模型选型结论。

发表评论

活动