local-knowledge-graph 1.6.1 → 1.7.0

package/lib/ingest.js

@@ -0,0 +1,355 @@
+'use strict';
+
+// 文档批量入图：上传 md/txt/pdf → 分片 → LLM抽取候选三元组 → 人工审核 → 批量入库
+// 任务持久化于 data/ingest_tasks/<id>.json，服务重启后 review 态可继续。
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { DATA_DIR } = require('./paths');
+const db = require('./db');
+const agent = require('./agent');
+
+const TASK_DIR = path.join(DATA_DIR, 'ingest_tasks');
+const MAX_SIZE = 10 * 1024 * 1024;
+const CHUNK_SIZE = 3000;
+const ACCEPT = ['.md', '.markdown', '.txt', '.pdf'];
+const CONFIDENCE = ['确证', '推测', '存疑'];
+
+const tasks = new Map(); // id -> task
+
+function ensureDir() { fs.mkdirSync(TASK_DIR, { recursive: true }); }
+
+function persist(task) {
+  ensureDir();
+  fs.writeFileSync(path.join(TASK_DIR, task.id + '.json'), JSON.stringify(task, null, 2));
+}
+
+function loadPersisted() {
+  ensureDir();
+  for (const f of fs.readdirSync(TASK_DIR)) {
+    if (!f.endsWith('.json')) continue;
+    try {
+      const t = JSON.parse(fs.readFileSync(path.join(TASK_DIR, f), 'utf8'));
+      if (t.status === 'extracting' || t.status === 'parsing') t.status = 'interrupted';
+      tasks.set(t.id, t);
+    } catch (_) { /* 损坏任务文件跳过 */ }
+  }
+}
+
+function listTasks() {
+  return [...tasks.values()]
+    .sort((a, b) => (b.created_at || '').localeCompare(a.created_at || ''))
+    .map((t) => ({ id: t.id, filename: t.filename, status: t.status, chunks_total: t.chunks_total, failed_chunks: (t.failed_chunks || []).length, entity_count: t.candidates.entities.length, relation_count: t.candidates.relations.length, created_at: t.created_at, error: t.error || null }));
+}
+
+function getTask(id) { return tasks.get(id) || null; }
+
+// ---------- 解析与分片 ----------
+async function extractText(filename, buffer) {
+  const ext = path.extname(filename).toLowerCase();
+  if (ext === '.pdf') {
+    const pdfParse = require('pdf-parse');
+    const r = await pdfParse(buffer);
+    return r.text || '';
+  }
+  return buffer.toString('utf8');
+}
+
+function chunkText(text) {
+  const paras = text.split(/\n{2,}/).map((s) => s.trim()).filter(Boolean);
+  const chunks = [];
+  let cur = '';
+  for (const p of paras) {
+    if (p.length > CHUNK_SIZE) {
+      if (cur) { chunks.push(cur); cur = ''; }
+      for (let i = 0; i < p.length; i += CHUNK_SIZE) chunks.push(p.slice(i, i + CHUNK_SIZE));
+      continue;
+    }
+    if ((cur + '\n\n' + p).length > CHUNK_SIZE) { chunks.push(cur); cur = p; }
+    else cur = cur ? cur + '\n\n' + p : p;
+  }
+  if (cur) chunks.push(cur);
+  return chunks;
+}
+
+// ---------- LLM 抽取 ----------
+function extractPrompt(chunk) {
+  return `你是三元组抽取器。禁止调用任何工具、禁止写入图谱、禁止执行操作，只阅读文本并直接输出JSON。
+严格输出JSON（禁止多余文字/代码块标记/解释），结构：
+{"entities":[{"name":"实体名","category":"物理实体|抽象实体|数值实体|时间实体","attributes":{"扁平键":"原子值"},"aliases":["别名"]}],"relations":[{"from":"起点实体名","to":"终点实体名","name":"关系名","category":"空间|互动|归属|时间|属性","confidence":"确证|推测|存疑"}]}
+要求：实体类别从4类中选最贴切的一种；关系类别从5类中选；confidence按文本依据强度标注，无把握用"推测"；属性值只能是字符串/数值/布尔；只依据文本内容，禁止编造；没有可抽取内容时输出 {"entities":[],"relations":[]}。
+
+文本：
+${chunk}`;
+}
+
+function safeParseJson(text) {
+  if (!text) return null;
+  let t = String(text).trim();
+  const m = t.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (m) t = m[1].trim();
+  const start = t.indexOf('{');
+  const end = t.lastIndexOf('}');
+  if (start === -1 || end === -1 || end <= start) return null;
+  try { return JSON.parse(t.slice(start, end + 1)); } catch (_) {
+    try { return JSON.parse(t.slice(start, end + 1).replace(/,\s*([}\]])/g, '$1')); } catch (_) { return null; }
+  }
+}
+
+function normalizeCandidates(raw, filename, chunkIdx) {
+  const srcRef = `《${filename}》片段${chunkIdx + 1}`;
+  const entities = [];
+  const relations = [];
+  if (raw && Array.isArray(raw.entities)) {
+    for (const e of raw.entities) {
+      if (!e || typeof e.name !== 'string' || !e.name.trim()) continue;
+      entities.push({
+        name: e.name.trim(),
+        category: ['物理实体', '抽象实体', '数值实体', '时间实体'].includes(e.category) ? e.category : '抽象实体',
+        attributes: (e.attributes && typeof e.attributes === 'object' && !Array.isArray(e.attributes)) ? e.attributes : {},
+        aliases: Array.isArray(e.aliases) ? e.aliases.filter((a) => typeof a === 'string' && a.trim()).map((a) => a.trim()).slice(0, 10) : [],
+        existing_id: null,
+        selected: true,
+      });
+    }
+  }
+  if (raw && Array.isArray(raw.relations)) {
+    for (const r of raw.relations) {
+      if (!r || typeof r.from !== 'string' || typeof r.to !== 'string' || typeof r.name !== 'string') continue;
+      if (!r.from.trim() || !r.to.trim() || !r.name.trim()) continue;
+      relations.push({
+        from: r.from.trim(),
+        to: r.to.trim(),
+        name: r.name.trim(),
+        category: ['空间', '互动', '归属', '时间', '属性'].includes(r.category) ? r.category : '属性',
+        confidence: CONFIDENCE.includes(r.confidence) ? r.confidence : '推测',
+        source_ref: srcRef,
+        existing_relation: null,
+        selected: true,
+      });
+    }
+  }
+  return { entities, relations };
+}
+
+// 实体自动匹配：主名→别名（同时检测候选之间重复）
+// 索引值区分两种命中：{entity_id} 指向现有实体；{cand} 指向候选下标
+function matchEntities(task) {
+  const nameIndex = new Map();
+  for (const e of db.listEntities()) {
+    nameIndex.set(e.name, { entity_id: e.id });
+    for (const a of db.listAliases(e.id)) if (!nameIndex.has(a.alias)) nameIndex.set(a.alias, { entity_id: e.id });
+  }
+  task.candidates.entities.forEach((c, i) => {
+    if (nameIndex.has(c.name)) {
+      const v = nameIndex.get(c.name);
+      if (v.entity_id !== undefined) { c.existing_id = v.entity_id; return; }
+      c.existing_id = v.cand;
+      c.dupe_of_candidate = true;
+      return;
+    }
+    nameIndex.set(c.name, { cand: i });
+    for (const a of c.aliases) if (!nameIndex.has(a)) nameIndex.set(a, { cand: i });
+  });
+  const resolve = (name) => {
+    const v = nameIndex.get(name);
+    return v ? { ...v } : null;
+  };
+  for (const r of task.candidates.relations) {
+    r.from_ref = resolve(r.from);
+    r.to_ref = resolve(r.to);
+    r.unresolved = !r.from_ref || !r.to_ref;
+  }
+}
+
+// ---------- 任务流程 ----------
+async function createTask(filename, buffer, opts = {}) {
+  const { runPlain, autoCommit = false } = opts;
+  const ext = path.extname(filename || '').toLowerCase();
+  if (!ACCEPT.includes(ext)) { const e = new Error(`仅支持 ${ACCEPT.join(' / ')} 格式`); e.status = 400; throw e; }
+  if (!buffer || buffer.length > MAX_SIZE) { const e = new Error('文件超过10MB上限'); e.status = 413; throw e; }
+
+  const dupCount = [...tasks.values()].filter((t) => t.filename === filename).length;
+  const task = {
+    id: crypto.randomBytes(6).toString('hex'),
+    filename,
+    display_name: dupCount ? `${filename}（第${dupCount + 1}次导入）` : filename,
+    status: 'parsing',
+    chunks_total: 0,
+    failed_chunks: [],
+    candidates: { entities: [], relations: [] },
+    auto_commit: !!autoCommit,
+    created_at: new Date().toISOString(),
+    committed_at: null,
+    error: null,
+  };
+  tasks.set(task.id, task);
+  storeUpload(task.id, filename, buffer);
+  persist(task);
+
+  // 异步执行，接口立即返回任务id；抽取走只读模式，杜绝Agent写库
+  run(task, buffer, runPlain || ((p, t) => agent.runPlain(p, t || 180000, { KG_MCP_READONLY: '1' })))
+    .catch((e) => {
+      task.status = 'failed';
+      task.error = e.message;
+      persist(task);
+    })
+    .finally(() => { if (typeof opts.onSettled === 'function') { try { opts.onSettled(); } catch (_) {} } });
+  return { id: task.id, status: task.status };
+}
+
+async function run(task, buffer, runPlain) {
+  // 1) 解析
+  let text;
+  try {
+    text = await extractText(task.filename, buffer);
+  } catch (e) {
+    task.status = 'failed';
+    task.error = '文档解析失败: ' + e.message;
+    persist(task);
+    return;
+  }
+  if (!text.trim()) {
+    task.status = 'failed';
+    task.error = '文档无可提取文本';
+    persist(task);
+    return;
+  }
+  const chunks = chunkText(text);
+  task.chunks_total = chunks.length;
+  task.status = 'extracting';
+  persist(task);
+
+  // 2) 逐片抽取
+  const raws = [];
+  task.chunk_errors = task.chunk_errors || [];
+  for (let i = 0; i < chunks.length; i++) {
+    try {
+      const out = await runPlain(extractPrompt(chunks[i]));
+      const outText = typeof out === 'string' ? out : (out && out.ok === false ? null : String((out && out.text) || ''));
+      if (outText === null) { task.chunk_errors.push({ chunk: i, error: (out && out.error) || '空结果' }); task.failed_chunks.push(i); continue; }
+      const parsed = safeParseJson(outText);
+      if (!parsed) { task.chunk_errors.push({ chunk: i, error: 'LLM输出无法解析为JSON：' + outText.slice(0, 120) }); task.failed_chunks.push(i); continue; }
+      raws.push(normalizeCandidates(parsed, task.filename, i));
+    } catch (e) {
+      task.chunk_errors.push({ chunk: i, error: e.message });
+      task.failed_chunks.push(i);
+      if (i === chunks.length - 1 && !raws.length && e.message && /超时|timeout/i.test(e.message)) {
+        task.error = 'LLM调用超时: ' + e.message;
+      }
+    }
+  }
+  // 3) 合并候选（同名实体去重合并别名）
+  for (const r of raws) {
+    for (const e of r.entities) {
+      const exist = task.candidates.entities.find((x) => x.name === e.name);
+      if (exist) { for (const a of e.aliases) if (!exist.aliases.includes(a)) exist.aliases.push(a); for (const [k, v] of Object.entries(e.attributes)) if (!(k in exist.attributes)) exist.attributes[k] = v; }
+      else task.candidates.entities.push(e);
+    }
+    task.candidates.relations.push(...r.relations);
+  }
+  // 关系去重（from+name+to）
+  const seen = new Set();
+  task.candidates.relations = task.candidates.relations.filter((r) => {
+    const key = `${r.from}|${r.name}|${r.to}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  matchEntities(task);
+
+  if (!task.candidates.entities.length && !task.candidates.relations.length) {
+    task.status = 'failed';
+    task.error = task.failed_chunks.length
+      ? (task.error || `全部${task.chunks_total}个片段抽取失败` + (task.chunk_errors.length ? `（首个错误: ${task.chunk_errors[0].error}）` : ''))
+      : '未抽取到候选三元组';
+    persist(task);
+    return;
+  }
+  task.status = 'review';
+  persist(task);
+
+  // 4) 跳过审核直通
+  if (task.auto_commit) commitTask(task.id, null, '系统');
+}
+
+function commitTask(id, selected, source) {
+  const task = tasks.get(id);
+  if (!task) { const e = new Error(`任务${id}不存在`); e.status = 404; throw e; }
+  if (task.status !== 'review') { const e = new Error(`任务状态为${task.status}，无法提交`); e.status = 400; throw e; }
+  const ents = task.candidates.entities.filter((c) => c.selected && (!c.dupe_of_candidate));
+  const rels = task.candidates.relations.filter((r) => r.selected && !r.unresolved);
+  if (selected) {
+    const entNames = new Set((selected.entities || []).map((s) => String(s)));
+    const relKeys = new Set(selected.relations || []);
+    for (const c of ents) c._want = entNames.has(c.name);
+    for (const r of rels) r._want = relKeys.has(`${r.from}|${r.name}|${r.to}`);
+  } else {
+    for (const c of ents) c._want = true;
+    for (const r of rels) r._want = true;
+  }
+
+  const applied = null;
+  void applied;
+  // 先打保存点再写入
+  const git = require('./git');
+  git.savepoint(`文档入图: ${task.display_name}`, source === '系统' ? '系统' : '手工');
+
+  const nameToId = new Map();
+  let entAdded = 0, entLinked = 0, relAdded = 0, relSkipped = 0;
+  const opsLog = [];
+  for (const c of ents) {
+    if (!c._want) continue;
+    if (c.existing_id !== null && c.existing_id !== undefined && typeof c.existing_id === 'number') {
+      nameToId.set(c.name, c.existing_id);
+      entLinked += 1;
+      for (const a of c.aliases) {
+        try { db.addAlias(c.existing_id, a, source === '系统' ? '系统' : '手工'); } catch (_) { /* 别名冲突忽略 */ }
+      }
+      continue;
+    }
+    const created = db.addEntity({ name: c.name, category: c.category, attributes: c.attributes }, '文档');
+    nameToId.set(c.name, created.id);
+    entAdded += 1;
+    for (const a of c.aliases) {
+      try { db.addAlias(created.id, a, source === '系统' ? '系统' : '手工'); } catch (_) {}
+    }
+    opsLog.push({ type: 'ADD_ENTITY', name: c.name, id: created.id });
+  }
+  for (const r of rels) {
+    if (!r._want) { relSkipped += 1; continue; }
+    const fromId = r.from_ref && r.from_ref.entity_id ? r.from_ref.entity_id : nameToId.get(r.from);
+    const toId = r.to_ref && r.to_ref.entity_id ? r.to_ref.entity_id : nameToId.get(r.to);
+    if (!fromId || !toId || fromId === toId) { relSkipped += 1; continue; }
+    try {
+      const created = db.addRelation({ source_id: fromId, target_id: toId, name: r.name, category: r.category, confidence: r.confidence, source_ref: r.source_ref }, '文档');
+      relAdded += 1;
+      opsLog.push({ type: 'ADD_RELATION', id: created.id, name: r.name, from: fromId, to: toId });
+    } catch (_) { relSkipped += 1; }
+  }
+  task.status = 'committed';
+  task.committed_at = new Date().toISOString();
+  task.result = { entities_added: entAdded, entities_linked: entLinked, relations_added: relAdded, relations_skipped: relSkipped };
+  persist(task);
+  return { ok: true, ...task.result, savepoint: task.display_name };
+}
+
+function deleteTask(id) {
+  const task = tasks.get(id);
+  if (!task) { const e = new Error(`任务${id}不存在`); e.status = 404; throw e; }
+  if (task.status === 'extracting' || task.status === 'parsing') { const e = new Error('任务执行中，请稍后再删除'); e.status = 400; throw e; }
+  tasks.delete(id);
+  try { fs.unlinkSync(path.join(TASK_DIR, id + '.json')); } catch (_) {}
+  return { deleted: id };
+}
+
+// 上传文件暂存（供审核期间重试/溯源）
+function storeUpload(id, filename, buffer) {
+  ensureDir();
+  const dir = path.join(DATA_DIR, 'uploads');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, id + '_' + filename), buffer);
+}
+
+module.exports = { createTask, listTasks, getTask, commitTask, deleteTask, storeUpload, loadPersisted, chunkText, safeParseJson, normalizeCandidates, matchEntities, extractText, extractPrompt, ACCEPT };

package/lib/rdf.js

@@ -42,6 +42,9 @@ function exportTurtle(graph) {
     for (const [k, v] of Object.entries(attrs)) {
       chunks.push(`    kg:attribute [ kg:key ${lit(k)} ; kg:value ${lit(v)} ]`);
     }
+    for (const alias of (graph.aliases && graph.aliases[e.id]) || []) {
+      chunks.push(`    kg:alias ${lit(alias)}`);
+    }
     parts.push(chunks.length ? lines.join('\n') + ' ;\n' + chunks.join(' ;\n') + ' .\n' : lines.join('\n') + ' .\n');
   }
 
@@ -53,6 +56,8 @@ function exportTurtle(graph) {
       `    kg:category "${esc(r.category)}" ;\n` +
       `    kg:subject kg:e${r.source_id} ;\n` +
       `    kg:object kg:e${r.target_id} ;\n` +
+      `    kg:confidence "${esc(r.confidence || '确证')}" ;\n` +
+      `    kg:sourceRef ${lit(r.source_ref || '')} ;\n` +
       `    kg:createdAt "${esc(r.created_at)}"^^xsd:dateTime ;\n` +
       `    kg:source "${esc(r.source)}" .\n`
     );

package/lib/similar.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// 相似实体：优先嵌入向量余弦Top-K，向量不可用时降级为共邻居Jaccard
+
+const db = require('./db');
+const embeddings = require('./embeddings');
+const vectors = require('./vectors');
+
+function coNeighborScores(targetId, entities, relations) {
+  const neighbors = new Map();
+  for (const r of relations) {
+    if (r.source_id === targetId) neighbors.set(r.target_id, 1);
+    if (r.target_id === targetId) neighbors.set(r.source_id, 1);
+  }
+  if (!neighbors.size) return [];
+  const incident = new Map();
+  for (const r of relations) {
+    for (const [a, b] of [[r.source_id, r.target_id], [r.target_id, r.source_id]]) {
+      if (!incident.has(a)) incident.set(a, new Set());
+      incident.get(a).add(b);
+    }
+  }
+  const own = incident.get(targetId) || new Set();
+  const scores = [];
+  for (const e of entities) {
+    if (e.id === targetId) continue;
+    const other = incident.get(e.id);
+    if (!other || !other.size) continue;
+    let inter = 0;
+    for (const n of other) if (own.has(n)) inter += 1;
+    if (inter === 0 && !neighbors.has(e.id)) continue;
+    const union = new Set([...own, ...other]).size;
+    scores.push({ id: e.id, score: inter / union });
+  }
+  return scores;
+}
+
+async function similarEntities(id, k = 8) {
+  const target = db.getEntity(id);
+  if (!target) { const e = new Error(`实体id=${id} 不存在`); e.status = 404; throw e; }
+  const cap = Math.min(20, Math.max(1, Number.isInteger(k) ? k : 8));
+  const graph = db.getGraph();
+  const byId = new Map(graph.entities.map((e) => [e.id, e]));
+
+  // 语义路径：目标向量缺失时即时补算
+  let semantic = [];
+  const s = embeddings.loadSettings();
+  if (s.api_key && vectors.count() > 0) {
+    try {
+      let trow = vectors.get(id);
+      if (!trow) {
+        const [vec] = await embeddings.embed([embeddings.entityText(target)], s);
+        vectors.upsert(id, Float32Array.from(vec));
+        trow = { entity_id: id, vector: Float32Array.from(vec) };
+      }
+      const tvec = Float32Array.from(trow.vector);
+      semantic = vectors.all()
+        .filter((row) => row.entity_id !== id)
+        .map((row) => ({ id: row.entity_id, score: embeddings.cosine(tvec, Float32Array.from(row.vector)) }))
+        .filter((x) => x.score > 0.1);
+    } catch (_) { semantic = []; }
+  }
+
+  if (semantic.length) {
+    semantic.sort((a, b) => b.score - a.score);
+    return {
+      mode: 'semantic',
+      results: semantic.slice(0, cap).map((x) => ({ entity: byId.get(x.id), score: Number(x.score.toFixed(4)) })).filter((x) => x.entity),
+    };
+  }
+
+  // 结构降级：共邻居Jaccard
+  const struct = coNeighborScores(id, graph.entities, graph.relations)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, cap)
+    .map((x) => ({ entity: byId.get(x.id), score: Number(x.score.toFixed(4)) }))
+    .filter((x) => x.entity);
+  return { mode: 'structure', results: struct };
+}
+
+module.exports = { similarEntities };

package/lib/validator.js

@@ -4,7 +4,8 @@
 
 const ENTITY_CATEGORIES = ['物理实体', '抽象实体', '数值实体', '时间实体'];
 const RELATION_CATEGORIES = ['空间', '互动', '归属', '时间', '属性'];
-const SOURCES = ['手工', 'OpenCode', '系统'];
+const SOURCES = ['手工', 'OpenCode', '系统', '文档'];
+const CONFIDENCE_LEVELS = ['确证', '推测', '存疑'];
 const RDF_TYPE_MAP = {
   '物理实体': 'PhysicalEntity',
   '抽象实体': 'AbstractEntity',
@@ -106,8 +107,17 @@ function validateRelationInput(input, db) {
     errors.push(`关系大类必须为以下5类之一: ${RELATION_CATEGORIES.join(' / ')}`);
   }
 
+  const confidence = input.confidence === undefined || input.confidence === null || input.confidence === '' ? '确证' : input.confidence;
+  if (!CONFIDENCE_LEVELS.includes(confidence)) {
+    errors.push(`置信度必须为以下3档之一: ${CONFIDENCE_LEVELS.join(' / ')}`);
+  }
+
+  const source_ref = input.source_ref === undefined || input.source_ref === null ? '' : input.source_ref;
+  if (typeof source_ref !== 'string') errors.push('来源引用(source_ref)必须为字符串');
+  else if (source_ref.length > 500) errors.push('来源引用长度不得超过500字符');
+
   if (errors.length) return { ok: false, errors, value: null };
-  return { ok: true, errors: [], value: { source_id: sid, target_id: tid, name: name.trim(), category } };
+  return { ok: true, errors: [], value: { source_id: sid, target_id: tid, name: name.trim(), category, confidence, source_ref } };
 }
 
 function validateRelationPatch(patch, existing, db) {
@@ -117,6 +127,8 @@ function validateRelationPatch(patch, existing, db) {
     target_id: existing.target_id,
     name: existing.name,
     category: existing.category,
+    confidence: existing.confidence || '确证',
+    source_ref: existing.source_ref || '',
   };
   if (patch.source_id !== undefined) merged.source_id = patch.source_id;
   if (patch.target_id !== undefined) merged.target_id = patch.target_id;
@@ -128,6 +140,17 @@ function validateRelationPatch(patch, existing, db) {
     if (!RELATION_CATEGORIES.includes(patch.category)) errors.push(`关系大类必须为: ${RELATION_CATEGORIES.join(' / ')}`);
     else merged.category = patch.category;
   }
+  if (patch.confidence !== undefined) {
+    if (patch.confidence === null || patch.confidence === '') merged.confidence = '确证';
+    else if (!CONFIDENCE_LEVELS.includes(patch.confidence)) errors.push(`置信度必须为: ${CONFIDENCE_LEVELS.join(' / ')}`);
+    else merged.confidence = patch.confidence;
+  }
+  if (patch.source_ref !== undefined) {
+    if (patch.source_ref === null) merged.source_ref = '';
+    else if (typeof patch.source_ref !== 'string') errors.push('来源引用(source_ref)必须为字符串');
+    else if (patch.source_ref.length > 500) errors.push('来源引用长度不得超过500字符');
+    else merged.source_ref = patch.source_ref;
+  }
   const check = validateRelationInput(merged, db);
   if (errors.length || !check.ok) return { ok: false, errors: [...errors, ...check.errors], value: null };
   return check;
@@ -137,6 +160,7 @@ module.exports = {
   ENTITY_CATEGORIES,
   RELATION_CATEGORIES,
   SOURCES,
+  CONFIDENCE_LEVELS,
   RDF_TYPE_MAP,
   RDF_RELATION_TYPE_MAP,
   validateEntityInput,

package/mcp/server.js

@@ -98,6 +98,19 @@ const TOOLS = [
       properties: { center: { type: 'string', description: '可选，实体id或名称' } },
     },
   },
+  {
+    name: 'kg_path',
+    description: '两实体关系路径枚举：返回最多5条按跳数升序的路径（每跳含关系名/类别/置信度），用于验证两个对象如何间接关联',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        from: { type: 'string', description: '起点实体id或名称' },
+        to: { type: 'string', description: '终点实体id或名称' },
+        max: { type: 'number', description: '可选，最大跳数2-6，默认4' },
+      },
+      required: ['from', 'to'],
+    },
+  },
   {
     name: 'kg_digest',
     description: '图谱目录：实体大类、关系大类、高频关系名Top20（含数量）、样例实体、规模。回答关系类问题前先取此目录，可显著提升Cypher查询的准确性',
@@ -200,6 +213,11 @@ const HANDLERS = {
     const { digest, stats } = require('./lib/ask').buildDigest();
     return { digest, ...stats };
   },
+  kg_path: async (args) => {
+    const from = resolveCenter(String(args.from || ''));
+    const to = resolveCenter(String(args.to || ''));
+    return db.findPaths(from.id, to.id, { maxHops: Number.isInteger(args.max) ? args.max : 4 });
+  },
   kg_export_rdf: async () => ({ turtle: rdf.exportTurtle(db.getGraph()) }),
   kg_apply_ops: async (args) => {
     if (READONLY) throw new Error('MCP运行于只读模式（KG_MCP_READONLY=1），写入被拒绝');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-knowledge-graph",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "本地知识图谱整合器：3D可视化 + AI对话建图 + 智能检索 + Git回溯 + RDF合规，全流程本地运行",
   "main": "server.js",
   "bin": {
@@ -25,7 +25,8 @@
     "test": "node --test \"test/*.test.js\""
   },
   "dependencies": {
-    "express": "^4.22.3"
+    "express": "^4.22.3",
+    "pdf-parse": "^2.4.5"
   },
   "keywords": [
     "knowledge-graph",