RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
import { FilterCollection } from '@/components/list-filter-bar/interface';
import { useHandleFilterSubmit } from '@/components/list-filter-bar/use-handle-filter-submit';
import message from '@/components/ui/message';
import { useHandleSearchChange } from '@/hooks/logic-hooks';
import memoryService, { getMemoryDetailById } from '@/services/memory-service';
import { groupListByType } from '@/utils/list-filter-util';
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { t } from 'i18next';
import { useCallback, useMemo, useState } from 'react';
import { useParams, useSearchParams } from 'react-router';
import { MemoryApiAction } from '../constant';
import {
IMessageContentProps,
IMessageTableProps,
} from '../memory-message/interface';
import { IMessageInfo } from './interface';
export const useFetchMemoryMessageList = () => {
const { id } = useParams();
const [searchParams] = useSearchParams();
const memoryBaseId = searchParams.get('id') || id;
const { handleInputChange, searchString, pagination, setPagination } =
useHandleSearchChange();
const { filterValue, handleFilterSubmit } = useHandleFilterSubmit();
const queryKey: (MemoryApiAction | number)[] = [
MemoryApiAction.FetchMemoryMessage,
];
const agentIds = Array.isArray(filterValue.agentId)
? filterValue.agentId
: [];
const { data, isFetching: loading } = useQuery<IMessageTableProps>({
queryKey: [...queryKey, searchString, pagination, filterValue],
initialData: {} as IMessageTableProps,
gcTime: 0,
queryFn: async () => {
if (memoryBaseId) {
const { data } = await getMemoryDetailById(memoryBaseId as string, {
keywords: searchString,
page: pagination.current,
page_size: pagination.pageSize,
agentId: agentIds.length > 0 ? agentIds.join(',') : undefined,
});
return data?.data ?? {};
} else {
return {};
}
},
});
return {
data,
loading,
handleInputChange,
searchString,
pagination,
setPagination,
filterValue,
handleFilterSubmit,
};
};
export const useMessageAction = () => {
const queryClient = useQueryClient();
const { id: memoryId } = useParams();
const [selectedMessage, setSelectedMessage] = useState<IMessageInfo>(
{} as IMessageInfo,
);
const [showDeleteDialog, setShowDeleteDialog] = useState(false);
const handleClickDeleteMessage = useCallback((message: IMessageInfo) => {
setSelectedMessage(message);
setShowDeleteDialog(true);
}, []);
const handleDeleteMessage = useCallback(() => {
// delete message
memoryService
.deleteMemoryMessage({
memory_id: memoryId,
message_id: selectedMessage.message_id,
})
.then((data: any) => {
if (data.data.code === 0) {
message.success(t('message.deleted'));
queryClient.invalidateQueries({
queryKey: [MemoryApiAction.FetchMemoryMessage],
});
}
});
setShowDeleteDialog(false);
}, [selectedMessage.message_id, queryClient, memoryId]);
const handleUpdateMessageState = useCallback(
async (messageInfo: IMessageInfo, enable: boolean): Promise<boolean> => {
try {
const { data } = await memoryService.updateMessageState({
memory_id: memoryId,
message_id: messageInfo.message_id,
status: enable || false,
});
if (data.code === 0) {
message.success(t('message.updated'));
queryClient.invalidateQueries({
queryKey: [MemoryApiAction.FetchMemoryMessage],
});
return true;
}
return false;
} catch {
return false;
}
},
[queryClient, memoryId],
);
const handleClickUpdateMessageState = useCallback(
(messageInfo: IMessageInfo, enable: boolean): Promise<boolean> => {
setSelectedMessage(messageInfo);
return handleUpdateMessageState(messageInfo, enable);
},
[handleUpdateMessageState],
);
const [showMessageContentDialog, setShowMessageContentDialog] =
useState(false);
const [selectedMessageContent, setSelectedMessageContent] =
useState<IMessageContentProps>({} as IMessageContentProps);
const {
data: messageContent,
isPending: fetchMessageContentLoading,
mutateAsync: fetchMessageContent,
} = useMutation<IMessageContentProps, Error, IMessageInfo>({
mutationKey: [
MemoryApiAction.FetchMessageContent,
selectedMessage.message_id,
],
mutationFn: async (selectedMessage: IMessageInfo) => {
setShowMessageContentDialog(true);
const res = await memoryService.getMessageContent({
memory_id: memoryId,
message_id: selectedMessage.message_id,
});
if (res.data.code === 0) {
setSelectedMessageContent(res.data.data);
} else {
message.error(res.data.message);
}
return res.data.data;
},
});
const handleClickMessageContentDialog = useCallback(
(message: IMessageInfo) => {
setSelectedMessage(message);
fetchMessageContent(message);
},
[fetchMessageContent],
);
return {
selectedMessage,
setSelectedMessage,
showDeleteDialog,
setShowDeleteDialog,
handleClickDeleteMessage,
handleDeleteMessage,
handleUpdateMessageState,
messageContent,
fetchMessageContentLoading,
fetchMessageContent,
selectedMessageContent,
showMessageContentDialog,
setShowMessageContentDialog,
handleClickMessageContentDialog,
handleClickUpdateMessageState,
};
};
export function useSelectFilters() {
const { data } = useFetchMemoryMessageList();
const agentId = useMemo(() => {
return groupListByType(
data?.messages?.message_list ?? [],
'agent_id',
'agent_name',
);
}, [data?.messages?.message_list]);
const filters: FilterCollection[] = [
{
field: 'agentId',
list: agentId,
label: 'Agent',
},
];
return { filters };
}