graphdatascience 1.20a2__tar.gz → 1.21a2__tar.gz

{graphdatascience-1.20a2/src/graphdatascience.egg-info → graphdatascience-1.21a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphdatascience
-Version: 1.20a2
+Version: 1.21a2
 Summary: A Python client for the Neo4j Graph Data Science (GDS) library
 Author-email: Neo4j <team-gds@neo4j.org>
 License-Expression: Apache-2.0

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/pyproject.toml

@@ -54,13 +54,12 @@ rust-ext = ["neo4j-rust-ext >= 4.4.12, < 7.0"]
 
 
 [dependency-groups]
-# To install all development dependencies,
-# run `pip install --group dev -e .` inside repository root folder.#
 dev = [
     "tox>4.24",
     { include-group = "dev-base" },
     { include-group = "test" },
     { include-group = "docs-ci" },
+    { include-group = "notebook-base"}
 ]
 
 dev-base = [
@@ -79,6 +78,7 @@ dev-base = [
 ]
 test = [
     "pytest == 9.0.2",
+    "pytest-timeout",
     "requests_mock == 1.12.1",
     "pytest_mock == 3.15.1",
     "testcontainers == 4.14.0",
@@ -89,6 +89,7 @@ docs-ci = [
     "sphinx == 7.3.7",
     "enum-tools[sphinx]==0.13.0",
     "autodoc_pydantic",
+    "networkx >= 2.0, < 4.0"
 ]
 notebook-base = [
     "nbconvert==7.16.6",
@@ -111,6 +112,10 @@ notebook-ci = [
 
 publish = ["build", "twine"]
 
+[tool.uv.extra-build-dependencies]
+torch-sparse = ["torch"]
+torch-scatter = ["torch"]
+
 [tool.setuptools]
 include-package-data = true
 zip-safe = false

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/arrow_client/arrow_info.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from ..query_runner.query_runner import QueryRunner
-from ..server_version.server_version import ServerVersion
+from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
+from graphdatascience.server_version.server_version import ServerVersion
 
 
 @dataclass(frozen=True)
@@ -20,7 +21,7 @@ class ArrowInfo:
             debugYields.append("versions")
 
         procResult = query_runner.call_procedure(
-            endpoint="gds.debug.arrow", custom_error=False, yields=debugYields
+            endpoint="gds.debug.arrow", query_type=QueryType.SYSTEM, custom_error=False, yields=debugYields
         ).iloc[0]
 
         return ArrowInfo(

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/endpoints.py

@@ -43,6 +43,17 @@ class DirectEndpoints(
         super().__init__(query_runner, namespace, server_version)
 
 
+class DirectSessionEndpoints(
+    SingleModeAlgoEndpoints,
+    DirectSystemEndpoints,
+    DirectUtilEndpoints,
+    PipelineEndpoints,
+    ConfigEndpoints,
+):
+    def __init__(self, query_runner: QueryRunner, namespace: str, server_version: ServerVersion):
+        super().__init__(query_runner, namespace, server_version)
+
+
 """
 This class should inherit endpoint classes that only expose calls of the `gds.alpha` namespace.
 Example of such endpoints: "gds.alpha.listProgress".

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/graph/graph_cypher_runner.py

@@ -6,13 +6,13 @@ from typing import Any
 
 from pandas import Series
 
+from graphdatascience.caller_base import CallerBase
+from graphdatascience.graph.graph_create_result import GraphCreateResult
+from graphdatascience.graph.graph_object import Graph
 from graphdatascience.query_runner.query_mode import QueryMode
-
-from ..caller_base import CallerBase
-from ..query_runner.query_runner import QueryRunner
-from ..server_version.server_version import ServerVersion
-from .graph_create_result import GraphCreateResult
-from .graph_object import Graph
+from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
+from graphdatascience.server_version.server_version import ServerVersion
 
 
 class GraphCypherRunner(CallerBase):
@@ -48,7 +48,7 @@ class GraphCypherRunner(CallerBase):
         GraphCypherRunner._verify_query_ends_with_return_clause(self._namespace, query)
 
         result: dict[str, Any] | None = self._query_runner.run_retryable_cypher(
-            query, params, database, custom_error=False, mode=QueryMode.READ
+            query, QueryType.USER_DIRECTED, params, database, custom_error=False, mode=QueryMode.READ
         ).squeeze()
 
         if not result:

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/graph/graph_entity_ops_runner.py

@@ -8,6 +8,7 @@ import pandas as pd
 from pandas import DataFrame, Series
 
 from graphdatascience.query_runner.query_mode import QueryMode
+from graphdatascience.query_runner.query_type import QueryType
 
 from ..call_parameters import CallParameters
 from ..error.cypher_warning_handler import (
@@ -169,6 +170,7 @@ class GraphNodePropertiesRunner(GraphEntityOpsBaseRunner):
 
             db_properties_df = query_runner.run_retryable_cypher(
                 GraphNodePropertiesRunner._build_query(db_node_properties),
+                QueryType.USER_TRANSPILED,
                 params={"ids": unique_node_ids},
                 mode=QueryMode.READ,
             )

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/graph/v2/graph_api.py

@@ -106,7 +106,7 @@ class GraphV2:
         """
         return self._backend.graph_info().density
 
-    def memory_usage(self) -> str:
+    def memory_usage(self) -> str | None:
         """
         Returns:
             the memory usage of the graph

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/graph_data_science.py

@@ -22,6 +22,7 @@ from .query_runner.arrow_info import ArrowInfo
 from .query_runner.arrow_query_runner import ArrowQueryRunner
 from .query_runner.neo4j_query_runner import Neo4jQueryRunner
 from .query_runner.query_runner import QueryRunner
+from .query_runner.query_type import QueryType
 from .server_version.server_version import ServerVersion
 from .utils.util_proc_runner import UtilProcRunner
 from .version import __min_server_version__
@@ -93,7 +94,7 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
         if isinstance(endpoint, QueryRunner):
             self._query_runner = endpoint
         else:
-            db_auth = None
+            db_auth: neo4j.Auth | None = None
             if auth:
                 db_auth = neo4j.basic_auth(*auth)
             neo4j_query_runner = Neo4jQueryRunner.create_for_db(
@@ -118,21 +119,29 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             if auth is not None:
                 username, password = auth
                 arrow_auth = UsernamePasswordAuthentication(username, password)
+            if isinstance(endpoint, Neo4jQueryRunner):
+                if neo4j_auth := endpoint.get_auth():
+                    arrow_auth = UsernamePasswordAuthentication(neo4j_auth[0], neo4j_auth[1])
 
-            if arrow_client_options is None:
-                arrow_client_options = {}
-            if arrow_disable_server_verification:
-                disable_server_verification(arrow_client_options)
-            if arrow_tls_root_certs is not None:
-                set_tls_root_certs(arrow_client_options, arrow_tls_root_certs)
-            self._query_runner = ArrowQueryRunner.create(
-                self._query_runner,
-                arrow_info=arrow_info,
-                arrow_authentication=arrow_auth,
-                encrypted=self._query_runner.encrypted(),
-                arrow_client_options=arrow_client_options,
-                connection_string_override=None if arrow is True else arrow,
-            )
+            if isinstance(endpoint, Driver) and not auth:
+                warnings.warn(
+                    "Falling back to use Cypher for GDS. To use Arrow, you must explicitly provide the `auth` parameter."
+                )
+            else:
+                if arrow_client_options is None:
+                    arrow_client_options = {}
+                if arrow_disable_server_verification:
+                    disable_server_verification(arrow_client_options)
+                if arrow_tls_root_certs is not None:
+                    set_tls_root_certs(arrow_client_options, arrow_tls_root_certs)
+                self._query_runner = ArrowQueryRunner.create(
+                    self._query_runner,
+                    arrow_info=arrow_info,
+                    arrow_authentication=arrow_auth,
+                    encrypted=self._query_runner.encrypted(),
+                    arrow_client_options=arrow_client_options,
+                    connection_string_override=None if arrow is True else arrow,
+                )
 
         arrow_client = (
             None if not isinstance(self._query_runner, ArrowQueryRunner) else self._query_runner._gds_arrow_client
@@ -258,15 +267,16 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             The query result as a DataFrame
         """
         qr = self._query_runner
+        query_type = QueryType.USER_DIRECTED
 
         # The Arrow query runner should not be used to execute arbitrary Cypher
         if isinstance(self._query_runner, ArrowQueryRunner):
             qr = self._query_runner.fallback_query_runner()
 
         if retryable:
-            return qr.run_retryable_cypher(query, params, database, custom_error=False, mode=mode)
+            return qr.run_retryable_cypher(query, query_type, params, database, custom_error=False, mode=mode)
         else:
-            return qr.run_cypher(query, params, database, custom_error=False, mode=mode)
+            return qr.run_cypher(query, query_type, params, database, custom_error=False, mode=mode)
 
     def driver_config(self) -> dict[str, Any]:
         """
@@ -310,6 +320,7 @@ class GraphDataScience(DirectEndpoints, UncallableNamespace):
             The Neo4j Driver instance to use.
         auth : tuple[str, str] | None, default None
             A username, password pair for authentication.
+            Is required for enabling Arrow.
         database: str | None, default None
             The Neo4j database to query against.
         arrow : str | bool, default True

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/procedure_surface/api/catalog/catalog_endpoints.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from types import TracebackType
-from typing import NamedTuple, Type
+from typing import Any, NamedTuple, Type
 
 from pandas import DataFrame
+from pydantic import field_validator
 
 from graphdatascience.graph.v2.graph_api import GraphV2
 from graphdatascience.procedure_surface.api.base_result import BaseResult
@@ -245,7 +246,12 @@ class GraphGenerationStats(BaseResult):
     relationship_seed: int | None
     average_degree: float
     relationship_distribution: str
-    relationship_property: RelationshipPropertySpec
+    relationship_property: RelationshipPropertySpec | None
+
+    @field_validator("relationship_property", mode="before")
+    @classmethod
+    def check_empty_property(cls, value: Any) -> Any:
+        return value or None
 
 
 class RelationshipPropertySpec(BaseResult):

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/procedure_surface/api/catalog/graph_info.py

@@ -15,7 +15,7 @@ class GraphInfo(BaseResult):
     database: str
     database_location: str
     configuration: dict[str, Any]
-    memory_usage: str
+    memory_usage: str | None  # can be none if there was an error computing the usage
     size_in_bytes: int
     node_count: int
     relationship_count: int

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/procedure_surface/api/model/model_catalog_endpoints.py

@@ -69,7 +69,7 @@ class ModelCatalogEndpoints(ABC):
         """
 
     @abstractmethod
-    def drop(self, model_name: str, *, fail_if_missing: bool = False) -> ModelDetails:
+    def drop(self, model_name: str, *, fail_if_missing: bool = False) -> ModelDetails | None:
         """Drop a model from the in-memory catalog.
 
         Parameters
@@ -86,13 +86,15 @@ class ModelCatalogEndpoints(ABC):
         """
 
     @abstractmethod
-    def delete(self, model_name: str) -> ModelDeleteResult:
+    def delete(self, model_name: str, fail_if_missing: bool = False) -> ModelDeleteResult | None:
         """Delete a persisted model from storage.
 
         Parameters
         ----------
         model_name: str
             The model to delete.
+        fail_if_missing: bool
+            If True, a missing model will cause an error. If False, returns None when missing.
 
         Returns
         -------

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/procedure_surface/arrow/model/model_catalog_arrow_endpoints.py

@@ -45,23 +45,28 @@ class ModelCatalogArrowEndpoints(ModelCatalogEndpoints):
             raise ValueError(f"Model with name `{model_name}` does not exist")
         return self._to_model_details(items[0])
 
-    def drop(self, model_name: str, *, fail_if_missing: bool = False) -> ModelDetails:
+    def drop(self, model_name: str, *, fail_if_missing: bool = False) -> ModelDetails | None:
         raw = self._arrow_client.do_action_with_retry(
             "v2/model.drop",
             payload=json.dumps({"modelName": model_name, "failIfMissing": fail_if_missing}).encode("utf-8"),
         )
         items = deserialize(raw)
-        if not items:
+        if not items and fail_if_missing:
             raise ValueError(f"Model with name `{model_name}` does not exist")
+        if not items:
+            return None
         return self._to_model_details(items[0])
 
-    def delete(self, model_name: str) -> ModelDeleteResult:
+    def delete(self, model_name: str, fail_if_missing: bool = False) -> ModelDeleteResult | None:
         raw = self._arrow_client.do_action_with_retry(
-            "v2/model.delete", payload=json.dumps({"modelName": model_name}).encode("utf-8")
+            "v2/model.delete",
+            payload=json.dumps({"modelName": model_name, "failIfMissing": fail_if_missing}).encode("utf-8"),
         )
         items = deserialize(raw)
-        if not items:
+        if not items and fail_if_missing:
             raise ValueError(f"Model with name `{model_name}` does not exist")
+        if not items:
+            return None
         return ModelDeleteResult(**items[0])
 
     def load(self, model_name: str) -> ModelLoadResult:

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/procedure_surface/cypher/model/model_catalog_cypher_endpoints.py

@@ -44,18 +44,30 @@ class ModelCatalogCypherEndpoints(ModelCatalogEndpoints):
             raise ValueError(f"Model with name `{model_name}` does not exist")
         return self._to_model_details(df.iloc[0].to_dict())
 
-    def drop(self, model_name: str, *, fail_if_missing: bool = False) -> ModelDetails:
+    def drop(self, model_name: str, *, fail_if_missing: bool = False) -> ModelDetails | None:
         params = CallParameters(model_name=model_name, fail_if_missing=fail_if_missing)
         df = self._query_runner.call_procedure("gds.model.drop", params=params, custom_error=False)
-        if df.empty:
+        if df.empty and fail_if_missing:
             raise ValueError(f"Model with name `{model_name}` does not exist")
+        if df.empty:
+            return None
         return self._to_model_details(df.iloc[0].to_dict())
 
-    def delete(self, model_name: str) -> ModelDeleteResult:
+    def delete(self, model_name: str, fail_if_missing: bool = False) -> ModelDeleteResult | None:
         params = CallParameters(model_name=model_name)
-        df = self._query_runner.call_procedure("gds.model.delete", params=params, custom_error=False)
-        if df.empty:
+
+        try:
+            df = self._query_runner.call_procedure("gds.model.delete", params=params, custom_error=False)
+        except neo4j.exceptions.ClientError as e:
+            if "Model with name" not in str(e) or fail_if_missing:
+                raise e
+            else:
+                return None
+
+        if df.empty and fail_if_missing:
             raise ValueError(f"Model with name `{model_name}` does not exist")
+        if df.empty:
+            return None
         return ModelDeleteResult(**df.iloc[0].to_dict())
 
     def load(self, model_name: str) -> ModelLoadResult:

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/procedure_surface/utils/result_utils.py

@@ -4,6 +4,7 @@ from pandas import DataFrame
 
 from graphdatascience.query_runner.query_mode import QueryMode
 from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
 
 
 def transpose_property_columns(result: DataFrame, list_node_labels: bool) -> DataFrame:
@@ -25,6 +26,7 @@ def join_db_node_properties(result: DataFrame, db_node_properties: list[str], qu
     query = _build_query(db_node_properties)
     db_properties_df = query_runner.run_retryable_cypher(
         query,
+        QueryType.USER_TRANSPILED,
         params={"ids": (result["nodeId"].tolist())},
         mode=QueryMode.READ,
     )

graphdatascience-1.21a2/src/graphdatascience/query_runner/__init__.py

@@ -0,0 +1,5 @@
+from .query_mode import QueryMode
+from .query_runner import QueryRunner
+from .query_type import QueryType
+
+__all__ = ["QueryRunner", "QueryMode", "QueryType"]

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/query_runner/arrow_query_runner.py

@@ -9,6 +9,7 @@ from graphdatascience.arrow_client.authenticated_flight_client import Authentica
 from graphdatascience.arrow_client.v1.gds_arrow_client import GdsArrowClient
 from graphdatascience.query_runner.arrow_authentication import ArrowAuthentication
 from graphdatascience.query_runner.query_mode import QueryMode
+from graphdatascience.query_runner.query_type import QueryType
 from graphdatascience.retry_utils.retry_config import RetryConfigV2
 
 from ..call_parameters import CallParameters
@@ -64,31 +65,38 @@ class ArrowQueryRunner(QueryRunner):
     def run_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
         custom_error: bool = True,
     ) -> DataFrame:
-        return self._fallback_query_runner.run_cypher(query, params, database, mode, custom_error=custom_error)
+        return self._fallback_query_runner.run_cypher(
+            query, query_type, params, database, mode, custom_error=custom_error
+        )
 
     def run_retryable_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
         custom_error: bool = True,
     ) -> DataFrame:
         return self._fallback_query_runner.run_retryable_cypher(
-            query, params, database, mode, custom_error=custom_error
+            query, query_type, params, database, mode, custom_error=custom_error
         )
 
-    def call_function(self, endpoint: str, params: CallParameters | None = None) -> Any:
-        return self._fallback_query_runner.call_function(endpoint, params)
+    def call_function(
+        self, endpoint: str, query_type: QueryType = QueryType.USER_TRANSPILED, params: CallParameters | None = None
+    ) -> Any:
+        return self._fallback_query_runner.call_function(endpoint, query_type, params)
 
     def call_procedure(
         self,
         endpoint: str,
+        query_type: QueryType = QueryType.USER_TRANSPILED,
         params: CallParameters | None = None,
         yields: list[str] | None = None,
         database: str | None = None,
@@ -189,7 +197,14 @@ class ArrowQueryRunner(QueryRunner):
             )
 
         return self._fallback_query_runner.call_procedure(
-            endpoint, params, yields, database, logging=logging, retryable=retryable, custom_error=custom_error
+            endpoint,
+            query_type,
+            params,
+            yields,
+            database,
+            logging=logging,
+            retryable=retryable,
+            custom_error=custom_error,
         )
 
     def server_version(self) -> ServerVersion:

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/query_runner/cypher_graph_constructor.py

@@ -12,6 +12,7 @@ from graphdatascience.query_runner.query_mode import QueryMode
 from ..server_version.server_version import ServerVersion
 from .graph_constructor import GraphConstructor
 from .query_runner import QueryRunner
+from .query_type import QueryType
 
 
 class CypherProjectionApi:
@@ -107,6 +108,7 @@ class CypherGraphConstructor(GraphConstructor):
         try:
             license: str = self._query_runner.run_retryable_cypher(
                 "CALL gds.debug.sysInfo() YIELD key, value WHERE key = 'gdsEdition' RETURN value",
+                QueryType.SYSTEM,
                 custom_error=False,
                 mode=QueryMode.READ,
             ).squeeze()
@@ -215,6 +217,7 @@ class CypherGraphConstructor(GraphConstructor):
             # not using retryable here as gds.graph.project adds a graph to the gds graph catalog
             self._query_runner.run_cypher(
                 query,
+                QueryType.USER_TRANSPILED,
                 {
                     "data": combined_df.values.tolist(),
                     "graph_name": self._graph_name,
@@ -377,6 +380,7 @@ class CypherGraphConstructor(GraphConstructor):
 
             self._query_runner.run_cypher(
                 query,
+                QueryType.USER_TRANSPILED,
                 {
                     "graph_name": self._graph_name,
                     "node_query": node_query,

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/query_runner/db_environment_resolver.py

@@ -1,18 +1,22 @@
 from graphdatascience.query_runner.neo4j_query_runner import Neo4jQueryRunner
+from graphdatascience.query_runner.query_type import QueryType
 
 
 class DbEnvironmentResolver:
     @staticmethod
     def hosted_in_aura(db_runner: Neo4jQueryRunner) -> bool:
         return (
-            db_runner.run_retryable_cypher("""
+            db_runner.run_retryable_cypher(
+                """
         CALL dbms.components() YIELD name, versions
         WHERE name = "Neo4j Kernel"
         UNWIND versions as v
         WITH name, v
         WHERE v ENDS WITH "aura"
         RETURN count(*) <> 0
-        """)
+        """,
+                QueryType.SYSTEM,
+            )
             .iloc[0]
             .item()
         ) is True

{graphdatascience-1.20a2 → graphdatascience-1.21a2}/src/graphdatascience/query_runner/neo4j_query_runner.py

@@ -11,6 +11,8 @@ from pandas import DataFrame
 from tenacity import retry, retry_if_exception, stop_after_delay, wait_fixed
 
 from graphdatascience.query_runner.query_mode import QueryMode
+from graphdatascience.query_runner.query_runner import QueryRunner
+from graphdatascience.query_runner.query_type import QueryType
 from graphdatascience.retry_utils.neo4j_retry_helper import is_retryable_neo4j_exception
 
 from ..call_parameters import CallParameters
@@ -23,7 +25,6 @@ from ..version import __version__
 from .cypher_graph_constructor import CypherGraphConstructor
 from .graph_constructor import GraphConstructor
 from .progress.query_progress_logger import QueryProgressLogger
-from .query_runner import QueryRunner
 
 
 class Neo4jQueryRunner(QueryRunner):
@@ -155,12 +156,24 @@ class Neo4jQueryRunner(QueryRunner):
         # progress logging should not retry a lot as it perodically fetches the latest progress anyway
         connectivity_retry_config = Neo4jQueryRunner.ConnectivityRetriesConfig(max_retries=2)
         # not using retryable cypher as failing is okay
-        return self.run_cypher(query=query, database=database, connectivity_retry_config=connectivity_retry_config)
+        return self.run_cypher(
+            query=query,
+            query_type=QueryType.USER_TRANSPILED,
+            database=database,
+            connectivity_retry_config=connectivity_retry_config,
+        )
+
+    def get_auth(self) -> tuple[str, str] | None:
+        if isinstance(self._auth, neo4j.Auth):
+            return self._auth.principal, self._auth.credentials
+        else:
+            return self._auth
 
     # only use for user defined queries
     def run_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
@@ -186,7 +199,7 @@ class Neo4jQueryRunner(QueryRunner):
             default_access_mode=mode.neo4j_access_mode(),
         ) as session:
             try:
-                result = session.run(query, params)
+                result = session.run(self._wrap_query(query, query_type), params)
             except Exception as e:
                 if custom_error:
                     self.handle_driver_exception(session, e)
@@ -211,6 +224,7 @@ class Neo4jQueryRunner(QueryRunner):
     def run_retryable_cypher(
         self,
         query: str,
+        query_type: QueryType,
         params: dict[str, Any] | None = None,
         database: str | None = None,
         mode: QueryMode | None = None,
@@ -221,7 +235,7 @@ class Neo4jQueryRunner(QueryRunner):
             database = self._database
 
         if self._NEO4J_DRIVER_VERSION < SemanticVersion(5, 5, 0):
-            return self.run_cypher(query, params, database, mode, custom_error, connectivity_retry_config)
+            return self.run_cypher(query, query_type, params, database, mode, custom_error, connectivity_retry_config)
 
         if not mode:
             routing = neo4j.RoutingControl.WRITE
@@ -232,7 +246,7 @@ class Neo4jQueryRunner(QueryRunner):
             bookmark_manager = neo4j.GraphDatabase.bookmark_manager(self.bookmarks())
 
             result = self._driver.execute_query(
-                query_=query,
+                query_=self._wrap_query(query, query_type),
                 parameters_=params,
                 database_=database,
                 result_transformer_=neo4j.Result.to_df,
@@ -250,17 +264,26 @@ class Neo4jQueryRunner(QueryRunner):
             else:
                 raise e
 
-    def call_function(self, endpoint: str, params: CallParameters | None = None, custom_error: bool = True) -> Any:
+    def call_function(
+        self,
+        endpoint: str,
+        query_type: QueryType = QueryType.USER_TRANSPILED,
+        params: CallParameters | None = None,
+        custom_error: bool = True,
+    ) -> Any:
         if params is None:
             params = CallParameters()
         query = f"RETURN {endpoint}({params.placeholder_str()})"
 
         # we can use retryable cypher as we expect all gds functions to be idempotent
-        return self.run_retryable_cypher(query, params, custom_error=custom_error, mode=QueryMode.READ).squeeze()
+        return self.run_retryable_cypher(
+            query, query_type, params, custom_error=custom_error, mode=QueryMode.READ
+        ).squeeze()
 
     def call_procedure(
         self,
         endpoint: str,
+        query_type: QueryType = QueryType.USER_TRANSPILED,
         params: CallParameters | None = None,
         yields: list[str] | None = None,
         database: str | None = None,
@@ -277,9 +300,11 @@ class Neo4jQueryRunner(QueryRunner):
 
         def run_cypher_query() -> DataFrame:
             if retryable:
-                return self.run_retryable_cypher(query, params, database, custom_error=custom_error, mode=mode)
+                return self.run_retryable_cypher(
+                    query, query_type, params, database, custom_error=custom_error, mode=mode
+                )
             else:
-                return self.run_cypher(query, params, database, custom_error=custom_error)
+                return self.run_cypher(query, query_type, params, database, custom_error=custom_error)
 
         job_id = None if not params else params.get_job_id()
         if self._resolve_show_progress(logging) and job_id:
@@ -295,7 +320,7 @@ class Neo4jQueryRunner(QueryRunner):
             return self._server_version
 
         try:
-            server_version_string = self.call_function("gds.version", custom_error=False)
+            server_version_string = self.call_function("gds.version", query_type=QueryType.SYSTEM, custom_error=False)
             server_version = ServerVersion.from_string(server_version_string)
             self._server_version = server_version
             return server_version
@@ -501,6 +526,12 @@ class Neo4jQueryRunner(QueryRunner):
         warnings.filterwarnings("ignore", message=r".*returned by the procedure.* is deprecated.*")
         warnings.filterwarnings("ignore", message=r".*procedure field deprecated..*")
 
+    def _wrap_query(self, query: str, query_type: QueryType) -> neo4j.Query:
+        return neo4j.Query(
+            text=query,  # type: ignore[assignment]
+            metadata={"app": f"gds-v{__version__}", "type": query_type.value},
+        )
+
     class ConnectivityRetriesConfig(NamedTuple):
         max_retries: int = 600
         wait_time: int = 1