From 3b53b2d7d1b93747596d9b952f2f8f732437d40a Mon Sep 17 00:00:00 2001
From: hanyuqing <1106611654@qq.com>
Date: Wed, 14 Jan 2026 08:47:25 +0800
Subject: [PATCH] =?UTF-8?q?=E5=B7=A5=E5=85=B7=E6=A0=8F=E5=A4=8D=E7=94=A8+?=
 =?UTF-8?q?=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 controller/GraphStyleController.py  | 117 +++--
 controller/OperationController.py   | 223 ++++++++-
 controller/QAController.py          | 129 +++---
 service/GraphStyleService.py        | 283 ++++++------
 service/OperationService.py         | 519 +++++++++++++++++++--
 util/auth_interceptor.py            |   1 +
 vue/src/api/data.js                 |  95 ++++
 vue/src/components/GraphToolbar.vue | 260 +++++++++++
 vue/src/system/GraphDemo.vue        | 281 +++++++-----
 vue/src/system/GraphQA.vue          | 280 +++++++++---
 vue/src/system/GraphStyle.vue       | 362 +++++++++++----
 vue/src/system/KGData.vue           | 874 ++++++++++++++++++++++++++++--------
 12 files changed, 2702 insertions(+), 722 deletions(-)
 create mode 100644 vue/src/components/GraphToolbar.vue

diff --git a/controller/GraphStyleController.py b/controller/GraphStyleController.py
index f601d03..ceced76 100644
--- a/controller/GraphStyleController.py
+++ b/controller/GraphStyleController.py
@@ -1,9 +1,12 @@
-# controller/GraphStyleController.py
 import json
+import logging
 from robyn import jsonify, Response
 from app import app
 from service.GraphStyleService import GraphStyleService
 
+# 配置日志记录
+logger = logging.getLogger(__name__)
+
 
 # --- 核心工具函数：解决乱码 ---
 def create_response(status_code, data_dict):
@@ -20,46 +23,76 @@ def create_response(status_code, data_dict):
 @app.post("/api/graph/style/save")
 async def save_style_config(request):
     """
-    保存配置接口 - 增强防跑偏版
-    逻辑：
-    1. 如果 body 中包含 is_auto_save: true，则强制忽略 group_name，防止自动保存篡改归属。
-    2. 如果是普通保存或移动，则正常传递 group_name。
+    保存配置接口 - 增强校验版
+    支持：
+    1. 跨组精准移动 (id + target_group_id) - 优先级最高
+    2. 跨组名称移动 (id + group_name + is_auto_save: false)
+    3. 手动/自动保存 (id + is_auto_save: true/false)
+    4. 新建保存 (无 id)
     """
     try:
+        # 1. 解析请求体
         body = request.json()
 
+        # 提取参数
         config_id = body.get('id')
         canvas_name = body.get('canvas_name')
         current_label = body.get('current_label')
         styles = body.get('styles')
 
-        # 核心改动：获取 group_name
+        # 核心改动点：接收精准 ID
+        target_group_id = body.get('target_group_id')
         group_name = body.get('group_name')
 
-        # 增加一个前端标识：如果是实时同步(防抖保存)，前端可以传这个字段
+        # 默认为 False，代表这是一次手动操作（可能是保存，也可能是移动）
         is_auto_save = body.get('is_auto_save', False)
 
+        # 2. 基础参数校验
         if not all([canvas_name, current_label, styles]):
-            return create_response(200, {"code": 400, "msg": "参数不完整"})
-
-        # 如果是自动保存模式，显式清空 group_name，强制 Service 进入“仅更新样式”逻辑
-        final_group_name = None if is_auto_save else group_name
-
-        # 将处理后的参数传给 Service 层
-        success = GraphStyleService.save_config(
-            canvas_name=canvas_name,
-            current_label=current_label,
-            styles_dict=styles,
-            group_name=final_group_name,
-            config_id=config_id
-        )
-
-        if success:
-            return create_response(200, {"code": 200, "msg": "操作成功"})
+            return create_response(200, {"code": 400, "msg": "参数不完整：缺失标签名或样式数据"})
+
+        # --- 核心逻辑分流 ---
+
+        # 情况 A：更新记录 (前端传了 ID)
+        if config_id:
+            # 判断动作类型用于日志和反馈
+            # 只要传了 target_group_id 或提供了 group_name 且非自动保存，就视为移动
+            is_moving = (target_group_id is not None) or (group_name is not None and not is_auto_save)
+            action_label = "移动" if is_moving else "更新"
+
+            # 修改点：将 target_group_id 显式传递给 Service 层
+            success = GraphStyleService.update_config(
+                config_id=int(config_id),
+                canvas_name=canvas_name,
+                current_label=current_label,
+                styles_dict=styles,
+                group_name=group_name,
+                target_group_id=target_group_id,  # 确保这一行存在！
+                is_auto_save=is_auto_save
+            )
+
+            if success:
+                return create_response(200, {"code": 200, "msg": f"{action_label}操作完成"})
+            else:
+                return create_response(200,
+                                       {"code": 500, "msg": f"{action_label}失败，请确认配置是否存在或内容是否有变化"})
+
+        # 情况 B：新增记录 (前端未传 ID)
         else:
-            return create_response(200, {"code": 500, "msg": "操作失败"})
+            success = GraphStyleService.create_config(
+                canvas_name=canvas_name,
+                current_label=current_label,
+                styles_dict=styles,
+                group_name=group_name
+            )
+            if success:
+                return create_response(200, {"code": 200, "msg": "新配置已创建成功"})
+            else:
+                return create_response(200, {"code": 500, "msg": "新建配置失败，请重试"})
+
     except Exception as e:
-        return create_response(200, {"code": 500, "msg": f"系统异常: {str(e)}"})
+        logger.error(f"Controller 异常: {str(e)}", exc_info=True)
+        return create_response(200, {"code": 500, "msg": f"服务器内部错误: {str(e)}"})
 
 
 @app.get("/api/graph/style/list/grouped")
@@ -69,12 +102,13 @@ async def get_grouped_style_list(request):
         data = GraphStyleService.get_grouped_configs()
         return create_response(200, {"code": 200, "data": data, "msg": "查询成功"})
     except Exception as e:
+        logger.error(f"查询异常: {str(e)}")
         return create_response(200, {"code": 500, "msg": f"查询异常: {str(e)}"})
 
 
 @app.post("/api/graph/style/group/apply")
 async def apply_style_group(request):
-    """应用全案"""
+    """应用全案：一键切换当前激活的样式组"""
     try:
         body = request.json()
         group_id = body.get('group_id')
@@ -86,7 +120,7 @@ async def apply_style_group(request):
         if success:
             return create_response(200, {"code": 200, "msg": "方案已成功应用"})
         else:
-            return create_response(200, {"code": 500, "msg": "应用全案失败"})
+            return create_response(200, {"code": 500, "msg": "应用全案失败，请检查方案是否存在"})
     except Exception as e:
         return create_response(200, {"code": 500, "msg": f"操作异常: {str(e)}"})
 
@@ -112,7 +146,7 @@ async def set_default_style_group(request):
 
 @app.get("/api/graph/style/groups")
 async def get_group_names(request):
-    """获取所有已存在的方案组列表"""
+    """获取所有已存在的方案组列表（用于下拉选择）"""
     try:
         data = GraphStyleService.get_group_list()
         return create_response(200, {"code": 200, "data": data, "msg": "查询成功"})
@@ -120,19 +154,9 @@ async def get_group_names(request):
         return create_response(200, {"code": 500, "msg": f"查询异常: {str(e)}"})
 
 
-@app.get("/api/graph/style/list")
-async def get_style_list(request):
-    """获取原始扁平配置列表"""
-    try:
-        data = GraphStyleService.get_all_configs()
-        return create_response(200, {"code": 200, "data": data, "msg": "查询成功"})
-    except Exception as e:
-        return create_response(200, {"code": 500, "msg": f"查询异常: {str(e)}"})
-
-
 @app.post("/api/graph/style/delete")
 async def delete_style_config(request):
-    """删除单条画布配置"""
+    """删除单条配置记录"""
     try:
         body = request.json()
         config_id = body.get('id')
@@ -144,14 +168,14 @@ async def delete_style_config(request):
         if success:
             return create_response(200, {"code": 200, "msg": "删除成功"})
         else:
-            return create_response(200, {"code": 500, "msg": "删除失败"})
+            return create_response(200, {"code": 404, "msg": "删除失败，配置可能已被删除"})
     except Exception as e:
         return create_response(200, {"code": 500, "msg": f"操作异常: {str(e)}"})
 
 
 @app.post("/api/graph/style/group/delete")
 async def delete_style_group(request):
-    """删除整个方案组及其下属所有配置"""
+    """级联删除整个方案组及其下属所有配置"""
     try:
         body = request.json()
         group_id = body.get('group_id')
@@ -161,7 +185,7 @@ async def delete_style_group(request):
 
         success = GraphStyleService.delete_group(group_id)
         if success:
-            return create_response(200, {"code": 200, "msg": "方案组已彻底删除"})
+            return create_response(200, {"code": 200, "msg": "方案组及关联配置已彻底删除"})
         else:
             return create_response(200, {"code": 500, "msg": "方案组删除失败"})
     except Exception as e:
@@ -175,6 +199,7 @@ async def batch_delete_style(request):
         body = request.json()
         config_ids = body.get('ids')
 
+        # 容错：处理前端可能以 JSON 字符串形式发送的列表
         if isinstance(config_ids, str):
             try:
                 config_ids = json.loads(config_ids)
@@ -182,9 +207,13 @@ async def batch_delete_style(request):
                 pass
 
         if not config_ids or not isinstance(config_ids, list):
-            return create_response(200, {"code": 400, "msg": "参数格式错误"})
+            return create_response(200, {"code": 400, "msg": "参数格式错误，请提供ID列表"})
 
         count = GraphStyleService.batch_delete_configs(config_ids)
-        return create_response(200, {"code": 200, "msg": f"成功删除 {count} 条配置", "count": count})
+        return create_response(200, {
+            "code": 200,
+            "msg": f"成功删除 {count} 条配置数据",
+            "count": count
+        })
     except Exception as e:
         return create_response(200, {"code": 500, "msg": f"批量删除异常: {str(e)}"})
\ No newline at end of file
diff --git a/controller/OperationController.py b/controller/OperationController.py
index afe162a..fc30c91 100644
--- a/controller/OperationController.py
+++ b/controller/OperationController.py
@@ -9,15 +9,40 @@ from urllib.parse import unquote
 operation_service = OperationService()
 
 
-# --- 核心工具函数 ---
-
+# 2. 新增/替换这个深度转换函数
+def deep_convert(data):
+    """
+    专门解决 Neo4j 对象序列化问题的工具函数
+    """
+    if isinstance(data, dict):
+        return {k: deep_convert(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [deep_convert(i) for i in data]
+    # 增加对数值类型的保护，其他的全部转为字符串
+    elif isinstance(data, (int, float, bool, type(None))):
+        return data
+    elif isinstance(data, str):
+        return data
+    # 如果是 Neo4j 的 ID、Long 或其他不可识别对象，一律强转字符串
+    else:
+        try:
+            return str(data)
+        except:
+            return None
+
+# 3. 替换原来的 create_response
 def create_response(status_code, data_dict):
     """
-    统一响应格式封装，强制使用 UTF-8 防止中文乱码。
+    统一响应格式封装。
+    不再直接用 jsonify(data_dict)，因为那处理不了嵌套的 Neo4j 对象。
     """
+    # 第一步：清洗数据，把所有特殊对象转为标准 Python 类型
+    clean_data = deep_convert(data_dict)
+
+    # 第二步：手动序列化，确保中文不乱码，且 elementId 等长字符串不被截断
     return Response(
         status_code=status_code,
-        description=jsonify(data_dict),
+        description=json.dumps(clean_data, ensure_ascii=False),
         headers={"Content-Type": "application/json; charset=utf-8"}
     )
 
@@ -333,4 +358,192 @@ def get_kg_stats(req):
             return create_response(200, {"code": 400, "msg": msg})
     except Exception as e:
         traceback.print_exc()
-        return create_response(200, {"code": 500, "msg": f"统计数据异常: {str(e)}"})
\ No newline at end of file
+        return create_response(200, {"code": 500, "msg": f"统计数据异常: {str(e)}"})
+
+
+# --- 12. 数据导出接口 ---
+
+@app.get("/api/kg/export/nodes")
+def export_nodes(req):
+    """
+    节点导出接口：全量导出满足筛选条件的节点
+    """
+    try:
+        # 1. 提取筛选参数
+        name_raw = get_query_param(req, "name", "")
+        label_raw = get_query_param(req, "label", "")
+
+        # 2. 参数清洗
+        name = name_raw.strip() if name_raw and str(name_raw).lower() not in ["null", "undefined"] else None
+        label = label_raw.strip() if label_raw and label_raw not in ["全部", "", "null", "undefined"] else None
+
+        # 3. 调用 Service：移除 limit 参数，执行全量导出
+        result = operation_service.export_nodes_to_json(label=label, name=name)
+
+        if result.get("success"):
+            return create_response(200, {
+                "code": 200,
+                "data": result.get("data"),
+                "total": result.get("count", 0),
+                "msg": "success"
+            })
+        else:
+            return create_response(200, {"code": 500, "msg": result.get("msg", "获取导出数据失败")})
+
+    except Exception as e:
+        traceback.print_exc()
+        return create_response(200, {"code": 500, "msg": f"导出节点接口异常: {str(e)}"})
+
+
+@app.get("/api/kg/export/relationships")
+def export_relationships(req):
+    """
+    关系导出接口：全量导出满足筛选条件的关系
+    """
+    try:
+        # 1. 提取筛选参数
+        source_raw = get_query_param(req, "source", "")
+        target_raw = get_query_param(req, "target", "")
+        type_raw = get_query_param(req, "type", "")
+
+        # 2. 参数清洗
+        source = source_raw.strip() if source_raw and str(source_raw).lower() not in ["null", "undefined"] else None
+        target = target_raw.strip() if target_raw and str(target_raw).lower() not in ["null", "undefined"] else None
+        rel_type = type_raw.strip() if type_raw and type_raw not in ["全部", "", "null", "undefined"] else None
+
+        # 3. 执行导出查询：移除 limit 参数，执行全量导出
+        result = operation_service.export_relationships_to_json(
+            source=source,
+            target=target,
+            rel_type=rel_type
+        )
+
+        if result.get("success"):
+            return create_response(200, {
+                "code": 200,
+                "data": result.get("data"),
+                "total": result.get("count", 0),
+                "msg": "success"
+            })
+        else:
+            return create_response(200, {
+                "code": 500,
+                "msg": result.get("msg", "获取导出关系失败")
+            })
+
+    except Exception as e:
+        traceback.print_exc()
+        return create_response(200, {
+            "code": 500,
+            "msg": f"导出关系接口异常: {str(e)}"
+        })
+
+
+# --- 13. 批量导入核心接口 (预检 & 执行) ---
+
+@app.post("/api/kg/import/nodes/precheck")
+def import_nodes_precheck(req):
+    """
+    预检接口：接收前端上传的 nodes 数组，进行冲突和有效性扫描。
+    """
+    try:
+        body = parse_request_body(req)
+        nodes = body.get("nodes", [])
+        if not nodes: return create_response(200, {"code": 400, "msg": "数据为空"})
+
+        result = operation_service.precheck_nodes_batch(nodes)
+        return create_response(200, {
+            "code": 200,
+            "data": {
+                "conflicts": result.get("conflicts", []),
+                "invalid": result.get("invalid", []),  # 这里会包含因缺少 nodeId 而被过滤的数据
+                "summary": result.get("summary", {})
+            },
+            "msg": "预检完成"
+        })
+    except Exception as e:
+        return create_response(200, {"code": 500, "msg": f"预检异常: {str(e)}"})
+
+
+@app.post("/api/kg/import/nodes/execute")
+def import_nodes_execute(req):
+    """
+    执行导入接口：支持模式 mode (strict/skip/update)。
+    """
+    try:
+        body = parse_request_body(req)
+        nodes = body.get("nodes", [])
+        mode = body.get("mode", "skip")
+
+        if not nodes: return create_response(200, {"code": 400, "msg": "批次数据为空"})
+
+        result = operation_service.execute_node_import_batch(nodes, mode=mode)
+
+        if result.get("success"):
+            return create_response(200, {"code": 200, "msg": result.get("msg")})
+        else:
+            # 严格模式下如果因冲突失败，返回详情
+            return create_response(200, {
+                "code": 500,
+                "msg": result.get("msg"),
+                "data": {"conflicts": result.get("conflicts", [])}
+            })
+    except Exception as e:
+        return create_response(200, {"code": 500, "msg": f"执行异常: {str(e)}"})
+
+# --- 关系导入核心修正 ---
+
+@app.post("/api/kg/import/relationships/precheck")
+def import_rels_precheck(req):
+    """
+    修正说明：适配 Service 层返回的 summary 结构，确保前端准确识别冲突数
+    """
+    try:
+        body = parse_request_body(req)
+        # 兼容 relationships 和 rels 两种写法
+        rels = body.get("relationships") or body.get("rels") or []
+        if not rels:
+            return create_response(200, {"code": 400, "msg": "预检数据为空"})
+
+        result = operation_service.precheck_rels_batch(rels)
+        return create_response(200, {
+            "code": 200,
+            "data": {
+                "conflicts": result.get("conflicts", []),
+                "invalid": result.get("invalid", []),
+                "summary": result.get("summary", {}) # 包含准确的 conflict 计数
+            },
+            "msg": "预检成功"
+        })
+    except Exception as e:
+        traceback.print_exc()
+        return create_response(200, {"code": 500, "msg": f"关系预检异常: {str(e)}"})
+
+
+@app.post("/api/kg/import/relationships/execute")
+def import_rels_execute(req):
+    """
+    修正说明：将 Service 层生成的包含 elementId 的标准 Graph 数据透传回前端
+    """
+    try:
+        body = parse_request_body(req)
+        rels = body.get("relationships") or body.get("rels") or []
+        mode = body.get("mode", "skip")
+
+        if not rels:
+            return create_response(200, {"code": 400, "msg": "执行数据为空"})
+
+        result = operation_service.execute_rel_import_batch(rels, mode=mode)
+
+        if result.get("success"):
+            return create_response(200, {
+                "code": 200,
+                "msg": result.get("msg"),
+                "data": result.get("data"), # 核心：返回标准嵌套结构的数组
+                "count": result.get("count", 0)
+            })
+        else:
+            return create_response(200, {"code": 500, "msg": result.get("msg")})
+    except Exception as e:
+        traceback.print_exc()
+        return create_response(200, {"code": 500, "msg": f"关系导入执行异常: {str(e)}"})
\ No newline at end of file
diff --git a/controller/QAController.py b/controller/QAController.py
index d61e52d..aeac479 100644
--- a/controller/QAController.py
+++ b/controller/QAController.py
@@ -9,48 +9,62 @@ from robyn import jsonify, Response
 from app import app
 from controller.client import client
 
-import uuid
+
+# --- 核心工具函数：解决元组返回错误及中文乱码 ---
+def create_response(status_code, data_dict):
+    """
+    统一响应格式封装。
+    1. 确保返回的是 Robyn 预期的 Response 对象。
+    2. description 必须是字符串（json.dumps 结果）。
+    3. 强制使用 UTF-8 防止中文乱码。
+    """
+    return Response(
+        status_code=status_code,
+        description=json.dumps(data_dict, ensure_ascii=False),
+        headers={"Content-Type": "application/json; charset=utf-8"}
+    )
+
 
 def convert_to_g6_format(data):
-    entities = data["entities"]
-    relations = data["relations"]
+    entities = data.get("entities", [])
+    relations = data.get("relations", [])
 
     # 创建实体名称到唯一ID的映射
     name_to_id = {}
     nodes = []
 
     for ent in entities:
-        name = ent["n"]
-        if name not in name_to_id:
+        name = ent.get("n")
+        if name and name not in name_to_id:
             node_id = str(uuid.uuid4())
             name_to_id[name] = node_id
             nodes.append({
                 "id": node_id,
                 "label": name,
                 "data": {
-                    "type": ent["t"]  # 可用于 G6 的节点样式区分
+                    "type": ent.get("t")  # 用于 G6 的节点样式区分
                 }
             })
 
     # 构建边，并为每条边生成唯一 ID
     edges = []
     for rel in relations:
-        e1 = rel["e1"]
-        e2 = rel["e2"]
-        r = rel["r"]
+        e1 = rel.get("e1")
+        e2 = rel.get("e2")
+        r = rel.get("r")
 
         source_id = name_to_id.get(e1)
         target_id = name_to_id.get(e2)
 
         if source_id and target_id:
-            edge_id = str(uuid.uuid4())  # 👈 为边生成唯一 ID
+            edge_id = str(uuid.uuid4())
             edges.append({
-                "id": edge_id,           # ✅ 添加 id 字段
+                "id": edge_id,
                 "source": source_id,
                 "target": target_id,
-                "label": r,              # G6 支持直接使用 label（非必须放 data）
+                "label": r,
                 "data": {
-                    "label": r           # 保留 data.label 便于扩展
+                    "label": r
                 }
             })
         else:
@@ -60,85 +74,88 @@ def convert_to_g6_format(data):
         "nodes": nodes,
         "edges": edges
     }
+
+
 @app.post("/api/qa/analyze")
 async def analyze(request):
     body = request.json()
     input_text = body.get("text", "").strip()
+
     if not input_text:
-        return jsonify({"error": "缺少 text 字段"}), 400
+        # 使用 create_response 统一返回格式，避免使用 jsonify 可能带来的元组嵌套问题
+        return create_response(400, {"error": "缺少 text 字段"})
+
     try:
-        # 直接转发到大模型服务（假设它返回 { "task_id": "xxx" }）
+        # 1. 提取实体
         resp = await client.post(
             "/getEntity",
             json={"text": input_text},
-            timeout=1800.0  # 30分钟
+            timeout=1800.0
         )
-        qaList = []
-        if resp.status_code == 202 or resp.status_code == 200:
 
+        qaList = []
+        if resp.status_code in (200, 202):
             resp_json = resp.json()
-            resp_json_data = resp_json.get("data",{})
-            resp_json_data = json.loads(resp_json_data)
+            # 处理字符串形式的 data 字段
+            resp_json_data = resp_json.get("data", "{}")
+            if isinstance(resp_json_data, str):
+                resp_json_data = json.loads(resp_json_data)
+
             entities = resp_json_data.get("entities", [])
-            print(entities)
-            data = []
+            print(f"提取到的实体: {entities}")
+
+            # 查询 Neo4j 邻居（此逻辑保留，虽目前未直接放入 qaList，可能用于后续扩展）
             for name in entities:
-                neighbors =neo4j_client.find_neighbors_with_relationshipsAI(
+                neo4j_client.find_neighbors_with_relationshipsAI(
                     node_label=None,
                     direction="both",
                     node_properties={"name": name},
                     rel_type=None
                 )
-                data.append({
-                    name:neighbors
-                })
-            resp = await client.post(
+
+            # 2. 问答代理获取答案列表
+            resp_agent = await client.post(
                 "/question_agent",
-                json={"neo4j_data": [],
-                     "text": input_text},
-                timeout=1800.0  # 30分钟
+                json={"neo4j_data": [], "text": input_text},
+                timeout=1800.0
             )
-            resp_data = resp.json()
-            inner_data = json.loads(resp_data["data"])
-            # 第二步：获取 json 数组
-            items = inner_data["json"]
 
-            # 第三步：按 sort 排序（虽然所有都是 0.9，但为了通用性还是排序）
-            # 如果 sort 相同，可以保留原始顺序（使用 stable sort），或按 xh 排序等
-            sorted_items = sorted(items, key=lambda x: x["sort"], reverse=True)
+            resp_data = resp_agent.json()
+            inner_data = json.loads(resp_data["data"])
+            items = inner_data.get("json", [])
 
-            # 第四步：取前5个
+            # 按权重排序取前5
+            sorted_items = sorted(items, key=lambda x: x.get("sort", 0), reverse=True)
             top5 = sorted_items[:5]
+
+            # 3. 对每个答案提取关系图谱
             for item in top5:
-                resp = await client.post(
+                resp_ext = await client.post(
                     "/extract_entities_and_relations",
                     json={"text": item['answer']},
-                    timeout=1800.0  # 30分钟
+                    timeout=1800.0
                 )
-                if resp.status_code in (200, 202):
-                    result = resp.json()
-                    print(result)
+
+                if resp_ext.status_code in (200, 202):
+                    result = resp_ext.json()
                     g6_data = convert_to_g6_format(result)
-                    print(g6_data)
                     qaList.append({
                         "answer": item["answer"],
                         "result": g6_data,
-                           })
-                print(f"xh: {item['xh']}, answer: {item['answer']}, sort: {item['sort']}")
-            print(resp.json())
-            return Response(
-                status_code=200,
-                description=jsonify(qaList),
-                headers={"Content-Type": "text/plain; charset=utf-8"}
-            )
+                    })
+                    print(f"处理成功 xh: {item.get('xh')}, sort: {item.get('sort')}")
+
+            # --- 修复点：使用 create_response 返回解析后的数组 ---
+            return create_response(200, qaList)
+
         else:
-            return jsonify({
+            return create_response(resp.status_code, {
                 "error": "提交失败",
                 "detail": resp.text
-            }), resp.status_code
+            })
+
     except Exception as e:
         error_trace = traceback.format_exc()
         print("❌ 发生异常:")
         print(error_trace)
-
-        return jsonify({"error": str(e),"traceback": error_trace}), 500
\ No newline at end of file
+        return create_response(500, {"error": str(e), "traceback": error_trace})
\ No newline at end of file
diff --git a/service/GraphStyleService.py b/service/GraphStyleService.py
index e4202ad..62e96e8 100644
--- a/service/GraphStyleService.py
+++ b/service/GraphStyleService.py
@@ -1,191 +1,218 @@
-# service/GraphStyleService.py
 import json
+import logging
 from util.mysql_utils import mysql_client
 
+# 配置日志
+logger = logging.getLogger(__name__)
+
 
 class GraphStyleService:
     @staticmethod
-    def save_config(canvas_name: str, current_label: str, styles_dict: dict, group_name: str = None, config_id: int = None) -> bool:
+    def _get_or_create_group(group_name: str) -> int:
+        """内部辅助方法：获取或创建方案组 ID"""
+        if not group_name or group_name.strip() == "":
+            group_name = "默认方案"
+
+        group_name = group_name.strip()
+
+        # 1. 查询是否存在
+        check_sql = "SELECT id FROM graph_style_groups WHERE group_name = %s LIMIT 1"
+        existing = mysql_client.execute_query(check_sql, (group_name,))
+        if existing:
+            return int(existing[0]['id'])
+
+        # 2. 不存在则插入
+        insert_sql = "INSERT INTO graph_style_groups (group_name, is_active, is_default) VALUES (%s, %s, %s)"
+        mysql_client.execute_update(insert_sql, (group_name, False, False))
+
+        # 3. 获取新生成的 ID
+        final_check = mysql_client.execute_query(check_sql, (group_name,))
+        return int(final_check[0]['id']) if final_check else 1
+
+    @staticmethod
+    def create_config(canvas_name: str, current_label: str, styles_dict: dict, group_name: str = None) -> bool:
+        """【纯新增】用于另存为或初始保存"""
+        config_json = json.dumps(styles_dict, ensure_ascii=False)
+        target_group_id = GraphStyleService._get_or_create_group(group_name)
+
+        sql = """
+            INSERT INTO graph_configs (canvas_name, current_label, config_json, group_id)
+            VALUES (%s, %s, %s, %s)
         """
-        保存图谱样式配置（修复版：防止自动保存导致的分组乱跑）
+        affected_rows = mysql_client.execute_update(sql, (canvas_name, current_label, config_json, target_group_id))
+        return affected_rows > 0
+
+    @staticmethod
+    def update_config(config_id: int, canvas_name: str, current_label: str, styles_dict: dict,
+                      group_name: str = None, is_auto_save: bool = False, target_group_id: int = None) -> bool:
         """
-        # 2. 转换样式 JSON
-        config_json = json.dumps(styles_dict, ensure_ascii=False)
+        核心更新逻辑：支持精准 ID 移动，优化了逻辑优先级判断
+        """
+        if not config_id:
+            logger.error("更新失败：缺少 config_id")
+            return False
 
-        # 3. 【核心修改点】：区分 更新 还是 新建
-        if config_id:
-            # --- 更新逻辑 ---
-            # 如果带了 ID，我们要极其谨慎地处理 group_id，防止在自动保存时被误改
-
-            # A. 如果调用者明确传了 group_name，说明是“移动”或“初次保存到某组”
-            if group_name and group_name.strip() != "":
-                # 检查/创建 目标方案组
-                check_group_sql = "SELECT id FROM graph_style_groups WHERE group_name = %s LIMIT 1"
-                existing_group = mysql_client.execute_query(check_group_sql, (group_name,))
-
-                if existing_group:
-                    target_group_id = existing_group[0]['id']
-                else:
-                    create_group_sql = "INSERT INTO graph_style_groups (group_name, is_active, is_default) VALUES (%s, %s, %s)"
-                    mysql_client.execute_update(create_group_sql, (group_name, False, False))
-                    target_group_id = mysql_client.execute_query("SELECT LAST_INSERT_ID() as last_id")[0]['last_id']
-
-                # 执行带分组更新的 SQL
-                sql = """
-                    UPDATE graph_configs 
-                    SET canvas_name = %s, current_label = %s, config_json = %s, group_id = %s 
-                    WHERE id = %s
-                """
-                affected_rows = mysql_client.execute_update(sql, (canvas_name, current_label, config_json, target_group_id, config_id))
+        config_json_str = json.dumps(styles_dict, ensure_ascii=False)
+
+        try:
+            # --- 步骤 1：查询当前数据库状态 ---
+            curr_sql = "SELECT group_id, canvas_name, current_label, config_json FROM graph_configs WHERE id = %s"
+            current_data = mysql_client.execute_query(curr_sql, (config_id,))
+
+            if not current_data:
+                logger.warning(f"更新失败：找不到 ID 为 {config_id} 的配置")
+                return False
+
+            curr_row = current_data[0]
+            old_group_id = int(curr_row['group_id'])
+
+            # --- 步骤 2：确定目标组 ID (调整优先级) ---
+            # 优先级 1: 只要传了 target_group_id，就说明是移动操作，优先级最高
+            if target_group_id is not None:
+                final_group_id = int(target_group_id)
+                logger.info(f"【移动模式】配置 {config_id}: 强制设定目标组 ID 为 {final_group_id}")
+
+            # 优先级 2: 自动保存模式下，锁定 group_id 不允许变动
+            elif is_auto_save:
+                final_group_id = old_group_id
+                logger.debug(f"【自保模式】配置 {config_id}: 锁定原组 ID {final_group_id}")
+
+            # 优先级 3: 传了 group_name 但没传 target_group_id (旧版移动逻辑)
+            elif group_name:
+                final_group_id = GraphStyleService._get_or_create_group(group_name)
+                logger.info(f"【名称模式】配置 {config_id}: 根据名称 [{group_name}] 获得 ID {final_group_id}")
+
+            # 兜底：保持不变
             else:
-                # B. 如果没有传 group_name，说明是“实时自动保存”，严禁修改 group_id
-                # 这样即使前端变量乱了，数据库的分组也不会变
-                sql = """
+                final_group_id = old_group_id
+
+            # --- 步骤 3：差异比对 ---
+            # 增加对数据一致性的判定
+            has_changed = (
+                    int(final_group_id) != old_group_id or
+                    canvas_name != curr_row['canvas_name'] or
+                    current_label != curr_row['current_label'] or
+                    config_json_str != curr_row['config_json']
+            )
+
+            if not has_changed:
+                logger.info(
+                    f"配置 {config_id} 内容无变化 (最终目标ID:{final_group_id}, 原ID:{old_group_id})，跳过数据库更新")
+                return True
+
+            # --- 步骤 4：执行更新 ---
+            sql = """
                     UPDATE graph_configs 
-                    SET canvas_name = %s, current_label = %s, config_json = %s 
+                    SET group_id = %s, canvas_name = %s, current_label = %s, config_json = %s 
                     WHERE id = %s
                 """
-                affected_rows = mysql_client.execute_update(sql, (canvas_name, current_label, config_json, config_id))
-        else:
-            # --- 新建逻辑 ---
-            # 新建时必须有组名，默认“默认方案”
-            if not group_name or group_name.strip() == "":
-                group_name = "默认方案"
-
-            check_group_sql = "SELECT id FROM graph_style_groups WHERE group_name = %s LIMIT 1"
-            existing_group = mysql_client.execute_query(check_group_sql, (group_name,))
-            if existing_group:
-                target_group_id = existing_group[0]['id']
-            else:
-                create_group_sql = "INSERT INTO graph_style_groups (group_name, is_active, is_default) VALUES (%s, %s, %s)"
-                mysql_client.execute_update(create_group_sql, (group_name, False, False))
-                target_group_id = mysql_client.execute_query("SELECT LAST_INSERT_ID() as last_id")[0]['last_id']
+            params = (final_group_id, canvas_name, current_label, config_json_str, config_id)
 
-            sql = """
-                INSERT INTO graph_configs (canvas_name, current_label, config_json, group_id)
-                VALUES (%s, %s, %s, %s)
-            """
-            affected_rows = mysql_client.execute_update(sql, (canvas_name, current_label, config_json, target_group_id))
+            affected_rows = mysql_client.execute_update(sql, params)
 
-        return affected_rows > 0
+            if affected_rows > 0:
+                logger.info(f"更新成功，ID: {config_id}, 归属组已变更为: {final_group_id}")
+                return True
+            else:
+                logger.error(f"数据库更新执行成功但受影响行数为 0，ID: {config_id}")
+                return False
+
+        except Exception as e:
+            logger.error(f"Service 层更新异常: {str(e)}", exc_info=True)
+            return False
 
     @staticmethod
     def get_grouped_configs() -> list:
-        """
-        获取嵌套结构的方案列表，按默认/激活状态排序
-        """
-        groups_sql = """
-            SELECT id, group_name, is_active, is_default 
-            FROM graph_style_groups 
-            ORDER BY is_default DESC, id ASC
-        """
+        """获取嵌套结构的方案列表"""
+        groups_sql = "SELECT id, group_name, is_active, is_default FROM graph_style_groups ORDER BY is_default DESC, id ASC"
         groups = mysql_client.execute_query(groups_sql) or []
 
         configs_sql = "SELECT id, group_id, canvas_name, current_label, config_json, create_time FROM graph_configs"
         configs = mysql_client.execute_query(configs_sql) or []
 
+        # 格式化配置数据
         for conf in configs:
-            if conf.get('config_json'):
-                try:
-                    conf['styles'] = json.loads(conf['config_json'])
-                except:
-                    conf['styles'] = {}
+            conf['styles'] = json.loads(conf['config_json']) if conf.get('config_json') else {}
+            # 保持 key 简洁
+            if 'config_json' in conf:
                 del conf['config_json']
-
             if conf.get('create_time') and not isinstance(conf['create_time'], str):
                 conf['create_time'] = conf['create_time'].strftime('%Y-%m-%d %H:%M:%S')
 
-        result = []
+        # 组装嵌套结构
         for g in groups:
             g['is_active'] = bool(g['is_active'])
             g['is_default'] = bool(g['is_default'])
-            g_children = [c for c in configs if c['group_id'] == g['id']]
-            g['configs'] = g_children
+            g['configs'] = [c for c in configs if c['group_id'] == g['id']]
             g['expanded'] = g['is_active']
-            result.append(g)
-
-        return result
+        return groups
 
     @staticmethod
     def apply_group_all(group_id: int) -> bool:
-        """应用全案：设置激活状态"""
+        """切换当前激活的方案组"""
         try:
-            reset_sql = "UPDATE graph_style_groups SET is_active = %s"
-            mysql_client.execute_update(reset_sql, (False,))
-            apply_sql = "UPDATE graph_style_groups SET is_active = %s WHERE id = %s"
-            affected_rows = mysql_client.execute_update(apply_sql, (True, group_id))
+            # 重置所有组的激活状态
+            mysql_client.execute_update("UPDATE graph_style_groups SET is_active = %s", (False,))
+            # 激活目标组
+            affected_rows = mysql_client.execute_update(
+                "UPDATE graph_style_groups SET is_active = %s WHERE id = %s",
+                (True, group_id)
+            )
             return affected_rows > 0
         except Exception as e:
-            print(f"Apply group error: {e}")
+            logger.error(f"应用全案异常: {str(e)}")
             return False
 
     @staticmethod
     def set_default_group(group_id: int) -> bool:
-        """设为系统初始默认方案"""
+        """设为默认方案组"""
         try:
-            reset_sql = "UPDATE graph_style_groups SET is_default = %s"
-            mysql_client.execute_update(reset_sql, (False,))
-            set_sql = "UPDATE graph_style_groups SET is_default = %s WHERE id = %s"
-            affected_rows = mysql_client.execute_update(set_sql, (True, group_id))
+            mysql_client.execute_update("UPDATE graph_style_groups SET is_default = %s", (False,))
+            affected_rows = mysql_client.execute_update(
+                "UPDATE graph_style_groups SET is_default = %s WHERE id = %s",
+                (True, group_id)
+            )
             return affected_rows > 0
         except Exception as e:
-            print(f"Set default error: {e}")
+            logger.error(f"设置默认方案异常: {str(e)}")
             return False
 
     @staticmethod
-    def get_all_configs() -> list:
-        """获取扁平查询"""
-        sql = """
-            SELECT c.id, c.group_id, c.canvas_name, c.current_label, c.config_json, c.create_time, g.is_active
-            FROM graph_configs c
-            LEFT JOIN graph_style_groups g ON c.group_id = g.id
-            ORDER BY c.create_time DESC
-        """
-        rows = mysql_client.execute_query(sql)
-        if not rows: return []
-
-        for row in rows:
-            if row.get('config_json'):
-                try:
-                    row['styles'] = json.loads(row['config_json'])
-                except:
-                    row['styles'] = {}
-                del row['config_json']
-            if row.get('create_time') and not isinstance(row['create_time'], str):
-                row['create_time'] = row['create_time'].strftime('%Y-%m-%d %H:%M:%S')
-            row['is_active'] = bool(row.get('is_active', False))
-        return rows
-
-    @staticmethod
     def delete_group(group_id: int) -> bool:
-        """级联删除"""
-        del_configs_sql = "DELETE FROM graph_configs WHERE group_id = %s"
-        mysql_client.execute_update(del_configs_sql, (group_id,))
-        del_group_sql = "DELETE FROM graph_style_groups WHERE id = %s"
-        affected_rows = mysql_client.execute_update(del_group_sql, (group_id,))
-        return affected_rows > 0
+        """级联删除组及其下的所有配置"""
+        try:
+            # 先删配置，再删组（如果没设外键级联）
+            mysql_client.execute_update("DELETE FROM graph_configs WHERE group_id = %s", (group_id,))
+            affected_rows = mysql_client.execute_update("DELETE FROM graph_style_groups WHERE id = %s", (group_id,))
+            return affected_rows > 0
+        except Exception as e:
+            logger.error(f"删除方案组异常: {str(e)}")
+            return False
 
     @staticmethod
     def delete_config(config_id: int) -> bool:
-        """删除配置"""
-        sql = "DELETE FROM graph_configs WHERE id = %s"
-        affected_rows = mysql_client.execute_update(sql, (config_id,))
-        return affected_rows > 0
+        """删除单个配置"""
+        try:
+            affected_rows = mysql_client.execute_update("DELETE FROM graph_configs WHERE id = %s", (config_id,))
+            return affected_rows > 0
+        except Exception as e:
+            logger.error(f"删除配置异常: {str(e)}")
+            return False
 
     @staticmethod
     def batch_delete_configs(config_ids: list) -> int:
         """批量删除"""
         if not config_ids: return 0
         try:
-            clean_ids = [int(cid) for cid in config_ids if str(cid).isdigit()]
-        except: return 0
-        if not clean_ids: return 0
-        placeholders = ', '.join(['%s'] * len(clean_ids))
-        sql = f"DELETE FROM graph_configs WHERE id IN ({placeholders})"
-        return mysql_client.execute_update(sql, tuple(clean_ids))
+            placeholders = ', '.join(['%s'] * len(config_ids))
+            sql = f"DELETE FROM graph_configs WHERE id IN ({placeholders})"
+            return mysql_client.execute_update(sql, tuple(config_ids))
+        except Exception as e:
+            logger.error(f"批量删除异常: {str(e)}")
+            return 0
 
     @staticmethod
     def get_group_list() -> list:
-        """获取方案列表"""
+        """简单的方案名称列表"""
         sql = "SELECT id, group_name, is_active, is_default FROM graph_style_groups ORDER BY is_default DESC, id DESC"
         return mysql_client.execute_query(sql) or []
\ No newline at end of file
diff --git a/service/OperationService.py b/service/OperationService.py
index 1237811..19c7aff 100644
--- a/service/OperationService.py
+++ b/service/OperationService.py
@@ -11,6 +11,96 @@ class OperationService:
     def __init__(self):
         self.db = neo4j_client
 
+    # --- 0. 内部辅助工具：格式标准化 ---
+    def _format_node_data(self, node):
+        """
+        统一转换前端传来的平铺或嵌套 JSON 格式。
+        输出标准结构: { "labels": [...], "properties": {...} }
+        """
+        # 1. 提取并标准化 labels
+        raw_labels = node.get("labels") or node.get("label")
+        if isinstance(raw_labels, str):
+            labels = [raw_labels]
+        elif isinstance(raw_labels, list):
+            labels = raw_labels
+        else:
+            labels = []
+
+        # 2. 提取并标准化 properties
+        if "properties" in node and isinstance(node["properties"], dict):
+            # 嵌套格式：直接取属性字典
+            props = node["properties"]
+        else:
+            # 平铺格式：打包除特殊键外的所有键值对
+            props = {
+                k: v for k, v in node.items()
+                if k not in ["label", "labels", "identity", "elementId"]
+            }
+
+        return {"labels": labels, "properties": props}
+
+    def _normalize_rel_data(self, item):
+        """
+        参考节点导入的逻辑，统一转换关系数据。
+        支持：标准嵌套 JSON、平铺 JSON、以及带有 properties 包装的格式。
+        """
+        def clean_str(val):
+            return str(val).strip() if val is not None else None
+
+        # 1. 尝试识别标准嵌套结构 (start/end 对象)
+        if isinstance(item.get("start"), dict) and isinstance(item.get("end"), dict):
+            s_node = item["start"]
+            e_node = item["end"]
+
+            # 使用获取属性的通用逻辑 ( properties 优先 )
+            s_props = s_node.get("properties") if isinstance(s_node.get("properties"), dict) else s_node
+            e_props = e_node.get("properties") if isinstance(e_node.get("properties"), dict) else e_node
+
+            # 提取标签 (取第一个标签用于精确匹配)
+            s_label = s_node.get("labels", [""])[0] if s_node.get("labels") else ""
+            e_label = e_node.get("labels", [""])[0] if e_node.get("labels") else ""
+
+            # 获取关系信息
+            rel_obj = {}
+            if item.get("segments") and len(item["segments"]) > 0:
+                rel_obj = item["segments"][0].get("relationship", {})
+            else:
+                rel_obj = item.get("relationship", {})
+
+            r_props = rel_obj.get("properties") if isinstance(rel_obj.get("properties"), dict) else rel_obj
+
+            return {
+                "source_name": clean_str(s_props.get("name")),
+                "source_label": s_label,
+                "target_name": clean_str(e_props.get("name")),
+                "target_label": e_label,
+                "rel_type": clean_str(rel_obj.get("type")),
+                "rel_label": clean_str(r_props.get("label") or r_props.get("name") or "")
+            }
+
+        # 2. 扁平格式适配
+        alias_map = {
+            "source": ["source_name", "source", "start_name", "起点"],
+            "target": ["target_name", "target", "end_name", "终点"],
+            "type": ["rel_type", "type", "relationship"],
+            "label": ["rel_label", "label", "关系标签"]
+        }
+
+        def find_value(keys):
+            for k in keys:
+                val = item.get(k)
+                if val and not isinstance(val, dict): return val
+            return None
+
+        return {
+            "source_name": clean_str(find_value(alias_map["source"])),
+            "source_label": clean_str(item.get("source_label") or ""),
+            "target_name": clean_str(find_value(alias_map["target"])),
+            "target_label": clean_str(item.get("target_label") or ""),
+            "rel_type": clean_str(find_value(alias_map["type"])),
+            "rel_label": clean_str(find_value(alias_map["label"])) or ""
+        }
+
     # --- 0. 数据修复工具 ---
     def fix_all_missing_node_ids(self):
         try:
@@ -392,86 +482,417 @@ class OperationService:
             return {"success": False, "msg": f"删除失败: {str(e)}"}
 
     # --- 7. 导出功能  ---
-    def export_nodes_to_json(self, label=None, name=None):
-        """
-        按照条件导出节点，确保包含 identity, elementId, labels, properties 等所有原始字段
-        """
+    def export_nodes_to_json(self, label=None, name=None):  # 删除了参数中的 limit=20
         try:
             conditions = []
             params = {}
 
-            # 构建过滤条件（复用查询逻辑，但去掉分页）
-            if name:
+            if name and str(name).strip() and name not in ["null", "undefined"]:
                 params["name"] = unquote(str(name)).strip()
                 conditions.append("n.name CONTAINS $name")
 
-            lb_clause = ""
-            if label and label not in ["全部", ""]:
-                # 为了保证原生对象的完整性，这里直接 MATCH 标签
-                lb_clause = f":`{label}`"
+            if label and str(label).strip() and label not in ["全部", "", "null", "undefined"]:
+                params["export_label"] = str(label).strip()
+                label_cypher = f":`{label}`"
+            else:
+                label_cypher = ""
 
             where_clause = "WHERE " + " AND ".join(conditions) if conditions else ""
 
-            # 注意：这里 RETURN n，返回的是整个节点对象
-            cypher = f"MATCH (n{lb_clause}) {where_clause} RETURN n"
-
-            raw_data = self.db.execute_read(cypher, params)
+            # 彻底移除 limit_clause
+            cypher = f"""
+            MATCH (n{label_cypher}) 
+            {where_clause} 
+            RETURN elementId(n) AS elementId, 
+                   labels(n) AS labels, 
+                   properties(n) AS properties
+            """
 
             export_items = []
-            for row in raw_data:
-                node = row['n']
-                # 核心逻辑：提取 Neo4j 节点对象的所有原生属性
-                node_data = {
-                    "identity": node.id, # 对应你截图中的 identity (旧版 ID)
-                    "elementId": node.element_id, # 对应你截图中的 elementId (新版 ID)
-                    "labels": list(node.labels),
-                    "properties": dict(node.items())
-                }
-                export_items.append(node_data)
+            with self.db.driver.session() as session:
+                result = session.run(cypher, params)
+                for index, row in enumerate(result):
+                    export_items.append({
+                        "identity": index,
+                        "elementId": row.get("elementId"),
+                        "labels": row.get("labels"),
+                        "properties": row.get("properties")
+                    })
 
-            return {"success": True, "data": export_items}
+            return {"success": True, "data": export_items, "count": len(export_items)}
         except Exception as e:
             traceback.print_exc()
             return {"success": False, "msg": f"导出节点失败: {str(e)}"}
 
-    def export_relationships_to_json(self, source=None, target=None, rel_type=None):
-        """
-        按照条件导出关系，确保包含起始/结束节点信息及完整属性
-        """
+    def export_relationships_to_json(self, source=None, target=None, rel_type=None):  # 删除了参数中的 limit=20
         try:
             conditions = []
             params = {}
+
             if source:
                 params["source"] = unquote(str(source)).strip()
                 conditions.append("a.name CONTAINS $source")
             if target:
                 params["target"] = unquote(str(target)).strip()
                 conditions.append("b.name CONTAINS $target")
-            if rel_type and rel_type not in ["全部", ""]:
-                conditions.append(f"type(r) = $rel_type")
-                params["rel_type"] = rel_type
+            if rel_type and str(rel_type).strip() and rel_type not in ["全部", "", "null", "undefined"]:
+                params["rel_type"] = str(rel_type).strip()
+                conditions.append("type(r) = $rel_type")
 
             where_clause = "WHERE " + " AND ".join(conditions) if conditions else ""
 
-            # 返回关系对象 r 以及起止节点的 elementId 以便追溯
-            cypher = f"MATCH (a)-[r]->(b) {where_clause} RETURN r, elementId(a) as startNode, elementId(b) as endNode"
-
-            raw_data = self.db.execute_read(cypher, params)
+            # 彻底移除 limit_clause
+            cypher = f"""
+        MATCH (a)-[r]->(b) 
+        {where_clause} 
+        RETURN 
+            {{
+                elementId: elementId(a),
+                labels: labels(a),
+                properties: properties(a)
+            }} AS start_node,
+            {{
+                elementId: elementId(b),
+                labels: labels(b),
+                properties: properties(b)
+            }} AS end_node,
+            {{
+                type: type(r),
+                properties: properties(r),
+                elementId: elementId(r),
+                startNodeElementId: elementId(a),
+                endNodeElementId: elementId(b)
+            }} AS rel_info
+        """
 
             export_items = []
-            for row in raw_data:
-                rel = row['r']
-                rel_data = {
-                    "identity": rel.id,
-                    "elementId": rel.element_id,
-                    "type": rel.type,
-                    "startNodeElementId": row['startNode'],
-                    "endNodeElementId": row['endNode'],
-                    "properties": dict(rel.items())
-                }
-                export_items.append(rel_data)
+            with self.db.driver.session() as session:
+                result = session.run(cypher, params)
+                for index, record in enumerate(result):
+                    s = record["start_node"]
+                    e = record["end_node"]
+                    r = record["rel_info"]
+
+                    node_id_base = index * 2
+                    s["identity"] = node_id_base
+                    e["identity"] = node_id_base + 1
+
+                    r["identity"] = index
+                    r["start"] = s["identity"]
+                    r["end"] = e["identity"]
+
+                    export_items.append({
+                        "start": s,
+                        "end": e,
+                        "segments": [{"start": s, "relationship": r, "end": e}],
+                        "length": 1.0
+                    })
+
+            return {"success": True, "data": export_items, "count": len(export_items)}
+        except Exception as e:
+            traceback.print_exc()
+            return {"success": False, "msg": f"导出关系失败: {str(e)}"}
+
+    # --- 8. 节点导入核心功能  ---
+    def precheck_nodes_batch(self, nodes_batch):
+        """
+        全量预检：针对一批数据，检查格式无效性、nodeId冲突、name+label冲突
+        """
+        conflicts = []
+        invalid_data = []
+        valid_nodes = []
+
+        # 1. 内存清洗：先转换格式，再严格校验“三要素”
+        for index, raw_node in enumerate(nodes_batch):
+            # 格式标准化 (处理平铺/嵌套)
+            node = self._format_node_data(raw_node)
+            props = node["properties"]
+
+            name = props.get("name")
+            labels = node["labels"]
+            node_id = props.get("nodeId")  # 关键：获取 nodeId
+
+            # 严格判定逻辑：name、labels、nodeId 缺一不可
+            if not name or not labels or node_id is None:
+                reasons = []
+                if not name: reasons.append("缺少 name")
+                if not labels: reasons.append("缺少 label")
+                if node_id is None: reasons.append("缺少 nodeId")
+
+                invalid_data.append({
+                    "index": index,
+                    "name": name or "未知",
+                    "reason": " | ".join(reasons)
+                })
+                continue
+
+            valid_nodes.append(node)
+
+        if not valid_nodes:
+            return {"success": True, "conflicts": conflicts, "invalid": invalid_data}
+
+        # 2. 批量数据库比对 (查询潜在冲突)
+        all_node_ids = [n["properties"]["nodeId"] for n in valid_nodes]
+        all_names = [n["properties"]["name"] for n in valid_nodes]
+
+        # 查询 nodeId 冲突
+        db_id_map = {}
+        if all_node_ids:
+            id_results = self.db.execute_read(
+                "MATCH (n) WHERE n.nodeId IN $ids RETURN n.nodeId as nodeId, n.name as name", {"ids": all_node_ids})
+            db_id_map = {row["nodeId"]: row for row in id_results}
+
+        # 查询 name+label 冲突
+        db_name_set = set()
+        if all_names:
+            name_results = self.db.execute_read(
+                "MATCH (n) WHERE n.name IN $names RETURN n.name as name, labels(n) as labels", {"names": all_names})
+            db_name_set = {f"{row['name']}_{lbl}" for row in name_results for lbl in row['labels']}
+
+        # 3. 组装冲突报告
+        for node in valid_nodes:
+            p = node["properties"]
+            n_id, name, labels = p["nodeId"], p["name"], node["labels"]
+
+            # 优先级 1: nodeId 冲突
+            if n_id in db_id_map:
+                conflicts.append({
+                    "name": name, "label": labels[0], "nodeId": n_id,
+                    "reason": f"业务ID冲突: 已存在 nodeId={n_id}",
+                    "type": "nodeId_duplicate"
+                })
+                continue
+
+            # 优先级 2: name + label 冲突
+            for lbl in labels:
+                if f"{name}_{lbl}" in db_name_set:
+                    conflicts.append({
+                        "name": name, "label": lbl, "nodeId": n_id,
+                        "reason": f"逻辑主键冲突: {lbl} 下已存在名称 '{name}'",
+                        "type": "logic_key_duplicate"
+                    })
+                    break
+
+        return {
+            "success": True,
+            "conflicts": conflicts,
+            "invalid": invalid_data,
+            "summary": {"total": len(nodes_batch), "valid": len(valid_nodes), "conflict": len(conflicts)}
+        }
+
+    def execute_node_import_batch(self, nodes_batch, mode="skip"):
+        try:
+            formatted_batch = [self._format_node_data(n) for n in nodes_batch]
+            # 获取当前时间的标准字符串格式，确保与手动添加的节点一致
+            current_time_str = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+            if mode == "strict":
+                check = self.precheck_nodes_batch(nodes_batch)
+                if check.get("conflicts"):
+                    return {"success": False, "msg": "严格模式下发现冲突，停止导入", "conflicts": check["conflicts"]}
+
+            label_groups = {}
+            for node in formatted_batch:
+                lbls = node.get("labels")
+                if not lbls or len(lbls) == 0: continue
+                lbl = lbls[0]
+                if lbl not in label_groups: label_groups[lbl] = []
+                props = node.get("properties")
+                if props and props.get("name"):
+                    label_groups[lbl].append(props)
+
+            total_imported = 0
+            with self.db.driver.session() as session:
+                for lbl, batch_props in label_groups.items():
+                    if not batch_props: continue
+
+                    # 关键修改：将 datetime() 替换为传入的 $now 字符串
+                    if mode == "update":
+                        cypher = f"""
+                        UNWIND $batch AS props
+                        MERGE (n:`{lbl}` {{name: props.name}})
+                        ON CREATE SET n = props, n.createTime = $now
+                        ON MATCH SET n += props, n.updateTime = $now
+                        RETURN count(n) as cnt
+                        """
+                    elif mode == "skip":
+                        cypher = f"""
+                        UNWIND $batch AS props
+                        MERGE (n:`{lbl}` {{name: props.name}})
+                        ON CREATE SET n = props, n.createTime = $now
+                        RETURN count(n) as cnt
+                        """
+                    else:
+                        cypher = f"""
+                        UNWIND $batch AS props
+                        CREATE (n:`{lbl}`)
+                        SET n = props, n.createTime = $now
+                        RETURN count(n) as cnt
+                        """
+
+                    res = session.run(cypher, {"batch": batch_props, "now": current_time_str})
+                    record = res.single()
+                    if record: total_imported += record["cnt"]
+
+            return {"success": True, "msg": f"成功处理 {total_imported} 个节点", "count": total_imported}
+        except Exception as e:
+            traceback.print_exc()
+            return {"success": False, "msg": f"批次导入异常: {str(e)}"}
+
+    def precheck_rels_batch(self, rels_batch):
+        """
+        关系导入预检 - 修复版
+        """
+        conflicts = []  # 关系已存在
+        invalid = []  # 节点不存在或格式错误
+        # 注意：这里不再使用 valid_to_check 这种模糊中间变量
+
+        # 统计真正可以执行导入的数量
+        actual_valid_count = 0
+
+        for raw_item in rels_batch:
+            item = self._normalize_rel_data(raw_item)
+
+            # 1. 基础格式校验
+            if not item["source_name"] or not item["target_name"] or not item["rel_type"]:
+                invalid.append({
+                    "source": item.get("source_name") or "未知",
+                    "target": item.get("target_name") or "未知",
+                    "reason": "格式错误：缺少必要字段"
+                })
+                continue
+
+            # 2. 数据库存在性校验
+            cypher = f"""
+            OPTIONAL MATCH (s {{name: $s_name}})
+            OPTIONAL MATCH (t {{name: $t_name}})
+            OPTIONAL MATCH (s)-[r:`{item['rel_type']}`]->(t)
+            RETURN s IS NOT NULL as hasS, t IS NOT NULL as hasT, r IS NOT NULL as hasR
+            """
+            res = self.db.execute_read(cypher, {"s_name": item["source_name"], "t_name": item["target_name"]})
+
+            if not res:
+                continue
+            rec = res[0]
+
+            if not rec["hasS"] or not rec["hasT"]:
+                # 关键修复：节点不存在，属于 invalid
+                invalid.append({
+                    "source": item["source_name"],
+                    "target": item["target_name"],
+                    "reason": f"节点不存在(起点:{'√' if rec['hasS'] else '×'}, 终点:{'√' if rec['hasT'] else '×'})"
+                })
+            elif rec["hasR"]:
+                # 关系已存在，属于冲突
+                conflicts.append({
+                    "source": item["source_name"],
+                    "target": item["target_name"],
+                    "type": item["rel_type"],
+                    "reason": "关系已存在"
+                })
+            else:
+                # 只有走到这里，才是真正的有效数据
+                actual_valid_count += 1
+
+        return {
+            "success": True,
+            "conflicts": conflicts,
+            "invalid": invalid,
+            "summary": {
+                "total": len(rels_batch),
+                "valid": actual_valid_count,  # 真正能导进去的数量
+                "conflict": len(conflicts),
+                "invalid": len(invalid)
+            }
+        }
+
+    def execute_rel_import_batch(self, rels_batch, mode="skip"):
+        """
+        执行导入：加入 Label 辅助匹配，确保 ElementId 100% 捕获
+        """
+        try:
+            now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            final_results = []
+
+            with self.db.driver.session() as session:
+                for raw_item in rels_batch:
+                    item = self._normalize_rel_data(raw_item)
+
+                    # 基础检查：没有起点或终点名称直接跳过
+                    if not item["source_name"] or not item["target_name"] or not item["rel_type"]:
+                        continue
+
+                    # 动态构建 Cypher：如果有 Label 则带上 Label，匹配更精准
+                    s_label_cypher = f":`{item['source_label']}`" if item['source_label'] else ""
+                    t_label_cypher = f":`{item['target_label']}`" if item['target_label'] else ""
+
+                    op = "ON MATCH SET r.label = $label" if mode == "update" else ""
+
+                    cypher = f"""
+                    MATCH (s{s_label_cypher} {{name: $s_name}})
+                    MATCH (t{t_label_cypher} {{name: $t_name}})
+                    MERGE (s)-[r:`{item['rel_type']}`]->(t)
+                    ON CREATE SET r.label = $label, r.createTime = $now
+                    {op}
+                    RETURN s, t, r, 
+                           id(s) as s_id, id(t) as t_id, id(r) as r_id,
+                           elementId(s) as s_eid, elementId(t) as t_eid, elementId(r) as r_eid
+                    """
+
+                    res = session.run(cypher, {
+                        "s_name": item["source_name"],
+                        "t_name": item["target_name"],
+                        "label": item["rel_label"],
+                        "now": now
+                    })
 
-            return {"success": True, "data": export_items}
+                    record = res.single()
+                    if record:
+                        s_node, t_node, r_rel = record["s"], record["t"], record["r"]
+
+                        # 严格按照你要求的“理想格式”拼装
+                        graph_item = {
+                            "start": {
+                                "identity": record["s_id"],
+                                "labels": list(s_node.labels),
+                                "properties": dict(s_node),
+                                "elementId": str(record["s_eid"])
+                            },
+                            "end": {
+                                "identity": record["t_id"],
+                                "labels": list(t_node.labels),
+                                "properties": dict(t_node),
+                                "elementId": str(record["t_eid"])
+                            },
+                            "segments": [{
+                                "start": {
+                                    "identity": record["s_id"],
+                                    "labels": list(s_node.labels),
+                                    "properties": dict(s_node),
+                                    "elementId": str(record["s_eid"])
+                                },
+                                "relationship": {
+                                    "identity": record["r_id"],
+                                    "start": record["s_id"],
+                                    "end": record["t_id"],
+                                    "type": r_rel.type,
+                                    "properties": dict(r_rel),
+                                    "elementId": str(record["r_eid"]),
+                                    "startNodeElementId": str(record["s_eid"]),
+                                    "endNodeElementId": str(record["t_eid"])
+                                },
+                                "end": {
+                                    "identity": record["identity"] if "identity" in t_node else record["t_id"], # 备选方案
+                                    "labels": list(t_node.labels),
+                                    "properties": dict(t_node),
+                                    "elementId": str(record["t_eid"])
+                                }
+                            }],
+                            "length": 1.0
+                        }
+                        final_results.append(graph_item)
+
+            return {"success": True, "data": final_results, "count": len(final_results)}
         except Exception as e:
             traceback.print_exc()
-            return {"success": False, "msg": f"导出关系失败: {str(e)}"}
\ No newline at end of file
+            return {"success": False, "msg": f"导入执行失败: {str(e)}"}
diff --git a/util/auth_interceptor.py b/util/auth_interceptor.py
index 2eeefc3..f0e4a8c 100644
--- a/util/auth_interceptor.py
+++ b/util/auth_interceptor.py
@@ -10,6 +10,7 @@ PUBLIC_PATHS = [
     '/api/register',
     '/api/checkUsername',
     '/resource',
+    '/api/kg/export',
 
 ]
 
diff --git a/vue/src/api/data.js b/vue/src/api/data.js
index 690b355..87e6f49 100644
--- a/vue/src/api/data.js
+++ b/vue/src/api/data.js
@@ -125,4 +125,99 @@ export function deleteRelationship(id) {
         method: 'post',
         data: { id }
     })
+}
+
+// --- 11. 导出接口---
+
+/**
+ * 导出节点数据到 JSON
+ * @param {object} params - 包含 name, label
+ */
+export function exportNodes(params) {
+    return request({
+        url: '/api/kg/export/nodes',
+        method: 'get',
+        params,
+        timeout: 60000
+    })
+}
+
+/**
+ * 导出关系数据到 JSON
+ * @param {object} params - 包含 source, target, type
+ */
+export function exportRelationships(params) {
+    return request({
+        url: '/api/kg/export/relationships',
+        method: 'get',
+        params,
+        timeout: 60000
+    })
+}
+
+// --- 12. 导入接口  ---
+
+/**
+ * 节点导入预检
+ * @param {Array} nodes - 全量节点列表（前端解析 JSON 后的数组）
+ * @returns {Promise} - 返回冲突列表和汇总报告
+ */
+export function precheckNodes(nodes) {
+    return request({
+        url: '/api/kg/import/nodes/precheck',
+        method: 'post',
+        data: { nodes },
+        // 预检 10 万条数据涉及大量内存比对，建议超时设为 2 分钟
+        timeout: 120000
+    })
+}
+
+/**
+ * 执行节点批量导入
+ * @param {Array} nodes - 当前批次的节点数据 (建议 5000 条一包)
+ * @param {string} mode - 导入模式: 'skip' (忽略), 'update' (更新), 'strict' (严格)
+ */
+export function executeImportNodes(nodes, mode = 'skip') {
+    return request({
+        url: '/api/kg/import/nodes/execute',
+        method: 'post',
+        data: {
+            nodes,
+            mode
+        },
+        // 单个批次处理建议超时 1 分钟
+        timeout: 60000
+    })
+}
+
+// --- 13. 关系导入接口  ---
+
+/**
+ * 关系导入预检
+ * @param {Array} relationships - 前端解析后的关系数组 (兼容嵌套和扁平格式)
+ */
+export function precheckRelationships(relationships) {
+    return request({
+        url: '/api/kg/import/relationships/precheck',
+        method: 'post',
+        data: { relationships },
+        timeout: 120000 // 关系预检涉及双向节点查询，超时时间设长
+    })
+}
+
+/**
+ * 执行关系批量导入
+ * @param {Array} relationships - 当前批次的关系数据
+ * @param {string} mode - 'skip' (忽略已存在), 'update' (覆盖已存在属性)
+ */
+export function executeImportRelationships(relationships, mode = 'skip') {
+    return request({
+        url: '/api/kg/import/relationships/execute',
+        method: 'post',
+        data: {
+            relationships,
+            mode
+        },
+        timeout: 60000
+    })
 }
\ No newline at end of file
diff --git a/vue/src/components/GraphToolbar.vue b/vue/src/components/GraphToolbar.vue
new file mode 100644
index 0000000..9ae4173
--- /dev/null
+++ b/vue/src/components/GraphToolbar.vue
@@ -0,0 +1,260 @@
+<template>
+  <div ref="toolbarContainer" class="custom-graph-toolbar"></div>
+</template>
+
+<script>
+import { ElMessageBox, ElMessage } from 'element-plus';
+
+export default {
+  name: 'GraphToolbar',
+  props: ['graph'],
+  data() {
+    return {
+      observer: null // 增加样式监听器
+    };
+  },
+  watch: {
+    graph: {
+      handler(newGraph) {
+        if (newGraph) {
+          this.$nextTick(() => {
+            // 给插件一点点初始化时间，确保 DOM 已存在
+            setTimeout(() => this.mountG6Toolbar(), 200);
+          });
+        }
+      },
+      immediate: true
+    }
+  },
+  beforeUnmount() {
+    // 组件销毁时断开监听，防止内存泄漏
+    if (this.observer) this.observer.disconnect();
+  },
+  methods: {
+    mountG6Toolbar() {
+      const container = this.$refs.toolbarContainer;
+      const g6ToolbarElement = document.querySelector('.g6-toolbar');
+
+      // 【日志 1：输入状态检查】
+      console.log('===[Toolbar Check Start]===');
+      console.log('1. Graph 实例状态:', !!this.graph);
+      console.log('2. Vue 容器 (ref):', !!container);
+      console.log('3. 是否抓取到原生 G6 DOM:', !!g6ToolbarElement);
+
+      if (!this.graph || !container || !g6ToolbarElement) {
+        console.warn('!!! [Toolbar] 挂载终止：由于缺少以上必要条件，搬家逻辑未执行。');
+        return;
+      }
+
+      // 1. 【搬家】将 G6 插件生成的 DOM 移动到 Vue 容器内
+      container.appendChild(g6ToolbarElement);
+
+      // 2. 【核心逻辑】锁死样式函数
+      const lockStyle = () => {
+        g6ToolbarElement.style.setProperty('position', 'static', 'important');
+        g6ToolbarElement.style.setProperty('inset', 'unset', 'important');
+        g6ToolbarElement.style.setProperty('display', 'flex', 'important');
+        g6ToolbarElement.style.setProperty('height', '100%', 'important');
+        g6ToolbarElement.style.setProperty('background', 'transparent', 'important');
+        g6ToolbarElement.style.setProperty('box-shadow', 'none', 'important');
+        g6ToolbarElement.style.setProperty('border', 'none', 'important');
+        g6ToolbarElement.style.setProperty('width', 'auto', 'important');
+      };
+
+      // 3. 【强效监控】防止刷新或 Resize 时 G6 自动改回样式
+      if (this.observer) this.observer.disconnect();
+      this.observer = new MutationObserver(() => lockStyle());
+      this.observer.observe(g6ToolbarElement, {attributes: true, attributeFilter: ['style']});
+
+      // 执行初始锁死
+      lockStyle();
+
+      // 4. 【修复报错】阻止冒泡，不使用 capture
+      const stopEvent = (e) => e.stopPropagation();
+      ['mousedown', 'click', 'dblclick', 'contextmenu', 'wheel'].forEach(type => {
+        g6ToolbarElement.addEventListener(type, stopEvent);
+      });
+    },
+
+    handleToolbarAction(id) {
+      if (!this.graph) return;
+      const historyPlugin = this.graph.getPluginInstance('history');
+      switch (id) {
+        case 'zoom-in':
+          this.graph.zoomBy(1.2);
+          break;
+        case 'zoom-out':
+          this.graph.zoomBy(0.8);
+          break;
+        case 'undo':
+          if (historyPlugin?.canUndo()) historyPlugin.undo();
+          break;
+        case 'redo':
+          if (historyPlugin?.canRedo()) historyPlugin.redo();
+          break;
+        case 'auto-fit':
+          this.graph.fitView();
+          break;
+        case 'reset':
+          break;
+        case 'export':
+          this.handleExportClick();
+          break;
+      }
+    },
+
+    async handleExportClick() {
+      ElMessageBox.confirm('请选择您要导出的图片格式：', '导出图谱', {
+        confirmButtonText: '导出为 PNG',
+        cancelButtonText: '导出为 SVG',
+        distinguishCancelAndClose: true,
+        type: 'info',
+        draggable: true,
+      }).then(async () => {
+        try {
+          const dataURL = await this.graph.toDataURL({type: 'image/png', backgroundColor: '#ffffff'});
+          const link = document.createElement('a');
+          link.href = dataURL;
+          link.download = `图谱_${Date.now()}.png`;
+          link.click();
+          ElMessage.success('PNG 导出成功');
+        } catch (e) {
+          ElMessage.error('PNG 导出失败');
+        }
+      }).catch((action) => {
+        if (action === 'cancel') this.exportToSVGManual();
+      });
+    },
+
+    exportToSVGManual() {
+      const graph = this.graph;
+      if (!graph) return;
+      const { nodes, edges } = graph.getData();
+      const bBox = graph.getCanvas().getRoot().getRenderBounds();
+      const padding = 60;
+      const minX = bBox.min[0] - padding;
+      const minY = bBox.min[1] - padding;
+      const maxX = bBox.max[0] + padding;
+      const maxY = bBox.max[1] + padding;
+      const vWidth = maxX - minX;
+      const vHeight = maxY - minY;
+
+      // 1. 定义与问答页面一致的颜色映射（用于兜底和逻辑计算）
+      const colorMap = {
+        'Disease': { fill: '#EF4444', stroke: '#B91C1C', edge: '#EF4444' },
+        'Drug': { fill: '#91cc75', stroke: '#047857', edge: '#91cc75' },
+        'Check': { fill: '#336eee', stroke: '#1D4ED8', edge: '#336eee' },
+        'Symptom': { fill: '#fac858', stroke: '#B45309', edge: '#fac858' },
+        'Other': { fill: '#59d1d4', stroke: '#40999b', edge: '#59d1d4' }
+      };
+
+      let svgContent = `<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="${vWidth}" height="${vHeight}" viewBox="${minX} ${minY} ${vWidth} ${vHeight}">`;
+      svgContent += `<rect x="${minX}" y="${minY}" width="${vWidth}" height="${vHeight}" fill="#ffffff" />`;
+
+      // 2. 渲染边
+      edges.forEach(edge => {
+        const s = nodes.find(n => n.id === edge.source);
+        const t = nodes.find(n => n.id === edge.target);
+        if (!s || !t) return;
+
+        // 获取坐标 (从 style 中取，G6 会把布局后的坐标存这)
+        const x1 = s.style?.x || 0;
+        const y1 = s.style?.y || 0;
+        const x2 = t.style?.x || 0;
+        const y2 = t.style?.y || 0;
+
+        // --- 核心修正：根据起点节点的类型来确定边的颜色 ---
+        // 这对应了你问答页面里 edge: { style: { stroke: (d) => ... } } 的逻辑
+        const sourceType = s.data?.label || 'Other'; // 获取起点类型 (Disease/Drug等)
+        const strokeColor = colorMap[sourceType]?.edge || '#cccccc';
+
+        // 绘制线条 (增加 stroke-width 确保可见)
+        svgContent += `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${strokeColor}" stroke-width="2" opacity="0.4" />`;
+
+        // 渲染边文字
+        const labelText = edge.data?.relationship?.properties?.label || edge.data?.label || "";
+        if (labelText) {
+          const mx = (x1 + x2) / 2;
+          const my = (y1 + y2) / 2;
+          svgContent += `<text x="${mx}" y="${my - 4}" fill="#666666" font-size="10" font-family="Microsoft YaHei" text-anchor="middle">${labelText}</text>`;
+        }
+      });
+
+      // 3. 渲染节点
+      nodes.forEach(node => {
+        const type = node.data?.label || 'Other';
+        const colors = colorMap[type] || colorMap['Other'];
+        const radius = (node.style?.size || 50) / 2;
+        const x = node.style?.x || 0;
+        const y = node.style?.y || 0;
+
+        svgContent += `<circle cx="${x}" cy="${y}" r="${radius}" fill="${colors.fill}" stroke="${colors.stroke}" stroke-width="1.5" />`;
+
+        if (node.data?.name) {
+          svgContent += `<text x="${x}" y="${y}" fill="#ffffff" font-size="12" font-family="Microsoft YaHei" text-anchor="middle" dominant-baseline="middle">${node.data.name}</text>`;
+        }
+      });
+
+      svgContent += `</svg>`;
+
+      // 保存文件逻辑保持不变...
+      try {
+        const blob = new Blob([svgContent], {type: 'image/svg+xml;charset=utf-8'});
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = `矢量图谱_${Date.now()}.svg`;
+        link.click();
+        URL.revokeObjectURL(url);
+        this.$message.success('全量矢量图导出成功');
+      } catch (err) {
+        this.$message.error('导出失败');
+      }
+    }
+  }
+}
+</script>
+
+<style scoped>
+.custom-graph-toolbar {
+  display: inline-flex !important;
+  width: auto !important;
+  min-width: 100px;
+  background: #ffffff;
+  border: 1px solid #e2e8f0;
+  border-radius: 8px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.08);
+  align-items: center;
+  height: 42px !important;
+  padding: 0 4px;
+  z-index: 1001;
+  pointer-events: auto;
+}
+
+:deep(.g6-toolbar) {
+  display: inline-flex !important;
+  height: 35px !important;
+  width: auto !important;
+  align-items: center !important;
+  background: transparent !important;
+}
+
+:deep(.g6-toolbar-item) {
+  width: 20px !important;
+  height: 35px !important;
+  font-size: 15px !important;
+  margin: 0 2px !important;
+  display: flex !important;
+  align-items: center !important;
+  justify-content: center !important;
+  border-radius: 6px;
+  cursor: pointer;
+  color: #838383 !important;
+  transition: all 0.2s;
+}
+
+:deep(.g6-toolbar-item:hover) {
+  background: #f1f5f9 !important;
+  color: #1e293b !important;
+}
+</style>
\ No newline at end of file
diff --git a/vue/src/system/GraphDemo.vue b/vue/src/system/GraphDemo.vue
index 38870ac..563e253 100644
--- a/vue/src/system/GraphDemo.vue
+++ b/vue/src/system/GraphDemo.vue
@@ -4,83 +4,90 @@
     <Menu
         :initial-active="0"
     />
-        <main class="main-body">
-          <header class="top-nav">
-            <div class="search-container">
-              <input v-model="searchKeyword" type="text" placeholder="搜索......" @keydown.enter="search"/>
-              <img src="@/assets/搜索.png" class="search-btn" @click="search"/>
-            </div>
-            <div class="legend-box">
-              <div v-for="(item, index) in legendItems" :key="index" class="legend-item">
-                <div
-                    :style="{
+    <main class="main-body">
+      <header class="top-nav">
+        <div class="search-container">
+          <input v-model="searchKeyword" type="text" placeholder="搜索......" @keydown.enter="search"/>
+          <img src="@/assets/搜索.png" class="search-btn" @click="search"/>
+        </div>
+        <div class="legend-box">
+          <div v-for="(item, index) in legendItems" :key="index" class="legend-item">
+            <div
+                :style="{
       backgroundColor: item.color,
       opacity: visibleCategories.has(item.key) ? 1 : 0.3 // ✅ 关键：根据状态调整透明度
     }"
-                    class="color-block"
-                    @click="toggleCategory(item.key)"
-                ></div>
-                <span style="    font-size: 12px;color: rgb(0, 0, 0);font-weight: 600;">{{ item.label }}</span>
-              </div>
+                class="color-block"
+                @click="toggleCategory(item.key)"
+            ></div>
+            <span style="    font-size: 12px;color: rgb(0, 0, 0);font-weight: 600;">{{ item.label }}</span>
+          </div>
+        </div>
+      </header>
+
+      <section class="main-content">
+        <div class="disease-container">
+          <div class="disease-header" :style="headerStyle">
+            <div class="d-title"><img :src="iconSrc" class="d-icon"/>
+              <span v-if="typeRadio=== 'Disease'">疾病信息</span>
+              <span v-if="typeRadio=== 'Drug'">药品信息</span>
+              <span v-if="typeRadio=== 'Check'">检查信息</span>
             </div>
-          </header>
-
-          <section class="main-content">
-            <div class="disease-container">
-              <div class="disease-header" :style="headerStyle">
-                <div class="d-title"><img :src="iconSrc" class="d-icon"/>
-                  <span v-if="typeRadio=== 'Disease'">疾病信息</span>
-                  <span v-if="typeRadio=== 'Drug'">药品信息</span>
-                  <span v-if="typeRadio=== 'Check'">检查信息</span>
-                </div>
-                <div v-if="typeRadio=== 'Disease'" class="d-count" :style="headerLabel">{{diseaseCount.toLocaleString()}}种</div>
-                <div v-if="typeRadio=== 'Drug'" class="d-count" :style="headerLabel">{{ drugCount.toLocaleString() }}种</div>
-                <div v-if="typeRadio=== 'Check'" class="d-count" :style="headerLabel">{{checkCount.toLocaleString()}}种</div>
-              </div>
-              <div>
-                <el-radio-group v-model="typeRadio" @change="changeTree">
-                  <el-radio
-                      value="Disease"
-                      :class="{'radio-disease': typeRadio === 'Disease'}"
-                  >疾病</el-radio>
-                  <el-radio
-                      value="Drug"
-                      :class="{'radio-drug': typeRadio === 'Drug'}"
-                  >药品</el-radio>
-                  <el-radio
-                      value="Check"
-                      :class="{'radio-check': typeRadio === 'Check'}"
-                  >检查</el-radio>
-                </el-radio-group>
-              </div>
-              <div class="disease-body">
-
-                <div class="tree">
-                  <el-tree
-                      :data="treeData"
-                      :props="treeProps"
-                      accordion
-                      expand-on-click-node
-                      :expand-on-click-node="false"
-                      @node-click="handleNodeClick"
-                  >
-                    <template #default="{ node, data }">
+            <div v-if="typeRadio=== 'Disease'" class="d-count" :style="headerLabel">{{diseaseCount.toLocaleString()}}种</div>
+            <div v-if="typeRadio=== 'Drug'" class="d-count" :style="headerLabel">{{ drugCount.toLocaleString() }}种</div>
+            <div v-if="typeRadio=== 'Check'" class="d-count" :style="headerLabel">{{checkCount.toLocaleString()}}种</div>
+          </div>
+          <div>
+            <el-radio-group v-model="typeRadio" @change="changeTree">
+              <el-radio
+                  value="Disease"
+                  :class="{'radio-disease': typeRadio === 'Disease'}"
+              >疾病</el-radio>
+              <el-radio
+                  value="Drug"
+                  :class="{'radio-drug': typeRadio === 'Drug'}"
+              >药品</el-radio>
+              <el-radio
+                  value="Check"
+                  :class="{'radio-check': typeRadio === 'Check'}"
+              >检查</el-radio>
+            </el-radio-group>
+          </div>
+          <div class="disease-body">
+
+            <div class="tree">
+              <el-tree
+                  :data="treeData"
+                  :props="treeProps"
+                  accordion
+                  expand-on-click-node
+                  :expand-on-click-node="false"
+                  @node-click="handleNodeClick"
+              >
+                <template #default="{ node, data }">
                         <span class="custom-tree-node">
                           <span class="code">{{ data.code }}</span>
                           <el-tooltip :content="data.label" placement="top">
                             <span class="label">{{ data.label }}</span>
                           </el-tooltip>
                         </span>
-                    </template>
-                  </el-tree>
-                </div>
-              </div>
-            </div>
-            <div class="graph-viewport">
-              <div ref="graphContainer" class="graph-container" id="container"></div>
+                </template>
+              </el-tree>
             </div>
-          </section>
-        </main>
+          </div>
+        </div>
+        <div class="graph-viewport">
+          <GraphToolbar
+              ref="toolbarRef"
+              v-if="_graph"
+              :graph="_graph"
+              class="toolbar-position"
+              style="position: absolute; top: 40px; left: 750px; z-index: 1000; width: auto;"
+          />
+          <div ref="graphContainer" class="graph-container" id="container"></div>
+        </div>
+      </section>
+    </main>
     <!-- 图谱容器 -->
   </div>
 </template>
@@ -90,13 +97,16 @@ import {getCheckTree, getCount, getDrugTree, getGraph, getTestGraphData} from "@
 import {Graph, Tooltip} from '@antv/g6';
 import Menu from "@/components/Menu.vue";
 import {a} from "vue-router/dist/devtools-EWN81iOl.mjs";
+import GraphToolbar from "@/components/GraphToolbar.vue";
 
 import Fuse from 'fuse.js';
+import {ElMessage} from "element-plus";
 export default {
   name: 'Display',
-  components: {Menu},
+  components: {Menu,GraphToolbar},
   data() {
     return {
+      _graph: null,
       G6: null, // 添加这个
       // 节点样式
       nodeShowLabel: true,
@@ -257,7 +267,7 @@ export default {
         edges: updatedEdges
       }
       this.defaultData = updatedData
-       setTimeout(() => {
+      setTimeout(() => {
         this.initGraph();
         this.buildCategoryIndex();
         window.addEventListener('resize', this.handleResize);
@@ -735,11 +745,10 @@ export default {
 
           },
           autoFit: {
-            type: 'center', // 自适应类型：'view' 或 'center'
+            type: 'center',
             options: {
-              // 仅适用于 'view' 类型
-              when: 'always', // 何时适配：'overflow'(仅当内容溢出时) 或 'always'(总是适配)
-              direction: 'both', // 适配方向：'x'、'y' 或 'both'
+              when: 'first',
+              direction: 'both',
             },
             animation: {
               // 自适应动画效果
@@ -747,8 +756,8 @@ export default {
               easing: 'ease-in-out', // 动画缓动函数
             },
           },
-          behaviors: [ 'zoom-canvas', 'drag-element',
-            'click-select','focus-element', {
+          behaviors: ['zoom-canvas', 'drag-element',
+            'click-select', 'focus-element', {
               type: 'hover-activate',
               degree: 1,
             },
@@ -795,7 +804,7 @@ export default {
                 shadowBlur: 10,
                 opacity: 1
               },
-              highlight:{
+              highlight: {
                 stroke: '#FF5722',
                 lineWidth: 4,
                 opacity: 1
@@ -803,7 +812,7 @@ export default {
               inactive: {
                 opacity: 0.8
               },
-              normal:{
+              normal: {
                 opacity: 1
               }
 
@@ -851,14 +860,14 @@ export default {
               inactive: {
                 opacity: 0.8
               },
-              normal:{
+              normal: {
                 opacity: 1
               }
 
             },
 
           },
-          data:this.defaultData,
+          data: this.defaultData,
 
         });
         this.$nextTick(() => {
@@ -916,23 +925,23 @@ export default {
         // });
         graph.on('node:click', (evt) => {
           const nodeItem = evt.target.id; // 获取当前鼠标进入的节点元素
-          let node=graph.getNodeData(nodeItem).data
-          let data={
-            label:node.name,
-            type:node.label
+          let node = graph.getNodeData(nodeItem).data
+          let data = {
+            label: node.name,
+            type: node.label
           }
-          getGraph(data).then(response=>{
+          getGraph(data).then(response => {
             console.log(response)
             this.formatData(response)
           }); // 等待 Promise 解析
         });
         graph.once('afterlayout', () => {
           if (!graph.destroyed) {
-            graph.fitCenter({ padding: 40, duration: 1000 });
+            graph.fitCenter({padding: 40, duration: 1000});
           }
         });
         this._graph = graph
-        this._graph.setPlugins([  {
+        this._graph.setPlugins([{
           type: 'tooltip',
           // 只对节点启用，边不显示tooltip
           enable: (e) => e.targetType === 'edge',
@@ -941,7 +950,7 @@ export default {
             console.log(e)
             const edge = items[0]; // 当前悬停的边
             if (!edge) return '';
-            const data=items[0].data
+            const data = items[0].data
             const sourceId = edge.source;
             const targetId = edge.target;
 
@@ -952,16 +961,78 @@ export default {
 
             const sourceName = sourceNode?.data.name || sourceId;
             const targetName = targetNode?.data.name || targetId;
-            const rel = data.relationship.properties.label  || '关联';
+            const rel = data.relationship.properties.label || '关联';
 
             return `<div style="padding: 4px 8px; color: #b6b2b2; border-radius: 4px; font-size: 12px;">
         ${sourceName} — ${rel} —> ${targetName}
       </div>`;
           },
-        },])
+        },
+          {
+            type: 'toolbar',
+            onClick: (id) =>
+            {
+              if (id === 'reset') {
+                // 1. 如果是重置，直接在本地执行方法
+                this.localResetGraph();
+              }
+              else if (this.$refs.toolbarRef) {
+                // 2. 其他功能（放大、导出等）继续交给组件处理
+                this.$refs.toolbarRef.handleToolbarAction(id);
+              }
+            },
+            getItems: () => {
+              return [
+                { id: 'zoom-in', value: 'zoom-in', title: '放大' },
+                { id: 'zoom-out', value: 'zoom-out', title: '缩小' },
+                { id: 'undo', value: 'undo', title: '撤销' },
+                { id: 'redo', value: 'redo', title: '重做' },
+                { id: 'auto-fit', value: 'auto-fit', title: '聚焦' },
+                { id: 'reset', value: 'reset', title: '重置' },
+                { id: 'export', value: 'export', title: '导出图谱' },
+              ];
+            },
+          },
+          // 如果需要撤销重做功能，必须加上 history 插件
+          { type: 'history', key: 'history' }])
+      }
+    },
+    localResetGraph() {
+      // 1. 检查图表实例和数据是否存在
+      if (!this._graph) return;
+
+      if (!this.defaultData || !this.defaultData.nodes) {
+        this.$message.warning("未找到可重置的数据源");
+        return;
       }
 
+      try {
+        // 2. 彻底清理鼠标指针状态
+        const canvas = this._graph.getCanvas();
+        if (canvas && typeof canvas.setCursor === 'function') {
+          canvas.setCursor('default');
+        }
 
+        // 3. 彻底销毁当前图谱实例
+        // 销毁会移除所有 DOM 节点和事件监听，彻底解决 EventBoundary 问题
+        this._graph.destroy();
+        this._graph = null;
+
+        // 4. 重新初始化
+        this.$nextTick(() => {
+          // initGraph 内部会自动读取 this.defaultData
+          this.initGraph();
+
+          // 5. 重新构建分类索引（因为 destroy 也会清空之前的交互索引）
+          this.buildCategoryIndex();
+
+          this.$message.success("图谱已重置");
+        });
+      } catch (err) {
+        console.error('重置图谱失败:', err);
+        // 降级处理：如果销毁失败，尝试刷新页面（可选）
+        // location.reload();
+      }
     },
 
     updateGraph(data) {
@@ -975,7 +1046,7 @@ export default {
       const updatedNodes = this.defaultData.nodes.map(node => ({
         ...node,
         type: this.nodeShape,
-        style:{
+        style: {
           size: this.nodeSize,
           fill: this.nodeFill,
           stroke: this.nodeStroke,
@@ -998,7 +1069,7 @@ export default {
       if (!this._graph) return
       const updatedEdges = this.defaultData.edges.map(edge => ({
         ...edge,
-        type:this.edgeType,
+        type: this.edgeType,
         style: {
           endArrow: this.edgeEndArrow,
           stroke: this.edgeStroke,
@@ -1276,12 +1347,14 @@ button:hover {
   padding: 0 15px;
   justify-content: flex-start;
 }
-.d-title{
+
+.d-title {
   display: flex;
   align-items: center;
   font-size: 13px;
 }
-.d-count{
+
+.d-count {
   font-size: 9px;
   background-color: #5989F0;
   border-radius: 7px;
@@ -1328,19 +1401,21 @@ button:hover {
   text-align: left;
   font-size: 12px;
 }
-.disease-body{
+
+.disease-body {
   width: 360px;
   overflow: scroll;
   height: 74vh;
 }
+
 /* 隐藏滚动条，但允许滚动 */
 .disease-body {
   /* Firefox */
   scrollbar-width: none; /* 'auto' | 'thin' | 'none' */
 
   /* Webkit (Chrome, Safari, Edge) */
-  -ms-overflow-style: none;  /* IE and Edge */
-  scrollbar-width: none;     /* Firefox */
+  -ms-overflow-style: none; /* IE and Edge */
+  scrollbar-width: none; /* Firefox */
   padding-bottom: 9px;
 }
 
@@ -1358,12 +1433,12 @@ button:hover {
 
 /deep/ .radio-drug .el-radio__input.is-checked .el-radio__inner {
   background: #52c41a; /* 检查的颜色 */
-  border-color:#52c41a;
+  border-color: #52c41a;
 }
 
 /deep/ .radio-check .el-radio__input.is-checked .el-radio__inner {
   background: #1890ff; /* 药品的颜色 */
-  border-color:#1890ff;
+  border-color: #1890ff;
 }
 
 
@@ -1376,25 +1451,25 @@ button:hover {
 
 /deep/ .radio-drug .el-radio__input.is-checked .el-radio__inner:hover {
   background: #52c41a; /* 检查的颜色 */
-  border-color:#52c41a;
+  border-color: #52c41a;
 }
 
 /deep/ .radio-check .el-radio__input.is-checked .el-radio__inner:hover {
   background: #1890ff; /* 药品的颜色 */
-  border-color:#1890ff;
+  border-color: #1890ff;
 }
 
 
-
 /* 自定义选中后的样式 */
-/deep/ .radio-disease .el-radio__input.is-checked+.el-radio__label {
+/deep/ .radio-disease .el-radio__input.is-checked + .el-radio__label {
   color: rgb(153, 10, 0);
 }
 
-/deep/ .radio-drug .el-radio__input.is-checked+.el-radio__label {
+/deep/ .radio-drug .el-radio__input.is-checked + .el-radio__label {
   color: #52c41a;
 }
-/deep/ .radio-check .el-radio__input.is-checked+.el-radio__label {
+
+/deep/ .radio-check .el-radio__input.is-checked + .el-radio__label {
   color: #1890ff;
 }
 </style>
\ No newline at end of file
diff --git a/vue/src/system/GraphQA.vue b/vue/src/system/GraphQA.vue
index 0bcce49..7fa6787 100644
--- a/vue/src/system/GraphQA.vue
+++ b/vue/src/system/GraphQA.vue
@@ -33,7 +33,7 @@
             <div class="answer-item" style=" background-color: #165DFF;
   border-color: #0066cc;
   color: #fff;    height: auto;max-height: 3vw">
-{{queryRecord}}
+              {{queryRecord}}
             </div>
           </div>
           <h2 class="section-title">问答结果</h2>
@@ -63,6 +63,12 @@
 
         <!-- 右侧：知识图谱 -->
         <div class="knowledge-graph">
+          <GraphToolbar
+              v-if="_graph"
+              :graph="_graph"
+              ref="toolbarRef"
+          />
+
           <div ref="graphContainer" class="graph-container" id="container"></div>
         </div>
       </div>
@@ -76,13 +82,15 @@ import Menu from "@/components/Menu.vue";
 import {qaAnalyze} from "@/api/qa";
 import {Graph} from "@antv/g6";
 import {getGraph} from "@/api/graph";
+import GraphToolbar from '@/components/GraphToolbar.vue';
 
 
 export default {
   name: 'GraghQA',
-  components: {Menu},
+  components: {Menu,GraphToolbar},
   data() {
     return {
+      _graph: null,
       query:"",
       answers:[],
       selected:0,
@@ -203,35 +211,78 @@ export default {
       }
 
     },
-    handleSearch(){
-      this.isSending=true
-      this.answers=[]
-      if (this._graph){
-        this._graph.clear()
-      }
-      let data={
-        text:this.query
+    handleSearch() {
+      alert('方法触发成功！');
+      console.log('--- 1. 发起搜索，参数为:', this.query);
+      this.isSending = true;
+      this.answers = [];
+
+      if (this._graph) {
+        this._graph.clear();
       }
-      this.queryRecord=this.query
-      this.query=""
-      // this.answers=[{"answer":"糖尿病患者应避免高糖食物，如糖果、甜点、含糖饮料等，以防止血糖波动。",
-      //   "result":{"nodes":[{"id":"e0a8410b-c5ee-47d4-acbe-b7ae5f111fd4","label":"糖尿病","type":"疾病"},{"id":"89f9498b-7a83-4361-889b-f96dfdfb802c","label":"血糖波动","type":"症状"},{"id":"03201620-ba9f-4957-b7d3-f89c5a115e37","label":"高糖食物","type":"其他类型"},{"id":"b0bace0a-eedc-485c-90d3-0a5378dc5556","label":"糖果","type":"其他类型"},{"id":"ffc12d7b-60e5-4ffa-a945-a0769f6e1047","label":"甜点","type":"其他类型"},{"id":"a7e94ee7-072b-456f-bc0c-354545851c38","label":"含糖饮料","type":"其他类型"}],"edges":[{"source":"e0a8410b-c5ee-47d4-acbe-b7ae5f111fd4","target":"03201620-ba9f-4957-b7d3-f89c5a115e37","label":"关联"},{"source":"e0a8410b-c5ee-47d4-acbe-b7ae5f111fd4","target":"b0bace0a-eedc-485c-90d3-0a5378dc5556","label":"关联"},{"source":"e0a8410b-c5ee-47d4-acbe-b7ae5f111fd4","target":"ffc12d7b-60e5-4ffa-a945-a0769f6e1047","label":"关联"},{"source":"e0a8410b-c5ee-47d4-acbe-b7ae5f111fd4","target":"a7e94ee7-072b-456f-bc0c-354545851c38","label":"关联"},{"source":"e0a8410b-c5ee-47d4-acbe-b7ae5f111fd4","target":"89f9498b-7a83-4361-889b-f96dfdfb802c","label":"导致"}]}}]
-      // this.initGraph(this.answers[0].result)
-      // this.formatData(this.answers[0].result)
-      qaAnalyze(data).then(res=>{
-        this.answers=res
-        if(this.answers.length>0){
-          this.initGraph(this.answers[0].result)
+
+      let data = { text: this.query };
+      this.queryRecord = this.query;
+      this.query = "";
+
+      // 1. 调用接口
+      qaAnalyze(data).then(res => {
+        console.log('--- 2. 接口响应成功 ---');
+        this.answers = res;
+        if (this.answers && this.answers.length > 0) {
+          this.initGraph(this.answers[0].result);
         }
-        this.isSending=false
-      })
+        this.isSending = false;
+      }).catch(err => {
+        console.error('--- 2. 接口失败，启动保底方案 ---', err);
+        const mockData = {
+          nodes: [
+            { id: "node1", label: "霍乱", data: { type: "疾病" } },
+            { id: "node2", label: "腹泻", data: { type: "症状" } },
+            { id: "node3", label: "脱水", data: { type: "疾病" } },
+            { id: "node4", label: "呕吐", data: { type: "疾病" } },
+            { id: "node5", label: "霍乱弧菌", data: { type: "病因" } },
+            { id: "node6", label: "复方磺胺", data: { type: "药品" } },
+
+          ],
+          edges: [
+            { id: "e1", source: "node1", target: "node2", data: { label: "典型症状" } },
+            { id: "e2", source: "node1", target: "node3", data: { label: "并发症" } },
+            { id: "e3", source: "node1", target: "node4", data: { label: "并发症" } },
+            { id: "e4", source: "node1", target: "node5", data: { label: "致病菌" } },
+            { id: "e5", source: "node1", target: "node6", data: { label: "推荐用药" } },
+          ]
+        };
+
+        // 伪造一个和接口返回格式一样的数组
+        this.answers = [{
+          answer: "后端接口连接失败，当前显示的是预览版图谱。",
+          result: mockData
+        }];
+
+        // 强制执行初始化，让工具栏出来
+        this.initGraph(this.answers[0].result);
+
+        this.isSending = false;
+        this.$message.warning("已切换至离线预览模式");
+      });
     },
-    formatData(data){
-      // this._graph.stopLayout();
-      // this.clearGraphState();
+    formatData(data) {
+      const typeMap = {
+        '疾病': 'Disease',
+        '药品': 'Drug',
+        '药物': 'Drug',
+        '症状': 'Symptom',
+        '检查': 'Check'
+      };
+
       const updatedEdges = data.edges.map(edge => ({
         ...edge,
-        type:  this.edgeType,
+        type: this.edgeType,
+        data: {
+          ...edge.data,
+          label: edge.data?.label || ""
+        },
         style: {
           endArrow: this.edgeEndArrow,
           stroke: this.edgeStroke,
@@ -240,28 +291,42 @@ export default {
           labelFontSize: this.edgeFontSize,
           labelFontFamily: this.edgeFontFamily,
           labelFill: this.edgeFontColor,
-
         },
-      }))
-      const updatedNodes = data.nodes.map(node => ({
-        ...node,
-        type: this.nodeShape,
-        style:{
-          size: this.nodeSize,
-          lineWidth: this.nodeLineWidth,
-          label: this.nodeShowLabel,
-          labelFontSize: this.nodeFontSize,
-          labelFontFamily: this.nodeFontFamily,
-          labelFill: this.nodeFontColor,
-          opacity: 1,
-        }
-      }))
+      }));
+
+      // 【关键修正点】
+      const updatedNodes = data.nodes.map(node => {
+        // 1. 这里使用标准大括号，去掉之前的圆括号
+        const englishLabel = typeMap[node.data?.type] || 'Other';
+
+        // 2. 必须手动 return
+        return {
+          ...node,
+          type: this.nodeShape,
+          data: {
+            ...node.data,
+            label: englishLabel, // 适配组件颜色逻辑 (GraphToolbar 里的 colorMap)
+            name: node.label     // 适配组件文字逻辑 (GraphToolbar 里的 node.data.name)
+          },
+          style: {
+            ...node.style,       // 必须保留原始 style 里的 x, y 坐标，否则导出时节点会重叠
+            size: this.nodeSize,
+            lineWidth: this.nodeLineWidth,
+            label: this.nodeShowLabel,
+            labelFontSize: this.nodeFontSize,
+            labelFontFamily: this.nodeFontFamily,
+            labelFill: this.nodeFontColor,
+            opacity: 1,
+          }
+        };
+      });
+
       const updatedData = {
         nodes: updatedNodes,
         edges: updatedEdges
-      }
+      };
 
-      this.updateGraph(updatedData)
+      this.updateGraph(updatedData);
     },
     updateGraph(data) {
       if (!this._graph) return
@@ -269,14 +334,39 @@ export default {
       this._graph.setData(data)
       this._graph.render()
     },
+    localResetGraph() {
+      if (!this._graph) return;
+
+      // 1. 获取当前选中的数据快照
+      const currentResult = this.answers[this.selected]?.result;
+      if (!currentResult) return;
+
+      // 2. 彻底销毁当前图谱实例（这是清理 EventBoundary 报错的终极手段）
+      this._graph.destroy();
+      this._graph = null;
+
+      // 3. 重新调用 initGraph，相当于重新加载页面时的纯净状态
+      // 这种方式不会闪烁，因为 initGraph 内部包含了一套完整的 render 流程
+      this.$nextTick(() => {
+        this.initGraph(currentResult);
+        this.$message.success("图谱已重置");
+      });
+    },
+
     initGraph(data) {
+      console.log('--- 触发了 initGraph ---', data);
       if (this._graph!=null){
         this._graph.destroy()
         this._graph = null;
       }
+
       const updatedEdges = data.edges.map(edge => ({
         ...edge,
         type:  this.edgeType,
+        data: {
+          ...edge.data,
+          label: edge.data?.label || ""
+        },
         style: {
           endArrow: this.edgeEndArrow,
           stroke: this.edgeStroke,
@@ -288,19 +378,29 @@ export default {
 
         },
       }))
-      const updatedNodes = data.nodes.map(node => ({
-        ...node,
-        type: this.nodeShape,
-        style:{
-          size: this.nodeSize,
-          lineWidth: this.nodeLineWidth,
-          label: this.nodeShowLabel,
-          labelFontSize: this.nodeFontSize,
-          labelFontFamily: this.nodeFontFamily,
-          labelFill: this.nodeFontColor,
-          opacity: 1,
-        }
-      }))
+      const typeMap = { '疾病': 'Disease', '药品': 'Drug', '药物': 'Drug', '症状': 'Symptom', '检查': 'Check' };
+      const updatedNodes = data.nodes.map(node => {
+        const englishLabel = typeMap[node.data?.type] || 'Other';
+        return {
+          ...node,
+          type: this.nodeShape,
+          data: {
+            ...node.data,
+            label: englishLabel, // 适配组件颜色逻辑
+            name: node.label     // 适配组件导出文字逻辑
+          },
+          style: {
+            ...node.style,
+            size: this.nodeSize,
+            lineWidth: this.nodeLineWidth,
+            label: this.nodeShowLabel,
+            labelFontSize: this.nodeFontSize,
+            labelFontFamily: this.nodeFontFamily,
+            labelFill: this.nodeFontColor,
+            opacity: 1,
+          }
+        };
+      });
       const updatedData = {
         nodes: updatedNodes,
         edges: updatedEdges
@@ -317,6 +417,32 @@ export default {
           container,
           width,
           height,
+          plugins: [
+            {
+              type: 'toolbar',
+              key: 'g6-toolbar',
+              onClick: (id) => {
+                if (id === 'reset') {
+                  this.localResetGraph(); // 如果你有重置方法
+                } else if (this.$refs.toolbarRef) {
+                  // 调用 GraphToolbar.vue 组件内部的方法执行 放大/缩小/导出
+                  this.$refs.toolbarRef.handleToolbarAction(id);
+                }
+              },
+              getItems: () => {
+                return [
+                  { id: 'zoom-in', value: 'zoom-in', title: '放大' },
+                  { id: 'zoom-out', value: 'zoom-out', title: '缩小' },
+                  { id: 'undo', value: 'undo', title: '撤销' },
+                  { id: 'redo', value: 'redo', title: '重做' },
+                  { id: 'auto-fit', value: 'auto-fit', title: '聚焦' },
+                  { id: 'reset', value: 'reset', title: '重置' },
+                  { id: 'export', value: 'export', title: '导出图谱' },
+                ];
+              },
+            },
+            { type: 'history', key: 'history' }, // 撤销重做必须
+          ],
           layout: {
             type: 'force', // 力导向布局
             gravity: 0.3,   // 重力系数，控制节点聚集程度
@@ -330,6 +456,10 @@ export default {
             'click-select','focus-element', {
               type: 'hover-activate',
               degree: 1,
+              enable: (e) =>
+              {
+                return e.target && e.target.id && e.action !== 'drag';
+              }
             },
             {
               type: 'drag-canvas',
@@ -388,9 +518,7 @@ export default {
 
           edge: {
             style: {
-              labelText: (d) => {
-                console.log(d)
-                return d.data.label},
+              labelText: (d) => {return d.data.label},
               stroke: (d) => {
                 const targetLabel = this._nodeLabelMap.get(d.source); // d.target 是目标节点 ID
                 if (targetLabel === '疾病') return 'rgba(239,68,68,0.5)';
@@ -452,8 +580,6 @@ export default {
 };
 </script>
 <style scoped>
-
-
 .medical-qa-container {
   padding: 25px;
   background-color: #F6F9FF;
@@ -630,9 +756,10 @@ export default {
 @keyframes bounce {
   0%, 80%, 100% {
     transform: scale(0);
-  } 40% {
-      transform: scale(1.0);
-    }
+  }
+  40% {
+    transform: scale(1.0);
+  }
 }
 
 /* 让每个圆点的动画延迟出现，形成连续效果 */
@@ -640,4 +767,29 @@ export default {
 .dot-2 { animation-delay: -0.2s; }
 .dot-3 { animation-delay: 0s; }
 .dot-4 { animation-delay: 0.2s; }
+
+.knowledge-graph {
+  position: relative; /* 必须！否则工具栏会飘走 */
+  flex: 1;
+  height: 100%;
+  background-color: white;
+  border-radius: 16px;
+  padding: 20px;
+  box-shadow: 0 4px 12px rgba(0,0,0,0.05);
+  overflow: hidden; /* 保证工具栏不超出边界 */
+}
+
+/* 确保图谱容器铺满 */
+.graph-container {
+  width: 100%;
+  height: 100%;
+}
+
+:deep(.custom-graph-toolbar) {
+  position: absolute !important; /* 强制绝对定位 */
+  top: 30px !important;
+  right: 30px !important;
+  z-index: 9999 !important; /* 确保层级最高 */
+  display: inline-flex !important;
+}
 </style>
\ No newline at end of file
diff --git a/vue/src/system/GraphStyle.vue b/vue/src/system/GraphStyle.vue
index b4ce351..33610c9 100644
--- a/vue/src/system/GraphStyle.vue
+++ b/vue/src/system/GraphStyle.vue
@@ -462,31 +462,22 @@ export default {
   methods: {
     handleEditConfig(item) {
       if (this.saveTimer) clearTimeout(this.saveTimer);
-
-      // 如果点击的是当前正在编辑的配置，则退出编辑状态
       if (this.editingConfigId === item.id) {
         this.exitEditingMode();
         return;
       }
-
       this.isInitialEcho = true;
       this.editingConfigId = item.id;
       this.editingConfigLabel = item.current_label;
       this.activeTags = item.current_label;
-
       const s = item.styles;
       if (!s) {
         this.isInitialEcho = false;
         return;
       }
-
-      // 将配置应用到控制面板变量
       this.applyStylesToPanel(s);
-
       const labelEn = tagToLabelMap[item.current_label];
       if (labelEn) this.tagStyles[labelEn] = JSON.parse(JSON.stringify(s));
-
-      // 确保该配置在 usingConfigIds 中
       if (!this.usingConfigIds.includes(item.id)) {
         this.styleGroups.forEach(g => {
           g.configs.forEach(c => {
@@ -497,14 +488,11 @@ export default {
         });
         this.usingConfigIds.push(item.id);
       }
-
       this.updateAllElements();
       this.$nextTick(() => {
         setTimeout(() => { this.isInitialEcho = false; }, 100);
       });
     },
-
-    // 抽离：将样式对象应用到左侧面板变量
     applyStylesToPanel(s) {
       this.nodeShowLabel = s.nodeShowLabel;
       this.nodeFontFamily = s.nodeFontFamily;
@@ -524,32 +512,22 @@ export default {
       this.edgeLineWidth = s.edgeLineWidth;
       this.edgeStroke = s.edgeStroke;
     },
-
-    // 退出编辑模式：恢复控制栏到初始默认值
     exitEditingMode() {
       this.editingConfigId = null;
       this.editingConfigLabel = '';
-
-      // 获取当前标签对应的系统初始默认样式
       const labelEn = tagToLabelMap[this.activeTags];
       const defaultStyle = this.getInitialTagParams(labelEn);
-
       this.isInitialEcho = true;
-      // 1. 恢复控制面板UI
       this.applyStylesToPanel(defaultStyle);
-      // 2. 恢复本地缓存（使图谱在该标签下也回归默认预览色）
       this.tagStyles[labelEn] = JSON.parse(JSON.stringify(defaultStyle));
-
       this.$nextTick(() => {
         this.isInitialEcho = false;
         this.updateAllElements();
       });
       ElMessage.info("已退出编辑模式，控制栏已恢复默认");
     },
-
     syncAndRefresh() {
       if (this.isInitialEcho) return;
-
       const labelEn = tagToLabelMap[this.activeTags];
       if (!labelEn) return;
 
@@ -561,46 +539,43 @@ export default {
         edgeFontSize: this.edgeFontSize, edgeFontColor: this.edgeFontColor, edgeType: this.edgeType,
         edgeLineWidth: this.edgeLineWidth, edgeStroke: this.edgeStroke
       };
-
-      // 实时预览更新
       this.tagStyles[labelEn] = currentStyle;
       this.updateAllElements();
 
-      // 只有在编辑模式下才同步到数据库
+      // 只有在“编辑模式”下才触发后端自动同步
       if (this.editingConfigId) {
         if (this.saveTimer) clearTimeout(this.saveTimer);
+
         const currentEditId = this.editingConfigId;
         this.saveTimer = setTimeout(async () => {
           try {
-            let targetConf = null;
-            let groupName = null;
+            // 修改点：简化逻辑，只传必要的 ID 和样式
+            const payload = {
+              id: currentEditId,          // 必须带 ID，触发后端 UPDATE
+              styles: currentStyle,       // 只传样式
+              is_auto_save: true,         // 告诉后端：强制锁定 GroupID，不准挪位置
+              // 这里的 canvas_name 和 current_label 主要是为了后端日志打印方便
+              canvas_name: this.saveForm.canvas_name || '自动保存',
+              current_label: this.activeTags
+            };
+
+            console.log(`%c[自动保存] 配置ID: ${currentEditId}`, "color: #E6A23C", payload);
+            await saveGraphStyle(payload);
+
+            // 更新本地内存中的样式，保持 UI 一致
             for (const group of this.styleGroups) {
-              targetConf = group.configs.find(c => c.id === currentEditId);
-              if (targetConf) {
-                groupName = group.group_name;
+              const conf = group.configs.find(c => c.id === currentEditId);
+              if (conf) {
+                conf.styles = JSON.parse(JSON.stringify(currentStyle));
                 break;
               }
             }
-
-            if (targetConf) {
-              const payload = {
-                id: currentEditId,
-                canvas_name: targetConf.canvas_name,
-                current_label: targetConf.current_label,
-                group_name: groupName,
-                styles: currentStyle,
-                is_auto_save: true
-              };
-              await saveGraphStyle(payload);
-              targetConf.styles = JSON.parse(JSON.stringify(currentStyle));
-            }
           } catch (err) {
             console.error("同步失败:", err);
           }
         }, 800);
       }
     },
-
     validateNodeSize(event) {
       const val = parseInt(event.target.value);
       if (isNaN(val) || val < 30 || val > 100) {
@@ -638,7 +613,6 @@ export default {
         edgeLineWidth: 2, edgeStroke: fill
       };
     },
-
     handleTagClick(tag) {
       if (this.editingConfigId && this.editingConfigLabel !== tag) {
         ElMessageBox.confirm(
@@ -654,18 +628,13 @@ export default {
         this.performTagSwitch(tag);
       }
     },
-
     performTagSwitch(tag) {
       this.activeTags = tag;
       const labelEn = tagToLabelMap[tag];
-
-      // 如果不在编辑模式，切换标签时让控制栏显示该标签的默认样式
       const style = this.editingConfigId ? this.tagStyles[labelEn] : this.getInitialTagParams(labelEn);
-
       if (style) {
         this.isInitialEcho = true;
         this.applyStylesToPanel(style);
-        // 如果是退出编辑后的切换，也要更新预览缓存
         if (!this.editingConfigId) {
           this.tagStyles[labelEn] = JSON.parse(JSON.stringify(style));
         }
@@ -674,26 +643,222 @@ export default {
       this.updateAllElements();
     },
 
+    // --- 第三种方法：XML 模板映射法  ---
+    async handleExportClick() {
+      if (!this._graph) return;
+      ElMessageBox.confirm(
+          '请选择您要导出的图片格式：',
+          '导出图谱',
+          {
+            confirmButtonText: '导出为 PNG',
+            cancelButtonText: '导出为 SVG',
+            distinguishCancelAndClose: true,
+            type: 'info',
+            draggable: true,
+          }
+      ).then(async () => {
+        try {
+          // PNG 导出保持官方推荐姿势
+          const dataURL = await this._graph.toDataURL({
+            type: 'image/png',
+            backgroundColor: '#ffffff'
+          });
+          const link = document.createElement('a');
+          link.href = dataURL;
+          link.download = `图谱_${Date.now()}.png`;
+          link.click();
+          ElMessage.success('PNG 导出成功');
+        } catch (e) {
+          ElMessage.error('PNG 导出失败');
+        }
+      }).catch((action) => {
+        if (action === 'cancel') {
+          this.exportToSVGManual();
+        }
+      });
+    },
+
+    exportToSVGManual() {
+      const graph = this._graph;
+      const { nodes, edges } = graph.getData();
+      const width = graph.getSize()[0];
+      const height = graph.getSize()[1];
+
+      // 1. 定义 SVG 头部和滤镜/渐变
+      let svgContent = `<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">`;
+      svgContent += `<rect width="100%" height="100%" fill="#ffffff" />`; // 背景
+      // 2. 先画边
+      edges.forEach(edge => {
+        const sourceNode = nodes.find(n => n.id === edge.source);
+        const targetNode = nodes.find(n => n.id === edge.target);
+        if (!sourceNode || !targetNode) return;
+        const x1 = sourceNode.style.x || 0;
+        const y1 = sourceNode.style.y || 0;
+        const x2 = targetNode.style.x || 0;
+        const y2 = targetNode.style.y || 0;
+        const style = edge.style || {};
+        const stroke = style.stroke || '#ccc';
+        const lineWidth = style.lineWidth || 1;
+        // 绘制直线
+        svgContent += `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${stroke}" stroke-width="${lineWidth}" />`;
+
+        // 如果有文字
+        if (style.labelText) {
+          const mx = (x1 + x2) / 2;
+          const my = (y1 + y2) / 2;
+          svgContent += `<text x="${mx}" y="${my}" fill="${style.labelFill || '#000'}" font-size="${style.labelFontSize || 10}" text-anchor="middle" dominant-baseline="middle">${style.labelText}</text>`;
+        }
+      });
+
+      // 3. 后画节点
+      nodes.forEach(node => {
+        const style = node.style || {};
+        const x = style.x || 0;
+        const y = style.y || 0;
+        const r = (style.size || 60) / 2;
+        const fill = style.fill || '#EF4444';
+        const stroke = style.stroke || '#B91C1C';
+        const lineWidth = style.lineWidth || 2;
+
+        // 绘制圆形
+        svgContent += `<circle cx="${x}" cy="${y}" r="${r}" fill="${fill}" stroke="${stroke}" stroke-width="${lineWidth}" />`;
+
+        // 绘制标签文字
+        if (style.labelText) {
+          svgContent += `<text x="${x}" y="${y}" fill="${style.labelFill || '#fff'}" font-size="${style.labelFontSize || 12}" font-family="${style.labelFontFamily || 'Arial'}" text-anchor="middle" dominant-baseline="middle">${style.labelText}</text>`;
+        }
+      });
+
+      svgContent += `</svg>`;
+
+      // 4. 触发下载
+      const blob = new Blob([svgContent], { type: 'image/svg+xml;charset=utf-8' });
+      const url = URL.createObjectURL(blob);
+      const link = document.createElement('a');
+      link.href = url;
+      link.download = `矢量图谱_${Date.now()}.svg`;
+      link.click();
+      URL.revokeObjectURL(url);
+      ElMessage.success(' SVG 导出成功');
+    },
+
+    initDraggableToolbar() {
+      const toolbar = document.querySelector('.draggable-toolbar');
+      if (!toolbar) return;
+      let isDragging = false;
+      let startPos = { x: 0, y: 0 };
+      let offset = { x: 0, y: 0 };
+      const onMouseDown = (e) => {
+        if (e.target.closest('.g6-toolbar-item')) return;
+        isDragging = true;
+        startPos = { x: e.clientX, y: e.clientY };
+        offset.x = e.clientX - toolbar.offsetLeft;
+        offset.y = e.clientY - toolbar.offsetTop;
+        toolbar.style.transition = 'none';
+        document.addEventListener('mousemove', onMouseMove);
+        document.addEventListener('mouseup', onMouseUp);
+        e.preventDefault();
+      };
+      const onMouseMove = (e) => {
+        if (!isDragging) return;
+        let left = e.clientX - offset.x;
+        let top = e.clientY - offset.y;
+        left = Math.max(10, Math.min(window.innerWidth - toolbar.offsetWidth - 10, left));
+        top = Math.max(10, Math.min(window.innerHeight - toolbar.offsetHeight - 10, top));
+        toolbar.style.left = left + 'px';
+        toolbar.style.top = top + 'px';
+        toolbar.style.right = 'auto';
+      };
+      const onMouseUp = () => {
+        isDragging = false;
+        document.removeEventListener('mousemove', onMouseMove);
+        document.removeEventListener('mouseup', onMouseUp);
+      };
+      toolbar.addEventListener('mousedown', onMouseDown);
+    },
+
     initGraph() {
       const container = this.$refs.graphContainer;
       if (!container || container.clientWidth === 0) return;
       this.defaultData.nodes.forEach(n => this._nodeLabelMap.set(n.id, n.data?.label));
       if (this._graph) this._graph.destroy();
+
       const graph = new Graph({
-        container, width: container.clientWidth, height: container.clientHeight || 600,
+        container,
+        width: container.clientWidth,
+        height: container.clientHeight || 600,
         layout: { type: 'radial', unitRadius: 100, preventOverlap: true, nodeSpacing: 50 },
         behaviors: ['zoom-canvas', 'drag-canvas', 'drag-element', 'hover-activate'],
-        autoFit: 'center', animation: false
+        autoFit: 'center',
+        animation: false,
+        plugins: [
+          { type: 'history', key: 'history' },
+          {
+            type: 'toolbar',
+            position: 'top-right',
+            className: 'g6-toolbar draggable-toolbar',
+            style: { marginRight: '320px', marginTop: '10px', cursor: 'move', zIndex: 999 },
+            onClick: (id) => {
+              const historyPlugin = this._graph.getPluginInstance('history');
+              switch (id) {
+                case 'zoom-in': this._graph.zoomBy(1.2); break;
+                case 'zoom-out': this._graph.zoomBy(0.8); break;
+                case 'undo':
+                  if (historyPlugin && historyPlugin.canUndo()) historyPlugin.undo();
+                  break;
+                case 'redo':
+                  if (historyPlugin && historyPlugin.canRedo()) historyPlugin.redo();
+                  break;
+                case 'auto-fit': this._graph.fitView(); break;
+                case 'reset':
+                  const currentData = this._graph.getData();
+                  const cleanNodes = currentData.nodes.map(node => {
+                    const { x, y, ...rest } = node;
+                    if (rest.style) {
+                      delete rest.style.x;
+                      delete rest.style.y;
+                    }
+                    return rest;
+                  });
+                  this._graph.zoomTo(1);
+                  this._graph.translateTo([container.clientWidth / 2, container.clientHeight / 2]);
+                  this._graph.setData({
+                    nodes: cleanNodes,
+                    edges: currentData.edges
+                  });
+                  this._graph.layout().then(() => {
+                    this._graph.fitCenter();
+                  });
+                  ElMessage.success("已重置图谱位置");
+                  break;
+                case 'export': this.handleExportClick(); break;
+              }
+            },
+            getItems: () => {
+              return [
+                { id: 'zoom-in', value: 'zoom-in', title: '放大' },
+                { id: 'zoom-out', value: 'zoom-out', title: '缩小' },
+                { id: 'undo', value: 'undo', title: '撤销' },
+                { id: 'redo', value: 'redo', title: '重做' },
+                { id: 'auto-fit', value: 'auto-fit', title: '聚焦' },
+                { id: 'reset', value: 'reset', title: '重置' },
+                { id: 'export', value: 'export', title: '导出图谱' },
+              ];
+            }
+          }
+        ]
       });
       this._graph = markRaw(graph);
       this.updateAllElements();
+      this.$nextTick(() => {
+        setTimeout(this.initDraggableToolbar, 800);
+      });
     },
     getEffectiveStyleKey(label) {
       return CORE_LABELS.includes(label) ? label : 'Other';
     },
     updateAllElements() {
       if (!this._graph) return;
-
       const currentActiveLabelEn = tagToLabelMap[this.activeTags];
       const labelToAppliedConfigMap = {};
       this.styleGroups.forEach(group => {
@@ -704,7 +869,6 @@ export default {
           }
         });
       });
-
       const hexToRgba = (hex, opacity) => {
         if (!hex) return 'rgba(182, 178, 178, 0.5)';
         if (hex.startsWith('rgba')) return hex;
@@ -715,7 +879,6 @@ export default {
       const nodes = this.defaultData.nodes.map(node => {
         const rawLabel = node.data?.label || '';
         const effectiveKey = this.getEffectiveStyleKey(rawLabel);
-
         let s;
         if (effectiveKey === currentActiveLabelEn) {
           s = {
@@ -727,7 +890,6 @@ export default {
         } else {
           s = labelToAppliedConfigMap[effectiveKey] || this.tagStyles[effectiveKey];
         }
-
         return {
           ...node, type: s?.nodeShape || 'circle',
           style: {
@@ -739,11 +901,9 @@ export default {
           }
         };
       });
-
       const edges = this.defaultData.edges.map(edge => {
         const sRawLabel = this._nodeLabelMap.get(edge.source);
         const effectiveKey = this.getEffectiveStyleKey(sRawLabel);
-
         let s;
         if (effectiveKey === currentActiveLabelEn) {
           s = {
@@ -754,7 +914,6 @@ export default {
         } else {
           s = labelToAppliedConfigMap[effectiveKey] || this.tagStyles[effectiveKey];
         }
-
         const strokeColor = hexToRgba(s?.edgeStroke || '#EF4444', 0.6);
         return {
           ...edge, type: s?.edgeType || 'line',
@@ -785,7 +944,6 @@ export default {
             }));
             return { ...group, configs: uniqueConfigs };
           });
-
           const activeGroup = this.styleGroups.find(g => g.is_active);
           if (activeGroup) {
             this.usingConfigIds = activeGroup.configs.map(c => c.id);
@@ -795,7 +953,6 @@ export default {
                 this.tagStyles[labelEn] = JSON.parse(JSON.stringify(conf.styles));
               }
             });
-
             const currentActiveConf = activeGroup.configs.find(c => c.current_label === this.activeTags);
             if (currentActiveConf) {
               this.isInitialEcho = true;
@@ -807,9 +964,7 @@ export default {
           }
           this.updateAllElements();
         }
-      } catch (err) {
-        console.error("加载配置失败:", err);
-      }
+      } catch (err) { console.error("加载配置失败:", err); }
     },
     async fetchGroupNames() {
       const res = await getGraphStyleGroups();
@@ -819,69 +974,83 @@ export default {
       const idx = this.usingConfigIds.indexOf(item.id);
       if (idx > -1) {
         this.usingConfigIds.splice(idx, 1);
-        if (this.editingConfigId === item.id) {
-          this.exitEditingMode(); // 退出应用的同时退出编辑
-        }
+        if (this.editingConfigId === item.id) this.exitEditingMode();
       } else {
         this.handleEditConfig(item);
       }
       this.updateAllElements();
     },
-
     validateGroupConstraint(groupName, labelName, excludeId = null) {
       const group = this.styleGroups.find(g => g.group_name === groupName);
       if (!group) return true;
-
       const isLabelExist = group.configs.some(c => c.current_label === labelName && c.id !== excludeId);
       if (isLabelExist) {
-        ElMessageBox.alert(`方案【${groupName}】中已存在【${labelName}】标签的配置，请先删除旧配置或选择其他方案。`, '校验失败', { type: 'error' }).catch(() => {});
+        ElMessageBox.alert(`方案【${groupName}】中已存在【${labelName}】标签的配置。`, '校验失败', { type: 'error' }).catch(() => {});
         return false;
       }
-
       if (group.configs.length >= 5 && !group.configs.some(c => c.id === excludeId)) {
-        ElMessageBox.alert(`方案【${groupName}】的配置已满（上限5个），无法添加。`, '校验失败', { type: 'error' }).catch(() => {});
+        ElMessageBox.alert(`方案【${groupName}】已满（上限5个）。`, '校验失败', { type: 'error' }).catch(() => {});
         return false;
       }
       return true;
     },
-
     async moveConfigToGroup(config, targetGroup) {
+      // 1. 拦截无效移动
+      if (config.group_id === targetGroup.id) {
+        return ElMessage.info("该配置已在该方案中");
+      }
+
       if (!this.validateGroupConstraint(targetGroup.group_name, config.current_label, config.id)) return;
+
       try {
+        // 2. 构造 Payload：直接传入 target_group_id
         const payload = {
-          id: config.id, canvas_name: config.canvas_name, group_name: targetGroup.group_name,
-          current_label: config.current_label, styles: config.styles, is_auto_save: false
+          id: config.id,
+          target_group_id: targetGroup.id, // 新增：直接传 ID，最准确D
+          canvas_name: config.canvas_name,
+          current_label: config.current_label,
+          styles: config.styles,
+          is_auto_save: false
         };
+
         const res = await saveGraphStyle(payload);
         if (res.code === 200) {
           ElMessage.success(`已移动至【${targetGroup.group_name}】`);
-          await this.fetchConfigs();
+          await this.fetchConfigs(); // 刷新列表
+        } else {
+          ElMessage.error(res.msg || "移动失败");
         }
-      } catch (err) { ElMessage.error("操作失败"); }
+      } catch (err) {
+        ElMessage.error("移动操作异常");
+      }
     },
-
     handleSaveClick() {
       this.fetchGroupNames();
       this.saveForm.canvas_name = `${this.activeTags}_${Date.now()}`;
+      this.saveForm.group_name = '';
       this.saveDialogVisible = true;
     },
-
     async confirmSave() {
       if (!this.saveForm.group_name?.trim() || !this.saveForm.canvas_name?.trim()) return ElMessage.warning("请完善名称");
       if (!this.validateGroupConstraint(this.saveForm.group_name.trim(), this.activeTags)) return;
       const labelEn = tagToLabelMap[this.activeTags];
       const payload = {
-        canvas_name: this.saveForm.canvas_name.trim(), group_name: this.saveForm.group_name.trim(),
-        current_label: this.activeTags, styles: { ...this.tagStyles[labelEn] }, is_auto_save: false
+        canvas_name: this.saveForm.canvas_name.trim(),
+        group_name: this.saveForm.group_name.trim(),
+        current_label: this.activeTags,
+        styles: { ...this.tagStyles[labelEn] },
+        is_auto_save: false // 标记为手动保存
       };
       const res = await saveGraphStyle(payload);
       if (res.code === 200) {
         ElMessage.success("保存成功");
         this.saveDialogVisible = false;
+        this.editingConfigId = null;
+        this.editingConfigLabel = '';
+
         await this.fetchConfigs();
       }
     },
-
     async applyWholeGroup(group) {
       if (this.saveTimer) clearTimeout(this.saveTimer);
       this.isInitialEcho = true;
@@ -899,13 +1068,11 @@ export default {
         const res = await applyGraphStyleGroup(group.id);
         if (res.code === 200) {
           await this.fetchConfigs();
-          // 应用全案后，默认开启第一个配置的编辑模式
           if (group.configs.length > 0) this.handleEditConfig(group.configs[0]);
           ElMessage.success(`已应用方案【${group.group_name}】`);
         }
       } catch (err) { this.isInitialEcho = false; ElMessage.error("切换失败"); }
     },
-
     resetStyle() {
       const labelEn = tagToLabelMap[this.activeTags];
       const initial = this.getInitialTagParams(labelEn);
@@ -917,7 +1084,6 @@ export default {
         this.syncAndRefresh();
       });
     },
-
     async deleteSingleConfig(id) {
       if (this.usingConfigIds.includes(id)) return ElMessage.error("应用中无法删除");
       try {
@@ -926,7 +1092,6 @@ export default {
         if (res.code === 200) { ElMessage.success("删除成功"); this.fetchConfigs(); }
       } catch (err) { }
     },
-
     async deleteGroup(groupId) {
       const group = this.styleGroups.find(g => g.id === groupId);
       if (!group || group.is_active) return ElMessage.error("应用中无法删除");
@@ -936,7 +1101,6 @@ export default {
         if (res.code === 200) { ElMessage.success("已删除"); this.fetchConfigs(); }
       } catch (err) { }
     },
-
     async handleUnifiedBatchDelete() {
       if (this.checkedConfigIds.length === 0 && this.checkedGroupIds.length === 0) return;
       try {
@@ -946,7 +1110,6 @@ export default {
         ElMessage.success("成功"); this.clearSelection(); this.fetchConfigs();
       } catch (e) { }
     },
-
     clearSelection() { this.checkedConfigIds = []; this.checkedGroupIds = []; },
     handleResize() {
       if (this._graph && this.$refs.graphContainer) {
@@ -956,6 +1119,7 @@ export default {
   }
 }
 </script>
+
 <style scoped>
 
 /* 精准控制“应用全案”按钮 */
@@ -1482,20 +1646,24 @@ export default {
 :deep(.el-dialog .el-input__inner) {
   outline: none !important;
 }
-</style>
 
-<style>
-.el-message-box__header {
-  text-align: left !important;
-  padding-top: 15px !important;
+/* 强制覆盖 G6 工具栏样式 */
+:deep(.g6-toolbar) {
+  height: 35px !important;
+  display: flex !important;
+  align-items: center !important;
+  padding: 0 10px !important;
 }
 
-.el-message-box__title {
-  color: #000000 !important;
-  font-weight: 500 !important;
-  font-size: 18px !important;
+:deep(.g6-toolbar-item) {
+  width: 20px !important;
+  height: 35px !important;
+  font-size: 15px !important;
+  margin: 0 4px !important;
 }
 
+</style>
+<style>
 .el-message-box__btns .el-button--primary {
   background-color: #1559f3 !important;
   border-color: #1559f3 !important;
diff --git a/vue/src/system/KGData.vue b/vue/src/system/KGData.vue
index 5f97879..bb24279 100644
--- a/vue/src/system/KGData.vue
+++ b/vue/src/system/KGData.vue
@@ -84,8 +84,8 @@
               </div>
               <div class="filter-btns">
                 <el-button type="primary" class="btn-search-ref" @click="handleNodeSearch">搜索</el-button>
-                <el-button type="primary"  class="btn-import" @click="">导入</el-button>
-                <el-button type="primary" class="btn-export" @click="">导出</el-button>
+                <el-button type="primary" class="btn-import" @click="triggerImport('node')">导入</el-button>
+                <el-button type="warning" class="btn-export" @click="handleExport('node')">导出</el-button>
                 <el-button class="btn-orange" @click="openNodeDialog(null)">新增节点</el-button>
               </div>
             </div>
@@ -104,7 +104,6 @@
                     <div class="op-group">
                       <el-button class="ref-op-btn edit" @click="openNodeDialog(scope.row)">编辑</el-button>
                       <el-button class="ref-op-btn delete" @click="handleDelete(scope.row, 'node')">删除</el-button>
-<!--                      <el-button class="ref-op-btn view" @click="handleView(scope.row, 'node')">详情</el-button>-->
                     </div>
                   </template>
                 </el-table-column>
@@ -178,6 +177,8 @@
               </div>
               <div class="filter-btns">
                 <el-button type="primary" class="btn-search-ref" @click="handleRelSearch">查询</el-button>
+                <el-button type="primary" class="btn-import" @click="triggerImport('rel')">导入</el-button>
+                <el-button type="warning" class="btn-export" @click="handleExport('rel')">导出</el-button>
                 <el-button class="btn-orange" @click="openRelDialog(null)">新增关系</el-button>
               </div>
             </div>
@@ -196,7 +197,6 @@
                     <div class="op-group">
                       <el-button class="ref-op-btn edit" @click="openRelDialog(scope.row)">编辑</el-button>
                       <el-button class="ref-op-btn delete" @click="handleDelete(scope.row, 'rel')">删除</el-button>
-<!--                      <el-button class="ref-op-btn view" @click="handleView(scope.row, 'rel')">详情</el-button>-->
                     </div>
                   </template>
                 </el-table-column>
@@ -222,7 +222,90 @@
       </div>
     </main>
 
-    <el-dialog v-model="detailVisible" title="数据详情" style="    border-radius: 7px;" width="550px" destroy-on-close header-class="bold-header">
+    <input type="file" ref="fileInput" style="display: none" accept=".json" @change="handleFileChange"/>
+
+    <el-dialog v-model="importDialogVisible" title="批量导入预检报告" width="550px" class="custom-dialog"
+               :close-on-click-modal="false" header-class="bold-header">
+      <div style="display: flex; gap: 16px; padding: 10px 5px;">
+        <div style="flex-shrink: 0; padding-top: 2px;">
+          <el-icon v-if="importStep === 'report'" :size="28"
+                   :color="importReport.conflicts.length > 0 ? '#e6a23c' : '#67c23a'">
+            <WarningFilled v-if="importReport.conflicts.length > 0"/>
+            <SuccessFilled v-else/>
+          </el-icon>
+          <el-icon v-else class="is-loading" :size="28" color="#165dff">
+            <Loading/>
+          </el-icon>
+        </div>
+
+        <div style="flex: 1;">
+          <div v-if="importStep === 'checking'">
+            <p style="margin: 0; font-size: 16px; font-weight: bold; color: #303133;">正在分析数据冲突...</p>
+            <p style="margin: 8px 0 0; font-size: 14px; color: #606266;">系统正在检查 JSON 文件中的重复数据。</p>
+          </div>
+
+          <div v-else-if="importStep === 'report'">
+            <p style="margin: 0; font-size: 16px; font-weight: bold; color: #303133;">
+              <span v-if="importReport.invalid.length > 0" style="color: #f56c6c">检测到非法数据</span>
+              <span v-else-if="importReport.conflicts.length > 0" style="color: #e6a23c">检测到数据冲突</span>
+              <span v-else style="color: #67c23a;">预检通过</span>
+            </p>
+
+            <p style="margin: 8px 0 15px; font-size: 14px; color: #606266; line-height: 1.6;">
+              本次导入包含 {{ importReport.summary.total }} 条数据。
+              <span v-if="importReport.invalid.length > 0">
+      其中 <b style="color: #f56c6c">{{ importReport.invalid.length }}</b> 条数据由于节点不存在无法导入。
+    </span>
+              <span v-if="importReport.conflicts.length > 0">
+      另有 <b style="color: #e6a23c">{{ importReport.conflicts.length }}</b> 条已存在。
+    </span>
+              <span v-if="importReport.summary.valid > 0" style="color: #67c23a;">
+      可导入 <b>{{ importReport.summary.valid }}</b> 条。
+    </span>
+            </p>
+
+            <div style="background: #f8f9fb; padding: 10px; border-radius: 6px; margin-bottom: 15px;">
+              <span style="font-size: 13px; font-weight: bold; color: #606266; margin-right: 10px;">处理策略:</span>
+              <el-radio-group v-model="importMode" size="small">
+                <el-radio label="skip">跳过重复</el-radio>
+                <el-radio label="update">覆盖更新</el-radio>
+              </el-radio-group>
+            </div>
+
+            <el-table :data="importReport.conflicts.slice(0, 5)" border size="small"
+                      style="width: 100%; font-size: 12px;">
+              <el-table-column :prop="importType === 'node' ? 'nodeId' : 'source'"
+                               :label="importType === 'node' ? 'ID' : '起点'" show-overflow-tooltip/>
+              <el-table-column :prop="importType === 'node' ? 'name' : 'target'"
+                               :label="importType === 'node' ? '名称' : '终点'" show-overflow-tooltip/>
+              <el-table-column
+                  v-if="importReport.invalid.length > 0"
+                  prop="reason"
+                  label="异常原因"
+                  width="180"
+                  style="color: #f56c6c"
+              />
+            </el-table>
+          </div>
+
+          <div v-else-if="importStep === 'uploading'">
+            <p style="margin: 0 0 10px; font-weight: bold;">正在写入数据库...</p>
+            <el-progress :percentage="importProgress" :stroke-width="15" striped striped-flow/>
+          </div>
+        </div>
+      </div>
+
+      <template #footer>
+        <div class="dialog-footer-wrap" v-if="importStep === 'report'">
+          <el-button class="btn-cancel" @click="importDialogVisible = false">取消导入</el-button>
+          <el-button class="btn-confirm" type="primary" @click="startBatchImport"
+                     :disabled="importReport.summary.valid === 0" >{{ importReport.summary.valid === 0 ? '无有效数据' : '开始导入' }}</el-button>
+        </div>
+      </template>
+    </el-dialog>
+
+    <el-dialog v-model="detailVisible" title="数据详情" style="border-radius: 7px;" width="550px" destroy-on-close
+               header-class="bold-header">
       <el-descriptions :column="1" border>
         <el-descriptions-item label="系统 ID (ElementId)">{{ currentDetail.id }}</el-descriptions-item>
         <template v-if="detailType === 'node'">
@@ -248,7 +331,8 @@
           <el-input v-model="nodeForm.name" placeholder="请输入实体名称" clearable/>
         </el-form-item>
         <el-form-item label="标签" required>
-          <el-select class="label-select" v-model="nodeForm.label" filterable placeholder="请选择标签" style="width: 100%">
+          <el-select class="label-select" v-model="nodeForm.label" filterable placeholder="请选择标签"
+                     style="width: 100%">
             <el-option v-for="item in dynamicLabels" :key="item" :label="translateToChinese(item)" :value="item"/>
           </el-select>
         </el-form-item>
@@ -292,9 +376,6 @@
             />
           </el-select>
         </el-form-item>
-<!--        <el-form-item label="显示名称">-->
-<!--          <el-input v-model="relForm.label" placeholder="用于前端展示的中文名称"/>-->
-<!--        </el-form-item>-->
       </el-form>
       <template #footer>
         <div class="dialog-footer-wrap">
@@ -310,70 +391,40 @@
 
 <script setup>
 import {ref, onMounted, reactive, computed} from 'vue'
-import {ElMessage, ElMessageBox} from 'element-plus'
+import {ElMessage, ElMessageBox, ElLoading} from 'element-plus'
 import Menu from '@/components/Menu.vue'
 import {
   getKgStats, getLabels, getRelationshipTypes, getNodeSuggestions, getNodesList, getRelationshipsList,
   addNode, updateNode, addRelationship, updateRelationship, deleteNode, deleteRelationship,
-  fixNodeIds
+  fixNodeIds,
+  exportNodes, exportRelationships,
+  precheckNodes, executeImportNodes,
+  precheckRelationships, executeImportRelationships
 } from '@/api/data'
 import {preload} from "@/api/graph";
 
-// --- 映射字典 (作为兜底和基础映射) ---
+// --- 映射字典 ---
 const CHINESE_TO_ENGLISH_LABEL = {
-  "疾病": "Disease",
-  "症状": "Symptom",
-  "检查项目": "AuxiliaryExamination",
-  "药物": "Drug",
-  "手术": "Operation",
-  "解剖部位": "CheckSubject",
-  "并发症": "Complication",
-  "诊断": "Diagnosis",
-  "治疗": "Treatment",
-  "辅助治疗": "AdjuvantTherapy",
-  "不良反应": "adverseReactions",
-  "检查": "Check",
-  "部门": "Department",
-  "疾病部位": "DiseaseSite",
-  "相关疾病": "RelatedDisease",
-  "相关症状": "RelatedSymptom",
-  "传播途径": "SpreadWay",
-  "阶段": "Stage",
-  "药物分类": "Subject",
-  "症状与体征": "SymptomAndSign",
-  "治疗方案": "TreatmentPrograms",
-  "类型": "Type",
-  "原因": "Cause",
-  "属性": "Attribute",
-  "指示/适应症": "Indications",
-  "成分": "Ingredients",
-  "病原学": "Pathogenesis",
-  "病理类型": "PathologicalType",
-  "发病机制": "Pathophysiology",
-  "注意事项": "Precautions",
-  "预后": "Prognosis",
-  "预后生存时间": "PrognosticSurvivalTime",
-  "疾病比率": "DiseaseRatio",
-  "药物治疗": "DrugTherapy",
-  "感染性": "Infectious",
-  "关联实体":"RelatedTo",
-  "人群分组":"MultipleGroups",
-  "发病率":"DiseaseRate"
+  "疾病": "Disease", "症状": "Symptom", "检查项目": "AuxiliaryExamination", "药物": "Drug", "手术": "Operation",
+  "解剖部位": "CheckSubject", "并发症": "Complication", "诊断": "Diagnosis", "治疗": "Treatment",
+  "辅助治疗": "AdjuvantTherapy", "不良反应": "adverseReactions", "检查": "Check", "部门": "Department",
+  "疾病部位": "DiseaseSite", "相关疾病": "RelatedDisease", "相关症状": "RelatedSymptom", "传播途径": "SpreadWay",
+  "阶段": "Stage", "药物分类": "Subject", "症状与体征": "SymptomAndSign", "治疗方案": "TreatmentPrograms",
+  "类型": "Type", "原因": "Cause", "属性": "Attribute", "指示/适应症": "Indications", "成分": "Ingredients",
+  "病原学": "Pathogenesis", "病理类型": "PathologicalType", "发病机制": "Pathophysiology", "注意事项": "Precautions",
+  "预后": "Prognosis", "预后生存时间": "PrognosticSurvivalTime", "疾病比率": "DiseaseRatio", "药物治疗": "DrugTherapy",
+  "感染性": "Infectious", "关联实体": "RelatedTo", "人群分组": "MultipleGroups", "发病率": "DiseaseRate"
 };
 
-// 动态获取的关系类型映射
 const dynamicRelTypes = ref([]);
 const dynamicLabels = ref([]);
 
-// 核心：翻译字典逻辑
 const ENGLISH_TO_CHINESE = computed(() => {
   const map = {};
-  // 1. 基础字典映射
   for (const [chi, eng] of Object.entries(CHINESE_TO_ENGLISH_LABEL)) {
     map[eng] = chi;
     map[eng.toLowerCase()] = chi;
   }
-  // 2. 数据库动态获取的映射 (优先级更高)
   dynamicRelTypes.value.forEach(item => {
     map[item.type] = item.label;
   });
@@ -411,30 +462,39 @@ const detailType = ref('node');
 const currentDetail = ref({});
 const isEdit = ref(false);
 
-// --- 表单数据 ---
 const nodeForm = reactive({id: '', name: '', label: ''});
 const relForm = reactive({id: '', source: '', target: '', type: '', label: ''});
 
-// --- 分页切换处理逻辑 ---
+// --- 批量导入状态 ---
+const fileInput = ref(null);
+const importDialogVisible = ref(false);
+const importType = ref('node');
+const importStep = ref('checking');
+const importProgress = ref(0);
+const importMode = ref('skip');
+const importRawData = ref([]);
+const importReport = reactive({
+  conflicts: [],
+  invalid: [],
+  summary: {total: 0, valid: 0, conflict: 0}
+});
+
+// 分页处理
 const handleNodeSizeChange = (val) => {
   pageSize.value = val;
   nodePage.value = 1;
   fetchNodes();
 };
-
 const handleRelSizeChange = (val) => {
   pageSize.value = val;
   relPage.value = 1;
   fetchRels();
 };
 
-// --- 数据抓取逻辑 ---
 const fetchAllMetadata = async () => {
-  // 获取全量节点标签
   getLabels().then(res => {
     if (res?.code === 200) dynamicLabels.value = res.data;
   });
-  // 获取全量关系类型
   getRelationshipTypes().then(res => {
     if (res?.code === 200) dynamicRelTypes.value = res.data;
   });
@@ -462,14 +522,12 @@ const fetchNodes = async () => {
   loading.value = true;
   try {
     const res = await getNodesList({
-      page: nodePage.value,
-      pageSize: pageSize.value,
-      name: nodeSearch.name?.trim() || null,
-      label: nodeSearch.label || null
+      page: nodePage.value, pageSize: pageSize.value,
+      name: nodeSearch.name?.trim() || null, label: nodeSearch.label || null
     });
     if (res?.code === 200) {
-      nodeData.value = res.data.items;
-      nodeTotal.value = res.data.total;
+      nodeData.value = res.data.items || res.data || [];
+      nodeTotal.value = res.count || res.data.total || 0;
     }
   } catch (e) {
     ElMessage.error('加载节点失败');
@@ -478,31 +536,52 @@ const fetchNodes = async () => {
   }
 };
 
+/**
+ * 关系列表解析逻辑
+ */
 const fetchRels = async () => {
   loading.value = true;
   try {
     const res = await getRelationshipsList({
-      page: relPage.value,
-      pageSize: pageSize.value,
-      source: relSearch.source?.trim() || null,
-      target: relSearch.target?.trim() || null,
-      type: relSearch.type || null // 此时 type 已经是英文
+      page: relPage.value, pageSize: pageSize.value,
+      source: relSearch.source?.trim() || null, target: relSearch.target?.trim() || null,
+      type: relSearch.type || null
     });
+
     if (res?.code === 200) {
-      relData.value = res.data.items;
-      relTotal.value = res.data.total;
+      const rawList = Array.isArray(res.data) ? res.data : (res.data.items || []);
+      relData.value = rawList.map(pathItem => {
+        const segment = (pathItem.segments && pathItem.segments.length > 0) ? pathItem.segments[0] : null;
+        const relObj = segment ? segment.relationship : null;
+
+        if (relObj) {
+          return {
+            id: relObj.elementId || relObj.identity,
+            elementId: relObj.elementId,
+            source: pathItem.start?.properties?.name || pathItem.start?.name || '未知',
+            target: pathItem.end?.properties?.name || pathItem.end?.name || '未知',
+            type: relObj.type,
+            label: relObj.properties?.label || relObj.label || relObj.type,
+            properties: relObj.properties || {}
+          };
+        }
+        return pathItem;
+      });
+      relTotal.value = res.count !== undefined ? res.count : (res.data.total || 0);
     }
   } catch (e) {
+    console.error("关系解析异常:", e);
     ElMessage.error('加载关系失败');
   } finally {
     loading.value = false;
   }
 };
 
+// 弹窗与提交
 const openNodeDialog = (row = null) => {
   isEdit.value = !!row;
   if (row) {
-    Object.assign(nodeForm, {id: row.id, name: row.name, label: row.labels?.[0] || ''});
+    Object.assign(nodeForm, {id: row.elementId || row.id, name: row.name, label: row.labels?.[0] || ''});
   } else {
     Object.assign(nodeForm, {id: '', name: '', label: ''});
   }
@@ -520,8 +599,8 @@ const submitNode = async () => {
       nodeDialogVisible.value = false;
       fetchNodes();
       fetchStats();
-      fetchAllMetadata(); // 刷新标签
-      preload();
+      fetchAllMetadata();
+      if (typeof preload === 'function') preload();
     } else {
       ElMessage.error(res?.msg || '操作失败');
     }
@@ -536,11 +615,11 @@ const openRelDialog = (row = null) => {
   isEdit.value = !!row;
   if (row) {
     Object.assign(relForm, {
-      id: row.id,
+      id: row.elementId || row.id,
       source: row.source,
       target: row.target,
       type: row.type,
-      label: row.label || ''
+      label: row.label || row.type
     });
   } else {
     Object.assign(relForm, {id: '', source: '', target: '', type: '', label: ''});
@@ -559,7 +638,7 @@ const submitRel = async () => {
       relDialogVisible.value = false;
       fetchRels();
       fetchStats();
-      fetchAllMetadata(); // 刷新关系类型列表
+      fetchAllMetadata();
     } else {
       ElMessage.error(res?.msg || '提交失败');
     }
@@ -572,14 +651,13 @@ const submitRel = async () => {
 
 const handleDelete = (row, type) => {
   ElMessageBox.confirm('确定要删除吗？', '提示', {
-    customClass: 'my-custom-btns', // 自定义类名
-    confirmButtonText: '确认',
-    cancelButtonText: '取消'
+    confirmButtonText: '确认', cancelButtonText: '取消', type: 'warning'
   }).then(async () => {
-    const res = type === 'node' ? await deleteNode(row.id) : await deleteRelationship(row.id);
+    const targetId = row.elementId || row.id;
+    const res = type === 'node' ? await deleteNode(targetId) : await deleteRelationship(targetId);
     if (res?.code === 200) {
       ElMessage.success('删除成功');
-      preload();
+      if (typeof preload === 'function') preload();
       type === 'node' ? fetchNodes() : fetchRels();
       fetchStats();
       fetchAllMetadata();
@@ -588,152 +666,584 @@ const handleDelete = (row, type) => {
   });
 };
 
-// 节点查询处理
+// 搜索建议逻辑
 const handleNodeSearch = () => {
   nodePage.value = 1;
   fetchNodes();
 };
-
-// 节点标签变更逻辑：切换标签时清空输入框，并刷新列表
 const handleNodeLabelChange = () => {
-  nodeSearch.name = ''; // 清空之前的输入值，让联想列表重新加载
+  nodeSearch.name = '';
   nodePage.value = 1;
   fetchNodes();
 };
-
 const handleRelSearch = () => {
   relPage.value = 1;
   fetchRels();
 };
 
-/**
- * 联想搜索建议逻辑修改：
- * 重点：将当前 nodeSearch.label 传给后端
- */
 const queryNodeSearch = async (queryString, cb) => {
-  // 条件拦截：没有标签 且 没有输入内容
-  if (!nodeSearch.label && !queryString?.trim()) {
-    return cb([]);
-  }
-
+  const currentLabel = activeName.value === 'first' ? nodeSearch.label : null;
+  if (!currentLabel && !queryString?.trim()) return cb([]);
   try {
-    // 【核心改动】：传递 nodeSearch.label 到后端接口
-    const res = await getNodeSuggestions(queryString || "", nodeSearch.label || null);
+    const res = await getNodeSuggestions(queryString || "", currentLabel);
     if (res?.code === 200) {
-      // 后端返回的是字符串数组，转成组件需要的对象数组格式
-      const results = (res.data || []).map(n => ({value: n}));
-      cb(results);
+      cb((res.data || []).map(n => ({value: n})));
     } else {
       cb([]);
     }
   } catch (e) {
-    console.error("联想查询失败", e);
     cb([]);
   }
 };
 
-const handleView = (row, type) => {
-  detailType.value = type;
-  currentDetail.value = {...row};
-  detailVisible.value = true;
+/**
+ * 导出功能 - 增加了二次确认弹窗
+ */
+const handleExport = async (type) => {
+  const typeText = type === 'node' ? '节点' : '关系';
+
+  // 1. 弹出确认框防止误触
+  ElMessageBox.confirm(
+      `确定要导出当前的${typeText}数据吗？若数据量较大可能需要一定处理时间。`,
+      '导出确认',
+      {
+        confirmButtonText: '立即导出',
+        cancelButtonText: '取消',
+        type: 'info',
+      }
+  ).then(async () => {
+    // 2. 用户点击确认后执行
+    const loadingInstance = ElLoading.service({
+      text: `正在导出${typeText}数据...`,
+      background: 'rgba(0, 0, 0, 0.7)'
+    });
+
+    try {
+      let res;
+      let fileName = '';
+      if (type === 'node') {
+        res = await exportNodes({
+          name: nodeSearch.name?.trim() || null,
+          label: nodeSearch.label || null
+        });
+        fileName = `KG_Nodes_${Date.now()}.json`;
+      } else {
+        res = await exportRelationships({
+          source: relSearch.source?.trim() || null,
+          target: relSearch.target?.trim() || null,
+          type: relSearch.type || null
+        });
+        fileName = `KG_Rels_${Date.now()}.json`;
+      }
+
+      if (res?.code === 200 && res.data) {
+        const blob = new Blob([JSON.stringify(res.data, null, 2)], {type: "application/json"});
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement("a");
+        link.href = url;
+        link.download = fileName;
+        document.body.appendChild(link); // 将链接添加到DOM
+        link.click();
+        document.body.removeChild(link); // 下载后移除
+        URL.revokeObjectURL(url);
+        ElMessage.success(`${typeText}导出完成`);
+      } else {
+        ElMessage.error(res?.msg || '导出失败');
+      }
+    } catch (error) {
+      console.error('导出异常:', error);
+      ElMessage.error('导出异常');
+    } finally {
+      loadingInstance.close();
+    }
+  }).catch(() => {
+    // 用户点击取消，不执行导出
+  });
+};
+
+// 批量导入逻辑
+const triggerImport = (type) => {
+  importType.value = type;
+  if (fileInput.value) fileInput.value.click();
+};
+
+const handleFileChange = async (e) => {
+  const file = e.target.files[0];
+  if (!file) return;
+  const reader = new FileReader();
+  reader.onload = async (event) => {
+    try {
+      const json = JSON.parse(event.target.result);
+      let dataList = [];
+      if (importType.value === 'node') {
+        dataList = Array.isArray(json) ? json : (json.nodes || []);
+      } else {
+        dataList = Array.isArray(json) ? json : (json.relationships || json.rels || []);
+      }
+
+      if (dataList.length === 0) return ElMessage.error("数据为空");
+      importRawData.value = dataList;
+      importDialogVisible.value = true;
+      importStep.value = 'checking';
+
+      const res = importType.value === 'node' ? await precheckNodes(dataList) : await precheckRelationships(dataList);
+      if (res?.code === 200) {
+        Object.assign(importReport, {
+          conflicts: res.data.conflicts || [],
+          invalid: res.data.invalid || [],
+          summary: res.data.summary || {total: dataList.length}
+        });
+        importStep.value = 'report';
+      } else {
+        ElMessage.error(res?.msg || "检查失败");
+        importDialogVisible.value = false;
+      }
+    } catch (err) {
+      ElMessage.error("文件解析失败");
+    } finally {
+      e.target.value = '';
+    }
+  };
+  reader.readAsText(file);
+};
+
+const startBatchImport = async () => {
+  if (importReport.summary.valid === 0) {
+    ElMessage.error("无有效数据可导入，请检查节点是否存在或数据格式。");
+    return;
+  }
+  importStep.value = 'uploading';
+  importProgress.value = 0;
+  const total = importRawData.value.length;
+  const chunkSize = 1000;
+  try {
+    for (let i = 0; i < total; i += chunkSize) {
+      const chunk = importRawData.value.slice(i, i + chunkSize);
+      const res = importType.value === 'node' ? await executeImportNodes(chunk, importMode.value) : await executeImportRelationships(chunk, importMode.value);
+      if (res?.code === 200) {
+        importProgress.value = Math.min(Math.round(((i + chunkSize) / total) * 100), 100);
+      } else {
+        throw new Error(res?.msg || "执行失败");
+      }
+    }
+    ElMessage.success(`导入成功`);
+    importDialogVisible.value = false;
+    fetchStats();
+    fetchAllMetadata();
+    if (typeof preload === 'function') preload();
+    activeName.value === 'first' ? fetchNodes() : fetchRels();
+  } catch (err) {
+    ElMessageBox.alert(`错误：${err.message}`);
+    importDialogVisible.value = false;
+  }
 };
 
 onMounted(() => {
   initDataGovernance();
   fetchStats();
   fetchNodes();
-  fetchAllMetadata(); // 初始化加载所有标签和关系类型
+  fetchAllMetadata();
 });
 </script>
 
 <style scoped>
-.knowledge-graph-data-container { background-color: #f4f7fa; display: flex; height: 100vh; width: 100vw; }
-.main-body { flex: 1; padding: 25px 40px;   overflow: auto;height: 100vh; }
-.page-header { display: flex; align-items: center; margin-bottom: 25px; }
-.header-decorator { width: 10px; height: 22px; background-color: #165dff; border-radius: 5px; margin-right: 10px; }
-.header-title { font-size: 22px; font-weight: bold; color: #165dff; margin: 0; }
-.stat-container { display: flex; gap: 5%; margin-bottom: 30px; }
-.custom-stat-card { flex: 1; max-width: 25%; height: 200px; background: #ffffff; border-radius: 40px; padding: 0 35px; box-shadow: 2px -1px 14px 9px #EBF1FF; border: 1px solid #ffffff; display: flex; align-items: center; transition: transform 0.3s ease; }
-.stat-inner { display: flex; flex-direction: column; align-items: flex-start; width: 100%; }
-.stat-label { color: #636364; font-size: 21px;  margin-bottom: 15px; }
-.stat-value { color: #165dff; font-size: 48px; font-weight: 800; margin-bottom: 15px; line-height: 1; }
-.stat-desc { color: #999; font-size: 14px; line-height: 1.4; }
-.data-content-wrapper { margin-top: 20px; display: flex; flex-direction: column; }
-.custom-folder-tabs { display: flex; padding-left: 40px; }
-.folder-tab-item { padding: 8px 20px; font-size: 12px; color: #86909c; cursor: pointer; background-color: #ecf2ff; border: 1px solid #dcdfe6; border-bottom: none; border-radius: 8px 8px 0 0; }
-.folder-tab-item.active { background-color: #f1f6ff !important; color: #2869ff; font-weight: bold; border: 2px solid #6896ff; border-bottom: 2px solid #ffffff; margin-bottom: -1px; z-index: 3; }
-.data-card-container { background: #ffffff; border-radius: 30px; padding: 20px 20px; box-shadow: 2px -1px 14px 4px #E1EAFF; border: 1px solid #eff4ff; position: relative; z-index: 4; }
-.filter-bar { display: flex; justify-content: flex-end; align-items: center; margin-bottom: 20px; }
-.filter-inputs { display: flex; gap: 35px; flex-wrap: nowrap;margin-right: 20px; }
-.input-group-inline { display: flex; align-items: center; gap: 12px; flex-shrink: 0; white-space: nowrap; }
-.filter-label-text { font-size: 14px; color: #165dff; font-weight: 600; flex-shrink: 0; }
-.search-input,.input-group-inline :deep(.el-input) { width: 200px !important;box-shadow: 0 0 0 2px #EBF0FF;border: none;border-radius: 5px; }
-.search-input, .search-select { width: 200px !important;box-shadow: 0 0 0 2px #EBF0FF;border: none;border-radius: 5px; }
-.input-group-inline :deep(.el-select__wrapper){
+.knowledge-graph-data-container {
+  background-color: #f4f7fa;
+  display: flex;
+  height: 100vh;
+  width: 100vw;
+}
+
+.main-body {
+  flex: 1;
+  padding: 25px 40px;
+  overflow: auto;
+  height: 100vh;
+}
+
+.page-header {
+  display: flex;
+  align-items: center;
+  margin-bottom: 25px;
+}
+
+.header-decorator {
+  width: 10px;
+  height: 22px;
+  background-color: #165dff;
+  border-radius: 5px;
+  margin-right: 10px;
+}
+
+.header-title {
+  font-size: 22px;
+  font-weight: bold;
+  color: #165dff;
+  margin: 0;
+}
+
+.stat-container {
+  display: flex;
+  gap: 5%;
+  margin-bottom: 30px;
+}
+
+.custom-stat-card {
+  flex: 1;
+  max-width: 25%;
+  height: 200px;
+  background: #ffffff;
+  border-radius: 40px;
+  padding: 0 35px;
+  box-shadow: 2px -1px 14px 9px #EBF1FF;
+  border: 1px solid #ffffff;
+  display: flex;
+  align-items: center;
+  transition: transform 0.3s ease;
+}
+
+.stat-inner {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  width: 100%;
+}
+
+.stat-label {
+  color: #636364;
+  font-size: 21px;
+  margin-bottom: 15px;
+}
+
+.stat-value {
+  color: #165dff;
+  font-size: 48px;
+  font-weight: 800;
+  margin-bottom: 15px;
+  line-height: 1;
+}
+
+.stat-desc {
+  color: #999;
+  font-size: 14px;
+  line-height: 1.4;
+}
+
+.data-content-wrapper {
+  margin-top: 20px;
+  display: flex;
+  flex-direction: column;
+}
+
+.custom-folder-tabs {
+  display: flex;
+  padding-left: 40px;
+}
+
+.folder-tab-item {
+  padding: 8px 20px;
+  font-size: 12px;
+  color: #86909c;
+  cursor: pointer;
+  background-color: #ecf2ff;
+  border: 1px solid #dcdfe6;
+  border-bottom: none;
+  border-radius: 8px 8px 0 0;
+}
+
+.folder-tab-item.active {
+  background-color: #f1f6ff !important;
+  color: #2869ff;
+  font-weight: bold;
+  border: 2px solid #6896ff;
+  border-bottom: 2px solid #ffffff;
+  margin-bottom: -1px;
+  z-index: 3;
+}
+
+.data-card-container {
+  background: #ffffff;
+  border-radius: 30px;
+  padding: 20px 20px;
+  box-shadow: 2px -1px 14px 4px #E1EAFF;
+  border: 1px solid #eff4ff;
+  position: relative;
+  z-index: 4;
+}
+
+.filter-bar {
+  display: flex;
+  justify-content: flex-end;
+  align-items: center;
+  margin-bottom: 20px;
+}
+
+.filter-inputs {
+  display: flex;
+  gap: 35px;
+  flex-wrap: nowrap;
+  margin-right: 20px;
+}
+
+.input-group-inline {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-shrink: 0;
+  white-space: nowrap;
+}
+
+.filter-label-text {
+  font-size: 14px;
+  color: #165dff;
+  font-weight: 600;
+  flex-shrink: 0;
+}
+
+.search-input, .input-group-inline :deep(.el-input) {
+  width: 200px !important;
+  box-shadow: 0 0 0 2px #EBF0FF;
+  border: none;
+  border-radius: 5px;
+}
+
+.search-input, .search-select {
+  width: 200px !important;
+  box-shadow: 0 0 0 2px #EBF0FF;
+  border: none;
+  border-radius: 5px;
+}
+
+.input-group-inline :deep(.el-select__wrapper) {
   box-shadow: none !important;
 }
-:deep(.input-group-inline .el-autocomplete .el-input__wrapper){
+
+:deep(.input-group-inline .el-autocomplete .el-input__wrapper) {
   box-shadow: none !important;
 }
-:deep(.label-select .el-autocomplete .el-input__wrapper.is-focus){
+
+:deep(.label-select .el-autocomplete .el-input__wrapper.is-focus) {
   box-shadow: none !important;
 }
-:deep(.label-select .el-autocomplete .el-input__wrapper:hover){
+
+:deep(.label-select .el-autocomplete .el-input__wrapper:hover) {
   box-shadow: none !important;
 }
-:deep(.el-form-item__content){box-shadow: 0 0 0 2px #EBF0FF;border: none;border-radius: 5px; }
-.label-select {box-shadow: 0 0 0 2px #EBF0FF;border: none;border-radius: 5px; }
-.btn-search-ref { background: #165dff !important; border-radius: 8px; height: 38px; }
-
-.btn-import { background: rgb(145, 204, 117) !important; border-radius: 8px; height: 38px;border: none }
-.btn-export { background: rgb(89, 209, 212) !important; border-radius: 8px; height: 38px;border: none }
-.btn-orange { background: #ffb142 !important; color: white !important; border-radius: 8px; height: 38px; border: none !important; }
-.table-compact { box-shadow: 0 4px 20px rgba(22, 93, 255, 0.08); overflow: hidden; }
-.ref-table :deep(.el-table__header) th { background-color: #e8f0ff !important; color: #2869ff; font-weight: 700; }
-.op-group { display: flex; gap: 8px; justify-content: center; }
-.ref-op-btn { border: none !important; color: white !important; padding: 6px 14px !important; border-radius: 8px !important; }
-.ref-op-btn.edit { background-color: #4379ff !important; }
-.ref-op-btn.delete { background-color: #ff6060 !important; }
-.ref-op-btn.view { background-color: #ffb142 !important; }
-.pagination-footer { margin-top: 20px; display: flex; justify-content: flex-end; }
-:deep(.bold-header) {  margin-right: 0 !important; display: flex !important; justify-content: flex-start !important; }
-:deep(.bold-header .el-dialog__title) { color: #303133 !important;font-weight: 900 !important;padding:5px;margin-bottom: 10px; font-size: 19px !important;}
-.custom-form :deep(.el-form-item__label) { color: #606266 !important;font-size: 16px !important; }
-.custom-form :deep(.el-input) {box-shadow: 0 0 0 2px #EBF0FF;border: none;border-radius: 5px;}
-.custom-form :deep(.el-select__wrapper){
+
+:deep(.el-form-item__content) {
+  box-shadow: 0 0 0 2px #EBF0FF;
+  border: none;
+  border-radius: 5px;
+}
+
+.label-select {
+  box-shadow: 0 0 0 2px #EBF0FF;
+  border: none;
+  border-radius: 5px;
+}
+
+.btn-search-ref {
+  background: #165dff !important;
+  border-radius: 8px;
+  height: 38px;
+}
+
+.btn-import {
+  background: rgb(145, 204, 117) !important;
+  border-radius: 8px;
+  height: 38px;
+  border: none
+}
+
+.btn-export {
+  background: rgb(89, 209, 212) !important;
+  border-radius: 8px;
+  height: 38px;
+  border: none
+}
+
+.btn-orange {
+  background: #ffb142 !important;
+  color: white !important;
+  border-radius: 8px;
+  height: 38px;
+  border: none !important;
+}
+
+.table-compact {
+  box-shadow: 0 4px 20px rgba(22, 93, 255, 0.08);
+  overflow: hidden;
+}
+
+.ref-table :deep(.el-table__header) th {
+  background-color: #e8f0ff !important;
+  color: #2869ff;
+  font-weight: 700;
+}
+
+.op-group {
+  display: flex;
+  gap: 8px;
+  justify-content: center;
+}
+
+.ref-op-btn {
+  border: none !important;
+  color: white !important;
+  padding: 6px 14px !important;
+  border-radius: 8px !important;
+}
+
+.ref-op-btn.edit {
+  background-color: #4379ff !important;
+}
+
+.ref-op-btn.delete {
+  background-color: #ff6060 !important;
+}
+
+.ref-op-btn.view {
+  background-color: #ffb142 !important;
+}
+
+.pagination-footer {
+  margin-top: 20px;
+  display: flex;
+  justify-content: flex-end;
+}
+
+:deep(.bold-header) {
+  margin-right: 0 !important;
+  display: flex !important;
+  justify-content: flex-start !important;
+}
+
+:deep(.bold-header .el-dialog__title) {
+  color: #303133 !important;
+  font-weight: 900 !important;
+  padding: 5px;
+  margin-bottom: 10px;
+  font-size: 19px !important;
+}
+
+.custom-form :deep(.el-form-item__label) {
+  color: #606266 !important;
+  font-size: 16px !important;
+}
+
+.custom-form :deep(.el-input) {
+  box-shadow: 0 0 0 2px #EBF0FF;
+  border: none;
+  border-radius: 5px;
+}
+
+.custom-form :deep(.el-select__wrapper) {
   box-shadow: none !important;
 }
-.custom-form :deep(.el-input__wrapper){
+
+.custom-form :deep(.el-input__wrapper) {
   box-shadow: none !important;
 }
-:deep(.custom-form .el-input__wrapper.is-focus){
+
+:deep(.custom-form .el-input__wrapper.is-focus) {
   box-shadow: none !important;
 }
-:deep(.custom-form .el-input__wrapper:hover){
+
+:deep(.custom-form .el-input__wrapper:hover) {
   box-shadow: none !important;
 }
-.dialog-footer-wrap { display: flex; justify-content: flex-end; gap: 15px;  }
-.btn-cancel { background-color: #e6e6e6 !important; border: none !important; color: #444 !important; padding: 18px 20px !important; font-weight: 500; }
-.btn-confirm { background-color: #165dff !important; border: none !important; padding: 18px 20px !important; font-weight: 500; }
-.animate-fade { animation: fadeIn 0.4s ease-out; }
-.pagination-custom-text{color: #86909c}
-:deep(.el-select__placeholder){color: #606266}
-:deep(.el-pagination__sizes .el-select__wrapper){box-shadow: 0 0 0 2px #EBF0FF;}
-:deep(.el-pagination.is-background .el-pager li.is-active){background-color: #165DFF;}
+
+.dialog-footer-wrap {
+  display: flex;
+  justify-content: flex-end;
+  gap: 15px;
+}
+
+.btn-cancel {
+  background-color: #e6e6e6 !important;
+  border: none !important;
+  color: #444 !important;
+  padding: 18px 20px !important;
+  font-weight: 500;
+}
+
+.btn-confirm {
+  background-color: #165dff !important;
+  border: none !important;
+  padding: 18px 20px !important;
+  font-weight: 500;
+}
+
+.animate-fade {
+  animation: fadeIn 0.4s ease-out;
+}
+
+.pagination-custom-text {
+  color: #86909c
+}
+
+:deep(.el-select__placeholder) {
+  color: #606266
+}
+
+:deep(.el-pagination__sizes .el-select__wrapper) {
+  box-shadow: 0 0 0 2px #EBF0FF;
+}
+
+:deep(.el-pagination.is-background .el-pager li.is-active) {
+  background-color: #165DFF;
+}
+
 :deep(.el-pager li.is-active) {
   color: #fff !important;
 }
-:deep(.el-dialog){border-radius: 7px}
 
-:deep(.el-input__inner) {color:#606266}
-:deep(.el-pagination .btn-next:hover){color: #165DFF !important;}
-:deep(.el-pagination .btn-prev:hover){color: #165DFF !important;}
-.pagination-footer :deep(.el-pagination .el-input__inner){box-shadow: 0 0 0 2px #EBF0FF;border-radius: 5px; }
-.pagination-footer :deep(.el-input__wrapper){  box-shadow: none !important;}
-@keyframes fadeIn { from { opacity: 0; transform: translateY(5px); } to { opacity: 1; transform: translateY(0); } }
+:deep(.el-dialog) {
+  border-radius: 7px
+}
+
+:deep(.el-input__inner) {
+  color: #606266
+}
+
+:deep(.el-pagination .btn-next:hover) {
+  color: #165DFF !important;
+}
+
+:deep(.el-pagination .btn-prev:hover) {
+  color: #165DFF !important;
+}
+
+:deep(.custom-dialog .el-dialog__footer) {
+  padding: 15px 25px 20px !important;
+}
+
+:deep(.custom-dialog .el-dialog__body) {
+  padding: 10px 25px 15px !important;
+}
+
+.pagination-footer :deep(.el-pagination .el-input__inner) {
+  box-shadow: 0 0 0 2px #EBF0FF;
+  border-radius: 5px;
+}
+
+.pagination-footer :deep(.el-input__wrapper) {
+  box-shadow: none !important;
+}
+
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(5px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
 </style>
 <style>
-.el-popper .el-select-dropdown__item.is-selected{
+.el-popper .el-select-dropdown__item.is-selected {
   color: #165DFF !important;
   font-weight: bold;
   color: #165dff;
@@ -810,8 +1320,20 @@ onMounted(() => {
   border-radius: 8px 8px 0 0;
 }
 
-.my-custom-btns .el-button:not(.el-button--primary){ background-color: #e6e6e6 !important; border: none !important; color: #444 !important; padding: 18px 20px !important; font-weight: 500; }
-.my-custom-btns .el-button--primary { background-color: #165dff !important; border: none !important; padding: 18px 20px !important; font-weight: 500; }
+.my-custom-btns .el-button:not(.el-button--primary) {
+  background-color: #e6e6e6 !important;
+  border: none !important;
+  color: #444 !important;
+  padding: 18px 20px !important;
+  font-weight: 500;
+}
+
+.my-custom-btns .el-button--primary {
+  background-color: #165dff !important;
+  border: none !important;
+  padding: 18px 20px !important;
+  font-weight: 500;
+}
 
 .data-card-container {
   background: #ffffff;