@lobehub/chat 1.15.6 → 1.15.8

package/src/store/file/slices/upload/action.ts

@@ -106,12 +106,14 @@ export const createFileUploadSlice: StateCreator<
       });
     } else {
       // 2. if file don't exist, need upload files
-      metadata = await uploadService.uploadWithProgress(file, (status, upload) => {
-        onStatusUpdate?.({
-          id: file.name,
-          type: 'updateFile',
-          value: { status: status === 'success' ? 'processing' : status, uploadState: upload },
-        });
+      metadata = await uploadService.uploadWithProgress(file, {
+        onProgress: (status, upload) => {
+          onStatusUpdate?.({
+            id: file.name,
+            type: 'updateFile',
+            value: { status: status === 'success' ? 'processing' : status, uploadState: upload },
+          });
+        },
       });
     }
 

package/src/store/knowledgeBase/initialState.ts

@@ -1,7 +1,9 @@
 import { KnowledgeBaseState, initialKnowledgeBaseState } from '../knowledgeBase/slices/crud';
+import { RAGEvalState, initialDatasetState } from '../knowledgeBase/slices/ragEval';
 
-export type KnowledgeBaseStoreState = KnowledgeBaseState;
+export type KnowledgeBaseStoreState = KnowledgeBaseState & RAGEvalState;
 
 export const initialState: KnowledgeBaseStoreState = {
   ...initialKnowledgeBaseState,
+  ...initialDatasetState,
 };

package/src/store/knowledgeBase/slices/ragEval/actions/dataset.ts

@@ -0,0 +1,88 @@
+import { SWRResponse, mutate } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { notification } from '@/components/AntdStaticMethods';
+import { useClientDataSWR } from '@/libs/swr';
+import { ragEvalService } from '@/services/ragEval';
+import { KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+import {
+  CreateNewEvalDatasets,
+  EvalDatasetRecord,
+  RAGEvalDataSetItem,
+  insertEvalDatasetRecordSchema,
+} from '@/types/eval';
+
+const FETCH_DATASET_LIST_KEY = 'FETCH_DATASET_LIST';
+const FETCH_DATASET_RECORD_KEY = 'FETCH_DATASET_RECORD_KEY';
+
+export interface RAGEvalDatasetAction {
+  createNewDataset: (params: CreateNewEvalDatasets) => Promise<void>;
+
+  importDataset: (file: File, datasetId: number) => Promise<void>;
+  refreshDatasetList: () => Promise<void>;
+  removeDataset: (id: number) => Promise<void>;
+  useFetchDatasetRecords: (datasetId: number | null) => SWRResponse<EvalDatasetRecord[]>;
+  useFetchDatasets: (knowledgeBaseId: string) => SWRResponse<RAGEvalDataSetItem[]>;
+}
+
+export const createRagEvalDatasetSlice: StateCreator<
+  KnowledgeBaseStore,
+  [['zustand/devtools', never]],
+  [],
+  RAGEvalDatasetAction
+> = (set, get) => ({
+  createNewDataset: async (params) => {
+    await ragEvalService.createDataset(params);
+    await get().refreshDatasetList();
+  },
+
+  importDataset: async (file, datasetId) => {
+    if (!datasetId) return;
+    const fileType = file.name.split('.').pop();
+
+    if (fileType === 'jsonl') {
+      // jsonl 文件 需要拆分成单个条，然后逐一校验格式
+      const jsonl = await file.text();
+      const { default: JSONL } = await import('jsonl-parse-stringify');
+
+      try {
+        const items = JSONL.parse(jsonl);
+
+        // check if the items are valid
+        insertEvalDatasetRecordSchema.array().parse(items);
+
+        // if valid, send to backend
+        await ragEvalService.importDatasetRecords(datasetId, file);
+      } catch (e) {
+        notification.error({ description: (e as Error).message, message: '文件格式错误' });
+      }
+    }
+
+    await get().refreshDatasetList();
+  },
+  refreshDatasetList: async () => {
+    await mutate(FETCH_DATASET_LIST_KEY);
+  },
+
+  removeDataset: async (id) => {
+    await ragEvalService.removeDataset(id);
+    await get().refreshDatasetList();
+  },
+  useFetchDatasetRecords: (datasetId) =>
+    useClientDataSWR<EvalDatasetRecord[]>(
+      !!datasetId ? [FETCH_DATASET_RECORD_KEY, datasetId] : null,
+      () => ragEvalService.getDatasetRecords(datasetId!),
+    ),
+  useFetchDatasets: (knowledgeBaseId) =>
+    useClientDataSWR<RAGEvalDataSetItem[]>(
+      [FETCH_DATASET_LIST_KEY, knowledgeBaseId],
+      () => ragEvalService.getDatasets(knowledgeBaseId),
+      {
+        fallbackData: [],
+        onSuccess: () => {
+          if (!get().initDatasetList)
+            set({ initDatasetList: true }, false, 'useFetchDatasets/init');
+        },
+      },
+    ),
+});

package/src/store/knowledgeBase/slices/ragEval/actions/evaluation.ts

@@ -0,0 +1,62 @@
+import { SWRResponse, mutate } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { useClientDataSWR } from '@/libs/swr';
+import { ragEvalService } from '@/services/ragEval';
+import { KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+import { CreateNewEvalEvaluation, RAGEvalDataSetItem } from '@/types/eval';
+
+const FETCH_EVALUATION_LIST_KEY = 'FETCH_EVALUATION_LIST_KEY';
+
+export interface RAGEvalEvaluationAction {
+  checkEvaluationStatus: (id: number) => Promise<void>;
+
+  createNewEvaluation: (params: CreateNewEvalEvaluation) => Promise<void>;
+  refreshEvaluationList: () => Promise<void>;
+
+  removeEvaluation: (id: number) => Promise<void>;
+  runEvaluation: (id: number) => Promise<void>;
+
+  useFetchEvaluationList: (knowledgeBaseId: string) => SWRResponse<RAGEvalDataSetItem[]>;
+}
+
+export const createRagEvalEvaluationSlice: StateCreator<
+  KnowledgeBaseStore,
+  [['zustand/devtools', never]],
+  [],
+  RAGEvalEvaluationAction
+> = (set, get) => ({
+  checkEvaluationStatus: async (id) => {
+    await ragEvalService.checkEvaluationStatus(id);
+  },
+
+  createNewEvaluation: async (params) => {
+    await ragEvalService.createEvaluation(params);
+    await get().refreshEvaluationList();
+  },
+  refreshEvaluationList: async () => {
+    await mutate(FETCH_EVALUATION_LIST_KEY);
+  },
+
+  removeEvaluation: async (id) => {
+    await ragEvalService.removeEvaluation(id);
+    // await get().refreshEvaluationList();
+  },
+
+  runEvaluation: async (id) => {
+    await ragEvalService.startEvaluationTask(id);
+  },
+
+  useFetchEvaluationList: (knowledgeBaseId) =>
+    useClientDataSWR<RAGEvalDataSetItem[]>(
+      [FETCH_EVALUATION_LIST_KEY, knowledgeBaseId],
+      () => ragEvalService.getEvaluationList(knowledgeBaseId),
+      {
+        fallbackData: [],
+        onSuccess: () => {
+          if (!get().initDatasetList)
+            set({ initDatasetList: true }, false, 'useFetchDatasets/init');
+        },
+      },
+    ),
+});

package/src/store/knowledgeBase/slices/ragEval/actions/index.ts

@@ -0,0 +1,20 @@
+import { StateCreator } from 'zustand/vanilla';
+
+import { KnowledgeBaseStore } from '@/store/knowledgeBase/store';
+
+import { RAGEvalDatasetAction, createRagEvalDatasetSlice } from './dataset';
+import { RAGEvalEvaluationAction, createRagEvalEvaluationSlice } from './evaluation';
+
+export interface RAGEvalAction extends RAGEvalDatasetAction, RAGEvalEvaluationAction {
+  // empty
+}
+
+export const createRagEvalSlice: StateCreator<
+  KnowledgeBaseStore,
+  [['zustand/devtools', never]],
+  [],
+  RAGEvalAction
+> = (...params) => ({
+  ...createRagEvalDatasetSlice(...params),
+  ...createRagEvalEvaluationSlice(...params),
+});

package/src/store/knowledgeBase/slices/ragEval/index.ts

@@ -0,0 +1,2 @@
+export * from './actions';
+export * from './initialState';

package/src/store/knowledgeBase/slices/ragEval/initialState.ts

@@ -0,0 +1,7 @@
+export interface RAGEvalState {
+  initDatasetList: boolean;
+}
+
+export const initialDatasetState: RAGEvalState = {
+  initDatasetList: false,
+};

package/src/store/knowledgeBase/store.ts

@@ -6,12 +6,17 @@ import { createDevtools } from '../middleware/createDevtools';
 import { KnowledgeBaseStoreState, initialState } from './initialState';
 import { KnowledgeBaseContentAction, createContentSlice } from './slices/content';
 import { KnowledgeBaseCrudAction, createCrudSlice } from './slices/crud';
+import { RAGEvalAction, createRagEvalSlice } from './slices/ragEval';
 
 //  ===============  聚合 createStoreFn ============ //
 
-export type KnowledgeBaseStore = KnowledgeBaseStoreState &
-  KnowledgeBaseCrudAction &
-  KnowledgeBaseContentAction;
+export interface KnowledgeBaseStore
+  extends KnowledgeBaseStoreState,
+    KnowledgeBaseCrudAction,
+    KnowledgeBaseContentAction,
+    RAGEvalAction {
+  // empty
+}
 
 const createStore: StateCreator<KnowledgeBaseStore, [['zustand/devtools', never]]> = (
   ...parameters
@@ -19,6 +24,7 @@ const createStore: StateCreator<KnowledgeBaseStore, [['zustand/devtools', never]
   ...initialState,
   ...createCrudSlice(...parameters),
   ...createContentSlice(...parameters),
+  ...createRagEvalSlice(...parameters),
 });
 
 //  ===============  实装 useStore ============ //

package/src/store/serverConfig/selectors.test.ts

@@ -20,6 +20,7 @@ describe('featureFlagsSelectors', () => {
       enableWebrtc: false,
       isAgentEditable: false,
       showCreateSession: true,
+      enableRAGEval: false,
       showDalle: true,
       enableKnowledgeBase: true,
       showLLM: false,

package/src/types/eval/dataset.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+
+export interface EvalDatasetRecordRefFile {
+  fileType: string;
+  id: string;
+  name: string;
+}
+export interface EvalDatasetRecord {
+  createdAt: Date;
+  id: number;
+  ideal?: string | null;
+
+  metadata: any;
+
+  question?: string | null;
+
+  /**
+   * The reference files for the question
+   */
+  referenceFiles?: EvalDatasetRecordRefFile[] | null;
+}
+
+export const insertEvalDatasetRecordSchema = z.object({
+  ideal: z.string().optional(),
+
+  question: z.string(),
+
+  referenceFiles: z.string().or(z.array(z.string())).optional(),
+});
+
+export type InsertEvalDatasetRecord = z.infer<typeof insertEvalDatasetRecordSchema>;
+
+export interface RAGEvalDataSetItem {
+  createdAt: Date;
+  description?: string | null;
+  id: number;
+  name: string;
+  updatedAt: Date;
+}
+
+export const insertEvalDatasetsSchema = z.object({
+  description: z.string().optional(),
+  knowledgeBaseId: z.string(),
+  name: z.string(),
+});
+
+export type CreateNewEvalDatasets = z.infer<typeof insertEvalDatasetsSchema>;

package/src/types/eval/evaluation.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+
+export enum EvalEvaluationStatus {
+  Error = 'Error',
+  Pending = 'Pending',
+  Processing = 'Processing',
+  Success = 'Success',
+}
+
+export interface EvaluationRecord {
+  answer: string;
+  context: string[];
+  createdAt: Date;
+  id: number;
+  ideal: string;
+  question: string;
+}
+
+export const insertEvaluationSchema = z.object({
+  ideal: z.string().optional(),
+
+  question: z.string(),
+
+  referenceFiles: z.string().or(z.array(z.string())).optional(),
+});
+
+export type InsertEvaluationRecord = z.infer<typeof insertEvaluationSchema>;
+
+export interface RAGEvalEvaluationItem {
+  createdAt: Date;
+  dataset: {
+    id: number;
+    name: string;
+  };
+  evalRecordsUrl?: string;
+  id: number;
+  name: string;
+  recordsStats: {
+    success: number;
+    total: number;
+  };
+  status: EvalEvaluationStatus;
+  updatedAt: Date;
+}
+
+export const insertEvalEvaluationSchema = z.object({
+  datasetId: z.number(),
+  description: z.string().optional(),
+  knowledgeBaseId: z.string(),
+  name: z.string(),
+});
+
+export type CreateNewEvalEvaluation = z.infer<typeof insertEvalEvaluationSchema>;

package/src/types/eval/index.ts

@@ -0,0 +1,3 @@
+export * from './dataset';
+export * from './evaluation';
+export * from './ragas';

package/src/types/eval/ragas.ts

@@ -0,0 +1,9 @@
+/**
+ * The data set for the RAGAS benchmark
+ */
+export interface RAGASDataSetItem {
+  answer: string;
+  context: string;
+  ground_truth: string;
+  question: string;
+}