codegraphcontext 0.4.5__py3-none-any.whl → 0.4.6__py3-none-any.whl

codegraphcontext/cli/config_manager.py

@@ -19,7 +19,10 @@ CONFIG_DIR = Path.home() / ".codegraphcontext"
 CONFIG_FILE = CONFIG_DIR / ".env"
 
 # Database credential keys (stored in same .env file but not managed as config)
-DATABASE_CREDENTIAL_KEYS = {"NEO4J_URI", "NEO4J_USERNAME", "NEO4J_PASSWORD", "NEO4J_DATABASE"}
+DATABASE_CREDENTIAL_KEYS = {
+    "NEO4J_URI", "NEO4J_USERNAME", "NEO4J_PASSWORD", "NEO4J_DATABASE",
+    "NORNIC_URI", "NORNIC_USERNAME", "NORNIC_PASSWORD", "NORNIC_DATABASE"
+}
 
 # Default configuration values
 DEFAULT_CONFIG = {
@@ -47,11 +50,16 @@ DEFAULT_CONFIG = {
     "SCIP_INDEXER": "false",
     "SCIP_LANGUAGES": "python,typescript,go,rust,java",
     "SKIP_EXTERNAL_RESOLUTION": "false",
+    # 0 = unlimited; any positive integer caps MCP tool response size.
+    "MAX_TOOL_RESPONSE_TOKENS": "0",
+    # JSON object mapping tool names to integer result-count limits.
+    # Example: {"find_code": 20, "analyze_code_relationships": 10, "find_dead_code": 30}
+    "TOOL_RESULT_LIMITS": "{}",
 }
 
 # Configuration key descriptions
 CONFIG_DESCRIPTIONS = {
-    "DEFAULT_DATABASE": "Default database backend (neo4j|falkordb|kuzudb)",
+    "DEFAULT_DATABASE": "Default database backend (neo4j|falkordb|kuzudb|nornic)",
     "FALKORDB_PATH": "Path to FalkorDB database file",
     "FALKORDB_SOCKET_PATH": "Path to FalkorDB Unix socket",
     "INDEX_VARIABLES": "Index variable nodes in the graph (lighter graph if false)",
@@ -74,11 +82,13 @@ CONFIG_DESCRIPTIONS = {
     "SCIP_INDEXER": "Use SCIP-based indexing for higher accuracy call/inheritance resolution (requires scip-<lang> tools installed)",
     "SCIP_LANGUAGES": "Comma-separated languages to index via SCIP when SCIP_INDEXER=true (python,typescript,go,rust,java)",
     "SKIP_EXTERNAL_RESOLUTION": "Skip resolution attempts for external library method calls (recommended for enterprise large Java/Spring codebases)",
+    "MAX_TOOL_RESPONSE_TOKENS": "Maximum tokens per MCP tool response (0 = unlimited). Truncates oversized payloads and appends a notice.",
+    "TOOL_RESULT_LIMITS": "JSON object mapping tool names to max result counts, e.g. {\"find_code\": 20, \"analyze_code_relationships\": 10}. Missing keys use built-in defaults.",
 }
 
 # Valid values for each config key
 CONFIG_VALIDATORS = {
-    "DEFAULT_DATABASE": ["neo4j", "falkordb", "falkordb-remote", "kuzudb"],
+    "DEFAULT_DATABASE": ["neo4j", "falkordb", "falkordb-remote", "kuzudb", "nornic"],
     "INDEX_VARIABLES": ["true", "false"],
     "ALLOW_DB_DELETION": ["true", "false"],
     "DEBUG_LOGS": ["true", "false"],
@@ -342,6 +352,26 @@ def validate_config_value(key: str, value: str) -> tuple[bool, Optional[str]]:
                 return False, "PARALLEL_WORKERS must be between 1 and 32"
         except ValueError:
             return False, "PARALLEL_WORKERS must be a number"
+
+    if key == "MAX_TOOL_RESPONSE_TOKENS":
+        try:
+            limit = int(value)
+            if limit < 0:
+                return False, "MAX_TOOL_RESPONSE_TOKENS must be 0 (unlimited) or a positive integer"
+        except ValueError:
+            return False, "MAX_TOOL_RESPONSE_TOKENS must be an integer (0 = unlimited)"
+
+    if key == "TOOL_RESULT_LIMITS":
+        import json as _json
+        try:
+            parsed = _json.loads(value)
+            if not isinstance(parsed, dict):
+                return False, "TOOL_RESULT_LIMITS must be a JSON object, e.g. {\"find_code\": 20}"
+            for k, v in parsed.items():
+                if not isinstance(v, int) or v < 1:
+                    return False, f"TOOL_RESULT_LIMITS: value for '{k}' must be a positive integer"
+        except _json.JSONDecodeError:
+            return False, "TOOL_RESULT_LIMITS must be valid JSON, e.g. {\"find_code\": 20, \"find_dead_code\": 30}"
     
     if key == "MAX_DEPTH":
         if value.lower() != "unlimited":

codegraphcontext/cli/setup_wizard.py

@@ -54,15 +54,18 @@ def _save_neo4j_credentials(creds):
 
 def _generate_mcp_json(creds):
     """Generates and prints the MCP JSON configuration."""
-    cgc_path = shutil.which("cgc") or sys.executable
+    cgc_path = shutil.which("cgc")
+    pipx_path = shutil.which("pipx")
 
-    if "python" in Path(cgc_path).name:
-        # fallback to running as module if no cgc binary is found
+    if cgc_path:
         command = cgc_path
-        args = ["-m", "cgc", "mcp", "start"]
+        args = ["mcp", "start"]
+    elif pipx_path:
+        command = pipx_path
+        args = ["run", "codegraphcontext", "mcp", "start"]
     else:
-        command = cgc_path
-        args = ["mcp","start"]
+        command = sys.executable
+        args = ["-m", "codegraphcontext", "mcp", "start"]
 
     mcp_config = {
         "mcpServers": {
@@ -84,6 +87,7 @@ def _generate_mcp_json(creds):
                         "list_indexed_repositories", "delete_repository", "list_watched_paths", 
                         "unwatch_directory", "visualize_graph_query"
                     ],
+                    "disabledTools": [],
                     "disabled": False
                 },
                 "disabled": False,
@@ -424,15 +428,18 @@ def configure_mcp_client():
         env_vars[key] = value
     
     # Generate MCP configuration
-    cgc_path = shutil.which("cgc") or sys.executable
+    cgc_path = shutil.which("cgc")
+    pipx_path = shutil.which("pipx")
 
-    if "python" in Path(cgc_path).name:
-        # fallback to running as module if no cgc binary is found
-        command = cgc_path
-        args = ["-m", "cgc", "mcp", "start"]
-    else:
+    if cgc_path:
         command = cgc_path
         args = ["mcp", "start"]
+    elif pipx_path:
+        command = pipx_path
+        args = ["run", "codegraphcontext", "mcp", "start"]
+    else:
+        command = sys.executable
+        args = ["-m", "codegraphcontext", "mcp", "start"]
 
     # Create MCP config with complete env section
     mcp_config = {
@@ -451,6 +458,7 @@ def configure_mcp_client():
                         "list_indexed_repositories", "delete_repository", "list_watched_paths", 
                         "unwatch_directory", "visualize_graph_query"
                     ],
+                    "disabledTools": [],
                     "disabled": False
                 },
                 "disabled": False,

codegraphcontext/core/__init__.py

@@ -52,7 +52,15 @@ def _is_neo4j_configured() -> bool:
         os.getenv('NEO4J_PASSWORD')
     ])
 
-def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager']:
+def _is_nornic_configured() -> bool:
+    """Check if Nornic is configured with credentials."""
+    return all([
+        os.getenv('NORNIC_URI'),
+        os.getenv('NORNIC_USERNAME'),
+        os.getenv('NORNIC_PASSWORD')
+    ])
+
+def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager', 'NornicDBManager']:
     """
     Factory function to get the appropriate database manager based on configuration.
 
@@ -111,8 +119,15 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
             from .database import DatabaseManager
             info_logger("Using Neo4j Server (explicit)")
             return DatabaseManager()
+
+        elif db_type == 'nornic':
+            if not _is_nornic_configured():
+                raise ValueError("Database set to 'nornic' but it is not configured.")
+            from .database_nornic import NornicDBManager
+            info_logger("Using Nornic DB (explicit)")
+            return NornicDBManager()
         else:
-            raise ValueError(f"Unknown database type: '{db_type}'. Use 'kuzudb', 'falkordb', 'falkordb-remote', or 'neo4j'.")
+            raise ValueError(f"Unknown database type: '{db_type}'. Use 'kuzudb', 'falkordb', 'falkordb-remote', 'neo4j', or 'nornic'.")
 
     # Implicit: remote FalkorDB when FALKORDB_HOST is set (explicit infra signal)
     if _is_falkordb_remote_configured():
@@ -146,6 +161,12 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
         info_logger("Using Neo4j Server (auto-detected)")
         return DatabaseManager()
 
+    # Implicit: Nornic when configured
+    if _is_nornic_configured():
+        from .database_nornic import NornicDBManager
+        info_logger("Using Nornic DB (auto-detected)")
+        return NornicDBManager()
+
     error_msg = "No database backend available.\n"
     error_msg += "Recommended: Install KùzuDB for zero-config ('pip install real_ladybug')\n"
 
@@ -161,5 +182,6 @@ from .database import DatabaseManager
 from .database_falkordb import FalkorDBManager
 from .database_falkordb_remote import FalkorDBRemoteManager
 from .database_kuzu import KuzuDBManager
+from .database_nornic import NornicDBManager
 
-__all__ = ['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager', 'get_database_manager']
+__all__ = ['DatabaseManager', 'FalkorDBManager', 'FalkorDBRemoteManager', 'KuzuDBManager', 'NornicDBManager', 'get_database_manager']

codegraphcontext/core/cgc_bundle.py

@@ -28,6 +28,7 @@ from datetime import datetime, date
 import subprocess
 
 from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
+from codegraphcontext.utils.git_utils import get_repo_commit_hash
 
 
 class _BundleEncoder(json.JSONEncoder):
@@ -293,15 +294,9 @@ class CGCBundle:
             
             # Try to get git information if available
             if repo_path and repo_path.exists():
-                try:
-                    commit = subprocess.check_output(
-                        ['git', 'rev-parse', 'HEAD'],
-                        cwd=repo_path,
-                        stderr=subprocess.DEVNULL
-                    ).decode().strip()
+                commit = get_repo_commit_hash(repo_path)
+                if commit:
                     metadata["commit"] = commit[:8]
-                except (subprocess.CalledProcessError, FileNotFoundError):
-                    pass
 
                 try:
                     result = session.run("""

codegraphcontext/core/database_falkordb.py

@@ -356,6 +356,18 @@ class FalkorDBSessionWrapper:
         """
         Execute a Cypher query on FalkorDB.
         """
+        constraint_command = self._translate_constraint_command(query)
+        if constraint_command is not None:
+            try:
+                self.graph.execute_command(*constraint_command)
+                return FalkorDBResultWrapper(None)
+            except Exception as e:
+                error_msg = str(e).lower()
+                if "already exists" in error_msg or "already created" in error_msg:
+                    return FalkorDBResultWrapper(None)
+                error_logger(f"FalkorDB constraint failed: {constraint_command!r} Error: {e}")
+                raise
+
         # Translate Neo4j schema queries to FalkorDB syntax
         query = self._translate_schema_query(query)
         
@@ -371,6 +383,56 @@ class FalkorDBSessionWrapper:
             error_logger(f"FalkorDB query failed: {query[:100]}... Error: {e}")
             raise
 
+    def _translate_constraint_command(self, query: str):
+        """
+        Translate Neo4j-style CREATE CONSTRAINT queries to GRAPH.CONSTRAINT CREATE.
+        FalkorDB 4.16.x expects this command path instead of GRAPH.QUERY.
+        """
+        q_upper = query.upper()
+        if "CREATE CONSTRAINT" not in q_upper:
+            return None
+
+        normalized = re.sub(r"\s+IF NOT EXISTS", "", query, flags=re.IGNORECASE)
+        normalized = re.sub(r"\s+", " ", normalized).strip()
+
+        entity_match = re.search(r"FOR\s*\((\w+):([^)]+)\)", normalized, flags=re.IGNORECASE)
+        if not entity_match:
+            return None
+        entity_type = "NODE"
+        label = entity_match.group(2).strip()
+
+        composite_match = re.search(
+            r"REQUIRE\s*\(([^)]+)\)\s*IS\s+UNIQUE",
+            normalized,
+            flags=re.IGNORECASE,
+        )
+        single_match = re.search(
+            r"REQUIRE\s+\w+\.([A-Za-z_][A-Za-z0-9_]*)\s+IS\s+UNIQUE",
+            normalized,
+            flags=re.IGNORECASE,
+        )
+
+        if composite_match:
+            props = [part.split(".")[-1].strip() for part in composite_match.group(1).split(",") if part.strip()]
+            constraint_type = "UNIQUE"
+        elif single_match:
+            props = [single_match.group(1).strip()]
+            constraint_type = "UNIQUE"
+        else:
+            return None
+
+        return [
+            "GRAPH.CONSTRAINT",
+            "CREATE",
+            self.graph.name,
+            constraint_type,
+            entity_type,
+            label,
+            "PROPERTIES",
+            len(props),
+            *props,
+        ]
+
     def _translate_schema_query(self, query: str) -> str:
         """Translate Neo4j schema queries to FalkorDB/RedisGraph syntax."""
         q_upper = query.upper()
@@ -379,26 +441,9 @@ class FalkorDBSessionWrapper:
         if "CREATE FULLTEXT INDEX" in q_upper:
             return "RETURN 1"
             
-        # Handle Constraints
+        # Handle Constraints through GRAPH.CONSTRAINT in run()
         if "CREATE CONSTRAINT" in q_upper:
-            # Remove "IF NOT EXISTS"
-            query = re.sub(r'\s+IF NOT EXISTS', '', query, flags=re.IGNORECASE)
-            
-            # Handle composite keys: (n.p1, n.p2) -> downgrade to INDEX
-            if "," in query:
-                match_node = re.search(r'FOR\s+(\([^)]+\))', query, flags=re.IGNORECASE)
-                match_props = re.search(r'REQUIRE\s+(\([^)]+\))\s+IS UNIQUE', query, flags=re.IGNORECASE)
-                
-                if match_node and match_props:
-                    return f"CREATE INDEX FOR {match_node.group(1)} ON {match_props.group(1)}"
-
-            # Handle simple uniqueness: CREATE CONSTRAINT name FOR (n:Label) REQUIRE n.prop IS UNIQUE
-            # TO: CREATE CONSTRAINT ON (n:Label) ASSERT n.prop IS UNIQUE
-            
-            # Remove constraint name
-            query = re.sub(r'CREATE CONSTRAINT\s+\w+\s+', 'CREATE CONSTRAINT ', query, flags=re.IGNORECASE)
-            query = re.sub(r'\s+FOR\s+', ' ON ', query, flags=re.IGNORECASE)
-            query = re.sub(r'\s+REQUIRE\s+', ' ASSERT ', query, flags=re.IGNORECASE)
+            return "RETURN 1"
             
         # Handle Regular Indexes
         elif "CREATE INDEX" in q_upper:

codegraphcontext/core/database_kuzu.py

@@ -99,7 +99,7 @@ class KuzuDBManager:
         # but we can wrap in try-except or check metadata.
         
         node_tables = [
-            ("Repository", "path STRING, name STRING, is_dependency BOOLEAN, PRIMARY KEY (path)"),
+            ("Repository", "path STRING, name STRING, is_dependency BOOLEAN, indexed_at STRING, commit_hash STRING, PRIMARY KEY (path)"),
             ("File", "path STRING, name STRING, relative_path STRING, is_dependency BOOLEAN, PRIMARY KEY (path)"),
             ("Directory", "path STRING, name STRING, PRIMARY KEY (path)"),
             ("Module", "name STRING, lang STRING, full_import_name STRING, PRIMARY KEY (name)"),
@@ -164,6 +164,9 @@ class KuzuDBManager:
             ("Module", "full_import_name", "STRING"),
             ("IMPORTS", "full_import_name", "STRING"),
             ("IMPORTS", "imported_name", "STRING"),
+            # Freshness properties added to Repository in 0.4.6
+            ("Repository", "indexed_at", "STRING"),
+            ("Repository", "commit_hash", "STRING"),
         ]
 
         for table_name, column_name, column_type in migrations:
@@ -171,7 +174,7 @@ class KuzuDBManager:
                 self._conn.execute(f"ALTER TABLE `{table_name}` ADD {column_name} {column_type}")
             except Exception as e:
                 err = str(e).lower()
-                if "already exists" in err or "duplicate" in err:
+                if "already exists" in err or "duplicate" in err or "already has property" in err:
                     continue
                 warning_logger(f"Kuzu Schema Migration Error ({table_name}.{column_name}): {e}")
                 debug_log(f"Kuzu Schema Migration Error ({table_name}.{column_name}): {e}")
@@ -277,6 +280,32 @@ class KuzuSessionWrapper:
             err_str = str(e).lower()
             if "already exists" in err_str:
                 return KuzuResultWrapper(None)
+            
+            # Fallback for KuzuDB UNWIND bug (unordered_map::at)
+            if "unordered_map::at" in err_str and "UNWIND" in query:
+                unwind_m = re.search(r'UNWIND\s+\$(\w+)\s+AS\s+(\w+)', query)
+                if unwind_m:
+                    batch_param = unwind_m.group(1)
+                    row_var = unwind_m.group(2)
+                    batch_data = parameters.get(batch_param)
+                    if isinstance(batch_data, list):
+                        loop_query = re.sub(r'UNWIND\s+\$\w+\s+AS\s+\w+', '', query, count=1)
+                        # Find all row.prop usages and replace with $row_prop
+                        props_used = set(re.findall(rf'{row_var}\.(\w+)', loop_query))
+                        for p in props_used:
+                            loop_query = loop_query.replace(f"{row_var}.{p}", f"${row_var}_{p}")
+                        
+                        last_result = None
+                        for item in batch_data:
+                            loop_params = parameters.copy()
+                            loop_params.pop(batch_param, None)
+                            for p in props_used:
+                                loop_params[f"{row_var}_{p}"] = item.get(p)
+                            if "uid" in item:
+                                loop_params[f"{row_var}_uid"] = item["uid"]
+                            last_result = self.run(loop_query, **loop_params)
+                        return last_result or KuzuResultWrapper(None)
+
             error_logger(f"Kuzu Query failed: {query[:100]}... Error: {e}")
             debug_log(f"Kuzu Query failed: {query[:100]}... Error: {e}")
             raise

codegraphcontext/core/database_nornic.py

@@ -0,0 +1,204 @@
+# src/codegraphcontext/core/database_nornic.py
+"""
+This module provides a thread-safe singleton manager for the Nornic DB connection.
+Nornic DB is compatible with Neo4j APIs and drivers.
+"""
+import os
+import re
+import threading
+from typing import Optional, Tuple
+from neo4j import GraphDatabase, Driver
+
+from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
+
+class NornicDriverWrapper:
+    """
+    A simple wrapper around the Nornic (Neo4j) Driver to inject a database name into session() calls.
+    """
+    def __init__(self, driver: Driver, database: str = None):
+        self._driver = driver
+        self._database = database
+
+    def session(self, **kwargs):
+        """Proxy method to get a session from the underlying driver."""
+        if self._database and 'database' not in kwargs:
+            kwargs["database"] = self._database
+        return self._driver.session(**kwargs)
+    
+    def close(self):
+        """Proxy method to close the underlying driver."""
+        self._driver.close()
+
+class NornicDBManager:
+    """
+    Manages the Nornic database driver as a singleton to ensure only one
+    connection pool is created and shared across the application.
+    """
+    _instance = None
+    _driver: Optional[Driver] = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        """Standard singleton pattern implementation."""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(NornicDBManager, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        """
+        Initializes the manager by reading credentials from environment variables.
+        The `_initialized` flag prevents re-initialization on subsequent calls.
+        """
+        if hasattr(self, '_initialized'):
+            return
+
+        self.nornic_uri = os.getenv('NORNIC_URI')
+        self.nornic_username = os.getenv('NORNIC_USERNAME', 'nornic')
+        self.nornic_password = os.getenv('NORNIC_PASSWORD')
+        self.nornic_database = os.getenv('NORNIC_DATABASE') 
+        self._initialized = True
+
+    def get_driver(self) -> Driver:
+        """
+        Gets the Nornic driver instance, creating it if it doesn't exist.
+        This method is thread-safe.
+
+        Returns:
+            The a wrapper for Nornic Driver instance.
+        """
+        if self._driver is None:
+            with self._lock:
+                if self._driver is None:
+                    if not all([self.nornic_uri, self.nornic_username, self.nornic_password]):
+                        raise ValueError(
+                            "Nornic credentials must be set via environment variables:\n"
+                            "- NORNIC_URI\n"
+                            "- NORNIC_USERNAME\n"
+                            "- NORNIC_PASSWORD"
+                        )
+                    
+                    is_valid, validation_error = self.validate_config(
+                        self.nornic_uri, 
+                        self.nornic_username, 
+                        self.nornic_password
+                    )
+                    
+                    if not is_valid:
+                        error_logger(f"Nornic configuration validation failed: {validation_error}")
+                        raise ValueError(validation_error)
+
+                    info_logger(f"Creating Nornic driver connection to {self.nornic_uri}")
+                    self._driver = GraphDatabase.driver(
+                        self.nornic_uri,
+                        auth=(self.nornic_username, self.nornic_password)
+                    )
+                    try:
+                        with self._driver.session() as session:
+                            session.run("RETURN 1").consume()
+                        info_logger("Nornic connection established successfully")
+                    except Exception as e:
+                        _, detailed_error = self.test_connection(
+                            self.nornic_uri,
+                            self.nornic_username,
+                            self.nornic_password
+                        )
+                        error_logger(f"Failed to connect to Nornic: {e}")
+                        if self._driver:
+                            self._driver.close()
+                        self._driver = None
+                        raise
+        return NornicDriverWrapper(self._driver, database=self.nornic_database)
+
+    def close_driver(self):
+        """Closes the Nornic driver connection if it exists."""
+        if self._driver is not None:
+            with self._lock:
+                if self._driver is not None:
+                    info_logger("Closing Nornic driver")
+                    self._driver.close()
+                    self._driver = None
+
+    def is_connected(self) -> bool:
+        """Checks if the database connection is currently active."""
+        if self._driver is None:
+            return False
+        try:
+            session_kwargs = {}
+            if self.nornic_database:
+                session_kwargs['database'] = self.nornic_database
+            with self._driver.session(**session_kwargs) as session:
+                session.run("RETURN 1").consume()
+            return True
+        except Exception:
+            return False
+    
+    def get_backend_type(self) -> str:
+        """Returns the database backend type."""
+        return 'nornic'
+
+    @staticmethod
+    def validate_config(uri: str, username: str, password: str) -> Tuple[bool, Optional[str]]:
+        """
+        Validates Nornic configuration parameters.
+        """
+        # Nornic likely uses similar URI formats to Neo4j/Bolt
+        uri_pattern = r'^(nornic|nornic\+s|nornic\+ssc|bolt|bolt\+s|bolt\+ssc|neo4j|neo4j\+s|neo4j\+ssc)://[^:]+(:\d+)?$'
+        if not re.match(uri_pattern, uri):
+            return False, (
+                "Invalid Nornic URI format.\n"
+                "Expected format: nornic://host:port or bolt://host:port\n"
+                "Example: nornic://localhost:7687"
+            )
+        
+        if not username or len(username.strip()) == 0:
+            return False, "Username cannot be empty."
+        
+        if not password or len(password.strip()) == 0:
+            return False, "Password cannot be empty."
+        
+        return True, None
+
+    @staticmethod
+    def test_connection(uri: str, username: str, password: str, database: str=None) -> Tuple[bool, Optional[str]]:
+        """
+        Tests the Nornic database connection.
+        """
+        try:
+            from neo4j import GraphDatabase
+            import socket
+            
+            try:
+                host_port = uri.split('://')[1]
+                if ':' in host_port:
+                    host = host_port.split(':')[0]
+                    port = int(host_port.split(':')[1])
+                else:
+                    host = host_port
+                    port = 7687 
+                
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(5)
+                result = sock.connect_ex((host, port))
+                sock.close()
+                
+                if result != 0:
+                    return False, f"Cannot reach Nornic server at {host}:{port}"
+            except Exception as e:
+                return False, f"Error parsing URI or checking connectivity: {str(e)}"
+            
+            driver = GraphDatabase.driver(uri, auth=(username, password))
+            
+            session_kwargs = {}
+            if database:
+                session_kwargs['database'] = database
+            with driver.session(**session_kwargs) as session:
+                result = session.run("RETURN 'Connection successful' as status")
+                result.single()
+            
+            driver.close()
+            return True, None
+            
+        except Exception as e:
+            return False, f"Connection failed: {str(e)}"