---

name: process-order

description: 处理客户订单

---

处理订单的步骤：

1. 调用 validateOrder(orderId) 检查订单是否有效。

2. 调用 reserveInventory(orderId) 预留所需库存。

3. 仅当预留成功时，调用 chargePayment(orderId) 进行扣款。

4. 最后，调用 sendConfirmationEmail(orderId) 发送确认邮件。

如果任何步骤失败，在报告错误之前调用 rollbackOrder(orderId) 回滚订单。

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

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

packagecom.cnblogs.yjmyzz.langchain4j.study.tools;

importdev.langchain4j.agent.tool.Tool;

importorg.springframework.stereotype.Component;

/**

* 一组用于处理客户订单的工具。

* 当 'process-order' SKILL激活时，LLM 将调用这些方法。

*/

@Component

publicclassOrderTools {

@Tool("验证订单ID是否有效")

publicString validateOrder(String orderId) {

System.out.println("工具：正在验证订单："+ orderId);

// 模拟验证逻辑

if(orderId !=null&& orderId.startsWith("ORD")) {

System.out.println("订单 "+ orderId +" 有效。");

return"订单 "+ orderId +" 有效。";

}else{

System.out.println("订单 "+ orderId +" 无效。");

return"订单 "+ orderId +" 无效。";

}

}

@Tool("为指定订单ID预留库存。返回成功或失败信息。")

publicString reserveInventory(String orderId) {

System.out.println("工具：正在为订单预留库存："+ orderId);

// 模拟库存预留

if("ORD001".equals(orderId)) {// 模拟成功示例

System.out.println("订单 "+ orderId +" 的库存已预留。");

return"订单 "+ orderId +" 的库存已预留。";

}elseif("ORD002".equals(orderId)) {// 模拟失败示例

System.out.println("为订单 "+ orderId +" 预留库存失败。库存不足。");

return"为订单 "+ orderId +" 预留库存失败。库存不足。";

}else{

System.out.println("订单 "+ orderId +" 的库存预留状态未知。");

return"订单 "+ orderId +" 的库存预留状态未知。";

}

}

@Tool("为指定订单ID扣款。返回支付状态。")

publicString chargePayment(String orderId) {

System.out.println("工具：正在为订单扣款："+ orderId);

// 模拟支付处理

return"订单 "+ orderId +" 扣款成功。";

}

@Tool("向客户发送指定订单ID的确认邮件。返回确认状态。")

publicString sendConfirmationEmail(String orderId) {

System.out.println("工具：正在为订单发送确认邮件："+ orderId);

// 模拟邮件发送

return"订单 "+ orderId +" 的确认邮件已发送。";

}

@Tool("因处理出错回滚订单。返回回滚状态。")

publicString rollbackOrder(String orderId) {

System.out.println("工具：因失败正在回滚订单："+ orderId);

// 模拟回滚

return"订单 "+ orderId +" 已成功回滚。";

}

}

1

2

3

4

5

6

7

8

9

packagecom.cnblogs.yjmyzz.langchain4j.study.service;

importdev.langchain4j.service.UserMessage;

publicinterfaceOrderProcessingAiService {

// 系统消息由 Spring 配置中的 AiServices.builder(...).systemMessage(...) 提供

String chat(@UserMessageString userMessage);

}

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

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

packagecom.cnblogs.yjmyzz.langchain4j.study.config;

importcom.cnblogs.yjmyzz.langchain4j.study.service.OrderProcessingAiService;

importcom.cnblogs.yjmyzz.langchain4j.study.tools.OrderTools;

importdev.langchain4j.memory.chat.MessageWindowChatMemory;

importdev.langchain4j.model.chat.ChatModel;

importdev.langchain4j.service.AiServices;

importdev.langchain4j.service.tool.ToolProvider;

importdev.langchain4j.skills.ClassPathSkillLoader;

importdev.langchain4j.skills.FileSystemSkill;

importdev.langchain4j.skills.Skill;

importdev.langchain4j.skills.Skills;

importorg.springframework.context.annotation.Bean;

importorg.springframework.context.annotation.Configuration;

importjava.util.List;

importjava.util.stream.Collectors;

@Configuration

publicclassLangChain4jConfig {

privatefinalOrderTools orderTools;// 自动注入 OrderTools

// 注入 OrderTools，用于技能作用域的工具

publicLangChain4jConfig(OrderTools orderTools) {

this.orderTools = orderTools;

}

@Bean

publicSkills skills() {

// 从类路径下的 'skills' 目录加载所有技能

// 假设你的 SKILL.md 文件位于 src/main/resources/skills/ 下

List<FileSystemSkill> loadedSkills = ClassPathSkillLoader.loadSkills("skills");

// 为 "process-order" 技能附加 OrderTools 作为技能作用域的工具

// 这意味着 OrderTools 中的方法只有在显式激活 "process-order" 技能后，

// 才会对 LLM 可见

List<Skill> configuredSkills = loadedSkills.stream()

.map(fsSkill -> {

if("process-order".equals(fsSkill.name())) {

returnSkill.builder()

.name(fsSkill.name())

.description(fsSkill.description())

.content(fsSkill.content())

.resources(fsSkill.resources())

.tools(orderTools)// 附加 OrderTools 作为技能作用域的工具

.build();

}

returnfsSkill;

})

.collect(Collectors.toList());

returnSkills.from(configuredSkills);

}

@Bean

publicToolProvider skillsToolProvider(Skills skills) {

// 该 ToolProvider 将处理 'activate_skill'、'read_skill_resource'

// 并在技能激活时动态暴露技能作用域的工具（例如 OrderTools 中的工具）

returnskills.toolProvider();

}

@Bean

publicOrderProcessingAiService orderProcessingAiService(ChatModel chatModel, Skills skills, ToolProvider skillsToolProvider) {

// 构建 AI 服务，整合聊天模型、聊天记忆以及技能 ToolProvider

returnAiServices.builder(OrderProcessingAiService.class)

.chatModel(chatModel)

.chatMemory(MessageWindowChatMemory.withMaxMessages(100))// 保留对话历史

.toolProvider(skillsToolProvider)// 注册技能工具提供者

// 将技能目录注入到系统消息中，以便 LLM 知道它可以激活哪些技能

.systemMessage("你是一个订单处理助手。你可以使用以下技能：\n"

+ skills.formatAvailableSkills()// 将技能格式化为 XML 提供给 LLM

+"\n当用户请求与这些技能之一相关时，请先使用 `activate_skill` 工具激活该技能，然后再继续处理。")

.build();

}

}

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

packagecom.cnblogs.yjmyzz.langchain4j.study.controller;

importcom.cnblogs.yjmyzz.langchain4j.study.service.OrderProcessingAiService;

importorg.springframework.web.bind.annotation.GetMapping;

importorg.springframework.web.bind.annotation.RequestParam;

importorg.springframework.web.bind.annotation.RestController;

/**

* 与使用技能的 LangChain4j AI 服务进行交互的 REST 控制器。

*/

@RestController

publicclassOrderController {

privatefinalOrderProcessingAiService orderProcessingAiService;

// 自动注入 AI 服务

publicOrderController(OrderProcessingAiService orderProcessingAiService) {

this.orderProcessingAiService = orderProcessingAiService;

}

/**

* 与订单处理 AI 助手进行聊天的端点。

* 示例：http://localhost:8080/chat/order?message=处理订单 ORD001

* 示例：http://localhost:8080/chat/order?message=你叫什么名字？

*/

@GetMapping("/chat/order")

publicString chatWithOrderAssistant(@RequestParam(value ="message", defaultValue ="处理订单 ORD001") String message) {

System.out.println("用户消息："+ message);

String aiResponse = orderProcessingAiService.chat(message);

System.out.println("AI 回复："+ aiResponse);

returnaiResponse;

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

用户消息：处理订单 ORD001

工具：正在验证订单：ORD001

订单 ORD001 有效。

工具：正在为订单预留库存：ORD001

订单 ORD001 的库存已预留。

工具：正在为订单扣款：ORD001

工具：正在为订单发送确认邮件：ORD001

AI 回复：✅ 订单 ORD001 处理完成！

处理结果：

- ✅ 订单验证：有效

- ✅ 库存预留：成功

- ✅ 支付扣款：成功

- ✅ 确认邮件：已发送

订单 ORD001 已成功处理完毕，客户将收到确认邮件。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

用户消息：处理订单 ORD002

工具：正在验证订单：ORD002

订单 ORD002 有效。

工具：正在为订单预留库存：ORD002

为订单 ORD002 预留库存失败。库存不足。

工具：因失败正在回滚订单：ORD002

AI 回复：❌ 订单 ORD002 处理失败！

处理结果：

- ✅ 订单验证：有效

- ❌ 库存预留：失败（库存不足）

- ➖ 支付扣款：未执行（因库存预留失败）

- ➖ 确认邮件：未发送