@cicctencent/agent-midway 0.1.1

package/dist/service/knowledge-base.service.js

@@ -0,0 +1,528 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeBaseService = void 0;
+const core_1 = require("@midwayjs/core");
+const midwayjs_base_1 = require("@cicctencent/midwayjs-base");
+const typeorm_1 = require("@midwayjs/typeorm");
+const typeorm_2 = require("typeorm");
+const openai_service_1 = require("./openai.service");
+const ai_knowledge_base_entity_1 = __importDefault(require("../model/ai-knowledge-base.entity"));
+const ai_kb_document_entity_1 = __importDefault(require("../model/ai-kb-document.entity"));
+const agent_server_1 = require("@cicctencent/agent-server");
+/**
+ * 知识库服务
+ * 管理知识库的创建、文档索引、向量搜索
+ *
+ * 向量存储委托给 agent-server 的 FileKnowledgeBase，
+ * 元数据（KnowledgeBase / KBDocument）仍由 TypeORM 实体管理。
+ */
+let KnowledgeBaseService = class KnowledgeBaseService extends midwayjs_base_1.BaseService {
+    constructor() {
+        super(...arguments);
+        /** FileKnowledgeBase 实例缓存: Map<knowledgeBaseId, FileKnowledgeBase> */
+        this.kbInstances = new Map();
+    }
+    get kbModel() {
+        if (this.kbRepo)
+            return this.kbRepo;
+        return (this.kbRepo = this.dataSource.getRepository(ai_knowledge_base_entity_1.default));
+    }
+    get docModel() {
+        if (this.docRepo)
+            return this.docRepo;
+        return (this.docRepo =
+            this.dataSource.getRepository(ai_kb_document_entity_1.default));
+    }
+    /**
+     * 获取 EmbeddingProvider，使用 OpenAIService 生成 embedding
+     */
+    getEmbeddingProvider() {
+        if (this._embeddingProvider)
+            return this._embeddingProvider;
+        this._embeddingProvider = {
+            dimensions: 1536,
+            embed: async (texts) => {
+                if (this.openaiService.isAvailable()) {
+                    try {
+                        const client = this.openaiService.client;
+                        const model = this.openaiConfig?.embeddingModel ||
+                            'text-embedding-3-small';
+                        const response = await client.embeddings.create({
+                            model,
+                            input: texts,
+                        });
+                        return response.data.map((item) => item.embedding);
+                    }
+                    catch (error) {
+                        console.warn('[KnowledgeBase] 向量生成失败，使用哈希降级:', error.message);
+                    }
+                }
+                // 降级：使用简单哈希向量
+                return texts.map(text => this.hashEmbedding(text, 1536));
+            },
+        };
+        return this._embeddingProvider;
+    }
+    /**
+     * 获取或创建 FileKnowledgeBase 实例
+     * 每个 KnowledgeBase 对应一个 FileKnowledgeBase（通过 docId 前缀隔离）
+     */
+    getFileKB(kbId) {
+        let fkb = this.kbInstances.get(kbId);
+        if (!fkb) {
+            fkb = new agent_server_1.FileKnowledgeBase({
+                embeddingProvider: this.getEmbeddingProvider(),
+            });
+            this.kbInstances.set(kbId, fkb);
+        }
+        return fkb;
+    }
+    // ===================== 知识库 CRUD =====================
+    /** 列出知识库 */
+    async list(applicationId, options) {
+        const where = { applicationId };
+        if (options?.enabled !== undefined) {
+            where.enabled = options.enabled ? 1 : 0;
+        }
+        if (options?.status) {
+            where.status = options.status;
+        }
+        return this.kbModel.find({
+            where,
+            order: { createTime: 'DESC' },
+        });
+    }
+    /** 获取单个知识库 */
+    async get(id, applicationId) {
+        const where = { id };
+        if (applicationId)
+            where.applicationId = applicationId;
+        return this.kbModel.findOne({ where });
+    }
+    /** 创建知识库 */
+    async create(applicationId, data) {
+        const kb = this.kbModel.create({
+            ...data,
+            applicationId,
+            status: 'pending',
+            documentCount: 0,
+            chunkCount: 0,
+        });
+        return this.kbModel.save(kb);
+    }
+    /** 更新知识库 */
+    async update(id, applicationId, data) {
+        await this.kbModel.update({ id, applicationId }, data);
+        return this.get(id, applicationId);
+    }
+    /** 删除知识库 */
+    async delete(id, applicationId) {
+        // 删除关联文档
+        await this.docModel.delete({ knowledgeBaseId: id });
+        // 清除 FileKnowledgeBase 实例缓存
+        this.kbInstances.delete(id);
+        // 删除知识库
+        await this.kbModel.delete({ id, applicationId });
+    }
+    /** 启用知识库 */
+    async enable(id, applicationId) {
+        await this.kbModel.update({ id, applicationId }, { enabled: 1 });
+        return this.get(id, applicationId);
+    }
+    /** 禁用知识库 */
+    async disable(id, applicationId) {
+        await this.kbModel.update({ id, applicationId }, { enabled: 0 });
+        return this.get(id, applicationId);
+    }
+    // ===================== 文档管理 =====================
+    /** 获取文档列表 */
+    async getDocuments(knowledgeBaseId) {
+        return this.docModel.find({
+            where: { knowledgeBaseId },
+            order: { createTime: 'DESC' },
+        });
+    }
+    /** 删除文档 */
+    async deleteDocument(documentId) {
+        const doc = await this.docModel.findOne({
+            where: { id: documentId },
+        });
+        if (!doc)
+            return;
+        const kbId = doc.knowledgeBaseId;
+        const fkb = this.getFileKB(kbId);
+        // 从 FileKnowledgeBase 中移除文档
+        await fkb.remove(`doc_${documentId}`);
+        // 更新知识库分块计数
+        const docs = await this.docModel.find({
+            where: { knowledgeBaseId: kbId },
+        });
+        const remainingDocCount = docs.filter(d => d.id !== documentId).length;
+        // 获取剩余分块数
+        const docList = await fkb.list();
+        const remainingChunks = docList.reduce((sum, d) => sum + d.chunkCount, 0);
+        await this.kbModel.update({ id: kbId }, {
+            chunkCount: remainingChunks,
+            documentCount: remainingDocCount,
+        });
+        await this.docModel.delete({ id: documentId });
+    }
+    // ===================== 文档索引 =====================
+    /**
+     * 从文件索引文档
+     * 使用 agent-server 的 parseDocument() 解析文件 + FileKnowledgeBase.ingest() 存储
+     *
+     * @param id 知识库 ID
+     * @param filePath 文件路径
+     * @param title 文档标题（可选，默认使用文件名）
+     */
+    async indexFromFile(id, filePath, title) {
+        const kb = await this.get(id);
+        if (!kb) {
+            throw new Error('知识库不存在');
+        }
+        await this.kbModel.update({ id }, { status: 'indexing', lastError: null });
+        try {
+            const fkb = this.getFileKB(id);
+            // 使用 parseDocument() 解析文档文件
+            const parsed = await (0, agent_server_1.parseDocument)(filePath, `doc_file_${Date.now()}`);
+            const filename = parsed.filename;
+            const docTitle = title || filename;
+            // 创建文档记录
+            const docEntity = this.docModel.create({
+                knowledgeBaseId: id,
+                title: docTitle,
+                content: parsed.text,
+                sourcePath: filePath,
+                sourceType: 'file',
+                status: 'pending',
+                meta: { filename, originalChunkCount: parsed.chunks.length },
+            });
+            const savedDoc = await this.docModel.save(docEntity);
+            const documentId = savedDoc.id;
+            const docIdStr = `doc_${documentId}`;
+            // 构建 TextChunk 数组
+            const textChunks = parsed.chunks.map((c, i) => ({
+                id: `${docIdStr}_chunk_${i}`,
+                docId: docIdStr,
+                content: c.content,
+                metadata: {
+                    documentId,
+                    title: docTitle,
+                    sourcePath: filePath,
+                    filename,
+                    chunkIndex: i,
+                    totalChunks: parsed.chunks.length,
+                    ...c.metadata,
+                },
+            }));
+            // 使用 FileKnowledgeBase.ingest() 存储
+            await fkb.ingest(docIdStr, textChunks);
+            // 更新文档状态
+            await this.docModel.update({ id: documentId }, { status: 'indexed', chunkCount: parsed.chunks.length });
+            // 更新知识库状态
+            const docCount = await this.docModel.count({
+                where: { knowledgeBaseId: id },
+            });
+            const docList = await fkb.list();
+            const totalChunks = docList.reduce((sum, d) => sum + d.chunkCount, 0);
+            await this.kbModel.update({ id }, {
+                status: 'ready',
+                documentCount: docCount,
+                chunkCount: totalChunks,
+            });
+            return { documentId, chunkCount: parsed.chunks.length };
+        }
+        catch (error) {
+            await this.kbModel.update({ id }, { status: 'error', lastError: error.message });
+            throw error;
+        }
+    }
+    /**
+     * 索引文档
+     * 对于有 sourcePath 的文档使用 parseDocument() 解析，否则使用内置分块逻辑
+     * 所有分块通过 FileKnowledgeBase.ingest() 存储
+     */
+    async indexDocuments(id, documents) {
+        const kb = await this.get(id);
+        if (!kb) {
+            throw new Error('知识库不存在');
+        }
+        // 更新状态为索引中
+        await this.kbModel.update({ id }, { status: 'indexing', lastError: null });
+        try {
+            const fkb = this.getFileKB(id);
+            let totalChunks = 0;
+            for (const doc of documents) {
+                // 创建文档记录
+                const docEntity = this.docModel.create({
+                    knowledgeBaseId: id,
+                    title: doc.title,
+                    content: doc.content,
+                    sourcePath: doc.sourcePath || '',
+                    sourceType: doc.sourceType || kb.sourceType,
+                    status: 'pending',
+                    meta: doc.meta || null,
+                });
+                const savedDoc = await this.docModel.save(docEntity);
+                const documentId = savedDoc.id;
+                const docIdStr = `doc_${documentId}`;
+                let chunks;
+                // 如果有 sourcePath 且是文件类型，使用 parseDocument() 解析
+                if (doc.sourcePath &&
+                    (doc.sourceType === 'file' || !doc.content)) {
+                    const parsed = await (0, agent_server_1.parseDocument)(doc.sourcePath, docIdStr);
+                    chunks = parsed.chunks.map(c => ({
+                        content: c.content,
+                        metadata: c.metadata || {},
+                    }));
+                }
+                else {
+                    // 使用内置分块逻辑处理文本内容
+                    chunks = this.chunkTextWithConfig(doc.content, docIdStr, kb.chunkSize, kb.chunkOverlap);
+                }
+                // 构建 TextChunk 数组
+                const textChunks = chunks.map((c, i) => ({
+                    id: `${docIdStr}_chunk_${i}`,
+                    docId: docIdStr,
+                    content: c.content,
+                    metadata: {
+                        documentId,
+                        title: doc.title,
+                        sourcePath: doc.sourcePath || '',
+                        chunkIndex: i,
+                        totalChunks: chunks.length,
+                        ...c.metadata,
+                    },
+                }));
+                // 使用 FileKnowledgeBase.ingest() 存储（内部会自动生成 embedding）
+                await fkb.ingest(docIdStr, textChunks);
+                totalChunks += chunks.length;
+                // 更新文档状态
+                await this.docModel.update({ id: documentId }, { status: 'indexed', chunkCount: chunks.length });
+            }
+            // 更新知识库状态
+            const docCount = await this.docModel.count({
+                where: { knowledgeBaseId: id },
+            });
+            await this.kbModel.update({ id }, {
+                status: 'ready',
+                documentCount: docCount,
+                chunkCount: totalChunks,
+            });
+            return {
+                documentCount: docCount,
+                chunkCount: totalChunks,
+            };
+        }
+        catch (error) {
+            await this.kbModel.update({ id }, { status: 'error', lastError: error.message });
+            throw error;
+        }
+    }
+    /**
+     * 重新索引
+     */
+    async reindex(id) {
+        const kb = await this.get(id);
+        if (!kb) {
+            throw new Error('知识库不存在');
+        }
+        // 清除 FileKnowledgeBase 实例缓存（重新创建）
+        this.kbInstances.delete(id);
+        // 获取所有文档
+        const docs = await this.docModel.find({
+            where: { knowledgeBaseId: id },
+        });
+        if (docs.length === 0) {
+            await this.kbModel.update({ id }, { status: 'ready', documentCount: 0, chunkCount: 0 });
+            return { documentCount: 0, chunkCount: 0 };
+        }
+        // 重置文档状态
+        await this.docModel.update({ knowledgeBaseId: id }, { status: 'pending', chunkCount: 0 });
+        // 重新索引
+        return this.indexDocuments(id, docs.map(d => ({
+            title: d.title,
+            content: d.content || '',
+            sourcePath: d.sourcePath,
+            sourceType: d.sourceType,
+            meta: d.meta || undefined,
+        })));
+    }
+    // ===================== 向量搜索 =====================
+    /**
+     * 向量搜索
+     * 使用 FileKnowledgeBase.search(query, topK) 进行语义检索
+     */
+    async search(id, query, options = {}) {
+        const kb = await this.get(id);
+        if (!kb) {
+            throw new Error('知识库不存在');
+        }
+        const fkb = this.getFileKB(id);
+        const topK = options.topK || 5;
+        const scoreThreshold = options.scoreThreshold || 0;
+        // 使用 FileKnowledgeBase.search() 进行向量搜索
+        const results = await fkb.search(query, topK);
+        return results
+            .filter(r => r.score >= scoreThreshold)
+            .map(r => ({
+            content: r.chunk.content,
+            score: r.score,
+            metadata: r.chunk.metadata || {},
+        }));
+    }
+    /**
+     * 使用 EmbeddingVectorIndex 进行向量搜索
+     * 适用于需要自定义向量索引的场景
+     *
+     * @param id 知识库 ID
+     * @param query 查询文本
+     * @param topK 返回结果数
+     */
+    async searchWithVectorIndex(id, query, topK = 5) {
+        const fkb = this.getFileKB(id);
+        const docList = await fkb.list();
+        // 获取所有文档的分块
+        const allChunks = [];
+        for (const doc of docList) {
+            // 通过 FileKnowledgeBase 的 search 获取分块内容
+            const results = await fkb.search('', 9999);
+            for (const r of results) {
+                if (r.chunk.docId === doc.id) {
+                    allChunks.push(r.chunk);
+                }
+            }
+        }
+        // 使用 EmbeddingVectorIndex 构建向量索引
+        const embeddingProvider = this.getEmbeddingProvider();
+        const vectorIndex = new agent_server_1.EmbeddingVectorIndex(embeddingProvider, {
+            textExtractor: (item) => item.metadata?.['content'] || '',
+        });
+        // 构建 VectorItem 数组
+        const items = allChunks.map(chunk => ({
+            id: chunk.id,
+            metadata: { content: chunk.content, ...chunk.metadata },
+            vector: chunk.embedding,
+        }));
+        await vectorIndex.build(items);
+        // 执行搜索
+        const searchResults = await vectorIndex.searchText(query, topK);
+        return searchResults.map(r => ({
+            content: r.item.metadata?.['content'] || '',
+            score: r.score,
+            metadata: r.item.metadata || {},
+        }));
+    }
+    // ===================== 私有方法 =====================
+    /**
+     * 使用配置参数对文本进行分块
+     * 参考 agent-server parseDocument 的 chunkText 逻辑
+     */
+    chunkTextWithConfig(text, docId, chunkSize = 500, chunkOverlap = 50) {
+        if (!text || !text.trim())
+            return [];
+        const chunks = [];
+        // 先按双换行分段（段落级）
+        const paragraphs = text.split(/\n\s*\n/).filter(p => p.trim());
+        let currentChunk = '';
+        let chunkIndex = 0;
+        for (const para of paragraphs) {
+            // 如果当前段落本身超过 chunkSize，按固定大小切分
+            if (para.length > chunkSize) {
+                // 先保存当前累积的内容
+                if (currentChunk.trim()) {
+                    chunks.push({
+                        content: currentChunk.trim(),
+                        metadata: { index: chunkIndex++, docId },
+                    });
+                    currentChunk = '';
+                }
+                // 固定大小切分长段落
+                for (let i = 0; i < para.length; i += chunkSize - chunkOverlap) {
+                    const slice = para.slice(i, i + chunkSize);
+                    chunks.push({
+                        content: slice.trim(),
+                        metadata: { index: chunkIndex++, docId },
+                    });
+                }
+            }
+            else if (currentChunk.length + para.length + 2 >
+                chunkSize) {
+                // 当前块已满，保存并开始新块
+                if (currentChunk.trim()) {
+                    chunks.push({
+                        content: currentChunk.trim(),
+                        metadata: { index: chunkIndex++, docId },
+                    });
+                }
+                currentChunk = para;
+            }
+            else {
+                // 追加到当前块
+                currentChunk = currentChunk
+                    ? `${currentChunk}\n\n${para}`
+                    : para;
+            }
+        }
+        // 保存最后一个块
+        if (currentChunk.trim()) {
+            chunks.push({
+                content: currentChunk.trim(),
+                metadata: { index: chunkIndex++, docId },
+            });
+        }
+        return chunks;
+    }
+    /**
+     * 哈希向量（降级方案）
+     */
+    hashEmbedding(text, dimensions) {
+        const vec = new Array(dimensions).fill(0);
+        const words = text.toLowerCase().split(/\s+/);
+        for (const word of words) {
+            let hash = 0;
+            for (let i = 0; i < word.length; i++) {
+                hash = ((hash << 5) - hash + word.charCodeAt(i)) | 0;
+            }
+            const idx = Math.abs(hash) % dimensions;
+            vec[idx] += 1;
+        }
+        // 归一化
+        const norm = Math.sqrt(vec.reduce((s, v) => s + v * v, 0));
+        if (norm > 0) {
+            for (let i = 0; i < dimensions; i++) {
+                vec[i] /= norm;
+            }
+        }
+        return vec;
+    }
+};
+exports.KnowledgeBaseService = KnowledgeBaseService;
+__decorate([
+    (0, typeorm_1.InjectDataSource)('default'),
+    __metadata("design:type", typeorm_2.DataSource)
+], KnowledgeBaseService.prototype, "dataSource", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", openai_service_1.OpenAIService)
+], KnowledgeBaseService.prototype, "openaiService", void 0);
+__decorate([
+    (0, core_1.Config)('openai'),
+    __metadata("design:type", Object)
+], KnowledgeBaseService.prototype, "openaiConfig", void 0);
+exports.KnowledgeBaseService = KnowledgeBaseService = __decorate([
+    (0, core_1.Provide)()
+], KnowledgeBaseService);

package/dist/service/mcp-server.service.d.ts

@@ -0,0 +1,39 @@
+import { BaseService } from '@cicctencent/midwayjs-base';
+import { DataSource, Repository } from 'typeorm';
+import AIMCPServerEntity from '../model/ai-mcp-server.entity';
+/**
+ * MCP Server 服务
+ * 管理 MCP Server 配置、状态、工具定义等
+ */
+export declare class MCPServerService extends BaseService {
+    dataSource: DataSource;
+    private repo?;
+    get model(): Repository<AIMCPServerEntity>;
+    /** 获取所有 MCP Server */
+    list(applicationId: number, options?: {
+        enabled?: boolean;
+        status?: string;
+    }): Promise<AIMCPServerEntity[]>;
+    /** 获取单个 MCP Server */
+    get(id: number, applicationId?: number): Promise<AIMCPServerEntity>;
+    /** 获取启用的 MCP Server */
+    getEnabled(applicationId: number): Promise<AIMCPServerEntity[]>;
+    /** 创建 MCP Server */
+    create(applicationId: number, data: Partial<AIMCPServerEntity>): Promise<AIMCPServerEntity>;
+    /** 更新 MCP Server */
+    update(id: number, applicationId: number, data: Partial<AIMCPServerEntity>): Promise<AIMCPServerEntity>;
+    /** 删除 MCP Server */
+    delete(id: number, applicationId: number): Promise<void>;
+    /** 启用 MCP Server */
+    enable(id: number, applicationId: number): Promise<AIMCPServerEntity>;
+    /** 禁用 MCP Server */
+    disable(id: number, applicationId: number): Promise<AIMCPServerEntity>;
+    /** 更新连接状态 */
+    updateStatus(id: number, applicationId: number, status: 'connected' | 'disconnected' | 'error', error?: string): Promise<AIMCPServerEntity>;
+    /** 更新工具定义 */
+    updateToolDefinitions(id: number, applicationId: number, tools: any[]): Promise<AIMCPServerEntity>;
+    /** 获取 MCP Server 的工具列表 */
+    getTools(id: number, applicationId: number): Promise<any[]>;
+    /** 批量获取工具定义 */
+    getToolsByServerIds(applicationId: number, ids: (number | string)[]): Promise<any[]>;
+}