Merge pull request #1367 from danielaskdd/add-graph-db-lock

Add graph_db_lock to ensure consistency across multiple processes for node and edge edition jobs

lightrag/api/__init__.py

@@ -1 +1 @@
-__api_version__ = "0149"
+__api_version__ = "0150"

lightrag/api/routers/graph_routes.py

@@ -2,14 +2,29 @@
 This module contains all graph-related routes for the LightRAG API.
 """
 
-from typing import Optional
-from fastapi import APIRouter, Depends, Query
+from typing import Optional, Dict, Any
+import traceback
+from fastapi import APIRouter, Depends, Query, HTTPException
+from pydantic import BaseModel
 
+from lightrag.utils import logger
 from ..utils_api import get_combined_auth_dependency
 
 router = APIRouter(tags=["graph"])
 
 
+class EntityUpdateRequest(BaseModel):
+    entity_name: str
+    updated_data: Dict[str, Any]
+    allow_rename: bool = False
+
+
+class RelationUpdateRequest(BaseModel):
+    source_id: str
+    target_id: str
+    updated_data: Dict[str, Any]
+
+
 def create_graph_routes(rag, api_key: Optional[str] = None):
     combined_auth = get_combined_auth_dependency(api_key)
 
@@ -21,7 +36,14 @@ def create_graph_routes(rag, api_key: Optional[str] = None):
         Returns:
             List[str]: List of graph labels
         """
-        return await rag.get_graph_labels()
+        try:
+            return await rag.get_graph_labels()
+        except Exception as e:
+            logger.error(f"Error getting graph labels: {str(e)}")
+            logger.error(traceback.format_exc())
+            raise HTTPException(
+                status_code=500, detail=f"Error getting graph labels: {str(e)}"
+            )
 
     @router.get("/graphs", dependencies=[Depends(combined_auth)])
     async def get_knowledge_graph(
@@ -43,10 +65,109 @@ def create_graph_routes(rag, api_key: Optional[str] = None):
         Returns:
             Dict[str, List[str]]: Knowledge graph for label
         """
-        return await rag.get_knowledge_graph(
-            node_label=label,
-            max_depth=max_depth,
-            max_nodes=max_nodes,
-        )
+        try:
+            return await rag.get_knowledge_graph(
+                node_label=label,
+                max_depth=max_depth,
+                max_nodes=max_nodes,
+            )
+        except Exception as e:
+            logger.error(f"Error getting knowledge graph for label '{label}': {str(e)}")
+            logger.error(traceback.format_exc())
+            raise HTTPException(
+                status_code=500, detail=f"Error getting knowledge graph: {str(e)}"
+            )
+
+    @router.get("/graph/entity/exists", dependencies=[Depends(combined_auth)])
+    async def check_entity_exists(
+        name: str = Query(..., description="Entity name to check"),
+    ):
+        """
+        Check if an entity with the given name exists in the knowledge graph
+
+        Args:
+            name (str): Name of the entity to check
+
+        Returns:
+            Dict[str, bool]: Dictionary with 'exists' key indicating if entity exists
+        """
+        try:
+            exists = await rag.chunk_entity_relation_graph.has_node(name)
+            return {"exists": exists}
+        except Exception as e:
+            logger.error(f"Error checking entity existence for '{name}': {str(e)}")
+            logger.error(traceback.format_exc())
+            raise HTTPException(
+                status_code=500, detail=f"Error checking entity existence: {str(e)}"
+            )
+
+    @router.post("/graph/entity/edit", dependencies=[Depends(combined_auth)])
+    async def update_entity(request: EntityUpdateRequest):
+        """
+        Update an entity's properties in the knowledge graph
+
+        Args:
+            request (EntityUpdateRequest): Request containing entity name, updated data, and rename flag
+
+        Returns:
+            Dict: Updated entity information
+        """
+        try:
+            result = await rag.aedit_entity(
+                entity_name=request.entity_name,
+                updated_data=request.updated_data,
+                allow_rename=request.allow_rename,
+            )
+            return {
+                "status": "success",
+                "message": "Entity updated successfully",
+                "data": result,
+            }
+        except ValueError as ve:
+            logger.error(
+                f"Validation error updating entity '{request.entity_name}': {str(ve)}"
+            )
+            raise HTTPException(status_code=400, detail=str(ve))
+        except Exception as e:
+            logger.error(f"Error updating entity '{request.entity_name}': {str(e)}")
+            logger.error(traceback.format_exc())
+            raise HTTPException(
+                status_code=500, detail=f"Error updating entity: {str(e)}"
+            )
+
+    @router.post("/graph/relation/edit", dependencies=[Depends(combined_auth)])
+    async def update_relation(request: RelationUpdateRequest):
+        """Update a relation's properties in the knowledge graph
+
+        Args:
+            request (RelationUpdateRequest): Request containing source ID, target ID and updated data
+
+        Returns:
+            Dict: Updated relation information
+        """
+        try:
+            result = await rag.aedit_relation(
+                source_entity=request.source_id,
+                target_entity=request.target_id,
+                updated_data=request.updated_data,
+            )
+            return {
+                "status": "success",
+                "message": "Relation updated successfully",
+                "data": result,
+            }
+        except ValueError as ve:
+            logger.error(
+                f"Validation error updating relation between '{request.source_id}' and '{request.target_id}': {str(ve)}"
+            )
+            raise HTTPException(status_code=400, detail=str(ve))
+        except Exception as e:
+            logger.error(
+                f"Error updating relation between '{request.source_id}' and '{request.target_id}': {str(e)}"
+            )
+            logger.error(traceback.format_exc())
+            raise HTTPException(
+                status_code=500, detail=f"Error updating relation: {str(e)}"
+            )
 
     return router

lightrag/lightrag.py

@@ -3,20 +3,22 @@ from __future__ import annotations
 import asyncio
 import configparser
 import os
-import csv
 import warnings
 from dataclasses import asdict, dataclass, field
 from datetime import datetime
 from functools import partial
 from typing import Any, AsyncIterator, Callable, Iterator, cast, final, Literal
-import pandas as pd
-
 
 from lightrag.kg import (
     STORAGES,
     verify_storage_implementation,
 )
 
+from lightrag.kg.shared_storage import (
+    get_namespace_data,
+    get_pipeline_status_lock,
+)
+
 from .base import (
     BaseGraphStorage,
     BaseKVStorage,
@@ -779,10 +781,6 @@ class LightRAG:
         3. Process each chunk for entity and relation extraction
         4. Update the document status
         """
-        from lightrag.kg.shared_storage import (
-            get_namespace_data,
-            get_pipeline_status_lock,
-        )
 
         # Get pipeline status shared data and lock
         pipeline_status = await get_namespace_data("pipeline_status")
@@ -1427,107 +1425,58 @@ class LightRAG:
     async def _query_done(self):
         await self.llm_response_cache.index_done_callback()
 
-    def delete_by_entity(self, entity_name: str) -> None:
-        loop = always_get_an_event_loop()
-        return loop.run_until_complete(self.adelete_by_entity(entity_name))
+    async def aclear_cache(self, modes: list[str] | None = None) -> None:
+        """Clear cache data from the LLM response cache storage.
 
-    # TODO: Lock all KG relative DB to esure consistency across multiple processes
-    async def adelete_by_entity(self, entity_name: str) -> None:
-        try:
-            await self.entities_vdb.delete_entity(entity_name)
-            await self.relationships_vdb.delete_entity_relation(entity_name)
-            await self.chunk_entity_relation_graph.delete_node(entity_name)
+        Args:
+            modes (list[str] | None): Modes of cache to clear. Options: ["default", "naive", "local", "global", "hybrid", "mix"].
+                             "default" represents extraction cache.
+                             If None, clears all cache.
 
-            logger.info(
-                f"Entity '{entity_name}' and its relationships have been deleted."
-            )
-            await self._delete_by_entity_done()
-        except Exception as e:
-            logger.error(f"Error while deleting entity '{entity_name}': {e}")
-
-    async def _delete_by_entity_done(self) -> None:
-        await asyncio.gather(
-            *[
-                cast(StorageNameSpace, storage_inst).index_done_callback()
-                for storage_inst in [  # type: ignore
-                    self.entities_vdb,
-                    self.relationships_vdb,
-                    self.chunk_entity_relation_graph,
-                ]
-            ]
-        )
+        Example:
+            # Clear all cache
+            await rag.aclear_cache()
 
-    def delete_by_relation(self, source_entity: str, target_entity: str) -> None:
-        """Synchronously delete a relation between two entities.
+            # Clear local mode cache
+            await rag.aclear_cache(modes=["local"])
 
-        Args:
-            source_entity: Name of the source entity
-            target_entity: Name of the target entity
+            # Clear extraction cache
+            await rag.aclear_cache(modes=["default"])
         """
-        loop = always_get_an_event_loop()
-        return loop.run_until_complete(
-            self.adelete_by_relation(source_entity, target_entity)
-        )
+        if not self.llm_response_cache:
+            logger.warning("No cache storage configured")
+            return
 
-    # TODO: Lock all KG relative DB to esure consistency across multiple processes
-    async def adelete_by_relation(self, source_entity: str, target_entity: str) -> None:
-        """Asynchronously delete a relation between two entities.
+        valid_modes = ["default", "naive", "local", "global", "hybrid", "mix"]
 
-        Args:
-            source_entity: Name of the source entity
-            target_entity: Name of the target entity
-        """
-        try:
-            # TODO: check if has_edge function works on reverse relation
-            # Check if the relation exists
-            edge_exists = await self.chunk_entity_relation_graph.has_edge(
-                source_entity, target_entity
-            )
-            if not edge_exists:
-                logger.warning(
-                    f"Relation from '{source_entity}' to '{target_entity}' does not exist"
-                )
-                return
+        # Validate input
+        if modes and not all(mode in valid_modes for mode in modes):
+            raise ValueError(f"Invalid mode. Valid modes are: {valid_modes}")
 
-            # Delete relation from vector database
-            relation_id = compute_mdhash_id(
-                source_entity + target_entity, prefix="rel-"
-            )
-            await self.relationships_vdb.delete([relation_id])
+        try:
+            # Reset the cache storage for specified mode
+            if modes:
+                success = await self.llm_response_cache.drop_cache_by_modes(modes)
+                if success:
+                    logger.info(f"Cleared cache for modes: {modes}")
+                else:
+                    logger.warning(f"Failed to clear cache for modes: {modes}")
+            else:
+                # Clear all modes
+                success = await self.llm_response_cache.drop_cache_by_modes(valid_modes)
+                if success:
+                    logger.info("Cleared all cache")
+                else:
+                    logger.warning("Failed to clear all cache")
 
-            # Delete relation from knowledge graph
-            await self.chunk_entity_relation_graph.remove_edges(
-                [(source_entity, target_entity)]
-            )
+            await self.llm_response_cache.index_done_callback()
 
-            logger.info(
-                f"Successfully deleted relation from '{source_entity}' to '{target_entity}'"
-            )
-            await self._delete_relation_done()
         except Exception as e:
-            logger.error(
-                f"Error while deleting relation from '{source_entity}' to '{target_entity}': {e}"
-            )
-
-    async def _delete_relation_done(self) -> None:
-        """Callback after relation deletion is complete"""
-        await asyncio.gather(
-            *[
-                cast(StorageNameSpace, storage_inst).index_done_callback()
-                for storage_inst in [  # type: ignore
-                    self.relationships_vdb,
-                    self.chunk_entity_relation_graph,
-                ]
-            ]
-        )
-
-    async def get_processing_status(self) -> dict[str, int]:
-        """Get current document processing status counts
+            logger.error(f"Error while clearing cache: {e}")
 
-        Returns:
-            Dict with counts for each status
-        """
-        return await self.doc_status.get_status_counts()
+    def clear_cache(self, modes: list[str] | None = None) -> None:
+        """Synchronous version of aclear_cache."""
+        return always_get_an_event_loop().run_until_complete(self.aclear_cache(modes))
 
     async def get_docs_by_status(
         self, status: DocStatus
@@ -1539,7 +1488,8 @@ class LightRAG:
         """
         return await self.doc_status.get_docs_by_status(status)
 
-    # TODO: Lock all KG relative DB to esure consistency across multiple processes
+    # TODO: Deprecated (Deleting documents can cause hallucinations in RAG.)
+    # Document delete is not working properly for most of the storage implementations.
     async def adelete_by_doc_id(self, doc_id: str) -> None:
         """Delete a document and all its related data
 
@@ -1796,109 +1746,82 @@ class LightRAG:
         except Exception as e:
             logger.error(f"Error while deleting document {doc_id}: {e}")
 
-    async def get_entity_info(
-        self, entity_name: str, include_vector_data: bool = False
-    ) -> dict[str, str | None | dict[str, str]]:
-        """Get detailed information of an entity"""
-
-        # Get information from the graph
-        node_data = await self.chunk_entity_relation_graph.get_node(entity_name)
-        source_id = node_data.get("source_id") if node_data else None
-
-        result: dict[str, str | None | dict[str, str]] = {
-            "entity_name": entity_name,
-            "source_id": source_id,
-            "graph_data": node_data,
-        }
-
-        # Optional: Get vector database information
-        if include_vector_data:
-            entity_id = compute_mdhash_id(entity_name, prefix="ent-")
-            vector_data = await self.entities_vdb.get_by_id(entity_id)
-            result["vector_data"] = vector_data
-
-        return result
+    async def adelete_by_entity(self, entity_name: str) -> None:
+        """Asynchronously delete an entity and all its relationships.
 
-    async def get_relation_info(
-        self, src_entity: str, tgt_entity: str, include_vector_data: bool = False
-    ) -> dict[str, str | None | dict[str, str]]:
-        """Get detailed information of a relationship"""
+        Args:
+            entity_name: Name of the entity to delete
+        """
+        from .utils_graph import adelete_by_entity
 
-        # Get information from the graph
-        edge_data = await self.chunk_entity_relation_graph.get_edge(
-            src_entity, tgt_entity
+        return await adelete_by_entity(
+            self.chunk_entity_relation_graph,
+            self.entities_vdb,
+            self.relationships_vdb,
+            entity_name,
         )
-        source_id = edge_data.get("source_id") if edge_data else None
-
-        result: dict[str, str | None | dict[str, str]] = {
-            "src_entity": src_entity,
-            "tgt_entity": tgt_entity,
-            "source_id": source_id,
-            "graph_data": edge_data,
-        }
 
-        # Optional: Get vector database information
-        if include_vector_data:
-            rel_id = compute_mdhash_id(src_entity + tgt_entity, prefix="rel-")
-            vector_data = await self.relationships_vdb.get_by_id(rel_id)
-            result["vector_data"] = vector_data
-
-        return result
+    def delete_by_entity(self, entity_name: str) -> None:
+        loop = always_get_an_event_loop()
+        return loop.run_until_complete(self.adelete_by_entity(entity_name))
 
-    async def aclear_cache(self, modes: list[str] | None = None) -> None:
-        """Clear cache data from the LLM response cache storage.
+    async def adelete_by_relation(self, source_entity: str, target_entity: str) -> None:
+        """Asynchronously delete a relation between two entities.
 
         Args:
-            modes (list[str] | None): Modes of cache to clear. Options: ["default", "naive", "local", "global", "hybrid", "mix"].
-                             "default" represents extraction cache.
-                             If None, clears all cache.
-
-        Example:
-            # Clear all cache
-            await rag.aclear_cache()
-
-            # Clear local mode cache
-            await rag.aclear_cache(modes=["local"])
-
-            # Clear extraction cache
-            await rag.aclear_cache(modes=["default"])
+            source_entity: Name of the source entity
+            target_entity: Name of the target entity
         """
-        if not self.llm_response_cache:
-            logger.warning("No cache storage configured")
-            return
+        from .utils_graph import adelete_by_relation
 
-        valid_modes = ["default", "naive", "local", "global", "hybrid", "mix"]
+        return await adelete_by_relation(
+            self.chunk_entity_relation_graph,
+            self.relationships_vdb,
+            source_entity,
+            target_entity,
+        )
 
-        # Validate input
-        if modes and not all(mode in valid_modes for mode in modes):
-            raise ValueError(f"Invalid mode. Valid modes are: {valid_modes}")
+    def delete_by_relation(self, source_entity: str, target_entity: str) -> None:
+        loop = always_get_an_event_loop()
+        return loop.run_until_complete(
+            self.adelete_by_relation(source_entity, target_entity)
+        )
 
-        try:
-            # Reset the cache storage for specified mode
-            if modes:
-                success = await self.llm_response_cache.drop_cache_by_modes(modes)
-                if success:
-                    logger.info(f"Cleared cache for modes: {modes}")
-                else:
-                    logger.warning(f"Failed to clear cache for modes: {modes}")
-            else:
-                # Clear all modes
-                success = await self.llm_response_cache.drop_cache_by_modes(valid_modes)
-                if success:
-                    logger.info("Cleared all cache")
-                else:
-                    logger.warning("Failed to clear all cache")
+    async def get_processing_status(self) -> dict[str, int]:
+        """Get current document processing status counts
 
-            await self.llm_response_cache.index_done_callback()
+        Returns:
+            Dict with counts for each status
+        """
+        return await self.doc_status.get_status_counts()
 
-        except Exception as e:
-            logger.error(f"Error while clearing cache: {e}")
+    async def get_entity_info(
+        self, entity_name: str, include_vector_data: bool = False
+    ) -> dict[str, str | None | dict[str, str]]:
+        """Get detailed information of an entity"""
+        from .utils_graph import get_entity_info
 
-    def clear_cache(self, modes: list[str] | None = None) -> None:
-        """Synchronous version of aclear_cache."""
-        return always_get_an_event_loop().run_until_complete(self.aclear_cache(modes))
+        return await get_entity_info(
+            self.chunk_entity_relation_graph,
+            self.entities_vdb,
+            entity_name,
+            include_vector_data,
+        )
+
+    async def get_relation_info(
+        self, src_entity: str, tgt_entity: str, include_vector_data: bool = False
+    ) -> dict[str, str | None | dict[str, str]]:
+        """Get detailed information of a relationship"""
+        from .utils_graph import get_relation_info
+
+        return await get_relation_info(
+            self.chunk_entity_relation_graph,
+            self.relationships_vdb,
+            src_entity,
+            tgt_entity,
+            include_vector_data,
+        )
 
-    # TODO: Lock all KG relative DB to esure consistency across multiple processes
     async def aedit_entity(
         self, entity_name: str, updated_data: dict[str, str], allow_rename: bool = True
     ) -> dict[str, Any]:
@@ -1914,204 +1837,25 @@ class LightRAG:
         Returns:
             Dictionary containing updated entity information
         """
-        try:
-            # 1. Get current entity information
-            node_exists = await self.chunk_entity_relation_graph.has_node(entity_name)
-            if not node_exists:
-                raise ValueError(f"Entity '{entity_name}' does not exist")
-            node_data = await self.chunk_entity_relation_graph.get_node(entity_name)
-
-            # Check if entity is being renamed
-            new_entity_name = updated_data.get("entity_name", entity_name)
-            is_renaming = new_entity_name != entity_name
-
-            # If renaming, check if new name already exists
-            if is_renaming:
-                if not allow_rename:
-                    raise ValueError(
-                        "Entity renaming is not allowed. Set allow_rename=True to enable this feature"
-                    )
-
-                existing_node = await self.chunk_entity_relation_graph.has_node(
-                    new_entity_name
-                )
-                if existing_node:
-                    raise ValueError(
-                        f"Entity name '{new_entity_name}' already exists, cannot rename"
-                    )
-
-            # 2. Update entity information in the graph
-            new_node_data = {**node_data, **updated_data}
-            new_node_data["entity_id"] = new_entity_name
-
-            if "entity_name" in new_node_data:
-                del new_node_data[
-                    "entity_name"
-                ]  # Node data should not contain entity_name field
-
-            # If renaming entity
-            if is_renaming:
-                logger.info(f"Renaming entity '{entity_name}' to '{new_entity_name}'")
-
-                # Create new entity
-                await self.chunk_entity_relation_graph.upsert_node(
-                    new_entity_name, new_node_data
-                )
-
-                # Store relationships that need to be updated
-                relations_to_update = []
-                relations_to_delete = []
-                # Get all edges related to the original entity
-                edges = await self.chunk_entity_relation_graph.get_node_edges(
-                    entity_name
-                )
-                if edges:
-                    # Recreate edges for the new entity
-                    for source, target in edges:
-                        edge_data = await self.chunk_entity_relation_graph.get_edge(
-                            source, target
-                        )
-                        if edge_data:
-                            relations_to_delete.append(
-                                compute_mdhash_id(source + target, prefix="rel-")
-                            )
-                            relations_to_delete.append(
-                                compute_mdhash_id(target + source, prefix="rel-")
-                            )
-                            if source == entity_name:
-                                await self.chunk_entity_relation_graph.upsert_edge(
-                                    new_entity_name, target, edge_data
-                                )
-                                relations_to_update.append(
-                                    (new_entity_name, target, edge_data)
-                                )
-                            else:  # target == entity_name
-                                await self.chunk_entity_relation_graph.upsert_edge(
-                                    source, new_entity_name, edge_data
-                                )
-                                relations_to_update.append(
-                                    (source, new_entity_name, edge_data)
-                                )
-
-                # Delete old entity
-                await self.chunk_entity_relation_graph.delete_node(entity_name)
-
-                # Delete old entity record from vector database
-                old_entity_id = compute_mdhash_id(entity_name, prefix="ent-")
-                await self.entities_vdb.delete([old_entity_id])
-                logger.info(
-                    f"Deleted old entity '{entity_name}' and its vector embedding from database"
-                )
-
-                # Delete old relation records from vector database
-                await self.relationships_vdb.delete(relations_to_delete)
-                logger.info(
-                    f"Deleted {len(relations_to_delete)} relation records for entity '{entity_name}' from vector database"
-                )
-
-                # Update relationship vector representations
-                for src, tgt, edge_data in relations_to_update:
-                    description = edge_data.get("description", "")
-                    keywords = edge_data.get("keywords", "")
-                    source_id = edge_data.get("source_id", "")
-                    weight = float(edge_data.get("weight", 1.0))
-
-                    # Create new content for embedding
-                    content = f"{src}\t{tgt}\n{keywords}\n{description}"
-
-                    # Calculate relationship ID
-                    relation_id = compute_mdhash_id(src + tgt, prefix="rel-")
-
-                    # Prepare data for vector database update
-                    relation_data = {
-                        relation_id: {
-                            "content": content,
-                            "src_id": src,
-                            "tgt_id": tgt,
-                            "source_id": source_id,
-                            "description": description,
-                            "keywords": keywords,
-                            "weight": weight,
-                        }
-                    }
-
-                    # Update vector database
-                    await self.relationships_vdb.upsert(relation_data)
-
-                # Update working entity name to new name
-                entity_name = new_entity_name
-            else:
-                # If not renaming, directly update node data
-                await self.chunk_entity_relation_graph.upsert_node(
-                    entity_name, new_node_data
-                )
-
-            # 3. Recalculate entity's vector representation and update vector database
-            description = new_node_data.get("description", "")
-            source_id = new_node_data.get("source_id", "")
-            entity_type = new_node_data.get("entity_type", "")
-            content = entity_name + "\n" + description
-
-            # Calculate entity ID
-            entity_id = compute_mdhash_id(entity_name, prefix="ent-")
-
-            # Prepare data for vector database update
-            entity_data = {
-                entity_id: {
-                    "content": content,
-                    "entity_name": entity_name,
-                    "source_id": source_id,
-                    "description": description,
-                    "entity_type": entity_type,
-                }
-            }
-
-            # Update vector database
-            await self.entities_vdb.upsert(entity_data)
-
-            # 4. Save changes
-            await self._edit_entity_done()
-
-            logger.info(f"Entity '{entity_name}' successfully updated")
-            return await self.get_entity_info(entity_name, include_vector_data=True)
-        except Exception as e:
-            logger.error(f"Error while editing entity '{entity_name}': {e}")
-            raise
+        from .utils_graph import aedit_entity
+
+        return await aedit_entity(
+            self.chunk_entity_relation_graph,
+            self.entities_vdb,
+            self.relationships_vdb,
+            entity_name,
+            updated_data,
+            allow_rename,
+        )
 
     def edit_entity(
         self, entity_name: str, updated_data: dict[str, str], allow_rename: bool = True
     ) -> dict[str, Any]:
-        """Synchronously edit entity information.
-
-        Updates entity information in the knowledge graph and re-embeds the entity in the vector database.
-
-        Args:
-            entity_name: Name of the entity to edit
-            updated_data: Dictionary containing updated attributes, e.g. {"description": "new description", "entity_type": "new type"}
-            allow_rename: Whether to allow entity renaming, defaults to True
-
-        Returns:
-            Dictionary containing updated entity information
-        """
         loop = always_get_an_event_loop()
         return loop.run_until_complete(
             self.aedit_entity(entity_name, updated_data, allow_rename)
         )
 
-    async def _edit_entity_done(self) -> None:
-        """Callback after entity editing is complete, ensures updates are persisted"""
-        await asyncio.gather(
-            *[
-                cast(StorageNameSpace, storage_inst).index_done_callback()
-                for storage_inst in [  # type: ignore
-                    self.entities_vdb,
-                    self.relationships_vdb,
-                    self.chunk_entity_relation_graph,
-                ]
-            ]
-        )
-
-    # TODO: Lock all KG relative DB to esure consistency across multiple processes
     async def aedit_relation(
         self, source_entity: str, target_entity: str, updated_data: dict[str, Any]
     ) -> dict[str, Any]:
@@ -2127,110 +1871,25 @@ class LightRAG:
         Returns:
             Dictionary containing updated relation information
         """
-        try:
-            # 1. Get current relation information
-            edge_exists = await self.chunk_entity_relation_graph.has_edge(
-                source_entity, target_entity
-            )
-            if not edge_exists:
-                raise ValueError(
-                    f"Relation from '{source_entity}' to '{target_entity}' does not exist"
-                )
-            edge_data = await self.chunk_entity_relation_graph.get_edge(
-                source_entity, target_entity
-            )
-            # Important: First delete the old relation record from the vector database
-            old_relation_id = compute_mdhash_id(
-                source_entity + target_entity, prefix="rel-"
-            )
-            await self.relationships_vdb.delete([old_relation_id])
-            logger.info(
-                f"Deleted old relation record from vector database for relation {source_entity} -> {target_entity}"
-            )
-
-            # 2. Update relation information in the graph
-            new_edge_data = {**edge_data, **updated_data}
-            await self.chunk_entity_relation_graph.upsert_edge(
-                source_entity, target_entity, new_edge_data
-            )
-
-            # 3. Recalculate relation's vector representation and update vector database
-            description = new_edge_data.get("description", "")
-            keywords = new_edge_data.get("keywords", "")
-            source_id = new_edge_data.get("source_id", "")
-            weight = float(new_edge_data.get("weight", 1.0))
-
-            # Create content for embedding
-            content = f"{source_entity}\t{target_entity}\n{keywords}\n{description}"
-
-            # Calculate relation ID
-            relation_id = compute_mdhash_id(
-                source_entity + target_entity, prefix="rel-"
-            )
-
-            # Prepare data for vector database update
-            relation_data = {
-                relation_id: {
-                    "content": content,
-                    "src_id": source_entity,
-                    "tgt_id": target_entity,
-                    "source_id": source_id,
-                    "description": description,
-                    "keywords": keywords,
-                    "weight": weight,
-                }
-            }
-
-            # Update vector database
-            await self.relationships_vdb.upsert(relation_data)
-
-            # 4. Save changes
-            await self._edit_relation_done()
-
-            logger.info(
-                f"Relation from '{source_entity}' to '{target_entity}' successfully updated"
-            )
-            return await self.get_relation_info(
-                source_entity, target_entity, include_vector_data=True
-            )
-        except Exception as e:
-            logger.error(
-                f"Error while editing relation from '{source_entity}' to '{target_entity}': {e}"
-            )
-            raise
+        from .utils_graph import aedit_relation
+
+        return await aedit_relation(
+            self.chunk_entity_relation_graph,
+            self.entities_vdb,
+            self.relationships_vdb,
+            source_entity,
+            target_entity,
+            updated_data,
+        )
 
     def edit_relation(
         self, source_entity: str, target_entity: str, updated_data: dict[str, Any]
     ) -> dict[str, Any]:
-        """Synchronously edit relation information.
-
-        Updates relation (edge) information in the knowledge graph and re-embeds the relation in the vector database.
-
-        Args:
-            source_entity: Name of the source entity
-            target_entity: Name of the target entity
-            updated_data: Dictionary containing updated attributes, e.g. {"description": "new description", "keywords": "keywords"}
-
-        Returns:
-            Dictionary containing updated relation information
-        """
         loop = always_get_an_event_loop()
         return loop.run_until_complete(
             self.aedit_relation(source_entity, target_entity, updated_data)
         )
 
-    async def _edit_relation_done(self) -> None:
-        """Callback after relation editing is complete, ensures updates are persisted"""
-        await asyncio.gather(
-            *[
-                cast(StorageNameSpace, storage_inst).index_done_callback()
-                for storage_inst in [  # type: ignore
-                    self.relationships_vdb,
-                    self.chunk_entity_relation_graph,
-                ]
-            ]
-        )
-
     async def acreate_entity(
         self, entity_name: str, entity_data: dict[str, Any]
     ) -> dict[str, Any]:
@@ -2245,68 +1904,19 @@ class LightRAG:
         Returns:
             Dictionary containing created entity information
         """
-        try:
-            # Check if entity already exists
-            existing_node = await self.chunk_entity_relation_graph.has_node(entity_name)
-            if existing_node:
-                raise ValueError(f"Entity '{entity_name}' already exists")
-
-            # Prepare node data with defaults if missing
-            node_data = {
-                "entity_id": entity_name,
-                "entity_type": entity_data.get("entity_type", "UNKNOWN"),
-                "description": entity_data.get("description", ""),
-                "source_id": entity_data.get("source_id", "manual"),
-            }
-
-            # Add entity to knowledge graph
-            await self.chunk_entity_relation_graph.upsert_node(entity_name, node_data)
-
-            # Prepare content for entity
-            description = node_data.get("description", "")
-            source_id = node_data.get("source_id", "")
-            entity_type = node_data.get("entity_type", "")
-            content = entity_name + "\n" + description
-
-            # Calculate entity ID
-            entity_id = compute_mdhash_id(entity_name, prefix="ent-")
-
-            # Prepare data for vector database update
-            entity_data_for_vdb = {
-                entity_id: {
-                    "content": content,
-                    "entity_name": entity_name,
-                    "source_id": source_id,
-                    "description": description,
-                    "entity_type": entity_type,
-                }
-            }
-
-            # Update vector database
-            await self.entities_vdb.upsert(entity_data_for_vdb)
-
-            # Save changes
-            await self._edit_entity_done()
-
-            logger.info(f"Entity '{entity_name}' successfully created")
-            return await self.get_entity_info(entity_name, include_vector_data=True)
-        except Exception as e:
-            logger.error(f"Error while creating entity '{entity_name}': {e}")
-            raise
+        from .utils_graph import acreate_entity
+
+        return await acreate_entity(
+            self.chunk_entity_relation_graph,
+            self.entities_vdb,
+            self.relationships_vdb,
+            entity_name,
+            entity_data,
+        )
 
     def create_entity(
         self, entity_name: str, entity_data: dict[str, Any]
     ) -> dict[str, Any]:
-        """Synchronously create a new entity.
-
-        Creates a new entity in the knowledge graph and adds it to the vector database.
-        Args:
-            entity_name: Name of the new entity
-            entity_data: Dictionary containing entity attributes, e.g. {"description": "description", "entity_type": "type"}
-
-        Returns:
-            Dictionary containing created entity information
-        """
         loop = always_get_an_event_loop()
         return loop.run_until_complete(self.acreate_entity(entity_name, entity_data))
 
@@ -2325,108 +1935,25 @@ class LightRAG:
         Returns:
             Dictionary containing created relation information
         """
-        try:
-            # Check if both entities exist
-            source_exists = await self.chunk_entity_relation_graph.has_node(
-                source_entity
-            )
-            target_exists = await self.chunk_entity_relation_graph.has_node(
-                target_entity
-            )
-
-            if not source_exists:
-                raise ValueError(f"Source entity '{source_entity}' does not exist")
-            if not target_exists:
-                raise ValueError(f"Target entity '{target_entity}' does not exist")
-
-            # Check if relation already exists
-            existing_edge = await self.chunk_entity_relation_graph.has_edge(
-                source_entity, target_entity
-            )
-            if existing_edge:
-                raise ValueError(
-                    f"Relation from '{source_entity}' to '{target_entity}' already exists"
-                )
-
-            # Prepare edge data with defaults if missing
-            edge_data = {
-                "description": relation_data.get("description", ""),
-                "keywords": relation_data.get("keywords", ""),
-                "source_id": relation_data.get("source_id", "manual"),
-                "weight": float(relation_data.get("weight", 1.0)),
-            }
-
-            # Add relation to knowledge graph
-            await self.chunk_entity_relation_graph.upsert_edge(
-                source_entity, target_entity, edge_data
-            )
-
-            # Prepare content for embedding
-            description = edge_data.get("description", "")
-            keywords = edge_data.get("keywords", "")
-            source_id = edge_data.get("source_id", "")
-            weight = edge_data.get("weight", 1.0)
-
-            # Create content for embedding
-            content = f"{keywords}\t{source_entity}\n{target_entity}\n{description}"
-
-            # Calculate relation ID
-            relation_id = compute_mdhash_id(
-                source_entity + target_entity, prefix="rel-"
-            )
-
-            # Prepare data for vector database update
-            relation_data_for_vdb = {
-                relation_id: {
-                    "content": content,
-                    "src_id": source_entity,
-                    "tgt_id": target_entity,
-                    "source_id": source_id,
-                    "description": description,
-                    "keywords": keywords,
-                    "weight": weight,
-                }
-            }
-
-            # Update vector database
-            await self.relationships_vdb.upsert(relation_data_for_vdb)
-
-            # Save changes
-            await self._edit_relation_done()
-
-            logger.info(
-                f"Relation from '{source_entity}' to '{target_entity}' successfully created"
-            )
-            return await self.get_relation_info(
-                source_entity, target_entity, include_vector_data=True
-            )
-        except Exception as e:
-            logger.error(
-                f"Error while creating relation from '{source_entity}' to '{target_entity}': {e}"
-            )
-            raise
+        from .utils_graph import acreate_relation
+
+        return await acreate_relation(
+            self.chunk_entity_relation_graph,
+            self.entities_vdb,
+            self.relationships_vdb,
+            source_entity,
+            target_entity,
+            relation_data,
+        )
 
     def create_relation(
         self, source_entity: str, target_entity: str, relation_data: dict[str, Any]
     ) -> dict[str, Any]:
-        """Synchronously create a new relation between entities.
-
-        Creates a new relation (edge) in the knowledge graph and adds it to the vector database.
-
-        Args:
-            source_entity: Name of the source entity
-            target_entity: Name of the target entity
-            relation_data: Dictionary containing relation attributes, e.g. {"description": "description", "keywords": "keywords"}
-
-        Returns:
-            Dictionary containing created relation information
-        """
         loop = always_get_an_event_loop()
         return loop.run_until_complete(
             self.acreate_relation(source_entity, target_entity, relation_data)
         )
 
-    # TODO: Lock all KG relative DB to esure consistency across multiple processes
     async def amerge_entities(
         self,
         source_entities: list[str],
@@ -2454,221 +1981,31 @@ class LightRAG:
         Returns:
             Dictionary containing the merged entity information
         """
-        try:
-            # Default merge strategy
-            default_strategy = {
-                "description": "concatenate",
-                "entity_type": "keep_first",
-                "source_id": "join_unique",
-            }
-
-            merge_strategy = (
-                default_strategy
-                if merge_strategy is None
-                else {**default_strategy, **merge_strategy}
-            )
-            target_entity_data = (
-                {} if target_entity_data is None else target_entity_data
-            )
-
-            # 1. Check if all source entities exist
-            source_entities_data = {}
-            for entity_name in source_entities:
-                node_exists = await self.chunk_entity_relation_graph.has_node(
-                    entity_name
-                )
-                if not node_exists:
-                    raise ValueError(f"Source entity '{entity_name}' does not exist")
-                node_data = await self.chunk_entity_relation_graph.get_node(entity_name)
-                source_entities_data[entity_name] = node_data
-
-            # 2. Check if target entity exists and get its data if it does
-            target_exists = await self.chunk_entity_relation_graph.has_node(
-                target_entity
-            )
-            existing_target_entity_data = {}
-            if target_exists:
-                existing_target_entity_data = (
-                    await self.chunk_entity_relation_graph.get_node(target_entity)
-                )
-                logger.info(
-                    f"Target entity '{target_entity}' already exists, will merge data"
-                )
-
-            # 3. Merge entity data
-            merged_entity_data = self._merge_entity_attributes(
-                list(source_entities_data.values())
-                + ([existing_target_entity_data] if target_exists else []),
-                merge_strategy,
-            )
-
-            # Apply any explicitly provided target entity data (overrides merged data)
-            for key, value in target_entity_data.items():
-                merged_entity_data[key] = value
-
-            # 4. Get all relationships of the source entities
-            all_relations = []
-            for entity_name in source_entities:
-                # Get all relationships of the source entities
-                edges = await self.chunk_entity_relation_graph.get_node_edges(
-                    entity_name
-                )
-                if edges:
-                    for src, tgt in edges:
-                        # Ensure src is the current entity
-                        if src == entity_name:
-                            edge_data = await self.chunk_entity_relation_graph.get_edge(
-                                src, tgt
-                            )
-                            all_relations.append((src, tgt, edge_data))
-
-            # 5. Create or update the target entity
-            merged_entity_data["entity_id"] = target_entity
-            if not target_exists:
-                await self.chunk_entity_relation_graph.upsert_node(
-                    target_entity, merged_entity_data
-                )
-                logger.info(f"Created new target entity '{target_entity}'")
-            else:
-                await self.chunk_entity_relation_graph.upsert_node(
-                    target_entity, merged_entity_data
-                )
-                logger.info(f"Updated existing target entity '{target_entity}'")
-
-            # 6. Recreate all relationships, pointing to the target entity
-            relation_updates = {}  # Track relationships that need to be merged
-            relations_to_delete = []
-
-            for src, tgt, edge_data in all_relations:
-                relations_to_delete.append(compute_mdhash_id(src + tgt, prefix="rel-"))
-                relations_to_delete.append(compute_mdhash_id(tgt + src, prefix="rel-"))
-                new_src = target_entity if src in source_entities else src
-                new_tgt = target_entity if tgt in source_entities else tgt
-
-                # Skip relationships between source entities to avoid self-loops
-                if new_src == new_tgt:
-                    logger.info(
-                        f"Skipping relationship between source entities: {src} -> {tgt} to avoid self-loop"
-                    )
-                    continue
-
-                # Check if the same relationship already exists
-                relation_key = f"{new_src}|{new_tgt}"
-                if relation_key in relation_updates:
-                    # Merge relationship data
-                    existing_data = relation_updates[relation_key]["data"]
-                    merged_relation = self._merge_relation_attributes(
-                        [existing_data, edge_data],
-                        {
-                            "description": "concatenate",
-                            "keywords": "join_unique",
-                            "source_id": "join_unique",
-                            "weight": "max",
-                        },
-                    )
-                    relation_updates[relation_key]["data"] = merged_relation
-                    logger.info(
-                        f"Merged duplicate relationship: {new_src} -> {new_tgt}"
-                    )
-                else:
-                    relation_updates[relation_key] = {
-                        "src": new_src,
-                        "tgt": new_tgt,
-                        "data": edge_data.copy(),
-                    }
-
-            # Apply relationship updates
-            for rel_data in relation_updates.values():
-                await self.chunk_entity_relation_graph.upsert_edge(
-                    rel_data["src"], rel_data["tgt"], rel_data["data"]
-                )
-                logger.info(
-                    f"Created or updated relationship: {rel_data['src']} -> {rel_data['tgt']}"
-                )
-
-                # Delete relationships records from vector database
-                await self.relationships_vdb.delete(relations_to_delete)
-                logger.info(
-                    f"Deleted {len(relations_to_delete)} relation records for entity '{entity_name}' from vector database"
-                )
-
-            # 7. Update entity vector representation
-            description = merged_entity_data.get("description", "")
-            source_id = merged_entity_data.get("source_id", "")
-            entity_type = merged_entity_data.get("entity_type", "")
-            content = target_entity + "\n" + description
-
-            entity_id = compute_mdhash_id(target_entity, prefix="ent-")
-            entity_data_for_vdb = {
-                entity_id: {
-                    "content": content,
-                    "entity_name": target_entity,
-                    "source_id": source_id,
-                    "description": description,
-                    "entity_type": entity_type,
-                }
-            }
-
-            await self.entities_vdb.upsert(entity_data_for_vdb)
-
-            # 8. Update relationship vector representations
-            for rel_data in relation_updates.values():
-                src = rel_data["src"]
-                tgt = rel_data["tgt"]
-                edge_data = rel_data["data"]
-
-                description = edge_data.get("description", "")
-                keywords = edge_data.get("keywords", "")
-                source_id = edge_data.get("source_id", "")
-                weight = float(edge_data.get("weight", 1.0))
-
-                content = f"{keywords}\t{src}\n{tgt}\n{description}"
-                relation_id = compute_mdhash_id(src + tgt, prefix="rel-")
-
-                relation_data_for_vdb = {
-                    relation_id: {
-                        "content": content,
-                        "src_id": src,
-                        "tgt_id": tgt,
-                        "source_id": source_id,
-                        "description": description,
-                        "keywords": keywords,
-                        "weight": weight,
-                    }
-                }
-
-                await self.relationships_vdb.upsert(relation_data_for_vdb)
-
-            # 9. Delete source entities
-            for entity_name in source_entities:
-                if entity_name == target_entity:
-                    logger.info(
-                        f"Skipping deletion of '{entity_name}' as it's also the target entity"
-                    )
-                    continue
-
-                # Delete entity node from knowledge graph
-                await self.chunk_entity_relation_graph.delete_node(entity_name)
-
-                # Delete entity record from vector database
-                entity_id = compute_mdhash_id(entity_name, prefix="ent-")
-                await self.entities_vdb.delete([entity_id])
-
-                logger.info(
-                    f"Deleted source entity '{entity_name}' and its vector embedding from database"
-                )
-
-            # 10. Save changes
-            await self._merge_entities_done()
+        from .utils_graph import amerge_entities
+
+        return await amerge_entities(
+            self.chunk_entity_relation_graph,
+            self.entities_vdb,
+            self.relationships_vdb,
+            source_entities,
+            target_entity,
+            merge_strategy,
+            target_entity_data,
+        )
 
-            logger.info(
-                f"Successfully merged {len(source_entities)} entities into '{target_entity}'"
+    def merge_entities(
+        self,
+        source_entities: list[str],
+        target_entity: str,
+        merge_strategy: dict[str, str] = None,
+        target_entity_data: dict[str, Any] = None,
+    ) -> dict[str, Any]:
+        loop = always_get_an_event_loop()
+        return loop.run_until_complete(
+            self.amerge_entities(
+                source_entities, target_entity, merge_strategy, target_entity_data
             )
-            return await self.get_entity_info(target_entity, include_vector_data=True)
-
-        except Exception as e:
-            logger.error(f"Error merging entities: {e}")
-            raise
+        )
 
     async def aexport_data(
         self,
@@ -2688,275 +2025,16 @@ class LightRAG:
                 - table: Print formatted tables to console
             include_vector_data: Whether to include data from the vector database.
         """
-        # Collect data
-        entities_data = []
-        relations_data = []
-        relationships_data = []
-
-        # --- Entities ---
-        all_entities = await self.chunk_entity_relation_graph.get_all_labels()
-        for entity_name in all_entities:
-            entity_info = await self.get_entity_info(
-                entity_name, include_vector_data=include_vector_data
-            )
-            entity_row = {
-                "entity_name": entity_name,
-                "source_id": entity_info["source_id"],
-                "graph_data": str(
-                    entity_info["graph_data"]
-                ),  # Convert to string to ensure compatibility
-            }
-            if include_vector_data and "vector_data" in entity_info:
-                entity_row["vector_data"] = str(entity_info["vector_data"])
-            entities_data.append(entity_row)
-
-        # --- Relations ---
-        for src_entity in all_entities:
-            for tgt_entity in all_entities:
-                if src_entity == tgt_entity:
-                    continue
-
-                edge_exists = await self.chunk_entity_relation_graph.has_edge(
-                    src_entity, tgt_entity
-                )
-                if edge_exists:
-                    relation_info = await self.get_relation_info(
-                        src_entity, tgt_entity, include_vector_data=include_vector_data
-                    )
-                    relation_row = {
-                        "src_entity": src_entity,
-                        "tgt_entity": tgt_entity,
-                        "source_id": relation_info["source_id"],
-                        "graph_data": str(
-                            relation_info["graph_data"]
-                        ),  # Convert to string
-                    }
-                    if include_vector_data and "vector_data" in relation_info:
-                        relation_row["vector_data"] = str(relation_info["vector_data"])
-                    relations_data.append(relation_row)
-
-        # --- Relationships (from VectorDB) ---
-        all_relationships = await self.relationships_vdb.client_storage
-        for rel in all_relationships["data"]:
-            relationships_data.append(
-                {
-                    "relationship_id": rel["__id__"],
-                    "data": str(rel),  # Convert to string for compatibility
-                }
-            )
-
-        # Export based on format
-        if file_format == "csv":
-            # CSV export
-            with open(output_path, "w", newline="", encoding="utf-8") as csvfile:
-                # Entities
-                if entities_data:
-                    csvfile.write("# ENTITIES\n")
-                    writer = csv.DictWriter(csvfile, fieldnames=entities_data[0].keys())
-                    writer.writeheader()
-                    writer.writerows(entities_data)
-                    csvfile.write("\n\n")
-
-                # Relations
-                if relations_data:
-                    csvfile.write("# RELATIONS\n")
-                    writer = csv.DictWriter(
-                        csvfile, fieldnames=relations_data[0].keys()
-                    )
-                    writer.writeheader()
-                    writer.writerows(relations_data)
-                    csvfile.write("\n\n")
-
-                # Relationships
-                if relationships_data:
-                    csvfile.write("# RELATIONSHIPS\n")
-                    writer = csv.DictWriter(
-                        csvfile, fieldnames=relationships_data[0].keys()
-                    )
-                    writer.writeheader()
-                    writer.writerows(relationships_data)
-
-        elif file_format == "excel":
-            # Excel export
-            entities_df = (
-                pd.DataFrame(entities_data) if entities_data else pd.DataFrame()
-            )
-            relations_df = (
-                pd.DataFrame(relations_data) if relations_data else pd.DataFrame()
-            )
-            relationships_df = (
-                pd.DataFrame(relationships_data)
-                if relationships_data
-                else pd.DataFrame()
-            )
-
-            with pd.ExcelWriter(output_path, engine="xlsxwriter") as writer:
-                if not entities_df.empty:
-                    entities_df.to_excel(writer, sheet_name="Entities", index=False)
-                if not relations_df.empty:
-                    relations_df.to_excel(writer, sheet_name="Relations", index=False)
-                if not relationships_df.empty:
-                    relationships_df.to_excel(
-                        writer, sheet_name="Relationships", index=False
-                    )
-
-        elif file_format == "md":
-            # Markdown export
-            with open(output_path, "w", encoding="utf-8") as mdfile:
-                mdfile.write("# LightRAG Data Export\n\n")
-
-                # Entities
-                mdfile.write("## Entities\n\n")
-                if entities_data:
-                    # Write header
-                    mdfile.write("| " + " | ".join(entities_data[0].keys()) + " |\n")
-                    mdfile.write(
-                        "| "
-                        + " | ".join(["---"] * len(entities_data[0].keys()))
-                        + " |\n"
-                    )
-
-                    # Write rows
-                    for entity in entities_data:
-                        mdfile.write(
-                            "| " + " | ".join(str(v) for v in entity.values()) + " |\n"
-                        )
-                    mdfile.write("\n\n")
-                else:
-                    mdfile.write("*No entity data available*\n\n")
-
-                # Relations
-                mdfile.write("## Relations\n\n")
-                if relations_data:
-                    # Write header
-                    mdfile.write("| " + " | ".join(relations_data[0].keys()) + " |\n")
-                    mdfile.write(
-                        "| "
-                        + " | ".join(["---"] * len(relations_data[0].keys()))
-                        + " |\n"
-                    )
-
-                    # Write rows
-                    for relation in relations_data:
-                        mdfile.write(
-                            "| "
-                            + " | ".join(str(v) for v in relation.values())
-                            + " |\n"
-                        )
-                    mdfile.write("\n\n")
-                else:
-                    mdfile.write("*No relation data available*\n\n")
-
-                # Relationships
-                mdfile.write("## Relationships\n\n")
-                if relationships_data:
-                    # Write header
-                    mdfile.write(
-                        "| " + " | ".join(relationships_data[0].keys()) + " |\n"
-                    )
-                    mdfile.write(
-                        "| "
-                        + " | ".join(["---"] * len(relationships_data[0].keys()))
-                        + " |\n"
-                    )
-
-                    # Write rows
-                    for relationship in relationships_data:
-                        mdfile.write(
-                            "| "
-                            + " | ".join(str(v) for v in relationship.values())
-                            + " |\n"
-                        )
-                else:
-                    mdfile.write("*No relationship data available*\n\n")
-
-        elif file_format == "txt":
-            # Plain text export
-            with open(output_path, "w", encoding="utf-8") as txtfile:
-                txtfile.write("LIGHTRAG DATA EXPORT\n")
-                txtfile.write("=" * 80 + "\n\n")
-
-                # Entities
-                txtfile.write("ENTITIES\n")
-                txtfile.write("-" * 80 + "\n")
-                if entities_data:
-                    # Create fixed width columns
-                    col_widths = {
-                        k: max(len(k), max(len(str(e[k])) for e in entities_data))
-                        for k in entities_data[0]
-                    }
-                    header = "  ".join(k.ljust(col_widths[k]) for k in entities_data[0])
-                    txtfile.write(header + "\n")
-                    txtfile.write("-" * len(header) + "\n")
-
-                    # Write rows
-                    for entity in entities_data:
-                        row = "  ".join(
-                            str(v).ljust(col_widths[k]) for k, v in entity.items()
-                        )
-                        txtfile.write(row + "\n")
-                    txtfile.write("\n\n")
-                else:
-                    txtfile.write("No entity data available\n\n")
-
-                # Relations
-                txtfile.write("RELATIONS\n")
-                txtfile.write("-" * 80 + "\n")
-                if relations_data:
-                    # Create fixed width columns
-                    col_widths = {
-                        k: max(len(k), max(len(str(r[k])) for r in relations_data))
-                        for k in relations_data[0]
-                    }
-                    header = "  ".join(
-                        k.ljust(col_widths[k]) for k in relations_data[0]
-                    )
-                    txtfile.write(header + "\n")
-                    txtfile.write("-" * len(header) + "\n")
-
-                    # Write rows
-                    for relation in relations_data:
-                        row = "  ".join(
-                            str(v).ljust(col_widths[k]) for k, v in relation.items()
-                        )
-                        txtfile.write(row + "\n")
-                    txtfile.write("\n\n")
-                else:
-                    txtfile.write("No relation data available\n\n")
-
-                # Relationships
-                txtfile.write("RELATIONSHIPS\n")
-                txtfile.write("-" * 80 + "\n")
-                if relationships_data:
-                    # Create fixed width columns
-                    col_widths = {
-                        k: max(len(k), max(len(str(r[k])) for r in relationships_data))
-                        for k in relationships_data[0]
-                    }
-                    header = "  ".join(
-                        k.ljust(col_widths[k]) for k in relationships_data[0]
-                    )
-                    txtfile.write(header + "\n")
-                    txtfile.write("-" * len(header) + "\n")
-
-                    # Write rows
-                    for relationship in relationships_data:
-                        row = "  ".join(
-                            str(v).ljust(col_widths[k]) for k, v in relationship.items()
-                        )
-                        txtfile.write(row + "\n")
-                else:
-                    txtfile.write("No relationship data available\n\n")
-
-        else:
-            raise ValueError(
-                f"Unsupported file format: {file_format}. "
-                f"Choose from: csv, excel, md, txt"
-            )
-        if file_format is not None:
-            print(f"Data exported to: {output_path} with format: {file_format}")
-        else:
-            print("Data displayed as table format")
+        from .utils import aexport_data as utils_aexport_data
+
+        await utils_aexport_data(
+            self.chunk_entity_relation_graph,
+            self.entities_vdb,
+            self.relationships_vdb,
+            output_path,
+            file_format,
+            include_vector_data,
+        )
 
     def export_data(
         self,
@@ -2985,153 +2063,3 @@ class LightRAG:
         loop.run_until_complete(
             self.aexport_data(output_path, file_format, include_vector_data)
         )
-
-    def merge_entities(
-        self,
-        source_entities: list[str],
-        target_entity: str,
-        merge_strategy: dict[str, str] = None,
-        target_entity_data: dict[str, Any] = None,
-    ) -> dict[str, Any]:
-        """Synchronously merge multiple entities into one entity.
-
-        Merges multiple source entities into a target entity, handling all relationships,
-        and updating both the knowledge graph and vector database.
-
-        Args:
-            source_entities: List of source entity names to merge
-            target_entity: Name of the target entity after merging
-            merge_strategy: Merge strategy configuration, e.g. {"description": "concatenate", "entity_type": "keep_first"}
-            target_entity_data: Dictionary of specific values to set for the target entity,
-                overriding any merged values, e.g. {"description": "custom description", "entity_type": "PERSON"}
-
-        Returns:
-            Dictionary containing the merged entity information
-        """
-        loop = always_get_an_event_loop()
-        return loop.run_until_complete(
-            self.amerge_entities(
-                source_entities, target_entity, merge_strategy, target_entity_data
-            )
-        )
-
-    def _merge_entity_attributes(
-        self, entity_data_list: list[dict[str, Any]], merge_strategy: dict[str, str]
-    ) -> dict[str, Any]:
-        """Merge attributes from multiple entities.
-
-        Args:
-            entity_data_list: List of dictionaries containing entity data
-            merge_strategy: Merge strategy for each field
-
-        Returns:
-            Dictionary containing merged entity data
-        """
-        merged_data = {}
-
-        # Collect all possible keys
-        all_keys = set()
-        for data in entity_data_list:
-            all_keys.update(data.keys())
-
-        # Merge values for each key
-        for key in all_keys:
-            # Get all values for this key
-            values = [data.get(key) for data in entity_data_list if data.get(key)]
-
-            if not values:
-                continue
-
-            # Merge values according to strategy
-            strategy = merge_strategy.get(key, "keep_first")
-
-            if strategy == "concatenate":
-                merged_data[key] = "\n\n".join(values)
-            elif strategy == "keep_first":
-                merged_data[key] = values[0]
-            elif strategy == "keep_last":
-                merged_data[key] = values[-1]
-            elif strategy == "join_unique":
-                # Handle fields separated by GRAPH_FIELD_SEP
-                unique_items = set()
-                for value in values:
-                    items = value.split(GRAPH_FIELD_SEP)
-                    unique_items.update(items)
-                merged_data[key] = GRAPH_FIELD_SEP.join(unique_items)
-            else:
-                # Default strategy
-                merged_data[key] = values[0]
-
-        return merged_data
-
-    def _merge_relation_attributes(
-        self, relation_data_list: list[dict[str, Any]], merge_strategy: dict[str, str]
-    ) -> dict[str, Any]:
-        """Merge attributes from multiple relationships.
-
-        Args:
-            relation_data_list: List of dictionaries containing relationship data
-            merge_strategy: Merge strategy for each field
-
-        Returns:
-            Dictionary containing merged relationship data
-        """
-        merged_data = {}
-
-        # Collect all possible keys
-        all_keys = set()
-        for data in relation_data_list:
-            all_keys.update(data.keys())
-
-        # Merge values for each key
-        for key in all_keys:
-            # Get all values for this key
-            values = [
-                data.get(key)
-                for data in relation_data_list
-                if data.get(key) is not None
-            ]
-
-            if not values:
-                continue
-
-            # Merge values according to strategy
-            strategy = merge_strategy.get(key, "keep_first")
-
-            if strategy == "concatenate":
-                merged_data[key] = "\n\n".join(str(v) for v in values)
-            elif strategy == "keep_first":
-                merged_data[key] = values[0]
-            elif strategy == "keep_last":
-                merged_data[key] = values[-1]
-            elif strategy == "join_unique":
-                # Handle fields separated by GRAPH_FIELD_SEP
-                unique_items = set()
-                for value in values:
-                    items = str(value).split(GRAPH_FIELD_SEP)
-                    unique_items.update(items)
-                merged_data[key] = GRAPH_FIELD_SEP.join(unique_items)
-            elif strategy == "max":
-                # For numeric fields like weight
-                try:
-                    merged_data[key] = max(float(v) for v in values)
-                except (ValueError, TypeError):
-                    merged_data[key] = values[0]
-            else:
-                # Default strategy
-                merged_data[key] = values[0]
-
-        return merged_data
-
-    async def _merge_entities_done(self) -> None:
-        """Callback after entity merging is complete, ensures updates are persisted"""
-        await asyncio.gather(
-            *[
-                cast(StorageNameSpace, storage_inst).index_done_callback()
-                for storage_inst in [  # type: ignore
-                    self.entities_vdb,
-                    self.relationships_vdb,
-                    self.chunk_entity_relation_graph,
-                ]
-            ]
-        )

lightrag/utils.py

@@ -893,6 +893,351 @@ def always_get_an_event_loop() -> asyncio.AbstractEventLoop:
         return new_loop
 
 
+async def aexport_data(
+    chunk_entity_relation_graph,
+    entities_vdb,
+    relationships_vdb,
+    output_path: str,
+    file_format: str = "csv",
+    include_vector_data: bool = False,
+) -> None:
+    """
+    Asynchronously exports all entities, relations, and relationships to various formats.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance for entities and relations
+        entities_vdb: Vector database storage for entities
+        relationships_vdb: Vector database storage for relationships
+        output_path: The path to the output file (including extension).
+        file_format: Output format - "csv", "excel", "md", "txt".
+            - csv: Comma-separated values file
+            - excel: Microsoft Excel file with multiple sheets
+            - md: Markdown tables
+            - txt: Plain text formatted output
+        include_vector_data: Whether to include data from the vector database.
+    """
+    # Collect data
+    entities_data = []
+    relations_data = []
+    relationships_data = []
+
+    # --- Entities ---
+    all_entities = await chunk_entity_relation_graph.get_all_labels()
+    for entity_name in all_entities:
+        # Get entity information from graph
+        node_data = await chunk_entity_relation_graph.get_node(entity_name)
+        source_id = node_data.get("source_id") if node_data else None
+
+        entity_info = {
+            "graph_data": node_data,
+            "source_id": source_id,
+        }
+
+        # Optional: Get vector database information
+        if include_vector_data:
+            entity_id = compute_mdhash_id(entity_name, prefix="ent-")
+            vector_data = await entities_vdb.get_by_id(entity_id)
+            entity_info["vector_data"] = vector_data
+
+        entity_row = {
+            "entity_name": entity_name,
+            "source_id": source_id,
+            "graph_data": str(
+                entity_info["graph_data"]
+            ),  # Convert to string to ensure compatibility
+        }
+        if include_vector_data and "vector_data" in entity_info:
+            entity_row["vector_data"] = str(entity_info["vector_data"])
+        entities_data.append(entity_row)
+
+    # --- Relations ---
+    for src_entity in all_entities:
+        for tgt_entity in all_entities:
+            if src_entity == tgt_entity:
+                continue
+
+            edge_exists = await chunk_entity_relation_graph.has_edge(
+                src_entity, tgt_entity
+            )
+            if edge_exists:
+                # Get edge information from graph
+                edge_data = await chunk_entity_relation_graph.get_edge(
+                    src_entity, tgt_entity
+                )
+                source_id = edge_data.get("source_id") if edge_data else None
+
+                relation_info = {
+                    "graph_data": edge_data,
+                    "source_id": source_id,
+                }
+
+                # Optional: Get vector database information
+                if include_vector_data:
+                    rel_id = compute_mdhash_id(src_entity + tgt_entity, prefix="rel-")
+                    vector_data = await relationships_vdb.get_by_id(rel_id)
+                    relation_info["vector_data"] = vector_data
+
+                relation_row = {
+                    "src_entity": src_entity,
+                    "tgt_entity": tgt_entity,
+                    "source_id": relation_info["source_id"],
+                    "graph_data": str(relation_info["graph_data"]),  # Convert to string
+                }
+                if include_vector_data and "vector_data" in relation_info:
+                    relation_row["vector_data"] = str(relation_info["vector_data"])
+                relations_data.append(relation_row)
+
+    # --- Relationships (from VectorDB) ---
+    all_relationships = await relationships_vdb.client_storage
+    for rel in all_relationships["data"]:
+        relationships_data.append(
+            {
+                "relationship_id": rel["__id__"],
+                "data": str(rel),  # Convert to string for compatibility
+            }
+        )
+
+    # Export based on format
+    if file_format == "csv":
+        # CSV export
+        with open(output_path, "w", newline="", encoding="utf-8") as csvfile:
+            # Entities
+            if entities_data:
+                csvfile.write("# ENTITIES\n")
+                writer = csv.DictWriter(csvfile, fieldnames=entities_data[0].keys())
+                writer.writeheader()
+                writer.writerows(entities_data)
+                csvfile.write("\n\n")
+
+            # Relations
+            if relations_data:
+                csvfile.write("# RELATIONS\n")
+                writer = csv.DictWriter(csvfile, fieldnames=relations_data[0].keys())
+                writer.writeheader()
+                writer.writerows(relations_data)
+                csvfile.write("\n\n")
+
+            # Relationships
+            if relationships_data:
+                csvfile.write("# RELATIONSHIPS\n")
+                writer = csv.DictWriter(
+                    csvfile, fieldnames=relationships_data[0].keys()
+                )
+                writer.writeheader()
+                writer.writerows(relationships_data)
+
+    elif file_format == "excel":
+        # Excel export
+        import pandas as pd
+
+        entities_df = pd.DataFrame(entities_data) if entities_data else pd.DataFrame()
+        relations_df = (
+            pd.DataFrame(relations_data) if relations_data else pd.DataFrame()
+        )
+        relationships_df = (
+            pd.DataFrame(relationships_data) if relationships_data else pd.DataFrame()
+        )
+
+        with pd.ExcelWriter(output_path, engine="xlsxwriter") as writer:
+            if not entities_df.empty:
+                entities_df.to_excel(writer, sheet_name="Entities", index=False)
+            if not relations_df.empty:
+                relations_df.to_excel(writer, sheet_name="Relations", index=False)
+            if not relationships_df.empty:
+                relationships_df.to_excel(
+                    writer, sheet_name="Relationships", index=False
+                )
+
+    elif file_format == "md":
+        # Markdown export
+        with open(output_path, "w", encoding="utf-8") as mdfile:
+            mdfile.write("# LightRAG Data Export\n\n")
+
+            # Entities
+            mdfile.write("## Entities\n\n")
+            if entities_data:
+                # Write header
+                mdfile.write("| " + " | ".join(entities_data[0].keys()) + " |\n")
+                mdfile.write(
+                    "| " + " | ".join(["---"] * len(entities_data[0].keys())) + " |\n"
+                )
+
+                # Write rows
+                for entity in entities_data:
+                    mdfile.write(
+                        "| " + " | ".join(str(v) for v in entity.values()) + " |\n"
+                    )
+                mdfile.write("\n\n")
+            else:
+                mdfile.write("*No entity data available*\n\n")
+
+            # Relations
+            mdfile.write("## Relations\n\n")
+            if relations_data:
+                # Write header
+                mdfile.write("| " + " | ".join(relations_data[0].keys()) + " |\n")
+                mdfile.write(
+                    "| " + " | ".join(["---"] * len(relations_data[0].keys())) + " |\n"
+                )
+
+                # Write rows
+                for relation in relations_data:
+                    mdfile.write(
+                        "| " + " | ".join(str(v) for v in relation.values()) + " |\n"
+                    )
+                mdfile.write("\n\n")
+            else:
+                mdfile.write("*No relation data available*\n\n")
+
+            # Relationships
+            mdfile.write("## Relationships\n\n")
+            if relationships_data:
+                # Write header
+                mdfile.write("| " + " | ".join(relationships_data[0].keys()) + " |\n")
+                mdfile.write(
+                    "| "
+                    + " | ".join(["---"] * len(relationships_data[0].keys()))
+                    + " |\n"
+                )
+
+                # Write rows
+                for relationship in relationships_data:
+                    mdfile.write(
+                        "| "
+                        + " | ".join(str(v) for v in relationship.values())
+                        + " |\n"
+                    )
+            else:
+                mdfile.write("*No relationship data available*\n\n")
+
+    elif file_format == "txt":
+        # Plain text export
+        with open(output_path, "w", encoding="utf-8") as txtfile:
+            txtfile.write("LIGHTRAG DATA EXPORT\n")
+            txtfile.write("=" * 80 + "\n\n")
+
+            # Entities
+            txtfile.write("ENTITIES\n")
+            txtfile.write("-" * 80 + "\n")
+            if entities_data:
+                # Create fixed width columns
+                col_widths = {
+                    k: max(len(k), max(len(str(e[k])) for e in entities_data))
+                    for k in entities_data[0]
+                }
+                header = "  ".join(k.ljust(col_widths[k]) for k in entities_data[0])
+                txtfile.write(header + "\n")
+                txtfile.write("-" * len(header) + "\n")
+
+                # Write rows
+                for entity in entities_data:
+                    row = "  ".join(
+                        str(v).ljust(col_widths[k]) for k, v in entity.items()
+                    )
+                    txtfile.write(row + "\n")
+                txtfile.write("\n\n")
+            else:
+                txtfile.write("No entity data available\n\n")
+
+            # Relations
+            txtfile.write("RELATIONS\n")
+            txtfile.write("-" * 80 + "\n")
+            if relations_data:
+                # Create fixed width columns
+                col_widths = {
+                    k: max(len(k), max(len(str(r[k])) for r in relations_data))
+                    for k in relations_data[0]
+                }
+                header = "  ".join(k.ljust(col_widths[k]) for k in relations_data[0])
+                txtfile.write(header + "\n")
+                txtfile.write("-" * len(header) + "\n")
+
+                # Write rows
+                for relation in relations_data:
+                    row = "  ".join(
+                        str(v).ljust(col_widths[k]) for k, v in relation.items()
+                    )
+                    txtfile.write(row + "\n")
+                txtfile.write("\n\n")
+            else:
+                txtfile.write("No relation data available\n\n")
+
+            # Relationships
+            txtfile.write("RELATIONSHIPS\n")
+            txtfile.write("-" * 80 + "\n")
+            if relationships_data:
+                # Create fixed width columns
+                col_widths = {
+                    k: max(len(k), max(len(str(r[k])) for r in relationships_data))
+                    for k in relationships_data[0]
+                }
+                header = "  ".join(
+                    k.ljust(col_widths[k]) for k in relationships_data[0]
+                )
+                txtfile.write(header + "\n")
+                txtfile.write("-" * len(header) + "\n")
+
+                # Write rows
+                for relationship in relationships_data:
+                    row = "  ".join(
+                        str(v).ljust(col_widths[k]) for k, v in relationship.items()
+                    )
+                    txtfile.write(row + "\n")
+            else:
+                txtfile.write("No relationship data available\n\n")
+
+    else:
+        raise ValueError(
+            f"Unsupported file format: {file_format}. "
+            f"Choose from: csv, excel, md, txt"
+        )
+    if file_format is not None:
+        print(f"Data exported to: {output_path} with format: {file_format}")
+    else:
+        print("Data displayed as table format")
+
+
+def export_data(
+    chunk_entity_relation_graph,
+    entities_vdb,
+    relationships_vdb,
+    output_path: str,
+    file_format: str = "csv",
+    include_vector_data: bool = False,
+) -> None:
+    """
+    Synchronously exports all entities, relations, and relationships to various formats.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance for entities and relations
+        entities_vdb: Vector database storage for entities
+        relationships_vdb: Vector database storage for relationships
+        output_path: The path to the output file (including extension).
+        file_format: Output format - "csv", "excel", "md", "txt".
+            - csv: Comma-separated values file
+            - excel: Microsoft Excel file with multiple sheets
+            - md: Markdown tables
+            - txt: Plain text formatted output
+        include_vector_data: Whether to include data from the vector database.
+    """
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    loop.run_until_complete(
+        aexport_data(
+            chunk_entity_relation_graph,
+            entities_vdb,
+            relationships_vdb,
+            output_path,
+            file_format,
+            include_vector_data,
+        )
+    )
+
+
 def lazy_external_import(module_name: str, class_name: str) -> Callable[..., Any]:
     """Lazily import a class from an external module based on the package of the caller."""
     # Get the caller's module and package

lightrag/utils_graph.py

@@ -0,0 +1,1066 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any, cast
+
+from .kg.shared_storage import get_graph_db_lock
+from .prompt import GRAPH_FIELD_SEP
+from .utils import compute_mdhash_id, logger
+from .base import StorageNameSpace
+
+
+async def adelete_by_entity(
+    chunk_entity_relation_graph, entities_vdb, relationships_vdb, entity_name: str
+) -> None:
+    """Asynchronously delete an entity and all its relationships.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance
+        entities_vdb: Vector database storage for entities
+        relationships_vdb: Vector database storage for relationships
+        entity_name: Name of the entity to delete
+    """
+    graph_db_lock = get_graph_db_lock(enable_logging=False)
+    # Use graph database lock to ensure atomic graph and vector db operations
+    async with graph_db_lock:
+        try:
+            await entities_vdb.delete_entity(entity_name)
+            await relationships_vdb.delete_entity_relation(entity_name)
+            await chunk_entity_relation_graph.delete_node(entity_name)
+
+            logger.info(
+                f"Entity '{entity_name}' and its relationships have been deleted."
+            )
+            await _delete_by_entity_done(
+                entities_vdb, relationships_vdb, chunk_entity_relation_graph
+            )
+        except Exception as e:
+            logger.error(f"Error while deleting entity '{entity_name}': {e}")
+
+
+async def _delete_by_entity_done(
+    entities_vdb, relationships_vdb, chunk_entity_relation_graph
+) -> None:
+    """Callback after entity deletion is complete, ensures updates are persisted"""
+    await asyncio.gather(
+        *[
+            cast(StorageNameSpace, storage_inst).index_done_callback()
+            for storage_inst in [  # type: ignore
+                entities_vdb,
+                relationships_vdb,
+                chunk_entity_relation_graph,
+            ]
+        ]
+    )
+
+
+async def adelete_by_relation(
+    chunk_entity_relation_graph,
+    relationships_vdb,
+    source_entity: str,
+    target_entity: str,
+) -> None:
+    """Asynchronously delete a relation between two entities.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance
+        relationships_vdb: Vector database storage for relationships
+        source_entity: Name of the source entity
+        target_entity: Name of the target entity
+    """
+    graph_db_lock = get_graph_db_lock(enable_logging=False)
+    # Use graph database lock to ensure atomic graph and vector db operations
+    async with graph_db_lock:
+        try:
+            # Check if the relation exists
+            edge_exists = await chunk_entity_relation_graph.has_edge(
+                source_entity, target_entity
+            )
+            if not edge_exists:
+                logger.warning(
+                    f"Relation from '{source_entity}' to '{target_entity}' does not exist"
+                )
+                return
+
+            # Delete relation from vector database
+            relation_id = compute_mdhash_id(
+                source_entity + target_entity, prefix="rel-"
+            )
+            await relationships_vdb.delete([relation_id])
+
+            # Delete relation from knowledge graph
+            await chunk_entity_relation_graph.remove_edges(
+                [(source_entity, target_entity)]
+            )
+
+            logger.info(
+                f"Successfully deleted relation from '{source_entity}' to '{target_entity}'"
+            )
+            await _delete_relation_done(relationships_vdb, chunk_entity_relation_graph)
+        except Exception as e:
+            logger.error(
+                f"Error while deleting relation from '{source_entity}' to '{target_entity}': {e}"
+            )
+
+
+async def _delete_relation_done(relationships_vdb, chunk_entity_relation_graph) -> None:
+    """Callback after relation deletion is complete, ensures updates are persisted"""
+    await asyncio.gather(
+        *[
+            cast(StorageNameSpace, storage_inst).index_done_callback()
+            for storage_inst in [  # type: ignore
+                relationships_vdb,
+                chunk_entity_relation_graph,
+            ]
+        ]
+    )
+
+
+async def aedit_entity(
+    chunk_entity_relation_graph,
+    entities_vdb,
+    relationships_vdb,
+    entity_name: str,
+    updated_data: dict[str, str],
+    allow_rename: bool = True,
+) -> dict[str, Any]:
+    """Asynchronously edit entity information.
+
+    Updates entity information in the knowledge graph and re-embeds the entity in the vector database.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance
+        entities_vdb: Vector database storage for entities
+        relationships_vdb: Vector database storage for relationships
+        entity_name: Name of the entity to edit
+        updated_data: Dictionary containing updated attributes, e.g. {"description": "new description", "entity_type": "new type"}
+        allow_rename: Whether to allow entity renaming, defaults to True
+
+    Returns:
+        Dictionary containing updated entity information
+    """
+    graph_db_lock = get_graph_db_lock(enable_logging=False)
+    # Use graph database lock to ensure atomic graph and vector db operations
+    async with graph_db_lock:
+        try:
+            # 1. Get current entity information
+            node_exists = await chunk_entity_relation_graph.has_node(entity_name)
+            if not node_exists:
+                raise ValueError(f"Entity '{entity_name}' does not exist")
+            node_data = await chunk_entity_relation_graph.get_node(entity_name)
+
+            # Check if entity is being renamed
+            new_entity_name = updated_data.get("entity_name", entity_name)
+            is_renaming = new_entity_name != entity_name
+
+            # If renaming, check if new name already exists
+            if is_renaming:
+                if not allow_rename:
+                    raise ValueError(
+                        "Entity renaming is not allowed. Set allow_rename=True to enable this feature"
+                    )
+
+                existing_node = await chunk_entity_relation_graph.has_node(
+                    new_entity_name
+                )
+                if existing_node:
+                    raise ValueError(
+                        f"Entity name '{new_entity_name}' already exists, cannot rename"
+                    )
+
+            # 2. Update entity information in the graph
+            new_node_data = {**node_data, **updated_data}
+            new_node_data["entity_id"] = new_entity_name
+
+            if "entity_name" in new_node_data:
+                del new_node_data[
+                    "entity_name"
+                ]  # Node data should not contain entity_name field
+
+            # If renaming entity
+            if is_renaming:
+                logger.info(f"Renaming entity '{entity_name}' to '{new_entity_name}'")
+
+                # Create new entity
+                await chunk_entity_relation_graph.upsert_node(
+                    new_entity_name, new_node_data
+                )
+
+                # Store relationships that need to be updated
+                relations_to_update = []
+                relations_to_delete = []
+                # Get all edges related to the original entity
+                edges = await chunk_entity_relation_graph.get_node_edges(entity_name)
+                if edges:
+                    # Recreate edges for the new entity
+                    for source, target in edges:
+                        edge_data = await chunk_entity_relation_graph.get_edge(
+                            source, target
+                        )
+                        if edge_data:
+                            relations_to_delete.append(
+                                compute_mdhash_id(source + target, prefix="rel-")
+                            )
+                            relations_to_delete.append(
+                                compute_mdhash_id(target + source, prefix="rel-")
+                            )
+                            if source == entity_name:
+                                await chunk_entity_relation_graph.upsert_edge(
+                                    new_entity_name, target, edge_data
+                                )
+                                relations_to_update.append(
+                                    (new_entity_name, target, edge_data)
+                                )
+                            else:  # target == entity_name
+                                await chunk_entity_relation_graph.upsert_edge(
+                                    source, new_entity_name, edge_data
+                                )
+                                relations_to_update.append(
+                                    (source, new_entity_name, edge_data)
+                                )
+
+                # Delete old entity
+                await chunk_entity_relation_graph.delete_node(entity_name)
+
+                # Delete old entity record from vector database
+                old_entity_id = compute_mdhash_id(entity_name, prefix="ent-")
+                await entities_vdb.delete([old_entity_id])
+                logger.info(
+                    f"Deleted old entity '{entity_name}' and its vector embedding from database"
+                )
+
+                # Delete old relation records from vector database
+                await relationships_vdb.delete(relations_to_delete)
+                logger.info(
+                    f"Deleted {len(relations_to_delete)} relation records for entity '{entity_name}' from vector database"
+                )
+
+                # Update relationship vector representations
+                for src, tgt, edge_data in relations_to_update:
+                    description = edge_data.get("description", "")
+                    keywords = edge_data.get("keywords", "")
+                    source_id = edge_data.get("source_id", "")
+                    weight = float(edge_data.get("weight", 1.0))
+
+                    # Create new content for embedding
+                    content = f"{src}\t{tgt}\n{keywords}\n{description}"
+
+                    # Calculate relationship ID
+                    relation_id = compute_mdhash_id(src + tgt, prefix="rel-")
+
+                    # Prepare data for vector database update
+                    relation_data = {
+                        relation_id: {
+                            "content": content,
+                            "src_id": src,
+                            "tgt_id": tgt,
+                            "source_id": source_id,
+                            "description": description,
+                            "keywords": keywords,
+                            "weight": weight,
+                        }
+                    }
+
+                    # Update vector database
+                    await relationships_vdb.upsert(relation_data)
+
+                # Update working entity name to new name
+                entity_name = new_entity_name
+            else:
+                # If not renaming, directly update node data
+                await chunk_entity_relation_graph.upsert_node(
+                    entity_name, new_node_data
+                )
+
+            # 3. Recalculate entity's vector representation and update vector database
+            description = new_node_data.get("description", "")
+            source_id = new_node_data.get("source_id", "")
+            entity_type = new_node_data.get("entity_type", "")
+            content = entity_name + "\n" + description
+
+            # Calculate entity ID
+            entity_id = compute_mdhash_id(entity_name, prefix="ent-")
+
+            # Prepare data for vector database update
+            entity_data = {
+                entity_id: {
+                    "content": content,
+                    "entity_name": entity_name,
+                    "source_id": source_id,
+                    "description": description,
+                    "entity_type": entity_type,
+                }
+            }
+
+            # Update vector database
+            await entities_vdb.upsert(entity_data)
+
+            # 4. Save changes
+            await _edit_entity_done(
+                entities_vdb, relationships_vdb, chunk_entity_relation_graph
+            )
+
+            logger.info(f"Entity '{entity_name}' successfully updated")
+            return await get_entity_info(
+                chunk_entity_relation_graph,
+                entities_vdb,
+                entity_name,
+                include_vector_data=True,
+            )
+        except Exception as e:
+            logger.error(f"Error while editing entity '{entity_name}': {e}")
+            raise
+
+
+async def _edit_entity_done(
+    entities_vdb, relationships_vdb, chunk_entity_relation_graph
+) -> None:
+    """Callback after entity editing is complete, ensures updates are persisted"""
+    await asyncio.gather(
+        *[
+            cast(StorageNameSpace, storage_inst).index_done_callback()
+            for storage_inst in [  # type: ignore
+                entities_vdb,
+                relationships_vdb,
+                chunk_entity_relation_graph,
+            ]
+        ]
+    )
+
+
+async def aedit_relation(
+    chunk_entity_relation_graph,
+    entities_vdb,
+    relationships_vdb,
+    source_entity: str,
+    target_entity: str,
+    updated_data: dict[str, Any],
+) -> dict[str, Any]:
+    """Asynchronously edit relation information.
+
+    Updates relation (edge) information in the knowledge graph and re-embeds the relation in the vector database.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance
+        entities_vdb: Vector database storage for entities
+        relationships_vdb: Vector database storage for relationships
+        source_entity: Name of the source entity
+        target_entity: Name of the target entity
+        updated_data: Dictionary containing updated attributes, e.g. {"description": "new description", "keywords": "new keywords"}
+
+    Returns:
+        Dictionary containing updated relation information
+    """
+    graph_db_lock = get_graph_db_lock(enable_logging=False)
+    # Use graph database lock to ensure atomic graph and vector db operations
+    async with graph_db_lock:
+        try:
+            # 1. Get current relation information
+            edge_exists = await chunk_entity_relation_graph.has_edge(
+                source_entity, target_entity
+            )
+            if not edge_exists:
+                raise ValueError(
+                    f"Relation from '{source_entity}' to '{target_entity}' does not exist"
+                )
+            edge_data = await chunk_entity_relation_graph.get_edge(
+                source_entity, target_entity
+            )
+            # Important: First delete the old relation record from the vector database
+            old_relation_id = compute_mdhash_id(
+                source_entity + target_entity, prefix="rel-"
+            )
+            await relationships_vdb.delete([old_relation_id])
+            logger.info(
+                f"Deleted old relation record from vector database for relation {source_entity} -> {target_entity}"
+            )
+
+            # 2. Update relation information in the graph
+            new_edge_data = {**edge_data, **updated_data}
+            await chunk_entity_relation_graph.upsert_edge(
+                source_entity, target_entity, new_edge_data
+            )
+
+            # 3. Recalculate relation's vector representation and update vector database
+            description = new_edge_data.get("description", "")
+            keywords = new_edge_data.get("keywords", "")
+            source_id = new_edge_data.get("source_id", "")
+            weight = float(new_edge_data.get("weight", 1.0))
+
+            # Create content for embedding
+            content = f"{source_entity}\t{target_entity}\n{keywords}\n{description}"
+
+            # Calculate relation ID
+            relation_id = compute_mdhash_id(
+                source_entity + target_entity, prefix="rel-"
+            )
+
+            # Prepare data for vector database update
+            relation_data = {
+                relation_id: {
+                    "content": content,
+                    "src_id": source_entity,
+                    "tgt_id": target_entity,
+                    "source_id": source_id,
+                    "description": description,
+                    "keywords": keywords,
+                    "weight": weight,
+                }
+            }
+
+            # Update vector database
+            await relationships_vdb.upsert(relation_data)
+
+            # 4. Save changes
+            await _edit_relation_done(relationships_vdb, chunk_entity_relation_graph)
+
+            logger.info(
+                f"Relation from '{source_entity}' to '{target_entity}' successfully updated"
+            )
+            return await get_relation_info(
+                chunk_entity_relation_graph,
+                relationships_vdb,
+                source_entity,
+                target_entity,
+                include_vector_data=True,
+            )
+        except Exception as e:
+            logger.error(
+                f"Error while editing relation from '{source_entity}' to '{target_entity}': {e}"
+            )
+            raise
+
+
+async def _edit_relation_done(relationships_vdb, chunk_entity_relation_graph) -> None:
+    """Callback after relation editing is complete, ensures updates are persisted"""
+    await asyncio.gather(
+        *[
+            cast(StorageNameSpace, storage_inst).index_done_callback()
+            for storage_inst in [  # type: ignore
+                relationships_vdb,
+                chunk_entity_relation_graph,
+            ]
+        ]
+    )
+
+
+async def acreate_entity(
+    chunk_entity_relation_graph,
+    entities_vdb,
+    relationships_vdb,
+    entity_name: str,
+    entity_data: dict[str, Any],
+) -> dict[str, Any]:
+    """Asynchronously create a new entity.
+
+    Creates a new entity in the knowledge graph and adds it to the vector database.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance
+        entities_vdb: Vector database storage for entities
+        relationships_vdb: Vector database storage for relationships
+        entity_name: Name of the new entity
+        entity_data: Dictionary containing entity attributes, e.g. {"description": "description", "entity_type": "type"}
+
+    Returns:
+        Dictionary containing created entity information
+    """
+    graph_db_lock = get_graph_db_lock(enable_logging=False)
+    # Use graph database lock to ensure atomic graph and vector db operations
+    async with graph_db_lock:
+        try:
+            # Check if entity already exists
+            existing_node = await chunk_entity_relation_graph.has_node(entity_name)
+            if existing_node:
+                raise ValueError(f"Entity '{entity_name}' already exists")
+
+            # Prepare node data with defaults if missing
+            node_data = {
+                "entity_id": entity_name,
+                "entity_type": entity_data.get("entity_type", "UNKNOWN"),
+                "description": entity_data.get("description", ""),
+                "source_id": entity_data.get("source_id", "manual"),
+            }
+
+            # Add entity to knowledge graph
+            await chunk_entity_relation_graph.upsert_node(entity_name, node_data)
+
+            # Prepare content for entity
+            description = node_data.get("description", "")
+            source_id = node_data.get("source_id", "")
+            entity_type = node_data.get("entity_type", "")
+            content = entity_name + "\n" + description
+
+            # Calculate entity ID
+            entity_id = compute_mdhash_id(entity_name, prefix="ent-")
+
+            # Prepare data for vector database update
+            entity_data_for_vdb = {
+                entity_id: {
+                    "content": content,
+                    "entity_name": entity_name,
+                    "source_id": source_id,
+                    "description": description,
+                    "entity_type": entity_type,
+                }
+            }
+
+            # Update vector database
+            await entities_vdb.upsert(entity_data_for_vdb)
+
+            # Save changes
+            await _edit_entity_done(
+                entities_vdb, relationships_vdb, chunk_entity_relation_graph
+            )
+
+            logger.info(f"Entity '{entity_name}' successfully created")
+            return await get_entity_info(
+                chunk_entity_relation_graph,
+                entities_vdb,
+                entity_name,
+                include_vector_data=True,
+            )
+        except Exception as e:
+            logger.error(f"Error while creating entity '{entity_name}': {e}")
+            raise
+
+
+async def acreate_relation(
+    chunk_entity_relation_graph,
+    entities_vdb,
+    relationships_vdb,
+    source_entity: str,
+    target_entity: str,
+    relation_data: dict[str, Any],
+) -> dict[str, Any]:
+    """Asynchronously create a new relation between entities.
+
+    Creates a new relation (edge) in the knowledge graph and adds it to the vector database.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance
+        entities_vdb: Vector database storage for entities
+        relationships_vdb: Vector database storage for relationships
+        source_entity: Name of the source entity
+        target_entity: Name of the target entity
+        relation_data: Dictionary containing relation attributes, e.g. {"description": "description", "keywords": "keywords"}
+
+    Returns:
+        Dictionary containing created relation information
+    """
+    graph_db_lock = get_graph_db_lock(enable_logging=False)
+    # Use graph database lock to ensure atomic graph and vector db operations
+    async with graph_db_lock:
+        try:
+            # Check if both entities exist
+            source_exists = await chunk_entity_relation_graph.has_node(source_entity)
+            target_exists = await chunk_entity_relation_graph.has_node(target_entity)
+
+            if not source_exists:
+                raise ValueError(f"Source entity '{source_entity}' does not exist")
+            if not target_exists:
+                raise ValueError(f"Target entity '{target_entity}' does not exist")
+
+            # Check if relation already exists
+            existing_edge = await chunk_entity_relation_graph.has_edge(
+                source_entity, target_entity
+            )
+            if existing_edge:
+                raise ValueError(
+                    f"Relation from '{source_entity}' to '{target_entity}' already exists"
+                )
+
+            # Prepare edge data with defaults if missing
+            edge_data = {
+                "description": relation_data.get("description", ""),
+                "keywords": relation_data.get("keywords", ""),
+                "source_id": relation_data.get("source_id", "manual"),
+                "weight": float(relation_data.get("weight", 1.0)),
+            }
+
+            # Add relation to knowledge graph
+            await chunk_entity_relation_graph.upsert_edge(
+                source_entity, target_entity, edge_data
+            )
+
+            # Prepare content for embedding
+            description = edge_data.get("description", "")
+            keywords = edge_data.get("keywords", "")
+            source_id = edge_data.get("source_id", "")
+            weight = edge_data.get("weight", 1.0)
+
+            # Create content for embedding
+            content = f"{keywords}\t{source_entity}\n{target_entity}\n{description}"
+
+            # Calculate relation ID
+            relation_id = compute_mdhash_id(
+                source_entity + target_entity, prefix="rel-"
+            )
+
+            # Prepare data for vector database update
+            relation_data_for_vdb = {
+                relation_id: {
+                    "content": content,
+                    "src_id": source_entity,
+                    "tgt_id": target_entity,
+                    "source_id": source_id,
+                    "description": description,
+                    "keywords": keywords,
+                    "weight": weight,
+                }
+            }
+
+            # Update vector database
+            await relationships_vdb.upsert(relation_data_for_vdb)
+
+            # Save changes
+            await _edit_relation_done(relationships_vdb, chunk_entity_relation_graph)
+
+            logger.info(
+                f"Relation from '{source_entity}' to '{target_entity}' successfully created"
+            )
+            return await get_relation_info(
+                chunk_entity_relation_graph,
+                relationships_vdb,
+                source_entity,
+                target_entity,
+                include_vector_data=True,
+            )
+        except Exception as e:
+            logger.error(
+                f"Error while creating relation from '{source_entity}' to '{target_entity}': {e}"
+            )
+            raise
+
+
+async def amerge_entities(
+    chunk_entity_relation_graph,
+    entities_vdb,
+    relationships_vdb,
+    source_entities: list[str],
+    target_entity: str,
+    merge_strategy: dict[str, str] = None,
+    target_entity_data: dict[str, Any] = None,
+) -> dict[str, Any]:
+    """Asynchronously merge multiple entities into one entity.
+
+    Merges multiple source entities into a target entity, handling all relationships,
+    and updating both the knowledge graph and vector database.
+
+    Args:
+        chunk_entity_relation_graph: Graph storage instance
+        entities_vdb: Vector database storage for entities
+        relationships_vdb: Vector database storage for relationships
+        source_entities: List of source entity names to merge
+        target_entity: Name of the target entity after merging
+        merge_strategy: Merge strategy configuration, e.g. {"description": "concatenate", "entity_type": "keep_first"}
+            Supported strategies:
+            - "concatenate": Concatenate all values (for text fields)
+            - "keep_first": Keep the first non-empty value
+            - "keep_last": Keep the last non-empty value
+            - "join_unique": Join all unique values (for fields separated by delimiter)
+        target_entity_data: Dictionary of specific values to set for the target entity,
+            overriding any merged values, e.g. {"description": "custom description", "entity_type": "PERSON"}
+
+    Returns:
+        Dictionary containing the merged entity information
+    """
+    graph_db_lock = get_graph_db_lock(enable_logging=False)
+    # Use graph database lock to ensure atomic graph and vector db operations
+    async with graph_db_lock:
+        try:
+            # Default merge strategy
+            default_strategy = {
+                "description": "concatenate",
+                "entity_type": "keep_first",
+                "source_id": "join_unique",
+            }
+
+            merge_strategy = (
+                default_strategy
+                if merge_strategy is None
+                else {**default_strategy, **merge_strategy}
+            )
+            target_entity_data = (
+                {} if target_entity_data is None else target_entity_data
+            )
+
+            # 1. Check if all source entities exist
+            source_entities_data = {}
+            for entity_name in source_entities:
+                node_exists = await chunk_entity_relation_graph.has_node(entity_name)
+                if not node_exists:
+                    raise ValueError(f"Source entity '{entity_name}' does not exist")
+                node_data = await chunk_entity_relation_graph.get_node(entity_name)
+                source_entities_data[entity_name] = node_data
+
+            # 2. Check if target entity exists and get its data if it does
+            target_exists = await chunk_entity_relation_graph.has_node(target_entity)
+            existing_target_entity_data = {}
+            if target_exists:
+                existing_target_entity_data = (
+                    await chunk_entity_relation_graph.get_node(target_entity)
+                )
+                logger.info(
+                    f"Target entity '{target_entity}' already exists, will merge data"
+                )
+
+            # 3. Merge entity data
+            merged_entity_data = _merge_entity_attributes(
+                list(source_entities_data.values())
+                + ([existing_target_entity_data] if target_exists else []),
+                merge_strategy,
+            )
+
+            # Apply any explicitly provided target entity data (overrides merged data)
+            for key, value in target_entity_data.items():
+                merged_entity_data[key] = value
+
+            # 4. Get all relationships of the source entities
+            all_relations = []
+            for entity_name in source_entities:
+                # Get all relationships of the source entities
+                edges = await chunk_entity_relation_graph.get_node_edges(entity_name)
+                if edges:
+                    for src, tgt in edges:
+                        # Ensure src is the current entity
+                        if src == entity_name:
+                            edge_data = await chunk_entity_relation_graph.get_edge(
+                                src, tgt
+                            )
+                            all_relations.append((src, tgt, edge_data))
+
+            # 5. Create or update the target entity
+            merged_entity_data["entity_id"] = target_entity
+            if not target_exists:
+                await chunk_entity_relation_graph.upsert_node(
+                    target_entity, merged_entity_data
+                )
+                logger.info(f"Created new target entity '{target_entity}'")
+            else:
+                await chunk_entity_relation_graph.upsert_node(
+                    target_entity, merged_entity_data
+                )
+                logger.info(f"Updated existing target entity '{target_entity}'")
+
+            # 6. Recreate all relationships, pointing to the target entity
+            relation_updates = {}  # Track relationships that need to be merged
+            relations_to_delete = []
+
+            for src, tgt, edge_data in all_relations:
+                relations_to_delete.append(compute_mdhash_id(src + tgt, prefix="rel-"))
+                relations_to_delete.append(compute_mdhash_id(tgt + src, prefix="rel-"))
+                new_src = target_entity if src in source_entities else src
+                new_tgt = target_entity if tgt in source_entities else tgt
+
+                # Skip relationships between source entities to avoid self-loops
+                if new_src == new_tgt:
+                    logger.info(
+                        f"Skipping relationship between source entities: {src} -> {tgt} to avoid self-loop"
+                    )
+                    continue
+
+                # Check if the same relationship already exists
+                relation_key = f"{new_src}|{new_tgt}"
+                if relation_key in relation_updates:
+                    # Merge relationship data
+                    existing_data = relation_updates[relation_key]["data"]
+                    merged_relation = _merge_relation_attributes(
+                        [existing_data, edge_data],
+                        {
+                            "description": "concatenate",
+                            "keywords": "join_unique",
+                            "source_id": "join_unique",
+                            "weight": "max",
+                        },
+                    )
+                    relation_updates[relation_key]["data"] = merged_relation
+                    logger.info(
+                        f"Merged duplicate relationship: {new_src} -> {new_tgt}"
+                    )
+                else:
+                    relation_updates[relation_key] = {
+                        "src": new_src,
+                        "tgt": new_tgt,
+                        "data": edge_data.copy(),
+                    }
+
+            # Apply relationship updates
+            for rel_data in relation_updates.values():
+                await chunk_entity_relation_graph.upsert_edge(
+                    rel_data["src"], rel_data["tgt"], rel_data["data"]
+                )
+                logger.info(
+                    f"Created or updated relationship: {rel_data['src']} -> {rel_data['tgt']}"
+                )
+
+                # Delete relationships records from vector database
+                await relationships_vdb.delete(relations_to_delete)
+                logger.info(
+                    f"Deleted {len(relations_to_delete)} relation records for entity from vector database"
+                )
+
+            # 7. Update entity vector representation
+            description = merged_entity_data.get("description", "")
+            source_id = merged_entity_data.get("source_id", "")
+            entity_type = merged_entity_data.get("entity_type", "")
+            content = target_entity + "\n" + description
+
+            entity_id = compute_mdhash_id(target_entity, prefix="ent-")
+            entity_data_for_vdb = {
+                entity_id: {
+                    "content": content,
+                    "entity_name": target_entity,
+                    "source_id": source_id,
+                    "description": description,
+                    "entity_type": entity_type,
+                }
+            }
+
+            await entities_vdb.upsert(entity_data_for_vdb)
+
+            # 8. Update relationship vector representations
+            for rel_data in relation_updates.values():
+                src = rel_data["src"]
+                tgt = rel_data["tgt"]
+                edge_data = rel_data["data"]
+
+                description = edge_data.get("description", "")
+                keywords = edge_data.get("keywords", "")
+                source_id = edge_data.get("source_id", "")
+                weight = float(edge_data.get("weight", 1.0))
+
+                content = f"{keywords}\t{src}\n{tgt}\n{description}"
+                relation_id = compute_mdhash_id(src + tgt, prefix="rel-")
+
+                relation_data_for_vdb = {
+                    relation_id: {
+                        "content": content,
+                        "src_id": src,
+                        "tgt_id": tgt,
+                        "source_id": source_id,
+                        "description": description,
+                        "keywords": keywords,
+                        "weight": weight,
+                    }
+                }
+
+                await relationships_vdb.upsert(relation_data_for_vdb)
+
+            # 9. Delete source entities
+            for entity_name in source_entities:
+                if entity_name == target_entity:
+                    logger.info(
+                        f"Skipping deletion of '{entity_name}' as it's also the target entity"
+                    )
+                    continue
+
+                # Delete entity node from knowledge graph
+                await chunk_entity_relation_graph.delete_node(entity_name)
+
+                # Delete entity record from vector database
+                entity_id = compute_mdhash_id(entity_name, prefix="ent-")
+                await entities_vdb.delete([entity_id])
+
+                logger.info(
+                    f"Deleted source entity '{entity_name}' and its vector embedding from database"
+                )
+
+            # 10. Save changes
+            await _merge_entities_done(
+                entities_vdb, relationships_vdb, chunk_entity_relation_graph
+            )
+
+            logger.info(
+                f"Successfully merged {len(source_entities)} entities into '{target_entity}'"
+            )
+            return await get_entity_info(
+                chunk_entity_relation_graph,
+                entities_vdb,
+                target_entity,
+                include_vector_data=True,
+            )
+
+        except Exception as e:
+            logger.error(f"Error merging entities: {e}")
+            raise
+
+
+def _merge_entity_attributes(
+    entity_data_list: list[dict[str, Any]], merge_strategy: dict[str, str]
+) -> dict[str, Any]:
+    """Merge attributes from multiple entities.
+
+    Args:
+        entity_data_list: List of dictionaries containing entity data
+        merge_strategy: Merge strategy for each field
+
+    Returns:
+        Dictionary containing merged entity data
+    """
+    merged_data = {}
+
+    # Collect all possible keys
+    all_keys = set()
+    for data in entity_data_list:
+        all_keys.update(data.keys())
+
+    # Merge values for each key
+    for key in all_keys:
+        # Get all values for this key
+        values = [data.get(key) for data in entity_data_list if data.get(key)]
+
+        if not values:
+            continue
+
+        # Merge values according to strategy
+        strategy = merge_strategy.get(key, "keep_first")
+
+        if strategy == "concatenate":
+            merged_data[key] = "\n\n".join(values)
+        elif strategy == "keep_first":
+            merged_data[key] = values[0]
+        elif strategy == "keep_last":
+            merged_data[key] = values[-1]
+        elif strategy == "join_unique":
+            # Handle fields separated by GRAPH_FIELD_SEP
+            unique_items = set()
+            for value in values:
+                items = value.split(GRAPH_FIELD_SEP)
+                unique_items.update(items)
+            merged_data[key] = GRAPH_FIELD_SEP.join(unique_items)
+        else:
+            # Default strategy
+            merged_data[key] = values[0]
+
+    return merged_data
+
+
+def _merge_relation_attributes(
+    relation_data_list: list[dict[str, Any]], merge_strategy: dict[str, str]
+) -> dict[str, Any]:
+    """Merge attributes from multiple relationships.
+
+    Args:
+        relation_data_list: List of dictionaries containing relationship data
+        merge_strategy: Merge strategy for each field
+
+    Returns:
+        Dictionary containing merged relationship data
+    """
+    merged_data = {}
+
+    # Collect all possible keys
+    all_keys = set()
+    for data in relation_data_list:
+        all_keys.update(data.keys())
+
+    # Merge values for each key
+    for key in all_keys:
+        # Get all values for this key
+        values = [
+            data.get(key) for data in relation_data_list if data.get(key) is not None
+        ]
+
+        if not values:
+            continue
+
+        # Merge values according to strategy
+        strategy = merge_strategy.get(key, "keep_first")
+
+        if strategy == "concatenate":
+            merged_data[key] = "\n\n".join(str(v) for v in values)
+        elif strategy == "keep_first":
+            merged_data[key] = values[0]
+        elif strategy == "keep_last":
+            merged_data[key] = values[-1]
+        elif strategy == "join_unique":
+            # Handle fields separated by GRAPH_FIELD_SEP
+            unique_items = set()
+            for value in values:
+                items = str(value).split(GRAPH_FIELD_SEP)
+                unique_items.update(items)
+            merged_data[key] = GRAPH_FIELD_SEP.join(unique_items)
+        elif strategy == "max":
+            # For numeric fields like weight
+            try:
+                merged_data[key] = max(float(v) for v in values)
+            except (ValueError, TypeError):
+                merged_data[key] = values[0]
+        else:
+            # Default strategy
+            merged_data[key] = values[0]
+
+    return merged_data
+
+
+async def _merge_entities_done(
+    entities_vdb, relationships_vdb, chunk_entity_relation_graph
+) -> None:
+    """Callback after entity merging is complete, ensures updates are persisted"""
+    await asyncio.gather(
+        *[
+            cast(StorageNameSpace, storage_inst).index_done_callback()
+            for storage_inst in [  # type: ignore
+                entities_vdb,
+                relationships_vdb,
+                chunk_entity_relation_graph,
+            ]
+        ]
+    )
+
+
+async def get_entity_info(
+    chunk_entity_relation_graph,
+    entities_vdb,
+    entity_name: str,
+    include_vector_data: bool = False,
+) -> dict[str, str | None | dict[str, str]]:
+    """Get detailed information of an entity"""
+
+    # Get information from the graph
+    node_data = await chunk_entity_relation_graph.get_node(entity_name)
+    source_id = node_data.get("source_id") if node_data else None
+
+    result: dict[str, str | None | dict[str, str]] = {
+        "entity_name": entity_name,
+        "source_id": source_id,
+        "graph_data": node_data,
+    }
+
+    # Optional: Get vector database information
+    if include_vector_data:
+        entity_id = compute_mdhash_id(entity_name, prefix="ent-")
+        vector_data = await entities_vdb.get_by_id(entity_id)
+        result["vector_data"] = vector_data
+
+    return result
+
+
+async def get_relation_info(
+    chunk_entity_relation_graph,
+    relationships_vdb,
+    src_entity: str,
+    tgt_entity: str,
+    include_vector_data: bool = False,
+) -> dict[str, str | None | dict[str, str]]:
+    """Get detailed information of a relationship"""
+
+    # Get information from the graph
+    edge_data = await chunk_entity_relation_graph.get_edge(src_entity, tgt_entity)
+    source_id = edge_data.get("source_id") if edge_data else None
+
+    result: dict[str, str | None | dict[str, str]] = {
+        "src_entity": src_entity,
+        "tgt_entity": tgt_entity,
+        "source_id": source_id,
+        "graph_data": edge_data,
+    }
+
+    # Optional: Get vector database information
+    if include_vector_data:
+        rel_id = compute_mdhash_id(src_entity + tgt_entity, prefix="rel-")
+        vector_data = await relationships_vdb.get_by_id(rel_id)
+        result["vector_data"] = vector_data
+
+    return result

lightrag_webui/src/api/lightrag.ts

@@ -507,3 +507,58 @@ export const loginToServer = async (username: string, password: string): Promise
 
   return response.data;
 }
+
+/**
+ * Updates an entity's properties in the knowledge graph
+ * @param entityName The name of the entity to update
+ * @param updatedData Dictionary containing updated attributes
+ * @param allowRename Whether to allow renaming the entity (default: false)
+ * @returns Promise with the updated entity information
+ */
+export const updateEntity = async (
+  entityName: string,
+  updatedData: Record<string, any>,
+  allowRename: boolean = false
+): Promise<DocActionResponse> => {
+  const response = await axiosInstance.post('/graph/entity/edit', {
+    entity_name: entityName,
+    updated_data: updatedData,
+    allow_rename: allowRename
+  })
+  return response.data
+}
+
+/**
+ * Updates a relation's properties in the knowledge graph
+ * @param sourceEntity The source entity name
+ * @param targetEntity The target entity name
+ * @param updatedData Dictionary containing updated attributes
+ * @returns Promise with the updated relation information
+ */
+export const updateRelation = async (
+  sourceEntity: string,
+  targetEntity: string,
+  updatedData: Record<string, any>
+): Promise<DocActionResponse> => {
+  const response = await axiosInstance.post('/graph/relation/edit', {
+    source_id: sourceEntity,
+    target_id: targetEntity,
+    updated_data: updatedData
+  })
+  return response.data
+}
+
+/**
+ * Checks if an entity name already exists in the knowledge graph
+ * @param entityName The entity name to check
+ * @returns Promise with boolean indicating if the entity exists
+ */
+export const checkEntityNameExists = async (entityName: string): Promise<boolean> => {
+  try {
+    const response = await axiosInstance.get(`/graph/entity/exists?name=${encodeURIComponent(entityName)}`)
+    return response.data.exists
+  } catch (error) {
+    console.error('Error checking entity name:', error)
+    return false
+  }
+}

lightrag_webui/src/components/graph/EditablePropertyRow.tsx

@@ -0,0 +1,117 @@
+import { useState, useEffect } from 'react'
+import { useTranslation } from 'react-i18next'
+import { toast } from 'sonner'
+import { updateEntity, updateRelation, checkEntityNameExists } from '@/api/lightrag'
+import { updateGraphNode, updateGraphEdge } from '@/utils/graphOperations'
+import { PropertyName, EditIcon, PropertyValue } from './PropertyRowComponents'
+import PropertyEditDialog from './PropertyEditDialog'
+
+/**
+ * Interface for the EditablePropertyRow component props
+ */
+interface EditablePropertyRowProps {
+  name: string                  // Property name to display and edit
+  value: any                    // Initial value of the property
+  onClick?: () => void          // Optional click handler for the property value
+  entityId?: string             // ID of the entity (for node type)
+  entityType?: 'node' | 'edge'  // Type of graph entity
+  sourceId?: string            // Source node ID (for edge type)
+  targetId?: string            // Target node ID (for edge type)
+  onValueChange?: (newValue: any) => void  // Optional callback when value changes
+  isEditable?: boolean         // Whether this property can be edited
+}
+
+/**
+ * EditablePropertyRow component that supports editing property values
+ * This component is used in the graph properties panel to display and edit entity properties
+ */
+const EditablePropertyRow = ({
+  name,
+  value: initialValue,
+  onClick,
+  entityId,
+  entityType,
+  sourceId,
+  targetId,
+  onValueChange,
+  isEditable = false
+}: EditablePropertyRowProps) => {
+  const { t } = useTranslation()
+  const [isEditing, setIsEditing] = useState(false)
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  const [currentValue, setCurrentValue] = useState(initialValue)
+
+  useEffect(() => {
+    setCurrentValue(initialValue)
+  }, [initialValue])
+
+  const handleEditClick = () => {
+    if (isEditable && !isEditing) {
+      setIsEditing(true)
+    }
+  }
+
+  const handleCancel = () => {
+    setIsEditing(false)
+  }
+
+  const handleSave = async (value: string) => {
+    if (isSubmitting || value === String(currentValue)) {
+      setIsEditing(false)
+      return
+    }
+
+    setIsSubmitting(true)
+
+    try {
+      if (entityType === 'node' && entityId) {
+        let updatedData = { [name]: value }
+
+        if (name === 'entity_id') {
+          const exists = await checkEntityNameExists(value)
+          if (exists) {
+            toast.error(t('graphPanel.propertiesView.errors.duplicateName'))
+            return
+          }
+          updatedData = { 'entity_name': value }
+        }
+
+        await updateEntity(entityId, updatedData, true)
+        await updateGraphNode(entityId, name, value)
+        toast.success(t('graphPanel.propertiesView.success.entityUpdated'))
+      } else if (entityType === 'edge' && sourceId && targetId) {
+        const updatedData = { [name]: value }
+        await updateRelation(sourceId, targetId, updatedData)
+        await updateGraphEdge(sourceId, targetId, name, value)
+        toast.success(t('graphPanel.propertiesView.success.relationUpdated'))
+      }
+
+      setIsEditing(false)
+      setCurrentValue(value)
+      onValueChange?.(value)
+    } catch (error) {
+      console.error('Error updating property:', error)
+      toast.error(t('graphPanel.propertiesView.errors.updateFailed'))
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  return (
+    <div className="flex items-center gap-1">
+      <PropertyName name={name} />
+      <EditIcon onClick={handleEditClick} />:
+      <PropertyValue value={currentValue} onClick={onClick} />
+      <PropertyEditDialog
+        isOpen={isEditing}
+        onClose={handleCancel}
+        onSave={handleSave}
+        propertyName={name}
+        initialValue={String(currentValue)}
+        isSubmitting={isSubmitting}
+      />
+    </div>
+  )
+}
+
+export default EditablePropertyRow

lightrag_webui/src/components/graph/GraphControl.tsx

@@ -99,7 +99,10 @@ const GraphControl = ({ disableHoverEffect }: { disableHoverEffect?: boolean })
     const events: Record<string, any> = {
       enterNode: (event: NodeEvent) => {
         if (!isButtonPressed(event.event.original)) {
-          setFocusedNode(event.node)
+          const graph = sigma.getGraph()
+          if (graph.hasNode(event.node)) {
+            setFocusedNode(event.node)
+          }
         }
       },
       leaveNode: (event: NodeEvent) => {
@@ -108,8 +111,11 @@ const GraphControl = ({ disableHoverEffect }: { disableHoverEffect?: boolean })
         }
       },
       clickNode: (event: NodeEvent) => {
-        setSelectedNode(event.node)
-        setSelectedEdge(null)
+        const graph = sigma.getGraph()
+        if (graph.hasNode(event.node)) {
+          setSelectedNode(event.node)
+          setSelectedEdge(null)
+        }
       },
       clickStage: () => clearSelection()
     }

lightrag_webui/src/components/graph/PropertiesView.tsx

@@ -5,6 +5,7 @@ import Button from '@/components/ui/Button'
 import useLightragGraph from '@/hooks/useLightragGraph'
 import { useTranslation } from 'react-i18next'
 import { GitBranchPlus, Scissors } from 'lucide-react'
+import EditablePropertyRow from './EditablePropertyRow'
 
 /**
  * Component that view properties of elements in graph.
@@ -169,12 +170,22 @@ const PropertyRow = ({
   name,
   value,
   onClick,
-  tooltip
+  tooltip,
+  entityId,
+  entityType,
+  sourceId,
+  targetId,
+  isEditable = false
 }: {
   name: string
   value: any
   onClick?: () => void
   tooltip?: string
+  entityId?: string
+  entityType?: 'node' | 'edge'
+  sourceId?: string
+  targetId?: string
+  isEditable?: boolean
 }) => {
   const { t } = useTranslation()
 
@@ -184,8 +195,23 @@ const PropertyRow = ({
     return translation === translationKey ? name : translation
   }
 
-  // Since Text component uses a label internally, we'll use a span here instead of a label
-  // to avoid nesting labels which is not recommended for accessibility
+  // Use EditablePropertyRow for editable fields (description, entity_id and keywords)
+  if (isEditable && (name === 'description' || name === 'entity_id' || name === 'keywords')) {
+    return (
+      <EditablePropertyRow
+        name={name}
+        value={value}
+        onClick={onClick}
+        entityId={entityId}
+        entityType={entityType}
+        sourceId={sourceId}
+        targetId={targetId}
+        isEditable={true}
+      />
+    )
+  }
+
+  // For non-editable fields, use the regular Text component
   return (
     <div className="flex items-center gap-2">
       <span className="text-primary/60 tracking-wide whitespace-nowrap">{getPropertyNameTranslation(name)}</span>:
@@ -253,7 +279,16 @@ const NodePropertiesView = ({ node }: { node: NodeType }) => {
         {Object.keys(node.properties)
           .sort()
           .map((name) => {
-            return <PropertyRow key={name} name={name} value={node.properties[name]} />
+            return (
+              <PropertyRow
+                key={name}
+                name={name}
+                value={node.properties[name]}
+                entityId={node.properties['entity_id'] || node.id}
+                entityType="node"
+                isEditable={name === 'description' || name === 'entity_id'}
+              />
+            )
           })}
       </div>
       {node.relationships.length > 0 && (
@@ -309,7 +344,18 @@ const EdgePropertiesView = ({ edge }: { edge: EdgeType }) => {
         {Object.keys(edge.properties)
           .sort()
           .map((name) => {
-            return <PropertyRow key={name} name={name} value={edge.properties[name]} />
+            return (
+              <PropertyRow
+                key={name}
+                name={name}
+                value={edge.properties[name]}
+                entityId={edge.id}
+                entityType="edge"
+                sourceId={edge.source}
+                targetId={edge.target}
+                isEditable={name === 'description' || name === 'keywords'}
+              />
+            )
           })}
       </div>
     </div>

lightrag_webui/src/components/graph/PropertyEditDialog.tsx

@@ -0,0 +1,152 @@
+import { useState, useEffect } from 'react'
+import { useTranslation } from 'react-i18next'
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+  DialogDescription
+} from '@/components/ui/Dialog'
+import Button from '@/components/ui/Button'
+
+interface PropertyEditDialogProps {
+  isOpen: boolean
+  onClose: () => void
+  onSave: (value: string) => void
+  propertyName: string
+  initialValue: string
+  isSubmitting?: boolean
+}
+
+/**
+ * Dialog component for editing property values
+ * Provides a modal with a title, multi-line text input, and save/cancel buttons
+ */
+const PropertyEditDialog = ({
+  isOpen,
+  onClose,
+  onSave,
+  propertyName,
+  initialValue,
+  isSubmitting = false
+}: PropertyEditDialogProps) => {
+  const { t } = useTranslation()
+  const [value, setValue] = useState('')
+
+  // Initialize value when dialog opens
+  useEffect(() => {
+    if (isOpen) {
+      setValue(initialValue)
+    }
+  }, [isOpen, initialValue])
+
+  // Get translated property name
+  const getPropertyNameTranslation = (name: string) => {
+    const translationKey = `graphPanel.propertiesView.node.propertyNames.${name}`
+    const translation = t(translationKey)
+    return translation === translationKey ? name : translation
+  }
+
+  // Get textarea configuration based on property name
+  const getTextareaConfig = (propertyName: string) => {
+    switch (propertyName) {
+    case 'description':
+      return {
+        // No rows attribute for description to allow auto-sizing
+        className: 'max-h-[50vh] min-h-[10em] resize-y', // Maximum height 70% of viewport, minimum height ~20 lines, allow vertical resizing
+        style: {
+          height: '70vh', // Set initial height to 70% of viewport
+          minHeight: '20em', // Minimum height ~20 lines
+          resize: 'vertical' as const // Allow vertical resizing, using 'as const' to fix type
+        }
+      };
+    case 'entity_id':
+      return {
+        rows: 2,
+        className: '',
+        style: {}
+      };
+    case 'keywords':
+      return {
+        rows: 4,
+        className: '',
+        style: {}
+      };
+    default:
+      return {
+        rows: 5,
+        className: '',
+        style: {}
+      };
+    }
+  };
+
+  const handleSave = () => {
+    if (value.trim() !== '') {
+      onSave(value)
+      onClose()
+    }
+  }
+
+  return (
+    <Dialog open={isOpen} onOpenChange={(open) => !open && onClose()}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle>
+            {t('graphPanel.propertiesView.editProperty', {
+              property: getPropertyNameTranslation(propertyName)
+            })}
+          </DialogTitle>
+          <DialogDescription>
+            {t('graphPanel.propertiesView.editPropertyDescription')}
+          </DialogDescription>
+        </DialogHeader>
+
+        {/* Multi-line text input using textarea */}
+        <div className="grid gap-4 py-4">
+          {(() => {
+            const config = getTextareaConfig(propertyName);
+            return propertyName === 'description' ? (
+              <textarea
+                value={value}
+                onChange={(e) => setValue(e.target.value)}
+                className={`border-input focus-visible:ring-ring flex w-full rounded-md border bg-transparent px-3 py-2 text-sm shadow-sm transition-colors focus-visible:ring-1 focus-visible:outline-none disabled:cursor-not-allowed disabled:opacity-50 ${config.className}`}
+                style={config.style}
+                disabled={isSubmitting}
+              />
+            ) : (
+              <textarea
+                value={value}
+                onChange={(e) => setValue(e.target.value)}
+                rows={config.rows}
+                className={`border-input focus-visible:ring-ring flex w-full rounded-md border bg-transparent px-3 py-2 text-sm shadow-sm transition-colors focus-visible:ring-1 focus-visible:outline-none disabled:cursor-not-allowed disabled:opacity-50 ${config.className}`}
+                disabled={isSubmitting}
+              />
+            );
+          })()}
+        </div>
+
+        <DialogFooter>
+          <Button
+            type="button"
+            variant="outline"
+            onClick={onClose}
+            disabled={isSubmitting}
+          >
+            {t('common.cancel')}
+          </Button>
+          <Button
+            type="button"
+            onClick={handleSave}
+            disabled={isSubmitting}
+          >
+            {t('common.save')}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+export default PropertyEditDialog

lightrag_webui/src/components/graph/PropertyRowComponents.tsx

@@ -0,0 +1,53 @@
+import { PencilIcon } from 'lucide-react'
+import Text from '@/components/ui/Text'
+import { useTranslation } from 'react-i18next'
+
+interface PropertyNameProps {
+  name: string
+}
+
+export const PropertyName = ({ name }: PropertyNameProps) => {
+  const { t } = useTranslation()
+
+  const getPropertyNameTranslation = (propName: string) => {
+    const translationKey = `graphPanel.propertiesView.node.propertyNames.${propName}`
+    const translation = t(translationKey)
+    return translation === translationKey ? propName : translation
+  }
+
+  return (
+    <span className="text-primary/60 tracking-wide whitespace-nowrap">
+      {getPropertyNameTranslation(name)}
+    </span>
+  )
+}
+
+interface EditIconProps {
+  onClick: () => void
+}
+
+export const EditIcon = ({ onClick }: EditIconProps) => (
+  <div>
+    <PencilIcon
+      className="h-3 w-3 text-gray-500 hover:text-gray-700 cursor-pointer"
+      onClick={onClick}
+    />
+  </div>
+)
+
+interface PropertyValueProps {
+  value: any
+  onClick?: () => void
+}
+
+export const PropertyValue = ({ value, onClick }: PropertyValueProps) => (
+  <div className="flex items-center gap-1">
+    <Text
+      className="hover:bg-primary/20 rounded p-1 overflow-hidden text-ellipsis"
+      tooltipClassName="max-w-80"
+      text={value}
+      side="left"
+      onClick={onClick}
+    />
+  </div>
+)

lightrag_webui/src/locales/ar.json

@@ -33,7 +33,8 @@
     "guestMode": "وضع بدون تسجيل دخول"
   },
   "common": {
-    "cancel": "إلغاء"
+    "cancel": "إلغاء",
+    "save": "حفظ"
   },
   "documentPanel": {
     "clearDocuments": {
@@ -236,6 +237,17 @@
       "vectorStorage": "تخزين المتجهات"
     },
     "propertiesView": {
+      "editProperty": "تعديل {{property}}",
+      "editPropertyDescription": "قم بتحرير قيمة الخاصية في منطقة النص أدناه.",
+      "errors": {
+        "duplicateName": "اسم العقدة موجود بالفعل",
+        "updateFailed": "فشل تحديث العقدة",
+        "tryAgainLater": "يرجى المحاولة مرة أخرى لاحقًا"
+      },
+      "success": {
+        "entityUpdated": "تم تحديث العقدة بنجاح",
+        "relationUpdated": "تم تحديث العلاقة بنجاح"
+      },
       "node": {
         "title": "عقدة",
         "id": "المعرف",

lightrag_webui/src/locales/en.json

@@ -33,7 +33,8 @@
     "guestMode": "Login Free"
   },
   "common": {
-    "cancel": "Cancel"
+    "cancel": "Cancel",
+    "save": "Save"
   },
   "documentPanel": {
     "clearDocuments": {
@@ -156,6 +157,7 @@
       "animal": "Animal",
       "unknown": "Unknown",
       "object": "Object",
+      "group": "Group",
       "technology": "Technology"
     },
     "sideBar": {
@@ -235,6 +237,17 @@
       "vectorStorage": "Vector Storage"
     },
     "propertiesView": {
+      "editProperty": "Edit {{property}}",
+      "editPropertyDescription": "Edit the property value in the text area below.",
+      "errors": {
+        "duplicateName": "Node name already exists",
+        "updateFailed": "Failed to update node",
+        "tryAgainLater": "Please try again later"
+      },
+      "success": {
+        "entityUpdated": "Node updated successfully",
+        "relationUpdated": "Relation updated successfully"
+      },
       "node": {
         "title": "Node",
         "id": "ID",

lightrag_webui/src/locales/fr.json

@@ -33,7 +33,8 @@
     "guestMode": "Mode sans connexion"
   },
   "common": {
-    "cancel": "Annuler"
+    "cancel": "Annuler",
+    "save": "Sauvegarder"
   },
   "documentPanel": {
     "clearDocuments": {
@@ -236,6 +237,17 @@
       "vectorStorage": "Stockage vectoriel"
     },
     "propertiesView": {
+      "editProperty": "Modifier {{property}}",
+      "editPropertyDescription": "Modifiez la valeur de la propriété dans la zone de texte ci-dessous.",
+      "errors": {
+        "duplicateName": "Le nom du nœud existe déjà",
+        "updateFailed": "Échec de la mise à jour du nœud",
+        "tryAgainLater": "Veuillez réessayer plus tard"
+      },
+      "success": {
+        "entityUpdated": "Nœud mis à jour avec succès",
+        "relationUpdated": "Relation mise à jour avec succès"
+      },
       "node": {
         "title": "Nœud",
         "id": "ID",

lightrag_webui/src/locales/zh.json

@@ -33,7 +33,8 @@
     "guestMode": "无需登陆"
   },
   "common": {
-    "cancel": "取消"
+    "cancel": "取消",
+    "save": "保存"
   },
   "documentPanel": {
     "clearDocuments": {
@@ -236,6 +237,17 @@
       "vectorStorage": "向量存储"
     },
     "propertiesView": {
+      "editProperty": "编辑{{property}}",
+      "editPropertyDescription": "在下方文本区域编辑属性值。",
+      "errors": {
+        "duplicateName": "节点名称已存在",
+        "updateFailed": "更新节点失败",
+        "tryAgainLater": "请稍后重试"
+      },
+      "success": {
+        "entityUpdated": "节点更新成功",
+        "relationUpdated": "关系更新成功"
+      },
       "node": {
         "title": "节点",
         "id": "ID",

lightrag_webui/src/locales/zh_TW.json

@@ -33,7 +33,8 @@
       "guestMode": "免登入"
     },
     "common": {
-      "cancel": "取消"
+      "cancel": "取消",
+      "save": "儲存"
     },
     "documentPanel": {
       "clearDocuments": {
@@ -236,6 +237,17 @@
         "vectorStorage": "向量儲存"
       },
       "propertiesView": {
+        "editProperty": "編輯{{property}}",
+        "editPropertyDescription": "在下方文字區域編輯屬性值。",
+        "errors": {
+          "duplicateName": "節點名稱已存在",
+          "updateFailed": "更新節點失敗",
+          "tryAgainLater": "請稍後重試"
+        },
+        "success": {
+          "entityUpdated": "節點更新成功",
+          "relationUpdated": "關係更新成功"
+        },
         "node": {
           "title": "節點",
           "id": "ID",
@@ -296,13 +308,14 @@
         "parametersTitle": "參數",
         "parametersDescription": "設定查詢參數",
         "queryMode": "查詢模式",
-        "queryModeTooltip": "選擇檢索策略：\n• Naive：基礎搜尋，無進階技術\n• Local：上下文相關資訊檢索\n• Global：利用全域知識庫\n• Hybrid：結合本地和全域檢索\n• Mix：整合知識圖譜和向量檢索",
+        "queryModeTooltip": "選擇檢索策略：\n• Naive：基礎搜尋，無進階技術\n• Local：上下文相關資訊檢索\n• Global：利用全域知識庫\n• Hybrid：結合本地和全域檢索\n• Mix：整合知識圖譜和向量檢索\n• Bypass：直接傳遞查詢到LLM，不進行檢索",
         "queryModeOptions": {
           "naive": "Naive",
           "local": "Local",
           "global": "Global",
           "hybrid": "Hybrid",
-          "mix": "Mix"
+          "mix": "Mix",
+          "bypass": "Bypass"
         },
         "responseFormat": "回應格式",
         "responseFormatTooltip": "定義回應格式。例如：\n• 多段落\n• 單段落\n• 重點",

lightrag_webui/src/stores/graph.ts

@@ -116,6 +116,10 @@ interface GraphState {
   // Node operation state
   nodeToExpand: string | null
   nodeToPrune: string | null
+
+  // Version counter to trigger data refresh
+  graphDataVersion: number
+  incrementGraphDataVersion: () => void
 }
 
 const useGraphStoreBase = create<GraphState>()((set) => ({
@@ -219,6 +223,10 @@ const useGraphStoreBase = create<GraphState>()((set) => ({
   triggerNodeExpand: (nodeId: string | null) => set({ nodeToExpand: nodeId }),
   triggerNodePrune: (nodeId: string | null) => set({ nodeToPrune: nodeId }),
 
+  // Version counter implementation
+  graphDataVersion: 0,
+  incrementGraphDataVersion: () => set((state) => ({ graphDataVersion: state.graphDataVersion + 1 })),
+
 }))
 
 const useGraphStore = createSelectors(useGraphStoreBase)

lightrag_webui/src/utils/graphOperations.ts

@@ -0,0 +1,175 @@
+import { useGraphStore } from '@/stores/graph'
+
+/**
+ * Interface for tracking edges that need updating when a node ID changes
+ */
+interface EdgeToUpdate {
+  originalDynamicId: string
+  newEdgeId: string
+  edgeIndex: number
+}
+
+/**
+ * Update node in the graph visualization
+ * Handles both property updates and entity ID changes
+ *
+ * @param nodeId - ID of the node to update
+ * @param propertyName - Name of the property being updated
+ * @param newValue - New value for the property
+ */
+export const updateGraphNode = async (nodeId: string, propertyName: string, newValue: string) => {
+  // Get graph state from store
+  const sigmaGraph = useGraphStore.getState().sigmaGraph
+  const rawGraph = useGraphStore.getState().rawGraph
+
+  // Validate graph state
+  if (!sigmaGraph || !rawGraph || !sigmaGraph.hasNode(String(nodeId))) {
+    return
+  }
+
+  try {
+    const nodeAttributes = sigmaGraph.getNodeAttributes(String(nodeId))
+
+    // Special handling for entity_id changes (node renaming)
+    if (propertyName === 'entity_id') {
+      // Create new node with updated ID but same attributes
+      sigmaGraph.addNode(newValue, { ...nodeAttributes, label: newValue })
+
+      const edgesToUpdate: EdgeToUpdate[] = []
+
+      // Process all edges connected to this node
+      sigmaGraph.forEachEdge(String(nodeId), (edge, attributes, source, target) => {
+        const otherNode = source === String(nodeId) ? target : source
+        const isOutgoing = source === String(nodeId)
+
+        // Get original edge dynamic ID for later reference
+        const originalEdgeDynamicId = edge
+        const edgeIndexInRawGraph = rawGraph.edgeDynamicIdMap[originalEdgeDynamicId]
+
+        // Create new edge with updated node reference
+        const newEdgeId = sigmaGraph.addEdge(
+          isOutgoing ? newValue : otherNode,
+          isOutgoing ? otherNode : newValue,
+          attributes
+        )
+
+        // Track edges that need updating in the raw graph
+        if (edgeIndexInRawGraph !== undefined) {
+          edgesToUpdate.push({
+            originalDynamicId: originalEdgeDynamicId,
+            newEdgeId: newEdgeId,
+            edgeIndex: edgeIndexInRawGraph
+          })
+        }
+
+        // Remove the old edge
+        sigmaGraph.dropEdge(edge)
+      })
+
+      // Remove the old node after all edges are processed
+      sigmaGraph.dropNode(String(nodeId))
+
+      // Update node reference in raw graph data
+      const nodeIndex = rawGraph.nodeIdMap[String(nodeId)]
+      if (nodeIndex !== undefined) {
+        rawGraph.nodes[nodeIndex].id = newValue
+        rawGraph.nodes[nodeIndex].properties.entity_id = newValue
+        delete rawGraph.nodeIdMap[String(nodeId)]
+        rawGraph.nodeIdMap[newValue] = nodeIndex
+      }
+
+      // Update all edge references in raw graph data
+      edgesToUpdate.forEach(({ originalDynamicId, newEdgeId, edgeIndex }) => {
+        if (rawGraph.edges[edgeIndex]) {
+          // Update source/target references
+          if (rawGraph.edges[edgeIndex].source === String(nodeId)) {
+            rawGraph.edges[edgeIndex].source = newValue
+          }
+          if (rawGraph.edges[edgeIndex].target === String(nodeId)) {
+            rawGraph.edges[edgeIndex].target = newValue
+          }
+
+          // Update dynamic ID mappings
+          rawGraph.edges[edgeIndex].dynamicId = newEdgeId
+          delete rawGraph.edgeDynamicIdMap[originalDynamicId]
+          rawGraph.edgeDynamicIdMap[newEdgeId] = edgeIndex
+        }
+      })
+
+      // Update selected node in store
+      useGraphStore.getState().setSelectedNode(newValue)
+    } else {
+      // For other properties, just update the property in raw graph
+      const nodeIndex = rawGraph.nodeIdMap[String(nodeId)]
+      if (nodeIndex !== undefined) {
+        rawGraph.nodes[nodeIndex].properties[propertyName] = newValue
+      }
+    }
+  } catch (error) {
+    console.error('Error updating node in graph:', error)
+    throw new Error('Failed to update node in graph')
+  }
+}
+
+/**
+ * Update edge in the graph visualization
+ *
+ * @param sourceId - ID of the source node
+ * @param targetId - ID of the target node
+ * @param propertyName - Name of the property being updated
+ * @param newValue - New value for the property
+ */
+export const updateGraphEdge = async (sourceId: string, targetId: string, propertyName: string, newValue: string) => {
+  // Get graph state from store
+  const sigmaGraph = useGraphStore.getState().sigmaGraph
+  const rawGraph = useGraphStore.getState().rawGraph
+
+  // Validate graph state
+  if (!sigmaGraph || !rawGraph) {
+    return
+  }
+
+  try {
+    // Find the edge between source and target nodes
+    const allEdges = sigmaGraph.edges()
+    let keyToUse = null
+
+    for (const edge of allEdges) {
+      const edgeSource = sigmaGraph.source(edge)
+      const edgeTarget = sigmaGraph.target(edge)
+
+      // Match edge in either direction (undirected graph support)
+      if ((edgeSource === sourceId && edgeTarget === targetId) ||
+          (edgeSource === targetId && edgeTarget === sourceId)) {
+        keyToUse = edge
+        break
+      }
+    }
+
+    if (keyToUse !== null) {
+      // Special handling for keywords property (updates edge label)
+      if(propertyName === 'keywords') {
+        sigmaGraph.setEdgeAttribute(keyToUse, 'label', newValue)
+      } else {
+        sigmaGraph.setEdgeAttribute(keyToUse, propertyName, newValue)
+      }
+
+      // Update edge in raw graph data using dynamic ID mapping
+      if (keyToUse && rawGraph.edgeDynamicIdMap[keyToUse] !== undefined) {
+        const edgeIndex = rawGraph.edgeDynamicIdMap[keyToUse]
+        if (rawGraph.edges[edgeIndex]) {
+          rawGraph.edges[edgeIndex].properties[propertyName] = newValue
+        }
+      } else if (keyToUse !== null) {
+        // Fallback: try to find edge by key in edge ID map
+        const edgeIndexByKey = rawGraph.edgeIdMap[keyToUse]
+        if (edgeIndexByKey !== undefined && rawGraph.edges[edgeIndexByKey]) {
+          rawGraph.edges[edgeIndexByKey].properties[propertyName] = newValue
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Error updating edge ${sourceId}->${targetId} in graph:`, error)
+    throw new Error('Failed to update edge in graph')
+  }
+}