Feat：support nebular database

examples/basic_modules/nebular_example.py

@@ -0,0 +1,197 @@
+from datetime import datetime
+
+from memos.configs.embedder import EmbedderConfigFactory
+from memos.configs.graph_db import GraphDBConfigFactory
+from memos.embedders.factory import EmbedderFactory
+from memos.graph_dbs.factory import GraphStoreFactory
+from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata
+
+
+embedder_config = EmbedderConfigFactory.model_validate(
+    {
+        "backend": "universal_api",
+        "config": {
+            "provider": "openai",
+            "api_key": "sk-xxxxxxxx",
+            "model_name_or_path": "text-embedding-3-large",
+            "base_url": "http://xxx.xxx.xxx.xxx:xxxx/v1",
+        },
+    }
+)
+embedder = EmbedderFactory.from_config(embedder_config)
+
+
+def embed_memory_item(memory: str) -> list[float]:
+    return embedder.embed([memory])[0]
+
+
+def example_multi_db(db_name: str = "paper"):
+    # Step 1: Build factory config
+    config = GraphDBConfigFactory(
+        backend="nebular",
+        config={
+            "hosts": ["xxx.xx.xxx.xx:xxxx", "xxx.xx.xxx.xx:xxxx", "xxx.xx.xxx.xx:xxxx"],
+            "user_name": "root",
+            "password": "xxxxxxxx",
+            "space": db_name,
+            "auto_create": True,
+            "embedding_dimension": 3072,
+            "use_multi_db": True,
+        },
+    )
+
+    # Step 2: Instantiate the graph store
+    graph = GraphStoreFactory.from_config(config)
+    graph.clear()
+
+    # Step 3: Create topic node
+    topic = TextualMemoryItem(
+        memory="This research addresses long-term multi-UAV navigation for energy-efficient communication coverage.",
+        metadata=TreeNodeTextualMemoryMetadata(
+            memory_type="LongTermMemory",
+            key="Multi-UAV Long-Term Coverage",
+            hierarchy_level="topic",
+            type="fact",
+            memory_time="2024-01-01",
+            source="file",
+            sources=["paper://multi-uav-coverage/intro"],
+            status="activated",
+            confidence=95.0,
+            tags=["UAV", "coverage", "multi-agent"],
+            entities=["UAV", "coverage", "navigation"],
+            visibility="public",
+            updated_at=datetime.now().isoformat(),
+            embedding=embed_memory_item(
+                "This research addresses long-term "
+                "multi-UAV navigation for "
+                "energy-efficient communication "
+                "coverage."
+            ),
+        ),
+    )
+
+    graph.add_node(
+        id=topic.id, memory=topic.memory, metadata=topic.metadata.model_dump(exclude_none=True)
+    )
+
+
+def example_shared_db(db_name: str = "shared-traval-group"):
+    """
+    Example: Single(Shared)-DB multi-tenant (logical isolation)
+    Multiple users' data in the same Neo4j DB with user_name as a tag.
+    """
+    # users
+    user_list = ["travel_member_alice", "travel_member_bob"]
+
+    for user_name in user_list:
+        # Step 1: Build factory config
+        config = GraphDBConfigFactory(
+            backend="nebular",
+            config={
+                "hosts": ["xxx.xx.xxx.xx:xxxx", "xxx.xx.xxx.xx:xxxx", "xxx.xx.xxx.xx:xxxx"],
+                "password": "xxxxxxxx",
+                "space": db_name,
+                "user_name": "root",
+                "auto_create": True,
+                "embedding_dimension": 3072,
+                "use_multi_db": False,
+            },
+        )
+
+        # Step 2: Instantiate graph store
+        graph = GraphStoreFactory.from_config(config)
+        print(f"\n[INFO] Working in shared DB: {db_name}, for user: {user_name}")
+        graph.clear()
+
+        # Step 3: Create topic node
+        topic = TextualMemoryItem(
+            memory="This research addresses long-term multi-UAV navigation for energy-efficient communication coverage.",
+            metadata=TreeNodeTextualMemoryMetadata(
+                memory_type="LongTermMemory",
+                key="Multi-UAV Long-Term Coverage",
+                hierarchy_level="topic",
+                type="fact",
+                memory_time="2024-01-01",
+                source="file",
+                sources=["paper://multi-uav-coverage/intro"],
+                status="activated",
+                confidence=95.0,
+                tags=["UAV", "coverage", "multi-agent"],
+                entities=["UAV", "coverage", "navigation"],
+                visibility="public",
+                updated_at=datetime.now().isoformat(),
+                embedding=embed_memory_item(
+                    "This research addresses long-term "
+                    "multi-UAV navigation for "
+                    "energy-efficient communication "
+                    "coverage."
+                ),
+            ),
+        )
+
+        graph.add_node(
+            id=topic.id, memory=topic.memory, metadata=topic.metadata.model_dump(exclude_none=True)
+        )
+
+        # Step 4: Add a concept for each user
+        concept = TextualMemoryItem(
+            memory=f"Itinerary plan for {user_name}",
+            metadata=TreeNodeTextualMemoryMetadata(
+                memory_type="LongTermMemory",
+                key="Multi-UAV Long-Term Coverage",
+                hierarchy_level="concept",
+                type="fact",
+                memory_time="2024-01-01",
+                source="file",
+                sources=["paper://multi-uav-coverage/intro"],
+                status="activated",
+                confidence=95.0,
+                tags=["UAV", "coverage", "multi-agent"],
+                entities=["UAV", "coverage", "navigation"],
+                visibility="public",
+                updated_at=datetime.now().isoformat(),
+                embedding=embed_memory_item(f"Itinerary plan for {user_name}"),
+            ),
+        )
+
+        graph.add_node(
+            id=concept.id,
+            memory=concept.memory,
+            metadata=concept.metadata.model_dump(exclude_none=True),
+        )
+
+        # Link concept to topic
+        graph.add_edge(source_id=concept.id, target_id=topic.id, type="RELATE_TO")
+
+        print(f"[INFO] Added nodes for {user_name}")
+
+        # Step 5: Query and print ALL for verification
+    print("\n=== Export entire DB (for verification, includes ALL users) ===")
+    graph = GraphStoreFactory.from_config(config)
+    all_graph_data = graph.export_graph()
+    print(all_graph_data)
+
+    # Step 6: Search for alice's data only
+    print("\n=== Search for travel_member_alice ===")
+    config_alice = GraphDBConfigFactory(
+        backend="nebular",
+        config={
+             "hosts": ["xxx.xx.xxx.xx:xxxx", "xxx.xx.xxx.xx:xxxx", "xxx.xx.xxx.xx:xxxx"],
+            "password": "xxxxxxxx",
+            "space": db_name,
+            "user_name": "root",
+            "embedding_dimension": 3072,
+        },
+    )
+    graph_alice = GraphStoreFactory.from_config(config_alice)
+    nodes = graph_alice.search_by_embedding(vector=embed_memory_item("travel itinerary"), top_k=1)
+    for node in nodes:
+        print(graph_alice.get_node(node["id"]))
+
+
+if __name__ == "__main__":
+    print("\n=== Example: Multi-DB ===")
+    example_multi_db(db_name="paper")
+
+    print("\n=== Example: Single-DB ===")
+    example_shared_db(db_name="shared_traval_group")

src/memos/configs/graph_db.py

@@ -68,7 +68,7 @@ class Neo4jGraphDBConfig(BaseGraphDBConfig):
         ),
     )
 
-    embedding_dimension: int = Field(default=768, description="Dimension of vector embedding")
+    embedding_dimension: int = Field(default=3072, description="Dimension of vector embedding")
 
     @model_validator(mode="after")
     def validate_config(self):
@@ -103,13 +103,63 @@ def validate_community(self):
         return self
 
 
+class NebulaGraphDBConfig(BaseConfig):
+    """
+    NebulaGraph-specific configuration.
+
+    Key concepts:
+    - `space`: Equivalent to a database or namespace. All tag/edge/schema live within a space.
+    - `user_name`: Used for logical tenant isolation if needed.
+    - `auto_create`: Whether to automatically create the target space if it does not exist.
+
+    Example:
+    ---
+    hosts = ["127.0.0.1:9669"]
+    user = "root"
+    password = "nebula"
+    space = "shared_graph"
+    user_name = "alice"
+    """
+
+    password: str
+    hosts: list[str] = Field(..., description="List of host:port strings for NebulaGraph servers")
+    space: str = Field(
+        ..., description="The name of the target NebulaGraph space (like a database)"
+    )
+    user_name: str | None = Field(
+        default=None,
+        description="Logical user or tenant ID for data isolation (optional, used in metadata tagging)",
+    )
+    auto_create: bool = Field(
+        default=False,
+        description="Whether to auto-create the space if it does not exist",
+    )
+    use_multi_db: bool = Field(
+        default=True,
+        description=(
+            "If True: use Neo4j's multi-database feature for physical isolation; "
+            "each user typically gets a separate database. "
+            "If False: use a single shared database with logical isolation by user_name."
+        ),
+    )
+    embedding_dimension: int = Field(default=3072, description="Dimension of vector embedding")
+
+    @model_validator(mode="after")
+    def validate_config(self):
+        """Validate config."""
+        if not self.space:
+            raise ValueError("`space` must be provided")
+        return self
+
+
 class GraphDBConfigFactory(BaseModel):
     backend: str = Field(..., description="Backend for graph database")
     config: dict[str, Any] = Field(..., description="Configuration for the graph database backend")
 
     backend_to_class: ClassVar[dict[str, Any]] = {
         "neo4j": Neo4jGraphDBConfig,
         "neo4j-community": Neo4jCommunityGraphDBConfig,
+        "nebular": NebulaGraphDBConfig,
     }
 
     @field_validator("backend")

src/memos/graph_dbs/factory.py

@@ -2,6 +2,7 @@
 
 from memos.configs.graph_db import GraphDBConfigFactory
 from memos.graph_dbs.base import BaseGraphDB
+from memos.graph_dbs.nebular import NebulaGraphDB
 from memos.graph_dbs.neo4j import Neo4jGraphDB
 from memos.graph_dbs.neo4j_community import Neo4jCommunityGraphDB
 
@@ -12,6 +13,7 @@ class GraphStoreFactory(BaseGraphDB):
     backend_to_class: ClassVar[dict[str, Any]] = {
         "neo4j": Neo4jGraphDB,
         "neo4j-community": Neo4jCommunityGraphDB,
+        "nebular": NebulaGraphDB,
     }
 
     @classmethod