1
 2
 3
 4
 5
 6
 7
 8
 9
10

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.38</version>
</dependency>
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
    <version>4.4.0</version>
</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

spring:
  application:
    name: AIAgent
server:
  port: 8123
  servlet:
    context-path: /api # 此时项目的访问路径为localhost:8123/api
# springdoc-openapi 接口文档配置
springdoc:
  swagger-ui:
    path: /swagger-ui.html
    tags-sorter: alpha
    operations-sorter: alpha
  api-docs:
    path: /v3/api-docs
  group-configs:
    - group: 'default'
      paths-to-match: '/**'
      packages-to-scan: com.yuanyu.aiagent.controller # 改为项目中Controller包的位置
# knife4j 的增强配置，不需要增强可以不配
knife4j:
  enable: true
  setting:
    language: zh_cn

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package com.yuanyu.aiagent.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    @GetMapping("/check")
    public String check() {
        return "OK";
    }
}

1
2
3
4
5
6

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dashscope-sdk-java</artifactId>
    <!-- 请将 'the-latest-version' 替换为最新版本号：https://mvnrepository.com/artifact/com.alibaba/dashscope-sdk-java -->
    <version>the-latest-version</version>
</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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

package com.yuanyu.aiagent.demo.invoke;// 建议dashscope SDK的版本 >= 2.12.0
import java.util.Arrays;
import java.lang.System;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.JsonUtils;

/**
 * 阿里云AI SDK调用
 */
public class SDKAiInvoke {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        Generation gen = new Generation();
        Message systemMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .content("You are a helpful assistant.")
                .build();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("你是谁？")
                .build();
        GenerationParam param = GenerationParam.builder()
                // 若没有配置环境变量，请用百炼API Key将下行替换为：.apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // 此处以qwen-plus为例，可按需更换模型名称。模型列表：https://help.aliyun.com/zh/model-studio/getting-started/models
                .model("qwen-plus")
                .messages(Arrays.asList(systemMsg, userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println(JsonUtils.toJson(result));
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            // 使用日志框架记录异常信息
            System.err.println("An error occurred while calling the generation service: " + e.getMessage());
        }
        System.exit(0);
    }
}

1

{"requestId":"b9af6846-fc2a-4ae5-9593-1003a7f15340","usage":{"input_tokens":22,"output_tokens":66,"total_tokens":88,"prompt_tokens_details":{"cached_tokens":0}},"output":{"choices":[{"finish_reason":"stop","message":{"role":"assistant","content":"你好！我是通义千问（Qwen），阿里巴巴集团旗下的超大规模语言模型。我能够回答问题、创作文字，比如写故事、写公文、写邮件、写剧本、逻辑推理、编程等等，还能表达观点，玩游戏等。如果你有任何问题或需要帮助，欢迎随时告诉我！😊"}}]},"status_code":200,"code":"","message":""}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

curl --location "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation" \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
    "model": "qwen-plus",
    "input":{
        "messages":[      
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "你是谁？"
            }
        ]
    },
    "parameters": {
        "result_format": "message"
    }
}'

  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
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

package com.yuanyu.aiagent.demo.invoke;

import cn.hutool.http.ContentType;
import cn.hutool.http.Header;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;

/**
 * 使用纯 Hutool 工具包调用阿里云通义千问 API
 * 仅依赖：hutool-all
 */
public class HttpAiInvoke {
    // 替换为你的 DashScope API Key
    private static final String DASHSCOPE_API_KEY = System.getenv("DASHSCOPE_API_KEY");
    private static final String API_URL = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation";

    public static void main(String[] args) {
        try {
            // 1. 构建请求体 JSON（使用 Hutool 自带的 JSON 工具）
            JSONObject requestBody = buildRequestBody();

            // 2. 发送 POST 请求
            String response = sendPostRequest(API_URL, requestBody.toString());

            // 3. 处理响应结果
            System.out.println("API 响应结果：");
            System.out.println(response);

        } catch (Exception e) {
            System.err.println("请求失败：" + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 构建请求体 JSON 结构（仅使用 Hutool 的 JSON 类）
     */
    private static JSONObject buildRequestBody() {
        // 外层对象
        JSONObject requestBody = new JSONObject();
        requestBody.put("model", "qwen-plus");

        // input 部分
        JSONObject input = new JSONObject();
        // messages 数组（使用 Hutool 的 JSONArray）
        JSONArray messages = new JSONArray();

        // system 消息
        JSONObject systemMsg = new JSONObject();
        systemMsg.put("role", "system");
        systemMsg.put("content", "You are a helpful assistant.");
        messages.add(systemMsg);

        // user 消息
        JSONObject userMsg = new JSONObject();
        userMsg.put("role", "user");
        userMsg.put("content", "你是谁？");
        messages.add(userMsg);

        input.put("messages", messages);
        requestBody.put("input", input);

        // parameters 部分
        JSONObject parameters = new JSONObject();
        parameters.put("result_format", "message");
        requestBody.put("parameters", parameters);

        return requestBody;
    }

    /**
     * 使用 Hutool 发送 POST 请求
     * @param url 请求地址
     * @param jsonBody 请求体 JSON 字符串
     * @return 响应结果字符串
     */
    private static String sendPostRequest(String url, String jsonBody) {
        // 构建 HTTP POST 请求（try-with-resources 自动关闭响应）
        try (HttpResponse response = HttpRequest.post(url)
                // 设置认证头（和原 curl 一致）
                .header(Header.AUTHORIZATION, "Bearer " + DASHSCOPE_API_KEY)
                // 设置 Content-Type 为 JSON
                .header(Header.CONTENT_TYPE, ContentType.JSON.getValue())
                // 设置请求体
                .body(jsonBody)
                // 设置超时时间（10 秒，可调整）
                .timeout(10000)
                // 执行请求
                .execute()) {

            // 检查响应状态码
            if (response.isOk()) {
                return response.body();
            } else {
                throw new RuntimeException("请求失败，状态码：" + response.getStatus()
                        + "，响应内容：" + response.body());
            }
        }
    }
}

1
2

API 响应结果：
{"output":{"choices":[{"message":{"content":"你好！我是通义千问（Qwen），阿里巴巴集团旗下的超大规模语言模型。我能够回答问题、创作文字，比如写故事、写公文、写邮件、写剧本、逻辑推理、编程等等，还能表达观点，玩游戏等。如果你有任何问题或需要帮助，欢迎随时告诉我！😊","role":"assistant"},"finish_reason":"stop"}]},"usage":{"total_tokens":88,"output_tokens":66,"input_tokens":22,"prompt_tokens_details":{"cached_tokens":0}},"request_id":"25ce80db-45aa-41f3-9bdc-4412eeda7626"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

<dependencies>
    <!-- Spring AI Alibaba Agent Framework -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-agent-framework</artifactId>
        <version>1.1.2.0</version>
    </dependency>

    <!-- DashScope ChatModel 支持（如果使用其他模型，请跳转 Spring AI 文档选择对应的 starter） -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
        <version>1.1.2.0</version>
    </dependency>
</dependencies>

1
2
3
4
5
6
7

spring:
  ai:
    dashscope:
      api-key: ${DASHSCOPE_API_KEY}
      chat:
        options:
          model: qwen-max

 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

package com.yuanyu.aiagent.demo.invoke;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * Spring AI 调用
 */
@Component
@RequiredArgsConstructor
public class SpringAiAiInvoke implements CommandLineRunner {
	// 声明的变量名最好是dashscopeChatModel
    private final ChatModel dashscopeChatModel;


    // 项目运行时自动调用
    @Override
    public void run(String... args) throws Exception {
        AssistantMessage assistantMessage = dashscopeChatModel.call(new Prompt("Ciallo～(∠・ω< )⌒☆"))
                .getResult() // 获取结果
                .getOutput();// 获取输出
        System.out.println(assistantMessage.getText());
    }
}

1

嘿！看起来你用了一种很可爱的方式来打招呼呢！(づ｡◕‿‿◕｡)づ 如果有什么我可以帮助你的，或者你想聊些什么有趣的事情，尽管告诉我哦～

1
2
3
4
5

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-community-dashscope</artifactId>
    <version>${latest version here}</version>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package com.yuanyu.aiagent.demo.invoke;

import dev.langchain4j.community.model.dashscope.QwenChatModel;
import dev.langchain4j.model.chat.ChatModel;

public class LangChainAiInvoke {
    public static void main(String[] args) {

        ChatModel qwenModel = QwenChatModel.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .modelName("qwen-max")
                .build();

        String result = qwenModel.chat("Ciallo～(∠・ω< )⌒☆");
        System.out.println(result);
    }
}

1

你好！看起来你使用了一种非常可爱的方式来打招呼呢！~(∠・ω< )⌒☆ 这个表情让人感觉很温馨。有什么我可以帮到你的吗？或者，你想聊些什么有趣的事情呢？

1
2

系统：你是一位经验丰富的Python教师，擅长向初学者解释编程概念。
用户：请解释 Python 中的列表推导式，包括基本语法和 2-3 个实用示例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

请提供一个社交媒体营销计划，针对一款新上市的智能手表。计划应包含:
1. 目标受众描述
2. 三个内容主题
3. 每个平台的内容类型建议
4. 发布频率建议

示例格式:
目标受众: [描述]
内容主题: [主题1], [主题2], [主题3]
平台策略: [平台] - [内容类型] - [频率]

1
2
3
4
5
6
7
8
9

分析以下公司的优势和劣势:
公司: Tesla

请使用表格格式回答，包含以下列:
- 优势(最少3项)
- 每项优势的简要分析
- 劣势(最少3项)
- 每项劣势的简要分析
- 应对建议

1
2
3
4
5

撰写一篇关于气候变化的科普文章，要求:
- 使用通俗易懂的语言，适合高中生阅读
- 包含5个小标题，每个标题下2-3段文字
- 总字数控制在800字左右
- 结尾提供3个可行的个人行动建议

1
2
3
4
5
6
7

问题：一个商店售卖T恤，每件15元。如果购买5件以上可以享受8折优惠。小明买了7件T恤，他需要支付多少钱？

请一步步思考解决这个问题:
1. 首先计算7件T恤的原价
2. 确定是否符合折扣条件
3. 如果符合，计算折扣后的价格
4. 得出最终支付金额

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

我将给你一些情感分析的例子，然后请你按照同样的方式分析新句子的情感倾向。

输入: "这家餐厅的服务太差了，等了一个小时才上菜"
输出: 负面，因为描述了长时间等待和差评服务

输入: "新买的手机屏幕清晰，电池也很耐用"
输出: 正面，因为赞扬了产品的多个方面

现在分析这个句子:
"这本书内容还行，但是价格有点贵"

1
2
3
4
5
6
7

请帮我创建一个简单的网站落地页设计方案，按照以下步骤:

步骤1: 分析目标受众(考虑年龄、职业、需求等因素)
步骤2: 确定页面核心信息(主标题、副标题、价值主张)
步骤3: 设计页面结构(至少包含哪些区块)
步骤4: 制定视觉引导策略(颜色、图像建议)
步骤5: 设计行动召唤(CTA)按钮和文案

1
2
3
4
5
6
7
8

解决以下概率问题:
从一副标准扑克牌中随机抽取两张牌，求抽到至少一张红桃的概率。

首先给出你的解答，然后:
1. 检查你的推理过程是否存在逻辑错误
2. 验证你使用的概率公式是否正确
3. 检查计算步骤是否有误
4. 如果发现任何问题，提供修正后的解答

1
2
3
4
5
6
7

请解释光合作用的过程及其在植物生长中的作用。在回答中:
1. 提供光合作用的科学定义
2. 解释主要的化学反应
3. 描述影响光合作用效率的关键因素
4. 说明其对生态系统的重要性

对于任何可能需要具体数据或研究支持的陈述，请明确指出这些信息的来源，并说明这些信息的可靠性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

分析"城市应该禁止私家车进入市中心"这一提议:

请从以下4个不同角度分析:
1. 环保专家视角
2. 经济学家视角
3. 市中心商户视角
4. 通勤居民视角

对每个视角:
- 提供支持该提议的2个论点
- 提供反对该提议的2个论点
- 分析可能的折中方案

1
2
3
4
5
6
7
8

设计一个智能家居系统的基础架构:

1. 首先用文字描述系统的主要功能和组件
2. 然后创建一个系统架构图(用ASCII或文本形式表示)
3. 接着提供用户交互流程
4. 最后简述实现这个系统可能面临的技术挑战

尝试从不同角度思考:功能性、用户体验、技术实现、安全性等。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

初始提示: 谈谈人工智能的影响。

[收到笼统回答后]
改进提示: 分析人工智能对医疗行业的三大积极影响和两大潜在风险，提供具体应用案例。

[如果回答仍然不够具体]
进一步改进: 详细分析AI在医学影像诊断领域的具体应用，包括:
1. 现有的2-3个成功商业化AI诊断系统及其准确率
2. 这些系统如何辅助放射科医生工作
3. 实施过程中遇到的主要挑战
4. 未来3-5年可能的技术发展方向

1
2
3
4
5
6
7

尝试解决以下具有挑战性的数学问题:
证明在三角形中，三条高的交点、三条中线的交点和三条角平分线的交点在同一条直线上。

如果你发现难以直接证明:
1. 说明你遇到的具体困难
2. 考虑是否有更简单的方法或特例可以探讨
3. 提供一个思路框架，即使无法给出完整证明

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

【专家角色】: {领域}专家
【任务描述】: {任务详细说明}
【所需内容】:
- {要点1}
- {要点2}
- {要点3}
【输出格式】: {格式要求}
【语言风格】: {风格要求}
【限制条件】: {字数、时间或其他限制}

例如:
【专家角色】: 营养学专家
【任务描述】: 为一位想减重的上班族设计一周健康饮食计划
【所需内容】:
- 七天的三餐安排
- 每餐的大致卡路里
- 准备建议和购物清单
【输出格式】: 按日分段，每餐列出具体食物
【语言风格】: 专业但友好
【限制条件】: 考虑准备时间短，预算有限

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

我发现之前请你生成的Python代码存在以下问题:
1. 没有正确处理文件不存在的情况
2. 数据处理逻辑中存在边界条件错误
3. 代码注释不够详细

请重新生成代码，特别注意:
1. 添加完整的异常处理
2. 测试并确保所有边界条件
3. 为每个主要函数和复杂逻辑添加详细注释
4. 遵循PEP 8编码规范

 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

package com.yuanyu.aiagent.controller;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    private final ChatClient chatClient;

    public DemoController(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @GetMapping("/generation")
    String generation(String userInput) {
        return this.chatClient.prompt()
                .system("用户说Ciallo时请回复‘柚子厨蒸鹅心’")
                .user(userInput)
                .call()
                .content();
    }
}

 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

package com.yuanyu.aiagent.demo.invoke;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * Spring AI 调用
 */
@Component
@RequiredArgsConstructor
public class SpringAiAiInvoke implements CommandLineRunner {

    private final ChatModel dashscopeChatModel;

    // 项目运行时自动调用
    @Override
    public void run(String... args) throws Exception {
        // 手动指定使用哪个模型
        ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
                .defaultSystem("用户说Ciallo时回复‘柚子厨蒸鹅心’")
                .build();

        String content = chatClient.prompt()
                .user("Ciallo～(∠・ω< )⌒☆")
                .call()
                .content();

        System.out.println(content);
    }
}

1
2
3
4
5
6
7
8
9

private final ChatModel model1;

private final ChatModel model2;

if (……) {
    ChatClient chatClient = ChatClient.builder(model1).build();
} else {
    ChatClient chatClient = ChatClient.builder(model1).build();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

@Configuration
public class ChatClientConfig {
	// 在配置类中分别定义
    
    @Bean
    public ChatClient openAiChatClient(OpenAiChatModel chatModel) {
        return ChatClient.create(chatModel);
    }

    @Bean
    public ChatClient anthropicChatClient(AnthropicChatModel chatModel) {
        return ChatClient.create(chatModel);
    }
}

 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

@Configuration
public class ChatClientExample {

    @Bean
    CommandLineRunner cli(
            @Qualifier("openAiChatClient") ChatClient openAiChatClient,
            @Qualifier("anthropicChatClient") ChatClient anthropicChatClient) {

        return args -> {
            var scanner = new Scanner(System.in);
            ChatClient chat;

            // Model selection
            System.out.println("\nSelect your AI model:");
            System.out.println("1. OpenAI");
            System.out.println("2. Anthropic");
            System.out.print("Enter your choice (1 or 2): ");

            String choice = scanner.nextLine().trim();

            if (choice.equals("1")) {
                chat = openAiChatClient;
                System.out.println("Using OpenAI model");
            } else {
                chat = anthropicChatClient;
                System.out.println("Using Anthropic model");
            }

            // Use the selected chat client
            System.out.print("\nEnter your question: ");
            String input = scanner.nextLine();
            String response = chat.prompt(input).call().content();
            System.out.println("ASSISTANT: " + response);

            scanner.close();
        };
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package com.yuanyu.ai.controller;

@RestController
@RequestMapping("/ai")
@RequiredArgsConstructor
public class GameController {
    // 此时会优先匹配名为openAiChatClient的bean
    private final ChatClient openAiChatClient;

    @RequestMapping(value = "/game", produces = "text/html;charset=UTF-8")
    public Flux<String> chat(@RequestParam String prompt) {
        return openAiChatClient.prompt()
                .user(prompt)
                .stream()
                .content();
    }
}

 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

// 返回ChatResponse对象，ChatResponse对象包含了很多信息
ChatResponse chatResponse = chatClient.prompt()
    .user("Tell me a joke")
    .call()
    .chatResponse();


// 返回实体对象
record ActorFilms(String actor, List<String> movies) {}
ActorFilms actorFilms = chatClient.prompt()
    .user("Generate the filmography for a random actor.")
    .call()
    .entity(ActorFilms.class);

// 还有一个重载的 entity 方法，其签名为 entity(ParameterizedTypeReference<T> type) ，允许你指定诸如泛型列表等类型
List<ActorFilms> multipleActors = chatClient.prompt()
    .user("Generate filmography for Tom Hanks and Bill Murray.")
    .call()
    .entity(new ParameterizedTypeReference<List<ActorFilms>>() {});

// stream() 方法可以让你异步获取响应，可以实现一个字一个字蹦出来的效果
Flux<String> streamResponse = chatClient.prompt()
    .user("Tell me a story")
    .stream()
    .content();

// 也可以流式获取ChatResponse对象
Flux<ChatResponse> streamWithMetadata = chatClient.prompt()
    .user("Tell me a story")
    .stream()
    .chatResponse();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

ChatClient chatClient = ChatClient.builder(chatModel)
        .defaultSystem("你是一个{personality}的智能助手")
        .build();


chatClient.prompt()
        .system(sp -> sp.param("personality", "暴躁")) // 替换模板
        .user(message)
        .call()
        .content());

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

ChatClient chatClient = ChatClient.builder(chatModel)
    .defaultAdvisors(
        new MessageChatMemoryAdvisor(chatMemory),  // 对话记忆
        new QuestionAnswerAdvisor(vectorStore) // RAG检索增强
    )
    .build();

String response = this.chatClient.prompt()
    .advisors(advisor -> 
              advisor.param("chat_memory_conversation_id", "001") // 设置对话的id，这样才能区分不同对话的记忆
            .param("chat_memory_response_size", 100)) // 指定对话的长度
    .user(userText)
    .call()
	.content();

1
2
3
4
5

ChatClient chatClient = ChatClient.builder(chatModel)
    .defaultAdvisors(
            MessageChatMemoryAdvisor.builder(chatMemory).build(),
            QuestionAnswerAdvisor.builder(vectorStore).build())
    .build();

1
2
3
4
5

// 获取order
int order = MessageChatMemoryAdvisor.builder(chatMemory).build().getOrder();

// 设置order
MessageChatMemoryAdvisor.builder(chatMemory).order(0).build()

1
2
3
4
5

[
  {"role": "user", "content": "你好"},
  {"role": "assistant", "content": "你好！有什么我能帮助你的吗？"},
  {"role": "user", "content": "讲个笑话"}
]

1
2
3
4
5
6

以下是之前的对话历史：
用户: 你好
助手: 你好！有什么我能帮助你的吗？
用户: 讲个笑话

现在请继续回答用户的问题。

 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

package com.yuanyu.aiagent.app;

import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class LoveApp {

    private final ChatClient chatClient;

    private static final String SYSTEM_PROMPT = "扮演深耕恋爱心理领域的专家。" +
            "开场向用户表明身份，告知用户可倾诉恋爱难题。围绕单身、恋爱、已婚三种状态提问：" +
            "单身状态询问社交圈拓展及追求心仪对象的困扰；恋爱状态询问沟通、习惯差异引发的矛盾；" +
            "已婚状态询问家庭责任与亲属关系处理的问题。引导用户详述事情经过、对方反应及自身想法，以便给出专属解决方案。";

    /**
     * 初始化 ChatClient
     * @param dashscopeChatModel
     */
    public LoveApp(ChatModel dashscopeChatModel) {
        // 初始化基于内存的对话记忆
        ChatMemory memory = MessageWindowChatMemory.builder()
                .maxMessages(10) // 最多保存 10 条消息（默认20条）
                .build();

        chatClient = ChatClient.builder(dashscopeChatModel)
                .defaultSystem(SYSTEM_PROMPT)
                .defaultAdvisors(
                        MessageChatMemoryAdvisor.builder(memory).build()
                )
                .build();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

/**
 * AI 对话
 * @param message
 * @param chatId
 * @return
 */
public String doChat(String message, String chatId) {
    ChatResponse chatResponse = chatClient.prompt()
            .user(message)
            .advisors(spec -> spec.param(ChatMemory.CONVERSATION_ID, chatId))
            .call()
            .chatResponse();
    String content = chatResponse.getResult().getOutput().getText();
    log.info("content: {}", content);
    return content;
}

 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

package com.yuanyu.aiagent.app;

import jakarta.annotation.Resource;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.UUID;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
class LoveAppTest {

    @Resource
    private LoveApp loveApp;

    @Test
    void doChat() {
        // 随机生成一个会话 ID
        String chatId = UUID.randomUUID().toString();

        // 测试对话
        // 第一轮
        String message = "你好，我是缘鱼。";
        String answer = loveApp.doChat(message, chatId);

        // 第二轮
        message = "Ciallo～(∠・ω< )⌒☆";
        answer = loveApp.doChat(message, chatId);
        Assertions.assertNotNull(answer); // 断言返回结果不为空，若为空则测试失败

        // 第三轮
        message = "我是谁？";
        answer = loveApp.doChat(message, chatId);
        Assertions.assertNotNull(answer);

    }
}

1
2
3

public class SimpleLoggerAdvisor implements CallAdvisor, StreamAdvisor {
	// ...
}

 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

@Override
public String getName() { 
    // 为每个 Advisor 提供一个唯一标识符（也可以直接定义一个字符串返回，比如return "CialloAdvisor";）
    return this.getClass().getSimpleName(); 
}

@Override
public int getOrder() { 
    // 通过设置 order 值来控制执行顺序。数值越小，优先级越高。
    return 0; 
}

@Override
public ChatClientResponse adviseCall(ChatClientRequest chatClientRequest, CallAdvisorChain callAdvisorChain) {

    // 前置处理请求（logRequest是自己定义的处理方法）
    logRequest(chatClientRequest);

    // 调用链中下一个Advisor
    ChatClientResponse chatClientResponse = callAdvisorChain.nextCall(chatClientRequest);

    // 后置处理响应
    logResponse(chatClientResponse);

    return chatClientResponse;
}

// 定义自己需要的处理
private void logRequest(ChatClientRequest request) {
    logger.debug("request: {}", request);
}

private void logResponse(ChatClientResponse chatClientResponse) {
    logger.debug("response: {}", chatClientResponse);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// getName、getOrder方法同上

@Override
public Flux<ChatClientResponse> adviseStream(ChatClientRequest chatClientRequest,
        StreamAdvisorChain streamAdvisorChain) {
    logRequest(chatClientRequest);

    // 获取流式响应（多个chunk）
    Flux<ChatClientResponse> chatClientResponses = streamAdvisorChain.nextStream(chatClientRequest);

   // 聚合响应并在完成后记录日志：
   // 聚合器会收集所有chunk，组装成完整的响应
   // 调用logResponse记录完整的响应日志（自定义方法）
   // 同时保持流式特性，继续向下游传递
    return new ChatClientMessageAggregator().aggregateChatClientResponse(chatClientResponses, this::logResponse); 
}

// logRequest、logResponse方法同上

 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

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.yuanyu.aiagent.advisor;

import java.util.function.Function;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ai.chat.client.ChatClientMessageAggregator;
import org.springframework.ai.chat.client.ChatClientRequest;
import org.springframework.ai.chat.client.ChatClientResponse;
import org.springframework.ai.chat.client.advisor.api.CallAdvisor;
import org.springframework.ai.chat.client.advisor.api.CallAdvisorChain;
import org.springframework.ai.chat.client.advisor.api.StreamAdvisor;
import org.springframework.ai.chat.client.advisor.api.StreamAdvisorChain;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.model.ModelOptionsUtils;
import org.springframework.lang.Nullable;
import reactor.core.publisher.Flux;

@Slf4j
public class MyLoggerAdvisor implements CallAdvisor, StreamAdvisor {

    public ChatClientResponse adviseCall(ChatClientRequest chatClientRequest, CallAdvisorChain callAdvisorChain) {
        this.logRequest(chatClientRequest);
        ChatClientResponse chatClientResponse = callAdvisorChain.nextCall(chatClientRequest);
        this.logResponse(chatClientResponse);
        return chatClientResponse;
    }

    public Flux<ChatClientResponse> adviseStream(ChatClientRequest chatClientRequest, StreamAdvisorChain streamAdvisorChain) {
        this.logRequest(chatClientRequest);
        Flux<ChatClientResponse> chatClientResponses = streamAdvisorChain.nextStream(chatClientRequest);
        return (new ChatClientMessageAggregator()).aggregateChatClientResponse(chatClientResponses, this::logResponse);
    }

    protected void logRequest(ChatClientRequest request) {
        log.info("AI Request: {}", request.prompt());
    }

    protected void logResponse(ChatClientResponse chatClientResponse) {
        log.info("AI Response: {}", chatClientResponse.chatResponse().getResult().getOutput().getText());
    }

    public String getName() {
        return this.getClass().getSimpleName();
    }

    public int getOrder() {
        return 0;
    }

}

1
2

{Input_Query}
Read the question again: {Input_Query}

 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

public class ReReadingAdvisor implements BaseAdvisor {

	private static final String DEFAULT_RE2_ADVISE_TEMPLATE = """
			{re2_input_query}
			Read the question again: {re2_input_query}
			""";

	private final String re2AdviseTemplate;

	private int order = 0;

	public ReReadingAdvisor() {
		this(DEFAULT_RE2_ADVISE_TEMPLATE);
	}

	public ReReadingAdvisor(String re2AdviseTemplate) {
		this.re2AdviseTemplate = re2AdviseTemplate;
	}

	@Override
	public ChatClientRequest before(ChatClientRequest chatClientRequest, AdvisorChain advisorChain) { // ①
		String augmentedUserText = PromptTemplate.builder()
			.template(this.re2AdviseTemplate)
			.variables(Map.of("re2_input_query", chatClientRequest.prompt().getUserMessage().getText()))
			.build()
			.render();

		return chatClientRequest.mutate()
			.prompt(chatClientRequest.prompt().augmentUserMessage(augmentedUserText))
			.build();
	}

	@Override
	public ChatClientResponse after(ChatClientResponse chatClientResponse, AdvisorChain advisorChain) {
		return chatClientResponse;
	}

	@Override
	public int getOrder() { // ②
		return this.order;
	}

	public ReReadingAdvisor withOrder(int order) {
		this.order = order;
		return this;
	}

}

 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

// 存入数据
public class MyLoggerAdvisor implements CallAdvisor, StreamAdvisor {
    public ChatClientResponse adviseCall(ChatClientRequest chatClientRequest, CallAdvisorChain callAdvisorChain) {
        // 要接收修改后的对象，然后传递修改后的对象
        ChatClientRequest request = this.logRequest(chatClientRequest);
        ChatClientResponse chatClientResponse = callAdvisorChain.nextCall(request);
        this.logResponse(chatClientResponse);
        return chatClientResponse;
    }

    // ...

    protected ChatClientRequest logRequest(ChatClientRequest request) {
        log.info("AI Request: {}", request.prompt());
		// 设置键值对后返回ChatClientRequest对象
        return request.mutate().context("hello", "ciallo").build();
    }

    // ...

}


// 取出数据
public class ReReadingAdvisor implements BaseAdvisor {
	// ...

	@Override
	public ChatClientRequest before(ChatClientRequest chatClientRequest, AdvisorChain advisorChain) { // ①
		// ...

        // 应该在控制台看见输出：************ciallo
		System.out.println("************" + chatClientRequest.context().get("hello"));

		return // ...
	}

	// ...
}