diff --git a/docs/latest/intro/knowledge-base.md b/docs/latest/intro/knowledge-base.md
index d0621ee5..995501fa 100644
--- a/docs/latest/intro/knowledge-base.md
+++ b/docs/latest/intro/knowledge-base.md
@@ -97,16 +97,32 @@ LIMIT $num
 
 ### 1. 以三元组形式导入
 
+系统支持通过网页导入 `jsonl` 格式的知识图谱数据，支持**简单三元组**和**带属性三元组**两种格式。
 
-系统支持通过网页导入 `jsonl` 格式的知识图谱数据：
+**简单格式（兼容旧版）**：
 
 ```jsonl
 {"h": "北京", "t": "中国", "r": "首都"}
 {"h": "上海", "t": "中国", "r": "直辖市"}
-{"h": "深圳", "t": "广东", "r": "省会"}
 ```
 
-**格式说明**，每行一个三元组，系统自动验证数据格式，并自动导入到 Neo4j 数据库，添加 `Upload`、`Entity`、`Relation` 标签，会自动处理重复的三元组。
+**扩展格式（支持属性）**：
+
+支持 `h`（头节点）、`t`（尾节点）和 `r`（关系）为对象结构，其中：
+- 节点对象必须包含 `name` 字段。
+- 关系对象必须包含 `type` 字段。
+- 其他字段将作为**属性**存储在 Neo4j 中。
+
+```jsonl
+{"h": {"name": "孙悟空", "title": "齐天大圣", "weapon": "如意金箍棒"}, "t": {"name": "唐僧", "species": "人"}, "r": {"type": "徒弟", "order": 1}}
+{"h": "猪八戒", "t": {"name": "唐僧"}, "r": {"type": "徒弟", "order": 2}}
+```
+
+**格式说明**：
+- 每行一个数据项。
+- 系统自动验证数据格式，并自动导入到 Neo4j 数据库。
+- 自动添加 `Upload`、`Entity` 标签（节点）和 `RELATION` 类型（关系）。
+- 自动处理重复实体和关系，并合并属性。
 
 Neo4j 访问信息可以参考 `docker-compose.yml` 中配置对应的环境变量来覆盖。
 
@@ -116,7 +132,9 @@ Neo4j 访问信息可以参考 `docker-compose.yml` 中配置对应的环境变
 - **连接地址**: bolt://localhost:7687
 
 ::: tip 测试数据
-可以使用 `test/data/A_Dream_of_Red_Mansions_tiny.jsonl` 文件进行测试导入。
+可以使用以下文件进行测试导入：
+- 简单格式：`test/data/A_Dream_of_Red_Mansions_tiny.jsonl`
+- 扩展属性格式：`test/data/complex_graph_test.jsonl`
 :::
 
 ### 2. 接入已有 Neo4j 实例
diff --git a/server/routers/graph_router.py b/server/routers/graph_router.py
index 3c024650..552e16fb 100644
--- a/server/routers/graph_router.py
+++ b/server/routers/graph_router.py
@@ -5,13 +5,213 @@ from fastapi import APIRouter, Body, Depends, HTTPException, Query
 from src.storage.db.models import User
 from server.utils.auth_middleware import get_admin_user
 from src import graph_base, knowledge_base
+from src.knowledge.adapters.factory import GraphAdapterFactory
+from src.knowledge.adapters.base import GraphAdapter
 from src.utils.logging_config import logger
 
 graph = APIRouter(prefix="/graph", tags=["graph"])
 
 
 # =============================================================================
-# === 子图查询分组 ===
+# === 统一图谱接口 (Unified Graph API) ===
+# =============================================================================
+
+
+async def _get_graph_adapter(db_id: str) -> GraphAdapter:
+    """
+    根据数据库ID获取对应的图谱适配器
+
+    Args:
+        db_id: 数据库ID
+
+    Returns:
+        GraphAdapter: 对应的图谱适配器实例
+    """
+    # 1. 检查是否是 LightRAG 数据库
+    if knowledge_base.is_lightrag_database(db_id):
+        rag_instance = await knowledge_base._get_lightrag_instance(db_id)
+        if not rag_instance:
+            raise HTTPException(status_code=404, detail=f"LightRAG database {db_id} not found or inaccessible")
+        return GraphAdapterFactory.create_adapter("lightrag", lightrag_instance=rag_instance)
+
+    # 2. 默认为 Upload/Neo4j 数据库 (假设 db_id 为 "neo4j" 或其他 Neo4j 数据库名)
+    # 这里我们假设非 LightRAG 的 ID 都是 Neo4j 的数据库名
+    # 如果未来有更多类型，需要更完善的 ID 区分机制 (例如前缀)
+    if not graph_base.is_running():
+        raise HTTPException(status_code=503, detail="Graph database service is not running")
+
+    return GraphAdapterFactory.create_adapter("upload", graph_db_instance=graph_base, config={"kgdb_name": db_id})
+
+
+@graph.get("/list")
+async def get_graphs(current_user: User = Depends(get_admin_user)):
+    """
+    获取所有可用的知识图谱列表
+
+    Returns:
+        包含所有图谱信息的列表 (包括 Neo4j 和 LightRAG)
+    """
+    try:
+        graphs = []
+
+        # 1. 获取默认 Neo4j 图谱信息
+        neo4j_info = graph_base.get_graph_info()
+        if neo4j_info:
+            graphs.append(
+                {
+                    "id": "neo4j",
+                    "name": "默认图谱",
+                    "type": "neo4j",
+                    "description": "Default graph database for uploaded documents",
+                    "status": neo4j_info.get("status", "unknown"),
+                    "created_at": neo4j_info.get("last_updated"),
+                    "node_count": neo4j_info.get("entity_count", 0),
+                    "edge_count": neo4j_info.get("relationship_count", 0),
+                }
+            )
+
+        # 2. 获取 LightRAG 数据库信息
+        lightrag_dbs = knowledge_base.get_lightrag_databases()
+        for db in lightrag_dbs:
+            graphs.append(
+                {
+                    "id": db.get("db_id"),
+                    "name": db.get("name"),
+                    "type": "lightrag",
+                    "description": db.get("description"),
+                    "status": "active",  # LightRAG DBs are usually active if listed
+                    "created_at": db.get("created_at"),
+                    "metadata": db,
+                }
+            )
+
+        return {"success": True, "data": graphs}
+
+    except Exception as e:
+        logger.error(f"Failed to list graphs: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Failed to list graphs: {str(e)}")
+
+
+@graph.get("/subgraph")
+async def get_subgraph(
+    db_id: str = Query(..., description="知识图谱ID"),
+    node_label: str = Query("*", description="节点标签或查询关键词"),
+    max_depth: int = Query(2, description="最大深度", ge=1, le=5),
+    max_nodes: int = Query(100, description="最大节点数", ge=1, le=1000),
+    current_user: User = Depends(get_admin_user),
+):
+    """
+    统一的子图查询接口
+
+    Args:
+        db_id: 图谱ID (LightRAG DB ID 或 "neo4j")
+        node_label: 查询关键词或标签
+        max_depth: 扩展深度
+        max_nodes: 返回最大节点数
+    """
+    try:
+        logger.info(f"Querying subgraph - db_id: {db_id}, label: {node_label}")
+
+        adapter = await _get_graph_adapter(db_id)
+
+        # 统一查询参数
+        # 对于 UploadGraphAdapter, kgdb_name 通常通过 kwargs 传递
+        # 对于 LightRAGGraphAdapter, max_depth/max_nodes 通过 kwargs 传递
+        result_data = await adapter.query_nodes(
+            keyword=node_label,
+            max_depth=max_depth,
+            max_nodes=max_nodes,
+            kgdb_name=db_id if not knowledge_base.is_lightrag_database(db_id) else "neo4j",
+        )
+
+        return {
+            "success": True,
+            "data": result_data,
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get subgraph: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Failed to get subgraph: {str(e)}")
+
+
+@graph.get("/labels")
+async def get_graph_labels(
+    db_id: str = Query(..., description="知识图谱ID"), current_user: User = Depends(get_admin_user)
+):
+    """
+    获取图谱的所有标签
+    """
+    try:
+        adapter = await _get_graph_adapter(db_id)
+        labels = await adapter.get_labels()
+        return {"success": True, "data": {"labels": labels}}
+
+    except Exception as e:
+        logger.error(f"Failed to get labels: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get labels: {str(e)}")
+
+
+@graph.get("/stats")
+async def get_graph_stats(
+    db_id: str = Query(..., description="知识图谱ID"), current_user: User = Depends(get_admin_user)
+):
+    """
+    获取图谱统计信息
+    """
+    try:
+        if knowledge_base.is_lightrag_database(db_id):
+            # 复用原有的 LightRAG 统计逻辑
+            # 这里暂时直接调用原有逻辑，理想情况下也应该封装进 Adapter
+            rag_instance = await knowledge_base._get_lightrag_instance(db_id)
+            if not rag_instance:
+                raise HTTPException(status_code=404, detail="Database not found")
+
+            knowledge_graph = await rag_instance.get_knowledge_graph(node_label="*", max_depth=1, max_nodes=10000)
+            entity_types = {}
+            for node in knowledge_graph.nodes:
+                entity_type = node.properties.get("entity_type", "unknown")
+                entity_types[entity_type] = entity_types.get(entity_type, 0) + 1
+
+            entity_types_list = [
+                {"type": k, "count": v} for k, v in sorted(entity_types.items(), key=lambda x: x[1], reverse=True)
+            ]
+
+            return {
+                "success": True,
+                "data": {
+                    "total_nodes": len(knowledge_graph.nodes),
+                    "total_edges": len(knowledge_graph.edges),
+                    "entity_types": entity_types_list,
+                },
+            }
+        else:
+            # Neo4j stats
+            info = graph_base.get_graph_info(graph_name=db_id)
+            if not info:
+                raise HTTPException(status_code=404, detail="Graph info not found")
+
+            return {
+                "success": True,
+                "data": {
+                    "total_nodes": info.get("entity_count", 0),
+                    "total_edges": info.get("relationship_count", 0),
+                    # Neo4j info currently returns 'labels' list, not counts per label.
+                    # Improving this would require updating GraphDatabase.get_graph_info
+                    "entity_types": [{"type": label, "count": "N/A"} for label in info.get("labels", [])],
+                },
+            }
+
+    except Exception as e:
+        logger.error(f"Failed to get stats: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get stats: {str(e)}")
+
+
+# =============================================================================
+# === 兼容性接口 (Deprecated/Compatibility) ===
 # =============================================================================
 
 
@@ -23,147 +223,36 @@ async def get_lightrag_subgraph(
     max_nodes: int = Query(100, description="最大节点数", ge=1, le=1000),
     current_user: User = Depends(get_admin_user),
 ):
-    """
-    使用 LightRAG 原生方法获取知识图谱子图
-
-    Args:
-        db_id: LightRAG 数据库实例ID
-        node_label: 节点标签，用于查找起始节点，使用 "*" 获取全图
-        max_depth: 子图的最大深度
-        max_nodes: 返回的最大节点数量
-
-    Returns:
-        包含节点和边的知识图谱数据
-    """
-    try:
-        logger.info(
-            f"获取子图数据 - db_id: {db_id}, node_label: {node_label}, max_depth: {max_depth}, max_nodes: {max_nodes}"
-        )
-
-        # 检查是否是 LightRAG 数据库
-        if not knowledge_base.is_lightrag_database(db_id):
-            raise HTTPException(
-                status_code=400, detail=f"数据库 {db_id} 不是 LightRAG 类型，图谱功能仅支持 LightRAG 知识库"
-            )
-
-        # 获取 LightRAG 实例
-        rag_instance = await knowledge_base._get_lightrag_instance(db_id)
-        if not rag_instance:
-            raise HTTPException(status_code=404, detail=f"LightRAG 数据库 {db_id} 不存在或无法访问")
-
-        # 使用 LightRAG 的原生 get_knowledge_graph 方法
-        knowledge_graph = await rag_instance.get_knowledge_graph(
-            node_label=node_label, max_depth=max_depth, max_nodes=max_nodes
-        )
-
-        # 将 LightRAG 的 KnowledgeGraph 格式转换为前端需要的格式
-        nodes = []
-        for node in knowledge_graph.nodes:
-            nodes.append(
-                {
-                    "id": node.id,
-                    "labels": node.labels,
-                    "entity_type": node.properties.get("entity_type", "unknown"),
-                    "properties": node.properties,
-                }
-            )
-
-        edges = []
-        for edge in knowledge_graph.edges:
-            edges.append(
-                {
-                    "id": edge.id,
-                    "source": edge.source,
-                    "target": edge.target,
-                    "type": edge.type,
-                    "properties": edge.properties,
-                }
-            )
-
-        result = {
-            "success": True,
-            "data": {
-                "nodes": nodes,
-                "edges": edges,
-                "is_truncated": knowledge_graph.is_truncated,
-                "total_nodes": len(nodes),
-                "total_edges": len(edges),
-            },
-        }
-
-        logger.info(f"成功获取子图 - 节点数: {len(nodes)}, 边数: {len(edges)}")
-        return result
-
-    except HTTPException:
-        # 重新抛出 HTTP 异常
-        raise
-    except Exception as e:
-        logger.error(f"获取子图数据失败: {e}")
-        logger.error(f"Traceback: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"获取子图数据失败: {str(e)}")
+    """(Deprecated) Use /graph/subgraph instead"""
+    return await get_subgraph(
+        db_id=db_id, node_label=node_label, max_depth=max_depth, max_nodes=max_nodes, current_user=current_user
+    )
 
 
 @graph.get("/lightrag/databases")
 async def get_lightrag_databases(current_user: User = Depends(get_admin_user)):
-    """
-    获取所有可用的 LightRAG 数据库
-
-    Returns:
-        可用的 LightRAG 数据库列表
-    """
+    """(Deprecated) Use /graph/list instead"""
     try:
         lightrag_databases = knowledge_base.get_lightrag_databases()
         return {"success": True, "data": {"databases": lightrag_databases}}
-
     except Exception as e:
-        logger.error(f"获取 LightRAG 数据库列表失败: {e}")
-        raise HTTPException(status_code=500, detail=f"获取 LightRAG 数据库列表失败: {str(e)}")
-
-
-# =============================================================================
-# === 节点管理分组 ===
-# =============================================================================
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @graph.get("/lightrag/labels")
 async def get_lightrag_labels(
     db_id: str = Query(..., description="数据库ID"), current_user: User = Depends(get_admin_user)
 ):
-    """
-    获取知识图谱中的所有标签
+    """(Deprecated) Use /graph/labels instead"""
+    return await get_graph_labels(db_id=db_id, current_user=current_user)
 
-    Args:
-        db_id: LightRAG 数据库实例ID
 
-    Returns:
-        图谱中所有可用的标签列表
-    """
-    try:
-        logger.info(f"获取图谱标签 - db_id: {db_id}")
-
-        # 检查是否是 LightRAG 数据库
-        if not knowledge_base.is_lightrag_database(db_id):
-            raise HTTPException(
-                status_code=400, detail=f"数据库 {db_id} 不是 LightRAG 类型，图谱功能仅支持 LightRAG 知识库"
-            )
-
-        # 获取 LightRAG 实例
-        rag_instance = await knowledge_base._get_lightrag_instance(db_id)
-        if not rag_instance:
-            raise HTTPException(status_code=404, detail=f"LightRAG 数据库 {db_id} 不存在或无法访问")
-
-        # 使用 LightRAG 的原生方法获取所有标签
-        labels = await rag_instance.get_graph_labels()
-
-        return {"success": True, "data": {"labels": labels}}
-
-    except HTTPException:
-        # 重新抛出 HTTP 异常
-        raise
-    except Exception as e:
-        logger.error(f"获取图谱标签失败: {e}")
-        logger.error(f"Traceback: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"获取图谱标签失败: {str(e)}")
+@graph.get("/lightrag/stats")
+async def get_lightrag_stats(
+    db_id: str = Query(..., description="数据库ID"), current_user: User = Depends(get_admin_user)
+):
+    """(Deprecated) Use /graph/stats instead"""
+    return await get_graph_stats(db_id=db_id, current_user=current_user)
 
 
 @graph.get("/neo4j/nodes")
@@ -172,110 +261,19 @@ async def get_neo4j_nodes(
     num: int = Query(100, description="节点数量", ge=1, le=1000),
     current_user: User = Depends(get_admin_user),
 ):
-    """
-    获取图谱节点样本数据
-    """
-    try:
-        logger.debug(f"Get graph nodes in {kgdb_name} with {num} nodes")
-
-        if not graph_base.is_running():
-            raise HTTPException(status_code=400, detail="图数据库未启动")
-
-        result = graph_base.get_sample_nodes(kgdb_name, num)
-
-        return {"success": True, "result": result, "message": "success"}
-
-    except Exception as e:
-        logger.error(f"获取图节点数据失败: {e}\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"获取图节点数据失败: {str(e)}")
+    """(Deprecated) Use /graph/subgraph instead"""
+    response = await get_subgraph(db_id=kgdb_name, node_label="*", max_nodes=num, current_user=current_user)
+    return {"success": True, "result": response["data"], "message": "success"}
 
 
 @graph.get("/neo4j/node")
 async def get_neo4j_node(
     entity_name: str = Query(..., description="实体名称"), current_user: User = Depends(get_admin_user)
 ):
-    """
-    根据实体名称查询图节点
-    """
-    try:
-        if not graph_base.is_running():
-            raise HTTPException(status_code=400, detail="图数据库未启动")
-
-        result = graph_base.query_node(keyword=entity_name)
-
-        return {"success": True, "result": result, "message": "success"}
-
-    except Exception as e:
-        logger.error(f"查询图节点失败: {e}\n{traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"查询图节点失败: {str(e)}")
-
-
-# =============================================================================
-# === 边管理分组 ===
-# =============================================================================
-
-# 可以在这里添加边相关的管理功能
-
-# =============================================================================
-# === 图谱分析分组 ===
-# =============================================================================
-
-
-@graph.get("/lightrag/stats")
-async def get_lightrag_stats(
-    db_id: str = Query(..., description="数据库ID"), current_user: User = Depends(get_admin_user)
-):
-    """
-    获取知识图谱统计信息
-    """
-    try:
-        logger.info(f"获取图谱统计信息 - db_id: {db_id}")
-
-        # 检查是否是 LightRAG 数据库
-        if not knowledge_base.is_lightrag_database(db_id):
-            raise HTTPException(
-                status_code=400, detail=f"数据库 {db_id} 不是 LightRAG 类型，图谱功能仅支持 LightRAG 知识库"
-            )
-
-        # 获取 LightRAG 实例
-        rag_instance = await knowledge_base._get_lightrag_instance(db_id)
-        if not rag_instance:
-            raise HTTPException(status_code=404, detail=f"LightRAG 数据库 {db_id} 不存在或无法访问")
-
-        # 通过获取全图来统计节点和边的数量
-        knowledge_graph = await rag_instance.get_knowledge_graph(
-            node_label="*",
-            max_depth=1,
-            max_nodes=10000,  # 设置较大值以获取完整统计
-        )
-
-        # 统计实体类型分布
-        entity_types = {}
-        for node in knowledge_graph.nodes:
-            entity_type = node.properties.get("entity_type", "unknown")
-            entity_types[entity_type] = entity_types.get(entity_type, 0) + 1
-
-        entity_types_list = [
-            {"type": k, "count": v} for k, v in sorted(entity_types.items(), key=lambda x: x[1], reverse=True)
-        ]
-
-        return {
-            "success": True,
-            "data": {
-                "total_nodes": len(knowledge_graph.nodes),
-                "total_edges": len(knowledge_graph.edges),
-                "entity_types": entity_types_list,
-                "is_truncated": knowledge_graph.is_truncated,
-            },
-        }
-
-    except HTTPException:
-        # 重新抛出 HTTP 异常
-        raise
-    except Exception as e:
-        logger.error(f"获取图谱统计信息失败: {e}")
-        logger.error(f"Traceback: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"获取图谱统计信息失败: {str(e)}")
+    """(Deprecated) Use /graph/subgraph instead"""
+    # neo4j/node uses query_nodes(keyword=entity_name)
+    response = await get_subgraph(db_id="neo4j", node_label=entity_name, current_user=current_user)
+    return {"success": True, "result": response["data"], "message": "success"}
 
 
 @graph.get("/neo4j/info")
@@ -298,10 +296,7 @@ async def index_neo4j_entities(data: dict = Body(default={}), current_user: User
         if not graph_base.is_running():
             raise HTTPException(status_code=400, detail="图数据库未启动")
 
-        # 获取参数或使用默认值
         kgdb_name = data.get("kgdb_name", "neo4j")
-
-        # 调用GraphDatabase的add_embedding_to_nodes方法
         count = graph_base.add_embedding_to_nodes(kgdb_name=kgdb_name)
 
         return {
diff --git a/src/agents/common/middlewares/dynamic_tool_middleware.py b/src/agents/common/middlewares/dynamic_tool_middleware.py
index acce5f4d..a8dc196b 100644
--- a/src/agents/common/middlewares/dynamic_tool_middleware.py
+++ b/src/agents/common/middlewares/dynamic_tool_middleware.py
@@ -60,7 +60,8 @@ class DynamicToolMiddleware(AgentMiddleware):
                     logger.warning(f"MCP server '{mcp}' not pre-loaded. Please add it to mcp_servers list.")
 
         logger.info(
-            f"Dynamic tool selection: {len(enabled_tools)} tools enabled: {[tool.name for tool in enabled_tools]}"
+            f"Dynamic tool selection: {len(enabled_tools)} tools enabled: {[tool.name for tool in enabled_tools]}, "
+            f"selected_tools: {selected_tools}, selected_mcps: {selected_mcps}"
         )
 
         # 更新 request 中的工具列表
diff --git a/src/agents/common/toolkits/mysql/tools.py b/src/agents/common/toolkits/mysql/tools.py
index 3a255806..69af8238 100644
--- a/src/agents/common/toolkits/mysql/tools.py
+++ b/src/agents/common/toolkits/mysql/tools.py
@@ -38,7 +38,9 @@ def get_connection_manager() -> MySQLConnectionManager:
         required_keys = ["host", "user", "password", "database"]
         for key in required_keys:
             if not mysql_config[key]:
-                raise MySQLConnectionError(f"MySQL configuration missing required key: {key}")
+                raise MySQLConnectionError(
+                    f"MySQL configuration missing required key: {key}, please check your environment variables."
+                )
 
         _connection_manager = MySQLConnectionManager(mysql_config)
     return _connection_manager
diff --git a/src/knowledge/adapters/__init__.py b/src/knowledge/adapters/__init__.py
new file mode 100644
index 00000000..027747fc
--- /dev/null
+++ b/src/knowledge/adapters/__init__.py
@@ -0,0 +1,6 @@
+from .base import GraphAdapter
+from .factory import GraphAdapterFactory
+from .lightrag import LightRAGGraphAdapter
+from .upload import UploadGraphAdapter
+
+__all__ = ["GraphAdapter", "UploadGraphAdapter", "LightRAGGraphAdapter", "GraphAdapterFactory"]
diff --git a/src/knowledge/adapters/base.py b/src/knowledge/adapters/base.py
new file mode 100644
index 00000000..a757c278
--- /dev/null
+++ b/src/knowledge/adapters/base.py
@@ -0,0 +1,87 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class GraphAdapter(ABC):
+    """图谱适配器基类 (Base Graph Adapter)"""
+
+    @abstractmethod
+    async def query_nodes(self, keyword: str, **kwargs) -> dict[str, Any]:
+        """查询节点 (Query nodes)"""
+        pass
+
+    @abstractmethod
+    async def add_entity(self, triples: list[dict], **kwargs) -> bool:
+        """添加实体三元组 (Add entity triples)"""
+        pass
+
+    @abstractmethod
+    async def get_sample_nodes(self, num: int = 50, **kwargs) -> dict[str, list]:
+        """获取样本节点 (Get sample nodes)"""
+        pass
+
+    @abstractmethod
+    def normalize_node(self, raw_node: Any) -> dict[str, Any]:
+        """标准化节点格式 (Normalize node format)"""
+        pass
+
+    @abstractmethod
+    def normalize_edge(self, raw_edge: Any) -> dict[str, Any]:
+        """标准化边格式 (Normalize edge format)"""
+        pass
+
+    @abstractmethod
+    async def get_labels(self) -> list[str]:
+        """获取所有标签 (Get all labels)"""
+        pass
+
+    def _create_standard_node(
+        self,
+        node_id: str,
+        name: str,
+        entity_type: str,
+        labels: list[str],
+        properties: dict[str, Any],
+        source: str,
+    ) -> dict[str, Any]:
+        """
+        Helper to create a standardized node dictionary.
+        """
+        return {
+            "id": node_id,
+            "name": name,
+            "original_id": node_id,
+            "type": entity_type,
+            "labels": labels,
+            "properties": properties,
+            "normalized": {
+                "name": name,
+                "type": entity_type,
+                "source": source,
+            },
+            "graph_type": source,
+        }
+
+    def _create_standard_edge(
+        self,
+        edge_id: str,
+        source_id: str,
+        target_id: str,
+        edge_type: str,
+        properties: dict[str, Any],
+        direction: str = "directed",
+    ) -> dict[str, Any]:
+        """
+        Helper to create a standardized edge dictionary.
+        """
+        return {
+            "id": edge_id,
+            "source_id": source_id,
+            "target_id": target_id,
+            "type": edge_type,
+            "properties": properties,
+            "normalized": {
+                "type": edge_type,
+                "direction": direction,
+            },
+        }
diff --git a/src/knowledge/adapters/factory.py b/src/knowledge/adapters/factory.py
new file mode 100644
index 00000000..66a23680
--- /dev/null
+++ b/src/knowledge/adapters/factory.py
@@ -0,0 +1,23 @@
+from .base import GraphAdapter
+from .lightrag import LightRAGGraphAdapter
+from .upload import UploadGraphAdapter
+
+
+class GraphAdapterFactory:
+    """图谱适配器工厂 (Graph Adapter Factory)"""
+
+    _registry: dict[str, type[GraphAdapter]] = {"upload": UploadGraphAdapter, "lightrag": LightRAGGraphAdapter}
+
+    @classmethod
+    def register(cls, graph_type: str, adapter_class: type[GraphAdapter]):
+        """注册适配器类 (Register adapter class)"""
+        cls._registry[graph_type] = adapter_class
+
+    @classmethod
+    def create_adapter(cls, graph_type: str, **kwargs) -> GraphAdapter:
+        """创建适配器实例 (Create adapter instance)"""
+        adapter_class = cls._registry.get(graph_type)
+        if not adapter_class:
+            raise ValueError(f"Unknown graph type: {graph_type}")
+
+        return adapter_class(**kwargs)
diff --git a/src/knowledge/adapters/lightrag.py b/src/knowledge/adapters/lightrag.py
new file mode 100644
index 00000000..1b130209
--- /dev/null
+++ b/src/knowledge/adapters/lightrag.py
@@ -0,0 +1,145 @@
+import logging
+from typing import Any
+
+from .base import GraphAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class LightRAGGraphAdapter(GraphAdapter):
+    """LightRAG图谱适配器 (LightRAG Graph Adapter)"""
+
+    def __init__(self, lightrag_instance: Any, config: dict[str, Any] = None):
+        self.config = config or {
+            "node_label_field": "labels",
+            "id_field": "id",
+            "type_field": "entity_type",
+            "relation_prefix": "HAS_",
+        }
+        self.lightrag = lightrag_instance
+
+    async def query_nodes(self, keyword: str, **kwargs) -> dict[str, Any]:
+        # Map keyword to node_label
+        # If keyword is empty or "*", query all (or sample)
+        node_label = keyword if keyword and keyword != "*" else "*"
+
+        max_depth = kwargs.get("max_depth", 2)
+        max_nodes = kwargs.get("max_nodes", 100)
+
+        # lightrag.get_knowledge_graph is async
+        # Note: if node_label is "*", LightRAG might return a large graph or sample depending on implementation
+        raw_graph = await self.lightrag.get_knowledge_graph(
+            node_label=node_label, max_depth=max_depth, max_nodes=max_nodes
+        )
+
+        return self._convert_lightrag_graph(raw_graph)
+
+    async def add_entity(self, triples: list[dict], **kwargs) -> bool:
+        """
+        LightRAG typically builds graph from text.
+        Direct triple injection might not be supported or requires different API.
+        """
+        logger.warning("add_entity is not fully supported for LightRAG adapter yet.")
+        return False
+
+    async def get_sample_nodes(self, num: int = 50, **kwargs) -> dict[str, list]:
+        # Use query_nodes with wildcard to get a subgraph
+        return await self.query_nodes("*", max_nodes=num, **kwargs)
+
+    def normalize_node(self, raw_node: Any) -> dict[str, Any]:
+        # Handle LightRAG Node object
+        node_id = getattr(raw_node, "id", None)
+        if node_id is None:
+            node_id = raw_node.get("id")
+
+        labels = getattr(raw_node, "labels", [])
+        if not labels and hasattr(raw_node, "get"):
+            labels = raw_node.get("labels", [])
+
+        properties = getattr(raw_node, "properties", {})
+        if not properties and hasattr(raw_node, "get"):
+            properties = raw_node.get("properties", {})
+
+        # 优先使用 entity_id 作为显示名称，因为 Neo4j 中 LightRAG 存储的实体名称在 entity_id 字段
+        # 如果不存在，则回退到 id
+        name = properties.get("entity_id", node_id)
+
+        # 尝试从 properties 获取 entity_type，或者从 labels 中推断（排除 kb_ 前缀的 label）
+        entity_type = properties.get("entity_type", "unknown")
+        if entity_type == "unknown" and labels:
+            for label in labels:
+                if not label.startswith("kb_"):
+                    entity_type = label
+                    break
+
+        return self._create_standard_node(
+            node_id=node_id, name=name, entity_type=entity_type, labels=labels, properties=properties, source="lightrag"
+        )
+
+    def normalize_edge(self, raw_edge: Any) -> dict[str, Any]:
+        # Handle LightRAG Edge object
+        edge_id = getattr(raw_edge, "id", None)
+        if edge_id is None:
+            edge_id = raw_edge.get("id")
+
+        source = getattr(raw_edge, "source", None)
+        if source is None:
+            source = raw_edge.get("source")
+
+        target = getattr(raw_edge, "target", None)
+        if target is None:
+            target = raw_edge.get("target")
+
+        edge_type = getattr(raw_edge, "type", None)
+        if edge_type is None:
+            edge_type = raw_edge.get("type")
+
+        properties = getattr(raw_edge, "properties", {})
+        if not properties and hasattr(raw_edge, "get"):
+            properties = raw_edge.get("properties", {})
+
+        # 优化边的显示类型
+        # LightRAG 的边类型通常是 "DIRECTED"，具体含义在 keywords 或 description 中
+        display_type = edge_type
+        if edge_type == "DIRECTED":
+            keywords = properties.get("keywords", [])
+            if keywords and isinstance(keywords, list) and len(keywords) > 0:
+                display_type = keywords[0]
+            elif properties.get("description"):
+                # 如果没有 keywords，尝试从 description 截取（太长就算了）
+                desc = properties.get("description", "")
+                if len(desc) < 20:
+                    display_type = desc
+                else:
+                    display_type = "related"  # fallback
+
+        return self._create_standard_edge(
+            edge_id=edge_id, source_id=source, target_id=target, edge_type=display_type, properties=properties
+        )
+
+    async def get_labels(self) -> list[str]:
+        return await self.lightrag.get_graph_labels()
+
+    def _convert_lightrag_graph(self, raw_graph) -> dict[str, Any]:
+        nodes = []
+        edges = []
+
+        # raw_graph has .nodes and .edges lists
+        if hasattr(raw_graph, "nodes"):
+            for node in raw_graph.nodes:
+                nodes.append(self.normalize_node(node))
+
+        if hasattr(raw_graph, "edges"):
+            for edge in raw_graph.edges:
+                edges.append(self.normalize_edge(edge))
+
+        result = {"nodes": nodes, "edges": edges}
+
+        # Add metadata if available
+        if hasattr(raw_graph, "is_truncated"):
+            result["is_truncated"] = raw_graph.is_truncated
+
+        result["total_nodes"] = len(nodes)
+        result["total_edges"] = len(edges)
+
+        return result
diff --git a/src/knowledge/adapters/upload.py b/src/knowledge/adapters/upload.py
new file mode 100644
index 00000000..3d4d3810
--- /dev/null
+++ b/src/knowledge/adapters/upload.py
@@ -0,0 +1,109 @@
+from typing import Any
+
+from src.knowledge.graph import GraphDatabase
+
+from .base import GraphAdapter
+
+
+class UploadGraphAdapter(GraphAdapter):
+    """Upload图谱适配器 (Upload Graph Adapter)"""
+
+    def __init__(self, graph_db_instance: GraphDatabase, config: dict[str, Any] = None):
+        self.config = config or {
+            "node_label": "Entity:Upload",
+            "id_field": "name",
+            "relation_label": "RELATION",
+            "default_tags": ["upload", "user_generated"],
+        }
+        self.graph_db = graph_db_instance
+
+    async def query_nodes(self, keyword: str, **kwargs) -> dict[str, Any]:
+        params = self._normalize_query_params(keyword, kwargs)
+
+        # 如果关键词是 "*" 或者为空，则执行采样查询
+        if not params["keyword"] or params["keyword"] == "*":
+            # 映射 max_nodes 到 num
+            num = kwargs.get("max_nodes", 100)
+            raw_results = self.graph_db.get_sample_nodes(kgdb_name=params.get("kgdb_name", "neo4j"), num=num)
+        else:
+            # 否则执行关键词搜索
+            # graph_db.query_node is sync
+            raw_results = self.graph_db.query_node(
+                keyword=params["keyword"],
+                threshold=params.get("threshold", 0.9),
+                kgdb_name=params.get("kgdb_name", "neo4j"),
+                hops=params.get("hops", 2),
+                return_format="graph",
+            )
+
+        return self._format_results(raw_results)
+
+    async def add_entity(self, triples: list[dict], **kwargs) -> bool:
+        kgdb_name = kwargs.get("kgdb_name", "neo4j")
+        # txt_add_vector_entity is async
+        await self.graph_db.txt_add_vector_entity(triples, kgdb_name=kgdb_name)
+        return True
+
+    async def get_sample_nodes(self, num: int = 50, **kwargs) -> dict[str, list]:
+        kgdb_name = kwargs.get("kgdb_name", "neo4j")
+        # get_sample_nodes is sync
+        raw_results = self.graph_db.get_sample_nodes(kgdb_name=kgdb_name, num=num)
+        return self._format_results(raw_results)
+
+    def normalize_node(self, raw_node: Any) -> dict[str, Any]:
+        """
+        raw_node expected format: {id: str, name: str, ...}
+        """
+        node_id = raw_node.get("id")
+        name = raw_node.get("name")
+
+        return self._create_standard_node(
+            node_id=node_id,
+            name=name,
+            entity_type="entity",
+            labels=["Entity", "Upload"],
+            properties=raw_node,
+            source="upload",
+        )
+
+    def normalize_edge(self, raw_edge: Any) -> dict[str, Any]:
+        """
+        raw_edge expected format: {type: str, source_id: str, target_id: str, ...}
+        """
+        # Generate an ID if not present (Upload graph edges might not have explicit ID in simple dict return)
+        edge_id = raw_edge.get("id")
+        if not edge_id:
+            edge_id = f"{raw_edge.get('source_id')}_{raw_edge.get('type')}_{raw_edge.get('target_id')}"
+
+        return self._create_standard_edge(
+            edge_id=edge_id,
+            source_id=raw_edge.get("source_id"),
+            target_id=raw_edge.get("target_id"),
+            edge_type=raw_edge.get("type"),
+            properties=raw_edge,
+        )
+
+    async def get_labels(self) -> list[str]:
+        kgdb_name = self.config.get("kgdb_name", "neo4j")
+        info = self.graph_db.get_graph_info(graph_name=kgdb_name)
+        return info.get("labels", []) if info else []
+
+    def _normalize_query_params(self, keyword: str, kwargs: dict) -> dict[str, Any]:
+        # Map max_depth to hops if present
+        hops = kwargs.get("hops")
+        if hops is None:
+            hops = kwargs.get("max_depth", 2)
+
+        return {
+            "keyword": keyword,
+            "threshold": kwargs.get("threshold", 0.9),
+            "kgdb_name": kwargs.get("kgdb_name", "neo4j"),
+            "hops": hops,
+            "filters": kwargs.get("filters", {}),
+            "context": kwargs.get("context", {}),
+        }
+
+    def _format_results(self, raw_results: dict[str, list]) -> dict[str, list]:
+        nodes = [self.normalize_node(n) for n in raw_results.get("nodes", [])]
+        edges = [self.normalize_edge(e) for e in raw_results.get("edges", [])]
+        return {"nodes": nodes, "edges": edges}
diff --git a/src/knowledge/graph.py b/src/knowledge/graph.py
index 1651f215..bfd325c1 100644
--- a/src/knowledge/graph.py
+++ b/src/knowledge/graph.py
@@ -64,6 +64,22 @@ class GraphDatabase:
         assert self.driver is not None, "Database is not connected"
         self.use_database(kgdb_name)
 
+        def _process_record_props(record):
+            """处理记录中的属性：扁平化 properties 并移除 embedding"""
+            if record is None:
+                return None
+
+            # 复制一份以避免修改原字典
+            data = dict(record)
+            props = data.pop("properties", {}) or {}
+
+            # 移除 embedding
+            if "embedding" in props:
+                del props["embedding"]
+
+            # 合并属性（优先保留原字典中的 id, name, type 等核心字段）
+            return {**props, **data}
+
         def query(tx, num):
             """Note: 使用连通性查询获取集中的节点子图"""
             # 首先尝试获取一个连通的子图
@@ -104,12 +120,18 @@ class GraphDatabase:
                 OPTIONAL MATCH (n)-[rel]-(m)
                 WHERE m IN final_nodes AND elementId(n) < elementId(m)
                 RETURN
-                    {id: elementId(n), name: n.name} AS h,
+                    {id: elementId(n), name: n.name, properties: properties(n)} AS h,
                     CASE WHEN rel IS NOT NULL THEN
-                        {type: rel.type, source_id: elementId(n), target_id: elementId(m)}
+                        {
+                            id: elementId(rel),
+                            type: rel.type,
+                            source_id: elementId(startNode(rel)),
+                            target_id: elementId(endNode(rel)),
+                            properties: properties(rel)
+                        }
                     ELSE null END AS r,
                     CASE WHEN m IS NOT NULL THEN
-                        {id: elementId(m), name: m.name}
+                        {id: elementId(m), name: m.name, properties: properties(m)}
                     ELSE null END AS t
                 """
 
@@ -119,7 +141,7 @@ class GraphDatabase:
                 node_ids = set()
 
                 for item in results:
-                    h_node = item["h"]
+                    h_node = _process_record_props(item["h"])
 
                     # 始终添加头节点
                     if h_node["id"] not in node_ids:
@@ -128,14 +150,15 @@ class GraphDatabase:
 
                     # 只有当边和尾节点都存在时才处理
                     if item["r"] is not None and item["t"] is not None:
-                        t_node = item["t"]
+                        t_node = _process_record_props(item["t"])
+                        r_edge = _process_record_props(item["r"])
 
                         # 避免重复添加尾节点
                         if t_node["id"] not in node_ids:
                             formatted_results["nodes"].append(t_node)
                             node_ids.add(t_node["id"])
 
-                        formatted_results["edges"].append(item["r"])
+                        formatted_results["edges"].append(r_edge)
 
                 # 如果连通查询返回的节点数不足，补充更多节点
                 if len(formatted_results["nodes"]) < num:
@@ -145,14 +168,14 @@ class GraphDatabase:
                     supplement_query = """
                     MATCH (n:Entity)
                     WHERE NOT elementId(n) IN $existing_ids
-                    RETURN {id: elementId(n), name: n.name} AS node
+                    RETURN {id: elementId(n), name: n.name, properties: properties(n)} AS node
                     LIMIT $count
                     """
 
                     supplement_results = tx.run(supplement_query, existing_ids=list(node_ids), count=remaining_count)
 
                     for item in supplement_results:
-                        node = item["node"]
+                        node = _process_record_props(item["node"])
                         formatted_results["nodes"].append(node)
                         node_ids.add(node["id"])
 
@@ -165,9 +188,15 @@ class GraphDatabase:
                 MATCH (n:Entity)-[r]-(m:Entity)
                 WHERE elementId(n) < elementId(m)
                 RETURN
-                    {id: elementId(n), name: n.name} AS h,
-                    {type: r.type, source_id: elementId(n), target_id: elementId(m)} AS r,
-                    {id: elementId(m), name: m.name} AS t
+                    {id: elementId(n), name: n.name, properties: properties(n)} AS h,
+                    {
+                        id: elementId(r),
+                        type: r.type,
+                        source_id: elementId(startNode(r)),
+                        target_id: elementId(endNode(r)),
+                        properties: properties(r)
+                    } AS r,
+                    {id: elementId(m), name: m.name, properties: properties(m)} AS t
                 LIMIT $num
                 """
                 results = tx.run(fallback_query, num=int(num))
@@ -175,8 +204,9 @@ class GraphDatabase:
                 node_ids = set()
 
                 for item in results:
-                    h_node = item["h"]
-                    t_node = item["t"]
+                    h_node = _process_record_props(item["h"])
+                    t_node = _process_record_props(item["t"])
+                    r_edge = _process_record_props(item["r"])
 
                     # 避免重复添加节点
                     if h_node["id"] not in node_ids:
@@ -186,7 +216,7 @@ class GraphDatabase:
                         formatted_results["nodes"].append(t_node)
                         node_ids.add(t_node["id"])
 
-                    formatted_results["edges"].append(item["r"])
+                    formatted_results["edges"].append(r_edge)
 
                 return formatted_results
 
@@ -230,18 +260,47 @@ class GraphDatabase:
                     return True
             return False
 
+        def _parse_node(node_data):
+            """解析节点数据，返回 (name, props)"""
+            if isinstance(node_data, dict):
+                props = node_data.copy()
+                name = props.pop("name", "")
+                return name, props
+            return str(node_data), {}
+
+        def _parse_relation(rel_data):
+            """解析关系数据，返回 (type, props)"""
+            if isinstance(rel_data, dict):
+                props = rel_data.copy()
+                rel_type = props.pop("type", "")
+                return rel_type, props
+            return str(rel_data), {}
+
         def _create_graph(tx, data):
             """添加一个三元组"""
             for entry in data:
+                h_name, h_props = _parse_node(entry.get("h"))
+                t_name, t_props = _parse_node(entry.get("t"))
+                r_type, r_props = _parse_relation(entry.get("r"))
+
+                if not h_name or not t_name or not r_type:
+                    continue
+
                 tx.run(
                     """
-                MERGE (h:Entity:Upload {name: $h})
-                MERGE (t:Entity:Upload {name: $t})
-                MERGE (h)-[r:RELATION {type: $r}]->(t)
+                MERGE (h:Entity:Upload {name: $h_name})
+                SET h += $h_props
+                MERGE (t:Entity:Upload {name: $t_name})
+                SET t += $t_props
+                MERGE (h)-[r:RELATION {type: $r_type}]->(t)
+                SET r += $r_props
                 """,
-                    h=entry["h"],
-                    t=entry["t"],
-                    r=entry["r"],
+                    h_name=h_name,
+                    h_props=h_props,
+                    t_name=t_name,
+                    t_props=t_props,
+                    r_type=r_type,
+                    r_props=r_props,
                 )
 
         def _create_vector_index(tx, dim):
@@ -263,6 +322,9 @@ class GraphDatabase:
             # 构建参数字典，将列表转换为"param0"、"param1"等键值对形式
             params = {f"param{i}": name for i, name in enumerate(entity_names)}
 
+            if not params:
+                return []
+
             # 构建查询参数列表
             param_placeholders = ", ".join([f"${key}" for key in params.keys()])
 
@@ -305,20 +367,24 @@ class GraphDatabase:
             session.execute_write(_create_vector_index, getattr(cur_embed_info, "dimension", 1024))
 
             # 收集所有需要处理的实体名称，去重
-            all_entities = []
+            all_entities = set()
             for entry in triples:
-                if entry["h"] not in all_entities:
-                    all_entities.append(entry["h"])
-                if entry["t"] not in all_entities:
-                    all_entities.append(entry["t"])
+                h_name, _ = _parse_node(entry.get("h"))
+                t_name, _ = _parse_node(entry.get("t"))
+                if h_name:
+                    all_entities.add(h_name)
+                if t_name:
+                    all_entities.add(t_name)
+
+            all_entities_list = list(all_entities)
 
             # 筛选出没有embedding的节点
-            nodes_without_embedding = session.execute_read(_get_nodes_without_embedding, all_entities)
+            nodes_without_embedding = session.execute_read(_get_nodes_without_embedding, all_entities_list)
             if not nodes_without_embedding:
                 logger.info("所有实体已有embedding，无需重新计算")
                 return
 
-            logger.info(f"需要为{len(nodes_without_embedding)}/{len(all_entities)}个实体计算embedding")
+            logger.info(f"需要为{len(nodes_without_embedding)}/{len(all_entities_list)}个实体计算embedding")
 
             # 批量处理实体
             max_batch_size = 1024  # 限制此部分的主要是内存大小 1024 * 1024 * 4 / 1024 / 1024 = 4GB
@@ -587,30 +653,70 @@ class GraphDatabase:
 
         self.use_database(kgdb_name)
 
+        def _process_record_props(record):
+            """处理记录中的属性：扁平化 properties 并移除 embedding"""
+            if record is None:
+                return None
+
+            # 复制一份以避免修改原字典
+            data = dict(record)
+            props = data.pop("properties", {}) or {}
+
+            # 移除 embedding
+            if "embedding" in props:
+                del props["embedding"]
+
+            # 合并属性（优先保留原字典中的 id, name, type 等核心字段）
+            return {**props, **data}
+
         def query(tx, entity_name, hops, limit):
             try:
                 query_str = """
                 WITH [
                     // 1跳出边
                     [(n {name: $entity_name})-[r1]->(m1) |
-                     {h: {id: elementId(n), name: n.name},
-                      r: {type: r1.type, source_id: elementId(n), target_id: elementId(m1)},
-                      t: {id: elementId(m1), name: m1.name}}],
+                     {h: {id: elementId(n), name: n.name, properties: properties(n)},
+                      r: {
+                        id: elementId(r1),
+                        type: r1.type,
+                        source_id: elementId(n),
+                        target_id: elementId(m1),
+                        properties: properties(r1)
+                      },
+                      t: {id: elementId(m1), name: m1.name, properties: properties(m1)}}],
                     // 2跳出边
                     [(n {name: $entity_name})-[r1]->(m1)-[r2]->(m2) |
-                     {h: {id: elementId(m1), name: m1.name},
-                      r: {type: r2.type, source_id: elementId(m1), target_id: elementId(m2)},
-                      t: {id: elementId(m2), name: m2.name}}],
+                     {h: {id: elementId(m1), name: m1.name, properties: properties(m1)},
+                      r: {
+                        id: elementId(r2),
+                        type: r2.type,
+                        source_id: elementId(m1),
+                        target_id: elementId(m2),
+                        properties: properties(r2)
+                      },
+                      t: {id: elementId(m2), name: m2.name, properties: properties(m2)}}],
                     // 1跳入边
                     [(m1)-[r1]->(n {name: $entity_name}) |
-                     {h: {id: elementId(m1), name: m1.name},
-                      r: {type: r1.type, source_id: elementId(m1), target_id: elementId(n)},
-                      t: {id: elementId(n), name: n.name}}],
+                     {h: {id: elementId(m1), name: m1.name, properties: properties(m1)},
+                      r: {
+                        id: elementId(r1),
+                        type: r1.type,
+                        source_id: elementId(m1),
+                        target_id: elementId(n),
+                        properties: properties(r1)
+                      },
+                      t: {id: elementId(n), name: n.name, properties: properties(n)}}],
                     // 2跳入边
                     [(m2)-[r2]->(m1)-[r1]->(n {name: $entity_name}) |
-                     {h: {id: elementId(m2), name: m2.name},
-                      r: {type: r2.type, source_id: elementId(m2), target_id: elementId(m1)},
-                      t: {id: elementId(m1), name: m1.name}}]
+                     {h: {id: elementId(m2), name: m2.name, properties: properties(m2)},
+                      r: {
+                        id: elementId(r2),
+                        type: r2.type,
+                        source_id: elementId(m2),
+                        target_id: elementId(m1),
+                        properties: properties(r2)
+                      },
+                      t: {id: elementId(m1), name: m1.name, properties: properties(m1)}}]
                 ] AS all_results
                 UNWIND all_results AS result_list
                 UNWIND result_list AS item
@@ -626,9 +732,13 @@ class GraphDatabase:
                 formatted_results = {"nodes": [], "edges": [], "triples": []}
 
                 for item in results:
-                    formatted_results["nodes"].extend([item["h"], item["t"]])
-                    formatted_results["edges"].append(item["r"])
-                    formatted_results["triples"].append((item["h"]["name"], item["r"]["type"], item["t"]["name"]))
+                    h = _process_record_props(item["h"])
+                    r = _process_record_props(item["r"])
+                    t = _process_record_props(item["t"])
+
+                    formatted_results["nodes"].extend([h, t])
+                    formatted_results["edges"].append(r)
+                    formatted_results["triples"].append((h["name"], r["type"], t["name"]))
 
                 logger.debug(f"Query Results: {results}")
                 return formatted_results
diff --git a/src/knowledge/implementations/lightrag.py b/src/knowledge/implementations/lightrag.py
index 08feed01..d62d1f44 100644
--- a/src/knowledge/implementations/lightrag.py
+++ b/src/knowledge/implementations/lightrag.py
@@ -200,6 +200,7 @@ class LightRagKB(KnowledgeBase):
     def _get_embedding_func(self, embed_info: dict):
         """获取 embedding 函数"""
         config_dict = get_embedding_config(embed_info)
+        logger.debug(f"Embedding config dict: {config_dict}")
 
         if config_dict.get("model_id") and config_dict["model_id"].startswith("ollama"):
             from lightrag.llm.ollama import ollama_embed
@@ -219,12 +220,19 @@ class LightRagKB(KnowledgeBase):
                 ),
             )
 
+        # 尝试获取模型名称，支持多种键名以保持兼容性
+        if "name" in config_dict and config_dict["name"]:
+            model_name = config_dict["name"]
+        elif "model" in config_dict and config_dict["model"]:
+            model_name = config_dict["model"]
+        else:
+            raise ValueError(f"Neither 'name' nor 'model' found in config_dict or both are empty: {config_dict}")
         return EmbeddingFunc(
             embedding_dim=config_dict["dimension"],
             max_token_size=8192,
             func=lambda texts: openai_embed(
                 texts=texts,
-                model=config_dict["model"],
+                model=model_name,
                 api_key=config_dict["api_key"],
                 base_url=config_dict["base_url"].replace("/embeddings", ""),
             ),
diff --git a/src/knowledge/utils/kb_utils.py b/src/knowledge/utils/kb_utils.py
index ac9411ed..75dbec58 100644
--- a/src/knowledge/utils/kb_utils.py
+++ b/src/knowledge/utils/kb_utils.py
@@ -289,30 +289,52 @@ def get_embedding_config(embed_info: dict) -> dict:
     Returns:
         dict: 标准化的嵌入配置
     """
-    config_dict = {}
-
     try:
-        if embed_info:
-            # 优先检查是否有 model_id 字段
-            if "model_id" in embed_info:
-                return config.embed_model_names[embed_info["model_id"]].model_dump()
-            elif hasattr(embed_info, "name") and isinstance(embed_info, EmbedModelInfo):
-                return embed_info.model_dump()
-            else:
-                # 字典形式（保持向后兼容）
-                config_dict["model"] = embed_info["name"]
-                config_dict["api_key"] = os.getenv(embed_info["api_key"]) or embed_info["api_key"]
-                config_dict["base_url"] = embed_info["base_url"]
-                config_dict["dimension"] = embed_info.get("dimension", 1024)
-        else:
-            return config.embed_model_names[config.embed_model].model_dump()
+        # 检查 embed_info 是否有效
+        if not embed_info or ("model" not in embed_info and "name" not in embed_info):
+            logger.error(f"Invalid embed_info: {embed_info}, using default embedding model config")
+            raise ValueError("Invalid embed_info: must be a non-empty dictionary")
+
+        # 优先检查是否有 model_id 字段
+        if "model_id" in embed_info and embed_info["model_id"]:
+            logger.warning(f"Using model_id: {embed_info['model_id']}")
+            config_dict = config.embed_model_names[embed_info["model_id"]].model_dump()
+            config_dict["api_key"] = os.getenv(config_dict["api_key"]) or config_dict["api_key"]
+            return config_dict
+
+        # 检查是否是 EmbedModelInfo 对象（在某些情况下可能直接传入对象）
+        if hasattr(embed_info, "name") and isinstance(embed_info, EmbedModelInfo):
+            logger.debug(f"Using EmbedModelInfo object: {embed_info.name}")
+            config_dict = embed_info.model_dump()
+            config_dict["api_key"] = os.getenv(config_dict["api_key"]) or config_dict["api_key"]
+            return config_dict
+
+        # 字典形式（保持向后兼容）
+        # 检查必需字段是否存在
+        if not embed_info.get("name") or not embed_info.get("base_url"):
+            logger.warning(f"embed_info missing required 'name' or 'base_url' field: {embed_info}, using default")
+            raise ValueError("embed_info missing required 'name' or 'base_url' field")
+
+        config_dict = {
+            "model": embed_info["name"],
+            "api_key": os.getenv(embed_info["api_key"]) or embed_info["api_key"],
+            "base_url": embed_info["base_url"],
+            "dimension": embed_info.get("dimension", 1024),
+        }
+        logger.debug(f"Embedding config from dict: {config_dict}")
+        return config_dict
 
     except Exception as e:
-        logger.error(f"Error in get_embedding_config: {e}, {embed_info}")
-        raise ValueError(f"Error in get_embedding_config: {e}")
-
-    logger.debug(f"Embedding config: {config_dict}")
-    return config_dict
+        logger.error(f"Error in get_embedding_config: {e}, embed_info={embed_info}")
+        # 返回默认配置作为fallback
+        logger.warning("Falling back to default embedding model config")
+        try:
+            config_dict = config.embed_model_names[config.embed_model].model_dump()
+            config_dict["api_key"] = os.getenv(config_dict["api_key"]) or config_dict["api_key"]
+            return config_dict
+        except Exception as fallback_error:
+            logger.error(f"Failed to get default embedding config: {fallback_error}")
+            raise ValueError(f"Failed to get embedding config and fallback failed: {e}")
 
 
 def is_minio_url(file_path: str) -> bool:
diff --git a/test/api/test_unified_graph_router.py b/test/api/test_unified_graph_router.py
new file mode 100644
index 00000000..632b1b7f
--- /dev/null
+++ b/test/api/test_unified_graph_router.py
@@ -0,0 +1,118 @@
+"""
+Integration tests for the unified graph router endpoints.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytestmark = [pytest.mark.asyncio, pytest.mark.integration]
+
+
+async def test_get_graphs_list(test_client, admin_headers):
+    """Test retrieving the list of all graphs."""
+    response = await test_client.get("/api/graph/list", headers=admin_headers)
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["success"] is True
+    graphs = payload["data"]
+    assert isinstance(graphs, list)
+
+    # Check for Neo4j default graph
+    neo4j_graph = next((g for g in graphs if g["id"] == "neo4j"), None)
+    assert neo4j_graph is not None
+    assert neo4j_graph["type"] == "neo4j"
+
+    # Note: LightRAG graphs might be empty if none created, but we check structure
+
+
+async def test_get_subgraph_neo4j(test_client, admin_headers):
+    """Test unified subgraph query for Neo4j."""
+    # Query with a wildcard or a known node. Using "*" to get a sample.
+    response = await test_client.get(
+        "/api/graph/subgraph", params={"db_id": "neo4j", "node_label": "*", "max_nodes": 10}, headers=admin_headers
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["success"] is True
+    data = payload["data"]
+    assert "nodes" in data
+    assert "edges" in data
+    assert isinstance(data["nodes"], list)
+
+
+async def test_get_subgraph_lightrag(test_client, admin_headers, knowledge_database):
+    """Test unified subgraph query for LightRAG."""
+    db_id = knowledge_database["db_id"]
+    response = await test_client.get(
+        "/api/graph/subgraph", params={"db_id": db_id, "node_label": "*", "max_nodes": 10}, headers=admin_headers
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["success"] is True
+    data = payload["data"]
+    assert "nodes" in data
+    assert "edges" in data
+
+
+async def test_get_stats_neo4j(test_client, admin_headers):
+    """Test stats endpoint for Neo4j."""
+    response = await test_client.get("/api/graph/stats", params={"db_id": "neo4j"}, headers=admin_headers)
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["success"] is True
+    data = payload["data"]
+    assert "total_nodes" in data
+    assert "total_edges" in data
+    assert "entity_types" in data
+
+
+async def test_get_stats_lightrag(test_client, admin_headers, knowledge_database):
+    """Test stats endpoint for LightRAG."""
+    db_id = knowledge_database["db_id"]
+    response = await test_client.get("/api/graph/stats", params={"db_id": db_id}, headers=admin_headers)
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["success"] is True
+    data = payload["data"]
+    assert "total_nodes" in data
+    assert "total_edges" in data
+    assert "entity_types" in data
+
+
+async def test_get_labels_neo4j(test_client, admin_headers):
+    """Test labels endpoint for Neo4j."""
+    response = await test_client.get("/api/graph/labels", params={"db_id": "neo4j"}, headers=admin_headers)
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["success"] is True
+    data = payload["data"]
+    assert "labels" in data
+    assert isinstance(data["labels"], list)
+
+
+async def test_deprecated_neo4j_endpoints(test_client, admin_headers):
+    """Verify deprecated endpoints still work and return correct structure."""
+
+    # /neo4j/nodes
+    response = await test_client.get(
+        "/api/graph/neo4j/nodes", params={"kgdb_name": "neo4j", "num": 5}, headers=admin_headers
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    # Check compatibility structure
+    assert payload["success"] is True
+    assert "result" in payload
+    assert payload["message"] == "success"
+    assert "nodes" in payload["result"]
+
+    # /neo4j/node
+    # This might return empty if "NonExistentEntity" doesn't exist, but structure should be valid
+    response = await test_client.get(
+        "/api/graph/neo4j/node", params={"entity_name": "NonExistentEntity"}, headers=admin_headers
+    )
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["success"] is True
+    assert "result" in payload
+    assert payload["message"] == "success"
diff --git a/test/data/complex_graph_test.jsonl b/test/data/complex_graph_test.jsonl
new file mode 100644
index 00000000..d36b0de9
--- /dev/null
+++ b/test/data/complex_graph_test.jsonl
@@ -0,0 +1,6 @@
+{"h": {"name": "孙悟空", "title": "齐天大圣", "weapon": "如意金箍棒", "species": "猴"}, "t": {"name": "唐僧", "title": "旃檀功德佛", "species": "人"}, "r": {"type": "徒弟", "order": 1}}
+{"h": {"name": "猪八戒", "title": "天蓬元帅", "weapon": "九齿钉耙", "species": "猪"}, "t": {"name": "唐僧"}, "r": {"type": "徒弟", "order": 2}}
+{"h": {"name": "沙悟净", "title": "卷帘大将", "weapon": "降妖宝杖"}, "t": {"name": "唐僧"}, "r": {"type": "徒弟", "order": 3}}
+{"h": {"name": "白龙马", "origin": "西海龙宫"}, "t": {"name": "唐僧"}, "r": {"type": "坐骑", "original_form": "龙"}}
+{"h": "孙悟空", "t": {"name": "猪八戒"}, "r": {"type": "师兄弟", "relationship": "conflict/cooperate"}}
+{"h": {"name": "如来佛祖", "location": "西天雷音寺"}, "t": {"name": "孙悟空"}, "r": {"type": "压制", "tool": "五指山", "duration": "500年"}}
\ No newline at end of file
diff --git a/test/test_graph_unit.py b/test/test_graph_unit.py
new file mode 100644
index 00000000..4c1b9d89
--- /dev/null
+++ b/test/test_graph_unit.py
@@ -0,0 +1,96 @@
+import pytest
+from unittest.mock import MagicMock, patch
+import os
+import sys
+
+# Add project root to path
+sys.path.append(os.getcwd())
+
+from src.knowledge.graph import GraphDatabase
+
+
+@pytest.mark.asyncio
+async def test_txt_add_vector_entity_parsing():
+    # Mock driver and session
+    mock_driver = MagicMock()
+    mock_session = MagicMock()
+    mock_driver.session.return_value.__enter__.return_value = mock_session
+
+    # Setup mock transaction
+    mock_tx = MagicMock()
+
+    def side_effect_execute_write(func, *args, **kwargs):
+        return func(mock_tx, *args, **kwargs)
+
+    # Mock execute_read to return empty list (no missing embeddings for this test)
+    # The code calls _get_nodes_without_embedding which returns [record['name']]
+    # If we return [], it means all nodes have embeddings or none found.
+    # Actually, the code checks:
+    # nodes_without_embedding = session.execute_read(_get_nodes_without_embedding, all_entities)
+    # Let's mock it to return empty list so we skip embedding generation loop which simplifies test
+    mock_session.execute_read.return_value = []
+
+    mock_session.execute_write.side_effect = side_effect_execute_write
+
+    # Mock embedding model
+    with patch("src.knowledge.graph.select_embedding_model") as mock_select_model:
+        mock_embed_model = MagicMock()
+        mock_select_model.return_value = mock_embed_model
+
+        # Instantiate GraphDatabase with mocked driver
+        # We also need to patch GD.driver in the init
+        with patch("src.knowledge.graph.GD.driver", return_value=mock_driver):
+            gd = GraphDatabase()
+            # Manually set driver and status just in case init didn't work as expected due to other mocks
+            gd.driver = mock_driver
+            gd.status = "open"
+            gd.embed_model_name = "test_model"  # avoid config check issues if possible
+
+            # Mock config to match
+            with patch("src.knowledge.graph.config.embed_model", "test_model"):
+                with patch("src.knowledge.graph.config.embed_model_names", {"test_model": MagicMock(dimension=1024)}):
+                    # Test data: Mixed format
+                    triples = [
+                        # Legacy format
+                        {"h": "A", "r": "KNOWS", "t": "B"},
+                        # Extended format
+                        {
+                            "h": {"name": "C", "age": 30},
+                            "r": {"type": "LIKES", "weight": 0.8},
+                            "t": {"name": "D", "role": "User"},
+                        },
+                    ]
+
+                    # Run the method
+                    await gd.txt_add_vector_entity(triples)
+
+                    # Verify calls to mock_tx.run
+                    merge_calls = []
+                    for call in mock_tx.run.call_args_list:
+                        args, kwargs = call
+                        query = args[0] if args else kwargs.get("query", "")
+                        if "MERGE (h:Entity:Upload" in query:
+                            # The args are passed as kwargs to run: h_name=..., etc.
+                            merge_calls.append(kwargs)
+
+                    assert len(merge_calls) == 2, f"Expected 2 merge calls, got {len(merge_calls)}"
+
+                    # Call 1 (Legacy)
+                    call1 = merge_calls[0]
+                    assert call1["h_name"] == "A"
+                    assert call1["h_props"] == {}
+                    assert call1["t_name"] == "B"
+                    assert call1["t_props"] == {}
+                    assert call1["r_type"] == "KNOWS"
+                    assert call1["r_props"] == {}
+
+                    # Call 2 (Extended)
+                    call2 = merge_calls[1]
+                    assert call2["h_name"] == "C"
+                    assert call2["h_props"] == {"age": 30}
+                    assert call2["t_name"] == "D"
+                    assert call2["t_props"] == {"role": "User"}
+                    assert call2["r_type"] == "LIKES"
+                    assert call2["r_props"] == {"weight": 0.8}
+
+                    print("Verification passed!")
diff --git a/web/src/apis/graph_api.js b/web/src/apis/graph_api.js
index aed00c9a..be5b67d1 100644
--- a/web/src/apis/graph_api.js
+++ b/web/src/apis/graph_api.js
@@ -7,15 +7,23 @@ import { apiGet, apiPost } from './base'
  */
 
 // =============================================================================
-// === LightRAG图知识库接口分组 ===
+// === 统一图谱接口 (Unified Graph API) ===
 // =============================================================================
 
-export const lightragApi = {
+export const unifiedApi = {
   /**
-   * 获取LightRAG知识图谱子图数据
+   * 获取所有可用的知识图谱列表
+   * @returns {Promise} - 图谱列表
+   */
+  getGraphs: async () => {
+    return await apiGet('/api/graph/list', {}, true)
+  },
+
+  /**
+   * 获取子图数据 (统一接口)
    * @param {Object} params - 查询参数
-   * @param {string} params.db_id - LightRAG数据库ID
-   * @param {string} params.node_label - 节点标签（"*"获取全图）
+   * @param {string} params.db_id - 图谱ID
+   * @param {string} params.node_label - 节点标签/关键词
    * @param {number} params.max_depth - 最大深度
    * @param {number} params.max_nodes - 最大节点数
    * @returns {Promise} - 子图数据
@@ -34,37 +42,12 @@ export const lightragApi = {
       max_nodes: max_nodes.toString()
     })
 
-    return await apiGet(`/api/graph/lightrag/subgraph?${queryParams.toString()}`, {}, true)
+    return await apiGet(`/api/graph/subgraph?${queryParams.toString()}`, {}, true)
   },
 
   /**
-   * 获取所有可用的LightRAG数据库
-   * @returns {Promise} - LightRAG数据库列表
-   */
-  getDatabases: async () => {
-    return await apiGet('/api/graph/lightrag/databases', {}, true)
-  },
-
-  /**
-   * 获取LightRAG图谱标签列表
-   * @param {string} db_id - LightRAG数据库ID
-   * @returns {Promise} - 标签列表
-   */
-  getLabels: async (db_id) => {
-    if (!db_id) {
-      throw new Error('db_id is required')
-    }
-
-    const queryParams = new URLSearchParams({
-      db_id: db_id
-    })
-
-    return await apiGet(`/api/graph/lightrag/labels?${queryParams.toString()}`, {}, true)
-  },
-
-  /**
-   * 获取LightRAG图谱统计信息
-   * @param {string} db_id - LightRAG数据库ID
+   * 获取图谱统计信息 (统一接口)
+   * @param {string} db_id - 图谱ID
    * @returns {Promise} - 统计信息
    */
   getStats: async (db_id) => {
@@ -76,10 +59,28 @@ export const lightragApi = {
       db_id: db_id
     })
 
-    return await apiGet(`/api/graph/lightrag/stats?${queryParams.toString()}`, {}, true)
+    return await apiGet(`/api/graph/stats?${queryParams.toString()}`, {}, true)
+  },
+
+  /**
+   * 获取图谱标签列表 (统一接口)
+   * @param {string} db_id - 图谱ID
+   * @returns {Promise} - 标签列表
+   */
+  getLabels: async (db_id) => {
+    if (!db_id) {
+      throw new Error('db_id is required')
+    }
+
+    const queryParams = new URLSearchParams({
+      db_id: db_id
+    })
+
+    return await apiGet(`/api/graph/labels?${queryParams.toString()}`, {}, true)
   }
 }
 
+
 // =============================================================================
 // === Neo4j图数据库接口分组 ===
 // =============================================================================
@@ -222,11 +223,21 @@ export const getGraphStats = async () => {
   return neo4jApi.getInfo()
 }
 
-// 保持旧的分组导出，便于批量替换
+// 兼容性导出 - 使用统一接口替代旧有的 graphApi
 export const graphApi = {
-  getSubgraph: lightragApi.getSubgraph,
-  getDatabases: lightragApi.getDatabases,
-  getLabels: lightragApi.getLabels,
-  getStats: lightragApi.getStats,
-  ...neo4jApi  // 临时兼容
+  // 使用统一接口替代 LightRAG 接口
+  getSubgraph: unifiedApi.getSubgraph,
+  getDatabases: async () => {
+    // 使用统一接口获取所有图谱，然后过滤出 LightRAG 类型的
+    const response = await unifiedApi.getGraphs()
+    if (response.success) {
+      const lightragDbs = response.data.filter(graph => graph.type === 'lightrag')
+      return { success: true, data: { databases: lightragDbs } }
+    }
+    return response
+  },
+  getLabels: unifiedApi.getLabels,
+  getStats: unifiedApi.getStats,
+  // 保留 Neo4j 接口
+  ...neo4jApi
 }
\ No newline at end of file
diff --git a/web/src/components/GraphCanvas.vue b/web/src/components/GraphCanvas.vue
index 0997c478..9458be8e 100644
--- a/web/src/components/GraphCanvas.vue
+++ b/web/src/components/GraphCanvas.vue
@@ -37,7 +37,7 @@ const props = defineProps({
   highlightKeywords: { type: Array, default: () => [] }
 })
 
-const emit = defineEmits(['ready', 'data-rendered'])
+const emit = defineEmits(['ready', 'data-rendered', 'node-click', 'edge-click', 'canvas-click'])
 
 const container = ref(null)
 const rootEl = ref(null)
@@ -88,6 +88,7 @@ function formatData() {
     data: {
       label: n[props.labelField] ?? n.name ?? String(n.id),
       degree: degrees.get(String(n.id)) || 0,
+      original: n // 保存原始数据
     },
   }))
 
@@ -95,7 +96,10 @@ function formatData() {
     id: e.id ? String(e.id) : `edge-${idx}`,
     source: String(e.source_id),
     target: String(e.target_id),
-    data: { label: e.type ?? '' },
+    data: {
+      label: e.type ?? '',
+      original: e // 保存原始数据
+    },
   }))
 
   return { nodes, edges }
@@ -185,9 +189,38 @@ function initGraph() {
         unselectedState: 'inactive', // 未选中节点状态
         multiple: true,
         trigger: ['shift'],
+        // 禁用默认的选中效果，避免与自定义事件冲突
+        disableDefault: false,
       }
     ],
   })
+
+  // 绑定事件
+  graphInstance.on('node:click', (evt) => {
+    const { target } = evt
+    // 获取节点ID
+    const nodeId = target.id
+    // 从 graph data 中找到对应的节点数据
+    // 注意：G6 v5 的事件对象结构可能有所不同，这里假设 target.id 是节点ID
+    // 也可以通过 graphInstance.getNodeData(nodeId) 获取
+    const nodeData = graphInstance.getNodeData(nodeId)
+    emit('node-click', nodeData)
+  })
+
+  graphInstance.on('edge:click', (evt) => {
+    const { target } = evt
+    const edgeId = target.id
+    const edgeData = graphInstance.getEdgeData(edgeId)
+    emit('edge-click', edgeData)
+  })
+
+  graphInstance.on('canvas:click', (evt) => {
+    // 只有点击画布空白处才触发
+    if (!evt.target) {
+        emit('canvas-click')
+    }
+  })
+
   emit('ready', graphInstance)
 }
 
@@ -364,7 +397,7 @@ defineExpose({
   position: relative;
   width: 100%;
   height: 100%;
-  background-color: var(--gray-0);
+  // background-color: var(--gray-0);
 
   .graph-canvas {
     width: 100%;
diff --git a/web/src/components/GraphDetailPanel.vue b/web/src/components/GraphDetailPanel.vue
new file mode 100644
index 00000000..86fb9ff7
--- /dev/null
+++ b/web/src/components/GraphDetailPanel.vue
@@ -0,0 +1,167 @@
+<template>
+  <transition name="slide-fade">
+    <div class="detail-card" v-if="visible">
+      <a-card :bordered="false" size="small" class="info-card">
+        <template #title>
+          <div class="card-title">
+            <span>{{ title }}</span>
+            <CloseOutlined @click="$emit('close')" class="close-icon" />
+          </div>
+        </template>
+
+        <div class="card-content">
+          <template v-if="item">
+            <a-descriptions :column="1" size="small" :bordered="true">
+              <template v-if="type === 'node'">
+                <a-descriptions-item label="名称">{{ item.data?.label }}</a-descriptions-item>
+                <a-descriptions-item label="ID">{{ item.id }}</a-descriptions-item>
+
+                <!-- 原始属性 -->
+                <template v-if="item.data?.original?.properties">
+                  <a-descriptions-item
+                    v-for="(value, key) in item.data.original.properties"
+                    :key="key"
+                    :label="key"
+                  >
+                    {{ value }}
+                  </a-descriptions-item>
+                </template>
+
+                <!-- 标签 -->
+                <a-descriptions-item label="标签" v-if="item.data?.original?.labels">
+                  <div class="tags-container">
+                    <a-tag v-for="tag in item.data.original.labels" :key="tag" color="blue">{{ tag }}</a-tag>
+                  </div>
+                </a-descriptions-item>
+              </template>
+
+              <template v-else-if="type === 'edge'">
+                <a-descriptions-item label="类型">{{ item.data?.label }}</a-descriptions-item>
+
+                <!-- 原始属性 -->
+                <template v-if="item.data?.original?.properties">
+                  <a-descriptions-item
+                    v-for="(value, key) in filteredEdgeProperties"
+                    :key="key"
+                    :label="key"
+                  >
+                    {{ value }}
+                  </a-descriptions-item>
+                </template>
+              </template>
+            </a-descriptions>
+          </template>
+        </div>
+      </a-card>
+    </div>
+  </transition>
+</template>
+
+<script setup>
+import { computed } from 'vue';
+import { CloseOutlined } from '@ant-design/icons-vue';
+
+const props = defineProps({
+  visible: Boolean,
+  item: Object,
+  type: String // 'node' | 'edge'
+});
+
+defineEmits(['close']);
+
+const title = computed(() => {
+  return props.type === 'node' ? '节点详情' : '关系详情';
+});
+
+// 过滤边的属性，隐藏内部字段
+const filteredEdgeProperties = computed(() => {
+  if (!props.item?.data?.original?.properties) {
+    return {};
+  }
+
+  const properties = props.item.data.original.properties;
+  const filtered = {};
+
+  // 定义需要隐藏的内部字段
+  const hiddenFields = ['source_id', 'target_id', '_id', 'truncate'];
+
+  Object.keys(properties).forEach(key => {
+    if (!hiddenFields.includes(key)) {
+      filtered[key] = properties[key];
+    }
+  });
+
+  return filtered;
+});
+</script>
+
+<style scoped lang="less">
+.detail-card {
+  position: absolute; // 改为 fixed，避免影响父组件布局
+  top: 80px;
+  right: 24px;
+  width: 300px;
+  max-height: calc(100% - 100px);
+  overflow-y: auto;
+  z-index: 1000;
+  pointer-events: auto; // 确保可以交互
+
+  .info-card {
+    background: var(--color-bg-container);
+    backdrop-filter: blur(8px);
+    -webkit-backdrop-filter: blur(8px);
+    box-shadow: 0 4px 12px var(--shadow-3);
+    border-radius: 4px;
+    border: 1px solid var(--gray-200);
+
+    :deep(.ant-card-body) {
+      padding: 12px;
+    }
+
+    :deep(.ant-descriptions-item-label),
+    :deep(.ant-descriptions-item-content) {
+      font-size: 12px;
+      padding: 4px 8px !important;
+    }
+  }
+
+  .card-title {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 13px;
+    font-weight: 600;
+
+    .close-icon {
+      cursor: pointer;
+      color: var(--gray-500);
+      transition: color 0.2s;
+
+      &:hover {
+        color: var(--gray-800);
+      }
+    }
+  }
+
+  .tags-container {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 4px;
+  }
+}
+
+/* 卡片过渡动画 */
+.slide-fade-enter-active {
+  transition: all 0.3s ease-out;
+}
+
+.slide-fade-leave-active {
+  transition: all 0.2s cubic-bezier(1, 0.5, 0.8, 1);
+}
+
+.slide-fade-enter-from,
+.slide-fade-leave-to {
+  transform: translateX(20px);
+  opacity: 0;
+}
+</style>
diff --git a/web/src/components/GraphInfoPanel.vue b/web/src/components/GraphInfoPanel.vue
index 6d3ebd3f..7a5b52ac 100644
--- a/web/src/components/GraphInfoPanel.vue
+++ b/web/src/components/GraphInfoPanel.vue
@@ -12,11 +12,7 @@
       <span v-if="graphInfo?.relationship_count" class="info-total">/ {{ graphInfo.relationship_count }}</span>
     </div>
 
-    <div v-if="graphInfo?.graph_name" class="info-item">
-      <span class="info-label">图谱</span>
-      <span class="info-value">{{ graphInfo.graph_name }}</span>
-    </div>
-
+  
     <div v-if="unindexedCount > 0" class="info-item warning">
       <span class="info-label">未索引</span>
       <span class="info-value warning">{{ unindexedCount }}</span>
@@ -35,17 +31,10 @@
       </a-tooltip>
     </div>
 
-    <div class="actions">
-      <a-button type="default" size="small" @click="$emit('export-data')">
-        <ExportOutlined />
-        导出数据
-      </a-button>
     </div>
-  </div>
 </template>
 
 <script setup>
-import { ExportOutlined } from '@ant-design/icons-vue'
 
 const props = defineProps({
   graphInfo: {
@@ -66,7 +55,7 @@ const props = defineProps({
   }
 })
 
-defineEmits(['index-nodes', 'export-data'])
+defineEmits(['index-nodes'])
 </script>
 
 <style lang="less" scoped>
@@ -120,40 +109,6 @@ defineEmits(['index-nodes', 'export-data'])
   font-size: 12px;
 }
 
-.actions {
-  margin-left: auto;
-  display: flex;
-  gap: 8px;
-
-  @media (max-width: 768px) {
-    margin-left: 0;
-    width: 100%;
-    justify-content: flex-end;
-  }
-}
-
-:deep(.ant-btn-default) {
-  font-size: 12px;
-  height: 28px;
-  padding: 0 12px;
-  border-radius: 6px;
-  border-color: var(--main-300);
-  color: var(--main-600);
-  background: var(--main-20);
-  transition: all 0.2s ease;
-
-  &:hover {
-    border-color: var(--main-500);
-    color: var(--main-700);
-    background: var(--main-40);
-    box-shadow: 0 2px 4px rgba(1, 97, 121, 0.1);
-  }
-
-  &:active {
-    transform: translateY(1px);
-  }
-}
-
 :deep(.ant-btn-primary) {
   font-size: 12px;
   height: 28px;
diff --git a/web/src/components/KnowledgeGraphSection.vue b/web/src/components/KnowledgeGraphSection.vue
index a9604fa1..3255e225 100644
--- a/web/src/components/KnowledgeGraphSection.vue
+++ b/web/src/components/KnowledgeGraphSection.vue
@@ -8,14 +8,49 @@
           <p>只有 LightRAG 类型的知识库支持知识图谱。</p>
         </div>
       </div>
-      <KnowledgeGraphViewer
-        v-else
-        :initial-database-id="databaseId"
-        :hide-db-selector="true"
-        :initial-limit="graphLimit"
-        :initial-depth="graphDepth"
-        ref="graphViewerRef"
-      />
+      <div v-else class="graph-wrapper">
+        <GraphCanvas
+          ref="graphRef"
+          :graph-data="graph.graphData"
+          @node-click="graph.handleNodeClick"
+          @edge-click="graph.handleEdgeClick"
+          @canvas-click="graph.handleCanvasClick"
+        >
+          <template #top>
+             <div class="compact-actions">
+                <a-input-search
+                  v-model:value="searchInput"
+                  placeholder="搜索实体"
+                  style="width: 200px"
+                  @search="onSearch"
+                  allow-clear
+                />
+                <a-button
+                  type="text"
+                  :icon="h(ReloadOutlined)"
+                  :loading="graph.fetching"
+                  @click="loadGraph"
+                  title="刷新"
+                />
+                <a-button
+                  type="text"
+                  :icon="h(SettingOutlined)"
+                  @click="showSettings = true"
+                  title="设置"
+                />
+             </div>
+          </template>
+        </GraphCanvas>
+
+        <!-- 详情浮动卡片 -->
+        <GraphDetailPanel
+          :visible="graph.showDetailDrawer"
+          :item="graph.selectedItem"
+          :type="graph.selectedItemType"
+          @close="graph.handleCanvasClick"
+          style="top: 50px; right: 10px;"
+        />
+      </div>
     </div>
 
     <!-- 设置模态框 -->
@@ -53,40 +88,19 @@
         </a-form>
       </div>
     </a-modal>
-
-    <!-- 导出功能暂禁，等待 LightRAG 库修复
-    <a-modal
-      v-model:open="showExportModal"
-      title="导出图谱数据"
-      @ok="handleExport"
-      ok-text="导出"
-      cancel-text="取消"
-    >
-      <a-form layout="vertical">
-        <a-form-item label="导出格式">
-          <a-select v-model:value="exportOptions.format">
-            <a-select-option value="zip">ZIP 压缩包</a-select-option>
-          </a-select>
-        </a-form-item>
-        <a-form-item>
-          <a-checkbox v-model:checked="exportOptions.include_vectors" disabled>
-            包含向量数据 (暂不支持)
-          </a-checkbox>
-        </a-form-item>
-      </a-form>
-    </a-modal>
-    -->
-
   </div>
 </template>
 
 <script setup>
-import { ref, computed, watch, nextTick, onUnmounted } from 'vue';
+import { ref, computed, watch, nextTick, onUnmounted, reactive, h } from 'vue';
 import { useDatabaseStore } from '@/stores/database';
-import { ReloadOutlined } from '@ant-design/icons-vue';
-import KnowledgeGraphViewer from '@/components/KnowledgeGraphViewer.vue';
-import { h } from 'vue';
+import { ReloadOutlined, SettingOutlined } from '@ant-design/icons-vue';
+import GraphCanvas from '@/components/GraphCanvas.vue';
+import GraphDetailPanel from '@/components/GraphDetailPanel.vue';
 import { getKbTypeLabel } from '@/utils/kb_utils';
+import { unifiedApi } from '@/apis/graph_api';
+import { message } from 'ant-design-vue';
+import { useGraph } from '@/composables/useGraph';
 
 const props = defineProps({
   active: {
@@ -95,25 +109,19 @@ const props = defineProps({
   },
 });
 
-// 声明事件
-const emit = defineEmits(['toggleVisible']);
-
 const store = useDatabaseStore();
 
 const databaseId = computed(() => store.databaseId);
 const kbType = computed(() => store.database.kb_type);
 const kbTypeLabel = computed(() => getKbTypeLabel(kbType.value || 'lightrag'));
 
-const graphViewerRef = ref(null);
+const graphRef = ref(null);
 const showSettings = ref(false);
 const graphLimit = ref(50);
 const graphDepth = ref(2);
+const searchInput = ref('');
 
-const showExportModal = ref(false);
-const exportOptions = ref({
-  format: 'zip',
-  include_vectors: false,
-});
+const graph = reactive(useGraph(graphRef));
 
 // 计算属性：是否支持知识图谱
 const isGraphSupported = computed(() => {
@@ -124,104 +132,40 @@ const isGraphSupported = computed(() => {
 let pendingLoadTimer = null;
 
 const loadGraph = async () => {
-  console.log('loadGraph 调用:', {
-    hasRef: !!graphViewerRef.value,
-    hasLoadFullGraph: graphViewerRef.value && typeof graphViewerRef.value.loadFullGraph === 'function'
-  });
+  if (!databaseId.value || !isGraphSupported.value) return;
 
-  // 等待一小段时间确保子组件已经完全初始化
-  await nextTick();
-
-  if (graphViewerRef.value && typeof graphViewerRef.value.loadFullGraph === 'function') {
-    console.log('调用 loadFullGraph');
-    graphViewerRef.value.loadFullGraph();
-  } else {
-    console.warn('无法调用 loadFullGraph:', {
-      hasRef: !!graphViewerRef.value,
-      refValue: graphViewerRef.value,
-      hasMethod: graphViewerRef.value && typeof graphViewerRef.value.loadFullGraph
+  graph.fetching = true;
+  try {
+    const res = await unifiedApi.getSubgraph({
+      db_id: databaseId.value,
+      node_label: searchInput.value || '*',
+      max_nodes: graphLimit.value,
+      max_depth: graphDepth.value
     });
-  }
-};
 
-const clearGraph = () => {
-  if (graphViewerRef.value && typeof graphViewerRef.value.clearGraph === 'function') {
-    graphViewerRef.value.clearGraph();
+    if (res.success && res.data) {
+        graph.updateGraphData(res.data.nodes, res.data.edges);
+    }
+  } catch (e) {
+    console.error('Failed to load graph:', e);
+    message.error('加载图谱失败');
+  } finally {
+    graph.fetching = false;
   }
 };
 
 const applySettings = () => {
   showSettings.value = false;
-  // 设置已通过props传递给子组件，不需要额外操作
+  loadGraph();
 };
 
-// const handleExport = async () => {
-//   const dbId = store.databaseId;
-//   if (!dbId) {
-//     message.error('请先选择一个知识库');
-//     return;
-//   }
-//   try {
-//     const response = await fetch(`/api/knowledge/databases/${dbId}/export?format=${exportOptions.value.format}`, {
-//       headers: {
-//         ...userStore.getAuthHeaders()
-//       }
-//     });
-
-//     if (!response.ok) {
-//       const errorData = await response.json();
-//       throw new Error(errorData.detail || `导出失败: ${response.statusText}`);
-//     }
-
-//     const blob = await response.blob();
-//     const url = window.URL.createObjectURL(blob);
-//     const a = document.createElement('a');
-//     a.style.display = 'none';
-//     a.href = url;
-
-//     const disposition = response.headers.get('content-disposition');
-//     let filename = `export_${dbId}.zip`;
-//     if (disposition) {
-//         const filenameMatch = disposition.match(/filename="([^"]+)"/);
-//         if (filenameMatch && filenameMatch[1]) {
-//             filename = filenameMatch[1];
-//         }
-//     }
-//     a.download = filename;
-//     document.body.appendChild(a);
-//     a.click();
-//     window.URL.revokeObjectURL(url);
-//     document.body.removeChild(a);
-
-//     message.success('导出任务已开始');
-//     showExportModal.value = false;
-//   } catch (error) {
-//     console.error('导出图谱失败:', error);
-//     message.error(error.message || '导出图谱失败');
-//   }
-// };
+const onSearch = () => {
+    loadGraph();
+}
 
 const scheduleGraphLoad = (delay = 200) => {
-  console.log('scheduleGraphLoad 调用:', {
-    active: props.active,
-    supported: isGraphSupported.value,
-    databaseId: databaseId.value,
-    hasGraphViewer: !!graphViewerRef.value
-  });
-
   // 确保组件激活且数据库支持图谱功能
-  if (!props.active) {
-    console.log('组件未激活，跳过图谱加载');
-    return;
-  }
-
-  if (!isGraphSupported.value) {
-    console.log('数据库不支持图谱功能，跳过加载');
-    return;
-  }
-
-  if (!databaseId.value) {
-    console.log('没有选中数据库，跳过图谱加载');
+  if (!props.active || !isGraphSupported.value || !databaseId.value) {
     return;
   }
 
@@ -230,16 +174,8 @@ const scheduleGraphLoad = (delay = 200) => {
   }
   pendingLoadTimer = setTimeout(async () => {
     await nextTick();
-    // 再次检查条件，防止在延迟期间状态发生变化
     if (props.active && isGraphSupported.value && databaseId.value) {
-      console.log('执行图谱加载');
       await loadGraph();
-    } else {
-      console.log('延迟检查时条件不满足:', {
-        active: props.active,
-        supported: isGraphSupported.value,
-        databaseId: databaseId.value
-      });
     }
   }, delay);
 };
@@ -256,9 +192,7 @@ watch(
 );
 
 watch(databaseId, () => {
-  clearGraph();
-
-  // 只有在新数据库支持图谱时才加载
+  graph.clearGraph();
   if (isGraphSupported.value) {
     scheduleGraphLoad(300);
   }
@@ -266,7 +200,7 @@ watch(databaseId, () => {
 
 watch(isGraphSupported, (supported) => {
   if (!supported) {
-    clearGraph();
+    graph.clearGraph();
     return;
   }
   scheduleGraphLoad(200);
@@ -287,12 +221,34 @@ onUnmounted(() => {
   display: flex;
   flex-direction: column;
   overflow: hidden;
+  position: relative;
 }
 
 .graph-container-compact {
   flex: 1;
   min-height: 0;
   overflow: hidden;
+  position: relative;
+}
+
+.graph-wrapper {
+    height: 100%;
+    width: 100%;
+    position: relative;
+}
+
+.compact-actions {
+    position: absolute;
+    top: 10px;
+    left: 10px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    background: var(--color-trans-light);
+    backdrop-filter: blur(4px);
+    padding: 6px;
+    border-radius: 8px;
+    box-shadow: 0 0px 4px var(--shadow-3);
 }
 
 .graph-disabled {
@@ -310,4 +266,4 @@ onUnmounted(() => {
     margin-bottom: 8px;
   }
 }
-</style>
+</style>
\ No newline at end of file
diff --git a/web/src/components/KnowledgeGraphViewer.vue b/web/src/components/KnowledgeGraphViewer.vue
deleted file mode 100644
index f0c00985..00000000
--- a/web/src/components/KnowledgeGraphViewer.vue
+++ /dev/null
@@ -1,1492 +0,0 @@
-<template>
-  <div class="knowledge-graph-viewer">
-    <!-- 控制面板 -->
-    <div class="control-panel" v-if="!props.hideControls">
-      <div class="database-section">
-        <a-select
-          v-if="!hideDbSelector"
-          v-model:value="selectedDatabase"
-          placeholder="选择数据库"
-          size="small"
-          style="width: 160px; margin-right: 6px"
-          :loading="loadingDatabases"
-          @change="onDatabaseChange"
-        >
-          <a-select-option
-            v-for="db in availableDatabases"
-            :key="db.db_id"
-            :value="db.db_id"
-          >
-            {{ db.name }} ({{ db.row_count || 0 }} 文件)
-          </a-select-option>
-        </a-select>
-
-        <a-select
-          v-model:value="selectedLabel"
-          placeholder="选择标签/实体类型"
-          size="small"
-          style="width: 140px"
-          :loading="loadingLabels"
-          :disabled="!selectedDatabase"
-          allow-clear
-          show-search
-        >
-          <a-select-option value="*">所有节点</a-select-option>
-          <a-select-option
-            v-for="label in availableLabels"
-            :key="label"
-            :value="label"
-          >
-            {{ label }}
-          </a-select-option>
-        </a-select>
-      </div>
-
-      <div class="search-section">
-        <a-input-number
-          v-model:value="searchParams.max_nodes"
-          :min="10"
-          :max="1000"
-          :step="10"
-          size="small"
-          addon-before="limit"
-          style="width: 140px"
-        />
-        <a-input-number
-          v-model:value="searchParams.max_depth"
-          :min="1"
-          :max="5"
-          :step="1"
-          size="small"
-          addon-before="depth"
-          style="width: 120px; margin-left: 6px"
-        />
-        <a-button
-          type="primary"
-          size="small"
-          :loading="loading"
-          @click="loadGraphData"
-          :disabled="!selectedDatabase"
-          style="margin-left: 6px"
-        >
-          <SearchOutlined v-if="!loading" /> 加载图谱
-        </a-button>
-      </div>
-
-    </div>
-
-    <!-- Sigma.js图可视化容器 -->
-    <div
-      class="sigma-container"
-      ref="sigmaContainer"
-      :class="{ 'loading': loading }"
-    ></div>
-
-    <div v-if="!props.hideStats" class="graph-overlay-stats">
-      <a-tag color="blue" size="small">节点: {{ stats.displayed_nodes || 0 }}</a-tag>
-      <a-tag color="green" size="small">边: {{ stats.displayed_edges || 0 }}</a-tag>
-    </div>
-
-    <!-- 节点详情面板 -->
-    <div
-      v-if="selectedNodeData"
-      class="detail-panel node-panel"
-      :style="{ transform: `translate(${nodePanelPosition.x}px, ${nodePanelPosition.y}px)` }"
-      @mousedown="startDragPanel('node', $event)"
-    >
-      <div class="detail-header">
-        <div class="panel-type-indicator node-indicator"></div>
-        <h4>节点: {{ getNodeDisplayName(selectedNodeData) }}</h4>
-        <a-button type="text" size="small" @click="clearSelection">
-          <CloseOutlined />
-        </a-button>
-      </div>
-      <div class="detail-content">
-        <div class="detail-item">
-          <span class="detail-label">ID:</span>
-          <span class="detail-value">{{ selectedNodeData.id }}</span>
-        </div>
-        <div class="detail-item">
-          <span class="detail-label">标签:</span>
-          <span class="detail-value">{{ selectedNodeData.labels?.join(', ') || 'N/A' }}</span>
-        </div>
-        <div class="detail-item">
-          <span class="detail-label">类型:</span>
-          <span class="detail-value">{{ selectedNodeData.entity_type }}</span>
-        </div>
-        <div v-if="selectedNodeData.properties?.description" class="detail-item">
-          <span class="detail-label">描述:</span>
-          <span class="detail-value">{{ selectedNodeData.properties.description }}</span>
-        </div>
-        <div class="detail-actions">
-          <a-button
-            type="primary"
-            size="small"
-            @click="expandNode(selectedNodeData.id)"
-            :loading="expanding"
-            :disabled="!selectedDatabase"
-          >
-            展开相邻节点
-          </a-button>
-        </div>
-      </div>
-    </div>
-
-    <!-- 边详情面板 -->
-    <div
-      v-if="selectedEdgeData"
-      class="detail-panel edge-panel"
-      :style="{ transform: `translate(${intelligentEdgePanelPosition.x}px, ${intelligentEdgePanelPosition.y}px)` }"
-      @mousedown="startDragPanel('edge', $event)"
-    >
-      <div class="detail-header">
-        <div class="panel-type-indicator edge-indicator"></div>
-        <h4>边: {{ getEdgeDisplayName(selectedEdgeData) }}</h4>
-        <a-button type="text" size="small" @click="clearSelection">
-          <CloseOutlined />
-        </a-button>
-      </div>
-      <div class="detail-content">
-        <div class="detail-item">
-          <span class="detail-label">ID:</span>
-          <span class="detail-value">{{ selectedEdgeData.id }}</span>
-        </div>
-        <div class="detail-item">
-          <span class="detail-label">源节点:</span>
-          <span class="detail-value">{{ selectedEdgeData.source }}</span>
-        </div>
-        <div class="detail-item">
-          <span class="detail-label">目标节点:</span>
-          <span class="detail-value">{{ selectedEdgeData.target }}</span>
-        </div>
-        <div class="detail-item">
-          <span class="detail-label">类型:</span>
-          <span class="detail-value">{{ selectedEdgeData.type || 'DIRECTED' }}</span>
-        </div>
-        <div v-if="selectedEdgeData.properties?.weight" class="detail-item">
-          <span class="detail-label">权重:</span>
-          <span class="detail-value">{{ selectedEdgeData.properties.weight }}</span>
-        </div>
-        <div v-if="selectedEdgeData.properties?.keywords" class="detail-item">
-          <span class="detail-label">关键词:</span>
-          <span class="detail-value">{{ selectedEdgeData.properties.keywords }}</span>
-        </div>
-        <div v-if="selectedEdgeData.properties?.description" class="detail-item">
-          <span class="detail-label">描述:</span>
-          <span class="detail-value">{{ selectedEdgeData.properties.description }}</span>
-        </div>
-      </div>
-    </div>
-
-    <!-- <div class="legend" v-if="entityTypes.length > 0">
-      <div class="legend-header">
-        <h4>实体类型</h4>
-      </div>
-      <div class="legend-content">
-        <div class="legend-item" v-for="type in entityTypes" :key="type.type">
-          <div
-            class="legend-color"
-            :style="{ backgroundColor: getEntityColor(type.type) }"
-          ></div>
-          <span>{{ type.type }} ({{ type.count }})</span>
-        </div>
-      </div>
-    </div> -->
-
-    <!-- 控制按钮 (简化版) -->
-    <div class="graph-controls">
-      <div class="control-group">
-        <a-button @click="zoomIn" size="small" type="text" class="control-btn">
-          <PlusOutlined />
-        </a-button>
-        <a-button @click="zoomOut" size="small" type="text" class="control-btn">
-          <MinusOutlined />
-        </a-button>
-        <a-button @click="resetCamera" size="small" type="text" class="control-btn" title="重置视图">
-          <HomeOutlined />
-        </a-button>
-      </div>
-    </div>
-
-    <!-- 加载遮罩 -->
-    <div v-if="loading" class="loading-overlay">
-      <div class="loading-content">
-        <a-spin size="large" />
-        <p>{{ loadingMessage }}</p>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script setup>
-import { ref, reactive, onMounted, onUnmounted, computed, watch, nextTick } from 'vue'
-import { message } from 'ant-design-vue'
-import {
-  SearchOutlined,
-  ClearOutlined,
-  CloseOutlined,
-  PlusOutlined,
-  MinusOutlined,
-  HomeOutlined
-} from '@ant-design/icons-vue'
-import Sigma from 'sigma'
-import { NodeBorderProgram } from '@sigma/node-border'
-import EdgeCurveProgram, { EdgeCurvedArrowProgram } from '@sigma/edge-curve'
-import { EdgeArrowProgram } from 'sigma/rendering'
-
-import { lightragApi } from '@/apis/graph_api'
-import { useGraphStore } from '@/stores/graphStore'
-import { useDatabaseStore } from '@/stores/database'
-
-// CSS 变量解析工具函数
-function getCSSVariable(variableName, element = document.documentElement) {
-  return getComputedStyle(element).getPropertyValue(variableName).trim()
-}
-import '@/assets/css/sigma.css'
-
-// 定义 props
-const props = defineProps({
-  initialDatabaseId: {
-    type: String,
-    default: ''
-  },
-  hideDbSelector: {
-    type: Boolean,
-    default: false
-  },
-  hideStats: {
-    type: Boolean,
-    default: false
-  },
-  hideControls: {
-    type: Boolean,
-    default: false
-  },
-  initialLimit: {
-    type: Number,
-    default: 200
-  },
-  initialDepth: {
-    type: Number,
-    default: 2
-  }
-})
-
-// 定义 emits
-const emit = defineEmits(['update:stats', 'refresh-graph', 'clear-graph'])
-
-// 状态管理
-const graphStore = useGraphStore()
-const databaseStore = useDatabaseStore()
-
-// 响应式引用
-const loading = ref(false)
-const loadingDatabases = ref(false)
-const loadingLabels = ref(false)
-const expanding = ref(false)
-const sigmaContainer = ref(null)
-const layoutRunning = ref(false)
-const loadingMessage = ref('加载图数据中...')
-
-// 面板拖拽相关
-const nodePanelPosition = ref({ x: 12, y: 60 })
-const edgePanelPosition = ref({ x: 12, y: 150 }) // 降低初始Y位置以适应紧凑模式
-const dragging = ref({ active: false, type: '', startX: 0, startY: 0, initialX: 0, initialY: 0 })
-
-// 数据库相关状态
-const selectedDatabase = ref('')
-const availableDatabases = ref([])
-const selectedLabel = ref('*')
-const availableLabels = ref([])
-
-// Sigma实例
-let sigmaInstance = null
-let layoutWorker = null
-
-// 搜索和筛选参数
-const searchParams = reactive({
-  max_nodes: props.initialLimit,
-  max_depth: props.initialDepth
-})
-
-// 计算属性
-const entityTypes = computed(() => graphStore.entityTypes)
-const stats = computed(() => graphStore.stats)
-const selectedNodeData = computed(() => graphStore.selectedNodeData)
-const selectedEdgeData = computed(() => graphStore.selectedEdgeData)
-
-// 智能边面板位置 - 确保在紧凑模式下也能正确显示
-const intelligentEdgePanelPosition = computed(() => {
-  if (!sigmaContainer.value) return edgePanelPosition.value
-
-  const containerHeight = sigmaContainer.value.clientHeight
-  const panelHeight = 200 // 估计的面板高度
-  const nodePanelBottom = selectedNodeData.value ? nodePanelPosition.value.y + 200 : 0
-
-  // 如果有节点面板显示，将边面板放在节点面板下方
-  if (selectedNodeData.value) {
-    return {
-      x: edgePanelPosition.value.x + 260, // 在节点面板右侧
-      y: Math.min(nodePanelPosition.value.y, containerHeight - panelHeight - 20)
-    }
-  }
-
-  // 确保边面板在容器范围内
-  return {
-    x: edgePanelPosition.value.x,
-    y: Math.min(edgePanelPosition.value.y, Math.max(60, containerHeight - panelHeight - 20))
-  }
-})
-
-// 获取节点显示名称
-const getNodeDisplayName = (node) => {
-  if (node.properties?.entity_id) {
-    return node.properties.entity_id
-  }
-  if (node.labels && node.labels.length > 0) {
-    return node.labels[0]
-  }
-  return node.id || 'Unknown'
-}
-
-// 获取边显示名称
-const getEdgeDisplayName = (edge) => {
-  if (edge.properties?.keywords) {
-    return edge.properties.keywords
-  }
-  if (edge.properties?.description) {
-    return edge.properties.description.substring(0, 20) + '...'
-  }
-  return `${edge.source} -> ${edge.target}`
-}
-
-// 加载可用数据库
-const loadAvailableDatabases = async () => {
-  loadingDatabases.value = true
-  try {
-    const response = await lightragApi.getDatabases()
-    if (response.success) {
-      availableDatabases.value = response.data.databases || []
-
-      // 如果有初始数据库 ID，直接使用它（上层已经检查过类型）
-      if (props.initialDatabaseId) {
-        selectedDatabase.value = props.initialDatabaseId
-        await onDatabaseChange(selectedDatabase.value)
-      } else if (availableDatabases.value.length > 0 && !selectedDatabase.value) {
-        // 没有初始数据库ID，选择第一个可用的数据库
-        selectedDatabase.value = availableDatabases.value[0].db_id
-        await onDatabaseChange(selectedDatabase.value)
-      }
-    }
-  } catch (error) {
-    console.error('加载数据库列表失败:', error)
-    message.error('加载数据库列表失败: ' + error.message)
-  } finally {
-    loadingDatabases.value = false
-  }
-}
-
-// 加载图标签
-const loadGraphLabels = async (dbId) => {
-  if (!dbId) return
-
-  loadingLabels.value = true
-  try {
-    const response = await lightragApi.getLabels(dbId)
-    if (response.success) {
-      availableLabels.value = response.data.labels || []
-    }
-  } catch (error) {
-    console.error('加载图标签失败:', error)
-    availableLabels.value = []
-  } finally {
-    loadingLabels.value = false
-  }
-}
-
-// 数据库切换处理
-const onDatabaseChange = async (dbId) => {
-  if (!dbId) return
-
-  selectedDatabase.value = dbId
-  selectedLabel.value = '*'
-
-  // 清空当前图谱
-  clearGraph()
-
-  // 加载新数据库的标签
-  await loadGraphLabels(dbId)
-
-  // message.info(`已切换到数据库: ${availableDatabases.value.find(db => db.db_id === dbId)?.name || dbId}`)
-}
-
-// Sigma.js配置
-const sigmaSettings = {
-  allowInvalidContainer: true,
-  defaultNodeType: 'default',
-  defaultEdgeType: 'curvedArrow',
-  renderEdgeLabels: true,
-  renderLabels: true,
-  enableEdgeEvents: true,
-  // 添加 passive event listener 配置以解决警告
-  enableCameraAPI: true,
-  touchActions: 'pan-y pinch-zoom',
-  eventBubbling: false,
-  edgeProgramClasses: {
-    arrow: EdgeArrowProgram,
-    curvedArrow: EdgeCurvedArrowProgram,
-    curved: EdgeCurveProgram
-  },
-  nodeProgramClasses: {
-    default: NodeBorderProgram
-  },
-  labelSize: 12,
-  edgeLabelSize: 10,
-  labelColor: {
-    color: getCSSVariable('--color-text')
-  },
-  edgeLabelColor: {
-    color: getCSSVariable('--color-text-secondary')
-  },
-  minEdgeThickness: 4, // 增加最小边厚度，提高点击性
-  maxEdgeThickness: 10, // 增加最大边厚度
-  // 添加边点击相关配置
-  edgeClickTolerance: 15, // 增加边点击容差，增加点击检测区域
-  edgeHoverTolerance: 12,  // 增加边悬停容差
-  zoomToSizeRatioFunction: (x) => x, // 确保缩放时边的厚度保持合理
-  eventListenerOptions: {
-    wheel: { passive: true },
-    touchstart: { passive: true },
-  },
-}
-
-// 初始化Sigma.js
-const initSigma = async () => {
-  if (!sigmaContainer.value || sigmaInstance) return
-
-  try {
-    sigmaInstance = new Sigma(
-      graphStore.sigmaGraph || graphStore.createSigmaGraph({ nodes: [], edges: [] }),
-      sigmaContainer.value,
-      sigmaSettings
-    )
-
-    // 保存实例到状态管理
-    graphStore.setSigmaInstance(sigmaInstance)
-
-    // 注册事件监听器
-    registerEvents()
-
-    console.log('Sigma.js 实例创建成功')
-  } catch (error) {
-    console.error('初始化Sigma.js失败:', error)
-    message.error('图可视化初始化失败')
-  }
-}
-
-// 拖拽状态
-const isDragging = ref(false)
-let draggedNode = null
-
-// 注册事件监听器
-const registerEvents = () => {
-  if (!sigmaInstance) return
-
-  // 节点点击事件
-  sigmaInstance.on('clickNode', ({ node }) => {
-    try {
-      const graph = sigmaInstance.getGraph()
-      if (graph.hasNode(node)) {
-        console.log('Clicked node:', node)
-
-        // 立即设置选中节点，显示详情面板
-        graphStore.setSelectedNode(node, false) // 先不移动相机
-
-        // 获取节点数据并确保设置成功
-        const nodeData = graph.getNodeAttributes(node)
-        console.log('Node data:', nodeData)
-
-        // 延迟一点后再移动相机，确保详情面板已显示
-        setTimeout(() => {
-          if (graphStore.selectedNode === node) {
-            graphStore.moveToSelectedNode = true
-            graphStore.setSelectedNode(node, true) // 现在移动相机
-          }
-        }, 100)
-
-      } else {
-        console.warn('Clicked node does not exist in graph:', node)
-      }
-    } catch (error) {
-      console.error('Error handling node click:', error)
-    }
-  })
-
-  // 节点悬停事件
-  sigmaInstance.on('enterNode', ({ node }) => {
-    if (!isDragging.value) {
-      try {
-        const graph = sigmaInstance.getGraph()
-        if (graph.hasNode(node)) {
-          graphStore.setFocusedNode(node)
-        }
-      } catch (error) {
-        console.error('Error handling node enter:', error)
-      }
-    }
-  })
-
-  sigmaInstance.on('leaveNode', () => {
-    if (!isDragging.value) {
-      graphStore.setFocusedNode(null)
-    }
-  })
-
-  // 边点击事件
-  sigmaInstance.on('clickEdge', ({ edge }) => {
-    try {
-      console.log('边被点击 - Sigma边ID:', edge)
-      const graph = sigmaInstance.getGraph()
-      if (graph.hasEdge(edge)) {
-        // 获取Sigma边的属性，其中包含原始数据
-        const sigmaEdgeData = graph.getEdgeAttributes(edge)
-        console.log('Sigma边属性:', sigmaEdgeData)
-
-        // 立即设置选中的边 - 使用Sigma边ID
-        graphStore.setSelectedEdge(edge)
-
-        // 确保边面板显示
-        nextTick(() => {
-          if (selectedEdgeData.value) {
-            console.log('边面板应该显示:', selectedEdgeData.value)
-            message.success(`已选中边: ${getEdgeDisplayName(selectedEdgeData.value)}`)
-          } else {
-            console.warn('selectedEdgeData为空，尝试使用Sigma边数据')
-            // 如果无法从rawGraph中找到，直接使用Sigma边的原始数据
-            const fallbackData = sigmaEdgeData.originalData || {
-              id: edge,
-              source: graph.source(edge),
-              target: graph.target(edge),
-              properties: {
-                keywords: sigmaEdgeData.label || '',
-                description: sigmaEdgeData.label || '',
-                weight: sigmaEdgeData.originalWeight || 1
-              }
-            }
-            console.log('使用回退边数据:', fallbackData)
-            message.success(`已选中边: ${getEdgeDisplayName(fallbackData)}`)
-          }
-        })
-      } else {
-        console.warn('点击的边不存在于图中:', edge)
-        message.warning('点击的边不存在于图中')
-      }
-    } catch (error) {
-      console.error('处理边点击事件时出错:', error)
-      message.error('处理边点击事件时出错')
-    }
-  })
-
-  // 添加边悬停事件以提高交互体验
-  sigmaInstance.on('enterEdge', ({ edge }) => {
-    if (!isDragging.value) {
-      try {
-        const graph = sigmaInstance.getGraph()
-        if (graph.hasEdge(edge)) {
-          // 高亮悬停的边
-          graph.setEdgeAttribute(edge, 'color', getCSSVariable('--color-error-500'))
-          graph.setEdgeAttribute(edge, 'size', (graph.getEdgeAttribute(edge, 'size') || 1) * 1.5)
-          sigmaInstance.refresh()
-          console.log('悬停在边上:', edge)
-        }
-      } catch (error) {
-        console.error('处理边悬停事件时出错:', error)
-      }
-    }
-  })
-
-  sigmaInstance.on('leaveEdge', ({ edge }) => {
-    if (!isDragging.value) {
-      try {
-        const graph = sigmaInstance.getGraph()
-        if (graph.hasEdge(edge)) {
-          // 恢复边的原始样式
-          const originalData = graph.getEdgeAttribute(edge, 'originalData')
-          graph.setEdgeAttribute(edge, 'color', originalData?.color || getCSSVariable('--color-text-secondary'))
-          graph.setEdgeAttribute(edge, 'size', originalData?.size || 1)
-          sigmaInstance.refresh()
-        }
-      } catch (error) {
-        console.error('处理边离开事件时出错:', error)
-      }
-    }
-  })
-
-  // 画布点击事件
-  sigmaInstance.on('clickStage', () => {
-    graphStore.clearSelection()
-  })
-
-  // 拖拽支持
-  sigmaInstance.on('downNode', (e) => {
-    isDragging.value = true
-    draggedNode = e.node
-
-    // 高亮拖拽节点
-    const graph = sigmaInstance.getGraph()
-    graph.setNodeAttribute(draggedNode, 'highlighted', true)
-
-    // 停止布局
-    if (layoutWorker) {
-      layoutWorker.stop()
-    }
-  })
-
-  sigmaInstance.getMouseCaptor().on('mousemovebody', (e) => {
-    if (!isDragging.value || !draggedNode) return
-
-    // 获取新位置
-    const pos = sigmaInstance.viewportToGraph(e)
-
-    // 更新节点位置
-    const graph = sigmaInstance.getGraph()
-    graph.setNodeAttribute(draggedNode, 'x', pos.x)
-    graph.setNodeAttribute(draggedNode, 'y', pos.y)
-
-    // 阻止默认行为
-    e.preventSigmaDefault()
-    e.original.preventDefault()
-    e.original.stopPropagation()
-  })
-
-  sigmaInstance.getMouseCaptor().on('mouseup', () => {
-    if (draggedNode) {
-      const graph = sigmaInstance.getGraph()
-      graph.removeNodeAttribute(draggedNode, 'highlighted')
-    }
-    isDragging.value = false
-    draggedNode = null
-  })
-}
-
-// 加载图数据
-const loadGraphData = async () => {
-  if (!selectedDatabase.value) {
-    console.warn('尝试加载图数据但没有选中数据库')
-    return
-  }
-
-  loading.value = true
-  loadingMessage.value = '加载图数据中...'
-  graphStore.setIsFetching(true)
-
-  try {
-    const [graphResponse, statsResponse] = await Promise.all([
-      lightragApi.getSubgraph({
-        db_id: selectedDatabase.value,
-        node_label: selectedLabel.value || '*',
-        max_depth: searchParams.max_depth,
-        max_nodes: searchParams.max_nodes
-      }),
-      lightragApi.getStats(selectedDatabase.value)
-    ])
-
-    if (graphResponse.success && statsResponse.success) {
-      // 设置实体类型
-      graphStore.setEntityTypes(statsResponse.data.entity_types || [])
-
-      // 创建图数据
-      const rawGraph = graphStore.createGraphFromApiData(
-        graphResponse.data.nodes,
-        graphResponse.data.edges
-      )
-
-      // 设置图数据
-      graphStore.setRawGraph(rawGraph)
-      // 更新当前显示的节点和边数量
-      graphStore.stats = {
-        displayed_nodes: graphResponse.data.nodes.length,
-        displayed_edges: graphResponse.data.edges.length,
-        is_truncated: graphResponse.data.is_truncated
-      }
-
-      console.log('Raw graph created:', {
-        nodes: rawGraph.nodes.length,
-        edges: rawGraph.edges.length,
-        sampleNode: rawGraph.nodes[0],
-        sampleEdge: rawGraph.edges[0]
-      })
-
-      // 创建Sigma图
-      const sigmaGraph = graphStore.createSigmaGraph(rawGraph)
-      graphStore.setSigmaGraph(sigmaGraph)
-
-      // 应用布局
-      await applyLayout(sigmaGraph)
-
-      // 更新Sigma实例
-      if (sigmaInstance) {
-        sigmaInstance.setGraph(sigmaGraph)
-        sigmaInstance.refresh()
-      } else {
-        await nextTick()
-        await initSigma()
-      }
-
-      // message.success(`加载成功：${rawGraph.nodes.length} 个节点，${rawGraph.edges.length} 条边${graphResponse.data.is_truncated ? ' (已截断)' : ''}`)
-    }
-  } catch (error) {
-    console.error('加载图数据失败:', error)
-    message.error('加载图数据失败: ' + error.message)
-  } finally {
-    loading.value = false
-    loadingMessage.value = '加载图数据中...'
-    graphStore.setIsFetching(false)
-  }
-}
-
-// 加载完整图数据
-const loadFullGraph = async () => {
-  console.log('loadFullGraph 调用:', {
-    selectedDatabase: selectedDatabase.value,
-    availableDatabases: availableDatabases.value.length,
-    initialDatabaseId: props.initialDatabaseId
-  });
-
-  // 如果还没有选中数据库，等待数据库加载完成
-  if (!selectedDatabase.value && props.initialDatabaseId) {
-    console.log('等待数据库加载完成...');
-    // 等待一小段时间让异步操作完成
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-
-  // 再次检查是否有选中的数据库
-  if (!selectedDatabase.value) {
-    console.warn('loadFullGraph: 没有选中的数据库，无法加载图谱')
-    return
-  }
-
-  selectedLabel.value = '*'
-  await loadGraphData()
-  emit('refresh-graph')
-}
-
-// 清空图谱
-const clearGraph = () => {
-  if (sigmaInstance) {
-    const emptyGraph = graphStore.createSigmaGraph({ nodes: [], edges: [] })
-    sigmaInstance.setGraph(emptyGraph)
-    sigmaInstance.refresh()
-  }
-  graphStore.reset()
-  emit('clear-graph')
-}
-
-// 应用布局算法
-const applyLayout = async (graph) => {
-  return new Promise((resolve) => {
-    if (!graph || graph.order === 0) {
-      resolve()
-      return
-    }
-
-    loadingMessage.value = '计算布局中...'
-
-    // 简单的力导向布局
-    const nodes = graph.nodes()
-    const edges = graph.edges()
-
-    // 随机初始位置
-    nodes.forEach((node) => {
-      if (!graph.hasNodeAttribute(node, 'x')) {
-        graph.setNodeAttribute(node, 'x', Math.random() * 1000)
-      }
-      if (!graph.hasNodeAttribute(node, 'y')) {
-        graph.setNodeAttribute(node, 'y', Math.random() * 1000)
-      }
-    })
-
-    // 简单的力导向迭代
-    const iterations = 100
-    for (let i = 0; i < iterations; i++) {
-      // 斥力
-      for (let j = 0; j < nodes.length; j++) {
-        for (let k = j + 1; k < nodes.length; k++) {
-          const node1 = nodes[j]
-          const node2 = nodes[k]
-
-          const x1 = graph.getNodeAttribute(node1, 'x')
-          const y1 = graph.getNodeAttribute(node1, 'y')
-          const x2 = graph.getNodeAttribute(node2, 'x')
-          const y2 = graph.getNodeAttribute(node2, 'y')
-
-          const dx = x2 - x1
-          const dy = y2 - y1
-          const distance = Math.sqrt(dx * dx + dy * dy) || 1
-
-          const force = 1000 / (distance * distance)
-          const fx = (dx / distance) * force
-          const fy = (dy / distance) * force
-
-          graph.setNodeAttribute(node1, 'x', x1 - fx)
-          graph.setNodeAttribute(node1, 'y', y1 - fy)
-          graph.setNodeAttribute(node2, 'x', x2 + fx)
-          graph.setNodeAttribute(node2, 'y', y2 + fy)
-        }
-      }
-
-      // 引力
-      edges.forEach((edge) => {
-        const source = graph.source(edge)
-        const target = graph.target(edge)
-
-        const x1 = graph.getNodeAttribute(source, 'x')
-        const y1 = graph.getNodeAttribute(source, 'y')
-        const x2 = graph.getNodeAttribute(target, 'x')
-        const y2 = graph.getNodeAttribute(target, 'y')
-
-        const dx = x2 - x1
-        const dy = y2 - y1
-        const distance = Math.sqrt(dx * dx + dy * dy) || 1
-
-        const force = distance * 0.01
-        const fx = (dx / distance) * force
-        const fy = (dy / distance) * force
-
-        graph.setNodeAttribute(source, 'x', x1 + fx)
-        graph.setNodeAttribute(source, 'y', y1 + fy)
-        graph.setNodeAttribute(target, 'x', x2 - fx)
-        graph.setNodeAttribute(target, 'y', y2 - fy)
-      })
-    }
-
-    resolve()
-  })
-}
-
-// 展开节点
-const expandNode = async (nodeId) => {
-  if (!selectedDatabase.value) {
-    console.warn('尝试展开节点但没有选中数据库')
-    return
-  }
-
-  expanding.value = true
-  try {
-    const response = await lightragApi.getSubgraph({
-      db_id: selectedDatabase.value,
-      node_label: nodeId,
-      max_depth: 1,
-      max_nodes: 50
-    })
-
-    if (response.success) {
-      // 合并新数据的逻辑
-      const existingNodeIds = new Set(graphStore.rawGraph.nodes.map(n => n.id))
-      const existingEdgeIds = new Set(graphStore.rawGraph.edges.map(e => e.id))
-
-      const newNodes = response.data.nodes.filter(node => !existingNodeIds.has(node.id))
-      const newEdges = response.data.edges.filter(edge => !existingEdgeIds.has(edge.id))
-
-      if (newNodes.length > 0 || newEdges.length > 0) {
-        // 重新创建图数据
-        const allNodes = [...graphStore.rawGraph.nodes, ...newNodes]
-        const allEdges = [...graphStore.rawGraph.edges, ...newEdges]
-
-        const rawGraph = graphStore.createGraphFromApiData(allNodes, allEdges)
-        graphStore.setRawGraph(rawGraph)
-
-        const sigmaGraph = graphStore.createSigmaGraph(rawGraph)
-        graphStore.setSigmaGraph(sigmaGraph)
-
-        if (sigmaInstance) {
-          sigmaInstance.setGraph(sigmaGraph)
-          sigmaInstance.refresh()
-        }
-
-        message.success(`展开成功：新增 ${newNodes.length} 个节点，${newEdges.length} 条边`)
-      } else {
-        message.info('没有新的相邻节点')
-      }
-    }
-  } catch (error) {
-    console.error('展开节点失败:', error)
-    message.error('展开节点失败: ' + error.message)
-  } finally {
-    expanding.value = false
-  }
-}
-
-// 控制方法
-const zoomIn = () => {
-  if (sigmaInstance) {
-    const camera = sigmaInstance.getCamera()
-    camera.animatedZoom({ duration: 200 })
-  }
-}
-
-const zoomOut = () => {
-  if (sigmaInstance) {
-    const camera = sigmaInstance.getCamera()
-    camera.animatedUnzoom({ duration: 200 })
-  }
-}
-
-const resetCamera = () => {
-  if (sigmaInstance) {
-    try {
-      const camera = sigmaInstance.getCamera()
-      const graph = sigmaInstance.getGraph()
-
-      // 如果图为空，直接重置
-      if (graph.order === 0) {
-        camera.animatedReset({ duration: 500 })
-        return
-      }
-
-      // 计算图的边界以确保所有节点都可见
-      const nodes = graph.nodes()
-      if (nodes.length > 0) {
-        const bounds = { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity }
-
-        nodes.forEach(node => {
-          const attrs = graph.getNodeAttributes(node)
-          if (typeof attrs.x === 'number' && typeof attrs.y === 'number') {
-            bounds.minX = Math.min(bounds.minX, attrs.x)
-            bounds.maxX = Math.max(bounds.maxX, attrs.x)
-            bounds.minY = Math.min(bounds.minY, attrs.y)
-            bounds.maxY = Math.max(bounds.maxY, attrs.y)
-          }
-        })
-
-        // 只有在边界有效时才使用fitBounds
-        if (isFinite(bounds.minX) && isFinite(bounds.maxX) && isFinite(bounds.minY) && isFinite(bounds.maxY)) {
-          const centerX = (bounds.minX + bounds.maxX) / 2
-          const centerY = (bounds.minY + bounds.maxY) / 2
-          const padding = 50
-
-          camera.animate({
-            x: centerX,
-            y: centerY,
-            ratio: Math.max(
-              (bounds.maxX - bounds.minX + padding) / window.innerWidth,
-              (bounds.maxY - bounds.minY + padding) / window.innerHeight
-            ) || 1.0
-          }, { duration: 500 })
-        } else {
-          // 回退到默认重置
-          camera.animatedReset({ duration: 500 })
-        }
-      } else {
-        camera.animatedReset({ duration: 500 })
-      }
-
-      console.log('Camera reset completed')
-      message.success('视图已重置')
-    } catch (error) {
-      console.error('Error resetting camera:', error)
-      // 强制重置
-      if (sigmaInstance) {
-        const camera = sigmaInstance.getCamera()
-        camera.setState({ x: 0, y: 0, ratio: 1.0 })
-        sigmaInstance.refresh()
-      }
-      message.info('视图已强制重置')
-    }
-  }
-}
-
-const toggleLayout = () => {
-  // 简单的布局切换
-  layoutRunning.value = !layoutRunning.value
-  if (layoutRunning.value && sigmaInstance) {
-    applyLayout(sigmaInstance.getGraph())
-  }
-}
-
-const clearSelection = () => {
-  graphStore.clearSelection()
-}
-
-const getEntityColor = (entityType) => {
-  return graphStore.getEntityColor(entityType)
-}
-
-// 面板拖拽功能
-const startDragPanel = (type, event) => {
-  event.preventDefault()
-
-  if (!sigmaContainer.value) return
-
-  const currentPosition = type === 'node' ? nodePanelPosition.value : edgePanelPosition.value
-
-  // 获取容器位置，计算相对于容器的鼠标位置
-  const containerRect = sigmaContainer.value.getBoundingClientRect()
-  const relativeX = event.clientX - containerRect.left
-  const relativeY = event.clientY - containerRect.top
-
-  dragging.value = {
-    active: true,
-    type: type,
-    startX: relativeX,
-    startY: relativeY,
-    initialX: currentPosition.x,
-    initialY: currentPosition.y
-  }
-
-  document.addEventListener('mousemove', onDragPanel)
-  document.addEventListener('mouseup', stopDragPanel)
-}
-
-const onDragPanel = (event) => {
-  if (!dragging.value.active || !sigmaContainer.value) return
-
-  // 获取容器位置和尺寸
-  const containerRect = sigmaContainer.value.getBoundingClientRect()
-
-  // 计算当前鼠标相对于容器的位置
-  const currentRelativeX = event.clientX - containerRect.left
-  const currentRelativeY = event.clientY - containerRect.top
-
-  // 计算拖拽偏移
-  const deltaX = currentRelativeX - dragging.value.startX
-  const deltaY = currentRelativeY - dragging.value.startY
-
-  const maxX = containerRect.width - 260  // 面板宽度为240px + 一些边距
-  const maxY = containerRect.height - 200 // 面板高度约为200px
-
-  const newPosition = {
-    x: Math.max(0, Math.min(maxX, dragging.value.initialX + deltaX)),
-    y: Math.max(0, Math.min(maxY, dragging.value.initialY + deltaY))
-  }
-
-  if (dragging.value.type === 'node') {
-    nodePanelPosition.value = newPosition
-  } else {
-    edgePanelPosition.value = newPosition
-  }
-}
-
-const stopDragPanel = () => {
-  dragging.value.active = false
-  document.removeEventListener('mousemove', onDragPanel)
-  document.removeEventListener('mouseup', stopDragPanel)
-}
-
-// 生命周期
-onMounted(async () => {
-  await nextTick()
-  await loadAvailableDatabases()
-})
-
-onUnmounted(() => {
-  // 清理拖拽事件监听器
-  document.removeEventListener('mousemove', onDragPanel)
-  document.removeEventListener('mouseup', stopDragPanel)
-
-  if (sigmaInstance) {
-    sigmaInstance.kill()
-    sigmaInstance = null
-  }
-  if (layoutWorker) {
-    layoutWorker.stop()
-  }
-  graphStore.reset()
-})
-
-// 监听选中节点数据变化，用于调试
-watch(() => graphStore.selectedNodeData, (nodeData) => {
-  console.log('Selected node data changed:', nodeData)
-})
-
-// 监听选中边数据变化，用于调试和确保面板显示
-watch(() => graphStore.selectedEdgeData, (edgeData) => {
-  console.log('Selected edge data changed:', edgeData)
-  if (edgeData) {
-    console.log('边面板应该显示，当前位置:', intelligentEdgePanelPosition.value)
-  }
-})
-
-// 监听选中节点变化，移动相机
-watch(() => graphStore.selectedNode, (nodeId) => {
-  if (nodeId && graphStore.moveToSelectedNode && sigmaInstance) {
-    try {
-      const graph = sigmaInstance.getGraph()
-
-      // 检查节点是否存在
-      if (!graph.hasNode(nodeId)) {
-        console.warn('Selected node does not exist in graph:', nodeId)
-        graphStore.moveToSelectedNode = false
-        return
-      }
-
-      const nodeAttributes = graph.getNodeAttributes(nodeId)
-
-      // 检查节点属性是否有效
-      if (!nodeAttributes || typeof nodeAttributes.x !== 'number' || typeof nodeAttributes.y !== 'number') {
-        console.warn('Invalid node attributes for node:', nodeId, nodeAttributes)
-        graphStore.moveToSelectedNode = false
-        return
-      }
-
-      const camera = sigmaInstance.getCamera()
-      const currentState = camera.getState()
-
-      console.log('Moving camera to node:', nodeId, {
-        x: nodeAttributes.x,
-        y: nodeAttributes.y,
-        currentRatio: currentState.ratio
-      })
-
-      // 计算合适的缩放比例，避免过度缩放
-      const currentRatio = currentState.ratio || 1.0
-      const targetRatio = Math.max(0.1, Math.min(currentRatio * 0.7, 0.6))
-
-      // 验证节点位置是否有效
-      const isValidPosition = (
-        typeof nodeAttributes.x === 'number' &&
-        typeof nodeAttributes.y === 'number' &&
-        !isNaN(nodeAttributes.x) &&
-        !isNaN(nodeAttributes.y) &&
-        isFinite(nodeAttributes.x) &&
-        isFinite(nodeAttributes.y)
-      )
-
-      if (!isValidPosition) {
-        console.warn('Invalid node position, skipping camera movement:', nodeAttributes)
-        return
-      }
-
-      // 移动相机到节点位置，使用安全的缩放比例
-      camera.animate(
-        {
-          x: nodeAttributes.x,
-          y: nodeAttributes.y,
-          ratio: targetRatio  // 使用计算出的安全缩放比例
-        },
-        {
-          duration: 600  // 适中的动画时间
-        }
-      )
-    } catch (error) {
-      console.error('Error moving camera to selected node:', error)
-      // 如果相机移动失败，至少确保显示节点详情
-      if (nodeId) {
-        const graph = sigmaInstance.getGraph()
-        if (graph.hasNode(nodeId)) {
-          const nodeData = graph.getNodeAttributes(nodeId)
-          console.log('Fallback: showing node details without camera movement', nodeData)
-        }
-      }
-    } finally {
-      // 确保重置标志
-      graphStore.moveToSelectedNode = false
-    }
-      }
-  })
-
-// 监听统计数据变化，通知父组件
-watch(stats, (newStats) => {
-  emit('update:stats', newStats)
-}, { deep: true, immediate: true })
-
-// 暴露给父组件的方法
-defineExpose({
-  loadFullGraph,
-  clearGraph
-})
-</script>
-
-<style lang="less" scoped>
-.knowledge-graph-viewer {
-  position: relative;
-  width: 100%;
-  // height: 100vh;
-  height: 100%;
-  display: flex;
-  flex-direction: column;
-  background: var(--gray-10);
-}
-
-.control-panel {
-  background: var(--gray-10);
-  padding: 6px 16px; /* Reduced from 16px */
-  border-bottom: none;
-  display: flex;
-  gap: 12px; /* Reduced from 16px */
-  align-items: center;
-  flex-wrap: wrap;
-  z-index: 1000;
-}
-
-.database-section,
-.search-section,
-.filter-section,
-.stats-section {
-  display: flex;
-  align-items: center;
-  gap: 6px; /* Reduced from 8px */
-}
-
-.stats-section {
-  margin-left: auto;
-}
-
-.sigma-container {
-  flex: 1;
-  // background: var(--gray-0);
-  position: relative; /* 确保子元素可以相对于此容器定位 */
-  // border: 1px solid var(--main-20);
-  border-radius: 8px;
-  overflow: hidden;
-
-  &.loading {
-    pointer-events: none;
-  }
-}
-
-.graph-overlay-stats {
-  position: absolute;
-  left: 16px;
-  bottom: 16px;
-  display: flex;
-  gap: 8px;
-  pointer-events: none;
-  z-index: 1100;
-}
-
-.detail-panel {
-  position: absolute;
-  width: 240px; /* Reduced from 300px */
-  background: var(--gray-0);
-  border: 1px solid var(--gray-200);
-  border-radius: 6px; /* Reduced from 8px */
-  box-shadow: 0 3px 12px var(--shadow-1); /* Reduced shadow */
-  transition: box-shadow 0.2s ease;
-  cursor: move;
-  z-index: 1000;
-
-  &:hover {
-    box-shadow: 0 4px 16px var(--shadow-2); /* Reduced shadow */
-  }
-
-  &.node-panel {
-    border-left: 4px solid var(--color-success-500); // 绿色边框标识节点面板
-  }
-
-  &.edge-panel {
-    border-left: 4px solid var(--color-info-500); // 蓝色边框标识边面板
-  }
-}
-
-.detail-header {
-  display: flex;
-  align-items: center;
-  gap: 6px; /* Reduced from 8px */
-  padding: 8px 12px; /* Reduced from 12px 16px */
-  border-bottom: 1px solid var(--gray-150);
-  background: var(--gray-25);
-  border-radius: 6px 6px 0 0; /* Reduced from 8px */
-
-  h4 {
-    margin: 0;
-    font-size: 12px; /* Reduced from 14px */
-    font-weight: 600;
-    flex: 1;
-    color: var(--color-text);
-  }
-}
-
-.panel-type-indicator {
-  width: 6px; /* Reduced from 8px */
-  height: 6px;
-  border-radius: 50%;
-  flex-shrink: 0;
-
-  &.node-indicator {
-    background: var(--color-success-500);
-  }
-
-  &.edge-indicator {
-    background: var(--color-info-500);
-  }
-}
-
-.detail-content {
-  padding: 10px; /* Reduced from 16px */
-  max-height: 300px; /* Reduced from 400px */
-  overflow-y: auto;
-}
-
-.detail-item {
-  display: flex;
-  margin-bottom: 8px; /* Reduced from 12px */
-
-  &:last-child {
-    margin-bottom: 0;
-  }
-}
-
-.detail-label {
-  min-width: 50px; /* Reduced from 60px */
-  font-weight: 600;
-  color: var(--color-text-secondary);
-  font-size: 11px; /* Reduced from 12px */
-  flex-shrink: 0;
-}
-
-.detail-value {
-  color: var(--color-text);
-  font-size: 11px; /* Reduced from 12px */
-  word-break: break-word;
-  line-height: 1.3; /* Reduced from 1.4 */
-}
-
-.detail-actions {
-  margin-top: 12px; /* Reduced from 16px */
-  padding-top: 8px; /* Reduced from 12px */
-  border-top: 1px solid var(--gray-150);
-}
-
-.graph-controls {
-  position: absolute;
-  bottom: 16px; /* Reduced from 20px */
-  right: 16px;
-  z-index: 1000;
-}
-
-.control-group {
-  background: color-mix(in srgb, var(--color-bg-container) 80%, transparent);
-  backdrop-filter: blur(8px);
-  border: 2px solid var(--gray-0);
-  border-radius: 16px; /* Reduced from 20px */
-  padding: 2px; /* Reduced from 4px */
-  box-shadow: 0 2px 8px var(--shadow-1); /* Reduced shadow */
-  display: flex;
-  gap: 1px; /* Reduced from 2px */
-}
-
-.control-btn {
-  width: 28px; /* Reduced from 32px */
-  height: 28px;
-  border-radius: 14px; /* Reduced from 16px */
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  border: none;
-  background: transparent;
-  color: var(--color-text-secondary);
-  transition: all 0.2s ease;
-
-  &:hover {
-    background: color-mix(in srgb, var(--main-color) 10%, transparent);
-    color: var(--main-color);
-  }
-}
-
-.legend {
-  position: absolute;
-  right: 12px; /* Reduced from 16px */
-  top: 60px; /* Reduced from 80px */
-  background: color-mix(in srgb, var(--color-bg-container) 80%, transparent);
-  backdrop-filter: blur(8px);
-  border: 2px solid var(--gray-0);
-  border-radius: 6px; /* Reduced from 8px */
-  width: 150px; /* Reduced from 180px */
-  max-height: 250px; /* Reduced from 300px */
-  z-index: 1000;
-  box-shadow: 0 3px 12px var(--shadow-1); /* Reduced shadow */
-  overflow: hidden;
-}
-
-.legend-header {
-  background: var(--gray-25);
-  padding: 6px 10px; /* Reduced from 8px 12px */
-  border-bottom: 1px solid var(--gray-150);
-
-  h4 {
-    margin: 0;
-    font-size: 12px; /* Reduced from 13px */
-    font-weight: 600;
-    color: var(--color-text);
-  }
-}
-
-.legend-content {
-  padding: 6px 10px; /* Reduced from 8px 12px */
-  max-height: 200px; /* Reduced from 240px */
-  overflow-y: auto;
-  overflow-x: hidden;
-
-  /* 自定义滚动条样式 */
-  &::-webkit-scrollbar {
-    width: 3px; /* Reduced from 4px */
-  }
-
-  &::-webkit-scrollbar-track {
-    background: transparent;
-  }
-
-  &::-webkit-scrollbar-thumb {
-    background: var(--gray-300);
-    border-radius: 2px;
-
-    &:hover {
-      background: var(--gray-400);
-    }
-  }
-}
-
-.legend-item {
-  display: flex;
-  align-items: center;
-  gap: 6px; /* Reduced from 8px */
-  padding: 2px 4px; /* Reduced from 4px 6px */
-  margin: 1px 0; /* Reduced from 2px */
-  border-radius: 3px; /* Reduced from 4px */
-  font-size: 11px; /* Reduced from 12px */
-  min-width: 0;
-  transition: background-color 0.2s ease;
-
-  span {
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    flex: 1;
-    min-width: 0;
-    color: var(--color-text-secondary);
-  }
-
-  &:hover {
-    background-color: var(--gray-50);
-  }
-}
-
-.legend-color {
-  width: 8px; /* Reduced from 10px */
-  height: 8px;
-  border-radius: 50%;
-  border: 1px solid var(--shadow-1);
-  flex-shrink: 0;
-}
-
-.loading-overlay {
-  position: absolute;
-  inset: 0;
-  background: color-mix(in srgb, var(--color-bg-container) 80%, transparent);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  z-index: 2000;
-}
-
-.loading-content {
-  text-align: center;
-
-  p {
-    margin-top: 12px; /* Reduced from 16px */
-    color: var(--color-text-secondary);
-    font-size: 12px; /* Added smaller font size */
-  }
-}
-</style>
diff --git a/web/src/components/LightRAGInfoPanel.vue b/web/src/components/LightRAGInfoPanel.vue
new file mode 100644
index 00000000..2afad6f2
--- /dev/null
+++ b/web/src/components/LightRAGInfoPanel.vue
@@ -0,0 +1,74 @@
+<template>
+  <div class="lightrag-info-panel">
+    <div class="info-item">
+      <span class="info-label">节点</span>
+      <span class="info-value">{{ stats?.total_nodes || 0 }}</span>
+    </div>
+
+    <div class="info-item">
+      <span class="info-label">边</span>
+      <span class="info-value">{{ stats?.total_edges || 0 }}</span>
+    </div>
+
+    
+      </div>
+</template>
+
+<script setup>
+import { computed } from 'vue'
+
+const props = defineProps({
+  stats: {
+    type: Object,
+    default: () => ({})
+  },
+  graphData: {
+    type: Object,
+    default: () => ({ nodes: [], edges: [] })
+  },
+  databaseName: {
+    type: String,
+    default: ''
+  }
+})
+
+</script>
+
+<style lang="less" scoped>
+.lightrag-info-panel {
+  display: flex;
+  align-items: center;
+  gap: 24px;
+  padding: 8px 16px;
+  background: var(--gray-50);
+  backdrop-filter: blur(10px);
+  -webkit-backdrop-filter: blur(10px);
+  border-radius: 8px;
+  margin: 0;
+  border: 1px solid var(--gray-0);
+  flex-wrap: wrap;
+  align-self: flex-start;
+
+  @media (max-width: 768px) {
+    gap: 16px;
+    padding: 12px 16px;
+  }
+}
+
+.info-item {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 14px;
+}
+
+.info-label {
+  color: var(--gray-700);
+  font-weight: 500;
+}
+
+.info-value {
+  color: var(--gray-1000);
+  font-weight: 600;
+}
+</style>
\ No newline at end of file
diff --git a/web/src/composables/useGraph.js b/web/src/composables/useGraph.js
new file mode 100644
index 00000000..5a126848
--- /dev/null
+++ b/web/src/composables/useGraph.js
@@ -0,0 +1,72 @@
+import { ref, reactive, nextTick } from 'vue';
+
+export function useGraph(graphRef) {
+  const fetching = ref(false);
+  const showDetailDrawer = ref(false);
+  const selectedItem = ref(null);
+  const selectedItemType = ref(null);
+
+  const graphData = reactive({
+    nodes: [],
+    edges: [],
+  });
+
+  const handleNodeClick = (nodeData) => {
+    selectedItem.value = nodeData;
+    selectedItemType.value = 'node';
+    showDetailDrawer.value = true;
+    console.log('Node clicked:', nodeData);
+  };
+
+  const handleEdgeClick = (edgeData) => {
+    selectedItem.value = edgeData;
+    selectedItemType.value = 'edge';
+    showDetailDrawer.value = true;
+    console.log('Edge clicked:', edgeData);
+  };
+
+  const handleCanvasClick = () => {
+    showDetailDrawer.value = false;
+    selectedItem.value = null;
+    selectedItemType.value = null;
+    // Clear focus state on the graph component if available
+    if (graphRef && graphRef.value && graphRef.value.clearFocus) {
+      graphRef.value.clearFocus();
+    }
+  };
+
+  const clearGraph = () => {
+    graphData.nodes = [];
+    graphData.edges = [];
+    handleCanvasClick();
+  };
+
+  const updateGraphData = (nodes, edges) => {
+    graphData.nodes = nodes || [];
+    graphData.edges = edges || [];
+    // Refresh graph visual after data update
+    refreshGraph();
+  };
+
+  const refreshGraph = () => {
+    nextTick(() => {
+      if (graphRef && graphRef.value && graphRef.value.refreshGraph) {
+        graphRef.value.refreshGraph();
+      }
+    });
+  };
+
+  return {
+    fetching,
+    graphData,
+    showDetailDrawer,
+    selectedItem,
+    selectedItemType,
+    handleNodeClick,
+    handleEdgeClick,
+    handleCanvasClick,
+    clearGraph,
+    updateGraphData,
+    refreshGraph,
+  };
+}
diff --git a/web/src/views/GraphView.vue b/web/src/views/GraphView.vue
index 20b4ce88..32c5b6e7 100644
--- a/web/src/views/GraphView.vue
+++ b/web/src/views/GraphView.vue
@@ -13,14 +13,31 @@
       title="图数据库"
     >
       <template #actions>
+        <div class="db-selector">
         <div class="status-wrapper">
           <div class="status-indicator" :class="graphStatusClass"></div>
           <span class="status-text">{{ graphStatusText }}</span>
         </div>
-        <a-button type="default" @click="openLink('http://localhost:7474/')" :icon="h(GlobalOutlined)">
+          <span class="label">知识库: </span>
+          <a-select
+            v-model:value="state.selectedDbId"
+            style="width: 200px"
+            :options="state.dbOptions"
+            @change="handleDbChange"
+            :loading="state.loadingDatabases"
+          />
+        </div>
+        <!-- <a-button type="default" @click="openLink('http://localhost:7474/')" :icon="h(GlobalOutlined)">
           Neo4j 浏览器
-        </a-button>
-        <a-button type="primary" @click="state.showModal = true" ><UploadOutlined/> 上传文件</a-button>
+        </a-button> -->
+        <a-button
+          v-if="isNeo4j"
+          type="primary"
+          @click="state.showModal = true" ><UploadOutlined/> 上传文件</a-button>
+        <a-button
+          v-else
+          type="primary"
+          @click="state.showUploadTipModal = true" ><UploadOutlined/> 上传文件</a-button>
         <a-button v-if="unindexedCount > 0" type="primary" @click="indexNodes" :loading="state.indexing">
           <SyncOutlined v-if="!state.indexing"/> 为{{ unindexedCount }}个节点添加索引
         </a-button>
@@ -30,15 +47,18 @@
     <div class="container-outter">
       <GraphCanvas
         ref="graphRef"
-        :graph-data="graphData"
+        :graph-data="graph.graphData"
         :highlight-keywords="[state.searchInput]"
+        @node-click="graph.handleNodeClick"
+        @edge-click="graph.handleEdgeClick"
+        @canvas-click="graph.handleCanvasClick"
       >
         <template #top>
           <div class="actions">
             <div class="actions-left">
               <a-input
                 v-model:value="state.searchInput"
-                placeholder="输入要查询的实体"
+                :placeholder="isNeo4j ? '输入要查询的实体' : '输入要查询的实体 (*为全部)'"
                 style="width: 300px"
                 @keydown.enter="onSearch"
                 allow-clear
@@ -47,44 +67,62 @@
                   <component :is="state.searchLoading ? LoadingOutlined : SearchOutlined" @click="onSearch" />
                 </template>
               </a-input>
+              <a-input
+                v-model:value="sampleNodeCount"
+                placeholder="查询数量"
+                style="width: 100px"
+                @keydown.enter="loadSampleNodes"
+                :loading="graph.fetching"
+              >
+                <template #suffix>
+                  <component :is="graph.fetching ? LoadingOutlined : ReloadOutlined" @click="loadSampleNodes" />
+                </template>
+              </a-input>
             </div>
             <div class="actions-right">
+              <a-button type="default" @click="exportGraphData" :icon="h(ExportOutlined)">
+                导出数据
+              </a-button>
               <a-button type="default" @click="state.showInfoModal = true" :icon="h(InfoCircleOutlined)">
                 说明
               </a-button>
-              <a-input
-                v-model:value="sampleNodeCount"
-                placeholder="查询三元组数量"
-                style="width: 100px"
-                @keydown.enter="loadSampleNodes"
-                :loading="state.fetching"
-              >
-                <template #suffix>
-                  <component :is="state.fetching ? LoadingOutlined : ReloadOutlined" @click="loadSampleNodes" />
-                </template>
-              </a-input>
             </div>
           </div>
         </template>
         <template #content>
-          <a-empty v-show="graphData.nodes.length === 0" style="padding: 4rem 0;"/>
+          <a-empty v-show="graph.graphData.nodes.length === 0" style="padding: 4rem 0;"/>
         </template>
         <template #bottom>
           <div class="footer">
             <GraphInfoPanel
+              v-if="isNeo4j"
               :graph-info="graphInfo"
-              :graph-data="graphData"
+              :graph-data="graph.graphData"
               :unindexed-count="unindexedCount"
               :model-matched="modelMatched"
               @index-nodes="indexNodes"
-              @export-data="exportGraphData"
+            />
+            <LightRAGInfoPanel
+              v-else
+              :stats="state.lightragStats"
+              :graph-data="graph.graphData"
+              :database-name="getDatabaseName()"
             />
           </div>
         </template>
-      </GraphCanvas>
-    </div>
+        </GraphCanvas>
+        <!-- 详情浮动卡片 -->
+        <GraphDetailPanel
+          :visible="graph.showDetailDrawer"
+          :item="graph.selectedItem"
+          :type="graph.selectedItemType"
+          :nodes="graph.graphData.nodes"
+          @close="graph.handleCanvasClick"
+          style="width: 380px;"
+        />
+      </div>
 
-    <a-modal
+      <a-modal
       :open="state.showModal" title="上传文件"
       @ok="addDocumentByFile"
       @cancel="() => state.showModal = false"
@@ -114,6 +152,32 @@
       </div>
     </a-modal>
 
+    <!-- 上传提示弹窗 -->
+    <a-modal
+      :open="state.showUploadTipModal"
+      title="文件上传说明"
+      @cancel="() => state.showUploadTipModal = false"
+      :footer="null"
+      width="500px"
+    >
+      <div class="upload-tip-content">
+        <a-alert
+          :message="getUploadTipMessage()"
+          type="info"
+          show-icon
+          style="margin-bottom: 16px;"
+        />
+        <div v-if="!isNeo4j" class="upload-tip-actions">
+          <p>如需上传文档到当前选中的知识库，请前往对应的知识库详情页面进行操作：</p>
+          <div class="action-buttons">
+            <a-button type="primary" @click="goToDatabasePage">
+              <DatabaseOutlined/> 前往知识库详情页
+            </a-button>
+          </div>
+        </div>
+      </div>
+    </a-modal>
+
     <!-- 说明弹窗 -->
     <a-modal
       :open="state.showInfoModal"
@@ -122,7 +186,7 @@
       :footer="null"
       width="600px"
     >
-      <div class="info-content">
+      <div class="info-content" v-if="isNeo4j">
         <p>本页面展示的是 Neo4j 图数据库中的知识图谱信息。</p>
         <p>具体展示内容包括：</p>
         <ul>
@@ -132,15 +196,13 @@
         <p>注意：</p>
         <ul>
           <li>这里仅展示用户上传的实体和关系，不包含知识库中自动创建的图谱。</li>
-          <li>查询逻辑基于 <code>graphbase.py</code> 中的 <code>get_sample_nodes</code> 方法实现：</li>
+          <li>查询逻辑基于 <code>graphbase.py</code> 中的 <code>get_sample_nodes</code> 方法实现。</li>
         </ul>
-        <pre><code>MATCH (n:Entity)-[r]-&gt;(m:Entity)
-RETURN
-    {id: elementId(n), name: n.name} AS h,
-    {type: r.type, source_id: elementId(n), target_id: elementId(m)} AS r,
-    {id: elementId(m), name: m.name} AS t
-LIMIT $num</code></pre>
-        <p>如需查看完整的 Neo4j 数据库内容，请使用 "Neo4j 浏览器" 按钮访问原生界面。</p>
+      </div>
+      <div class="info-content" v-else>
+        <p>本页面展示的是 LightRAG 知识库生成的图谱信息。</p>
+        <p>数据来源于选定的知识库实例。</p>
+        <p>支持通过实体名称进行模糊搜索，输入 "*" 可查看采样全图。</p>
       </div>
     </a-modal>
   </div>
@@ -148,45 +210,103 @@ LIMIT $num</code></pre>
 
 <script setup>
 import { computed, onMounted, reactive, ref, h } from 'vue';
+import { useRouter } from 'vue-router';
 import { message } from 'ant-design-vue';
 import { useConfigStore } from '@/stores/config';
-import { UploadOutlined, SyncOutlined, GlobalOutlined, InfoCircleOutlined, SearchOutlined, ReloadOutlined, LoadingOutlined, HighlightOutlined } from '@ant-design/icons-vue';
+import { UploadOutlined, SyncOutlined, GlobalOutlined, InfoCircleOutlined, SearchOutlined, ReloadOutlined, LoadingOutlined, HighlightOutlined, DatabaseOutlined, ExportOutlined } from '@ant-design/icons-vue';
 import HeaderComponent from '@/components/HeaderComponent.vue';
-import { neo4jApi } from '@/apis/graph_api';
+import { neo4jApi, unifiedApi } from '@/apis/graph_api';
 import { useUserStore } from '@/stores/user';
 import GraphCanvas from '@/components/GraphCanvas.vue';
 import GraphInfoPanel from '@/components/GraphInfoPanel.vue';
+import LightRAGInfoPanel from '@/components/LightRAGInfoPanel.vue';
+import GraphDetailPanel from '@/components/GraphDetailPanel.vue';
+import UploadModal from '@/components/FileUploadModal.vue';
+import { useGraph } from '@/composables/useGraph';
 
 const configStore = useConfigStore();
 const cur_embed_model = computed(() => configStore.config?.embed_model);
 const modelMatched = computed(() => !graphInfo?.value?.embed_model_name || graphInfo.value.embed_model_name === cur_embed_model.value)
 
+const router = useRouter();
 const graphRef = ref(null)
 const graphInfo = ref(null)
 const fileList = ref([]);
 const sampleNodeCount = ref(100);
-const graphData = reactive({
-  nodes: [],
-  edges: [],
-});
+
+const graph = reactive(useGraph(graphRef));
 
 const state = reactive({
-  fetching: false,
   loadingGraphInfo: false,
+  loadingDatabases: false,
   searchInput: '',
   searchLoading: false,
   showModal: false,
   showInfoModal: false,
+  showUploadTipModal: false,
   processing: false,
   indexing: false,
   showPage: true,
+  selectedDbId: 'neo4j',
+  dbOptions: [],
+  lightragStats: null,
 })
 
+const isNeo4j = computed(() => state.selectedDbId === 'neo4j');
+
 // 计算未索引节点数量
 const unindexedCount = computed(() => {
   return graphInfo.value?.unindexed_node_count || 0;
 });
 
+const loadDatabases = async () => {
+  state.loadingDatabases = true;
+  try {
+    const res = await unifiedApi.getGraphs();
+    if (res.success && res.data) {
+      state.dbOptions = res.data.map(db => ({
+        label: `${db.name} (${db.type})`,
+        value: db.id,
+        type: db.type
+      }));
+
+      // If no selection or invalid selection, select first
+      if (!state.selectedDbId || !state.dbOptions.find(o => o.value === state.selectedDbId)) {
+        if (state.dbOptions.length > 0) {
+          state.selectedDbId = state.dbOptions[0].value;
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Failed to load databases:', error);
+  } finally {
+    state.loadingDatabases = false;
+  }
+};
+
+const handleDbChange = () => {
+  // Clear current data
+  graph.clearGraph();
+  state.searchInput = '';
+  state.lightragStats = null;
+
+  if (isNeo4j.value) {
+    loadGraphInfo();
+  } else {
+    // Also load stats for LightRAG
+    loadLightRAGStats();
+  }
+  loadSampleNodes();
+};
+
+const loadLightRAGStats = () => {
+  unifiedApi.getStats(state.selectedDbId).then(res => {
+    if(res.success) {
+      state.lightragStats = res.data;
+    }
+  }).catch(e => console.error(e));
+};
+
 const loadGraphInfo = () => {
   state.loadingGraphInfo = true
   neo4jApi.getInfo()
@@ -222,20 +342,24 @@ const addDocumentByFile = () => {
 };
 
 const loadSampleNodes = () => {
-  state.fetching = true
-  neo4jApi.getSampleNodes('neo4j', sampleNodeCount.value)
+  graph.fetching = true
+
+  unifiedApi.getSubgraph({
+    db_id: state.selectedDbId,
+    node_label: '*',
+    max_nodes: sampleNodeCount.value
+  })
     .then((data) => {
-      graphData.nodes = data.result.nodes
-      graphData.edges = data.result.edges
-      console.log(graphData)
-      // 初次加载后兜底刷新一次，避免容器初次可见尺寸未稳定
-      setTimeout(() => graphRef.value?.refreshGraph?.(), 500)
+      // Normalize data structure if needed
+      const result = data.data;
+      graph.updateGraphData(result.nodes, result.edges);
+      console.log(graph.graphData)
     })
     .catch((error) => {
       console.error(error)
       message.error(error.message || '加载节点失败');
     })
-    .finally(() => state.fetching = false)
+    .finally(() => graph.fetching = false)
 }
 
 const onSearch = () => {
@@ -244,29 +368,33 @@ const onSearch = () => {
     return
   }
 
-  if (graphInfo?.value?.embed_model_name !== cur_embed_model.value) {
+  if (isNeo4j.value && graphInfo?.value?.embed_model_name !== cur_embed_model.value) {
     // 可选：提示模型不一致
   }
 
-  if (!state.searchInput) {
+  if (!state.searchInput && isNeo4j.value) {
     message.error('请输入要查询的实体')
     return
   }
 
   state.searchLoading = true
-  neo4jApi.queryNode(state.searchInput)
+
+  unifiedApi.getSubgraph({
+    db_id: state.selectedDbId,
+    node_label: state.searchInput || '*',
+    max_nodes: sampleNodeCount.value
+  })
     .then((data) => {
-      if (!data.result || !data.result.nodes || !data.result.edges) {
+      const result = data.data;
+      if (!result || !result.nodes || !result.edges) {
         throw new Error('返回数据格式不正确');
       }
-      graphData.nodes = data.result.nodes
-      graphData.edges = data.result.edges
-      if (graphData.nodes.length === 0) {
+      graph.updateGraphData(result.nodes, result.edges);
+      if (graph.graphData.nodes.length === 0) {
         message.info('未找到相关实体')
       }
       console.log(data)
-      console.log(graphData)
-      graphRef.value?.refreshGraph?.()
+      console.log(graph.graphData)
     })
     .catch((error) => {
       console.error('查询错误:', error);
@@ -275,8 +403,9 @@ const onSearch = () => {
     .finally(() => state.searchLoading = false)
 };
 
-onMounted(() => {
-  loadGraphInfo();
+onMounted(async () => {
+  await loadDatabases();
+  loadGraphInfo(); // Load default (Neo4j) info
   loadSampleNodes();
 });
 
@@ -332,9 +461,10 @@ const indexNodes = () => {
 
 const exportGraphData = () => {
   const dataStr = JSON.stringify({
-    nodes: graphData.nodes,
-    edges: graphData.edges,
-    graphInfo: graphInfo.value,
+    nodes: graph.graphData.nodes,
+    edges: graph.graphData.edges,
+    graphInfo: isNeo4j.value ? graphInfo.value : state.lightragStats,
+    source: state.selectedDbId,
     exportTime: new Date().toISOString()
   }, null, 2);
 
@@ -342,7 +472,7 @@ const exportGraphData = () => {
   const url = URL.createObjectURL(dataBlob);
   const link = document.createElement('a');
   link.href = url;
-  link.download = `graph-data-${new Date().toISOString().slice(0, 10)}.json`;
+  link.download = `graph-data-${state.selectedDbId}-${new Date().toISOString().slice(0, 10)}.json`;
   document.body.appendChild(link);
   link.click();
   document.body.removeChild(link);
@@ -360,6 +490,38 @@ const openLink = (url) => {
   window.open(url, '_blank')
 }
 
+const getDatabaseName = () => {
+  const selectedDb = state.dbOptions.find(db => db.value === state.selectedDbId);
+  return selectedDb ? selectedDb.label : state.selectedDbId;
+};
+
+const getUploadTipMessage = () => {
+  if (isNeo4j.value) {
+    return 'Neo4j 图数据库支持通过上传 JSONL 格式文件直接导入实体和关系数据。';
+  } else {
+    const selectedDb = state.dbOptions.find(db => db.value === state.selectedDbId);
+    const dbType = selectedDb?.type || '未知';
+    const dbName = selectedDb?.label || getDatabaseName();
+    return `当前选择的是 ${dbType.toUpperCase()} 类型的知识库"${dbName}"，该类型知识库需要在文档知识库页面上传文档，系统会自动从中提取知识图谱。`;
+  }
+};
+
+const goToDatabasePage = () => {
+  state.showUploadTipModal = false;
+
+  // 如果不是 Neo4j，需要找到对应的知识库 ID 并跳转
+  if (!isNeo4j.value) {
+    const selectedDb = state.dbOptions.find(db => db.value === state.selectedDbId);
+    if (selectedDb && selectedDb.type !== 'neo4j') {
+      // 跳转到对应的知识库详情页面
+      router.push(`/database/${state.selectedDbId}`);
+    } else {
+      // 如果找不到对应的数据库，跳转到数据库列表页面
+      router.push('/database');
+    }
+  }
+};
+
 </script>
 
 <style lang="less" scoped>
@@ -374,6 +536,17 @@ const openLink = (url) => {
   }
 }
 
+.db-selector {
+  display: flex;
+  align-items: center;
+  margin-right: 20px;
+
+  .label {
+    font-size: 14px;
+    margin-right: 8px;
+  }
+}
+
 .status-wrapper {
   display: flex;
   align-items: center;
@@ -469,4 +642,19 @@ const openLink = (url) => {
     box-shadow: none;
   }
 }
-</style>
+
+.upload-tip-content {
+  .upload-tip-actions {
+    p {
+      margin-bottom: 16px;
+      color: var(--color-text-secondary);
+    }
+  }
+
+  .action-buttons {
+    display: flex;
+    justify-content: center;
+    margin-top: 20px;
+  }
+}
+</style>
\ No newline at end of file