将DeepSeek预设指定角色

最新推荐文章于 2025-05-10 17:17:50 发布

墨执咖️

最新推荐文章于 2025-05-10 17:17:50 发布

阅读量619

点赞数 16

分类专栏： Java篇后端 DeepSeek 文章标签： java spring 前端

本文链接：https://blog.csdn.net/2301_76761656/article/details/147469455

版权

Java篇同时被 3 个专栏收录

21 篇文章

订阅专栏

后端

16 篇文章

订阅专栏

DeepSeek

2 篇文章

订阅专栏

预设角色（系统消息SystemMessage）：

基础大模型是没有目的性的，你聊什么给什么，但是如果我们开发的事一个智能票务助手，我需要他以一个票务助手的角色跟我对话，并且在我跟他说"退票"的时候，让大模型一定要告诉我“车次”和"姓名" ，这样我才能去调用业务方法（假设有一个业务方法，需要根据车子和姓名才能查询具体车票），进行退票。

在langchain4j中实现也非常简单:

@SystemMessage 系统消息，一般做一些预设角色的提示词，设置大模型的基本职责
可以通过{{current_date}} 传入参数，因为预设词中的文本可能需要实时变化
@V(“current_date”)，通过@V传入{{}}中的参数
一旦参数不止一个，就需要通过@UserMessage设置用户信息

修改AiConfig中的内容：

加入：

//定义角色
@SystemMessage("""
        您是“12345”铁路公司的客户聊天支持代理。请以友好、乐于助人且愉快的方式来回复。
        您正在通过在线聊天系统与客户互动。
        在提供有关预订或取消预订的信息之前，您必须始终从用户处获取以下信息:预订号、客户姓名。
        请讲中文。
        今天的日期是 {{current_date}}.
        """)
TokenStream stream(@UserMessage String userMessage,
                   @V("current_date") String currentDate);

完整代码：

package com.gec.langchain4.config;

import com.gec.langchain4.service.ToolsService;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiStreamingChatModel;
import dev.langchain4j.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Configuration
public class AiConfig {

    // 定义AI助手的公共接口
    public interface Assistant{
        // 普通聊天方法（阻塞式，返回完整响应）
        String chat(String message);

        // 流式响应方法（实时返回生成的token）
        TokenStream stream(String message);

        //定义角色
        @SystemMessage("""
                您是“12345”铁路公司的客户聊天支持代理。请以友好、乐于助人且愉快的方式来回复。
                您正在通过在线聊天系统与客户互动。
                在提供有关预订或取消预订的信息之前，您必须始终从用户处获取以下信息:预订号、客户姓名。
                请讲中文。
                今天的日期是 {{current_date}}.
                """)
        TokenStream stream(@UserMessage String userMessage,
                           @V("current_date") String currentDate);

    }

//    @Bean
//    public StreamingChatLanguageModel deepSeekModel() {
//        return OpenAiStreamingChatModel.builder()
//                .apiKey("sk-2c6e258110424ba1bef5a241dc47c3fa")
//                .baseUrl("https://api.deepseek.com/v1") // 替换为 DeepSeek 的端点
    //                .modelName("deepseek-chat") // DeepSeek 的模型名称
//                .build();
//    }

    // 定义Spring Bean来创建助手实例
    @Bean  // 标记为Spring管理的Bean
    public Assistant getAssistant(
            // 注入标准聊天语言模型（用于普通响应）
            ChatLanguageModel chatLanguageModel,
            // 注入流式聊天语言模型（用于流式响应）
            StreamingChatLanguageModel streamingChatLanguageModel,
            ToolsService toolsService
    ){

        // 创建聊天记忆，保留最近10条消息的对话上下文
        ChatMemory chatMemory = MessageWindowChatMemory.withMaxMessages(10);

        // 使用AI服务构建助手实现
        Assistant assistant = AiServices.builder(Assistant.class)
                // 设置标准聊天模型（用于chat()方法）
                .chatLanguageModel(chatLanguageModel)
                // 设置流式聊天模型（用于stream()方法）
                .streamingChatLanguageModel(streamingChatLanguageModel)
                // 配置聊天记忆保持对话上下文
                .chatMemory(chatMemory)
                //加入配置的工具
                .tools(toolsService)
                // 完成构建
                .build();

        // 返回配置好的助手实例
        return assistant;
    }

    public interface AssistantUnique{
        // 普通聊天方法（阻塞式，返回完整响应）
        String chat(@MemoryId int memoryId,@UserMessage String message);

        /**
         * 流式聊天方法（实时返回token）
         *
         *@param memoryId 对话记忆ID（用于区分不同会话）
         *@param userMessage 用户输入的消息
         *@return TokenStream 流式响应对象
         */
        TokenStream stream(@MemoryId int memoryId,@UserMessage String userMessage);
    }

    /**
     * 创建AssistantUnique实例的方法
     * @param chatLanguageModel 同步聊天模型（注入的依赖）
     * @param streamingChatLanguageModel 流式聊天模型（注入的依赖）
     * @return 配置好的AssistantUnique实例
     */
    @Bean
    public AssistantUnique getAssistantUnique(ChatLanguageModel chatLanguageModel,
                                              StreamingChatLanguageModel streamingChatLanguageModel){

        // 使用AiServices构建器创建接口实现
        AssistantUnique assistantUnique = AiServices.builder(AssistantUnique.class)
                // 设置同步聊天模型（用于chat方法）
                .chatLanguageModel(chatLanguageModel)
                // 设置流式聊天模型（用于stream方法）
                .streamingChatLanguageModel(streamingChatLanguageModel)
                // 配置对话记忆提供者（为每个memoryId创建独立的记忆窗口）
                .chatMemoryProvider(memoryId->
                        MessageWindowChatMemory.builder().maxMessages(10) // 每个对话最多保存10条消息
                                .id(memoryId)  // 设置记忆ID（区分不同会话）
                                .build())
                .build();

        return assistantUnique;
    }

}

修改控制器：memoryStreamChat这个方法：

// 定义HTTP接口端点，处理带有记忆功能的流式聊天请求
    @RequestMapping(value = "/memory_steam_chat",produces = "text/stream;charset=utf-8")
// 返回Flux<String>类型实现流式响应，参数message默认值为"我是谁"
    public Flux<String> memoryStreamChat(
            // 从请求参数获取用户消息，默认值"我是谁"
            @RequestParam(defaultValue = "我是谁") String message,
            // 注入HttpServletResponse对象（虽然响应式编程中通常不直接使用）
            HttpServletResponse response) {

        // 调用助手服务的流式接口，获取TokenStream对象
        TokenStream stream = assistant.stream(message, LocalDate.now().toString());

        // 创建Flux流式响应
        return Flux.create(sink -> {
            // 设置部分响应回调：每次收到部分响应时通过sink发送数据
            stream.onPartialResponse(s -> sink.next(s))
                    // 设置完成回调：当收到完成信号时关闭流
                    .onCompleteResponse(c-> sink.complete())
                    // 设置错误回调：发生错误时传递错误信号 它的作用是将 sink 对象的 error 方法作为函数式接口的实现传递进去。
                    .onError(sink::error)//stream.onError(error -> sink.error(error));
                    // 启动流处理
                    .start();
        });
    }

完整代码：

package com.gec.langchain4.controller;

import com.gec.langchain4.config.AiConfig;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.service.TokenStream;
import opennlp.tools.ml.maxent.io.QNModelWriter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

import javax.servlet.http.HttpServletResponse;
import java.time.LocalDate;
import java.util.Date;

@RestController
@RequestMapping("/ai")
public class AiController2 {

    //注入langChain的封装好的语言对象
    @Autowired
    ChatLanguageModel chatLanguageModel;

    @Autowired
    AiConfig2.Assistant assistant;

    @RequestMapping("/chat")
    public String test(@RequestParam(defaultValue = "你是谁") String name){
        return chatLanguageModel.chat(name);
    }

    // 定义HTTP接口端点，处理带有记忆功能的流式聊天请求
    @RequestMapping(value = "/memory_steam_chat",produces = "text/stream;charset=utf-8")
// 返回Flux<String>类型实现流式响应，参数message默认值为"我是谁"
    public Flux<String> memoryStreamChat(
            // 从请求参数获取用户消息，默认值"我是谁"
            @RequestParam(defaultValue = "我是谁") String message,
            // 注入HttpServletResponse对象（虽然响应式编程中通常不直接使用）
            HttpServletResponse response) {

        // 调用助手服务的流式接口，获取TokenStream对象
        TokenStream stream = assistant.stream(message, LocalDate.now().toString());

        // 创建Flux流式响应
        return Flux.create(sink -> {
            // 设置部分响应回调：每次收到部分响应时通过sink发送数据
            stream.onPartialResponse(s -> sink.next(s))
                    // 设置完成回调：当收到完成信号时关闭流
                    .onCompleteResponse(c-> sink.complete())
                    // 设置错误回调：发生错误时传递错误信号 它的作用是将 sink 对象的 error 方法作为函数式接口的实现传递进去。
                    .onError(sink::error)//stream.onError(error -> sink.error(error));
                    // 启动流处理
                    .start();
        });
    }

    @Autowired
    AiConfig.AssistantUnique assistantUnique;

    @RequestMapping("/memoryId_chat")
    public String memoryChat(@RequestParam(defaultValue = "我是谁") String message,int userId){
        return assistantUnique.chat(userId,message);
    }
}

效果：

加入退票信息：

我们可以用前端页面来调用这个接口：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>DeepSeek 智能票务客服</title>
    <style>
        :root {
            --primary-color: #6e48aa;
            --secondary-color: #9d50bb;
            --bg-color: #f5f7fa;
            --user-bubble: #e3f2fd;
            --bot-bubble: #ffffff;
            --text-color: #333;
            --shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }

        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        body {
            background-color: var(--bg-color);
            color: var(--text-color);
            height: 100vh;
            display: flex;
            flex-direction: column;
        }

        .header {
            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color));
            color: white;
            padding: 1rem;
            text-align: center;
            box-shadow: var(--shadow);
            position: relative;
            z-index: 10;
        }

        .header h1 {
            font-size: 1.5rem;
            font-weight: 600;
        }

        .chat-container {
            flex: 1;
            overflow-y: auto;
            padding: 1rem;
            display: flex;
            flex-direction: column;
            gap: 1rem;
            padding-bottom: 80px;
        }

        .message {
            max-width: 80%;
            padding: 0.8rem 1rem;
            border-radius: 1rem;
            line-height: 1.4;
            position: relative;
            animation: fadeIn 0.3s ease;
            word-wrap: break-word;
        }

        @keyframes fadeIn {
            from { opacity: 0; transform: translateY(10px); }
            to { opacity: 1; transform: translateY(0); }
        }

        .user-message {
            align-self: flex-end;
            background-color: var(--user-bubble);
            border-bottom-right-radius: 0.2rem;
            color: #1a237e;
        }

        .bot-message {
            align-self: flex-start;
            background-color: var(--bot-bubble);
            border-bottom-left-radius: 0.2rem;
            box-shadow: var(--shadow);
        }

        .message-time {
            font-size: 0.7rem;
            color: #666;
            margin-top: 0.3rem;
            text-align: right;
        }

        .input-container {
            position: fixed;
            bottom: 0;
            left: 0;
            right: 0;
            padding: 1rem;
            background-color: white;
            box-shadow: 0 -2px 10px rgba(0, 0, 0, 0.1);
            display: flex;
            gap: 0.5rem;
        }

        #message-input {
            flex: 1;
            padding: 0.8rem 1rem;
            border: 1px solid #ddd;
            border-radius: 2rem;
            outline: none;
            font-size: 1rem;
            transition: border 0.3s;
        }

        #message-input:focus {
            border-color: var(--primary-color);
        }

        #send-button {
            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color));
            color: white;
            border: none;
            border-radius: 2rem;
            padding: 0 1.5rem;
            cursor: pointer;
            font-weight: 600;
            transition: transform 0.2s, opacity 0.2s;
        }

        #send-button:hover {
            opacity: 0.9;
            transform: scale(1.02);
        }

        #send-button:active {
            transform: scale(0.98);
        }

        .typing-indicator {
            display: inline-block;
            padding: 0.8rem 1rem;
            background-color: var(--bot-bubble);
            border-radius: 1rem;
            box-shadow: var(--shadow);
            align-self: flex-start;
            margin-bottom: 1rem;
        }

        .typing-dot {
            display: inline-block;
            width: 8px;
            height: 8px;
            border-radius: 50%;
            background-color: #666;
            margin: 0 2px;
            animation: typingAnimation 1.4s infinite ease-in-out;
        }

        .typing-dot:nth-child(1) {
            animation-delay: 0s;
        }

        .typing-dot:nth-child(2) {
            animation-delay: 0.2s;
        }

        .typing-dot:nth-child(3) {
            animation-delay: 0.4s;
        }

        @keyframes typingAnimation {
            0%, 60%, 100% { transform: translateY(0); }
            30% { transform: translateY(-5px); }
        }

        /* Markdown 样式增强 */
        .bot-message pre {
            background-color: #f8f8f8;
            padding: 1rem;
            border-radius: 0.5rem;
            overflow-x: auto;
        }

        .bot-message code {
            font-family: 'Courier New', monospace;
            background-color: #f0f0f0;
            padding: 0.2rem 0.4rem;
            border-radius: 0.3rem;
            font-size: 0.9em;
        }

        /* 响应式设计 */
        @media (max-width: 768px) {
            .message {
                max-width: 90%;
            }
        }
    </style>
</head>
<body>
<div class="header">
    <h1>DeepSeek 智能助手</h1>
</div>

<div class="chat-container" id="chat-container">
    <!-- 聊天消息将在这里动态添加 -->
</div>

<div class="input-container">
    <input type="text" id="message-input" placeholder="输入消息..." autocomplete="off">
    <button id="send-button">发送</button>
</div>

<script>
    document.addEventListener('DOMContentLoaded', function() {
        const chatContainer = document.getElementById('chat-container');
        const messageInput = document.getElementById('message-input');
        const sendButton = document.getElementById('send-button');

        // 添加示例欢迎消息
        addBotMessage("你好！我是DeepSeek智能助手，有什么可以帮你的吗？");

        // 发送消息函数
        function sendMessage() {
            const message = messageInput.value.trim();
            if (message === '') return;

            // 添加用户消息到聊天界面
            addUserMessage(message);
            messageInput.value = '';
            messageInput.focus();

            // 显示"正在输入"指示器
            const typingIndicator = showTypingIndicator();

            // 创建机器人消息容器（初始为空）
            const botMessageElement = createBotMessageContainer();
            let botResponse = '';

            // 发送消息到后端（流式接收）
            fetch('http://localhost:8080/ai/memory_steam_chat?message=' + encodeURIComponent(message), {
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json',
                }
            })
                .then(response => {
                    if (!response.ok) {
                        throw new Error('网络响应不正常');
                    }

                    const reader = response.body.getReader();
                    const decoder = new TextDecoder('utf-8');

                    function readStream() {
                        return reader.read().then(({done, value}) => {
                            if (done) {
                                removeTypingIndicator(typingIndicator);
                                addMessageTime(botMessageElement);
                                return;
                            }

                            // 解码数据块并追加到消息
                            const chunk = decoder.decode(value, {stream: true});
                            botResponse += chunk;

                            // 更新消息容器的内容（逐步显示）
                            botMessageElement.querySelector('.message-content').innerHTML = formatResponse(botResponse);

                            // 自动滚动到底部
                            scrollToBottom();

                            // 继续读取下一个数据块
                            return readStream();
                        });
                    }

                    return readStream();
                })
                .catch(error => {
                    console.error('Error:', error);
                    removeTypingIndicator(typingIndicator);
                    addBotMessage("抱歉，出现了错误，请稍后再试。");
                });
        }

        // 创建机器人消息容器
        function createBotMessageContainer() {
            const messageElement = document.createElement('div');
            messageElement.className = 'message bot-message';
            messageElement.innerHTML = '<div class="message-content"></div>';
            chatContainer.appendChild(messageElement);
            scrollToBottom();
            return messageElement;
        }

        // 添加消息时间戳
        function addMessageTime(messageElement) {
            const time = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
            const timeElement = document.createElement('div');
            timeElement.className = 'message-time';
            timeElement.textContent = time;
            messageElement.appendChild(timeElement);
        }

        // 格式化响应内容（简单Markdown支持）
        function formatResponse(text) {
            // 简单处理换行
            return text.replace(/\n/g, '<br>')
                // 粗体
                .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
                // 代码块
                .replace(/```([\s\S]*?)```/g, '<pre><code>$1</code></pre>')
                // 行内代码
                .replace(/`(.*?)`/g, '<code>$1</code>');
        }

        // 添加用户消息到聊天界面
        function addUserMessage(text) {
            const messageElement = document.createElement('div');
            messageElement.className = 'message user-message';

            const time = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });

            messageElement.innerHTML = `
                <div>${text}</div>
                <div class="message-time">${time}</div>
            `;

            chatContainer.appendChild(messageElement);
            scrollToBottom();
        }

        // 添加机器人消息到聊天界面
        function addBotMessage(text) {
            const messageElement = document.createElement('div');
            messageElement.className = 'message bot-message';

            const time = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });

            messageElement.innerHTML = `
                <div>${formatResponse(text)}</div>
                <div class="message-time">${time}</div>
            `;

            chatContainer.appendChild(messageElement);
            scrollToBottom();
        }

        // 显示"正在输入"指示器
        function showTypingIndicator() {
            const indicator = document.createElement('div');
            indicator.className = 'typing-indicator';
            indicator.id = 'typing-indicator';
            indicator.innerHTML = `
                <div class="typing-dot"></div>
                <div class="typing-dot"></div>
                <div class="typing-dot"></div>
            `;

            chatContainer.appendChild(indicator);
            scrollToBottom();
            return indicator;
        }

        // 移除"正在输入"指示器
        function removeTypingIndicator(indicator) {
            if (indicator && indicator.parentNode) {
                indicator.parentNode.removeChild(indicator);
            }
        }

        // 滚动到底部
        function scrollToBottom() {
            chatContainer.scrollTop = chatContainer.scrollHeight;
        }

        // 事件监听
        sendButton.addEventListener('click', sendMessage);

        messageInput.addEventListener('keypress', function(e) {
            if (e.key === 'Enter') {
                sendMessage();
            }
        });
    });
</script>
</body>
</html>