@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/to-comparators.js

@@ -0,0 +1,11 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_range } from "../classes/range.js";
+//#region node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Range = require_range();
+	const toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+	module.exports = toComparators;
+}));
+//#endregion
+export default require_to_comparators();
+export { require_to_comparators };

package/dist/node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/valid.js

@@ -0,0 +1,17 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_range } from "../classes/range.js";
+//#region node_modules/.pnpm/semver@7.7.4/node_modules/semver/ranges/valid.js
+var require_valid = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Range = require_range();
+	const validRange = (range, options) => {
+		try {
+			return new Range(range, options).range || "*";
+		} catch (er) {
+			return null;
+		}
+	};
+	module.exports = validRange;
+}));
+//#endregion
+export default require_valid();
+export { require_valid };

package/dist/node_modules/.pnpm/set-blocking@2.0.0/node_modules/set-blocking/index.js

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/set-blocking@2.0.0/node_modules/set-blocking/index.js
+var require_set_blocking = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function(blocking) {
+		[process.stdout, process.stderr].forEach(function(stream) {
+			if (stream._handle && stream.isTTY && typeof stream._handle.setBlocking === "function") stream._handle.setBlocking(blocking);
+		});
+	};
+}));
+//#endregion
+export default require_set_blocking();
+export { require_set_blocking };

package/dist/node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js

@@ -0,0 +1,130 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_signals } from "./signals.js";
+//#region node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
+var require_signal_exit = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var process = global.process;
+	const processOk = function(process) {
+		return process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
+	};
+	/* istanbul ignore if */
+	if (!processOk(process)) module.exports = function() {
+		return function() {};
+	};
+	else {
+		var assert = __require("assert");
+		var signals = require_signals();
+		var isWin = /^win/i.test(process.platform);
+		var EE = __require("events");
+		/* istanbul ignore if */
+		if (typeof EE !== "function") EE = EE.EventEmitter;
+		var emitter;
+		if (process.__signal_exit_emitter__) emitter = process.__signal_exit_emitter__;
+		else {
+			emitter = process.__signal_exit_emitter__ = new EE();
+			emitter.count = 0;
+			emitter.emitted = {};
+		}
+		if (!emitter.infinite) {
+			emitter.setMaxListeners(Infinity);
+			emitter.infinite = true;
+		}
+		module.exports = function(cb, opts) {
+			/* istanbul ignore if */
+			if (!processOk(global.process)) return function() {};
+			assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+			if (loaded === false) load();
+			var ev = "exit";
+			if (opts && opts.alwaysLast) ev = "afterexit";
+			var remove = function() {
+				emitter.removeListener(ev, cb);
+				if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) unload();
+			};
+			emitter.on(ev, cb);
+			return remove;
+		};
+		var unload = function unload() {
+			if (!loaded || !processOk(global.process)) return;
+			loaded = false;
+			signals.forEach(function(sig) {
+				try {
+					process.removeListener(sig, sigListeners[sig]);
+				} catch (er) {}
+			});
+			process.emit = originalProcessEmit;
+			process.reallyExit = originalProcessReallyExit;
+			emitter.count -= 1;
+		};
+		module.exports.unload = unload;
+		var emit = function emit(event, code, signal) {
+			/* istanbul ignore if */
+			if (emitter.emitted[event]) return;
+			emitter.emitted[event] = true;
+			emitter.emit(event, code, signal);
+		};
+		var sigListeners = {};
+		signals.forEach(function(sig) {
+			sigListeners[sig] = function listener() {
+				/* istanbul ignore if */
+				if (!processOk(global.process)) return;
+				if (process.listeners(sig).length === emitter.count) {
+					unload();
+					emit("exit", null, sig);
+					/* istanbul ignore next */
+					emit("afterexit", null, sig);
+					/* istanbul ignore next */
+					if (isWin && sig === "SIGHUP") sig = "SIGINT";
+					/* istanbul ignore next */
+					process.kill(process.pid, sig);
+				}
+			};
+		});
+		module.exports.signals = function() {
+			return signals;
+		};
+		var loaded = false;
+		var load = function load() {
+			if (loaded || !processOk(global.process)) return;
+			loaded = true;
+			emitter.count += 1;
+			signals = signals.filter(function(sig) {
+				try {
+					process.on(sig, sigListeners[sig]);
+					return true;
+				} catch (er) {
+					return false;
+				}
+			});
+			process.emit = processEmit;
+			process.reallyExit = processReallyExit;
+		};
+		module.exports.load = load;
+		var originalProcessReallyExit = process.reallyExit;
+		var processReallyExit = function processReallyExit(code) {
+			/* istanbul ignore if */
+			if (!processOk(global.process)) return;
+			process.exitCode = code || 0;
+			emit("exit", process.exitCode, null);
+			/* istanbul ignore next */
+			emit("afterexit", process.exitCode, null);
+			/* istanbul ignore next */
+			originalProcessReallyExit.call(process, process.exitCode);
+		};
+		var originalProcessEmit = process.emit;
+		var processEmit = function processEmit(ev, arg) {
+			if (ev === "exit" && processOk(global.process)) {
+				/* istanbul ignore else */
+				if (arg !== void 0) process.exitCode = arg;
+				var ret = originalProcessEmit.apply(this, arguments);
+				/* istanbul ignore next */
+				emit("exit", process.exitCode, null);
+				/* istanbul ignore next */
+				emit("afterexit", process.exitCode, null);
+				/* istanbul ignore next */
+				return ret;
+			} else return originalProcessEmit.apply(this, arguments);
+		};
+	}
+}));
+//#endregion
+export default require_signal_exit();
+export { require_signal_exit };

package/dist/node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js

@@ -0,0 +1,16 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/signals.js
+var require_signals = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = [
+		"SIGABRT",
+		"SIGALRM",
+		"SIGHUP",
+		"SIGINT",
+		"SIGTERM"
+	];
+	if (process.platform !== "win32") module.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+	if (process.platform === "linux") module.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+}));
+//#endregion
+export default require_signals();
+export { require_signals };

package/dist/node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js

@@ -0,0 +1,30 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_strip_ansi } from "../../../strip-ansi@6.0.1/node_modules/strip-ansi/index.js";
+import { require_is_fullwidth_code_point } from "../../../is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js";
+import { require_emoji_regex } from "../../../emoji-regex@8.0.0/node_modules/emoji-regex/index.js";
+//#region node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js
+var require_string_width = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const stripAnsi = require_strip_ansi();
+	const isFullwidthCodePoint = require_is_fullwidth_code_point();
+	const emojiRegex = require_emoji_regex();
+	const stringWidth = (string) => {
+		if (typeof string !== "string" || string.length === 0) return 0;
+		string = stripAnsi(string);
+		if (string.length === 0) return 0;
+		string = string.replace(emojiRegex(), "  ");
+		let width = 0;
+		for (let i = 0; i < string.length; i++) {
+			const code = string.codePointAt(i);
+			if (code <= 31 || code >= 127 && code <= 159) continue;
+			if (code >= 768 && code <= 879) continue;
+			if (code > 65535) i++;
+			width += isFullwidthCodePoint(code) ? 2 : 1;
+		}
+		return width;
+	};
+	module.exports = stringWidth;
+	module.exports.default = stringWidth;
+}));
+//#endregion
+export default require_string_width();
+export { require_string_width };

package/dist/node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js

@@ -0,0 +1,10 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_ansi_regex } from "../../../ansi-regex@5.0.1/node_modules/ansi-regex/index.js";
+//#region node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js
+var require_strip_ansi = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const ansiRegex = require_ansi_regex();
+	module.exports = (string) => typeof string === "string" ? string.replace(ansiRegex(), "") : string;
+}));
+//#endregion
+export default require_strip_ansi();
+export { require_strip_ansi };

package/dist/node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js

@@ -0,0 +1,26 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js
+var require_universalify = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.fromCallback = function(fn) {
+		return Object.defineProperty(function(...args) {
+			if (typeof args[args.length - 1] === "function") fn.apply(this, args);
+			else return new Promise((resolve, reject) => {
+				args.push((err, res) => err != null ? reject(err) : resolve(res));
+				fn.apply(this, args);
+			});
+		}, "name", { value: fn.name });
+	};
+	exports.fromPromise = function(fn) {
+		return Object.defineProperty(function(...args) {
+			const cb = args[args.length - 1];
+			if (typeof cb !== "function") return fn.apply(this, args);
+			else {
+				args.pop();
+				fn.apply(this, args).then((r) => cb(null, r), cb);
+			}
+		}, "name", { value: fn.name });
+	};
+}));
+//#endregion
+export default require_universalify();
+export { require_universalify };

package/dist/node_modules/.pnpm/util-deprecate@1.0.2/node_modules/util-deprecate/browser.js

@@ -0,0 +1,59 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/util-deprecate@1.0.2/node_modules/util-deprecate/browser.js
+var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Module exports.
+	*/
+	module.exports = deprecate;
+	/**
+	* Mark that a method should not be used.
+	* Returns a modified function which warns once by default.
+	*
+	* If `localStorage.noDeprecation = true` is set, then it is a no-op.
+	*
+	* If `localStorage.throwDeprecation = true` is set, then deprecated functions
+	* will throw an Error when invoked.
+	*
+	* If `localStorage.traceDeprecation = true` is set, then deprecated functions
+	* will invoke `console.trace()` instead of `console.error()`.
+	*
+	* @param {Function} fn - the function to deprecate
+	* @param {String} msg - the string to print to the console when `fn` is invoked
+	* @returns {Function} a new "deprecated" version of `fn`
+	* @api public
+	*/
+	function deprecate(fn, msg) {
+		if (config("noDeprecation")) return fn;
+		var warned = false;
+		function deprecated() {
+			if (!warned) {
+				if (config("throwDeprecation")) throw new Error(msg);
+				else if (config("traceDeprecation")) console.trace(msg);
+				else console.warn(msg);
+				warned = true;
+			}
+			return fn.apply(this, arguments);
+		}
+		return deprecated;
+	}
+	/**
+	* Checks `localStorage` for boolean values for the given `name`.
+	*
+	* @param {String} name
+	* @returns {Boolean}
+	* @api private
+	*/
+	function config(name) {
+		try {
+			if (!global.localStorage) return false;
+		} catch (_) {
+			return false;
+		}
+		var val = global.localStorage[name];
+		if (null == val) return false;
+		return String(val).toLowerCase() === "true";
+	}
+}));
+//#endregion
+export default require_browser();
+export { require_browser };

package/dist/node_modules/.pnpm/wide-align@1.1.5/node_modules/wide-align/align.js

@@ -0,0 +1,52 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_string_width } from "../../../string-width@4.2.3/node_modules/string-width/index.js";
+//#region node_modules/.pnpm/wide-align@1.1.5/node_modules/wide-align/align.js
+var require_align = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var stringWidth = require_string_width();
+	exports.center = alignCenter;
+	exports.left = alignLeft;
+	exports.right = alignRight;
+	function createPadding(width) {
+		var result = "";
+		var string = " ";
+		var n = width;
+		do {
+			if (n % 2) result += string;
+			n = Math.floor(n / 2);
+			string += string;
+		} while (n);
+		return result;
+	}
+	function alignLeft(str, width) {
+		var trimmed = str.trimRight();
+		if (trimmed.length === 0 && str.length >= width) return str;
+		var padding = "";
+		var strWidth = stringWidth(trimmed);
+		if (strWidth < width) padding = createPadding(width - strWidth);
+		return trimmed + padding;
+	}
+	function alignRight(str, width) {
+		var trimmed = str.trimLeft();
+		if (trimmed.length === 0 && str.length >= width) return str;
+		var padding = "";
+		var strWidth = stringWidth(trimmed);
+		if (strWidth < width) padding = createPadding(width - strWidth);
+		return padding + trimmed;
+	}
+	function alignCenter(str, width) {
+		var trimmed = str.trim();
+		if (trimmed.length === 0 && str.length >= width) return str;
+		var padLeft = "";
+		var padRight = "";
+		var strWidth = stringWidth(trimmed);
+		if (strWidth < width) {
+			var padLeftBy = parseInt((width - strWidth) / 2, 10);
+			padLeft = createPadding(padLeftBy);
+			padRight = createPadding(width - (strWidth + padLeftBy));
+		}
+		return padLeft + trimmed + padRight;
+	}
+}));
+//#endregion
+export default require_align();
+export { require_align };

package/dist/node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js

@@ -0,0 +1,26 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
+var require_wrappy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = wrappy;
+	function wrappy(fn, cb) {
+		if (fn && cb) return wrappy(fn)(cb);
+		if (typeof fn !== "function") throw new TypeError("need wrapper function");
+		Object.keys(fn).forEach(function(k) {
+			wrapper[k] = fn[k];
+		});
+		return wrapper;
+		function wrapper() {
+			var args = new Array(arguments.length);
+			for (var i = 0; i < args.length; i++) args[i] = arguments[i];
+			var ret = fn.apply(this, args);
+			var cb = args[args.length - 1];
+			if (typeof ret === "function" && ret !== cb) Object.keys(cb).forEach(function(k) {
+				ret[k] = cb[k];
+			});
+			return ret;
+		}
+	}
+}));
+//#endregion
+export default require_wrappy();
+export { require_wrappy };

package/dist/tools.js

@@ -9,6 +9,45 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/core";
 //#region src/tools.ts
+async function buildKnowledgeGraphAsync(params) {
+	const docDir = path.join(params.scope.documentsDir, params.docId);
+	const metadataPath = path.join(docDir, "metadata.json");
+	let payload = null;
+	try {
+		payload = await fs.readFile(metadataPath, "utf-8");
+	} catch {
+		payload = null;
+	}
+	if (!payload) {
+		params.api.logger.warn(`knowhere: cannot build KG, metadata not found for docId=${params.docId}`);
+		return;
+	}
+	const payloadData = JSON.parse(payload);
+	const fullMarkdownPath = path.join(docDir, "full_markdown.txt");
+	let fullMarkdown = "";
+	try {
+		fullMarkdown = await fs.readFile(fullMarkdownPath, "utf-8");
+	} catch {
+		params.api.logger.warn(`knowhere: full_markdown.txt not found for docId=${params.docId}, using empty content`);
+	}
+	const keywords = await params.kgService.extractKeywords(fullMarkdown, 20);
+	await params.kgService.saveDocumentToKb({
+		kbId: params.kbId,
+		docId: params.docId,
+		sourcePath: docDir,
+		keywords,
+		metadata: {
+			title: payloadData.document?.title || "Untitled",
+			sourceLabel: payloadData.document?.sourceLabel || "Unknown",
+			checksum: params.documentPayload.downloadedResult.rawZipSha1,
+			ingestedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	});
+	await params.kgService.scheduleBuild(params.kbId, async () => {
+		await params.kgService.buildKnowledgeGraph(params.kbId);
+	});
+	params.api.logger.info(`knowhere: knowledge graph build completed kbId=${params.kbId} docId=${params.docId}`);
+}
 const PREVIEW_SUMMARY_MAX_CHARS = 120;
 const INGEST_TRACKER_LANGUAGES = new Set(["ch", "en"]);
 function textResult(text) {
@@ -492,7 +531,7 @@ function createIngestTool(params) {
 	return {
 		name: "knowhere_ingest_document",
 		label: "Knowhere Ingest",
-		description: "Parse a local file or remote URL with Knowhere and store the result in the current scope. Before calling this for a document that might already be stored in the current scope, use knowhere_list_documents and reuse the existing stored document when Source, File, or Title clearly match unless the user explicitly asks for a fresh parse or overwrite. When the user provides a URL to a document (PDF link, web page, etc.), pass it as the url parameter — Knowhere fetches it directly, no local download needed. Returns immediately with a job ID while parsing continues in the background. Use knowhere_get_job_status to check progress at any time. Use lang to control the language of the direct tracker follow-up (`en` by default, `ch` for Chinese). Provide either filePath or url, not both.",
+		description: "Parse a local file or remote URL with Knowhere and store the result in the current scope. Before calling this for a document that might already be stored in the current scope, use knowhere_list_documents and reuse the existing stored document when Source, File, or Title clearly match unless the user explicitly asks for a fresh parse or overwrite. When the user provides a URL to a document (PDF link, web page, etc.), pass it as the url parameter — Knowhere fetches it directly, no local download needed. Returns immediately with a job ID while parsing continues in the background. Use knowhere_get_job_status only when the current turn needs the parsed result. Use lang to control the language of any user-facing background status update (`en` by default, `ch` for Chinese). Provide either filePath or url, not both.",
 		parameters: {
 			type: "object",
 			additionalProperties: false,
@@ -536,7 +575,7 @@ function createIngestTool(params) {
 				},
 				lang: {
 					type: "string",
-					description: "Language for the direct tracker follow-up message sent after background parsing completes or fails. Supports en and ch; unsupported values fall back to en."
+					description: "Language for any user-facing background status update sent after parsing completes or fails. Supports en and ch; unsupported values fall back to en."
 				},
 				parsing: {
 					type: "object",
@@ -629,6 +668,25 @@ function createIngestTool(params) {
 					downloadedResult: ingestResult.downloadedResult
 				}, { overwrite });
 				params.api.logger.info(`knowhere: knowhere_ingest_document stored document scope=${scope.label} jobId=${ingestResult.job.job_id} docId=${storedDocument.id} label=${JSON.stringify(progressLabel)}`);
+				if (params.kgService.isEnabled()) {
+					const kbId = params.kgService.resolveKbId(params.ctx);
+					if (kbId) {
+						params.api.logger.info(`knowhere: initiating knowledge graph build kbId=${kbId} docId=${storedDocument.id}`);
+						buildKnowledgeGraphAsync({
+							kgService: params.kgService,
+							kbId,
+							docId: storedDocument.id,
+							documentPayload: ingestResult,
+							scope,
+							ctx: params.ctx,
+							api: params.api,
+							channelRoute,
+							sessionKey
+						}).catch((kgError) => {
+							params.api.logger.error(`knowhere: knowledge graph build failed kbId=${kbId} docId=${storedDocument.id}: ${formatErrorMessage(kgError)}`);
+						});
+					}
+				}
 				await notifyBackgroundIngestOutcome({
 					api: params.api,
 					context: params.ctx,
@@ -679,7 +737,7 @@ function createIngestTool(params) {
 				`Job ID: ${createdJob.job_id}`,
 				`File: ${progressLabel}`,
 				`Scope: ${scope.label}`,
-				"Use knowhere_get_job_status to check progress at any time."
+				"Use knowhere_get_job_status only if this turn needs the parsed result."
 			].join("\n"));
 		}
 	};
@@ -1479,12 +1537,104 @@ function createSetApiKeyTool(params) {
 		}
 	};
 }
+function createKgListTool(params) {
+	return {
+		name: "knowhere_kg_list",
+		label: "Knowhere KG List",
+		description: "List all available knowledge bases with optional statistics. Returns knowledge base IDs, document counts, and graph metadata.",
+		parameters: {
+			type: "object",
+			additionalProperties: false,
+			properties: { includeStats: {
+				type: "boolean",
+				description: "Include document count and graph statistics"
+			} }
+		},
+		execute: async (_toolCallId, rawParams) => {
+			const includeStats = readBoolean((isRecord(rawParams) ? rawParams : {}).includeStats, false);
+			if (!params.kgService.isEnabled()) return textResult("Knowledge graph is disabled or unavailable.");
+			params.api.logger.info(`knowhere: knowhere_kg_list listing knowledge bases includeStats=${includeStats}`);
+			const kbIds = await params.kgService.listKnowledgeBases();
+			if (kbIds.length === 0) return textResult("No knowledge bases found.");
+			const lines = [`Found ${kbIds.length} knowledge base(s):`, ""];
+			if (includeStats) {
+				const statsPromises = kbIds.map(async (kbId) => {
+					return {
+						kbId,
+						metadata: await params.kgService.getKbMetadata(kbId)
+					};
+				});
+				const stats = await Promise.all(statsPromises);
+				for (const { kbId, metadata } of stats) {
+					lines.push(`- ${kbId}`);
+					if (metadata) {
+						lines.push(`  Documents: ${metadata.documentCount || 0}`);
+						lines.push(`  Created: ${metadata.createdAt || "unknown"}`);
+						lines.push(`  Last updated: ${metadata.lastUpdated || "unknown"}`);
+					}
+				}
+			} else for (const kbId of kbIds) lines.push(`- ${kbId}`);
+			return textResult(lines.join("\n"));
+		}
+	};
+}
+function createKgQueryTool(params) {
+	return {
+		name: "knowhere_kg_query",
+		label: "Knowhere KG Query",
+		description: "Query the knowledge graph for file-level connections and document relationships. Returns the complete knowledge graph structure with file metadata, top keywords, importance scores, and cross-file edges.",
+		parameters: {
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				kbId: {
+					type: "string",
+					description: "Knowledge base ID to query"
+				},
+				fileKey: {
+					type: "string",
+					description: "Optional: Filter edges for a specific file (e.g., 'report.docx')"
+				}
+			},
+			required: ["kbId"]
+		},
+		execute: async (_toolCallId, rawParams) => {
+			const paramsRecord = isRecord(rawParams) ? rawParams : {};
+			const kbId = readString(paramsRecord.kbId);
+			const fileKey = readString(paramsRecord.fileKey);
+			if (!kbId) throw new Error("kbId is required.");
+			if (!params.kgService.isEnabled()) return textResult("Knowledge graph is disabled or unavailable.");
+			params.api.logger.info(`knowhere: knowhere_kg_query querying graph kbId=${kbId} fileKey=${fileKey || "all"}`);
+			const graph = await params.kgService.getKnowledgeGraph(kbId);
+			if (!graph) return textResult(`Knowledge graph not found for knowledge base ${kbId}.`);
+			let edges = graph.edges;
+			if (fileKey) {
+				edges = edges.filter((edge) => edge.source === fileKey || edge.target === fileKey);
+				if (edges.length === 0) return textResult(`No connections found for file ${fileKey} in knowledge base ${kbId}.`);
+			}
+			return formatJsonToolResult({
+				kbId,
+				version: graph.version,
+				stats: graph.stats,
+				files: graph.files,
+				edges: edges.map((edge) => ({
+					source: edge.source,
+					target: edge.target,
+					connection_count: edge.connection_count,
+					avg_score: edge.avg_score,
+					top_connections: edge.top_connections
+				}))
+			});
+		}
+	};
+}
 function createKnowhereToolFactory(params) {
 	return (ctx) => [
 		createIngestTool({
 			api: params.api,
 			config: params.config,
 			store: params.store,
+			kgService: params.kgService,
 			ctx
 		}),
 		createJobListTool({
@@ -1538,6 +1688,16 @@ function createKnowhereToolFactory(params) {
 		createSetApiKeyTool({
 			api: params.api,
 			config: params.config
+		}),
+		createKgListTool({
+			api: params.api,
+			kgService: params.kgService,
+			ctx
+		}),
+		createKgQueryTool({
+			api: params.api,
+			kgService: params.kgService,
+			ctx
 		})
 	];
 }

package/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Knowhere",
   "description": "Parse documents with Knowhere and expose the stored result as tool-queryable document state for OpenClaw agents.",
   "skills": ["./skills"],
-  "version": "0.1.4",
+  "version": "0.1.5",
   "uiHints": {
     "apiKey": {
       "label": "Knowhere API Key",