cognee 0.5.0.dev0__py3-none-any.whl → 0.5.0.dev1__py3-none-any.whl

cognee/api/v1/ui/node_setup.py

@@ -0,0 +1,360 @@
+import os
+import platform
+import subprocess
+import tempfile
+from pathlib import Path
+
+import requests
+
+from cognee.shared.logging_utils import get_logger
+
+logger = get_logger()
+
+
+def get_nvm_dir() -> Path:
+    """
+    Get the nvm directory path following standard nvm installation logic.
+    Uses XDG_CONFIG_HOME if set, otherwise falls back to ~/.nvm.
+    """
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config_home:
+        return Path(xdg_config_home) / "nvm"
+    return Path.home() / ".nvm"
+
+
+def get_nvm_sh_path() -> Path:
+    """
+    Get the path to nvm.sh following standard nvm installation logic.
+    """
+    return get_nvm_dir() / "nvm.sh"
+
+
+def check_nvm_installed() -> bool:
+    """
+    Check if nvm (Node Version Manager) is installed.
+    """
+    try:
+        # Check if nvm is available in the shell
+        # nvm is typically sourced in shell config files, so we need to check via shell
+        if platform.system() == "Windows":
+            # On Windows, nvm-windows uses a different approach
+            result = subprocess.run(
+                ["nvm", "version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                shell=True,
+            )
+        else:
+            # On Unix-like systems, nvm is a shell function, so we need to source it
+            # First check if nvm.sh exists
+            nvm_path = get_nvm_sh_path()
+            if not nvm_path.exists():
+                logger.debug(f"nvm.sh not found at {nvm_path}")
+                return False
+
+            # Try to source nvm and check version, capturing errors
+            result = subprocess.run(
+                ["bash", "-c", f"source {nvm_path} && nvm --version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+
+            if result.returncode != 0:
+                # Log the error to help diagnose configuration issues
+                if result.stderr:
+                    logger.debug(f"nvm check failed: {result.stderr.strip()}")
+                return False
+
+        return result.returncode == 0
+    except Exception as e:
+        logger.debug(f"Exception checking nvm: {str(e)}")
+        return False
+
+
+def install_nvm() -> bool:
+    """
+    Install nvm (Node Version Manager) on Unix-like systems.
+    """
+    if platform.system() == "Windows":
+        logger.error("nvm installation on Windows requires nvm-windows.")
+        logger.error(
+            "Please install nvm-windows manually from: https://github.com/coreybutler/nvm-windows"
+        )
+        return False
+
+    logger.info("Installing nvm (Node Version Manager)...")
+
+    try:
+        # Download and install nvm
+        nvm_install_script = "https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh"
+        logger.info(f"Downloading nvm installer from {nvm_install_script}...")
+
+        response = requests.get(nvm_install_script, timeout=60)
+        response.raise_for_status()
+
+        # Create a temporary script file
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
+            f.write(response.text)
+            install_script_path = f.name
+
+        try:
+            # Make the script executable and run it
+            os.chmod(install_script_path, 0o755)
+            result = subprocess.run(
+                ["bash", install_script_path],
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+
+            if result.returncode == 0:
+                logger.info("✓ nvm installed successfully")
+                # Source nvm in current shell session
+                nvm_dir = get_nvm_dir()
+                if nvm_dir.exists():
+                    return True
+                else:
+                    logger.warning(
+                        f"nvm installation completed but nvm directory not found at {nvm_dir}"
+                    )
+                    return False
+            else:
+                logger.error(f"nvm installation failed: {result.stderr}")
+                return False
+        finally:
+            # Clean up temporary script
+            try:
+                os.unlink(install_script_path)
+            except Exception:
+                pass
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Failed to download nvm installer: {str(e)}")
+        return False
+    except Exception as e:
+        logger.error(f"Failed to install nvm: {str(e)}")
+        return False
+
+
+def install_node_with_nvm() -> bool:
+    """
+    Install the latest Node.js version using nvm.
+    Returns True if installation succeeds, False otherwise.
+    """
+    if platform.system() == "Windows":
+        logger.error("Node.js installation via nvm on Windows requires nvm-windows.")
+        logger.error("Please install Node.js manually from: https://nodejs.org/")
+        return False
+
+    logger.info("Installing latest Node.js version using nvm...")
+
+    try:
+        # Source nvm and install latest Node.js
+        nvm_path = get_nvm_sh_path()
+        if not nvm_path.exists():
+            logger.error(f"nvm.sh not found at {nvm_path}. nvm may not be properly installed.")
+            return False
+
+        nvm_source_cmd = f"source {nvm_path}"
+        install_cmd = f"{nvm_source_cmd} && nvm install node"
+
+        result = subprocess.run(
+            ["bash", "-c", install_cmd],
+            capture_output=True,
+            text=True,
+            timeout=300,  # 5 minutes timeout for Node.js installation
+        )
+
+        if result.returncode == 0:
+            logger.info("✓ Node.js installed successfully via nvm")
+
+            # Set as default version
+            use_cmd = f"{nvm_source_cmd} && nvm alias default node"
+            subprocess.run(
+                ["bash", "-c", use_cmd],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+
+            # Add nvm to PATH for current session
+            # This ensures node/npm are available in subsequent commands
+            nvm_dir = get_nvm_dir()
+            if nvm_dir.exists():
+                # Update PATH for current process
+                nvm_bin = nvm_dir / "versions" / "node"
+                # Find the latest installed version
+                if nvm_bin.exists():
+                    versions = sorted(nvm_bin.iterdir(), reverse=True)
+                    if versions:
+                        latest_node_bin = versions[0] / "bin"
+                        if latest_node_bin.exists():
+                            current_path = os.environ.get("PATH", "")
+                            os.environ["PATH"] = f"{latest_node_bin}:{current_path}"
+
+            return True
+        else:
+            logger.error(f"Failed to install Node.js: {result.stderr}")
+            return False
+
+    except subprocess.TimeoutExpired:
+        logger.error("Timeout installing Node.js (this can take several minutes)")
+        return False
+    except Exception as e:
+        logger.error(f"Error installing Node.js: {str(e)}")
+        return False
+
+
+def check_node_npm() -> tuple[bool, str]:  # (is_available, error_message)
+    """
+    Check if Node.js and npm are available.
+    If not available, attempts to install nvm and Node.js automatically.
+    """
+
+    try:
+        # Check Node.js - try direct command first, then with nvm if needed
+        result = subprocess.run(["node", "--version"], capture_output=True, text=True, timeout=10)
+        if result.returncode != 0:
+            # If direct command fails, try with nvm sourced (in case nvm is installed but not in PATH)
+            nvm_path = get_nvm_sh_path()
+            if nvm_path.exists():
+                result = subprocess.run(
+                    ["bash", "-c", f"source {nvm_path} && node --version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if result.returncode != 0 and result.stderr:
+                    logger.debug(f"Failed to source nvm or run node: {result.stderr.strip()}")
+        if result.returncode != 0:
+            # Node.js is not installed, try to install it
+            logger.info("Node.js is not installed. Attempting to install automatically...")
+
+            # Check if nvm is installed
+            if not check_nvm_installed():
+                logger.info("nvm is not installed. Installing nvm first...")
+                if not install_nvm():
+                    return (
+                        False,
+                        "Failed to install nvm. Please install Node.js manually from https://nodejs.org/",
+                    )
+
+            # Install Node.js using nvm
+            if not install_node_with_nvm():
+                return (
+                    False,
+                    "Failed to install Node.js. Please install Node.js manually from https://nodejs.org/",
+                )
+
+            # Verify installation after automatic setup
+            # Try with nvm sourced first
+            nvm_path = get_nvm_sh_path()
+            if nvm_path.exists():
+                result = subprocess.run(
+                    ["bash", "-c", f"source {nvm_path} && node --version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                if result.returncode != 0 and result.stderr:
+                    logger.debug(
+                        f"Failed to verify node after installation: {result.stderr.strip()}"
+                    )
+            else:
+                result = subprocess.run(
+                    ["node", "--version"], capture_output=True, text=True, timeout=10
+                )
+            if result.returncode != 0:
+                nvm_path = get_nvm_sh_path()
+                return (
+                    False,
+                    f"Node.js installation completed but node command is not available. Please restart your terminal or source {nvm_path}",
+                )
+
+        node_version = result.stdout.strip()
+        logger.debug(f"Found Node.js version: {node_version}")
+
+        # Check npm - handle Windows PowerShell scripts
+        if platform.system() == "Windows":
+            # On Windows, npm might be a PowerShell script, so we need to use shell=True
+            result = subprocess.run(
+                ["npm", "--version"], capture_output=True, text=True, timeout=10, shell=True
+            )
+        else:
+            # On Unix-like systems, if we just installed via nvm, we may need to source nvm
+            # Try direct command first
+            result = subprocess.run(
+                ["npm", "--version"], capture_output=True, text=True, timeout=10
+            )
+            if result.returncode != 0:
+                # Try with nvm sourced
+                nvm_path = get_nvm_sh_path()
+                if nvm_path.exists():
+                    result = subprocess.run(
+                        ["bash", "-c", f"source {nvm_path} && npm --version"],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
+                    )
+                    if result.returncode != 0 and result.stderr:
+                        logger.debug(f"Failed to source nvm or run npm: {result.stderr.strip()}")
+
+        if result.returncode != 0:
+            return False, "npm is not installed or not in PATH"
+
+        npm_version = result.stdout.strip()
+        logger.debug(f"Found npm version: {npm_version}")
+
+        return True, f"Node.js {node_version}, npm {npm_version}"
+
+    except subprocess.TimeoutExpired:
+        return False, "Timeout checking Node.js/npm installation"
+    except FileNotFoundError:
+        # Node.js is not installed, try to install it
+        logger.info("Node.js is not found. Attempting to install automatically...")
+
+        # Check if nvm is installed
+        if not check_nvm_installed():
+            logger.info("nvm is not installed. Installing nvm first...")
+            if not install_nvm():
+                return (
+                    False,
+                    "Failed to install nvm. Please install Node.js manually from https://nodejs.org/",
+                )
+
+        # Install Node.js using nvm
+        if not install_node_with_nvm():
+            return (
+                False,
+                "Failed to install Node.js. Please install Node.js manually from https://nodejs.org/",
+            )
+
+        # Retry checking Node.js after installation
+        try:
+            result = subprocess.run(
+                ["node", "--version"], capture_output=True, text=True, timeout=10
+            )
+            if result.returncode == 0:
+                node_version = result.stdout.strip()
+                # Check npm
+                nvm_path = get_nvm_sh_path()
+                if nvm_path.exists():
+                    result = subprocess.run(
+                        ["bash", "-c", f"source {nvm_path} && npm --version"],
+                        capture_output=True,
+                        text=True,
+                        timeout=10,
+                    )
+                    if result.returncode == 0:
+                        npm_version = result.stdout.strip()
+                        return True, f"Node.js {node_version}, npm {npm_version}"
+                    elif result.stderr:
+                        logger.debug(f"Failed to source nvm or run npm: {result.stderr.strip()}")
+        except Exception as e:
+            logger.debug(f"Exception retrying node/npm check: {str(e)}")
+
+        return False, "Node.js/npm not found. Please install Node.js from https://nodejs.org/"
+    except Exception as e:
+        return False, f"Error checking Node.js/npm: {str(e)}"

cognee/api/v1/ui/npm_utils.py

@@ -0,0 +1,50 @@
+import platform
+import subprocess
+from pathlib import Path
+from typing import List
+
+from cognee.shared.logging_utils import get_logger
+from .node_setup import get_nvm_sh_path
+
+logger = get_logger()
+
+
+def run_npm_command(cmd: List[str], cwd: Path, timeout: int = 300) -> subprocess.CompletedProcess:
+    """
+    Run an npm command, ensuring nvm is sourced if needed (Unix-like systems only).
+    Returns the CompletedProcess result.
+    """
+    if platform.system() == "Windows":
+        # On Windows, use shell=True for npm commands
+        return subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            shell=True,
+        )
+    else:
+        # On Unix-like systems, try direct command first
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        # If it fails and nvm might be installed, try with nvm sourced
+        if result.returncode != 0:
+            nvm_path = get_nvm_sh_path()
+            if nvm_path.exists():
+                nvm_cmd = f"source {nvm_path} && {' '.join(cmd)}"
+                result = subprocess.run(
+                    ["bash", "-c", nvm_cmd],
+                    cwd=cwd,
+                    capture_output=True,
+                    text=True,
+                    timeout=timeout,
+                )
+                if result.returncode != 0 and result.stderr:
+                    logger.debug(f"npm command failed with nvm: {result.stderr.strip()}")
+        return result

cognee/api/v1/ui/ui.py

@@ -15,6 +15,8 @@ import shutil
 
 from cognee.shared.logging_utils import get_logger
 from cognee.version import get_cognee_version
+from .node_setup import check_node_npm, get_nvm_dir, get_nvm_sh_path
+from .npm_utils import run_npm_command
 
 logger = get_logger()
 
@@ -285,48 +287,6 @@ def find_frontend_path() -> Optional[Path]:
     return None
 
 
-def check_node_npm() -> tuple[bool, str]:
-    """
-    Check if Node.js and npm are available.
-    Returns (is_available, error_message)
-    """
-
-    try:
-        # Check Node.js
-        result = subprocess.run(["node", "--version"], capture_output=True, text=True, timeout=10)
-        if result.returncode != 0:
-            return False, "Node.js is not installed or not in PATH"
-
-        node_version = result.stdout.strip()
-        logger.debug(f"Found Node.js version: {node_version}")
-
-        # Check npm - handle Windows PowerShell scripts
-        if platform.system() == "Windows":
-            # On Windows, npm might be a PowerShell script, so we need to use shell=True
-            result = subprocess.run(
-                ["npm", "--version"], capture_output=True, text=True, timeout=10, shell=True
-            )
-        else:
-            result = subprocess.run(
-                ["npm", "--version"], capture_output=True, text=True, timeout=10
-            )
-
-        if result.returncode != 0:
-            return False, "npm is not installed or not in PATH"
-
-        npm_version = result.stdout.strip()
-        logger.debug(f"Found npm version: {npm_version}")
-
-        return True, f"Node.js {node_version}, npm {npm_version}"
-
-    except subprocess.TimeoutExpired:
-        return False, "Timeout checking Node.js/npm installation"
-    except FileNotFoundError:
-        return False, "Node.js/npm not found. Please install Node.js from https://nodejs.org/"
-    except Exception as e:
-        return False, f"Error checking Node.js/npm: {str(e)}"
-
-
 def install_frontend_dependencies(frontend_path: Path) -> bool:
     """
     Install frontend dependencies if node_modules doesn't exist.
@@ -341,24 +301,7 @@ def install_frontend_dependencies(frontend_path: Path) -> bool:
     logger.info("Installing frontend dependencies (this may take a few minutes)...")
 
     try:
-        # Use shell=True on Windows for npm commands
-        if platform.system() == "Windows":
-            result = subprocess.run(
-                ["npm", "install"],
-                cwd=frontend_path,
-                capture_output=True,
-                text=True,
-                timeout=300,  # 5 minutes timeout
-                shell=True,
-            )
-        else:
-            result = subprocess.run(
-                ["npm", "install"],
-                cwd=frontend_path,
-                capture_output=True,
-                text=True,
-                timeout=300,  # 5 minutes timeout
-            )
+        result = run_npm_command(["npm", "install"], frontend_path, timeout=300)
 
         if result.returncode == 0:
             logger.info("Frontend dependencies installed successfully")
@@ -642,6 +585,21 @@ def start_ui(
     env["HOST"] = "localhost"
     env["PORT"] = str(port)
 
+    # If nvm is installed, ensure it's available in the environment
+    nvm_path = get_nvm_sh_path()
+    if platform.system() != "Windows" and nvm_path.exists():
+        # Add nvm to PATH for the subprocess
+        nvm_dir = get_nvm_dir()
+        # Find the latest Node.js version installed via nvm
+        nvm_versions = nvm_dir / "versions" / "node"
+        if nvm_versions.exists():
+            versions = sorted(nvm_versions.iterdir(), reverse=True)
+            if versions:
+                latest_node_bin = versions[0] / "bin"
+                if latest_node_bin.exists():
+                    current_path = env.get("PATH", "")
+                    env["PATH"] = f"{latest_node_bin}:{current_path}"
+
     # Start the development server
     logger.info(f"Starting frontend server at http://localhost:{port}")
     logger.info("This may take a moment to compile and start...")
@@ -659,14 +617,26 @@ def start_ui(
                 shell=True,
             )
         else:
-            process = subprocess.Popen(
-                ["npm", "run", "dev"],
-                cwd=frontend_path,
-                env=env,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                preexec_fn=os.setsid if hasattr(os, "setsid") else None,
-            )
+            # On Unix-like systems, use bash with nvm sourced if available
+            if nvm_path.exists():
+                # Use bash to source nvm and run npm
+                process = subprocess.Popen(
+                    ["bash", "-c", f"source {nvm_path} && npm run dev"],
+                    cwd=frontend_path,
+                    env=env,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    preexec_fn=os.setsid if hasattr(os, "setsid") else None,
+                )
+            else:
+                process = subprocess.Popen(
+                    ["npm", "run", "dev"],
+                    cwd=frontend_path,
+                    env=env,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    preexec_fn=os.setsid if hasattr(os, "setsid") else None,
+                )
 
         # Start threads to stream frontend output with prefix
         _stream_process_output(process, "stdout", "[FRONTEND]", "\033[33m")  # Yellow

cognee/context_global_variables.py

@@ -4,9 +4,10 @@ from typing import Union
 from uuid import UUID
 
 from cognee.base_config import get_base_config
-from cognee.infrastructure.databases.vector.config import get_vectordb_context_config
-from cognee.infrastructure.databases.graph.config import get_graph_context_config
+from cognee.infrastructure.databases.vector.config import get_vectordb_config
+from cognee.infrastructure.databases.graph.config import get_graph_config
 from cognee.infrastructure.databases.utils import get_or_create_dataset_database
+from cognee.infrastructure.databases.utils import resolve_dataset_database_connection_info
 from cognee.infrastructure.files.storage.config import file_storage_config
 from cognee.modules.users.methods import get_user
 
@@ -16,22 +17,59 @@ vector_db_config = ContextVar("vector_db_config", default=None)
 graph_db_config = ContextVar("graph_db_config", default=None)
 session_user = ContextVar("session_user", default=None)
 
-VECTOR_DBS_WITH_MULTI_USER_SUPPORT = ["lancedb", "falkor"]
-GRAPH_DBS_WITH_MULTI_USER_SUPPORT = ["kuzu", "falkor"]
-
 
 async def set_session_user_context_variable(user):
     session_user.set(user)
 
 
 def multi_user_support_possible():
-    graph_db_config = get_graph_context_config()
-    vector_db_config = get_vectordb_context_config()
-    return (
-        graph_db_config["graph_database_provider"] in GRAPH_DBS_WITH_MULTI_USER_SUPPORT
-        and vector_db_config["vector_db_provider"] in VECTOR_DBS_WITH_MULTI_USER_SUPPORT
+    graph_db_config = get_graph_config()
+    vector_db_config = get_vectordb_config()
+
+    graph_handler = graph_db_config.graph_dataset_database_handler
+    vector_handler = vector_db_config.vector_dataset_database_handler
+    from cognee.infrastructure.databases.dataset_database_handler import (
+        supported_dataset_database_handlers,
     )
 
+    if graph_handler not in supported_dataset_database_handlers:
+        raise EnvironmentError(
+            "Unsupported graph dataset to database handler configured. Cannot add support for multi-user access control mode. Please use a supported graph dataset to database handler or set the environment variables ENABLE_BACKEND_ACCESS_CONTROL to false to switch off multi-user access control mode.\n"
+            f"Selected graph dataset to database handler: {graph_handler}\n"
+            f"Supported dataset to database handlers: {list(supported_dataset_database_handlers.keys())}\n"
+        )
+
+    if vector_handler not in supported_dataset_database_handlers:
+        raise EnvironmentError(
+            "Unsupported vector dataset to database handler configured. Cannot add support for multi-user access control mode. Please use a supported vector dataset to database handler or set the environment variables ENABLE_BACKEND_ACCESS_CONTROL to false to switch off multi-user access control mode.\n"
+            f"Selected vector dataset to database handler: {vector_handler}\n"
+            f"Supported dataset to database handlers: {list(supported_dataset_database_handlers.keys())}\n"
+        )
+
+    if (
+        supported_dataset_database_handlers[graph_handler]["handler_provider"]
+        != graph_db_config.graph_database_provider
+    ):
+        raise EnvironmentError(
+            "The selected graph dataset to database handler does not work with the configured graph database provider. Cannot add support for multi-user access control mode. Please use a supported graph dataset to database handler or set the environment variables ENABLE_BACKEND_ACCESS_CONTROL to false to switch off multi-user access control mode.\n"
+            f"Selected graph database provider: {graph_db_config.graph_database_provider}\n"
+            f"Selected graph dataset to database handler: {graph_handler}\n"
+            f"Supported dataset to database handlers: {list(supported_dataset_database_handlers.keys())}\n"
+        )
+
+    if (
+        supported_dataset_database_handlers[vector_handler]["handler_provider"]
+        != vector_db_config.vector_db_provider
+    ):
+        raise EnvironmentError(
+            "The selected vector dataset to database handler does not work with the configured vector database provider. Cannot add support for multi-user access control mode. Please use a supported vector dataset to database handler or set the environment variables ENABLE_BACKEND_ACCESS_CONTROL to false to switch off multi-user access control mode.\n"
+            f"Selected vector database provider: {vector_db_config.vector_db_provider}\n"
+            f"Selected vector dataset to database handler: {vector_handler}\n"
+            f"Supported dataset to database handlers: {list(supported_dataset_database_handlers.keys())}\n"
+        )
+
+    return True
+
 
 def backend_access_control_enabled():
     backend_access_control = os.environ.get("ENABLE_BACKEND_ACCESS_CONTROL", None)
@@ -41,12 +79,7 @@ def backend_access_control_enabled():
         return multi_user_support_possible()
     elif backend_access_control.lower() == "true":
         # If enabled, ensure that the current graph and vector DBs can support it
-        multi_user_support = multi_user_support_possible()
-        if not multi_user_support:
-            raise EnvironmentError(
-                "ENABLE_BACKEND_ACCESS_CONTROL is set to true but the current graph and/or vector databases do not support multi-user access control. Please use supported databases or disable backend access control."
-            )
-        return True
+        return multi_user_support_possible()
     return False
 
 
@@ -76,6 +109,8 @@ async def set_database_global_context_variables(dataset: Union[str, UUID], user_
 
     # To ensure permissions are enforced properly all datasets will have their own databases
     dataset_database = await get_or_create_dataset_database(dataset, user)
+    # Ensure that all connection info is resolved properly
+    dataset_database = await resolve_dataset_database_connection_info(dataset_database)
 
     base_config = get_base_config()
     data_root_directory = os.path.join(
@@ -86,6 +121,8 @@ async def set_database_global_context_variables(dataset: Union[str, UUID], user_
     )
 
     # Set vector and graph database configuration based on dataset database information
+    # TODO: Add better handling of vector and graph config accross Cognee.
+    #  LRU_CACHE takes into account order of inputs, if order of inputs is changed it will be registered as a new DB adapter
     vector_config = {
         "vector_db_provider": dataset_database.vector_database_provider,
         "vector_db_url": dataset_database.vector_database_url,
@@ -101,6 +138,14 @@ async def set_database_global_context_variables(dataset: Union[str, UUID], user_
         "graph_file_path": os.path.join(
             databases_directory_path, dataset_database.graph_database_name
         ),
+        "graph_database_username": dataset_database.graph_database_connection_info.get(
+            "graph_database_username", ""
+        ),
+        "graph_database_password": dataset_database.graph_database_connection_info.get(
+            "graph_database_password", ""
+        ),
+        "graph_dataset_database_handler": "",
+        "graph_database_port": "",
     }
 
     storage_config = {