feat: implement knowledge move functionality

- Added API endpoints for moving knowledge items between knowledge bases, including validation for source and target compatibility.
- Implemented asynchronous task handling for knowledge moves, tracking progress and status updates.
- Introduced new localization strings for move-related UI elements in English, Korean, Russian, and Chinese.
- Enhanced the frontend to support knowledge move operations, including target selection and progress monitoring.

These changes significantly improve the application's capabilities for managing knowledge across different bases, providing users with a seamless experience in organizing their knowledge assets.
This commit is contained in:
wizardchen
2026-03-09 13:14:42 +08:00
committed by lyingbug
parent 33ccc41bea
commit 125d3e5e4a
16 changed files with 1015 additions and 5 deletions
+20
View File
@@ -45,6 +45,26 @@ export function copyKnowledgeBase(data: { source_id: string; target_id?: string
return post(`/api/v1/knowledge-bases/copy`, data);
}
// 获取可移动目标知识库列表(同类型、同Embedding模型)
export function listMoveTargets(sourceKbId: string) {
return get(`/api/v1/knowledge-bases/${sourceKbId}/move-targets`);
}
// 移动知识到其他知识库
export function moveKnowledge(data: {
knowledge_ids: string[];
source_kb_id: string;
target_kb_id: string;
mode: 'reuse_vectors' | 'reparse';
}) {
return post('/api/v1/knowledge/move', data);
}
// 获取知识移动进度
export function getKnowledgeMoveProgress(taskId: string) {
return get(`/api/v1/knowledge/move/progress/${taskId}`);
}
export function togglePinKnowledgeBase(id: string) {
return put(`/api/v1/knowledge-bases/${id}/pin`);
}
+16
View File
@@ -200,6 +200,22 @@ export default {
draftTip: 'Temporarily saved and not included in retrieval',
untitledDocument: 'Untitled Document',
deleteDocument: 'Delete Document',
moveDocument: 'Move to...',
moveToKnowledgeBase: 'Move to Knowledge Base',
moveSelectTarget: 'Select target knowledge base',
moveNoTargets: 'No compatible knowledge bases found (same type and embedding model required)',
moveMode: 'Move Mode',
moveModeReuseVectors: 'Reuse Vectors (Fast)',
moveModeReuseVectorsDesc: 'Directly move chunks and vector indices. Use when chunking config is the same.',
moveModeReparse: 'Re-parse',
moveModeReparseDesc: "Re-parse documents using the target knowledge base's chunking config.",
moveConfirm: 'Confirm Move',
moveConfirmTitle: 'Confirm move settings',
moveStarted: 'Move task submitted',
moveFailed: 'Move failed',
moveCompleted: 'Move completed',
moveCompletedWithErrors: 'Move completed: {success} succeeded, {failed} failed',
moveProgress: 'Moving...',
parsingFailed: 'Parsing failed',
parsingInProgress: 'Parsing...',
generatingSummary: 'Generating summary...',
+16
View File
@@ -203,6 +203,22 @@ export default {
draftTip: "임시 저장된 내용, 검색에 포함되지 않음",
untitledDocument: "제목 없는 문서",
deleteDocument: "문서 삭제",
moveDocument: "이동...",
moveToKnowledgeBase: "지식베이스로 이동",
moveSelectTarget: "대상 지식베이스 선택",
moveNoTargets: "호환되는 지식베이스가 없습니다 (동일한 유형과 임베딩 모델 필요)",
moveMode: "이동 모드",
moveModeReuseVectors: "벡터 재사용 (빠름)",
moveModeReuseVectorsDesc: "청크와 벡터 인덱스를 직접 이동합니다. 청킹 설정이 동일할 때 사용합니다.",
moveModeReparse: "재해석",
moveModeReparseDesc: "대상 지식베이스의 청킹 설정으로 문서를 다시 해석합니다.",
moveConfirm: "이동 확인",
moveConfirmTitle: "이동 설정 확인",
moveStarted: "이동 작업이 제출되었습니다",
moveFailed: "이동 실패",
moveCompleted: "이동 완료",
moveCompletedWithErrors: "이동 완료: {success}개 성공, {failed}개 실패",
moveProgress: "이동 중...",
parsingFailed: "파싱 실패",
parsingInProgress: "파싱 중...",
generatingSummary: "요약 생성 중...",
+16
View File
@@ -172,6 +172,22 @@ export default {
draftTip: 'Временно сохранён, не участвует в поиске',
untitledDocument: 'Документ без названия',
deleteDocument: 'Удалить документ',
moveDocument: 'Переместить в...',
moveToKnowledgeBase: 'Переместить в базу знаний',
moveSelectTarget: 'Выберите целевую базу знаний',
moveNoTargets: 'Совместимые базы знаний не найдены (требуется одинаковый тип и модель эмбеддинга)',
moveMode: 'Режим перемещения',
moveModeReuseVectors: 'Повторное использование векторов (быстро)',
moveModeReuseVectorsDesc: 'Прямое перемещение чанков и векторных индексов. Используйте при одинаковой конфигурации разбиения.',
moveModeReparse: 'Повторный парсинг',
moveModeReparseDesc: 'Повторный парсинг документов с конфигурацией разбиения целевой базы знаний.',
moveConfirm: 'Подтвердить перемещение',
moveConfirmTitle: 'Подтвердите настройки перемещения',
moveStarted: 'Задача перемещения отправлена',
moveFailed: 'Перемещение не удалось',
moveCompleted: 'Перемещение завершено',
moveCompletedWithErrors: 'Перемещение завершено: {success} успешно, {failed} не удалось',
moveProgress: 'Перемещение...',
parsingFailed: 'Парсинг не удался',
parsingInProgress: 'Парсинг...',
generatingSummary: 'Генерация резюме...',
+16
View File
@@ -200,6 +200,22 @@ export default {
draftTip: "暂存内容,未参与检索",
untitledDocument: "未命名文档",
deleteDocument: "删除文档",
moveDocument: "移动到...",
moveToKnowledgeBase: "移动到知识库",
moveSelectTarget: "选择目标知识库",
moveNoTargets: "没有兼容的目标知识库(需要相同类型和 Embedding 模型)",
moveMode: "移动模式",
moveModeReuseVectors: "复用向量(快速)",
moveModeReuseVectorsDesc: "直接移动分块和向量索引,适用于分片配置相同的情况",
moveModeReparse: "重新解析",
moveModeReparseDesc: "使用目标知识库的分片配置重新解析文档",
moveConfirm: "确认移动",
moveConfirmTitle: "确认移动设置",
moveStarted: "移动任务已提交",
moveFailed: "移动失败",
moveCompleted: "移动完成",
moveCompletedWithErrors: "移动完成:{success} 成功,{failed} 失败",
moveProgress: "正在移动...",
parsingFailed: "解析失败",
parsingInProgress: "解析中...",
generatingSummary: "生成摘要中...",
+297 -4
View File
@@ -30,6 +30,7 @@ import {
reparseKnowledge,
} from "@/api/knowledge-base/index";
import FAQEntryManager from './components/FAQEntryManager.vue';
import { listMoveTargets, moveKnowledge, getKnowledgeMoveProgress } from '@/api/knowledge-base';
import { useI18n } from 'vue-i18n';
import { formatStringDate, kbFileTypeVerification } from '@/utils';
import { getParserEngines, type ParserEngineInfo } from '@/api/system';
@@ -151,7 +152,13 @@ const kbLastUpdated = computed(() => {
});
const knowledgeList = ref<Array<{ id: string; name: string; type?: string }>>([]);
let { cardList, total, moreIndex, details, getKnowled, delKnowledge, openMore, onVisibleChange, getCardDetails, getfDetails } = useKnowledgeBase(kbId.value)
let { cardList, total, moreIndex, details, getKnowled, delKnowledge, openMore, onVisibleChange: _onVisibleChange, getCardDetails, getfDetails } = useKnowledgeBase(kbId.value)
const onVisibleChange = (visible: boolean) => {
_onVisibleChange(visible);
if (!visible) {
moveMenuMode.value = 'normal';
}
};
let isCardDetails = ref(false);
let timeout: ReturnType<typeof setInterval> | null = null;
let delDialog = ref(false)
@@ -161,6 +168,17 @@ let knowledgeScroll = ref()
let page = 1;
let pageSize = 35;
// Move state — inline in card menu
const moveMenuMode = ref<'normal' | 'targets' | 'confirm'>('normal');
const moveKnowledgeId = ref('');
const moveTargetKbs = ref<any[]>([]);
const moveTargetsLoading = ref(false);
const moveSelectedTargetId = ref('');
const moveSelectedTargetName = ref('');
const moveMode = ref<'reuse_vectors' | 'reparse'>('reuse_vectors');
const moveSubmitting = ref(false);
let movePollTimer: ReturnType<typeof setInterval> | null = null;
const selectedTagId = ref<string>('');
const tagList = ref<any[]>([]);
const tagLoading = ref(false);
@@ -659,6 +677,7 @@ onMounted(() => {
onUnmounted(() => {
window.removeEventListener('knowledgeFileUploaded', handleFileUploaded as EventListener);
window.removeEventListener('openURLImportDialog', handleOpenURLImportDialog as EventListener);
stopMovePoll();
});
watch(() => cardList.value, (newValue) => {
if (isFAQ.value) return;
@@ -783,6 +802,99 @@ const delCard = (index: number, item: KnowledgeCard) => {
delDialog.value = true;
};
const handleMoveKnowledge = async (item: KnowledgeCard) => {
moveKnowledgeId.value = item.id;
moveMenuMode.value = 'targets';
moveTargetsLoading.value = true;
moveTargetKbs.value = [];
try {
const res: any = await listMoveTargets(kbId.value);
moveTargetKbs.value = res.data || [];
} catch {
moveTargetKbs.value = [];
} finally {
moveTargetsLoading.value = false;
}
};
const handleMoveSelectTarget = (kb: any) => {
moveSelectedTargetId.value = kb.id;
moveSelectedTargetName.value = kb.name;
moveMode.value = 'reuse_vectors';
moveMenuMode.value = 'confirm';
};
const handleMoveBack = () => {
if (moveMenuMode.value === 'confirm') {
moveMenuMode.value = 'targets';
} else {
moveMenuMode.value = 'normal';
}
};
const handleMoveConfirm = async () => {
if (!moveSelectedTargetId.value || moveSubmitting.value) return;
moveSubmitting.value = true;
try {
const res: any = await moveKnowledge({
knowledge_ids: [moveKnowledgeId.value],
source_kb_id: kbId.value,
target_kb_id: moveSelectedTargetId.value,
mode: moveMode.value,
});
const taskId = res.data?.task_id;
MessagePlugin.info(t('knowledgeBase.moveStarted'));
// Close the card menu
moveMenuMode.value = 'normal';
cardList.value.forEach(c => { c.isMore = false; });
if (taskId) {
startMovePoll(taskId);
} else {
moveSubmitting.value = false;
loadKnowledgeFiles(kbId.value);
}
} catch (e: any) {
MessagePlugin.error(e?.message || t('knowledgeBase.moveFailed'));
moveSubmitting.value = false;
}
};
const startMovePoll = (taskId: string) => {
if (movePollTimer) clearInterval(movePollTimer);
movePollTimer = setInterval(async () => {
try {
const res: any = await getKnowledgeMoveProgress(taskId);
const data = res.data;
if (!data) return;
if (data.status === 'completed') {
stopMovePoll();
moveSubmitting.value = false;
const failed = data.failed || 0;
if (failed > 0) {
MessagePlugin.warning(t('knowledgeBase.moveCompletedWithErrors', { success: (data.processed || 0) - failed, failed }));
} else {
MessagePlugin.success(t('knowledgeBase.moveCompleted'));
}
loadKnowledgeFiles(kbId.value);
} else if (data.status === 'failed') {
stopMovePoll();
moveSubmitting.value = false;
MessagePlugin.error(t('knowledgeBase.moveFailed'));
}
} catch {
// ignore poll errors
}
}, 2000);
};
const stopMovePoll = () => {
if (movePollTimer) {
clearInterval(movePollTimer);
movePollTimer = null;
}
};
const manualEditorSuccess = ({ kbId: savedKbId }: { kbId: string; knowledgeId: string; status: 'draft' | 'publish' }) => {
if (savedKbId === kbId.value && !isFAQ.value) {
loadKnowledgeFiles(savedKbId);
@@ -1605,7 +1717,8 @@ async function createNewSession(value: string): Promise<void> {
<img class="more" src="@/assets/img/more.png" alt="" />
</div>
<template #content>
<div class="card-menu">
<!-- Normal menu -->
<div v-if="moveMenuMode === 'normal'" class="card-menu">
<div
v-if="item.type === 'manual'"
class="card-menu-item"
@@ -1618,11 +1731,81 @@ async function createNewSession(value: string): Promise<void> {
<t-icon class="icon" name="refresh" />
<span>{{ t('knowledgeBase.rebuildDocument') }}</span>
</div>
<div class="card-menu-item" @click.stop="handleMoveKnowledge(item)">
<t-icon class="icon" name="swap" />
<span>{{ t('knowledgeBase.moveDocument') }}</span>
</div>
<div class="card-menu-item danger" @click.stop="delCard(index, item)">
<t-icon class="icon" name="delete" />
<span>{{ t('knowledgeBase.deleteDocument') }}</span>
</div>
</div>
<!-- Move: target KB list -->
<div v-else-if="moveMenuMode === 'targets'" class="card-menu move-menu">
<div class="move-menu-header" @click.stop="handleMoveBack">
<t-icon name="chevron-left" size="16px" />
<span>{{ t('knowledgeBase.moveToKnowledgeBase') }}</span>
</div>
<div v-if="moveTargetsLoading" class="move-menu-loading">
<t-loading size="small" />
</div>
<div v-else-if="moveTargetKbs.length === 0" class="move-menu-empty">
{{ t('knowledgeBase.moveNoTargets') }}
</div>
<template v-else>
<div
v-for="kb in moveTargetKbs"
:key="kb.id"
class="card-menu-item"
@click.stop="handleMoveSelectTarget(kb)"
>
<t-icon class="icon" name="root-list" />
<span class="move-target-name">{{ kb.name }}</span>
<span v-if="kb.knowledge_count !== undefined" class="move-target-count">{{ kb.knowledge_count }}</span>
</div>
</template>
</div>
<!-- Move: confirm with mode selection -->
<div v-else-if="moveMenuMode === 'confirm'" class="card-menu move-menu">
<div class="move-menu-header" @click.stop="handleMoveBack">
<t-icon name="chevron-left" size="16px" />
<span>{{ t('knowledgeBase.moveConfirmTitle') }}</span>
</div>
<div class="move-confirm-body">
<div class="move-target-info">
<t-icon name="arrow-right" size="14px" />
<span>{{ moveSelectedTargetName }}</span>
</div>
<div
class="move-mode-item"
:class="{ active: moveMode === 'reuse_vectors' }"
@click.stop="moveMode = 'reuse_vectors'"
>
<t-radio :checked="moveMode === 'reuse_vectors'" />
<div class="move-mode-text">
<span class="move-mode-label">{{ t('knowledgeBase.moveModeReuseVectors') }}</span>
<span class="move-mode-desc">{{ t('knowledgeBase.moveModeReuseVectorsDesc') }}</span>
</div>
</div>
<div
class="move-mode-item"
:class="{ active: moveMode === 'reparse' }"
@click.stop="moveMode = 'reparse'"
>
<t-radio :checked="moveMode === 'reparse'" />
<div class="move-mode-text">
<span class="move-mode-label">{{ t('knowledgeBase.moveModeReparse') }}</span>
<span class="move-mode-desc">{{ t('knowledgeBase.moveModeReparseDesc') }}</span>
</div>
</div>
<div class="move-confirm-actions">
<t-button size="small" variant="outline" @click.stop="handleMoveBack">{{ t('common.cancel') }}</t-button>
<t-button size="small" theme="primary" :loading="moveSubmitting" @click.stop="handleMoveConfirm">{{ t('knowledgeBase.moveConfirm') }}</t-button>
</div>
</div>
</div>
</template>
</t-popup>
</div>
@@ -1750,7 +1933,7 @@ async function createNewSession(value: string): Promise<void> {
</div>
</div>
</t-dialog>
<!-- URL 导入对话框 -->
<t-dialog
v-model:visible="urlDialogVisible"
@@ -1805,7 +1988,8 @@ async function createNewSession(value: string): Promise<void> {
}
.card-more .t-popup__content {
width: 180px;
min-width: 180px;
width: auto;
padding: 6px 0;
margin-top: 4px !important;
color: var(--td-text-color-primary);
@@ -2785,6 +2969,115 @@ async function createNewSession(value: string): Promise<void> {
}
}
.move-menu {
min-width: 220px;
max-width: 280px;
max-height: 360px;
overflow-y: auto;
.move-menu-header {
display: flex;
align-items: center;
gap: 6px;
padding: 8px 12px;
font-size: 13px;
font-weight: 500;
color: var(--td-text-color-primary);
border-bottom: 1px solid var(--td-component-stroke);
cursor: pointer;
&:hover {
background: var(--td-bg-color-container-hover);
}
}
.move-menu-loading {
display: flex;
align-items: center;
justify-content: center;
padding: 20px 0;
}
.move-menu-empty {
padding: 12px 16px;
font-size: 12px;
color: var(--td-text-color-placeholder);
text-align: center;
line-height: 1.5;
}
.move-target-name {
flex: 1;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.move-target-count {
font-size: 12px;
color: var(--td-text-color-placeholder);
}
.move-confirm-body {
padding: 8px;
.move-target-info {
display: flex;
align-items: center;
gap: 6px;
padding: 6px 8px;
background: var(--td-bg-color-container-hover);
border-radius: 6px;
font-size: 13px;
color: var(--td-text-color-secondary);
margin-bottom: 8px;
}
.move-mode-item {
display: flex;
align-items: flex-start;
gap: 6px;
padding: 6px 8px;
border-radius: 6px;
cursor: pointer;
margin-bottom: 4px;
&:hover {
background: var(--td-bg-color-container-hover);
}
&.active {
background: var(--td-brand-color-light);
}
.move-mode-text {
display: flex;
flex-direction: column;
gap: 2px;
.move-mode-label {
font-size: 13px;
font-weight: 500;
color: var(--td-text-color-primary);
}
.move-mode-desc {
font-size: 11px;
color: var(--td-text-color-placeholder);
line-height: 1.4;
}
}
}
.move-confirm-actions {
display: flex;
justify-content: flex-end;
gap: 8px;
margin-top: 8px;
}
}
}
.card-draft {
display: flex;
align-items: center;
+7
View File
@@ -420,6 +420,13 @@ func (r *chunkRepository) DeleteByKnowledgeList(ctx context.Context, tenantID ui
).Delete(&types.Chunk{}).Error
}
// MoveChunksByKnowledgeID updates knowledge_base_id for all chunks of a knowledge item
func (r *chunkRepository) MoveChunksByKnowledgeID(ctx context.Context, tenantID uint64, knowledgeID string, targetKBID string) error {
return r.db.WithContext(ctx).Model(&types.Chunk{}).
Where("tenant_id = ? AND knowledge_id = ?", tenantID, knowledgeID).
Update("knowledge_base_id", targetKBID).Error
}
// DeleteChunksByTagID deletes all chunks with the specified tag ID
// Returns the IDs of deleted chunks for index cleanup
func (r *chunkRepository) DeleteChunksByTagID(ctx context.Context, tenantID uint64, kbID string, tagID string, excludeIDs []string) ([]string, error) {
+329 -1
View File
@@ -1938,7 +1938,7 @@ func (s *knowledgeService) ProcessSummaryGeneration(ctx context.Context, t *asyn
}
if kb.SummaryModelID == "" {
logger.Errorf(ctx, "Knowledge base summary model ID is empty")
logger.Warn(ctx, "Knowledge base summary model ID is empty, skipping summary generation")
return nil
}
@@ -8399,6 +8399,334 @@ func (s *knowledgeService) GetKBCloneProgress(ctx context.Context, taskID string
return &progress, nil
}
// ─── Knowledge Move ─────────────────────────────────────────────────────────
const (
knowledgeMoveProgressKeyPrefix = "knowledge_move_progress:"
knowledgeMoveProgressTTL = 24 * time.Hour
)
func getKnowledgeMoveProgressKey(taskID string) string {
return knowledgeMoveProgressKeyPrefix + taskID
}
func (s *knowledgeService) saveKnowledgeMoveProgress(ctx context.Context, progress *types.KnowledgeMoveProgress) error {
key := getKnowledgeMoveProgressKey(progress.TaskID)
data, err := json.Marshal(progress)
if err != nil {
return fmt.Errorf("failed to marshal move progress: %w", err)
}
return s.redisClient.Set(ctx, key, data, knowledgeMoveProgressTTL).Err()
}
// SaveKnowledgeMoveProgress saves the knowledge move progress to Redis (public method for handler use)
func (s *knowledgeService) SaveKnowledgeMoveProgress(ctx context.Context, progress *types.KnowledgeMoveProgress) error {
return s.saveKnowledgeMoveProgress(ctx, progress)
}
// GetKnowledgeMoveProgress retrieves the progress of a knowledge move task
func (s *knowledgeService) GetKnowledgeMoveProgress(ctx context.Context, taskID string) (*types.KnowledgeMoveProgress, error) {
key := getKnowledgeMoveProgressKey(taskID)
data, err := s.redisClient.Get(ctx, key).Bytes()
if err != nil {
if errors.Is(err, redis.Nil) {
return nil, werrors.NewNotFoundError("Knowledge move task not found")
}
return nil, fmt.Errorf("failed to get move progress from Redis: %w", err)
}
var progress types.KnowledgeMoveProgress
if err := json.Unmarshal(data, &progress); err != nil {
return nil, fmt.Errorf("failed to unmarshal move progress: %w", err)
}
return &progress, nil
}
// ProcessKnowledgeMove handles Asynq knowledge move tasks
func (s *knowledgeService) ProcessKnowledgeMove(ctx context.Context, t *asynq.Task) error {
var payload types.KnowledgeMovePayload
if err := json.Unmarshal(t.Payload(), &payload); err != nil {
return fmt.Errorf("failed to unmarshal knowledge move payload: %w", err)
}
// Add tenant ID to context
ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)
// Get tenant info and add to context
tenantInfo, err := s.tenantRepo.GetTenantByID(ctx, payload.TenantID)
if err != nil {
logger.Errorf(ctx, "ProcessKnowledgeMove: failed to get tenant info: %v", err)
return fmt.Errorf("failed to get tenant info: %w", err)
}
ctx = context.WithValue(ctx, types.TenantInfoContextKey, tenantInfo)
// Check if this is the last retry
retryCount, _ := asynq.GetRetryCount(ctx)
maxRetry, _ := asynq.GetMaxRetry(ctx)
isLastRetry := retryCount >= maxRetry
logger.Infof(ctx, "ProcessKnowledgeMove: task=%s, source=%s, target=%s, mode=%s, count=%d, retry=%d/%d",
payload.TaskID, payload.SourceKBID, payload.TargetKBID, payload.Mode, len(payload.KnowledgeIDs), retryCount, maxRetry)
// Helper function to handle errors - only mark as failed on last retry
handleError := func(progress *types.KnowledgeMoveProgress, err error, message string) {
if isLastRetry {
progress.Status = types.KBCloneStatusFailed
progress.Error = err.Error()
progress.Message = message
progress.UpdatedAt = time.Now().Unix()
_ = s.saveKnowledgeMoveProgress(ctx, progress)
}
}
// Update progress to processing
progress := &types.KnowledgeMoveProgress{
TaskID: payload.TaskID,
SourceKBID: payload.SourceKBID,
TargetKBID: payload.TargetKBID,
Status: types.KBCloneStatusProcessing,
Total: len(payload.KnowledgeIDs),
Progress: 0,
Message: "Starting knowledge move...",
UpdatedAt: time.Now().Unix(),
}
_ = s.saveKnowledgeMoveProgress(ctx, progress)
// Get source and target knowledge bases
sourceKB, err := s.kbService.GetKnowledgeBaseByID(ctx, payload.SourceKBID)
if err != nil {
handleError(progress, err, "Failed to get source knowledge base")
return err
}
targetKB, err := s.kbService.GetKnowledgeBaseByID(ctx, payload.TargetKBID)
if err != nil {
handleError(progress, err, "Failed to get target knowledge base")
return err
}
// Validate compatibility
if sourceKB.Type != targetKB.Type {
err := fmt.Errorf("type mismatch: source=%s, target=%s", sourceKB.Type, targetKB.Type)
handleError(progress, err, "Source and target knowledge bases must be the same type")
return err
}
if sourceKB.EmbeddingModelID != targetKB.EmbeddingModelID {
err := fmt.Errorf("embedding model mismatch: source=%s, target=%s", sourceKB.EmbeddingModelID, targetKB.EmbeddingModelID)
handleError(progress, err, "Source and target must use the same embedding model")
return err
}
// Process each knowledge item
for i, knowledgeID := range payload.KnowledgeIDs {
err := s.moveOneKnowledge(ctx, knowledgeID, sourceKB, targetKB, payload.Mode)
if err != nil {
logger.Errorf(ctx, "ProcessKnowledgeMove: failed to move knowledge %s: %v", knowledgeID, err)
progress.Failed++
}
progress.Processed = i + 1
if progress.Total > 0 {
progress.Progress = progress.Processed * 100 / progress.Total
}
progress.Message = fmt.Sprintf("Moved %d/%d knowledge items", progress.Processed, progress.Total)
progress.UpdatedAt = time.Now().Unix()
_ = s.saveKnowledgeMoveProgress(ctx, progress)
}
// Mark as completed
if progress.Failed > 0 && progress.Failed == progress.Total {
progress.Status = types.KBCloneStatusFailed
progress.Message = fmt.Sprintf("Knowledge move failed: all %d items failed", progress.Total)
} else {
progress.Status = types.KBCloneStatusCompleted
progress.Message = fmt.Sprintf("Knowledge move completed: %d/%d succeeded", progress.Processed-progress.Failed, progress.Total)
}
progress.Progress = 100
progress.UpdatedAt = time.Now().Unix()
_ = s.saveKnowledgeMoveProgress(ctx, progress)
logger.Infof(ctx, "ProcessKnowledgeMove: task=%s completed, processed=%d, failed=%d", payload.TaskID, progress.Processed, progress.Failed)
return nil
}
// moveOneKnowledge moves a single knowledge item from source KB to target KB.
func (s *knowledgeService) moveOneKnowledge(
ctx context.Context,
knowledgeID string,
sourceKB, targetKB *types.KnowledgeBase,
mode string,
) error {
tenantID := ctx.Value(types.TenantIDContextKey).(uint64)
// Get the knowledge item
knowledge, err := s.repo.GetKnowledgeByID(ctx, tenantID, knowledgeID)
if err != nil {
return fmt.Errorf("failed to get knowledge %s: %w", knowledgeID, err)
}
// Only move completed items
if knowledge.ParseStatus != types.ParseStatusCompleted {
return fmt.Errorf("knowledge %s is not in completed status (current: %s)", knowledgeID, knowledge.ParseStatus)
}
// Mark as processing during move
knowledge.ParseStatus = types.ParseStatusProcessing
if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {
return fmt.Errorf("failed to mark knowledge as processing: %w", err)
}
switch mode {
case "reuse_vectors":
return s.moveKnowledgeReuseVectors(ctx, knowledge, sourceKB, targetKB)
case "reparse":
return s.moveKnowledgeReparse(ctx, knowledge, sourceKB, targetKB)
default:
return fmt.Errorf("unknown move mode: %s", mode)
}
}
// moveKnowledgeReuseVectors moves knowledge by copying vector indices and updating DB references.
func (s *knowledgeService) moveKnowledgeReuseVectors(
ctx context.Context,
knowledge *types.Knowledge,
sourceKB, targetKB *types.KnowledgeBase,
) error {
tenantID := ctx.Value(types.TenantIDContextKey).(uint64)
tenantInfo := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)
// 1. Get old chunk IDs for vector index copy mapping
oldChunks, err := s.chunkRepo.ListChunksByKnowledgeID(ctx, tenantID, knowledge.ID)
if err != nil {
return fmt.Errorf("failed to list chunks: %w", err)
}
// Build identity mapping (same chunk IDs, just moving between KBs)
chunkIDMapping := make(map[string]string, len(oldChunks))
for _, c := range oldChunks {
chunkIDMapping[c.ID] = c.ID
}
// 2. Copy vector indices from source KB to target KB
if len(chunkIDMapping) > 0 && knowledge.EmbeddingModelID != "" {
retrieveEngine, err := retriever.NewCompositeRetrieveEngine(s.retrieveEngine, tenantInfo.GetEffectiveEngines())
if err != nil {
return fmt.Errorf("failed to init retrieve engine: %w", err)
}
embeddingModel, err := s.modelService.GetEmbeddingModel(ctx, knowledge.EmbeddingModelID)
if err != nil {
return fmt.Errorf("failed to get embedding model: %w", err)
}
// Copy indices from source KB to target KB
knowledgeIDMapping := map[string]string{knowledge.ID: knowledge.ID}
if err := retrieveEngine.CopyIndices(ctx, sourceKB.ID, targetKB.ID,
knowledgeIDMapping, chunkIDMapping,
embeddingModel.GetDimensions(), sourceKB.Type,
); err != nil {
return fmt.Errorf("failed to copy indices: %w", err)
}
// Delete indices from source KB
if err := retrieveEngine.DeleteByKnowledgeIDList(ctx, []string{knowledge.ID},
embeddingModel.GetDimensions(), sourceKB.Type,
); err != nil {
logger.Warnf(ctx, "moveKnowledgeReuseVectors: failed to delete old indices for knowledge %s: %v", knowledge.ID, err)
// Non-fatal: indices will be orphaned but won't affect correctness
}
}
// 3. Update chunks' knowledge_base_id in DB
if err := s.chunkRepo.MoveChunksByKnowledgeID(ctx, tenantID, knowledge.ID, targetKB.ID); err != nil {
return fmt.Errorf("failed to move chunks: %w", err)
}
// 4. Update knowledge record
knowledge.KnowledgeBaseID = targetKB.ID
knowledge.TagID = "" // Clear tag since tags are KB-scoped
knowledge.ParseStatus = types.ParseStatusCompleted
knowledge.UpdatedAt = time.Now()
if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {
return fmt.Errorf("failed to update knowledge: %w", err)
}
return nil
}
// moveKnowledgeReparse moves knowledge to target KB and re-parses it with target KB's configuration.
func (s *knowledgeService) moveKnowledgeReparse(
ctx context.Context,
knowledge *types.Knowledge,
_, targetKB *types.KnowledgeBase,
) error {
tenantID := ctx.Value(types.TenantIDContextKey).(uint64)
// 1. Clean up existing chunks and vector indices
if err := s.cleanupKnowledgeResources(ctx, knowledge); err != nil {
logger.Warnf(ctx, "moveKnowledgeReparse: cleanup partial error for knowledge %s: %v", knowledge.ID, err)
// Continue - partial cleanup is acceptable
}
// 2. Update knowledge to belong to target KB
knowledge.KnowledgeBaseID = targetKB.ID
knowledge.EmbeddingModelID = targetKB.EmbeddingModelID
knowledge.TagID = "" // Clear tag since tags are KB-scoped
knowledge.ParseStatus = types.ParseStatusPending
knowledge.EnableStatus = "disabled"
knowledge.Description = ""
knowledge.ProcessedAt = nil
knowledge.UpdatedAt = time.Now()
if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {
return fmt.Errorf("failed to update knowledge: %w", err)
}
// 3. Enqueue document processing task with target KB's configuration
if knowledge.IsManual() {
meta, err := knowledge.ManualMetadata()
if err != nil || meta == nil {
return fmt.Errorf("failed to get manual metadata for reparse: %w", err)
}
s.triggerManualProcessing(ctx, targetKB, knowledge, meta.Content, false)
return nil
}
if knowledge.FilePath != "" {
enableMultimodel := targetKB.IsMultimodalEnabled()
enableQuestionGeneration := false
questionCount := 3
if targetKB.QuestionGenerationConfig != nil && targetKB.QuestionGenerationConfig.Enabled {
enableQuestionGeneration = true
if targetKB.QuestionGenerationConfig.QuestionCount > 0 {
questionCount = targetKB.QuestionGenerationConfig.QuestionCount
}
}
taskPayload := types.DocumentProcessPayload{
TenantID: tenantID,
KnowledgeID: knowledge.ID,
KnowledgeBaseID: targetKB.ID,
FilePath: knowledge.FilePath,
FileName: knowledge.FileName,
FileType: getFileType(knowledge.FileName),
EnableMultimodel: enableMultimodel,
EnableQuestionGeneration: enableQuestionGeneration,
QuestionCount: questionCount,
}
payloadBytes, err := json.Marshal(taskPayload)
if err != nil {
return fmt.Errorf("failed to marshal document process payload: %w", err)
}
task := asynq.NewTask(types.TypeDocumentProcess, payloadBytes, asynq.Queue("default"), asynq.MaxRetry(3))
info, err := s.task.Enqueue(task)
if err != nil {
return fmt.Errorf("failed to enqueue document process task: %w", err)
}
logger.Infof(ctx, "moveKnowledgeReparse: enqueued reparse task id=%s for knowledge=%s", info.ID, knowledge.ID)
}
return nil
}
// getOrCreateTagInTarget finds or creates a tag in the target knowledge base based on the source tag.
// It looks up the source tag by ID, then tries to find a tag with the same name in the target KB.
// If not found, it creates a new tag with the same properties.
+190
View File
@@ -8,16 +8,20 @@ import (
"net/http"
"strconv"
"strings"
"time"
goerrors "errors"
"github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/application/service"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/Tencent/WeKnora/internal/utils"
secutils "github.com/Tencent/WeKnora/internal/utils"
"github.com/gin-gonic/gin"
"github.com/hibiken/asynq"
)
// KnowledgeHandler processes HTTP requests related to knowledge resources
@@ -26,6 +30,7 @@ type KnowledgeHandler struct {
kbService interfaces.KnowledgeBaseService
kbShareService interfaces.KBShareService
agentShareService interfaces.AgentShareService
asynqClient interfaces.TaskEnqueuer
}
// NewKnowledgeHandler creates a new knowledge handler instance
@@ -34,12 +39,14 @@ func NewKnowledgeHandler(
kbService interfaces.KnowledgeBaseService,
kbShareService interfaces.KBShareService,
agentShareService interfaces.AgentShareService,
asynqClient interfaces.TaskEnqueuer,
) *KnowledgeHandler {
return &KnowledgeHandler{
kgService: kgService,
kbService: kbService,
kbShareService: kbShareService,
agentShareService: agentShareService,
asynqClient: asynqClient,
}
}
@@ -1284,3 +1291,186 @@ func (h *KnowledgeHandler) SearchKnowledge(c *gin.Context) {
"has_more": hasMore,
})
}
// MoveKnowledgeRequest defines the request for moving knowledge items
type MoveKnowledgeRequest struct {
KnowledgeIDs []string `json:"knowledge_ids" binding:"required,min=1"`
SourceKBID string `json:"source_kb_id" binding:"required"`
TargetKBID string `json:"target_kb_id" binding:"required"`
Mode string `json:"mode" binding:"required,oneof=reuse_vectors reparse"`
}
// MoveKnowledgeResponse defines the response for move knowledge
type MoveKnowledgeResponse struct {
TaskID string `json:"task_id"`
SourceKBID string `json:"source_kb_id"`
TargetKBID string `json:"target_kb_id"`
KnowledgeCount int `json:"knowledge_count"`
Message string `json:"message"`
}
// MoveKnowledge moves knowledge items from one knowledge base to another (async task).
func (h *KnowledgeHandler) MoveKnowledge(c *gin.Context) {
ctx := c.Request.Context()
var req MoveKnowledgeRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "MoveKnowledge: failed to parse request", err)
c.Error(errors.NewBadRequestError("Invalid request parameters: " + err.Error()))
return
}
// Validate source != target
if req.SourceKBID == req.TargetKBID {
c.Error(errors.NewBadRequestError("Source and target knowledge base cannot be the same"))
return
}
tenantID, exists := c.Get(types.TenantIDContextKey.String())
if !exists {
c.Error(errors.NewUnauthorizedError("Unauthorized"))
return
}
// Validate source KB
sourceKB, err := h.kbService.GetKnowledgeBaseByID(ctx, req.SourceKBID)
if err != nil {
if goerrors.Is(err, repository.ErrKnowledgeBaseNotFound) {
c.Error(errors.NewNotFoundError("Source knowledge base not found"))
return
}
c.Error(errors.NewInternalServerError(err.Error()))
return
}
if sourceKB.TenantID != tenantID.(uint64) {
c.Error(errors.NewForbiddenError("No permission to access source knowledge base"))
return
}
// Validate target KB
targetKB, err := h.kbService.GetKnowledgeBaseByID(ctx, req.TargetKBID)
if err != nil {
if goerrors.Is(err, repository.ErrKnowledgeBaseNotFound) {
c.Error(errors.NewNotFoundError("Target knowledge base not found"))
return
}
c.Error(errors.NewInternalServerError(err.Error()))
return
}
if targetKB.TenantID != tenantID.(uint64) {
c.Error(errors.NewForbiddenError("No permission to access target knowledge base"))
return
}
// Validate type match
if sourceKB.Type != targetKB.Type {
c.Error(errors.NewBadRequestError("Source and target knowledge bases must be the same type"))
return
}
// Validate embedding model match
if sourceKB.EmbeddingModelID != targetKB.EmbeddingModelID {
c.Error(errors.NewBadRequestError("Source and target must use the same embedding model"))
return
}
// Validate all knowledge IDs belong to source KB and are in completed status
for _, kID := range req.KnowledgeIDs {
knowledge, err := h.kgService.GetKnowledgeByID(ctx, kID)
if err != nil {
c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge item %s not found", kID)))
return
}
if knowledge.KnowledgeBaseID != req.SourceKBID {
c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge item %s does not belong to the source knowledge base", kID)))
return
}
if knowledge.ParseStatus != types.ParseStatusCompleted {
c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge item %s is not in completed status (current: %s)", kID, knowledge.ParseStatus)))
return
}
}
// Generate task ID
taskID := utils.GenerateTaskID("kg_move", tenantID.(uint64), req.SourceKBID)
// Create move payload
payload := types.KnowledgeMovePayload{
TenantID: tenantID.(uint64),
TaskID: taskID,
KnowledgeIDs: req.KnowledgeIDs,
SourceKBID: req.SourceKBID,
TargetKBID: req.TargetKBID,
Mode: req.Mode,
}
payloadBytes, err := json.Marshal(payload)
if err != nil {
logger.Errorf(ctx, "MoveKnowledge: failed to marshal payload: %v", err)
c.Error(errors.NewInternalServerError("Failed to create task"))
return
}
// Enqueue move task
task := asynq.NewTask(types.TypeKnowledgeMove, payloadBytes,
asynq.TaskID(taskID), asynq.Queue("default"), asynq.MaxRetry(3))
info, err := h.asynqClient.Enqueue(task)
if err != nil {
logger.Errorf(ctx, "MoveKnowledge: failed to enqueue task: %v", err)
c.Error(errors.NewInternalServerError("Failed to enqueue task"))
return
}
logger.Infof(ctx, "MoveKnowledge: task enqueued: %s, asynq_id: %s, source: %s, target: %s, count: %d",
taskID, info.ID, secutils.SanitizeForLog(req.SourceKBID), secutils.SanitizeForLog(req.TargetKBID), len(req.KnowledgeIDs))
// Save initial progress
initialProgress := &types.KnowledgeMoveProgress{
TaskID: taskID,
SourceKBID: req.SourceKBID,
TargetKBID: req.TargetKBID,
Status: types.KBCloneStatusPending,
Total: len(req.KnowledgeIDs),
Progress: 0,
Message: "Task queued, waiting to start...",
CreatedAt: time.Now().Unix(),
UpdatedAt: time.Now().Unix(),
}
if err := h.kgService.SaveKnowledgeMoveProgress(ctx, initialProgress); err != nil {
logger.Warnf(ctx, "MoveKnowledge: failed to save initial progress: %v", err)
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": MoveKnowledgeResponse{
TaskID: taskID,
SourceKBID: req.SourceKBID,
TargetKBID: req.TargetKBID,
KnowledgeCount: len(req.KnowledgeIDs),
Message: "Knowledge move task started",
},
})
}
// GetKnowledgeMoveProgress retrieves the progress of a knowledge move task.
func (h *KnowledgeHandler) GetKnowledgeMoveProgress(c *gin.Context) {
ctx := c.Request.Context()
taskID := c.Param("task_id")
if taskID == "" {
c.Error(errors.NewBadRequestError("Task ID cannot be empty"))
return
}
progress, err := h.kgService.GetKnowledgeMoveProgress(ctx, taskID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(err)
return
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": progress,
})
}
+63
View File
@@ -778,3 +778,66 @@ func validateExtractConfig(config *types.ExtractConfig) error {
return nil
}
// ListMoveTargets returns knowledge bases eligible as move targets for the given source KB.
// Filters: same Type, same EmbeddingModelID, different ID, not temporary.
func (h *KnowledgeBaseHandler) ListMoveTargets(c *gin.Context) {
ctx := c.Request.Context()
sourceKBID := c.Param("id")
if sourceKBID == "" {
c.Error(apperrors.NewBadRequestError("Knowledge base ID is required"))
return
}
tenantID, exists := c.Get(types.TenantIDContextKey.String())
if !exists {
c.Error(apperrors.NewUnauthorizedError("Unauthorized"))
return
}
// Get source knowledge base
sourceKB, err := h.service.GetKnowledgeBaseByID(ctx, sourceKBID)
if err != nil {
if stderrors.Is(err, repository.ErrKnowledgeBaseNotFound) {
c.Error(errors.NewNotFoundError("Source knowledge base not found"))
return
}
c.Error(errors.NewInternalServerError(err.Error()))
return
}
if sourceKB.TenantID != tenantID.(uint64) {
c.Error(errors.NewForbiddenError("No permission to access this knowledge base"))
return
}
// Get all knowledge bases
allKBs, err := h.service.ListKnowledgeBases(ctx)
if err != nil {
c.Error(errors.NewInternalServerError(err.Error()))
return
}
// Filter eligible targets
targets := make([]*types.KnowledgeBase, 0)
for _, kb := range allKBs {
if kb.ID == sourceKBID {
continue
}
if kb.IsTemporary {
continue
}
if kb.Type != sourceKB.Type {
continue
}
if kb.EmbeddingModelID != sourceKB.EmbeddingModelID {
continue
}
targets = append(targets, kb)
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": targets,
})
}
+6
View File
@@ -199,6 +199,10 @@ func RegisterKnowledgeRoutes(r *gin.RouterGroup, handler *handler.KnowledgeHandl
k.PUT("/tags", handler.UpdateKnowledgeTagBatch)
// 搜索知识
k.GET("/search", handler.SearchKnowledge)
// 移动知识到其他知识库
k.POST("/move", handler.MoveKnowledge)
// 获取知识移动进度
k.GET("/move/progress/:task_id", handler.GetKnowledgeMoveProgress)
}
}
@@ -254,6 +258,8 @@ func RegisterKnowledgeBaseRoutes(r *gin.RouterGroup, handler *handler.KnowledgeB
kb.POST("/copy", handler.CopyKnowledgeBase)
// 获取知识库复制进度
kb.GET("/copy/progress/:task_id", handler.GetKBCloneProgress)
// 获取可移动目标知识库列表
kb.GET("/:id/move-targets", handler.ListMoveTargets)
}
}
+1
View File
@@ -90,6 +90,7 @@ func RegisterSyncHandlers(params SyncTaskParams) {
params.Executor.RegisterHandler(types.TypeQuestionGeneration, params.KnowledgeService.ProcessQuestionGeneration)
params.Executor.RegisterHandler(types.TypeSummaryGeneration, params.KnowledgeService.ProcessSummaryGeneration)
params.Executor.RegisterHandler(types.TypeKBClone, params.KnowledgeService.ProcessKBClone)
params.Executor.RegisterHandler(types.TypeKnowledgeMove, params.KnowledgeService.ProcessKnowledgeMove)
params.Executor.RegisterHandler(types.TypeKnowledgeListDelete, params.KnowledgeService.ProcessKnowledgeListDelete)
params.Executor.RegisterHandler(types.TypeIndexDelete, params.TagService.ProcessIndexDelete)
params.Executor.RegisterHandler(types.TypeKBDelete, params.KnowledgeBaseService.ProcessKBDelete)
+3
View File
@@ -90,6 +90,9 @@ func RunAsynqServer(params AsynqTaskParams) *asynq.ServeMux {
// Register KB clone handler
mux.HandleFunc(types.TypeKBClone, params.KnowledgeService.ProcessKBClone)
// Register knowledge move handler
mux.HandleFunc(types.TypeKnowledgeMove, params.KnowledgeService.ProcessKnowledgeMove)
// Register knowledge list delete handler
mux.HandleFunc(types.TypeKnowledgeListDelete, params.KnowledgeService.ProcessKnowledgeListDelete)
+27
View File
@@ -10,6 +10,7 @@ const (
TypeIndexDelete = "index:delete" // 索引删除任务
TypeKBDelete = "kb:delete" // 知识库删除任务
TypeKnowledgeListDelete = "knowledge:list_delete" // 批量删除知识任务
TypeKnowledgeMove = "knowledge:move" // 知识移动任务
TypeDataTableSummary = "datatable:summary" // 表格摘要任务
TypeImageMultimodal = "image:multimodal" // 图片多模态处理任务(OCR + VLM Caption)
)
@@ -98,6 +99,32 @@ type KnowledgeListDeletePayload struct {
KnowledgeIDs []string `json:"knowledge_ids"`
}
// KnowledgeMovePayload represents the knowledge move task payload
type KnowledgeMovePayload struct {
TenantID uint64 `json:"tenant_id"`
TaskID string `json:"task_id"`
KnowledgeIDs []string `json:"knowledge_ids"`
SourceKBID string `json:"source_kb_id"`
TargetKBID string `json:"target_kb_id"`
Mode string `json:"mode"` // "reuse_vectors" or "reparse"
}
// KnowledgeMoveProgress represents the progress of a knowledge move task
type KnowledgeMoveProgress struct {
TaskID string `json:"task_id"`
SourceKBID string `json:"source_kb_id"`
TargetKBID string `json:"target_kb_id"`
Status KBCloneTaskStatus `json:"status"`
Progress int `json:"progress"` // 0-100
Total int `json:"total"` // 总知识数
Processed int `json:"processed"` // 已处理数
Failed int `json:"failed"` // 失败数
Message string `json:"message"` // 状态消息
Error string `json:"error"` // 错误信息
CreatedAt int64 `json:"created_at"` // 任务创建时间
UpdatedAt int64 `json:"updated_at"` // 最后更新时间
}
// ImageMultimodalPayload represents the image multimodal processing task payload.
type ImageMultimodalPayload struct {
TenantID uint64 `json:"tenant_id"`
+2
View File
@@ -58,6 +58,8 @@ type ChunkRepository interface {
DeleteChunksByKnowledgeID(ctx context.Context, tenantID uint64, knowledgeID string) error
// DeleteByKnowledgeList deletes all chunks for a knowledge list
DeleteByKnowledgeList(ctx context.Context, tenantID uint64, knowledgeIDs []string) error
// MoveChunksByKnowledgeID updates knowledge_base_id for all chunks of a knowledge item
MoveChunksByKnowledgeID(ctx context.Context, tenantID uint64, knowledgeID string, targetKBID string) error
// DeleteChunksByTagID deletes all chunks with the specified tag ID
// Returns the IDs of deleted chunks for index cleanup
DeleteChunksByTagID(ctx context.Context, tenantID uint64, kbID string, tagID string, excludeIDs []string) ([]string, error)
+6
View File
@@ -139,12 +139,18 @@ type KnowledgeService interface {
ProcessSummaryGeneration(ctx context.Context, t *asynq.Task) error
// ProcessKBClone handles Asynq knowledge base clone tasks
ProcessKBClone(ctx context.Context, t *asynq.Task) error
// ProcessKnowledgeMove handles Asynq knowledge move tasks
ProcessKnowledgeMove(ctx context.Context, t *asynq.Task) error
// ProcessKnowledgeListDelete handles Asynq knowledge list delete tasks
ProcessKnowledgeListDelete(ctx context.Context, t *asynq.Task) error
// GetKBCloneProgress retrieves the progress of a knowledge base clone task
GetKBCloneProgress(ctx context.Context, taskID string) (*types.KBCloneProgress, error)
// SaveKBCloneProgress saves the progress of a knowledge base clone task
SaveKBCloneProgress(ctx context.Context, progress *types.KBCloneProgress) error
// GetKnowledgeMoveProgress retrieves the progress of a knowledge move task
GetKnowledgeMoveProgress(ctx context.Context, taskID string) (*types.KnowledgeMoveProgress, error)
// SaveKnowledgeMoveProgress saves the progress of a knowledge move task
SaveKnowledgeMoveProgress(ctx context.Context, progress *types.KnowledgeMoveProgress) error
// GetFAQImportProgress retrieves the progress of an FAQ import task
GetFAQImportProgress(ctx context.Context, taskID string) (*types.FAQImportProgress, error)
// UpdateLastFAQImportResultDisplayStatus updates the display status of FAQ import result