@shenghuabi/knowledge 1.0.21

package/knowledge.mjs

@@ -0,0 +1,2856 @@
+// packages/knowledge/knowledge.manager.service.ts
+import {
+  createInjector as createInjector2,
+  inject as inject12,
+  Injector as Injector4,
+  RootStaticInjectOptions as RootStaticInjectOptions2
+} from "static-injector";
+
+// packages/knowledge/const.ts
+import { InjectionToken } from "static-injector";
+function getGraphCollectionName(name) {
+  return `[图谱]${name}-定义`;
+}
+function getActivateCollectionName(name) {
+  return `${name}[激活]`;
+}
+var DICT_PREFIX = "[字典]-";
+var Text2VecToken = new InjectionToken("text2vec");
+var TextSplitterToken = new InjectionToken(
+  "TextSplitter"
+);
+var ConfigToken = new InjectionToken(
+  "config"
+);
+var GetConfigToken = new InjectionToken("getConfig");
+var OCRToken = new InjectionToken("OCR");
+var DirToken = new InjectionToken("dir");
+var ReRankerToken = new InjectionToken("reranker");
+
+// packages/knowledge/dict/dict.knowledge.service.ts
+import { computed, inject as inject3 } from "static-injector";
+import { QdrantClientService as QdrantClientService3 } from "@shenghuabi/knowledge/qdrant";
+import { DictService } from "@shenghuabi/knowledge/file-parser";
+import { v4 as v42 } from "uuid";
+import { promise as fastq2 } from "fastq";
+import {
+  BatchQueue,
+  CacheQueue as CacheQueue2,
+  html2Text,
+  isTruthy,
+  LogToken
+} from "@shenghuabi/knowledge/util";
+
+// packages/knowledge/template.format.ts
+import hbs from "handlebars";
+function interpolate(input, value) {
+  return hbs.compile(input, { noEscape: true, preventIndent: true })(value, {
+    allowProtoPropertiesByDefault: true
+  });
+}
+function entryFormat(payload, knowledge, defaultContent, embedingTemplate) {
+  return embedingTemplate?.enable && embedingTemplate?.value ? interpolate(embedingTemplate.value, {
+    ENTRY: { ...payload, knowledge }
+  }).trim() : defaultContent;
+}
+
+// packages/knowledge/dict/dict.knowledge.service.ts
+import { createNormalizeVfs, path } from "@cyia/vfs2";
+
+// packages/knowledge/knowledge.util.service.ts
+import { inject, RootStaticInjectOptions } from "static-injector";
+import { CacheQueue } from "@shenghuabi/knowledge/util";
+import { promise as fastq } from "fastq";
+import { QdrantClientService } from "@shenghuabi/knowledge/qdrant";
+var KnowledgeUtilService = class extends RootStaticInjectOptions {
+  #qdClient = inject(QdrantClientService);
+  multiDelete(list, filter) {
+    return Promise.all(list.map((item) => this.#qdClient.delete(item, filter)));
+  }
+  updatePointsQueue(collectionName) {
+    return new CacheQueue(
+      fastq(
+        (list) => this.#qdClient.upsert(collectionName, {
+          wait: true,
+          points: list
+        }),
+        8
+      ),
+      20
+    );
+  }
+  async destroyKnowledge(list, vfs) {
+    await Promise.all(
+      list.map(
+        (collectionName) => this.#qdClient.deleteCollection(collectionName)
+      )
+    );
+    if (vfs && await vfs.exists("")) {
+      await vfs.rm("", { recursive: true, force: true });
+    }
+  }
+  export(list) {
+    return Promise.all(
+      list.map(
+        (collectionName) => this.#qdClient.createSnapshot(collectionName).then((result) => ({
+          ...result,
+          collection: collectionName
+        }))
+      )
+    );
+  }
+};
+
+// packages/knowledge/common/define/base.ts
+import * as v from "valibot";
+var BaseKnowledgeConfig = v.object({
+  /** 知识库名 */
+  name: v.string(),
+  activateCollection: v.string()
+});
+
+// packages/knowledge/normal/define/config.ts
+import * as v3 from "valibot";
+
+// packages/knowledge/common/define/embedding.ts
+import * as v2 from "valibot";
+var EmbeddingTemplateDefine = v2.object({
+  enable: v2.boolean(),
+  value: v2.optional(v2.string())
+});
+
+// packages/knowledge/normal/define/config.ts
+var NormalCollectionDefine = v3.object({
+  collectionName: v3.string(),
+  embeddingTemplate: v3.optional(
+    v3.object({
+      entry: v3.optional(EmbeddingTemplateDefine)
+    })
+  ),
+  size: v3.number()
+});
+var NormalKnowledgeConfigDefine = v3.pipe(
+  v3.object({
+    ...BaseKnowledgeConfig.entries,
+    type: v3.optional(v3.literal("normal"), "normal"),
+    collectionList: v3.array(NormalCollectionDefine)
+  }),
+  v3.transform((item) => ({
+    ...item,
+    /** 激活的普通知识库(文件切片) */
+    activateName: getActivateCollectionName(item.name)
+  }))
+);
+
+// packages/knowledge/dict/define/config.ts
+import * as v4 from "valibot";
+var DictCollectionDefine = NormalCollectionDefine;
+var DictKnowledgeConfigDefine = v4.pipe(
+  v4.object({
+    ...BaseKnowledgeConfig.entries,
+    type: v4.optional(v4.literal("dict"), "dict"),
+    collectionList: v4.array(DictCollectionDefine),
+    /** 词条提取 */
+    extractorWord: v4.optional(v4.boolean()),
+    /** 图像识别 */
+    useOcr: v4.optional(v4.boolean())
+  }),
+  v4.transform((item) => ({
+    ...item,
+    /** 激活的普通知识库(文件切片) */
+    activateName: getActivateCollectionName(item.name)
+  }))
+);
+
+// packages/knowledge/dict/dict.knowledge.service.ts
+import * as v5 from "valibot";
+
+// packages/knowledge/common/common.knowledge.service.ts
+import { inject as inject2 } from "static-injector";
+import { QdrantClientService as QdrantClientService2 } from "@shenghuabi/knowledge/qdrant";
+var CommonKnowledgeService = class {
+  #qdClient = inject2(QdrantClientService2);
+  #config = inject2(
+    ConfigToken
+  );
+  #text2vec = inject2(Text2VecToken);
+  #reranker = inject2(ReRankerToken);
+  async searchChunk(text, filter, options) {
+    const queryResult = await this.#qdClient.search(
+      this.#config().activateName,
+      {
+        limit: options?.limit ? options.limit * this.#reranker.getQueryRatio() : void 0,
+        filter,
+        with_payload: true,
+        with_vector: false,
+        score_threshold: options?.score,
+        offset: options?.offset,
+        vector: {
+          name: "chunk",
+          vector: await this.#text2vec(text, this.#config().activateCollection)
+        }
+      }
+    );
+    const resultList = await this.#reranker.run({
+      value: text,
+      docs: queryResult.map(
+        (item) => item.payload?.["embeddingChunk"]
+      )
+    });
+    return resultList.slice(0, options?.limit).map(({ index }) => queryResult[index]);
+  }
+  getCollection() {
+    return this.#qdClient.getCollection(this.#config().activateName);
+  }
+};
+
+// packages/knowledge/dict/dict.knowledge.service.ts
+var DictKnowledgeService = class extends CommonKnowledgeService {
+  #text2vec = inject3(Text2VecToken);
+  #reranker = inject3(ReRankerToken);
+  #textSplitter = inject3(TextSplitterToken);
+  #ocr = inject3(OCRToken, { optional: true }) || void 0;
+  #config = inject3(ConfigToken);
+  #vfs = computed(() => createNormalizeVfs({ dir: this.#dir() }));
+  #qdClient = inject3(QdrantClientService3);
+  #dict = inject3(DictService);
+  #util = inject3(KnowledgeUtilService);
+  #dir = inject3(DirToken);
+  #log = inject3(LogToken);
+  formatCollection(input) {
+    return v5.parse(DictCollectionDefine, input);
+  }
+  async #createCollection(collection) {
+    const { exists } = await this.#qdClient.collectionExists(
+      collection.collectionName
+    );
+    if (exists) {
+      throw new Error(`集合${collection.collectionName}已存在`);
+    }
+    await this.#qdClient.createCollection(collection.collectionName, {
+      vectors: {
+        chunk: {
+          size: collection.size,
+          distance: "Cosine",
+          on_disk: true
+        },
+        word: {
+          size: collection.size,
+          distance: "Cosine",
+          on_disk: true
+        }
+      }
+    });
+    await this.#qdClient.createPayloadKeywordIndex(
+      collection.collectionName,
+      "word"
+    );
+    await this.#qdClient.createPayloadKeywordIndex(
+      collection.collectionName,
+      "chunk"
+    );
+    await this.#qdClient.createPayloadKeywordIndex(
+      collection.collectionName,
+      "content"
+    );
+  }
+  /** 只创建这一次,剩下的都是插入或更新 */
+  async create(collection) {
+    await this.#createCollection(collection);
+    await this.#qdClient.setActivateCollection(
+      this.#config().name,
+      this.#config().activateName
+    );
+  }
+  async #getImportQueue(collection, assetHandle) {
+    const assetFolder = path.join(this.#dir(), "assets");
+    const contentBatchQueue = new BatchQueue(
+      (str) => this.#text2vec(str, collection.collectionName)
+    );
+    let sum = 0;
+    const updateCacheQueue = this.#util.updatePointsQueue(collection.collectionName);
+    let updateError;
+    updateCacheQueue.queue.error((error) => {
+      if (error) {
+        updateError = error;
+        updateCacheQueue.queue.killAndDrain();
+      }
+    });
+    const importCacheQueue = new CacheQueue2(
+      fastq2(async (wordList) => {
+        const preMergeList = (await Promise.all(
+          wordList.map(async (entryItem) => {
+            if (assetHandle) {
+              if (this.#config().extractorWord) {
+                this.#vfs().write(entryItem.word, entryItem.content);
+              }
+            }
+            const formatedContent = assetHandle ? await this.#formatContent(entryItem, assetFolder, {
+              useOcr: this.#config().useOcr,
+              refReplace: true
+            }) : entryItem.formatedContent || entryItem.content;
+            const splitContentList = (await this.#textSplitter(
+              formatedContent,
+              {
+                ...entryItem,
+                formatedContent
+              },
+              collection.collectionName
+            )).filter((item) => !!item.pageContent.trim());
+            if (!splitContentList.length) {
+              return void 0;
+            }
+            return {
+              word: entryItem.word,
+              contentList: splitContentList.map((item) => {
+                const pageContent = item.pageContent.trim();
+                const metadata = {
+                  ...item.metadata,
+                  chunk: pageContent
+                };
+                const embeddingChunk = entryFormat(
+                  metadata,
+                  this.#config().name,
+                  `${metadata["word"]}
+${pageContent}`,
+                  collection.embeddingTemplate?.entry
+                );
+                if (!embeddingChunk) {
+                  this.#log.warn(
+                    `内容格式化后内容为空,跳过
+${JSON.stringify({ payload: metadata, knowledge: this.#config().name, pageContent })}`
+                  );
+                  return;
+                }
+                metadata["embeddingChunk"] = embeddingChunk;
+                return {
+                  chunk: embeddingChunk,
+                  metadata
+                };
+              }).filter(isTruthy)
+            };
+          })
+        )).filter(isTruthy).filter((item) => !!item.contentList.length);
+        if (!preMergeList.length) {
+          return;
+        }
+        const [wordVecResult, contentVecResult] = await Promise.all([
+          this.#text2vec(
+            preMergeList.map((item) => item.word),
+            collection.collectionName
+          ),
+          contentBatchQueue.then(
+            Promise.all(
+              preMergeList.flatMap(
+                (item) => item.contentList.map(
+                  (item2) => contentBatchQueue.push(item2.chunk)
+                )
+              )
+            )
+          )
+        ]);
+        let startIndex = 0;
+        for (let i = 0; i < preMergeList.length; i++) {
+          const preData = preMergeList[i];
+          const wordVector = wordVecResult[i];
+          const endIndex = startIndex + preData.contentList.length;
+          const extResult = contentVecResult.slice(startIndex, endIndex);
+          startIndex = endIndex;
+          extResult.forEach((item, j) => {
+            updateCacheQueue.push({
+              id: v42(),
+              vector: {
+                word: wordVector,
+                chunk: extResult[j]
+              },
+              payload: preData.contentList[j].metadata
+            });
+          });
+        }
+        sum += wordList.length;
+        this.#log.info(`已导入 ${sum} 条`);
+      }, 2),
+      256
+    );
+    importCacheQueue.queue.error((error) => {
+      if (error) {
+        updateError = error;
+        importCacheQueue.queue.killAndDrain();
+      }
+    });
+    return {
+      importQueue: importCacheQueue,
+      getSum: () => sum,
+      updateQueue: updateCacheQueue,
+      getError() {
+        return updateError;
+      }
+    };
+  }
+  async importDict(input) {
+    const collection = this.#config().collectionList[0];
+    return this.#dict.importDict(this.#config().name, this.#dir(), input).then(async (generator) => {
+      const { importQueue, getSum, updateQueue, getError } = await this.#getImportQueue(collection, true);
+      for await (const item of generator) {
+        importQueue.push(item);
+      }
+      importQueue.complete();
+      await importQueue.queue.drained();
+      updateQueue.complete();
+      await updateQueue.queue.drained();
+      const error = getError();
+      if (error) {
+        throw error;
+      }
+      return getSum();
+    }).catch(async (rej) => {
+      this.#log.error(`导入失败`, rej);
+      await this.destroy();
+      throw rej;
+    });
+  }
+  async #formatContent(wordItem, assetFolder, options) {
+    const result = await html2Text(wordItem.htmlContent ?? wordItem.content, {
+      useOcr: options.useOcr,
+      ocrFn: this.#ocr,
+      assetFolder
+    });
+    return options.refReplace ? result.replaceAll(`～`, wordItem.word) : result;
+  }
+  async addCollection(collection) {
+    await this.#createCollection(collection);
+    const { importQueue, updateQueue, getError } = await this.#getImportQueue(
+      collection,
+      false
+    );
+    try {
+      let offset;
+      const activateCollectionName = this.#config().activateName;
+      const wordSet = /* @__PURE__ */ new Set();
+      do {
+        const { points, next_page_offset } = await this.#qdClient.scroll(
+          activateCollectionName,
+          {
+            limit: 5e3,
+            with_payload: true,
+            offset
+          }
+        );
+        for (const point of points) {
+          const id = `${point.payload["word"]}|${point.payload["formatedContent"] || point.payload["content"]}`;
+          if (wordSet.has(id)) {
+            continue;
+          }
+          wordSet.add(id);
+          importQueue.push(point.payload);
+        }
+        offset = next_page_offset;
+      } while (offset);
+      importQueue.complete();
+      await importQueue.queue.drained();
+      updateQueue.complete();
+      await updateQueue.queue.drained();
+      const error = getError();
+      if (error) {
+        throw error;
+      }
+    } catch (error) {
+      await this.#qdClient.deleteCollection(collection.collectionName);
+      throw error;
+    }
+    await this.#qdClient.setActivateCollection(
+      collection.collectionName,
+      this.#config().activateName
+    );
+  }
+  async deleteCollection(collectionName) {
+    const isActivate = this.#config().activateCollection === collectionName;
+    if (isActivate) {
+      return false;
+    }
+    const collection = this.#config().collectionList.find(
+      (item) => item.collectionName === collectionName
+    );
+    if (!collection) {
+      return false;
+    }
+    await this.#qdClient.deleteCollection(collectionName);
+    return true;
+  }
+  async changeActivateCollection(collectionName) {
+    await this.#qdClient.setActivateCollection(
+      collectionName,
+      this.#config().activateName
+    );
+  }
+  export() {
+    return this.#util.export(
+      this.#config().collectionList.map(({ collectionName }) => collectionName)
+    );
+  }
+  async destroy() {
+    return this.#util.destroyKnowledge(
+      this.#config().collectionList.map(({ collectionName }) => collectionName),
+      this.#vfs()
+    );
+  }
+  async searchWord(text, options) {
+    const queryResult = await this.#qdClient.search(
+      this.#config().activateName,
+      {
+        limit: options.limit ? options.limit * this.#reranker.getQueryRatio() : void 0,
+        with_payload: true,
+        with_vector: false,
+        score_threshold: options.score,
+        offset: options.offset,
+        vector: {
+          name: "word",
+          vector: await this.#text2vec(text, this.#config().activateCollection)
+        }
+      }
+    );
+    const resultList = await this.#reranker.run({
+      value: text,
+      docs: queryResult.map((item) => item.payload?.["word"])
+    });
+    return resultList.slice(0, options?.limit).map(({ index }) => queryResult[index]);
+  }
+  /** 当普通数据库用 */
+  matchWord(text, options) {
+    return this.#qdClient.scroll(this.#config().activateName, {
+      limit: options.limit,
+      filter: {
+        must: {
+          key: "word",
+          match: {
+            value: text
+          }
+        }
+      },
+      with_payload: true,
+      with_vector: false
+    });
+  }
+};
+
+// packages/knowledge/graph/graph.knowledge.service.ts
+import { inject as inject7, Injector } from "static-injector";
+import { QdrantClientService as QdrantClientService7 } from "@shenghuabi/knowledge/qdrant";
+import { LogToken as LogToken4 } from "@shenghuabi/knowledge/util";
+import { promise as fastq4 } from "fastq";
+
+// packages/knowledge/graph/const.ts
+import { InjectionToken as InjectionToken2 } from "static-injector";
+var ContentParserToken = new InjectionToken2(
+  "ContentParser"
+);
+var QueryParamsToken = new InjectionToken2("QueryParams");
+var RagChatToken = new InjectionToken2("RagChat");
+var CHAT_INPUT = `$$INPUT$$`;
+
+// packages/knowledge/graph/vecotr-format.ts
+function edgeVectorString(options) {
+  return `${options.keywords?.join(",") ?? ""},${options.source},${options.target},${options.description}`;
+}
+function nodeVectorString(options) {
+  return `${options.name},${options.description}`;
+}
+
+// packages/knowledge/graph/graph.knowledge.service.ts
+import { v4 as v44 } from "uuid";
+
+// packages/knowledge/normal/normal.knowledge.service.ts
+import { QdrantClientService as QdrantClientService4 } from "@shenghuabi/knowledge/qdrant";
+import { computed as computed2, inject as inject4 } from "static-injector";
+import { createNormalizeVfs as createNormalizeVfs2 } from "@cyia/vfs2";
+import { promise as fastq3 } from "fastq";
+import { getHash, isTruthy as isTruthy2, runInEmbeddingContext } from "@shenghuabi/knowledge/util";
+import { LogToken as LogToken2 } from "@shenghuabi/knowledge/util";
+import * as v6 from "valibot";
+var NormalKnowledgeService = class extends CommonKnowledgeService {
+  #text2vec = inject4(Text2VecToken);
+  #textSplitter = inject4(TextSplitterToken);
+  #config = inject4(ConfigToken);
+  #util = inject4(KnowledgeUtilService);
+  #qdClient = inject4(QdrantClientService4);
+  #channel = inject4(LogToken2);
+  #vfs = computed2(() => createNormalizeVfs2({ dir: this.#dir() }));
+  #dir = inject4(DirToken);
+  KeyWordIndex = ["fileName"];
+  getPayload(fileName, content) {
+    return { fileName };
+  }
+  formatCollection(input) {
+    return v6.parse(NormalCollectionDefine, input);
+  }
+  async createCollection(collection) {
+    this.#channel.info(
+      `创建集合:${this.#config().name};嵌入长度:${collection.size}`
+    );
+    const { exists } = await this.#qdClient.collectionExists(
+      collection.collectionName
+    );
+    if (exists) {
+      throw new Error(`集合${collection.collectionName}已存在`);
+    }
+    await this.#qdClient.createCollection(collection.collectionName, {
+      vectors: {
+        chunk: {
+          size: collection.size,
+          distance: "Cosine",
+          on_disk: true
+        }
+      }
+    });
+    this.#channel.info(`创建索引`);
+    for (const keyword of this.KeyWordIndex) {
+      await this.#qdClient.createPayloadKeywordIndex(
+        collection.collectionName,
+        keyword
+      );
+    }
+  }
+  /** 创建知识库 */
+  async create(collection) {
+    this.#channel.info(`准备创建知识库:${this.#config().name}`);
+    await this.createCollection(collection);
+    await this.#qdClient.setActivateCollection(
+      collection.collectionName,
+      this.#config().activateName
+    );
+    this.#channel.info(`创建完成:${this.#config().name}`);
+  }
+  async insertItemOnly(fileName, content, collectionList) {
+    return await runInEmbeddingContext(
+      (t2v) => Promise.all(
+        collectionList.map(async (collectionItem) => {
+          const chunkList = (await this.#textSplitter(
+            content,
+            this.getPayload(fileName, content),
+            collectionItem.collectionName
+          )).filter((item) => !!item.pageContent.trim());
+          if (!chunkList.length) {
+            return;
+          }
+          const points = await Promise.all(
+            chunkList.map(async (item) => {
+              const pageContent = item.pageContent.trim();
+              const id = getHash(pageContent);
+              const payload = {
+                ...item.metadata,
+                chunk: pageContent,
+                hash: id
+              };
+              const embeddingChunk = entryFormat(
+                payload,
+                this.#config().name,
+                pageContent,
+                collectionItem.embeddingTemplate?.entry
+              );
+              if (!embeddingChunk) {
+                this.#channel.warn(
+                  `内容格式化后内容为空,跳过
+${JSON.stringify({ payload, knowledge: this.#config().name, pageContent })}`
+                );
+                return;
+              }
+              payload["embeddingChunk"] = embeddingChunk;
+              return {
+                id,
+                vector: {
+                  chunk: await t2v(
+                    embeddingChunk,
+                    collectionItem.collectionName
+                  )
+                },
+                payload
+              };
+            })
+          ).then((list) => list.filter(isTruthy2));
+          if (points.length) {
+            await this.#qdClient.upsert(collectionItem.collectionName, {
+              wait: true,
+              points
+            });
+            return points;
+          }
+          return;
+        })
+      ).then((list) => list.filter(isTruthy2)),
+      this.#text2vec
+    );
+  }
+  async _insertItem(fileName, content) {
+    if (await this.#vfs().exists(fileName)) {
+      return false;
+    }
+    await this.#vfs().writeFile(fileName, content);
+    return await this.insertItemOnly(
+      fileName,
+      content,
+      this.#config().collectionList
+    );
+  }
+  async insertItem(fileName, content, signal2) {
+    await this._insertItem(fileName, content);
+  }
+  async deleteItem(fileName) {
+    await this.#util.multiDelete(
+      this.#config().collectionList.map((item) => item.collectionName),
+      {
+        filter: {
+          must: [{ key: "fileName", match: { value: fileName } }],
+          should: null
+        }
+      }
+    );
+    await this.#vfs().delete(fileName, { force: true });
+  }
+  async updateItem(fileName, content) {
+    await this.deleteItem(fileName);
+    await this.insertItem(fileName, content);
+  }
+  async addCollection(collection) {
+    const list = await this.#vfs().exists("") ? await this.#vfs().readdir("") : [];
+    await this.createCollection(collection);
+    const queue = fastq3(async (fileName) => {
+      const content = await this.#vfs().readContent(fileName);
+      if (typeof content !== "string" || !content) {
+        return;
+      }
+      await this.insertItemOnly(fileName, content, [collection]);
+    }, 20);
+    let queueError;
+    queue.error((error) => {
+      if (error) {
+        queueError = error;
+        queue.killAndDrain();
+      }
+    });
+    try {
+      for (const item of list) {
+        queue.push(item);
+      }
+      await queue.drained();
+      if (queueError) {
+        throw queueError;
+      }
+    } catch (error) {
+      await this.#qdClient.deleteCollection(collection.collectionName);
+      throw error;
+    }
+    await this.#qdClient.setActivateCollection(
+      collection.collectionName,
+      this.#config().activateName
+    );
+  }
+  // 激活collection不可删除,所以这里不应该有删除切换的问题
+  async deleteCollection(collectionName) {
+    const isActivate = this.#config().activateCollection === collectionName;
+    if (isActivate) {
+      return false;
+    }
+    const collection = this.#config().collectionList.find(
+      (item) => item.collectionName === collectionName
+    );
+    if (!collection) {
+      return false;
+    }
+    await this.#qdClient.deleteCollection(collectionName);
+    return true;
+  }
+  async changeActivateCollection(collectionName) {
+    await this.#qdClient.setActivateCollection(
+      collectionName,
+      this.#config().activateName
+    );
+  }
+  export() {
+    return this.#util.export(
+      this.#config().collectionList.map(({ collectionName }) => collectionName)
+    );
+  }
+  async destroy() {
+    return this.#util.destroyKnowledge(
+      this.#config().collectionList.map(({ collectionName }) => collectionName),
+      this.#vfs()
+    );
+  }
+};
+
+// packages/knowledge/graph/define/config.ts
+import * as v7 from "valibot";
+var GraphCollectionDefine = v7.pipe(
+  v7.object({
+    collectionName: v7.string(),
+    size: v7.number(),
+    embeddingTemplate: v7.optional(
+      v7.object({
+        entry: v7.optional(EmbeddingTemplateDefine),
+        node: v7.optional(EmbeddingTemplateDefine),
+        edge: v7.optional(EmbeddingTemplateDefine)
+      })
+    )
+  }),
+  v7.transform((collection) => ({
+    ...collection,
+    graphCollectionName: getGraphCollectionName(collection.collectionName)
+  }))
+);
+var GraphKnowledgeConfigDefine = v7.pipe(
+  v7.object({
+    ...BaseKnowledgeConfig.entries,
+    type: v7.optional(v7.literal("normal-graph"), "normal-graph"),
+    maxChunkAsync: v7.number(),
+    collectionList: v7.array(GraphCollectionDefine)
+  }),
+  v7.transform((input) => ({
+    ...input,
+    /** 激活的普通知识库(文件切片) */
+    activateName: getActivateCollectionName(input.name),
+    /** 激活的图数据库 */
+    activateGraphName: getActivateCollectionName(
+      getGraphCollectionName(input.name)
+    )
+  }))
+);
+
+// packages/knowledge/graph/graph.knowledge.service.ts
+import * as v11 from "valibot";
+
+// packages/knowledge/graph/graph.util.service.ts
+import { runInEmbeddingContext as runInEmbeddingContext2 } from "@shenghuabi/knowledge/util";
+import { inject as inject5 } from "static-injector";
+import { QdrantClientService as QdrantClientService5 } from "@shenghuabi/knowledge/qdrant";
+
+// packages/knowledge/graph/define/define.ts
+import { uniqBy } from "lodash-es";
+import * as v8 from "valibot";
+
+// packages/knowledge/graph/util.ts
+function getEdgeName(source, target) {
+  return `${source},${target}`;
+}
+
+// packages/knowledge/graph/define/define.ts
+import { v4 as v43 } from "uuid";
+var ENTITY_DEFINE = v8.object({
+  name: v8.string(),
+  description: v8.optional(v8.string(), ""),
+  /** 实体类型 */
+  type: v8.string()
+});
+var ENTITY_RELATION_DEFINE = v8.object({
+  source: v8.string(),
+  target: v8.string(),
+  description: v8.optional(v8.string(), ""),
+  strength: v8.optional(v8.number(), 5),
+  keywords: v8.optional(
+    v8.union([
+      v8.pipe(
+        v8.string(),
+        v8.transform((str) => str.split(",").map((item) => item.trim()))
+      ),
+      v8.array(v8.string())
+    ])
+  )
+});
+var EntityExtraDefine = v8.object({
+  entity: v8.pipe(
+    v8.nullish(v8.array(ENTITY_DEFINE), []),
+    v8.transform(
+      (list) => uniqBy(
+        (list || []).filter((item) => !!item.name && !!item.description),
+        (item) => `${item.name}|${item.type}|${item.description}`
+      )
+    )
+  ),
+  entity_relation: v8.pipe(
+    v8.nullish(v8.array(ENTITY_RELATION_DEFINE), []),
+    v8.transform(
+      (list) => uniqBy(
+        (list || []).filter(
+          (item) => !!item.source && !!item.target && !!item.description
+        ),
+        (item) => `${item.source}|${item.target}|${item.description}`
+      )
+    )
+  ),
+  keyword: v8.pipe(
+    v8.nullish(v8.array(v8.string()), []),
+    v8.transform((item) => item.map((item2) => item2.trim()))
+  )
+});
+var NodePayloadDefine = v8.object({
+  ...ENTITY_DEFINE.entries,
+  kind: v8.optional(v8.literal("node"), "node"),
+  id: v8.string(),
+  chunkId: v8.string(),
+  fileName: v8.string()
+});
+var NodeItemDefine = v8.pipe(
+  v8.omit(NodePayloadDefine, ["kind"]),
+  v8.transform((data) => ({ ...data, kind: "node" }))
+);
+var NodePayloadNewDefine = v8.pipe(
+  v8.object({
+    ...v8.omit(NodePayloadDefine, ["id"]).entries,
+    embeddingChunk: v8.string()
+  })
+);
+var NodeItemNewDefine = v8.pipe(
+  v8.object({
+    ...v8.omit(NodePayloadDefine, ["kind", "id"]).entries,
+    id: v8.optional(NodePayloadDefine.entries.id, () => v43())
+  }),
+  v8.transform((data) => ({ ...data, kind: "node" }))
+);
+var EdgePayloadDefine = v8.object({
+  ...ENTITY_RELATION_DEFINE.entries,
+  chunkId: v8.string(),
+  kind: v8.optional(v8.literal("edge"), "edge"),
+  name: v8.string(),
+  fileName: v8.string(),
+  id: v8.string()
+});
+var EdgeItemDefine = v8.pipe(
+  v8.omit(EdgePayloadDefine, ["kind", "name"]),
+  v8.transform((data) => ({
+    ...data,
+    name: getEdgeName(data.source, data.target),
+    kind: "edge"
+  }))
+);
+var EdgePayloadNewDefine = v8.pipe(
+  v8.object({
+    ...v8.omit(EdgePayloadDefine, ["name", "id"]).entries,
+    embeddingChunk: v8.string()
+  }),
+  v8.transform((data) => ({
+    ...data,
+    name: getEdgeName(data.source, data.target)
+  }))
+);
+var EdgeItemNewDefine = v8.pipe(
+  v8.object({
+    ...v8.omit(EdgePayloadDefine, ["kind", "name", "id"]).entries,
+    id: v8.optional(NodePayloadDefine.entries.id, () => v43())
+  }),
+  v8.transform((data) => ({
+    ...data,
+    name: getEdgeName(data.source, data.target),
+    kind: "edge"
+  }))
+);
+var KnowledgeGraphCreateDefine = v8.object({
+  fileName: v8.string(),
+  chunkId: v8.string(),
+  nodeList: v8.optional(v8.array(ENTITY_DEFINE), []),
+  edgeList: v8.optional(v8.array(ENTITY_RELATION_DEFINE), [])
+});
+var KeywordPayloadNewDefine = v8.pipe(
+  v8.object({
+    kind: v8.optional(v8.literal("keyword"), "keyword"),
+    keyword: v8.string(),
+    chunkId: v8.string(),
+    fileName: v8.string()
+  })
+);
+
+// packages/knowledge/graph/graph.util.service.ts
+import * as v9 from "valibot";
+var GraphKnowledgeUtilService = class {
+  #qdClient = inject5(QdrantClientService5);
+  #config = inject5(ConfigToken);
+  #text2vec = inject5(Text2VecToken);
+  updateContext(fn) {
+    return runInEmbeddingContext2(async (t2v) => {
+      const result = await fn();
+      const requstList = [];
+      if (result.upsert) {
+        requstList.push(
+          this.#config().collectionList.map(
+            async ({
+              graphCollectionName,
+              collectionName,
+              embeddingTemplate
+            }) => {
+              const list = [];
+              if (result.upsert?.nodes?.length) {
+                list.push(
+                  Promise.all(
+                    result.upsert?.nodes.map(async (item) => {
+                      const embeddingChunk = entryFormat(
+                        item.payload,
+                        this.#config().name,
+                        nodeVectorString(item.payload),
+                        embeddingTemplate?.node
+                      );
+                      return {
+                        id: item.id,
+                        payload: v9.parse(NodePayloadNewDefine, {
+                          ...item.payload,
+                          embeddingChunk
+                        }),
+                        vector: {
+                          chunk: await t2v(embeddingChunk, collectionName)
+                        }
+                      };
+                    })
+                  ).then(
+                    (points) => this.#qdClient.upsert(graphCollectionName, { points })
+                  )
+                );
+              }
+              if (result.upsert?.edges?.length) {
+                list.push(
+                  Promise.all(
+                    result.upsert?.edges.map(async (item) => {
+                      const embeddingChunk = entryFormat(
+                        item.payload,
+                        this.#config().name,
+                        edgeVectorString(item.payload),
+                        embeddingTemplate?.edge
+                      );
+                      return {
+                        id: item.id,
+                        payload: v9.parse(EdgePayloadNewDefine, {
+                          ...item.payload,
+                          embeddingChunk
+                        }),
+                        vector: {
+                          chunk: await t2v(embeddingChunk, collectionName)
+                        }
+                      };
+                    })
+                  ).then(
+                    (points) => this.#qdClient.upsert(graphCollectionName, { points })
+                  )
+                );
+              }
+              if (result.upsert?.keywords?.length) {
+                list.push(
+                  Promise.all(
+                    result.upsert?.keywords.map(async (item) => ({
+                      id: item.id,
+                      payload: v9.parse(KeywordPayloadNewDefine, item.payload),
+                      vector: {
+                        chunk: await t2v(item.payload.keyword, collectionName)
+                      }
+                    }))
+                  ).then(
+                    (points) => this.#qdClient.upsert(graphCollectionName, { points })
+                  )
+                );
+              }
+              return Promise.all(list);
+            }
+          )
+        );
+      }
+      if (result.delete) {
+        requstList.push(
+          this.#config().collectionList.map(
+            async ({ graphCollectionName, collectionName }) => {
+              await Promise.all(
+                [result.delete?.nodes, result.delete?.edges].map(
+                  (deleteData) => {
+                    if (Array.isArray(deleteData)) {
+                      if (deleteData.length) {
+                        return this.#qdClient.delete(graphCollectionName, {
+                          points: deleteData.map((item) => item.id)
+                        });
+                      }
+                    } else if (deleteData) {
+                      return this.#qdClient.delete(graphCollectionName, {
+                        filter: deleteData.filter
+                      });
+                    }
+                  }
+                )
+              );
+            }
+          )
+        );
+      }
+      return Promise.all(requstList.flat());
+    }, this.#text2vec);
+  }
+};
+
+// packages/knowledge/graph/graph.local.service.ts
+import { QdrantClientService as QdrantClientService6 } from "@shenghuabi/knowledge/qdrant";
+import { computed as computed3, inject as inject6, signal, untracked } from "static-injector";
+import Graph from "graphology";
+import * as v10 from "valibot";
+import { LogToken as LogToken3 } from "@shenghuabi/knowledge/util";
+var GraphLocalService = class {
+  #qdClient = inject6(QdrantClientService6);
+  #config = inject6(ConfigToken);
+  #limit = 5e3;
+  #graph;
+  #log = inject6(LogToken3);
+  update$ = signal(0);
+  graphExport$$ = computed3(() => {
+    this.update$();
+    return this.#graph.export();
+  });
+  getGraph() {
+    return this.#graph;
+  }
+  loadDataInitGraph$$ = computed3(() => {
+    this.initGraph();
+    return untracked(() => this.loadingData());
+  });
+  /** 只初始化数据 */
+  initGraph() {
+    this.#graph = new Graph();
+    return this.#graph;
+  }
+  #getEdgesFromSource(name) {
+    try {
+      return this.#graph.outEdges(name);
+    } catch (error) {
+      this.#log.warn(error);
+      return [];
+    }
+  }
+  #getEdgesFromTarget(name) {
+    try {
+      return this.#graph.inEdges(name);
+    } catch (error) {
+      this.#log.warn(error);
+      return [];
+    }
+  }
+  getTargetListFromSource(name) {
+    return this.#graph.hasNode(name) ? this.#getEdgesFromSource(name).flatMap(
+      (name2) => this.#graph.getTargetAttributes(name2).list
+    ) : [];
+  }
+  edgeToNode(item, type) {
+    return {
+      name: item[type],
+      description: item.description,
+      type: "未知",
+      chunkId: item.chunkId,
+      fileName: item.fileName
+    };
+  }
+  createOrUpdateNodeAttr(item) {
+    const payload = v10.parse(NodeItemNewDefine, item);
+    if (this.#graph.hasNode(payload.name)) {
+      const obj = this.#graph.getNodeAttributes(payload.name);
+      for (let index = 0; index < obj.list.length; index++) {
+        const item2 = obj.list[index];
+        if (item2.id === payload.id) {
+          obj.list[index] = payload;
+          this.#graph.replaceNodeAttributes(payload.name, obj);
+          return;
+        }
+      }
+      obj.list.push(payload);
+      this.#graph.replaceNodeAttributes(payload.name, obj);
+    } else {
+      this.#graph.addNode(payload.name, {
+        list: [payload],
+        name: payload.name
+      });
+    }
+  }
+  // source/target可能不存在,需要临时节点
+  createOrUpdateEdgeAttr(item) {
+    const payload = v10.parse(EdgeItemNewDefine, item);
+    if (this.#graph.hasEdge(payload.name)) {
+      const obj = this.#graph.getEdgeAttributes(payload.name);
+      for (let index = 0; index < obj.list.length; index++) {
+        const item2 = obj.list[index];
+        if (item2.id === payload.id) {
+          obj.list[index] = payload;
+          this.#graph.replaceEdgeAttributes(item2.name, obj);
+          return;
+        }
+      }
+      obj.list.push(payload);
+      this.#graph.replaceEdgeAttributes(payload.name, obj);
+    } else {
+      if (!this.#graph.hasNode(item.source)) {
+        this.#graph.addNode(item.source, {
+          list: [v10.parse(NodeItemNewDefine, this.edgeToNode(item, "source"))],
+          name: item.source
+        });
+      }
+      if (!this.#graph.hasNode(item.target)) {
+        this.#graph.addNode(item.target, {
+          list: [v10.parse(NodeItemNewDefine, this.edgeToNode(item, "target"))],
+          name: item.target
+        });
+      }
+      this.#graph.addEdgeWithKey(payload.name, item.source, item.target, {
+        list: [payload],
+        name: payload.name,
+        source: payload.source,
+        target: payload.target
+      });
+    }
+  }
+  #deleteNodeAttr(payload) {
+    if (this.#graph.hasNode(payload.name)) {
+      const attr = this.#graph.getNodeAttributes(payload.name);
+      const index = attr.list.findIndex((item) => item.id === payload.id);
+      if (index !== -1) {
+        attr.list.splice(index, 1);
+        if (attr.list.length === 0) {
+          this.#graph.dropNode(payload.name);
+        } else {
+          this.#graph.replaceNodeAttributes(payload.name, attr);
+        }
+      }
+    }
+  }
+  #deleteEdgeAttr(item) {
+    const name = getEdgeName(item.source, item.target);
+    if (!this.#graph.hasEdge(name)) {
+      return;
+    }
+    const attr = this.#graph.getEdgeAttributes(name);
+    for (let index = 0; index < attr.list.length; index++) {
+      const edgeItem = attr.list[index];
+      if (edgeItem.id === item.id) {
+        attr.list.splice(index, 1);
+        if (attr.list.length === 0) {
+          this.#graph.dropEdge(name);
+        } else {
+          this.#graph.replaceEdgeAttributes(name, attr);
+        }
+        return;
+      }
+    }
+  }
+  #updateGraph(payload, update) {
+    if (payload.kind === "node") {
+      this.createOrUpdateNodeAttr(payload);
+    } else if (payload.kind === "edge") {
+      this.createOrUpdateEdgeAttr(payload);
+    }
+  }
+  async loadingData() {
+    let offset;
+    const [nodeList, edgeList] = await Promise.all(
+      ["node", "edge"].map(async (kind) => {
+        const nodePoints = [];
+        do {
+          const { points, next_page_offset } = await this.#qdClient.scroll(
+            this.#config().activateGraphName,
+            {
+              limit: this.#limit,
+              filter: {
+                must: {
+                  key: "kind",
+                  match: {
+                    value: kind
+                  }
+                }
+              },
+              with_payload: true,
+              offset
+            }
+          );
+          nodePoints.push(() => {
+            for (const item of points) {
+              this.#updateGraph({ ...item.payload, id: item.id });
+            }
+          });
+          offset = next_page_offset;
+        } while (offset);
+        return nodePoints;
+      })
+    );
+    nodeList.forEach((fn) => fn());
+    edgeList.forEach((fn) => fn());
+  }
+  /** 一个节点分多个,需要删除原来的节点和边,然后插入
+   * 拆分后的节点有可能是存在的
+   */
+  async splitNode(options) {
+    const nodeAttr = this.#graph.getNodeAttributes(options.node);
+    options.list.map((replaceNodeName) => {
+      nodeAttr.list.forEach((item) => {
+        this.createOrUpdateNodeAttr({ ...item, name: replaceNodeName });
+      });
+    });
+    const sourceEdges = this.#getEdgesFromSource(options.node);
+    const targetEdges = this.#getEdgesFromTarget(options.node);
+    for (const edge of sourceEdges) {
+      const attr = this.#graph.getEdgeAttributes(edge);
+      for (const replaceNodeName of options.list) {
+        attr.list.forEach((attrItem) => {
+          this.createOrUpdateEdgeAttr({ ...attrItem, source: replaceNodeName });
+        });
+      }
+    }
+    for (const edge of targetEdges) {
+      const attr = this.#graph.getEdgeAttributes(edge);
+      for (const replaceNodeName of options.list) {
+        attr.list.forEach((attrItem) => {
+          this.createOrUpdateEdgeAttr({ ...attrItem, target: replaceNodeName });
+        });
+      }
+    }
+    this.#graph.dropNode(options.node);
+    this.update$.update((a) => a + 1);
+  }
+  async mergeNode(options) {
+    const sourceEdges = options.list.flatMap(
+      (item) => this.#getEdgesFromSource(item)
+    );
+    const targetEdges = options.list.flatMap(
+      (item) => this.#getEdgesFromTarget(item)
+    );
+    options.list.forEach((node) => {
+      const attr = this.#graph.getNodeAttributes(node);
+      attr.list.forEach((item) => {
+        this.createOrUpdateNodeAttr({ ...item, name: options.node });
+      });
+    });
+    for (const edge of sourceEdges) {
+      const data = this.#graph.getEdgeAttributes(edge);
+      data.list.forEach((item) => {
+        this.createOrUpdateEdgeAttr({ ...item, source: options.node });
+      });
+    }
+    for (const edge of targetEdges) {
+      const data = this.#graph.getEdgeAttributes(edge);
+      data.list.forEach((item) => {
+        this.createOrUpdateEdgeAttr({ ...item, target: options.node });
+      });
+    }
+    options.list.forEach((item) => {
+      this.#graph.dropNode(item);
+    });
+    this.update$.update((a) => a + 1);
+  }
+  async changeNodeDescription(payload) {
+    this.createOrUpdateNodeAttr(payload);
+    this.update$.update((a) => a + 1);
+  }
+  async changeEdge(item, oldItem) {
+    this.createOrUpdateEdgeAttr(item);
+    if (item.source !== oldItem.source || item.target !== oldItem.target) {
+      this.#deleteEdgeAttr(oldItem);
+    }
+    this.update$.update((a) => a + 1);
+  }
+  async add(input) {
+    input.nodes?.forEach((item) => {
+      this.createOrUpdateNodeAttr(item);
+    });
+    input.edges?.forEach((item) => {
+      this.createOrUpdateEdgeAttr(item);
+    });
+    this.update$.update((a) => a + 1);
+  }
+  async deleteNodeItem(item) {
+    this.#deleteNodeAttr(item);
+    this.update$.update((a) => a + 1);
+  }
+  deleteEdgeItem(item) {
+    this.#deleteEdgeAttr(item);
+    this.update$.update((a) => a + 1);
+  }
+  deleteNode(name) {
+    this.#graph.dropNode(name);
+    this.update$.update((a) => a + 1);
+  }
+  /**
+   * node=>edge
+   * 确定最相似的chunk(第一位)
+   * 获取传入节点的所有变
+   */
+  getEdgeByNode(nodes) {
+    const repeatList = /* @__PURE__ */ new Set();
+    const list = [];
+    for (const node of nodes) {
+      for (const edgeName of [
+        ...this.#graph.outEdges(node.name),
+        ...this.#graph.inEdges(node.name)
+      ]) {
+        const key = `${edgeName}|${node.chunkId}`;
+        if (repeatList.has(key)) {
+          continue;
+        }
+        repeatList.add(key);
+        list.push(
+          ...this.#graph.getEdgeAttributes(edgeName).list.filter((item) => item.chunkId === node.chunkId)
+        );
+      }
+    }
+    return list;
+  }
+  /**
+   * 根据边查节点
+   * 通过边上的chunkid,查找同在这个chunkid上的souce/target节点,权重为边
+   */
+  getNodeByEdge(edges) {
+    const repeatList = /* @__PURE__ */ new Set();
+    const list = [];
+    for (const edge of edges) {
+      for (const nodeName of [edge.source, edge.target]) {
+        const key = `${nodeName}|${edge.chunkId}`;
+        if (repeatList.has(key)) {
+          continue;
+        }
+        repeatList.add(key);
+        list.push(
+          ...this.#graph.getNodeAttributes(nodeName).list.filter((item) => item.chunkId === edge.chunkId)
+        );
+      }
+    }
+    return list;
+  }
+  getChunkEdgeByNode(node) {
+    const list = [];
+    for (const edgeName of [
+      ...this.#graph.outEdges(node.name),
+      ...this.#graph.inEdges(node.name)
+    ]) {
+      const edgeAttr = this.#graph.getEdgeAttributes(edgeName);
+      list.push(
+        ...edgeAttr.list.filter((item) => node.chunkId === item.chunkId)
+      );
+    }
+    return list;
+  }
+};
+
+// packages/knowledge/graph/graph.knowledge.service.ts
+import { BatchQueue as BatchQueue2 } from "@shenghuabi/knowledge/util";
+var GraphKnolwdgeService = class extends NormalKnowledgeService {
+  #text2vec = inject7(Text2VecToken);
+  #config = inject7(ConfigToken);
+  #util = inject7(KnowledgeUtilService);
+  #graphUtil = inject7(GraphKnowledgeUtilService);
+  #qdClient = inject7(QdrantClientService7);
+  #channel = inject7(LogToken4);
+  #injector = inject7(Injector);
+  #contentParser = inject7(ContentParserToken);
+  #graphLocal = inject7(GraphLocalService);
+  formatCollection(input) {
+    return v11.parse(GraphCollectionDefine, input);
+  }
+  async #createCollection(collection) {
+    const collectionName = getGraphCollectionName(collection.collectionName);
+    this.#channel.info(`创建图集合:${collectionName}`);
+    const { exists } = await this.#qdClient.collectionExists(collectionName);
+    if (exists) {
+      throw new Error(`集合${collectionName}已存在`);
+    }
+    await this.#qdClient.createCollection(collectionName, {
+      vectors: {
+        chunk: {
+          size: collection.size,
+          distance: "Cosine",
+          on_disk: true
+        }
+      }
+    });
+    this.#channel.info(`创建图索引`);
+    await this.#qdClient.createPayloadKeywordIndex(collectionName, "kind");
+    await this.#qdClient.createPayloadKeywordIndex(collectionName, "fileName");
+    await this.#qdClient.createPayloadKeywordIndex(collectionName, "name");
+    await this.#qdClient.createPayloadKeywordIndex(collectionName, "source");
+    await this.#qdClient.createPayloadKeywordIndex(collectionName, "target");
+  }
+  async create(collection) {
+    await super.create(collection);
+    await this.#createCollection(collection);
+    await this.#qdClient.setActivateCollection(
+      collection.graphCollectionName,
+      this.#config().activateGraphName
+    );
+  }
+  /** 图谱知识库不允许改chunksize,因为改了后切片就不一样了,那么生成的关系一定也不一样了 */
+  async insertItem(fileName, content, signal2) {
+    const list = await this._insertItem(fileName, content);
+    if (!list || !list.length) {
+      return;
+    }
+    const result = list[0].map(({ payload }) => payload);
+    await this.#insert(result, fileName, signal2);
+  }
+  async #insert(chunkList, fileName, signal2) {
+    const countObj = {
+      success: 0,
+      error: 0
+    };
+    const hasGraph = !!this.#graphLocal.getGraph();
+    const llmAsyncQueue = fastq4(async (document) => {
+      if (signal2?.aborted) {
+        return;
+      }
+      const extractData = await this.#contentParser.parse(document, signal2);
+      countObj.success++;
+      const nodes = extractData.entity.map((item) => ({
+        id: v44(),
+        payload: {
+          ...item,
+          fileName,
+          chunkId: document.hash
+        }
+      }));
+      const edges = extractData.entity_relation.map((item) => ({
+        id: v44(),
+        payload: {
+          ...item,
+          fileName,
+          chunkId: document.hash
+        }
+      }));
+      const keywords = extractData.keyword.map((item) => ({
+        id: v44(),
+        payload: {
+          keyword: item,
+          chunkId: document.hash,
+          fileName
+        }
+      }));
+      await this.#graphUtil.updateContext(async () => ({
+        upsert: {
+          nodes,
+          edges,
+          keywords
+        }
+      }));
+      if (hasGraph) {
+        this.#graphLocal.add({
+          nodes: nodes.map((item) => ({ ...item.payload, id: item.id })),
+          edges: edges.map((item) => ({ ...item.payload, id: item.id }))
+        });
+      }
+    }, this.#config().maxChunkAsync);
+    llmAsyncQueue.error((error, task) => {
+      if (error) {
+        countObj.error++;
+        this.#channel.warn(`[${fileName}]解析失败:
+${task.chunk}
+`, error);
+      }
+    });
+    for (const item of chunkList) {
+      llmAsyncQueue.push(item);
+    }
+    await llmAsyncQueue.drained();
+    if (signal2?.aborted) {
+      return this.deleteItem(fileName);
+    }
+    if (chunkList.length === countObj.error) {
+      await super.deleteItem(fileName);
+    }
+  }
+  async deleteItem(fileName) {
+    await super.deleteItem(fileName);
+    await this.#util.multiDelete(
+      this.#config().collectionList.map((item) => item.graphCollectionName),
+      {
+        filter: {
+          must: [{ key: "fileName", match: { value: fileName } }],
+          should: null
+        }
+      }
+    );
+  }
+  async updateItem(fileName, content) {
+    await this.deleteItem(fileName);
+    await this.insertItem(fileName, content);
+  }
+  async addCollection(collection) {
+    const activateCollectionName = this.#config().activateGraphName;
+    await super.addCollection(collection);
+    await this.#createCollection(collection);
+    const newCollectionName = collection.graphCollectionName;
+    const batchQueue = new BatchQueue2(
+      (item) => this.#text2vec(item, collection.collectionName)
+    );
+    const queue = this.#util.updatePointsQueue(newCollectionName);
+    let queueError = void 0;
+    queue.queue.error((err) => {
+      if (err) {
+        queueError = err;
+        queue.queue.killAndDrain();
+      }
+    });
+    let offset;
+    do {
+      const { points, next_page_offset } = await this.#qdClient.scroll(
+        activateCollectionName,
+        {
+          limit: 5e3,
+          with_payload: true,
+          with_vector: false,
+          offset
+        }
+      );
+      await batchQueue.then(
+        Promise.all([
+          Promise.all(
+            points.map(async (point) => {
+              let embeddingChunk;
+              if (point.payload["kind"] === "node") {
+                embeddingChunk = entryFormat(
+                  point.payload,
+                  this.#config().name,
+                  nodeVectorString(point.payload),
+                  collection.embeddingTemplate?.node
+                );
+              } else if (point.payload["kind"] === "edge") {
+                embeddingChunk = entryFormat(
+                  point.payload,
+                  this.#config().name,
+                  edgeVectorString(point.payload),
+                  collection.embeddingTemplate?.edge
+                );
+              } else {
+                embeddingChunk = point.payload["keyword"];
+              }
+              const vector = await batchQueue.push(embeddingChunk);
+              queue.push({
+                id: point.id,
+                payload: {
+                  ...point.payload,
+                  embeddingChunk
+                },
+                vector: {
+                  chunk: vector
+                }
+              });
+            })
+          )
+        ])
+      );
+      offset = next_page_offset;
+    } while (offset);
+    queue.complete();
+    await queue.queue.drained();
+    if (queueError) {
+      await this.#qdClient.deleteCollection(collection.collectionName);
+      await this.#qdClient.deleteCollection(collection.graphCollectionName);
+      throw queueError;
+    }
+    await this.#qdClient.setActivateCollection(
+      newCollectionName,
+      this.#config().activateGraphName
+    );
+  }
+  async deleteCollection(collectionName) {
+    const result = await super.deleteCollection(collectionName);
+    if (!result) {
+      return result;
+    }
+    const collection = this.#config().collectionList.find(
+      (item) => item.collectionName === collectionName
+    );
+    await this.#qdClient.deleteCollection(collection.graphCollectionName);
+    return true;
+  }
+  async changeActivateCollection(collectionName) {
+    await super.changeActivateCollection(collectionName);
+    await this.#qdClient.setActivateCollection(
+      getGraphCollectionName(collectionName),
+      this.#config().activateGraphName
+    );
+  }
+  export() {
+    return this.#util.export(
+      this.#config().collectionList.flatMap(
+        ({ collectionName, graphCollectionName }) => [
+          collectionName,
+          graphCollectionName
+        ]
+      )
+    );
+  }
+  async destroy() {
+    await super.destroy();
+    return this.#util.destroyKnowledge(
+      this.#config().collectionList.map(
+        ({ graphCollectionName }) => graphCollectionName
+      )
+    );
+  }
+};
+
+// packages/knowledge/knowledge.manager.service.ts
+import { FileParserService } from "@shenghuabi/knowledge/file-parser";
+
+// packages/knowledge/graph/graph.handle.service.ts
+import { QdrantClientService as QdrantClientService8 } from "@shenghuabi/knowledge/qdrant";
+import { inject as inject8, Injector as Injector2 } from "static-injector";
+import { v4 as v45 } from "uuid";
+import * as v12 from "valibot";
+import { isTruthy as isTruthy3, LogToken as LogToken5 } from "@shenghuabi/knowledge/util";
+var MAX_LIMIT = 99999;
+var FilterEdge = {
+  key: "kind",
+  match: {
+    value: "edge"
+  }
+};
+var FilterNode = {
+  key: "kind",
+  match: {
+    value: "node"
+  }
+};
+var GraphHandleService = class {
+  #text2vec = inject8(Text2VecToken);
+  #config = inject8(ConfigToken);
+  #util = inject8(KnowledgeUtilService);
+  #qdClient = inject8(QdrantClientService8);
+  #channel = inject8(LogToken5);
+  #injector = inject8(Injector2);
+  #graphUtil = inject8(GraphKnowledgeUtilService);
+  /** 拆分节点
+   */
+  async splitNode(options) {
+    await this.#graphUtil.updateContext(async () => {
+      const [{ points: nodes }, { points: edges }] = await Promise.all([
+        this.#qdClient.scroll(this.#config().activateGraphName, {
+          limit: MAX_LIMIT,
+          filter: {
+            must: [FilterNode, { key: "name", match: { value: options.node } }]
+          },
+          with_payload: true,
+          with_vector: false
+        }),
+        this.#qdClient.scroll(this.#config().activateGraphName, {
+          limit: MAX_LIMIT,
+          filter: {
+            must: [FilterEdge],
+            should: [
+              { key: "source", match: { value: options.node } },
+              { key: "target", match: { value: options.node } }
+            ]
+          },
+          with_payload: true,
+          with_vector: false
+        })
+      ]);
+      const [updateNodes, updateEdges] = await Promise.all([
+        Promise.all(
+          nodes.flatMap(
+            (node) => options.list.map(async (nodeName) => {
+              const payload = { ...node.payload, name: nodeName };
+              return {
+                payload,
+                id: v45()
+              };
+            })
+          )
+        ),
+        Promise.all(
+          edges.flatMap(
+            (edge) => options.list.map(async (nodeName) => {
+              const payload = edge.payload["source"] === options.node ? { ...edge.payload, source: nodeName } : { ...edge.payload, target: nodeName };
+              payload["name"] = getEdgeName(
+                payload["source"],
+                payload["target"]
+              );
+              return {
+                payload,
+                id: v45()
+              };
+            })
+          )
+        )
+      ]);
+      return {
+        upsert: {
+          nodes: updateNodes,
+          edges: updateEdges
+        },
+        delete: {
+          nodes,
+          edges
+        }
+      };
+    });
+  }
+  /** 合并节点 */
+  async mergeNode(options) {
+    const listToObj = options.list.reduce(
+      (obj, item) => {
+        obj[item] = true;
+        return obj;
+      },
+      {}
+    );
+    await this.#graphUtil.updateContext(async () => {
+      const [{ points: nodes }, { points: edges }] = await Promise.all([
+        this.#qdClient.scroll(this.#config().activateGraphName, {
+          limit: MAX_LIMIT,
+          filter: {
+            must: [FilterNode, { key: "name", match: { any: options.list } }]
+          },
+          with_payload: true,
+          with_vector: false
+        }),
+        this.#qdClient.scroll(this.#config().activateGraphName, {
+          limit: MAX_LIMIT,
+          filter: {
+            must: [FilterEdge],
+            should: [
+              { key: "source", match: { any: options.list } },
+              { key: "target", match: { any: options.list } }
+            ]
+          },
+          with_payload: true,
+          with_vector: false
+        })
+      ]);
+      const [updateNodes, updateEdges] = await Promise.all([
+        Promise.all(
+          nodes.map(async (node) => {
+            const payload = { ...node.payload, name: options.node };
+            return {
+              payload,
+              id: v45()
+            };
+          })
+        ),
+        Promise.all(
+          edges.map(async (edge) => {
+            const hasSource = listToObj[edge.payload["source"]];
+            const hasTarget = listToObj[edge.payload["target"]];
+            if (hasSource && hasTarget) {
+              return void 0;
+            }
+            const payload = hasSource ? { ...edge.payload, source: options.node } : { ...edge.payload, target: options.node };
+            payload["name"] = getEdgeName(payload["source"], payload["target"]);
+            return {
+              payload,
+              id: v45()
+            };
+          })
+        ).then((list) => list.filter(isTruthy3))
+      ]);
+      return {
+        upsert: {
+          nodes: updateNodes,
+          edges: updateEdges
+        },
+        delete: {
+          nodes,
+          edges
+        }
+      };
+    });
+  }
+  /** 虽然可以修改其他的,但是只允许修改描述 */
+  async changeNodeDescription(item) {
+    const payload = v12.parse(NodeItemDefine, item);
+    const id = payload.id;
+    delete payload.id;
+    await this.#graphUtil.updateContext(async () => ({
+      upsert: {
+        nodes: [
+          {
+            id,
+            payload
+          }
+        ]
+      }
+    }));
+  }
+  /**
+   * 修改边,如果关系修改了不需要改边 */
+  async changeEdge(item) {
+    const id = item.id;
+    const payload = v12.parse(EdgeItemDefine, item);
+    delete item.id;
+    await this.#graphUtil.updateContext(async () => ({
+      upsert: {
+        edges: [
+          {
+            id,
+            payload
+          }
+        ]
+      }
+    }));
+  }
+  /** 可以添加节点/边 */
+  async addNodeItem(input) {
+    await this.#graphUtil.updateContext(async () => {
+      const nodes = (input.nodes ?? []).map((node) => {
+        const payload = v12.parse(NodeItemNewDefine, node);
+        return {
+          id: v45(),
+          payload
+        };
+      });
+      const edges = (input.edges ?? []).map((edge) => {
+        const payload = v12.parse(EdgeItemNewDefine, edge);
+        return {
+          id: v45(),
+          payload
+        };
+      });
+      return {
+        upsert: { nodes, edges }
+      };
+    });
+  }
+  /** 删除节点的一条 */
+  async deleteNodeItem(item) {
+    await this.#graphUtil.updateContext(async () => {
+      const { points } = await this.#qdClient.scroll(
+        this.#config().activateGraphName,
+        {
+          limit: 1,
+          filter: {
+            must: [FilterNode, { key: "name", match: { value: item.name } }]
+          }
+        }
+      );
+      return {
+        delete: {
+          nodes: [item],
+          edges: points.length === 1 ? {
+            filter: {
+              must: [FilterEdge],
+              should: [
+                { key: "source", match: { value: item.name } },
+                { key: "target", match: { value: item.name } }
+              ]
+            }
+          } : []
+        }
+      };
+    });
+  }
+  /** 删除整个边(边不影响节点) */
+  async deleteEdge(item) {
+    await this.#graphUtil.updateContext(async () => ({
+      delete: {
+        edges: [item]
+      }
+    }));
+  }
+  /** 删除整个节点(对应边也删除) */
+  async deleteNodeByName(name) {
+    await this.#graphUtil.updateContext(async () => ({
+      delete: {
+        nodes: {
+          filter: {
+            must: [FilterNode, { key: "name", match: { value: name } }],
+            should: null
+          }
+        },
+        edges: {
+          filter: {
+            must: [FilterEdge],
+            should: [
+              { key: "source", match: { value: name } },
+              { key: "target", match: { value: name } }
+            ]
+          }
+        }
+      }
+    }));
+  }
+};
+
+// packages/knowledge/graph/graph.service.ts
+import { createInjector, inject as inject10, Injector as Injector3 } from "static-injector";
+
+// packages/knowledge/graph/graph.query.service.ts
+import { QdrantClientService as QdrantClientService9 } from "@shenghuabi/knowledge/qdrant";
+import { inject as inject9 } from "static-injector";
+import { differenceBy, uniqBy as uniqBy2 } from "lodash-es";
+
+// packages/knowledge/graph/util/graph-util.ts
+function getNodeStrList(item, index) {
+  return [
+    index + 1,
+    item.name,
+    item.type,
+    item.list.map((item2) => item2.description).join(";"),
+    (item.degree * 100).toFixed(0)
+  ];
+}
+function getEdgeStrList(item, i) {
+  return [
+    i + 1,
+    item.source,
+    item.target,
+    item.list.map((item2) => item2.description).join(";"),
+    (item.degree * 100).toFixed(0)
+  ];
+}
+
+// packages/knowledge/graph/util/format-attr.ts
+import * as v13 from "valibot";
+import { countBy, maxBy } from "lodash-es";
+function getNodeType(list) {
+  const data = countBy(list, (item) => item.type);
+  delete data["未知"];
+  return maxBy(Object.entries(data), (a) => a[1])?.[0] ?? "未知";
+}
+function formatNodeAttr2(list) {
+  let allCount = 0;
+  const attrList = list.map(({ data: data2, score: score2 }) => {
+    allCount += score2;
+    return v13.parse(NodePayloadDefine, data2);
+  });
+  const score = allCount / list.length;
+  const data = countBy(attrList, (item) => item.type);
+  delete data["未知"];
+  const type = getNodeType(attrList);
+  attrList.forEach((item) => {
+    item.type = type;
+  });
+  return {
+    list: attrList,
+    name: attrList[0].name,
+    type: getNodeType(attrList),
+    degree: score
+  };
+}
+function formatEdgeAttr2(list) {
+  let allCount = 0;
+  const attrList = list.map(({ data, score: score2 }) => {
+    allCount += score2;
+    return v13.parse(EdgePayloadDefine, data);
+  });
+  const score = allCount / list.length;
+  return {
+    list: attrList,
+    name: attrList[0].name,
+    source: attrList[0].source,
+    target: attrList[0].target,
+    degree: score
+  };
+}
+
+// packages/knowledge/graph/define/query.ts
+import * as v14 from "valibot";
+var GraphRelationQueryDefine = v14.pipe(
+  v14.object({
+    node: v14.optional(v14.string()),
+    edge: v14.optional(v14.string())
+  }),
+  v14.forward(
+    v14.partialCheck(
+      [["node"], ["edge"]],
+      (input) => typeof input.node === "string" || typeof input.edge === "string",
+      "节点或边必须存在一个"
+    ),
+    ["node"]
+  )
+);
+
+// packages/knowledge/graph/graph.query.service.ts
+import * as v15 from "valibot";
+var GraphQueryService = class {
+  #qdClient = inject9(QdrantClientService9);
+  #config = inject9(ConfigToken);
+  #graphChange = inject9(GraphLocalService);
+  #queryParams = inject9(QueryParamsToken);
+  #text2vec = inject9(Text2VecToken);
+  #reranker = inject9(ReRankerToken);
+  /** 返回限制索引 */
+  #listLimit(list, strListFn, limit) {
+    let count = 0;
+    const strList = list.map(strListFn);
+    for (let i = 0; i < strList.length; i++) {
+      const str = strList[i];
+      count += str.length;
+      if (count > limit) {
+        return list.slice(0, i);
+      }
+    }
+    return list;
+  }
+  #contextLimit(context) {
+    return {
+      nodes: this.#listLimit(
+        context.nodes,
+        (item, i) => getNodeStrList(item, i).join("|"),
+        this.#queryParams.lengthLimit.node
+      ),
+      edges: this.#listLimit(
+        context.edges,
+        (item, i) => getEdgeStrList(item, i).join("|"),
+        this.#queryParams.lengthLimit.edge
+      ),
+      chunks: this.#listLimit(
+        context.chunks,
+        (list) => list.chunk,
+        this.#queryParams.lengthLimit.chunk
+      )
+    };
+  }
+  async #queryGraphCollection(content, kind) {
+    return this.#qdClient.search(this.#config().activateGraphName, {
+      limit: this.#queryParams.topK * this.#reranker.getQueryRatio(),
+      vector: {
+        name: "chunk",
+        vector: await this.#text2vec(
+          content,
+          this.#config().activateCollection
+        )
+      },
+      filter: {
+        must: {
+          key: "kind",
+          match: {
+            value: kind
+          }
+        }
+      },
+      with_payload: true
+      // with_lookup: true,
+    }).then(
+      (item) => item.map((item2) => ({ ...item2.payload, id: item2.id }))
+    );
+  }
+  async #findChunkDataById(ids) {
+    return this.#qdClient.retrieve(this.#config().activateName, { ids, with_payload: true }).then(
+      (item) => item.map(
+        (item2) => ({
+          ...item2.payload,
+          knowledge: this.#config().name
+        })
+      )
+    );
+  }
+  #getEdgeByNode(nodes) {
+    const list = this.#graphChange.getEdgeByNode(nodes);
+    return this.#qdClient.retrieve(this.#config().activateGraphName, {
+      ids: list.map((item) => item.id)
+    }).then(
+      (list2) => list2.map(
+        (item) => ({ ...item.payload, id: item.id })
+      )
+    );
+  }
+  #getNodeByEdge(edges) {
+    const list = this.#graphChange.getNodeByEdge(edges);
+    return this.#qdClient.retrieve(this.#config().activateGraphName, {
+      ids: list.map((item) => item.id)
+    }).then(
+      (list2) => list2.map(
+        (item) => ({ ...item.payload, id: item.id })
+      )
+    );
+  }
+  async #queryLocal(keywords) {
+    const nodeGroupResult = await this.#queryGraphCollection(
+      keywords,
+      "node"
+    );
+    const chunkResult = await this.#findChunkDataById(
+      nodeGroupResult.map((item) => item.chunkId)
+    );
+    return {
+      nodes: nodeGroupResult,
+      edges: await this.#getEdgeByNode(nodeGroupResult),
+      chunks: chunkResult
+    };
+  }
+  async #queryGlobal(keywords) {
+    const edgeGroupResult = await this.#queryGraphCollection(
+      keywords,
+      "edge"
+    );
+    const chunkResult = await this.#findChunkDataById(
+      edgeGroupResult.map((item) => item["chunkId"])
+    );
+    return {
+      nodes: await this.#getNodeByEdge(edgeGroupResult),
+      edges: edgeGroupResult,
+      chunks: chunkResult
+    };
+  }
+  async query(params, question) {
+    params = v15.parse(GraphRelationQueryDefine, params);
+    await this.#graphChange.loadDataInitGraph$$();
+    let context;
+    if (params.node && params.edge) {
+      const context1 = await this.#queryLocal(params.node);
+      const context2 = await this.#queryGlobal(params.edge);
+      const ctx2NodeExtra = differenceBy(
+        context2.nodes,
+        context1.nodes,
+        (item) => item.id
+      );
+      const ctx1EdgeExtra = differenceBy(
+        context1.edges,
+        context2.edges,
+        (item) => item.id
+      );
+      context = {
+        nodes: [...context1.nodes, ...ctx2NodeExtra],
+        edges: [...context2.edges, ...ctx1EdgeExtra],
+        chunks: uniqBy2(
+          [...context1.chunks, ...context2.chunks],
+          (a) => a.chunk
+        )
+      };
+    } else if (params.node) {
+      context = await this.#queryLocal(params.node);
+    } else if (params.edge) {
+      context = await this.#queryGlobal(params.edge);
+    } else {
+      throw new Error("");
+    }
+    const nodeSortedList = await this.#reranker.run({
+      value: question,
+      docs: context.nodes.map((item) => item.embeddingChunk)
+    });
+    const nodeSorted = nodeSortedList.slice(0, Math.ceil(nodeSortedList.length * 0.3)).reduce(
+      (obj, item) => {
+        const data = context.nodes[item.index];
+        obj[data.name] ??= [];
+        obj[data.name].push({ data, score: item.score });
+        return obj;
+      },
+      {}
+    );
+    const edgeSortList = await this.#reranker.run({
+      value: question,
+      docs: context.edges.map((item) => item.embeddingChunk)
+    });
+    const edgeSorted = edgeSortList.slice(0, Math.ceil(nodeSortedList.length * 0.3)).reduce(
+      (obj, item) => {
+        const data = context.edges[item.index];
+        obj[data.name] ??= [];
+        obj[data.name].push({ data, score: item.score });
+        return obj;
+      },
+      {}
+    );
+    return this.#contextLimit({
+      nodes: Object.values(nodeSorted).reduce((allList, list) => {
+        let length = 0;
+        const index = list.findIndex((value, index2) => {
+          length += value.data.description.length;
+          return length > this.#queryParams.lengthLimit.nodeDescription;
+        });
+        allList.push(
+          formatNodeAttr2(list.slice(0, index == -1 ? list.length : index))
+        );
+        return allList;
+      }, []).sort((a, b) => b.degree - a.degree),
+      edges: Object.values(edgeSorted).reduce((allList, list) => {
+        let length = 0;
+        const index = list.findIndex((value) => {
+          length += value.data.description.length;
+          return length > this.#queryParams.lengthLimit.nodeDescription;
+        });
+        allList.push(
+          formatEdgeAttr2(list.slice(0, index == -1 ? list.length : index))
+        );
+        return allList;
+      }, []).sort((a, b) => b.degree - a.degree),
+      chunks: (await this.#reranker.run({
+        value: question,
+        docs: context.chunks.map((item) => item.embeddingChunk)
+      })).map((item) => context.chunks[item.index])
+    });
+  }
+  async searchNode(str, selectedList) {
+    await this.#graphChange.loadDataInitGraph$$();
+    const limit = 20;
+    const list = [];
+    for (const nodeName of this.#graphChange.getGraph().nodes()) {
+      if (!selectedList.includes(nodeName) && nodeName.includes(str)) {
+        list.push(nodeName);
+        if (limit === list.length) {
+          return list;
+        }
+      }
+    }
+    return list;
+  }
+  async getFileNameList() {
+    const result = await this.#qdClient.queryGroups(
+      this.#config().activateName,
+      {
+        limit: 9999,
+        group_by: "fileName",
+        group_size: 1,
+        with_payload: []
+      }
+    );
+    return result.groups;
+  }
+  async getChunkContent(fileName) {
+    const { points } = await this.#qdClient.query(this.#config().activateName, {
+      limit: 9999,
+      filter: {
+        must: {
+          key: "fileName",
+          match: { value: fileName }
+        }
+      },
+      with_payload: true
+    });
+    return points.map((item) => ({
+      ...item,
+      payload: {
+        ...item.payload,
+        knowledge: this.#config().name
+      }
+    }));
+  }
+  async getGraphData() {
+    await this.#graphChange.loadDataInitGraph$$();
+    return this.#graphChange.getGraph().export();
+  }
+  async queryNode(list, options) {
+    return this.#qdClient.scroll(this.#config().activateGraphName, {
+      limit: options.nodeSizeLimit,
+      filter: {
+        must: [
+          {
+            key: "kind",
+            match: {
+              value: "node"
+            }
+          },
+          {
+            key: "name",
+            match: {
+              any: list
+            }
+          }
+        ]
+      },
+      with_payload: true
+      // with_lookup: true,
+    }).then((item) => item.points);
+  }
+  async fuzzyQueryNode(content, options) {
+    return this.#qdClient.searchPointGroups(this.#config().activateGraphName, {
+      limit: options.nodeLimit,
+      score_threshold: options.score,
+      vector: {
+        name: "chunk",
+        vector: await this.#text2vec(
+          content,
+          this.#config().activateCollection
+        )
+      },
+      group_by: "name",
+      group_size: options.nodeSizeLimit,
+      filter: {
+        must: {
+          key: "kind",
+          match: {
+            value: "node"
+          }
+        }
+      },
+      with_payload: true
+      // with_lookup: true,
+    }).then((item) => item.groups);
+  }
+};
+
+// packages/knowledge/graph/graph.service.ts
+var GraphService = class {
+  local = inject10(GraphLocalService);
+  #knowledge = inject10(GraphHandleService);
+  knowledge = inject10(GraphKnolwdgeService);
+  #injector = inject10(Injector3);
+  graphExport$$ = this.local.graphExport$$;
+  createQuery(queryParams) {
+    return createInjector({
+      providers: [
+        GraphQueryService,
+        { provide: QueryParamsToken, useValue: queryParams }
+      ],
+      parent: this.#injector
+    }).get(GraphQueryService);
+  }
+  loadDataInit$$ = this.local.loadDataInitGraph$$;
+  initGraph() {
+    return this.local.initGraph();
+  }
+  getGraph() {
+    return this.local.getGraph();
+  }
+  async splitNode(options) {
+    await this.local.splitNode(options);
+    await this.#knowledge.splitNode(options);
+  }
+  async mergeNode(options) {
+    await this.local.mergeNode(options);
+    await this.#knowledge.mergeNode(options);
+  }
+  async changeNodeDescription(item) {
+    await this.local.changeNodeDescription(item);
+    await this.#knowledge.changeNodeDescription(item);
+  }
+  async changeEdge(item, oldItem) {
+    await this.local.changeEdge(item, oldItem);
+    await this.#knowledge.changeEdge(item);
+  }
+  async add(input) {
+    await this.local.add(input);
+    await this.#knowledge.addNodeItem(input);
+  }
+  async deleteNodeItem(item) {
+    await this.local.deleteNodeItem(item);
+    await this.#knowledge.deleteNodeItem(item);
+  }
+  async deleteEdge(item) {
+    await this.local.deleteEdgeItem(item);
+    await this.#knowledge.deleteEdge(item);
+  }
+  async deleteNodeByName(name) {
+    await this.local.deleteNode(name);
+    await this.#knowledge.deleteNodeByName(name);
+  }
+};
+
+// packages/knowledge/knowledge.manager.service.ts
+import * as fs from "fs/promises";
+import { fileTypeFromBuffer } from "file-type";
+import path3 from "path";
+
+// packages/knowledge/article/article.knowledge.service.ts
+import { getHash as getHash2 } from "@shenghuabi/knowledge/util";
+import { createNormalizeVfs as createNormalizeVfs3, path as path2 } from "@cyia/vfs2";
+import { computed as computed4, inject as inject11 } from "static-injector";
+import { QdrantClientService as QdrantClientService10 } from "@shenghuabi/knowledge/qdrant";
+import { promise as fastq5 } from "fastq";
+
+// packages/knowledge/article/define/payload.ts
+import * as v16 from "valibot";
+var ArticlePayload = v16.object({
+  fileHash: v16.string(),
+  fullName: v16.string(),
+  name: v16.string(),
+  dir: v16.string(),
+  chunk: v16.string(),
+  hash: v16.string(),
+  loc: v16.custom(Boolean)
+});
+
+// packages/knowledge/article/article.knowledge.service.ts
+import * as v17 from "valibot";
+var ArticleKnowledgeService = class extends NormalKnowledgeService {
+  #text2vec = inject11(Text2VecToken);
+  #reranker = inject11(ReRankerToken);
+  #config = inject11(ConfigToken);
+  #dir = inject11(DirToken);
+  #qdClient = inject11(QdrantClientService10);
+  #util = inject11(KnowledgeUtilService);
+  #vfs = computed4(() => createNormalizeVfs3({ dir: this.#dir() }));
+  KeyWordIndex = ["fullName", "dir", "fileHash"];
+  getPayload(fileName, content) {
+    return {
+      fileHash: getHash2(content),
+      fullName: fileName,
+      name: path2.basename(fileName),
+      dir: path2.dirname(fileName)
+    };
+  }
+  async insertItem(fileName, content) {
+    const { points } = await this.#qdClient.scroll(
+      this.#config().activateName,
+      {
+        limit: 1,
+        filter: {
+          should: [
+            { key: "fileHash", match: { value: getHash2(content) } },
+            { key: "fullName", match: { value: fileName } }
+          ]
+        }
+      }
+    );
+    if (points.length) {
+      return;
+    }
+    await this.insertItemOnly(fileName, content, this.#config().collectionList);
+  }
+  async deleteItem(fileName) {
+    await this.#util.multiDelete(
+      this.#config().collectionList.map((item) => item.collectionName),
+      {
+        filter: {
+          must: [{ key: "fullName", match: { value: fileName } }],
+          should: null
+        }
+      }
+    );
+  }
+  async addCollection(collection) {
+    await this.createCollection(collection);
+    try {
+      const queue = fastq5(async (payload) => {
+        payload = v17.parse(ArticlePayload, payload);
+        const content = await this.#vfs().readContent(payload.fullName);
+        if (!content) {
+          return;
+        }
+        await this.insertItemOnly(payload.fullName, content, [collection]);
+      }, 10);
+      let offset;
+      const wordSet = /* @__PURE__ */ new Set();
+      let queueError;
+      queue.error((error) => {
+        if (error) {
+          queueError = error;
+          queue.killAndDrain();
+        }
+      });
+      do {
+        const { points, next_page_offset } = await this.#qdClient.scroll(
+          this.#config().activateName,
+          {
+            limit: 5e3,
+            with_payload: true,
+            offset
+          }
+        );
+        for (const point of points) {
+          const id = `${point.payload["fileHash"]}`;
+          if (wordSet.has(id)) {
+            continue;
+          }
+          wordSet.add(id);
+          queue.push(point.payload);
+        }
+        offset = next_page_offset;
+      } while (offset);
+      await queue.drained();
+      if (queueError) {
+        throw queueError;
+      }
+    } catch (error) {
+      await this.#qdClient.deleteCollection(collection.collectionName);
+      throw error;
+    }
+    await this.#qdClient.setActivateCollection(
+      collection.collectionName,
+      this.#config().activateName
+    );
+  }
+  destroy() {
+    return this.#util.destroyKnowledge(
+      this.#config().collectionList.map(({ collectionName }) => collectionName)
+    );
+  }
+  async searchGroupByChunk(text, options, filter) {
+    const queryResult = await this.#qdClient.searchPointGroups(
+      this.#config().activateName,
+      {
+        group_by: "hash",
+        filter,
+        with_payload: true,
+        with_vector: false,
+        score_threshold: options?.score,
+        vector: {
+          name: "chunk",
+          vector: await this.#text2vec(text, this.#config().activateCollection)
+        },
+        group_size: options.group_size * this.#reranker.getQueryRatio(),
+        limit: options.limit
+      }
+    );
+    return Promise.all(
+      queryResult.groups.map(async (item) => {
+        const resultList = await this.#reranker.run({
+          value: text,
+          docs: item.hits.map(
+            (item2) => item2.payload?.["embeddingChunk"]
+          )
+        });
+        return {
+          ...item,
+          hits: resultList.slice(0, options.group_size).map(({ index }) => item.hits[index])
+        };
+      })
+    );
+  }
+};
+
+// packages/knowledge/article/define/config.ts
+import * as v18 from "valibot";
+var ArticleCollectionDefine = v18.object({
+  collectionName: v18.string(),
+  embeddingTemplate: v18.optional(
+    v18.object({
+      entry: v18.optional(EmbeddingTemplateDefine)
+    })
+  ),
+  size: v18.number()
+});
+var ArticleKnowledgeConfigDefine = v18.pipe(
+  v18.object({
+    ...BaseKnowledgeConfig.entries,
+    type: v18.optional(v18.literal("article"), "article"),
+    collectionList: v18.array(ArticleCollectionDefine)
+  }),
+  v18.transform((item) => ({
+    ...item,
+    /** 激活的普通知识库(文件切片) */
+    activateName: getActivateCollectionName(item.name)
+  }))
+);
+
+// packages/knowledge/knowledge.manager.service.ts
+import { QdrantClientService as QdrantClientService11 } from "@shenghuabi/knowledge/qdrant";
+import { LogToken as LogToken6 } from "@shenghuabi/knowledge/util";
+var KnowledgeManagerService = class extends RootStaticInjectOptions2 {
+  #injector = inject12(Injector4);
+  #fileParser = inject12(FileParserService);
+  #cacheMap = /* @__PURE__ */ new Map();
+  #qdClient = inject12(QdrantClientService11);
+  async getConfig(name) {
+    throw new Error("未实现");
+  }
+  async getInjector(name, extraProviders) {
+    let injector = this.#cacheMap.get(name);
+    if (!injector) {
+      const config = await this.getConfig(name);
+      const CommonProviders = [
+        { provide: ConfigToken, useValue: config },
+        ...extraProviders ?? []
+      ];
+      switch (config().type) {
+        case "normal":
+          injector = createInjector2({
+            providers: [NormalKnowledgeService, ...CommonProviders],
+            parent: this.#injector
+          });
+          break;
+        case "article":
+          injector = createInjector2({
+            providers: [ArticleKnowledgeService, ...CommonProviders],
+            parent: this.#injector
+          });
+          break;
+        case "dict":
+          injector = createInjector2({
+            providers: [DictKnowledgeService, ...CommonProviders],
+            parent: this.#injector
+          });
+          break;
+        case "normal-graph":
+          injector = createInjector2({
+            providers: [
+              GraphKnolwdgeService,
+              GraphLocalService,
+              GraphHandleService,
+              GraphService,
+              GraphKnowledgeUtilService,
+              ...CommonProviders
+            ],
+            parent: this.#injector
+          });
+          break;
+        default:
+          throw "";
+      }
+      this.#cacheMap.set(name, injector);
+    }
+    return injector;
+  }
+  async #get(name) {
+    const injector = await this.getInjector(name);
+    const config = injector.get(ConfigToken);
+    switch (config().type) {
+      case "normal":
+        return injector.get(NormalKnowledgeService);
+      case "dict":
+        return injector.get(DictKnowledgeService);
+      case "normal-graph":
+        return injector.get(GraphKnolwdgeService);
+      case "article":
+        return injector.get(ArticleKnowledgeService);
+      default:
+        throw new Error("");
+    }
+  }
+  async create(name, collection) {
+    const instance = await this.#get(name);
+    await instance.create(instance.formatCollection(collection));
+  }
+  /** 普通知识库和图谱知识库用 */
+  async importFiles(name, filePathList, signal2) {
+    const injector = await this.getInjector(name);
+    const logService = injector.get(LogToken6);
+    const instance = await this.#get(name);
+    for (const filePath of filePathList) {
+      if (signal2?.aborted) {
+        return;
+      }
+      const content = await fs.readFile(filePath);
+      const list = await this.#fileParser.parse(filePath, content);
+      for (const item of list) {
+        if (signal2?.aborted) {
+          return;
+        }
+        logService.info(`正在导入 ${filePath}/${item.title}`);
+        const content2 = item.content.trim();
+        if (content2) {
+          await instance.insertItem(item.title, content2, signal2);
+        } else {
+          logService.warn(`内容为空 ${filePath}/${item.title}`);
+        }
+      }
+    }
+  }
+  /** 字典专用 */
+  async importDict(name, input) {
+    const instance = await this.#get(name);
+    return await instance.importDict(input);
+  }
+  async get(name) {
+    return await this.#get(name);
+  }
+  async importTextFile(name, dir, filePathList, signal2) {
+    const injector = await this.getInjector(name);
+    const logService = injector.get(LogToken6);
+    const instance = await this.#get(name);
+    for (const filePath of filePathList) {
+      if (signal2?.aborted) {
+        return;
+      }
+      logService.info(`正在导入 ${filePath}`);
+      const buffer = await fs.readFile(path3.join(dir, filePath));
+      const type = await fileTypeFromBuffer(buffer);
+      if (type) {
+        continue;
+      }
+      let content;
+      try {
+        content = buffer.toString();
+      } catch (error) {
+        continue;
+      }
+      await instance.insertItem(filePath, content);
+    }
+  }
+  async deleteItem(name, fileName) {
+    const instance = await this.#get(name);
+    await instance.deleteItem(fileName);
+  }
+  async updateItem(name, fileName, content) {
+    const instance = await this.#get(name);
+    await instance.updateItem(fileName, content);
+  }
+  /** 通用接口 */
+  async addCollection(name, collection) {
+    const instance = await this.#get(name);
+    await instance.addCollection(instance.formatCollection(collection));
+  }
+  /** 通用接口 */
+  async deleteCollection(name, collectionName) {
+    const instance = await this.#get(name);
+    return await instance.deleteCollection(collectionName);
+  }
+  async changeActivateCollection(name, collectionName) {
+    const instance = await this.#get(name);
+    await instance.changeActivateCollection(collectionName);
+  }
+  async destroy(name) {
+    const instance = await this.#get(name);
+    this.#cacheMap.delete(name);
+    await instance.destroy();
+  }
+  async export(name) {
+    const instance = await this.#get(name);
+    return await instance.export();
+  }
+  async import(name, options) {
+    const logService = (await this.getInjector(name)).get(LogToken6);
+    for (const item of options.snapshotList) {
+      logService.info(`正在导入 ${item.collection}`);
+      await this.#qdClient.recoverSnapshot(item.collection, {
+        location: item.filePath,
+        priority: "no_sync",
+        checksum: item.checksum
+      });
+    }
+    await this.#qdClient.setActivateCollection(
+      options.activateCollection,
+      getActivateCollectionName(name)
+    );
+    if (options.type === "normal-graph") {
+      await this.#qdClient.setActivateCollection(
+        getGraphCollectionName(options.activateCollection),
+        getActivateCollectionName(getGraphCollectionName(name))
+      );
+    }
+  }
+  async getGraph(name) {
+    const injector = await this.getInjector(name);
+    return injector.get(GraphService);
+  }
+};
+
+// packages/knowledge/common/define/chunk.ts
+import * as v19 from "valibot";
+var FileChunkPayloadDefine = v19.object({
+  chunk: v19.string(),
+  fileName: v19.string(),
+  loc: v19.custom(Boolean),
+  hash: v19.string(),
+  embeddingChunk: v19.string()
+});
+export {
+  ArticleCollectionDefine,
+  ArticleKnowledgeConfigDefine,
+  ArticleKnowledgeService,
+  ArticlePayload,
+  BaseKnowledgeConfig,
+  CHAT_INPUT,
+  ConfigToken,
+  ContentParserToken,
+  DICT_PREFIX,
+  DictCollectionDefine,
+  DictKnowledgeConfigDefine,
+  DictKnowledgeService,
+  DirToken,
+  ENTITY_DEFINE,
+  ENTITY_RELATION_DEFINE,
+  EdgeItemDefine,
+  EdgeItemNewDefine,
+  EdgePayloadDefine,
+  EdgePayloadNewDefine,
+  EmbeddingTemplateDefine,
+  EntityExtraDefine,
+  FileChunkPayloadDefine,
+  GetConfigToken,
+  GraphCollectionDefine,
+  GraphHandleService,
+  GraphKnolwdgeService,
+  GraphKnowledgeConfigDefine,
+  GraphLocalService,
+  GraphQueryService,
+  GraphService,
+  KeywordPayloadNewDefine,
+  KnowledgeGraphCreateDefine,
+  KnowledgeManagerService,
+  NodeItemDefine,
+  NodeItemNewDefine,
+  NodePayloadDefine,
+  NodePayloadNewDefine,
+  NormalCollectionDefine,
+  NormalKnowledgeConfigDefine,
+  NormalKnowledgeService,
+  OCRToken,
+  QueryParamsToken,
+  RagChatToken,
+  ReRankerToken,
+  Text2VecToken,
+  TextSplitterToken,
+  getActivateCollectionName,
+  getGraphCollectionName
+};
+//# sourceMappingURL=knowledge.mjs.map