一、概述

之前咱们的AI助手存在两个问题:

  1. 响应太慢:后端使用阻塞式 ChatLanguageModel.generate() 调用大模型,必须等待完整回复生成完毕后才一次性返回给前端,用户需要等待数十秒才能看到任何内容
  2. 没有记忆:每次对话只发送当前问题给大模型,AI 无法理解对话上下文,导致用户连续提问时回答脱节

本文将详细介绍如何将 AI 对话改造为 专业的流式输出(Token-by-Token SSE) 效果,同时引入 对话记忆功能,让 AI 能够记住对话历史。

改造完成后,AI 回复像 ChatGPT 一样逐字输出,体验流畅;连续对话时 AI 能理解上文,回答连贯。

1.1 功能对比

维度改造前改造后
回复方式阻塞式,等待完整回复后一次性返回流式 StreamingChatLanguageModel,token-by-token SSE 推送
首字延迟数十秒几百毫秒
用户体验长时间白屏等待逐字打字效果,即时可见
对话记忆无,每次提问彼此独立每次发送最近 20 条历史消息作为上下文
记忆存储无MySQL conversation + message 表持久化

1.2 技术架构

图片.png

1.3 数据模型

对话记忆功能依赖两张 MySQL 表存储对话和消息:

Conversation(对话)
├── id: 对话ID(雪花ID)
├── title: 对话标题
├── user_id: 用户ID
├── model: 使用的模型
├── tokens_used: Token 消耗量
├── status: 0-进行中, 1-已结束
└── created_at / updated_at

Message(消息)
├── id: 消息ID(雪花ID)
├── conversation_id: 所属对话ID
├── role: user / assistant
├── content: 消息内容
├── tokens: 估算的 Token 数
└── created_at

1.4 核心改造点

改造层级文件改造内容
模型层ModelProvider.java新增 StreamingChatLanguageModel 支持
服务层AiChatServiceImpl.java替换阻塞调用为流式调用,新增 buildChatHistory()
服务层RagChatServiceImpl.javaRAG 路径同步改造流式输出
接口层AiChatService.java新增 chatStream() 方法
前端服务ai.service.ts实现 SSE ReadableStream 解析 + token 批处理
前端状态ai.store.ts流式消息累积更新
前端页面AIAssistantPage.tsxReactMarkdown 渲染 + 滚动优化

二、后端改造:流式输出

2.1 ModelProvider:新增流式模型实例

LangChain4j 的 OpenAiStreamingChatModel 与 OpenAiChatModel 使用**相同的 API 参数**(baseUrl、apiKey、modelName、maxTokens、temperature),区别在于 OpenAiStreamingChatModel 返回的是流式响应,通过 StreamingResponseHandler 回调接口逐 token 推送。

编辑 kb-ai/src/main/java/com/knowledge/base/ai/config/ModelProvider.java,新增以下内容:

(1)新增导入

import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiStreamingChatModel;

(2)新增流式模型缓存

/** 流式模型实例缓存(懒加载) */
private final Map<String, StreamingChatLanguageModel> streamingInstanceCache = new ConcurrentHashMap<>();

(3)新增流式模型构建方法

/**
 * 懒加载构建 StreamingChatLanguageModel 实例(流式输出)
 */
private StreamingChatLanguageModel buildStreamingModel(String modelName) {
    switch (modelName) {
        case "qwen":
            return OpenAiStreamingChatModel.builder()
                    .baseUrl(qwenBaseUrl)
                    .apiKey(qwenApiKey)
                    .modelName(qwenModel)
                    .maxTokens(qwenMaxTokens)
                    .temperature(qwenTemperature)
                    .build();
        case "deepseek":
            return OpenAiStreamingChatModel.builder()
                    .baseUrl(deepseekBaseUrl)
                    .apiKey(deepseekApiKey)
                    .modelName(deepseekModel)
                    .maxTokens(deepseekMaxTokens)
                    .temperature(deepseekTemperature)
                    .build();
        default:
            throw new IllegalStateException("未知模型:" + modelName);
    }
}

(4)新增获取流式模型的公开方法

/**
 * 根据模型名称获取 StreamingChatLanguageModel 实例(流式输出,懒加载)
 *
 * @param modelName 模型名称(qwen | deepseek)
 * @return StreamingChatLanguageModel 实例
 * @throws IllegalStateException 如果请求的模型未配置API Key
 */
public StreamingChatLanguageModel getStreamingModel(String modelName) {
    String key = resolveModelKey(modelName);
    if (!modelAvailable.containsKey(key) || !modelAvailable.get(key)) {
        throw new IllegalStateException(
                "模型 '" + key + "' 未配置API Key,无法使用。请设置环境变量后重启服务。");
    }
    return streamingInstanceCache.computeIfAbsent(key, k -> {
        log.info("🔄 首次调用,构建 StreamingChatLanguageModel:{}", k);
        return buildStreamingModel(k);
    });
}
注意:流式模型和阻塞式模型共用同一套 API Key 和参数配置(qwen.* / deepseek.*),配置项无需更改。buildStreamingModel 的参数与 buildModel 完全一致,仅类型不同。

2.2 AiChatService 接口:新增流式方法

编辑 kb-ai/src/main/java/com/knowledge/base/ai/service/AiChatService.java,新增流式对话方法声明:

/**
 * AI对话(流式)
 *
 * @param requestDTO 对话请求
 * @param userId     用户ID
 * @return SSE事件发射器
 */
SseEmitter chatStream(ChatRequestDTO requestDTO, Long userId);

2.3 AiChatServiceImpl:核心流式逻辑

这是最核心的改造。编辑 kb-ai/src/main/java/com/knowledge/base/ai/service/impl/AiChatServiceImpl.java。

2.3.1 流式 SSE 实现原理

图片.png

关键组件说明:

组件说明
SseEmitterSpring MVC 提供的 SSE 发射器,支持服务器向客户端推送事件流
StreamingChatLanguageModelLangChain4j 流式接口,内部由 OkHttp 实现 HTTP 流式请求
StreamingResponseHandler回调接口:onNext(token) / onComplete() / onError()
CompletableFuture.runAsync异步执行 LLM 调用,避免阻塞 Tomcat 线程

2.3.2 完整流式实现代码

@Override
public SseEmitter chatStream(ChatRequestDTO requestDTO, Long userId) {
    // RAG路由:如果启用了知识库检索增强且RAG服务可用
    if (requestDTO.isEnableRag() && ragChatService != null) {
        try {
            return ragChatService.chatWithContextStream(requestDTO, userId);
        } catch (Exception e) {
            log.warn("RAG流式对话失败,降级为普通LLM流式对话:{}", e.getMessage());
        }
    }

    SseEmitter emitter = new SseEmitter(30 * 60 * 1000L);  // 30分钟超时

    try {
        // 1. 创建或验证对话
        Long conversationId = requestDTO.getConversationId();
        if (conversationId == null) {
            conversationId = conversationService.createConversation(requestDTO, userId);
        } else {
            Conversation existingConv = conversationService.getById(conversationId);
            if (existingConv == null || !existingConv.getUserId().equals(userId)) {
                conversationId = conversationService.createConversation(requestDTO, userId);
            }
        }
        final Long finalConversationId = conversationId;
        final String modelName = requestDTO.getModel() != null
                ? requestDTO.getModel() : modelProvider.getDefaultModelName();

        // 2. 异步执行流式 LLM 调用
        CompletableFuture.runAsync(() -> {
            try {
                StreamingChatLanguageModel streamingModel =
                        modelProvider.getStreamingModel(modelName);

                // 3. 构建对话上下文(历史消息),实现记忆功能 ← 见第三节
                List<ChatMessage> chatMessages = buildChatHistory(finalConversationId);

                // 4. 持久化用户消息
                Message userMsgEntity = Message.builder()
                        .conversationId(finalConversationId)
                        .role("user")
                        .content(requestDTO.getContent())
                        .tokens(estimateTokens(requestDTO.getContent()))
                        .build();
                messageMapper.insert(userMsgEntity);

                // 5. 将当前用户消息加入上下文
                chatMessages.add(UserMessage.from(requestDTO.getContent()));

                // 6. 累积完整响应用于持久化
                StringBuilder fullResponseBuilder = new StringBuilder();

                // 7. 流式调用大模型
                streamingModel.generate(chatMessages,
                        new StreamingResponseHandler<AiMessage>() {

                    @Override
                    public void onNext(String token) {
                        fullResponseBuilder.append(token);
                        try {
                            emitter.send(SseEmitter.event()
                                    .name("message")
                                    .data(token));
                        } catch (IOException e) {
                            log.warn("发送流式token失败(客户端可能已断开): {}",
                                    e.getMessage());
                        }
                    }

                    @Override
                    public void onComplete(Response<AiMessage> response) {
                        try {
                            String fullResponse = fullResponseBuilder.toString();

                            // 持久化 AI 消息
                            Message aiMsgEntity = Message.builder()
                                    .conversationId(finalConversationId)
                                    .role("assistant")
                                    .content(fullResponse)
                                    .tokens(estimateTokens(fullResponse))
                                    .build();
                            messageMapper.insert(aiMsgEntity);

                            // 更新 Token 统计
                            AtomicInteger totalTokens =
                                    new AtomicInteger(userMsgEntity.getTokens());
                            totalTokens.addAndGet(aiMsgEntity.getTokens());
                            conversationService.updateTokens(
                                    finalConversationId, totalTokens.get());

                            // 发送完成事件
                            emitter.send(SseEmitter.event()
                                    .name("done")
                                    .data(ChatResponseVO.builder()
                                            .conversationId(finalConversationId)
                                            .messageId(aiMsgEntity.getId())
                                            .content(fullResponse)
                                            .tokens(totalTokens.get())
                                            .build()));
                            emitter.complete();
                        } catch (IOException e) {
                            log.warn("发送完成事件失败: {}", e.getMessage());
                        }
                    }

                    @Override
                    public void onError(Throwable error) {
                        log.error("流式对话失败: {}", error.getMessage(), error);
                        try {
                            emitter.send(SseEmitter.event()
                                    .name("error")
                                    .data(error.getMessage()));
                            emitter.complete();
                        } catch (IOException e) {
                            log.error("发送错误事件失败: {}", e.getMessage());
                        }
                    }
                });

            } catch (Exception e) {
                // 错误处理:提取 HTTP 状态码,给出友好提示
                // ... 省略详细错误处理代码 ...
                emitter.send(SseEmitter.event().name("error").data(errorMsg));
                emitter.complete();
            }
        }, asyncTaskExecutor);

    } catch (Exception e) {
        log.error("创建SSE发射器失败: {}", e.getMessage(), e);
        emitter.completeWithError(e);
    }

    return emitter;
}

2.3.3 与改造前的对比

改造前(阻塞式):

// 阻塞等待完整响应,用户体验差
ChatLanguageModel chatModel = modelProvider.getModel(modelName);
Response<AiMessage> response = chatModel.generate(chatMessages);
String responseContent = response.content().text();  // 需要等待数十秒

改造后(流式):

// 逐 token 推送,即时可见
StreamingChatLanguageModel streamingModel =
        modelProvider.getStreamingModel(modelName);
streamingModel.generate(chatMessages, new StreamingResponseHandler<AiMessage>() {
    @Override
    public void onNext(String token) {
        emitter.send(SseEmitter.event().name("message").data(token));
    }
    // ...
});

三、后端改造:对话记忆功能

3.1 记忆原理

图片.png

每次用户提问时,系统会从 MySQL 的 message 表中加载该对话最近 20 条消息,组装成 LangChain4j 的 List<ChatMessage> 格式,与当前问题一起发送给大模型。这样大模型就能"看到"之前的对话内容,给出连贯的回答。

为什么是 20 条? 这是一个经验值:足够覆盖常规多轮对话需求,同时避免上下文过长导致 Token 消耗过高、响应变慢。

3.2 buildChatHistory 实现

编辑 AiChatServiceImpl.java,新增 buildChatHistory() 方法:

/**
 * 从 MySQL 中加载最近 N 条对话记录,构建 LangChain4j 消息上下文
 * <p>实现对话记忆功能,让 AI 能理解本轮对话的历史(最多保留最近 20 条消息)</p>
 */
private List<ChatMessage> buildChatHistory(Long conversationId) {
    LambdaQueryWrapper<Message> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(Message::getConversationId, conversationId)
            .orderByDesc(Message::getCreatedAt)
            .last("LIMIT 20");
    List<Message> historyMessages = messageMapper.selectList(queryWrapper);
    // 按时间正序排列(最早的在前面)
    Collections.reverse(historyMessages);

    List<ChatMessage> chatMessages = new ArrayList<>();
    for (Message msg : historyMessages) {
        if ("user".equals(msg.getRole())) {
            chatMessages.add(UserMessage.from(msg.getContent()));
        } else if ("assistant".equals(msg.getRole())) {
            chatMessages.add(AiMessage.from(msg.getContent()));
        }
    }
    return chatMessages;
}

关键设计决策:

决策说明
LIMIT 20保留最近 20 条消息作为上下文窗口
orderByDesc + reverse先倒序取最新 N 条,再反转为正序(时间顺序)
仅加载 user + assistant系统消息(如 system prompt)不参与历史对话
每次提问都重新加载保证历史是最新的,不依赖内存缓存

3.3 在 chat() 非流式方法中也加入记忆

非流式 chat() 方法同样需要记忆功能,改造方式完全一致:

// chat() 方法中加入 buildChatHistory
List<ChatMessage> chatMessages = buildChatHistory(conversationId);
// ... 保存用户消息 ...
chatMessages.add(UserMessage.from(requestDTO.getContent()));
Response<AiMessage> response = chatModel.generate(chatMessages);

3.4 RAG 路径同步改造

RagChatServiceImpl 中的 chatWithContextStream() 和 chatWithContext() 也同步加入流式输出和 buildChatHistory() 记忆功能。RAG 路径的区别仅在于 RAG Prompt 包含了检索到的知识库文档作为参考上下文,但记忆机制完全相同。


四、前端改造:SSE 流解析与渲染

4.1 SSE 协议解析

后端通过 SSE(Server-Sent Events)推送事件,格式如下:

event: message
data: 根据

event: message
data: 您

event: message
data: 提供

event: done
data: {"conversationId":123,"content":"...","tokens":500}

前端使用 fetch + ReadableStream API 逐行解析 SSE 事件流。

4.2 ai.service.ts:流式请求 + Token 批处理

编辑 src/services/ai.service.ts。

4.2.1 Token 批处理回调

逐 token 更新 Zustand store 会导致页面频繁刷新、产生明显跳动。解决方案是 批处理缓冲:每 80ms 将缓冲区中的 tokens 合并为一批,一次性更新 UI。

/**
 * 流式输出批处理回调
 *
 * <p>每隔 flushInterval ms 将缓冲区中的 token 批量发送给 onMessage,
 * 而非每个 token 都触发一次回调,减少状态更新频率,避免页面跳动。</p>
 */
function createBatchedCallback(
  onMessage: (chunk: string) => void,
  flushInterval: number = 80,
): { addToken: (token: string) => void; flush: () => void } {
  let buffer: string[] = [];
  let timer: ReturnType<typeof setInterval> | null = null;

  const startTimer = () => {
    if (timer) return;
    timer = setInterval(() => {
      if (buffer.length > 0) {
        const batch = buffer.join('');
        buffer = [];
        onMessage(batch);
      }
    }, flushInterval);
  };

  return {
    addToken: (token: string) => {
      buffer.push(token);
      startTimer();
    },
    flush: () => {
      if (timer) {
        clearInterval(timer);
        timer = null;
      }
      if (buffer.length > 0) {
        const batch = buffer.join('');
        buffer = [];
        onMessage(batch);
      }
    },
  };
}

4.2.2 askStream 方法:SSE 流式对话

askStream: (
  data: AIRequest,
  onMessage: (message: string) => void,
  onDone?: (result: { conversationId: number | string;
      messageId: number | string; content: string; tokens: number }) => void,
  onError?: (error: string) => void,
) => {
  // 创建批处理回调:每 80ms 批量输出一次
  const { addToken, flush } = createBatchedCallback(onMessage, 80);

  return fetch(`${import.meta.env.VITE_API_BASE_URL}/ai/chat/stream`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': tokenStorage.getAuthorizationHeader(),
    },
    body: JSON.stringify({
      content: data.question,
      conversationId: data.conversationId,
      model: data.model,
      enableRag: data.context?.knowledgeBase === true,
    }),
  }).then(async (response) => {
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    const reader = response.body?.getReader();
    const decoder = new TextDecoder();
    if (!reader) throw new Error('无法读取响应流');

    let buffer = '';
    let currentEvent = '';
    let messageLines: string[] = [];

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;

      buffer += decoder.decode(value, { stream: true });
      const lines = buffer.split('\n');
      buffer = lines.pop() || '';  // 保留不完整的最后一行

      for (const line of lines) {
        // 解析 event: 行
        if (line.startsWith('event:')) {
          if (messageLines.length > 0) {
            addToken(messageLines.join('\n'));
            messageLines = [];
          }
          currentEvent = line.slice(6).trim();
          continue;
        }

        // 解析 data: 行
        if (line.startsWith('data:')) {
          const data = line.startsWith('data: ')
              ? line.slice(6) : line.slice(5);

          if (currentEvent === 'error') {
            flush();
            onError?.(data);
            continue;
          }

          if (currentEvent === 'done') {
            flush();
            try {
              const parsed = JSON.parse(data);
              onDone?.(parsed);
            } catch { /* done 事件数据非 JSON,忽略 */ }
            continue;
          }

          // message 事件:累积 data 行
          messageLines.push(data);
          continue;
        }

        // 空行 = SSE 事件边界
        if (line === '') {
          if (messageLines.length > 0) {
            addToken(messageLines.join('\n'));
            messageLines = [];
          }
          currentEvent = '';
        }
      }
    }

    // 流结束时发送残留数据
    if (messageLines.length > 0) {
      addToken(messageLines.join('\n'));
    }
    flush();
  });
},

4.3 SSE 解析状态机

图片.png

4.4 AIAssistantPage:滚动优化

流式输出时内容持续增长,如果每次新增内容都用 smooth 滚动(~300ms 动画),动画会被频繁打断产生剧烈跳动。解决方案是流式输出期间用 behavior: 'auto' 瞬时滚动,流结束后才用 smooth。

const scrollToBottom = () => {
  messagesEndRef.current?.scrollIntoView({
    behavior: isStreaming ? 'auto' : 'smooth',
  });
};

五、记忆功能的数据库表设计

对话记忆功能基于两张已有的 MySQL 表:

5.1 Conversation 表

CREATE TABLE `conversation` (
  `id` BIGINT NOT NULL COMMENT '对话ID',
  `title` VARCHAR(100) NOT NULL DEFAULT '新对话' COMMENT '对话标题',
  `user_id` BIGINT NOT NULL COMMENT '用户ID',
  `model` VARCHAR(50) DEFAULT NULL COMMENT '使用的模型名称',
  `system_prompt` TEXT COMMENT '系统提示词',
  `tokens_used` INT NOT NULL DEFAULT 0 COMMENT 'Token使用量',
  `message_count` INT NOT NULL DEFAULT 0 COMMENT '消息数量',
  `status` TINYINT NOT NULL DEFAULT 0 COMMENT '状态(0-进行中,1-已结束)',
  `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  `deleted` TINYINT NOT NULL DEFAULT 0 COMMENT '逻辑删除',
  PRIMARY KEY (`id`),
  KEY `idx_user_id` (`user_id`),
  KEY `idx_created_at` (`created_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='AI对话表';

5.2 Message 表

CREATE TABLE `message` (
  `id` BIGINT NOT NULL COMMENT '消息ID',
  `conversation_id` BIGINT NOT NULL COMMENT '所属对话ID',
  `role` VARCHAR(20) NOT NULL COMMENT '角色(user/assistant/system)',
  `content` LONGTEXT NOT NULL COMMENT '消息内容',
  `tokens` INT NOT NULL DEFAULT 0 COMMENT '估算Token数',
  `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `deleted` TINYINT NOT NULL DEFAULT 0 COMMENT '逻辑删除',
  PRIMARY KEY (`id`),
  KEY `idx_conversation_id` (`conversation_id`),
  KEY `idx_created_at` (`created_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='AI消息表';

5.3 ORM 实体类

Conversation 实体(kb-ai/.../entity/Conversation.java):

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@TableName("conversation")
public class Conversation {
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;
    @TableField("title")
    private String title;
    @TableField("user_id")
    private Long userId;
    @TableField("model")
    private String model;
    @TableField("system_prompt")
    private String systemPrompt;
    @TableField("tokens_used")
    private Integer tokensUsed;
    @TableField("message_count")
    private Integer messageCount;
    @TableField("status")
    private Integer status;
    @TableField(value = "created_at", fill = FieldFill.INSERT)
    private LocalDateTime createdAt;
    @TableField(value = "updated_at", fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updatedAt;
    @TableLogic
    @TableField("deleted")
    private Integer deleted;
}

Message 实体(kb-ai/.../entity/Message.java):

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@TableName("message")
public class Message {
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;
    @TableField("conversation_id")
    private Long conversationId;
    @TableField("role")
    private String role;       // user / assistant
    @TableField("content")
    private String content;
    @TableField("tokens")
    private Integer tokens;
    @TableField(value = "created_at", fill = FieldFill.INSERT)
    private LocalDateTime createdAt;
    @TableLogic
    @TableField("deleted")
    private Integer deleted;
}

六、测试

按顺序启动下面这些微服务:

kb-auth-user

kb-ai

kb-gateway

启动前端

cd knowledge-base-frontend

npm run dev

浏览器访问AI对话页面:

http://localhost:3002/ai

图片.png

输入问题:@Import注解有什么用途?

它会流式输出内容,响应速度还是比较快的。

image

再问一下带记忆的上下文关联的问题:

image

也可以回答上了。

总结

本文详细介绍了 AI 对话流式输出和记忆功能的完整改造方案,涵盖了以下核心内容:

改造清单

改造项实现方式说明
流式模型OpenAiStreamingChatModelLangChain4j 流式接口,与阻塞式共用参数
SSE 推送SseEmitter + StreamingResponseHandlerSpring MVC 原生 SSE 支持
异步执行CompletableFuture.runAsync避免阻塞 Tomcat 线程
前端解析fetch + ReadableStream逐行解析 SSE 事件流
Token 批处理createBatchedCallback(80ms)减少 Zustand 更新频率
滚动优化behavior: 'auto'流式期间瞬时滚动
对话记忆buildChatHistory()MySQL 最近 20 条消息
记忆持久化Message 表每次对话自动存储
RAG 流式RagChatServiceImpl.chatWithContextStream知识库路径同步流式化

技术要点

  1. 流式模型与阻塞式模型用同一套 API 参数:buildStreamingModel 与 buildModel 参数完全一致,仅类型不同
  2. SSE 三大事件:message(token 推送)、done(完成通知)、error(错误通知)
  3. 前端 SSE 解析:逐行读取 ReadableStream,按 event: / data: / 空行 三种行类型分别处理
  4. 批处理优化:80ms 窗口批量输出 tokens,平衡实时性与性能
  5. 记忆窗口:LIMIT 20 + orderByDesc + reverse,取出最近 20 条并按时间正序排列
  6. 优雅降级:RAG 异常时自动回退到普通流式对话

通过本文的学习,你应该能够掌握:

  • LangChain4j StreamingChatLanguageModel 的使用方法和 StreamingResponseHandler 回调机制
  • Spring MVC SseEmitter 实现 SSE 服务器推送的完整流程
  • 前端 ReadableStream API 解析 SSE 事件流的技术细节
  • 通过 MySQL 消息表实现 AI 对话记忆功能的架构设计
  • Token 批处理、滚动优化等前端性能调优技巧

祝你开发顺利!

最后修改:2026 年 10 月 24 日
如果觉得我的文章对你有用,请随意赞赏