@lobehub/chat 1.121.1 → 1.122.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 1.122.0](https://github.com/lobehub/lobe-chat/compare/v1.121.1...v1.122.0)
+
+<sup>Released on **2025-09-04**</sup>
+
+#### ✨ Features
+
+- **misc**: Refactor to speed up send message in server mode.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Refactor to speed up send message in server mode, closes [#9046](https://github.com/lobehub/lobe-chat/issues/9046) ([4813b6d](https://github.com/lobehub/lobe-chat/commit/4813b6d))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.121.1](https://github.com/lobehub/lobe-chat/compare/v1.121.0...v1.121.1)
 
 <sup>Released on **2025-09-03**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "features": [
+        "Refactor to speed up send message in server mode."
+      ]
+    },
+    "date": "2025-09-04",
+    "version": "1.122.0"
+  },
   {
     "children": {
       "fixes": [

package/next.config.ts

@@ -38,6 +38,7 @@ const nextConfig: NextConfig = {
     // refs: https://github.com/lobehub/lobe-chat/pull/7430
     serverMinification: false,
     webVitalsAttribution: ['CLS', 'LCP'],
+    webpackMemoryOptimizations: true,
   },
   async headers() {
     const securityHeaders = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.121.1",
+  "version": "1.122.0",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/const/src/index.ts

@@ -3,6 +3,7 @@ export * from './branding';
 export * from './currency';
 export * from './layoutTokens';
 export * from './message';
+export * from './session';
 export * from './settings';
 export * from './user';
 export * from './version';

package/packages/const/src/session.ts

@@ -1,7 +1,7 @@
-import { DEFAULT_AGENT_META, DEFAULT_INBOX_AVATAR } from '@/const/meta';
-import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
-import { LobeAgentSession, LobeSessionType } from '@/types/session';
-import { merge } from '@/utils/merge';
+import { LobeAgentSession, LobeSessionType } from '@lobechat/types';
+
+import { DEFAULT_AGENT_META } from './meta';
+import { DEFAULT_AGENT_CONFIG } from './settings';
 
 export const INBOX_SESSION_ID = 'inbox';
 
@@ -16,10 +16,3 @@ export const DEFAULT_AGENT_LOBE_SESSION: LobeAgentSession = {
   type: LobeSessionType.Agent,
   updatedAt: new Date(),
 };
-
-export const DEFAULT_INBOX_SESSION: LobeAgentSession = merge(DEFAULT_AGENT_LOBE_SESSION, {
-  id: 'inbox',
-  meta: {
-    avatar: DEFAULT_INBOX_AVATAR,
-  },
-});

package/packages/database/src/models/__tests__/message.test.ts

@@ -2112,6 +2112,47 @@ describe('MessageModel', () => {
     });
   });
 
+  describe('updateMessageRAG', () => {
+    it('should insert message query chunks for RAG', async () => {
+      // prepare message and query
+      const messageId = 'rag-msg-1';
+      const queryId = uuid();
+      const chunk1 = uuid();
+      const chunk2 = uuid();
+
+      await serverDB.transaction(async (trx) => {
+        await trx.insert(messages).values({ id: messageId, role: 'user', userId, content: 'c' });
+        await trx.insert(chunks).values([
+          { id: chunk1, text: 'a' },
+          { id: chunk2, text: 'b' },
+        ]);
+        await trx
+          .insert(messageQueries)
+          .values({ id: queryId, messageId, userId, userQuery: 'q', rewriteQuery: 'rq' });
+      });
+
+      await messageModel.updateMessageRAG(messageId, {
+        ragQueryId: queryId,
+        fileChunks: [
+          { id: chunk1, similarity: 0.9 },
+          { id: chunk2, similarity: 0.8 },
+        ],
+      });
+
+      const rows = await serverDB
+        .select()
+        .from(messageQueryChunks)
+        .where(eq(messageQueryChunks.messageId, messageId));
+
+      expect(rows).toHaveLength(2);
+      const s1 = rows.find((r) => r.chunkId === chunk1)!;
+      const s2 = rows.find((r) => r.chunkId === chunk2)!;
+      expect(s1.queryId).toBe(queryId);
+      expect(s1.similarity).toBe('0.90000');
+      expect(s2.similarity).toBe('0.80000');
+    });
+  });
+
   describe('deleteMessageQuery', () => {
     it('should delete a message query by ID', async () => {
       // 创建测试数据

package/packages/database/src/models/message.ts

@@ -1,15 +1,3 @@
-import type { HeatmapsProps } from '@lobehub/charts';
-import dayjs from 'dayjs';
-import { and, asc, count, desc, eq, gt, inArray, isNotNull, isNull, like, sql } from 'drizzle-orm';
-
-import { LobeChatDatabase } from '../type';
-import {
-  genEndDateWhere,
-  genRangeWhere,
-  genStartDateWhere,
-  genWhere,
-} from '../utils/genWhere';
-import { idGenerator } from '../utils/idGenerator';
 import {
   ChatFileItem,
   ChatImageItem,
@@ -22,7 +10,12 @@ import {
   ModelRankItem,
   NewMessageQueryParams,
   UpdateMessageParams,
-} from '@/types/message';
+  UpdateMessageRAGParams,
+} from '@lobechat/types';
+import type { HeatmapsProps } from '@lobehub/charts';
+import dayjs from 'dayjs';
+import { and, asc, count, desc, eq, gt, inArray, isNotNull, isNull, like, sql } from 'drizzle-orm';
+
 import { merge } from '@/utils/merge';
 import { today } from '@/utils/time';
 
@@ -41,6 +34,9 @@ import {
   messages,
   messagesFiles,
 } from '../schemas';
+import { LobeChatDatabase } from '../type';
+import { genEndDateWhere, genRangeWhere, genStartDateWhere, genWhere } from '../utils/genWhere';
+import { idGenerator } from '../utils/idGenerator';
 
 export interface QueryMessageParams {
   current?: number;
@@ -614,6 +610,18 @@ export class MessageModel {
       .where(eq(messageTTS.id, id));
   };
 
+  async updateMessageRAG(id: string, { ragQueryId, fileChunks }: UpdateMessageRAGParams) {
+    return this.db.insert(messageQueryChunks).values(
+      fileChunks.map((chunk) => ({
+        chunkId: chunk.id,
+        messageId: id,
+        queryId: ragQueryId,
+        similarity: chunk.similarity?.toString(),
+        userId: this.userId,
+      })),
+    );
+  }
+
   // **************** Delete *************** //
 
   deleteMessage = async (id: string) => {

package/packages/database/src/models/topic.ts

@@ -1,23 +1,18 @@
 import { and, count, desc, eq, gt, ilike, inArray, isNull, sql } from 'drizzle-orm';
 
-import { LobeChatDatabase } from '../type';
-import {
-  genEndDateWhere,
-  genRangeWhere,
-  genStartDateWhere,
-  genWhere,
-} from '../utils/genWhere';
-import { idGenerator } from '../utils/idGenerator';
 import { MessageItem } from '@/types/message';
 import { TopicRankItem } from '@/types/topic';
 
 import { TopicItem, messages, topics } from '../schemas';
+import { LobeChatDatabase } from '../type';
+import { genEndDateWhere, genRangeWhere, genStartDateWhere, genWhere } from '../utils/genWhere';
+import { idGenerator } from '../utils/idGenerator';
 
 export interface CreateTopicParams {
   favorite?: boolean;
   messages?: string[];
   sessionId?: string | null;
-  title: string;
+  title?: string;
 }
 
 interface QueryTopicParams {

package/packages/types/src/aiChat.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+
+import { ChatMessage } from './message';
+import { ChatTopic } from './topic';
+
+export interface SendNewMessage {
+  content: string;
+  // if message has attached with files, then add files to message and the agent
+  files?: string[];
+}
+
+export interface SendMessageServerParams {
+  newAssistantMessage: {
+    model: string;
+    provider: string;
+  };
+  newTopic?: {
+    title?: string;
+    topicMessageIds?: string[];
+  };
+  newUserMessage: SendNewMessage;
+  sessionId?: string;
+  threadId?: string;
+  // if there is activeTopicId，then add topicId to message
+  topicId?: string;
+}
+
+export const AiSendMessageServerSchema = z.object({
+  newAssistantMessage: z.object({
+    model: z.string().optional(),
+    provider: z.string().optional(),
+  }),
+  newTopic: z
+    .object({
+      title: z.string().optional(),
+      topicMessageIds: z.array(z.string()).optional(),
+    })
+    .optional(),
+  newUserMessage: z.object({
+    content: z.string(),
+    files: z.array(z.string()).optional(),
+  }),
+  sessionId: z.string().optional(),
+  threadId: z.string().optional(),
+  topicId: z.string().optional(),
+});
+
+export interface SendMessageServerResponse {
+  assistantMessageId: string;
+  isCreatNewTopic: boolean;
+  messages: ChatMessage[];
+  topicId: string;
+  topics?: ChatTopic[];
+  userMessageId: string;
+}

package/packages/types/src/index.ts

@@ -1,4 +1,5 @@
 export * from './agent';
+export * from './aiChat';
 export * from './aiProvider';
 export * from './artifact';
 export * from './asyncTask';
@@ -11,7 +12,10 @@ export * from './knowledgeBase';
 export * from './llm';
 export * from './message';
 export * from './meta';
+export * from './rag';
 export * from './serverConfig';
+export * from './session';
+export * from './topic';
 export * from './user';
 export * from './user/settings';
 // FIXME: I think we need a refactor for the "openai" types

package/packages/types/src/message/base.ts

@@ -1,7 +1,20 @@
-import { ChatMessageError } from '@/types/message/chat';
-import { ChatImageItem } from '@/types/message/image';
-import { ChatToolPayload, MessageToolCall } from '@/types/message/tools';
-import { GroundingSearch } from '@/types/search';
+import { IPluginErrorType } from '@lobehub/chat-plugin-sdk';
+
+import { ILobeAgentRuntimeErrorType } from '@/libs/model-runtime';
+
+import { ErrorType } from '../fetch';
+import { GroundingSearch } from '../search';
+import { ChatImageItem } from './image';
+import { ChatToolPayload, MessageToolCall } from './tools';
+
+/**
+ * 聊天消息错误对象
+ */
+export interface ChatMessageError {
+  body?: any;
+  message: string;
+  type: ErrorType | IPluginErrorType | ILobeAgentRuntimeErrorType;
+}
 
 export interface CitationItem {
   id?: string;

package/packages/types/src/message/chat.ts

@@ -1,25 +1,11 @@
-import { IPluginErrorType } from '@lobehub/chat-plugin-sdk';
-
-import { ILobeAgentRuntimeErrorType } from '@/libs/model-runtime';
-
-import { ErrorType } from '../fetch';
 import { MetaData } from '../meta';
 import { MessageSemanticSearchChunk } from '../rag';
 import { GroundingSearch } from '../search';
-import { MessageMetadata, MessageRoleType, ModelReasoning } from './base';
+import type { ChatMessageError, MessageMetadata, MessageRoleType, ModelReasoning } from './base';
 import { ChatImageItem } from './image';
 import { ChatPluginPayload, ChatToolPayload } from './tools';
 import { Translate } from './translate';
 
-/**
- * 聊天消息错误对象
- */
-export interface ChatMessageError {
-  body?: any;
-  message: string;
-  type: ErrorType | IPluginErrorType | ILobeAgentRuntimeErrorType;
-}
-
 export interface ChatTranslate extends Translate {
   content?: string;
 }

package/packages/types/src/message/index.ts

@@ -3,6 +3,7 @@ import { UploadFileItem } from '../files';
 export * from './base';
 export * from './chat';
 export * from './image';
+export * from './rag';
 export * from './tools';
 
 export interface SendMessageParams {

package/packages/types/src/message/rag.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+import { MessageSemanticSearchChunk } from '../rag';
+
+export const SemanticSearchChunkSchema = z.object({
+  id: z.string(),
+  similarity: z.number(),
+});
+
+export interface UpdateMessageRAGParams {
+  fileChunks: MessageSemanticSearchChunk[];
+  ragQueryId?: string;
+}
+
+export const UpdateMessageRAGParamsSchema = z.object({
+  id: z.string(),
+  value: z.object({
+    fileChunks: z.array(SemanticSearchChunkSchema),
+    ragQueryId: z.string().optional(),
+  }),
+});

package/packages/utils/src/index.ts

@@ -2,6 +2,7 @@ export * from './client/cookie';
 export * from './detectChinese';
 export * from './format';
 export * from './imageToBase64';
+export * from './object';
 export * from './parseModels';
 export * from './pricing';
 export * from './safeParseJSON';

package/packages/utils/src/object.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+
+import { cleanObject } from './object';
+
+describe('cleanObject', () => {
+  it('should remove null, undefined and empty string fields', () => {
+    const input = { a: 1, b: null, c: undefined, d: '', e: 0, f: false } as const;
+    const res = cleanObject({ ...input });
+    expect(res).toEqual({ a: 1, e: 0, f: false });
+  });
+});

package/src/server/routers/lambda/__tests__/message.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, it, vi } from 'vitest';
 import { MessageModel } from '@/database/models/message';
 import { FileService } from '@/server/services/file';
 import { ChatMessage, CreateMessageParams } from '@/types/message';
+import { UpdateMessageRAGParams } from '@/types/message/rag';
 
 vi.mock('@/database/models/message', () => ({
   MessageModel: vi.fn(),
@@ -210,4 +211,33 @@ describe('messageRouter', () => {
     expect(mockUpdate).toHaveBeenCalledWith(input.id, input.value);
     expect(result).toEqual({ success: true });
   });
+
+  it('should handle updateMessageRAG', async () => {
+    const mockUpdateRAG = vi.fn().mockResolvedValue(undefined);
+    vi.mocked(MessageModel).mockImplementation(
+      () =>
+        ({
+          updateMessageRAG: mockUpdateRAG,
+        }) as any,
+    );
+
+    const input = {
+      id: 'msg1',
+      value: { ragQueryId: 'q1', fileChunks: [{ id: 'c1', similarity: 0.9 }] },
+    } as {
+      id: string;
+      value: UpdateMessageRAGParams;
+    };
+
+    const ctx = {
+      messageModel: new MessageModel({} as any, 'user1'),
+    };
+
+    await ctx.messageModel.updateMessageRAG(input.id, input.value);
+
+    expect(mockUpdateRAG).toHaveBeenCalledWith('msg1', {
+      ragQueryId: 'q1',
+      fileChunks: [{ id: 'c1', similarity: 0.9 }],
+    });
+  });
 });

package/src/server/routers/lambda/aiChat.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { MessageModel } from '@/database/models/message';
+import { TopicModel } from '@/database/models/topic';
+import { AiChatService } from '@/server/services/aiChat';
+
+import { aiChatRouter } from './aiChat';
+
+vi.mock('@/database/models/message');
+vi.mock('@/database/models/topic');
+vi.mock('@/server/services/aiChat');
+vi.mock('@/server/services/file', () => ({
+  FileService: vi.fn(),
+}));
+
+describe('aiChatRouter', () => {
+  const mockCtx = { userId: 'u1' };
+
+  it('should create topic optionally, create user/assistant messages, and return payload', async () => {
+    const mockCreateTopic = vi.fn().mockResolvedValue({ id: 't1' });
+    const mockCreateMessage = vi
+      .fn()
+      .mockResolvedValueOnce({ id: 'm-user' })
+      .mockResolvedValueOnce({ id: 'm-assistant' });
+    const mockGet = vi
+      .fn()
+      .mockResolvedValue({ messages: [{ id: 'm-user' }, { id: 'm-assistant' }], topics: [{}] });
+
+    vi.mocked(TopicModel).mockImplementation(() => ({ create: mockCreateTopic }) as any);
+    vi.mocked(MessageModel).mockImplementation(() => ({ create: mockCreateMessage }) as any);
+    vi.mocked(AiChatService).mockImplementation(() => ({ getMessagesAndTopics: mockGet }) as any);
+
+    const caller = aiChatRouter.createCaller(mockCtx as any);
+
+    const input = {
+      newAssistantMessage: { model: 'gpt-4o', provider: 'openai' },
+      newTopic: { title: 'T', topicMessageIds: ['a', 'b'] },
+      newUserMessage: { content: 'hi', files: ['f1'] },
+      sessionId: 's1',
+    } as any;
+
+    const res = await caller.sendMessageInServer(input);
+
+    expect(mockCreateTopic).toHaveBeenCalledWith({
+      messages: ['a', 'b'],
+      sessionId: 's1',
+      title: 'T',
+    });
+
+    expect(mockCreateMessage).toHaveBeenNthCalledWith(1, {
+      content: 'hi',
+      files: ['f1'],
+      role: 'user',
+      sessionId: 's1',
+      topicId: 't1',
+    });
+
+    expect(mockCreateMessage).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        content: expect.any(String),
+        fromModel: 'gpt-4o',
+        parentId: 'm-user',
+        role: 'assistant',
+        sessionId: 's1',
+        topicId: 't1',
+      }),
+    );
+
+    expect(mockGet).toHaveBeenCalledWith({ includeTopic: true, sessionId: 's1', topicId: 't1' });
+    expect(res.assistantMessageId).toBe('m-assistant');
+    expect(res.userMessageId).toBe('m-user');
+    expect(res.isCreatNewTopic).toBe(true);
+    expect(res.topicId).toBe('t1');
+    expect(res.messages?.length).toBe(2);
+    expect(res.topics?.length).toBe(1);
+  });
+
+  it('should reuse existing topic when topicId provided', async () => {
+    const mockCreateMessage = vi
+      .fn()
+      .mockResolvedValueOnce({ id: 'm-user' })
+      .mockResolvedValueOnce({ id: 'm-assistant' });
+    const mockGet = vi.fn().mockResolvedValue({ messages: [], topics: undefined });
+
+    vi.mocked(MessageModel).mockImplementation(() => ({ create: mockCreateMessage }) as any);
+    vi.mocked(AiChatService).mockImplementation(() => ({ getMessagesAndTopics: mockGet }) as any);
+
+    const caller = aiChatRouter.createCaller(mockCtx as any);
+
+    const res = await caller.sendMessageInServer({
+      newAssistantMessage: { model: 'gpt-4o', provider: 'openai' },
+      newUserMessage: { content: 'hi' },
+      sessionId: 's1',
+      topicId: 't-exist',
+    } as any);
+
+    expect(mockCreateMessage).toHaveBeenCalled();
+    expect(mockGet).toHaveBeenCalledWith({
+      includeTopic: false,
+      sessionId: 's1',
+      topicId: 't-exist',
+    });
+    expect(res.isCreatNewTopic).toBe(false);
+    expect(res.topicId).toBe('t-exist');
+  });
+});

package/src/server/routers/lambda/aiChat.ts

@@ -0,0 +1,80 @@
+import { AiSendMessageServerSchema, SendMessageServerResponse } from '@lobechat/types';
+
+import { LOADING_FLAT } from '@/const/message';
+import { MessageModel } from '@/database/models/message';
+import { TopicModel } from '@/database/models/topic';
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { serverDatabase } from '@/libs/trpc/lambda/middleware';
+import { AiChatService } from '@/server/services/aiChat';
+import { FileService } from '@/server/services/file';
+
+const aiChatProcedure = authedProcedure.use(serverDatabase).use(async (opts) => {
+  const { ctx } = opts;
+
+  return opts.next({
+    ctx: {
+      aiChatService: new AiChatService(ctx.serverDB, ctx.userId),
+      fileService: new FileService(ctx.serverDB, ctx.userId),
+      messageModel: new MessageModel(ctx.serverDB, ctx.userId),
+      topicModel: new TopicModel(ctx.serverDB, ctx.userId),
+    },
+  });
+});
+
+export const aiChatRouter = router({
+  sendMessageInServer: aiChatProcedure
+    .input(AiSendMessageServerSchema)
+    .mutation(async ({ input, ctx }) => {
+      let messageId: string;
+      let topicId = input.topicId!;
+
+      let isCreatNewTopic = false;
+
+      // create topic if there should be a new topic
+      if (input.newTopic) {
+        const topicItem = await ctx.topicModel.create({
+          messages: input.newTopic.topicMessageIds,
+          sessionId: input.sessionId,
+          title: input.newTopic.title,
+        });
+        topicId = topicItem.id;
+        isCreatNewTopic = true;
+      }
+
+      // create user message
+      const userMessageItem = await ctx.messageModel.create({
+        content: input.newUserMessage.content,
+        files: input.newUserMessage.files,
+        role: 'user',
+        sessionId: input.sessionId!,
+        topicId,
+      });
+
+      messageId = userMessageItem.id;
+      // create assistant message
+      const assistantMessageItem = await ctx.messageModel.create({
+        content: LOADING_FLAT,
+        fromModel: input.newAssistantMessage.model,
+        parentId: messageId,
+        role: 'assistant',
+        sessionId: input.sessionId!,
+        topicId,
+      });
+
+      // retrieve latest messages and topic with
+      const { messages, topics } = await ctx.aiChatService.getMessagesAndTopics({
+        includeTopic: isCreatNewTopic,
+        sessionId: input.sessionId,
+        topicId,
+      });
+
+      return {
+        assistantMessageId: assistantMessageItem.id,
+        isCreatNewTopic,
+        messages,
+        topicId,
+        topics,
+        userMessageId: messageId,
+      } as SendMessageServerResponse;
+    }),
+});

package/src/server/routers/lambda/index.ts

@@ -4,6 +4,7 @@
 import { publicProcedure, router } from '@/libs/trpc/lambda';
 
 import { agentRouter } from './agent';
+import { aiChatRouter } from './aiChat';
 import { aiModelRouter } from './aiModel';
 import { aiProviderRouter } from './aiProvider';
 import { apiKeyRouter } from './apiKey';
@@ -30,6 +31,7 @@ import { userRouter } from './user';
 
 export const lambdaRouter = router({
   agent: agentRouter,
+  aiChat: aiChatRouter,
   aiModel: aiModelRouter,
   aiProvider: aiProviderRouter,
   apiKey: apiKeyRouter,