local-knowledge-graph 1.9.0 → 1.10.1

package/HELP.md

@@ -112,8 +112,8 @@ kg
 ### 与本程序结合的路线
 
 1. **已具备**：传递/对称/逆公理推理 + 问答证据链 + MCP 推理查询（外部 Agent 可调 `kg_inference`）
-2. **低成本扩展·共同邻居推荐**：A→B、B→C 有边则提示 A↔C 为候选关系，在实体信息卡列出"推荐关系"，一键让 AI 验证或人工确认入库
-3. **AI 推荐关系**：选取两个实体，把二者属性与邻域子图交给 LLM 判断"是否存在关系、是什么关系、依据是什么"，经审核界面勾选入库（复用文档入图的审核管线）
+2. **已具备·共同邻居推荐**：检索页签"关系推荐"卡一键扫描全图——无直接边但拥有共同邻居的实体对自动列为候选（Adamic-Adar 打分，邻居越稀有越靠前）；实体信息卡"推荐关系"按钮查看与该实体相关的候选。每条候选可点「AI 判断」让 LLM 给出关系名/大类/置信度/依据，确认后一键采纳入库（来源引用自动记为 AI 推荐依据，可撤销）
+3. **已具备·AI 推荐关系**：即上条「AI 判断」——把两实体属性与共同关联交给大模型判断"是否存在关系、是什么关系、依据是什么"，输出仅供决策，入库必须人工点击确认（AI 不直接写库）
 4. **进阶·自定义规则**：设置页开放规则编辑（如 师从(A,B) ∧ 师从(B,C) ⇒ 同门(A,C)），与内置传递/对称推理共用"推"标记展示
 
 ### 应用场景与效益
@@ -128,6 +128,7 @@ kg
 
 - **AI 对话建图**：右侧输入自然语言指令（联网补全），或上传文档（md/txt/pdf/docx）批量抽取三元组
 - **智能提问**：检索页签一句话找关系（LLM 编译检索计划，本地只读执行，可生成带引用的综述）
+- **关系推荐**：共同邻居算法找"该连没连"的实体对，AI 判断后一键采纳入库（检索页签"关系推荐"卡 / 实体卡"推荐关系"按钮）
 - **语义检索**：配置硅基流动 API Key 后支持语义+关键词混合检索（未配置时自动退化为关键词模式）
 - **最短路径 / 中心子图 / 推理**：挖掘实体间关联链路、层级范围与隐性关系（方法体系见上文"知识推理"章节）
 - **撤销**：Ctrl+Z 或按钮，可连续撤销
@@ -164,6 +165,7 @@ kg
 
 ## 版本历史摘要
 
+- **v1.10.0**：关系推荐——共同邻居算法（Adamic-Adar 打分，排除已有直接边）全图/中心实体两种扫描；AI 判断候选关系（LLM 给出关系名/大类/置信度/依据，人工确认后入库，不直接写库）；检索页签新增"关系推荐"卡，实体信息卡新增"推荐关系"按钮
 - **v1.9.0**：检索配置增强（Base URL 页面可配 + 测试连接按钮，保存前即可验证密钥/地址/模型）；关系图片绑定（信息卡上传/缩略图/灯箱，佐证材料与关系绑定，删关系连带清理）；帮助文档全面增补（检索配置详解/关系编辑与图片/知识推理方法体系与应用场景）
 - **v1.8.0**：MCP 外部接入——设置新增 MCP 页签（服务开关/只读模式/令牌管理/三类客户端一键复制配置）；`/mcp` Streamable HTTP 端点（令牌鉴权+CORS，12 个工具含完整 CRUD）；`kg --mcp` 本机 stdio 接入；图谱变更实时同步（SSE 推送+跨进程探测，页面 3 秒内自动刷新）
 - **v1.7.0**：六项图谱能力升级——①实体别名（增删/全局唯一/搜索与消歧联动）②同名冲突检测（创建即提示，可合并可强制）③多路径查找（2-6跳，图上高亮，MCP kg_path）④相似实体推荐（语义+结构双模式）⑤关系置信度三档（确证/推测/存疑，样式区分可过滤）与来源引用标注 ⑥智能问答附证据路径链 ⑦文档批量入图（md/txt/pdf→LLM抽取→审核勾选→来源标记入库，支持跳过审核）

package/lib/recommend.js

@@ -0,0 +1,133 @@
+'use strict';
+
+// 关系推荐：共同邻居图算法（Adamic-Adar打分）+ LLM候选关系判断
+// 设计约束：推荐纯本地只读计算；LLM判断只输出建议JSON，入库须经前端确认（走人工接口，来源'手工'）。
+
+const REL_CATS = ['空间', '互动', '归属', '时间', '属性'];
+const CONF_LEVELS = ['确证', '推测', '存疑'];
+const MAX_LLM_TIMEOUT = 60000; // opencode CLI 实测冷启动+推理可达30-50s，与综述超时一致
+
+// ---------- 共同邻居推荐 ----------
+// 对每对无直接边的实体统计共同邻居并按 Adamic-Adar 打分（邻居越稀有分越高）。
+// opts.centerId 限定只返回与该实体相关的候选；opts.minCommon 最小共同邻居数（默认2，center模式1）；opts.limit 返回上限（默认20）。
+function computeCoNeighborRecs(graph, opts = {}) {
+  const centerId = opts.centerId || null;
+  const limit = Math.min(Math.max(1, Number(opts.limit) || 20), 100);
+  const minCommon = Math.max(1, Number(opts.minCommon) || (centerId ? 1 : 2));
+
+  const byId = new Map(graph.entities.map((e) => [e.id, e]));
+  const neighbors = new Map(); // id -> Map(邻居id -> 经该邻居相连的关系数)
+  const touch = (id) => { if (!neighbors.has(id)) neighbors.set(id, new Map()); };
+  const direct = new Set(); // 'a|b' 双向规范化键
+  const dkey = (a, b) => (a < b ? `${a}|${b}` : `${b}|${a}`);
+  for (const r of graph.relations) {
+    if (!byId.has(r.source_id) || !byId.has(r.target_id)) continue;
+    touch(r.source_id); touch(r.target_id);
+    neighbors.get(r.source_id).set(r.target_id, (neighbors.get(r.source_id).get(r.target_id) || 0) + 1);
+    neighbors.get(r.target_id).set(r.source_id, (neighbors.get(r.target_id).get(r.source_id) || 0) + 1);
+    direct.add(dkey(r.source_id, r.target_id));
+  }
+
+  // 每节点收集2跳计数：O(V * deg^2)，大图时节点按度截断保护
+  const DEG_CAP = 300;
+  const nodes = [...byId.keys()].filter((id) => neighbors.has(id));
+  const counter = new Map(); // 'a|b' -> Map(commonId -> true)
+  for (const a of nodes) {
+    const nbs = [...neighbors.get(a).keys()];
+    if (nbs.length > DEG_CAP) continue; // 度数过高的枢纽节点跳过全对展开，防爆炸
+    for (const m of nbs) {
+      const mn = neighbors.get(m);
+      if (!mn) continue;
+      for (const b of mn.keys()) {
+        if (b === a || neighbors.get(a).has(b)) continue; // 自身或已有直接边
+        const k = dkey(a, b);
+        if (!counter.has(k)) counter.set(k, new Map());
+        counter.get(k).set(m, true);
+      }
+    }
+  }
+
+  const nameOf = (id) => (byId.get(id) ? byId.get(id).name : `#${id}`);
+  const recs = [];
+  for (const [k, commons] of counter) {
+    if (commons.size < minCommon) continue;
+    const [a, b] = k.split('|').map(Number);
+    if (centerId && a !== centerId && b !== centerId) continue;
+    // Adamic-Adar：sum(1/log(deg(共同邻居)))
+    let score = 0;
+    for (const c of commons.keys()) {
+      const deg = (neighbors.get(c) || new Map()).size || 1;
+      score += 1 / Math.log(deg + 1);
+    }
+    recs.push({
+      source_id: a, target_id: b,
+      source_name: nameOf(a), target_name: nameOf(b),
+      common_count: commons.size,
+      common_names: [...commons.keys()].slice(0, 6).map(nameOf),
+      score: Number(score.toFixed(4)),
+    });
+  }
+  recs.sort((x, y) => y.score - x.score || y.common_count - x.common_count);
+  return recs.slice(0, limit);
+}
+
+// ---------- LLM 候选关系判断 ----------
+function buildJudgePrompt(a, b, commonNames) {
+  const ent = (e) => {
+    let s = `- ${e.name}（${e.category}）`;
+    let attrs = '';
+    try { attrs = JSON.stringify(JSON.parse(e.attributes || '{}')); } catch (_) { attrs = String(e.attributes || '{}'); }
+    if (attrs && attrs !== '{}') s += ` 属性:${attrs.slice(0, 300)}`;
+    return s;
+  };
+  return [
+    '你是知识图谱专家。判断以下两个实体之间是否存在值得录入图谱的明确关系（基于常识与给出的事实，不要编造）。',
+    `实体A: ${ent(a)}`,
+    `实体B: ${ent(b)}`,
+    commonNames && commonNames.length ? `它们在图谱中拥有共同关联: ${commonNames.join('、')}` : '',
+    '',
+    '只输出JSON（不要其他文字），格式：',
+    '{"has_relation": true/false, "name": "关系名(2-4字，如 师从/位于/效力于)", "category": "空间|互动|归属|时间|属性 之一", "confidence": "确证|推测|存疑 之一", "evidence": "一句话依据"}',
+    'has_relation 为 false 时其余字段留空字符串。',
+  ].filter(Boolean).join('\n');
+}
+
+// 校验LLM输出；非法字段回退默认或拒绝
+function validateJudge(j) {
+  if (!j || typeof j !== 'object') return { ok: false, error: '输出不是JSON对象' };
+  const out = {
+    has_relation: Boolean(j.has_relation),
+    name: String(j.name || '').trim().slice(0, 30),
+    category: REL_CATS.includes(j.category) ? j.category : '',
+    confidence: CONF_LEVELS.includes(j.confidence) ? j.confidence : '推测',
+    evidence: String(j.evidence || '').trim().slice(0, 300),
+  };
+  if (!out.has_relation) return { ok: true, judge: { has_relation: false } };
+  if (!out.name) return { ok: false, error: 'has_relation为true时关系名不能为空' };
+  if (!out.category) return { ok: false, error: `关系大类必须是: ${REL_CATS.join('/')}` };
+  return { ok: true, judge: out };
+}
+
+function extractJson(text) {
+  let t = String(text || '').trim().replace(/```(?:json)?/gi, '');
+  const start = t.indexOf('{');
+  const end = t.lastIndexOf('}');
+  if (start === -1 || end <= start) throw new Error('输出中未找到JSON对象');
+  return JSON.parse(t.slice(start, end + 1));
+}
+
+// runPlain 可注入（测试mock）；graph 关系用于取两实体邻域摘要
+async function aiJudgeRelation(payload, runPlain) {
+  const { a, b, common_names } = payload || {};
+  if (!a || !b) { const e = new Error('必须提供待判断的两个实体'); e.status = 400; throw e; }
+  const rp = runPlain || require('./agent').runPlain;
+  const r = await rp(buildJudgePrompt(a, b, common_names || []), MAX_LLM_TIMEOUT);
+  if (!r.ok) { const e = new Error(`LLM判断失败: ${r.error}`); e.status = 502; throw e; }
+  let raw;
+  try { raw = extractJson(r.text); } catch (e) { const err = new Error(`LLM输出无法解析: ${e.message}`); err.status = 502; throw err; }
+  const v = validateJudge(raw);
+  if (!v.ok) { const err = new Error(`LLM输出校验未通过: ${v.error}`); err.status = 502; throw err; }
+  return { ...v.judge, source_id: a.id, target_id: b.id, source_name: a.name, target_name: b.name };
+}
+
+module.exports = { computeCoNeighborRecs, buildJudgePrompt, validateJudge, aiJudgeRelation, REL_CATS, CONF_LEVELS };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-knowledge-graph",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "本地知识图谱整合器：3D可视化 + AI对话建图 + 智能检索 + Git回溯 + RDF合规，全流程本地运行",
   "main": "server.js",
   "bin": {

package/public/app.js

@@ -256,6 +256,83 @@ function makeLabelSprite(text, cssColor, fontSize) {
   return sprite;
 }
 
+/* ---- 平行边弧形分离 ---- */
+// 同对节点多条关系时线弯曲错开：offset 为弧的偏移强度（0=直线），标签置于各弧顶
+const ARC_SEGMENTS = 16;
+function arcOffsetVec(dir, arc) {
+  // 弧偏移方向：取与边垂直的平面，按边序号均匀转开角度；强度=边长*比例，保证不同长度边分离度一致
+  const up = Math.abs(dir.y) > 0.92 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
+  const u = new THREE.Vector3().crossVectors(dir, up).normalize();
+  const v = new THREE.Vector3().crossVectors(dir, u).normalize();
+  const ang = (arc.idx / arc.total) * Math.PI * 2 + 0.6; // 固定相位避免与常用方向重合
+  const strength = 0.14; // 弧顶偏移 = 边长 * strength
+  return u.multiplyScalar(Math.cos(ang)).add(v.multiplyScalar(Math.sin(ang))).multiplyScalar(dir.length() * strength);
+}
+
+// 曲线上参数 t∈[0,1] 的点：a→b 直线叠加抛物弧偏移（中点最大，两端为0）
+function arcPoint(out, a, b, dir, off, t) {
+  const sag = 4 * t * (1 - t);
+  out.set(
+    a.x + dir.x * t + off.x * sag,
+    a.y + dir.y * t + off.y * sag,
+    a.z + dir.z * t + off.z * sag
+  );
+  return out;
+}
+
+function makeRelLine(pa, pb, arc, color, dashed, opacity, dashSize, gapSize) {
+  const pts = [];
+  if (arc) {
+    const dir = pb.clone().sub(pa);
+    const off = arcOffsetVec(dir, arc);
+    for (let i = 0; i <= ARC_SEGMENTS; i++) pts.push(arcPoint(new THREE.Vector3(), pa, pb, dir, off, i / ARC_SEGMENTS).clone());
+  } else {
+    pts.push(pa.clone(), pb.clone());
+  }
+  const geo = new THREE.BufferGeometry().setFromPoints(pts);
+  const mat = dashed
+    ? new THREE.LineDashedMaterial({ color, dashSize, gapSize, transparent: true, opacity })
+    : new THREE.LineBasicMaterial({ color, transparent: true, opacity });
+  const line = new THREE.Line(geo, mat);
+  if (dashed) line.computeLineDistances();
+  return line;
+}
+
+// 每帧根据节点最新位置刷新弧线几何
+const _arcDir = new THREE.Vector3(), _arcOff = new THREE.Vector3(), _arcTmp = new THREE.Vector3();
+function updateRelLine(l) {
+  if (!l.arc) {
+    const posAttr = l.line.geometry.attributes.position;
+    posAttr.setXYZ(0, l.a.pos.x, l.a.pos.y, l.a.pos.z);
+    posAttr.setXYZ(1, l.b.pos.x, l.b.pos.y, l.b.pos.z);
+    posAttr.needsUpdate = true;
+    if (l.dashed) l.line.computeLineDistances();
+    l.label.position.copy(l.a.pos).add(l.b.pos).multiplyScalar(0.5);
+    return;
+  }
+  _arcDir.subVectors(l.b.pos, l.a.pos);
+  _arcOff.copy(arcOffsetVec(_arcDir, l.arc));
+  const posAttr = l.line.geometry.attributes.position;
+  for (let i = 0; i <= ARC_SEGMENTS; i++) {
+    arcPoint(_arcTmp, l.a.pos, l.b.pos, _arcDir, _arcOff, i / ARC_SEGMENTS);
+    posAttr.setXYZ(i, _arcTmp.x, _arcTmp.y, _arcTmp.z);
+  }
+  posAttr.needsUpdate = true;
+  if (l.dashed) l.line.computeLineDistances();
+  // 标签置于弧顶（t=0.5）外移一点，跟随弧线弯曲
+  arcPoint(_arcTmp, l.a.pos, l.b.pos, _arcDir, _arcOff, 0.5);
+  const lift = _arcOff.clone().multiplyScalar(6);
+  l.label.position.copy(_arcTmp).add(lift);
+}
+
+function setRelLabelPos(lbl, pa, pb, arc) {
+  if (!arc) { lbl.position.copy(pa).add(pb).multiplyScalar(0.5); return; }
+  const dir = pb.clone().sub(pa);
+  const off = arcOffsetVec(dir, arc);
+  const p = arcPoint(new THREE.Vector3(), pa, pb, dir, off, 0.5);
+  lbl.position.copy(p).add(off.clone().multiplyScalar(6));
+}
+
 function buildNodeMesh(category) {
   const st = ENTITY_STYLE[category] || { color: 0xaaaaaa };
   let mesh;
@@ -338,6 +415,21 @@ function rebuildGraph() {
     simNodes.push({ id: e.id, pos: mesh.position.clone(), vel: new THREE.Vector3(), mesh, label, radius: 10, sizeScale: ENTITY_STYLE[e.category] ? (ENTITY_STYLE[e.category].size || 1) : 1 });
   });
 
+  // 同节点对的平行边统一编号：线作弧形分离，标签各置弧顶，避免文字与线完全重叠
+  const pairCount = new Map(); // 'a|b'(无向) -> 同对节点边的总数
+  for (const r of rels) {
+    const k = r.source_id < r.target_id ? `${r.source_id}|${r.target_id}` : `${r.target_id}|${r.source_id}`;
+    pairCount.set(k, (pairCount.get(k) || 0) + 1);
+  }
+  const pairSeen = new Map();
+  const arcOf = (r) => {
+    const k = r.source_id < r.target_id ? `${r.source_id}|${r.target_id}` : `${r.target_id}|${r.source_id}`;
+    const n = pairCount.get(k) || 1;
+    const i = pairSeen.get(k) || 0;
+    pairSeen.set(k, i + 1);
+    return n > 1 ? { idx: i, total: n } : null;
+  };
+
   rels.forEach((r) => {
     const a = simNodes.find((n) => n.id === r.source_id);
     const b = simNodes.find((n) => n.id === r.target_id);
@@ -347,21 +439,16 @@ function rebuildGraph() {
     const baseOp = st.opacity === undefined ? 0.9 : st.opacity;
     const op = conf === '存疑' ? Math.min(baseOp, 0.35) : baseOp; // 存疑降不透明度
     const dashed = st.dashed || conf === '推测';                  // 推测强制虚线
-    const geo = new THREE.BufferGeometry().setFromPoints([a.pos, b.pos]);
-    const mat = dashed
-      ? new THREE.LineDashedMaterial({ color: st.color, dashSize: st.dashSize || 6, gapSize: st.gapSize || 4, transparent: true, opacity: op })
-      : new THREE.LineBasicMaterial({ color: st.color, transparent: true, opacity: op });
-    const line = new THREE.Line(geo, mat);
+    const arc = arcOf(r);
+    const line = makeRelLine(a.pos, b.pos, arc, st.color, dashed, op, st.dashSize || 6, st.gapSize || 4);
     line.userData.relationId = r.id;
     line.userData.baseOpacity = op;
     linkGroup.add(line);
-    const mid = a.pos.clone().add(b.pos).multiplyScalar(0.5);
-    // 线标注显示具体关系名（如"父子"），线型/颜色仍由大类规定
     const lbl = makeLabelSprite(r.name, st.css, 24);
     lbl.userData.text = r.name;
-    lbl.position.copy(mid);
+    setRelLabelPos(lbl, a.pos, b.pos, arc);
     labelGroup.add(lbl);
-    simLinks.push({ id: r.id, a, b, line, label: lbl, dashed, confidence: conf });
+    simLinks.push({ id: r.id, a, b, line, label: lbl, dashed, confidence: conf, arc });
   });
 
   // 推理关系叠加：虚化虚线 + "(推)"标注，负数id与库中显式关系区分；仅显示两端均在当前视图的边
@@ -372,16 +459,18 @@ function rebuildGraph() {
       const a = simNodes.find((n) => n.id === ir.source_id);
       const b = simNodes.find((n) => n.id === ir.target_id);
       if (!a || !b) return;
-      const geo = new THREE.BufferGeometry().setFromPoints([a.pos, b.pos]);
-      const mat = new THREE.LineDashedMaterial({ color: 0xc792ea, dashSize: 3, gapSize: 5, transparent: true, opacity: 0.35 });
-      const line = new THREE.Line(geo, mat);
-      line.computeLineDistances();
+      // 推理边并入平行边分组：同对节点的显式边与推理边互不错开编号，仅继续排号
+      const k = ir.source_id < ir.target_id ? `${ir.source_id}|${ir.target_id}` : `${ir.target_id}|${ir.source_id}`;
+      const n = (pairCount.get(k) || 0) + 1;
+      pairCount.set(k, n);
+      const arc = n > 1 ? { idx: n - 1, total: n } : null;
+      const line = makeRelLine(a.pos, b.pos, arc, 0xc792ea, true, 0.35, 3, 5);
       line.userData.relationId = -(idx + 1);
       linkGroup.add(line);
       const lbl = makeLabelSprite(ir.name + '(推)', '#c792ea', 22);
-      lbl.position.copy(a.pos.clone().add(b.pos).multiplyScalar(0.5));
+      setRelLabelPos(lbl, a.pos, b.pos, arc);
       labelGroup.add(lbl);
-      simLinks.push({ id: line.userData.relationId, a, b, line, label: lbl, dashed: true });
+      simLinks.push({ id: line.userData.relationId, a, b, line, label: lbl, dashed: true, arc });
     });
   }
 
@@ -429,12 +518,7 @@ function simStep() {
   }
   settleCount++;
   for (const l of simLinks) {
-    const posAttr = l.line.geometry.attributes.position;
-    posAttr.setXYZ(0, l.a.pos.x, l.a.pos.y, l.a.pos.z);
-    posAttr.setXYZ(1, l.b.pos.x, l.b.pos.y, l.b.pos.z);
-    posAttr.needsUpdate = true;
-    if (l.dashed) l.line.computeLineDistances();
-    l.label.position.copy(l.a.pos).add(l.b.pos).multiplyScalar(0.5);
+    updateRelLine(l);
   }
   for (const nd of simNodes) {
     nd.mesh.position.copy(nd.pos);
@@ -589,9 +673,11 @@ function renderInfoCard() {
         <button onclick="focusEgo(${e.id})">以此为中心</button>
         <button onclick="askPath(${e.id}, '${escapeHtml(e.name).replace(/'/g, "\\'")}')">查路径</button>
         <button onclick="loadSimilar(${e.id})">相似实体</button>
+        <button onclick="loadEntityRecs(${e.id})">推荐关系</button>
         <button onclick="$('entity-img-input').click()">绑图片</button>
       </div>
       <div id="similar-box"></div>
+      <div id="rec-box"></div>
       <div class="btns"><button onclick="editEntity(${e.id})">编辑</button><button class="danger" onclick="delEntity(${e.id})">删除</button></div>`;
     card.style.display = 'block';
     if (imgCount > 0 && !imgs) loadEntityImages(e.id);
@@ -1084,6 +1170,95 @@ async function loadSimilar(id) {
 }
 window.loadSimilar = loadSimilar;
 
+/* ================= 关系推荐（共同邻居 + AI判断） ================= */
+const judgeCache = new Map(); // 'a|b' -> judge结果（本会话内复用，避免重复调LLM）
+
+// 单条候选的展开渲染：AI判断按钮 → 判断结果 → 采纳入库
+function recRowHtml(rec, boxId) {
+  const key = `${rec.source_id}|${rec.target_id}`;
+  const id = `${boxId}-${key.replace(/\|/g, '_')}`;
+  return `<div class="kv" style="padding:6px 0;border-top:1px dashed #2a3a55" id="row-${id}">
+    <span style="cursor:pointer;color:#7fd1ff" onclick="focusEntity(${rec.source_id})">${escapeHtml(rec.source_name)}</span>
+    <b style="color:#c792ea"> ⇄? </b>
+    <span style="cursor:pointer;color:#7fd1ff" onclick="focusEntity(${rec.target_id})">${escapeHtml(rec.target_name)}</span>
+    <span style="color:#8fa3c0;font-size:11px">共同邻居${rec.common_count}：${escapeHtml((rec.common_names || []).join('、'))}　AA ${rec.score}</span>
+    <div style="margin-top:4px"><button class="ghost" onclick="aiJudgeRec(${rec.source_id},${rec.target_id},'${id}')">AI 判断</button></div>
+    <div id="jr-${id}"></div>
+  </div>`;
+}
+
+async function aiJudgeRec(sourceId, targetId, rowId) {
+  const box = $('jr-' + rowId);
+  if (!box) return;
+  const key = `${sourceId}|${targetId}`;
+  if (judgeCache.has(key)) { renderJudge(box, judgeCache.get(key), rowId); return; }
+  box.innerHTML = '<div class="kv" style="color:#8fa3c0">AI 判断中…（约10-30秒）</div>';
+  try {
+    const j = await api('/api/recommend/ai', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ source_id: sourceId, target_id: targetId }) });
+    judgeCache.set(key, j);
+    renderJudge(box, j, rowId);
+  } catch (e) { box.innerHTML = `<div class="kv" style="color:#e0a768">判断失败：${escapeHtml(e.message)}</div>`; }
+}
+window.aiJudgeRec = aiJudgeRec;
+
+function renderJudge(box, j, rowId) {
+  if (!j.has_relation) { box.innerHTML = '<div class="kv" style="color:#8b949e">AI 判断：无明显关系可录</div>'; return; }
+  const confColor = { '确证': '#7ee787', '推测': '#e0a768', '存疑': '#8b949e' }[j.confidence] || '#8fa3c0';
+  box.innerHTML = `<div class="kv" style="background:#1a2332;border-radius:6px;padding:6px">
+    建议关系：<b style="color:#7ee787">${escapeHtml(j.name)}</b>
+    <span class="tag" style="color:${confColor};border-color:${confColor}55">${j.category}·${j.confidence}</span>
+    <div style="color:#8fa3c0;font-size:11px">依据：${escapeHtml(j.evidence || '（无）')}</div>
+    <div style="margin-top:4px"><button class="primary" onclick="acceptRec(${j.source_id},${j.target_id},'${rowId}')">采纳入库</button></div>
+  </div>`;
+}
+window.acceptRec = acceptRec;
+
+async function acceptRec(sourceId, targetId, rowId) {
+  const judge = judgeCache.get(`${sourceId}|${targetId}`);
+  if (!judge || !judge.has_relation) { toast('判断结果已失效，请重新AI判断', true); return; }
+  try {
+    await api('/api/relations', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({
+      source_id: sourceId, target_id: targetId, name: judge.name, category: judge.category, confidence: judge.confidence,
+      source_ref: 'AI推荐: ' + (judge.evidence || '共同邻居推荐'),
+    }) });
+    toast(`已录入关系「${judge.name}」`);
+    const row = $('row-' + rowId);
+    if (row) row.remove();
+  } catch (e) { toast(e.message, true); }
+}
+
+function renderRecList(recs, boxId, emptyText) {
+  const box = $(boxId);
+  if (!box) return;
+  box.innerHTML = recs.length
+    ? recs.map((r) => recRowHtml(r, boxId)).join('')
+    : `<div class="kv">${emptyText}</div>`;
+}
+
+async function scanRecs() {
+  const btn = $('rc-scan');
+  btn.disabled = true;
+  $('rc-status').textContent = '扫描中…';
+  try {
+    const r = await api('/api/recommend?limit=20');
+    $('rc-status').textContent = `${r.recommendations.length} 条候选`;
+    renderRecList(r.recommendations, 'rc-list', '无可推荐候选（共同邻居≥2且无直接边的实体对）');
+  } catch (e) { $('rc-status').textContent = e.message; }
+  btn.disabled = false;
+}
+$('rc-scan').addEventListener('click', scanRecs);
+
+async function loadEntityRecs(id) {
+  const box = $('rec-box');
+  if (!box) return;
+  box.innerHTML = '<div class="kv">候选关系计算中…</div>';
+  try {
+    const r = await api(`/api/recommend?center=${id}&limit=10`);
+    renderRecList(r.recommendations, 'rec-box', '暂无候选（该实体2跳内无共同邻居≥1的无边实体对）');
+  } catch (e) { box.innerHTML = `<div class="kv" style="color:#e0a768">${escapeHtml(e.message)}</div>`; }
+}
+window.loadEntityRecs = loadEntityRecs;
+
 async function delRelation(id) {
   if (!confirm(`删除关系 #${id}？其绑定的图片文件将一并移除。`)) return;
   try {

package/public/index.html

@@ -117,6 +117,11 @@
           <div class="row"><button class="primary" id="s-run">检索</button><span id="s-mode" style="font-size:11px;color:#8fa3c0;align-self:center"></span></div>
           <div id="s-results"></div>
         </div>
+        <div class="card">
+          <h3>关系推荐（共同邻居 + AI 判断）</h3>
+          <div class="row"><button class="primary" id="rc-scan">扫描全图推荐</button><span id="rc-status" style="font-size:11px;color:#8fa3c0;align-self:center"></span></div>
+          <div id="rc-list"></div>
+        </div>
         <div class="card">
           <h3>关系查询（迷你Cypher，只读）</h3>
           <textarea id="c-query" placeholder="MATCH (a)-[r:互动]->(b) WHERE a.name contains 郑和 RETURN a.name, r.name, b.name LIMIT 10"></textarea>
@@ -250,6 +255,7 @@
           <ul class="hp-list">
             <li><b>AI 对话建图</b>：右侧输入自然语言（如"联网查一下珠穆朗玛峰的海拔并建入图谱"），或上传文档（md/txt/pdf/docx）批量抽取</li>
             <li><b>检索页签</b>：智能提问（一句话找关系）、语义/关键词混合检索；语义配置卡可填 Base URL/Key/模型并一键测试连接</li>
+            <li><b>关系推荐</b>：共同邻居找"该连没连"的实体对（检索页签"关系推荐"卡 / 实体卡"推荐关系"按钮），AI 判断后一键采纳入库</li>
             <li><b>最短路径</b>：搜索或列表选中实体后，用"路径"功能查两实体关联链路</li>
             <li><b>撤销</b>：按钮或 Ctrl+Z，可连续撤销；删除实体仅恢复实体本身，关联关系可在日志页看到级联记录</li>
             <li><b>推理</b>：开关叠加虚线显示的隐性关系（传递/对称/逆规则），点击可见推导依据</li>

package/server.js

@@ -10,6 +10,7 @@ const rdf = require('./lib/rdf');
 const agent = require('./lib/agent');
 const V = require('./lib/validator');
 const inference = require('./lib/inference');
+const recommend = require('./lib/recommend');
 const embeddings = require('./lib/embeddings');
 const askLib = require('./lib/ask');
 const updater = require('./lib/updater');
@@ -412,6 +413,45 @@ api.get('/inference', (req, res) => {
 
 api.get('/ontology', (req, res) => res.json(inference.loadOntology()));
 
+// ---------- 关系推荐（共同邻居 + LLM判断） ----------
+api.get('/recommend', (req, res) => {
+  const g = db.getGraph();
+  const center = String(req.query.center || '').trim();
+  const opts = { limit: Number(req.query.limit) || 20 };
+  if (center) {
+    let cid = null;
+    if (/^\d+$/.test(center)) cid = Number(center);
+    else {
+      const cands = g.entities.filter((e) => e.name === center);
+      if (cands.length === 1) cid = cands[0].id;
+      else if (cands.length > 1) return res.status(409).json({ error: `实体名"${center}"存在${cands.length}个候选，请改用id`, candidates: cands.map((h) => ({ id: h.id, name: h.name, category: h.category })) });
+    }
+    if (cid && !g.entities.some((e) => e.id === cid)) return res.status(404).json({ error: `实体"${center}"不存在` });
+    if (cid) opts.centerId = cid;
+  }
+  res.json({ recommendations: recommend.computeCoNeighborRecs(g, opts) });
+});
+
+// LLM判断候选关系：只给建议，入库由前端确认后走人工接口
+api.post('/recommend/ai', async (req, res) => {
+  if (agentBusy) return res.status(429).json({ error: '已有AI任务执行中（问答、导入或智能检索），请稍后再试' });
+  const body = req.body || {};
+  const g = db.getGraph();
+  const byId = new Map(g.entities.map((e) => [e.id, e]));
+  const a = byId.get(Number(body.source_id));
+  const b = byId.get(Number(body.target_id));
+  if (!a || !b) return res.status(404).json({ error: '待判断的实体不存在' });
+  agentBusy = true;
+  try {
+    const judge = await recommend.aiJudgeRelation({ a, b, common_names: body.common_names });
+    res.json(judge);
+  } catch (e) {
+    res.status(e.status || 500).json({ error: e.message });
+  } finally {
+    agentBusy = false;
+  }
+});
+
 // ---------- 向量混合检索 ----------
 api.get('/embeddings/status', (req, res) => res.json(embeddings.status()));