@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/README.md

@@ -138,3 +138,6 @@ Within each scope, the plugin keeps:
 
 Contributor-oriented architecture, workflow, and packaging notes live in
 `DEVELOPMENT.md` at the repository root.
+
+Release-process details for maintainers live in
+[`docs/release-workflow.md`](./docs/release-workflow.md).

package/dist/_virtual/_rolldown/runtime.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -34,4 +35,4 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
 });
 //#endregion
-export { __commonJSMin, __exportAll, __require, __toESM };
+export { __commonJSMin, __esmMin, __exportAll, __require, __toESM };

package/dist/config.js

@@ -48,6 +48,79 @@ const knowherePluginConfigSchema = {
 			minimum: 1e3,
 			maximum: 72e5,
 			default: 6e5
+		},
+		knowledgeGraph: {
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				enabled: {
+					type: "boolean",
+					default: true
+				},
+				kbId: { type: "string" },
+				kbIdSource: {
+					type: "string",
+					enum: [
+						"disabled",
+						"agent",
+						"agent-session",
+						"global"
+					],
+					default: "disabled"
+				},
+				concurrentBuildStrategy: {
+					type: "string",
+					enum: ["queue", "skip"],
+					default: "queue"
+				},
+				buildTimeout: {
+					type: "integer",
+					minimum: 1e4,
+					maximum: 6e5,
+					default: 3e5
+				},
+				notifyOnGraphFailure: {
+					type: "boolean",
+					default: false
+				},
+				connectConfig: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						minKeywordOverlap: {
+							type: "integer",
+							minimum: 1,
+							default: 3
+						},
+						keywordScoreWeight: {
+							type: "number",
+							minimum: 0,
+							default: 1
+						},
+						maxConnectionsPerChunk: {
+							type: "integer",
+							minimum: 1,
+							default: 10
+						},
+						minScoreThreshold: {
+							type: "number",
+							minimum: 0,
+							maximum: 1,
+							default: .8
+						},
+						crossFileOnly: {
+							type: "boolean",
+							default: true
+						},
+						maxContentOverlap: {
+							type: "number",
+							minimum: 0,
+							maximum: 1,
+							default: .8
+						}
+					}
+				}
+			}
 		}
 	}
 };
@@ -142,5 +215,46 @@ async function persistApiKey(storageDir, apiKey) {
 	const filePath = resolveApiKeyStatePath(storageDir);
 	await fs.writeFile(filePath, JSON.stringify({ apiKey: apiKey.trim() }), "utf-8");
 }
+function readKbIdSource(raw) {
+	const value = readString(raw, "kbIdSource");
+	if (value === "disabled" || value === "agent" || value === "agent-session" || value === "global") return value;
+	return "disabled";
+}
+function resolveKnowledgeGraphConfig(raw) {
+	const kgConfig = isRecord(raw.knowledgeGraph) ? raw.knowledgeGraph : {};
+	const connectConfig = isRecord(kgConfig.connectConfig) ? kgConfig.connectConfig : {};
+	return {
+		enableKnowledgeGraph: typeof kgConfig.enabled === "boolean" ? kgConfig.enabled : true,
+		kbId: readString(kgConfig, "kbId"),
+		kbIdSource: readKbIdSource(kgConfig),
+		concurrentBuildStrategy: kgConfig.concurrentBuildStrategy === "queue" || kgConfig.concurrentBuildStrategy === "skip" ? kgConfig.concurrentBuildStrategy : "queue",
+		buildTimeout: readNumber(kgConfig, "buildTimeout", 3e5, {
+			min: 1e4,
+			max: 6e5,
+			integer: true
+		}),
+		notifyOnGraphFailure: typeof kgConfig.notifyOnGraphFailure === "boolean" ? kgConfig.notifyOnGraphFailure : false,
+		connectConfig: {
+			minKeywordOverlap: readNumber(connectConfig, "minKeywordOverlap", 3, {
+				min: 1,
+				integer: true
+			}),
+			keywordScoreWeight: readNumber(connectConfig, "keywordScoreWeight", 1, { min: 0 }),
+			maxConnectionsPerChunk: readNumber(connectConfig, "maxConnectionsPerChunk", 10, {
+				min: 1,
+				integer: true
+			}),
+			minScoreThreshold: readNumber(connectConfig, "minScoreThreshold", .8, {
+				min: 0,
+				max: 1
+			}),
+			crossFileOnly: typeof connectConfig.crossFileOnly === "boolean" ? connectConfig.crossFileOnly : true,
+			maxContentOverlap: readNumber(connectConfig, "maxContentOverlap", .8, {
+				min: 0,
+				max: 1
+			})
+		}
+	};
+}
 //#endregion
-export { assertKnowhereApiKey, formatPaymentRequiredMessage, isPaymentRequiredError, knowherePluginConfigSchema, persistApiKey, readPersistedApiKey, resolveKnowhereConfig };
+export { assertKnowhereApiKey, formatPaymentRequiredMessage, isPaymentRequiredError, knowherePluginConfigSchema, persistApiKey, readPersistedApiKey, resolveKnowhereConfig, resolveKnowledgeGraphConfig };

package/dist/connect-builder.js

@@ -0,0 +1,181 @@
+import { __esmMin } from "./_virtual/_rolldown/runtime.js";
+//#region src/connect-builder.ts
+/**
+* Normalize a keyword to lowercase
+* Equivalent to Python: _normalize_keyword
+*/
+function normalizeKeyword(keyword) {
+	return keyword.toLowerCase().trim();
+}
+/**
+* Extract file key from a chunk path
+* Equivalent to Python: _extract_file_key
+*
+* Example: "Default_Root/report.docx/Chapter 1" -> "report.docx"
+*/
+function extractFileKey(path) {
+	const parts = path.split("/");
+	if (parts.length >= 2) return parts[1];
+	return path;
+}
+/**
+* Build inverted keyword index: keyword -> [chunk_ids]
+* Equivalent to Python: _build_keyword_index
+*/
+function buildKeywordIndex(chunks) {
+	const index = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const keywords = chunk.metadata.keywords || [];
+		for (const kw of keywords) {
+			const normalized = normalizeKeyword(kw);
+			if (!index.has(normalized)) index.set(normalized, /* @__PURE__ */ new Set());
+			index.get(normalized).add(chunk.chunk_id);
+		}
+	}
+	return index;
+}
+/**
+* Get keywords from a chunk with fallback to tokens
+* Equivalent to Python: _get_keywords
+*/
+function getKeywords(chunk) {
+	const keywords = chunk.metadata.keywords || [];
+	if (keywords.length > 0) return keywords;
+	const tokens = chunk.metadata.tokens || [];
+	if (tokens.length > 0) return tokens.filter((token) => {
+		if (token.length <= 1) return false;
+		if (/^\d+$/.test(token)) return false;
+		return true;
+	});
+	return [];
+}
+/**
+* Compute character-length-weighted keyword overlap score
+* Equivalent to Python: _compute_keyword_score
+*
+* Formula: sum(len(kw)^2 for kw in shared_keywords) / sqrt(sum(len(kw)^2 for kw in all_keywords_A) * sum(..._B))
+*/
+function computeKeywordScore(keywordsA, keywordsB, sharedKeywords) {
+	if (sharedKeywords.length === 0) return 0;
+	const sharedWeight = sharedKeywords.reduce((sum, kw) => sum + kw.length ** 2, 0);
+	const weightA = keywordsA.reduce((sum, kw) => sum + kw.length ** 2, 0);
+	const weightB = keywordsB.reduce((sum, kw) => sum + kw.length ** 2, 0);
+	if (weightA === 0 || weightB === 0) return 0;
+	const score = sharedWeight / Math.sqrt(weightA * weightB);
+	return Math.min(score, 1);
+}
+/**
+* Check if two strings are near-duplicates using SequenceMatcher
+* Equivalent to Python: difflib.SequenceMatcher(None, a, b).ratio()
+*
+* Uses Longest Common Subsequence (LCS) algorithm
+*/
+function sequenceMatcherRatio(a, b) {
+	if (a === b) return 1;
+	if (a.length === 0 || b.length === 0) return 0;
+	const m = a.length;
+	const n = b.length;
+	const dp = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) if (a[i - 1] === b[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
+	else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+	const lcsLength = dp[m][n];
+	const totalLength = m + n;
+	return 2 * lcsLength / totalLength;
+}
+/**
+* Main function to build connections between chunks
+* Equivalent to Python: build_connections
+*/
+function buildConnections(chunks, config, logger) {
+	if (chunks.length < 2) {
+		logger?.info("Not enough chunks for connection building (need >= 2)");
+		return [];
+	}
+	logger?.info(`Building connections for ${chunks.length} chunks`);
+	const keywordIndex = buildKeywordIndex(chunks);
+	const chunkById = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) chunkById.set(chunk.chunk_id, chunk);
+	const chunksByFile = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const fileKey = extractFileKey(chunk.path);
+		if (!chunksByFile.has(fileKey)) chunksByFile.set(fileKey, /* @__PURE__ */ new Set());
+		chunksByFile.get(fileKey).add(chunk.chunk_id);
+	}
+	const candidatePairs = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const normalizedKeywords = getKeywords(chunk).map(normalizeKeyword);
+		const candidates = /* @__PURE__ */ new Set();
+		for (const kw of normalizedKeywords) {
+			const matchingChunks = keywordIndex.get(kw);
+			if (matchingChunks) {
+				for (const targetId of matchingChunks) if (targetId !== chunk.chunk_id) candidates.add(targetId);
+			}
+		}
+		if (candidates.size > 0) candidatePairs.set(chunk.chunk_id, candidates);
+	}
+	logger?.info(`Found ${candidatePairs.size} chunks with candidate connections`);
+	const connections = [];
+	const seenPairs = /* @__PURE__ */ new Set();
+	for (const [sourceId, targetIds] of candidatePairs) {
+		const sourceChunk = chunkById.get(sourceId);
+		if (!sourceChunk) continue;
+		const sourceKeywords = getKeywords(sourceChunk);
+		sourceKeywords.map(normalizeKeyword);
+		const sourceFileKey = extractFileKey(sourceChunk.path);
+		for (const targetId of targetIds) {
+			const targetChunk = chunkById.get(targetId);
+			if (!targetChunk) continue;
+			const pairKey = sourceId < targetId ? `${sourceId}::${targetId}` : `${targetId}::${sourceId}`;
+			if (seenPairs.has(pairKey)) continue;
+			seenPairs.add(pairKey);
+			const targetFileKey = extractFileKey(targetChunk.path);
+			if (config.crossFileOnly && sourceFileKey === targetFileKey) continue;
+			const contentRatio = sequenceMatcherRatio(sourceChunk.content.slice(0, 500), targetChunk.content.slice(0, 500));
+			if (contentRatio >= config.maxContentOverlap) {
+				logger?.info(`Skipping near-duplicate pair: ${sourceChunk.path} <-> ${targetChunk.path} (ratio: ${contentRatio.toFixed(2)})`);
+				continue;
+			}
+			const targetKeywords = getKeywords(targetChunk);
+			const targetNormalized = targetKeywords.map(normalizeKeyword);
+			const sharedKeywords = [];
+			for (const kw of sourceKeywords) {
+				const normalized = normalizeKeyword(kw);
+				if (targetNormalized.includes(normalized)) sharedKeywords.push(kw);
+			}
+			if (sharedKeywords.length < config.minKeywordOverlap) continue;
+			const finalScore = computeKeywordScore(sourceKeywords, targetKeywords, sharedKeywords) * config.keywordScoreWeight;
+			if (finalScore < config.minScoreThreshold) continue;
+			connections.push({
+				source: sourceId,
+				target: targetId,
+				relation: "related",
+				score: finalScore,
+				sharedKeywords
+			});
+		}
+	}
+	logger?.info(`Built ${connections.length} connections before filtering`);
+	connections.sort((a, b) => b.score - a.score);
+	if (config.maxConnectionsPerChunk > 0) {
+		const connectionsByChunk = /* @__PURE__ */ new Map();
+		for (const conn of connections) {
+			if (!connectionsByChunk.has(conn.source)) connectionsByChunk.set(conn.source, []);
+			if (!connectionsByChunk.has(conn.target)) connectionsByChunk.set(conn.target, []);
+			connectionsByChunk.get(conn.source).push(conn);
+			connectionsByChunk.get(conn.target).push(conn);
+		}
+		const kept = /* @__PURE__ */ new Set();
+		for (const [chunkId, conns] of connectionsByChunk) {
+			const topN = conns.sort((a, b) => b.score - a.score).slice(0, config.maxConnectionsPerChunk);
+			for (const conn of topN) kept.add(conn);
+		}
+		const filtered = connections.filter((conn) => kept.has(conn));
+		logger?.info(`Filtered to ${filtered.length} connections after maxConnectionsPerChunk limit`);
+		return filtered;
+	}
+	return connections;
+}
+var init_connect_builder = __esmMin((() => {}));
+//#endregion
+init_connect_builder();
+export { buildConnections, init_connect_builder };

package/dist/graph-builder.js

@@ -0,0 +1,204 @@
+import { __toESM } from "./_virtual/_rolldown/runtime.js";
+import { require_nodejieba } from "./node_modules/.pnpm/nodejieba@2.6.0/node_modules/nodejieba/index.js";
+//#region src/graph-builder.ts
+var import_nodejieba = /* @__PURE__ */ __toESM(require_nodejieba(), 1);
+/**
+* Extract file key from chunk path
+*/
+function extractFileKey(path) {
+	const parts = path.split("/");
+	if (parts.length >= 2) return parts[1];
+	return path;
+}
+/**
+* Extract label from chunk path (last segment)
+*/
+function extractLabel(path) {
+	const parts = path.split("/");
+	return parts[parts.length - 1] || path;
+}
+/**
+* Extract tokens from text using jieba
+* Equivalent to Python: _extract_tokens_from_content
+*/
+function extractTokensFromContent(content, jiebaInitialized) {
+	const cleanContent = content.replace(/<[^>]*>/g, " ");
+	if (!jiebaInitialized) return cleanContent.split(/\s+/).filter((w) => w.length > 1);
+	try {
+		return import_nodejieba.cut(cleanContent).filter((token) => {
+			if (token.length <= 1) return false;
+			if (/^\d+$/.test(token)) return false;
+			if (/^[^\w\u4e00-\u9fa5]+$/.test(token)) return false;
+			return true;
+		});
+	} catch (error) {
+		return cleanContent.split(/\s+/).filter((w) => w.length > 1);
+	}
+}
+/**
+* Compute TF-IDF top keywords for a file
+* Equivalent to Python: _compute_tfidf_top_keywords
+*/
+function computeTfidfTopKeywords(fileChunks, allChunks, topK, jiebaInitialized) {
+	if (fileChunks.length === 0) return [];
+	const fileTokens = [];
+	for (const chunk of fileChunks) {
+		const tokens = extractTokensFromContent(chunk.content, jiebaInitialized);
+		fileTokens.push(...tokens);
+	}
+	if (fileTokens.length === 0) return [];
+	const termFreq = /* @__PURE__ */ new Map();
+	for (const token of fileTokens) {
+		const normalized = token.toLowerCase();
+		termFreq.set(normalized, (termFreq.get(normalized) || 0) + 1);
+	}
+	const docFreq = /* @__PURE__ */ new Map();
+	for (const chunk of allChunks) {
+		const tokens = new Set(extractTokensFromContent(chunk.content, jiebaInitialized).map((t) => t.toLowerCase()));
+		for (const token of tokens) docFreq.set(token, (docFreq.get(token) || 0) + 1);
+	}
+	const totalDocs = allChunks.length;
+	const tfidfScores = [];
+	for (const [term, tf] of termFreq) {
+		const df = docFreq.get(term) || 1;
+		const tfidf = tf * Math.log(totalDocs / df);
+		tfidfScores.push({
+			term,
+			score: tfidf
+		});
+	}
+	tfidfScores.sort((a, b) => b.score - a.score);
+	return tfidfScores.slice(0, topK).map((item) => item.term);
+}
+/**
+* Compute file importance based on chunk count and usage heat
+* Equivalent to Python: _compute_file_importance
+*
+* Formula: (chunk_count_weight * normalized_chunk_count) + (heat_weight * usage_heat)
+* Usage heat uses exponential decay: sum(e^(-decay * days_since_access))
+*/
+function computeFileImportance(fileKey, fileChunks, allChunks, chunkStats, decayRate = .01) {
+	const chunkCountWeight = .3;
+	const heatWeight = .7;
+	const fileChunkCount = fileChunks.length;
+	const maxChunkCount = Math.max(...getAllChunkCountsByFile(allChunks));
+	const normalizedChunkCount = maxChunkCount > 0 ? fileChunkCount / maxChunkCount : 0;
+	let usageHeat = 0;
+	const now = Date.now();
+	for (const chunk of fileChunks) {
+		const stats = chunkStats[chunk.chunk_id];
+		if (stats && stats.hit_count > 0) {
+			const daysSinceAccess = (now - (stats.last_accessed ? new Date(stats.last_accessed).getTime() : now)) / (1e3 * 60 * 60 * 24);
+			const decayedHitCount = stats.hit_count * Math.exp(-decayRate * daysSinceAccess);
+			usageHeat += decayedHitCount;
+		}
+	}
+	const normalizedHeat = Math.min(usageHeat / 100, 1);
+	const importance = chunkCountWeight * normalizedChunkCount + heatWeight * normalizedHeat;
+	return Math.min(importance, 1);
+}
+/**
+* Helper: Get chunk counts by file
+*/
+function getAllChunkCountsByFile(chunks) {
+	const countsByFile = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const fileKey = extractFileKey(chunk.path);
+		countsByFile.set(fileKey, (countsByFile.get(fileKey) || 0) + 1);
+	}
+	return Array.from(countsByFile.values());
+}
+/**
+* Aggregate chunk-level connections into file-level edges
+* Equivalent to Python: _aggregate_file_level_edges
+*/
+function aggregateFileLevelEdges(connections, chunkById, topN = 5) {
+	const filePairs = /* @__PURE__ */ new Map();
+	for (const conn of connections) {
+		const sourceChunk = chunkById.get(conn.source);
+		const targetChunk = chunkById.get(conn.target);
+		if (!sourceChunk || !targetChunk) continue;
+		const sourceFile = extractFileKey(sourceChunk.path);
+		const targetFile = extractFileKey(targetChunk.path);
+		if (sourceFile === targetFile) continue;
+		const pairKey = sourceFile < targetFile ? `${sourceFile}::${targetFile}` : `${targetFile}::${sourceFile}`;
+		if (!filePairs.has(pairKey)) filePairs.set(pairKey, []);
+		filePairs.get(pairKey).push(conn);
+	}
+	const fileEdges = [];
+	for (const [pairKey, conns] of filePairs) {
+		const [sourceFile, targetFile] = pairKey.split("::");
+		const avgScore = conns.reduce((sum, conn) => sum + conn.score, 0) / conns.length;
+		const topConns = conns.sort((a, b) => b.score - a.score).slice(0, topN).map((conn) => {
+			const sourceChunk = chunkById.get(conn.source);
+			const targetChunk = chunkById.get(conn.target);
+			return {
+				source_chunk: extractLabel(sourceChunk.path),
+				source_id: conn.source,
+				target_chunk: extractLabel(targetChunk.path),
+				target_id: conn.target,
+				relation: conn.relation,
+				score: conn.score
+			};
+		});
+		fileEdges.push({
+			source: sourceFile,
+			target: targetFile,
+			connection_count: conns.length,
+			avg_score: avgScore,
+			top_connections: topConns
+		});
+	}
+	return fileEdges;
+}
+/**
+* Main function to build knowledge graph
+* Equivalent to Python: build_knowledge_graph
+*/
+function buildKnowledgeGraph(chunks, connections, chunkStats, jiebaInitialized, logger) {
+	logger?.info(`Building knowledge graph from ${chunks.length} chunks and ${connections.length} connections`);
+	const chunkById = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) chunkById.set(chunk.chunk_id, chunk);
+	const chunksByFile = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const fileKey = extractFileKey(chunk.path);
+		if (!chunksByFile.has(fileKey)) chunksByFile.set(fileKey, []);
+		chunksByFile.get(fileKey).push(chunk);
+	}
+	const filesMetadata = {};
+	for (const [fileKey, fileChunks] of chunksByFile) {
+		const typeCount = {};
+		for (const chunk of fileChunks) {
+			const type = chunk.metadata.type || "text";
+			typeCount[type] = (typeCount[type] || 0) + 1;
+		}
+		const topKeywords = computeTfidfTopKeywords(fileChunks, chunks, 10, jiebaInitialized);
+		const importance = computeFileImportance(fileKey, fileChunks, chunks, chunkStats);
+		let topSummary = "";
+		for (const chunk of fileChunks) if (chunk.metadata.summary && typeof chunk.metadata.summary === "string") {
+			topSummary = chunk.metadata.summary;
+			break;
+		}
+		filesMetadata[fileKey] = {
+			chunks_count: fileChunks.length,
+			types: typeCount,
+			top_keywords: topKeywords,
+			top_summary: topSummary,
+			importance
+		};
+	}
+	const fileEdges = aggregateFileLevelEdges(connections, chunkById, 5);
+	logger?.info(`Created graph with ${Object.keys(filesMetadata).length} files and ${fileEdges.length} edges`);
+	return {
+		version: "2.0",
+		stats: {
+			total_files: Object.keys(filesMetadata).length,
+			total_chunks: chunks.length,
+			total_cross_file_edges: fileEdges.length
+		},
+		files: filesMetadata,
+		edges: fileEdges
+	};
+}
+//#endregion
+export { buildKnowledgeGraph };

package/dist/index.js

@@ -1,6 +1,7 @@
-import { knowherePluginConfigSchema, readPersistedApiKey, resolveKnowhereConfig } from "./config.js";
+import { knowherePluginConfigSchema, readPersistedApiKey, resolveKnowhereConfig, resolveKnowledgeGraphConfig } from "./config.js";
 import { KnowhereStore } from "./store.js";
 import { createKnowhereToolFactory } from "./tools.js";
+import { KnowledgeGraphService } from "./kg-service.js";
 //#region src/index.ts
 const plugin = {
 	id: "knowhere-claw",
@@ -9,11 +10,19 @@ const plugin = {
 	configSchema: knowherePluginConfigSchema,
 	register(api) {
 		const config = resolveKnowhereConfig(api);
+		const kgConfig = resolveKnowledgeGraphConfig(api.pluginConfig && typeof api.pluginConfig === "object" ? api.pluginConfig : {});
 		const store = new KnowhereStore({
 			rootDir: config.storageDir,
 			scopeMode: config.scopeMode,
 			logger: api.logger
 		});
+		const kgService = new KnowledgeGraphService({
+			config: kgConfig,
+			logger: api.logger
+		});
+		kgService.initialize().catch((error) => {
+			api.logger.warn(`knowhere: knowledge graph service initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
 		if (!config.apiKey) readPersistedApiKey(config.storageDir).then((persistedKey) => {
 			if (persistedKey) {
 				config.apiKey = persistedKey;
@@ -25,7 +34,8 @@ const plugin = {
 		api.registerTool(createKnowhereToolFactory({
 			api,
 			config,
-			store
+			store,
+			kgService
 		}), { names: [
 			"knowhere_ingest_document",
 			"knowhere_list_jobs",
@@ -37,7 +47,9 @@ const plugin = {
 			"knowhere_list_documents",
 			"knowhere_remove_document",
 			"knowhere_clear_scope",
-			"knowhere_set_api_key"
+			"knowhere_set_api_key",
+			"knowhere_kg_list",
+			"knowhere_kg_query"
 		] });
 	}
 };