docs(knowledge-base): 添加知识库模块传参方式和参数命名规范文档

云

3 小时以前 16697df76d7b27ff65d229937b3f3ac4cc0e56a0

 src/api/collaborativeApproval/knowledgeBase.js

@@ -1,60 +1,92 @@
import request from "@/utils/request";
import { getToken } from '@/utils/auth';

// 查询知识库列表
/**
 * 知识库管理接口
 * 传参规范:
 * - GET请求: 使用 params
 * - POST请求: 使用 data
 * - DELETE请求: 使用 data
 * - 流式请求: 使用 Fetch API
 */

// ==================== 知识库CRUD接口 ====================

/**
 * 查询知识库列表
 * @param {Object} query - 查询参数
 * @param {number} query.current - 当前页码(必填)
 * @param {number} query.size - 每页条数(必填)
 * @param {string} [query.title] - 知识标题(可选,模糊搜索)
 * @param {string} [query.type] - 知识类型(可选,精确匹配)
 * @returns {Promise}
 */
export function listKnowledgeBase(query) {
  return request({
    url: "/knowledgeBase/getList",
    method: "get",
    params: query,
    params: query,  // GET请求使用params
  });
}

// 查询知识库详细
// export function getKnowledgeBase(knowledgeBaseId) {
//   return request({
//     url: "/collaborativeApproval/knowledgeBase/" + knowledgeBaseId,
//     method: "get",
//   });
// }

// 新增知识库
/**
 * 新增知识库
 * @param {Object} data - 知识库数据
 * @param {string} data.title - 知识标题(必填)
 * @param {string} data.type - 知识类型(必填)
 * @param {string} [data.scenario] - 适用场景(可选)
 * @param {string} [data.efficiency] - 解决效率(可选)
 * @param {string} data.problem - 问题描述(必填)
 * @param {string} data.solution - 解决方案(必填)
 * @param {string} [data.keyPoints] - 关键要点(可选)
 * @param {string} [data.creator] - 创建人(可选)
 * @param {number} [data.usageCount=0] - 使用次数(可选)
 * @returns {Promise}
 */
export function addKnowledgeBase(data) {
  return request({
    url: "/knowledgeBase/add",
    method: "post",
    data: data,
    data: data,  // POST请求使用data
  });
}

// 修改知识库
/**
 * 修改知识库
 * @param {Object} data - 知识库数据
 * @param {number} data.id - 知识库ID(必填)
 * @param {string} data.title - 知识标题(必填)
 * @param {string} data.type - 知识类型(必填)
 * @returns {Promise}
 */
export function updateKnowledgeBase(data) {
  return request({
    url: "/knowledgeBase/update",
    method: "post",
    data: data,
    data: data,  // POST请求使用data
  });
}

// 删除知识库
export function delKnowledgeBase(query) {
/**
 * 删除知识库(支持批量删除)
 * @param {number[]} ids - 知识库ID数组
 * @returns {Promise}
 */
export function delKnowledgeBase(ids) {
  return request({
    url: "/knowledgeBase/delete",
    method: "delete",
    data: query,
    data: ids,  // DELETE请求使用data传递数组
  });
}

// 批量删除知识库
export function delKnowledgeBaseBatch(knowledgeBaseIds) {
  return request({
    url: "/knowledgeBase/batch",
    method: "delete",
    data: knowledgeBaseIds,
  });
}
// ==================== 文件管理接口 ====================

// 获取知识库文件向量化状态
/**
 * 查询知识库文件向量化状态
 * @param {number} knowledgeBaseId - 知识库ID
 * @returns {Promise} 返回文件列表及向量化状态
 */
export function getVectorStatus(knowledgeBaseId) {
  return request({
    url: `/knowledgeBase/vector/status/${knowledgeBaseId}`,
@@ -62,7 +94,39 @@
  });
}

// 重新向量化文件
/**
 * 保存知识库文件关联(触发向量化)
 * @param {Object} data - 文件关联数据
 * @param {number} data.knowledgeBaseId - 知识库ID(必填)
 * @param {number[]} data.storageBlobIds - 文件blob ID数组(必填)
 * @returns {Promise}
 */
export function saveKnowledgeBaseFiles(data) {
  return request({
    url: "/knowledgeBase/file/save",
    method: "post",
    data: data,  // POST请求使用data
  });
}

/**
 * 删除知识库文件
 * @param {number[]} ids - 向量记录ID数组
 * @returns {Promise}
 */
export function deleteKnowledgeBaseFile(ids) {
  return request({
    url: "/knowledgeBase/file/delete",
    method: "delete",
    data: ids,  // DELETE请求使用data传递数组
  });
}

/**
 * 重新向量化文件
 * @param {number} vectorId - 向量记录ID
 * @returns {Promise}
 */
export function reprocessVector(vectorId) {
  return request({
    url: `/knowledgeBase/vector/reprocess/${vectorId}`,
@@ -70,36 +134,22 @@
  });
}

// 保存知识库文件关联
export function saveKnowledgeBaseFiles(data) {
  return request({
    url: "/knowledgeBase/file/save",
    method: "post",
    data: data,
  });
}
// ==================== 知识问答接口 ====================

// 删除知识库文件
export function deleteKnowledgeBaseFiles(vectorIds) {
  return request({
    url: "/knowledgeBase/file/delete",
    method: "delete",
    data: vectorIds,
  });
}

// 查询知识库问答历史
export function getKnowledgeHistory(memoryId) {
  return request({
    url: `/ai/knowledge/history/${memoryId}`,
    method: "get",
  });
}

// 知识库问答(流式)
export async function knowledgeChat(data) {
/**
 * 知识库问答(流式)
 * 后端接口: POST /ai/knowledge/chat
 * 响应类型: text/stream;charset=utf-8 (Spring Flux<String>)
 *
 * @param {Object} data - 问答参数
 * @param {number} data.knowledgeBaseId - 知识库ID(必填)
 * @param {string} data.memoryId - 会话ID(必填,用于保持上下文)
 * @param {string} data.question - 用户问题(必填)
 * @returns {Promise<Response>} 返回Fetch Response对象
 */
export function knowledgeChat(data) {
  const token = getToken();
  const response = await fetch(import.meta.env.VITE_APP_BASE_API + '/ai/knowledge/chat', {
  return fetch(import.meta.env.VITE_APP_BASE_API + '/ai/knowledge/chat', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
@@ -107,6 +157,16 @@
    },
    body: JSON.stringify(data)
  });
  return response.body;
}

/**
 * 查询知识库问答历史
 * @param {string} memoryId - 会话ID
 * @returns {Promise}
 */
export function getKnowledgeHistory(memoryId) {
  return request({
    url: `/ai/knowledge/history/${memoryId}`,
    method: "get",
  });
}