Cypher refactor driver code (#130)

* implement `driver.execute_query()`

clean driver code by removing sessions and transactions in favor of `execute_query()` syntax

* update driver syntax

* Update Dockerfile

Author: a-s-g93

servers/mcp-neo4j-cypher/CHANGELOG.md

@@ -3,6 +3,7 @@
 ### Fixed
 
 ### Changed
+* Update Neo4j Driver syntax to use `driver.execute_query(...)`. This cleans the driver code.
 
 ### Added
 

servers/mcp-neo4j-cypher/Dockerfile

@@ -18,6 +18,8 @@ COPY README.md /app/
 
 RUN pip install --no-cache-dir -e .
 
+# adding comment to trigger Docker hub build
+
 # Environment variables for Neo4j connection
 ENV NEO4J_URI="bolt://host.docker.internal:7687"
 ENV NEO4J_USERNAME="neo4j"

servers/mcp-neo4j-cypher/src/mcp_neo4j_cypher/server.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import re
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 from fastmcp.exceptions import ToolError
 from fastmcp.tools.tool import ToolResult, TextContent
@@ -10,8 +10,7 @@
 from neo4j import (
     AsyncDriver,
     AsyncGraphDatabase,
-    AsyncResult,
-    AsyncTransaction,
+    RoutingControl
 )
 from neo4j.exceptions import ClientError, Neo4jError
 from pydantic import Field
@@ -27,19 +26,6 @@ def _format_namespace(namespace: str) -> str:
     else:
         return ""
 
-async def _read(tx: AsyncTransaction, query: str, params: dict[str, Any]) -> str:
-    raw_results = await tx.run(query, params)
-    eager_results = await raw_results.to_eager_result()
-
-    return json.dumps([r.data() for r in eager_results.records], default=str)
-
-
-async def _write(
-    tx: AsyncTransaction, query: str, params: dict[str, Any]
-) -> AsyncResult:
-    return await tx.run(query, params)
-
-
 def _is_write_query(query: str) -> bool:
     """Check if the query is a write query."""
     return (
@@ -135,18 +121,19 @@ def clean_schema(schema: dict) -> dict:
 
 
         try:
-            async with neo4j_driver.session(database=database) as session:
-                results_json_str = await session.execute_read(
-                    _read, get_schema_query, dict()
-                )
 
-                logger.debug(f"Read query returned {len(results_json_str)} rows")
+            results_json_str = await neo4j_driver.execute_query(get_schema_query, 
+                                                                routing_control=RoutingControl.READ, 
+                                                                database_=database,
+                                                                result_transformer_=lambda r: r.data())
+            
+            logger.debug(f"Read query returned {len(results_json_str)} rows")
+
+            schema_clean = clean_schema(results_json_str[0].get('value'))
 
-                schema = json.loads(results_json_str)[0].get('value')
-                schema_clean = clean_schema(schema)
-                schema_clean_str = json.dumps(schema_clean)
+            schema_clean_str = json.dumps(schema_clean, default=str)
 
-                return ToolResult(content=[TextContent(type="text", text=schema_clean_str)])
+            return ToolResult(content=[TextContent(type="text", text=schema_clean_str)])
 
         except ClientError as e:
             if "Neo.ClientError.Procedure.ProcedureNotFound" in str(e):
@@ -180,12 +167,17 @@ async def read_neo4j_cypher(
             raise ValueError("Only MATCH queries are allowed for read-query")
 
         try:
-            async with neo4j_driver.session(database=database) as session:
-                results_json_str = await session.execute_read(_read, query, params)
+            results = await neo4j_driver.execute_query(query, 
+                                                        parameters_=params, 
+                                                        routing_control=RoutingControl.READ, 
+                                                        database_=database,
+                                                        result_transformer_=lambda r: r.data())
+            
+            results_json_str = json.dumps(results, default=str)
 
-                logger.debug(f"Read query returned {len(results_json_str)} rows")
+            logger.debug(f"Read query returned {len(results_json_str)} rows")
 
-                return ToolResult(content=[TextContent(type="text", text=results_json_str)])
+            return ToolResult(content=[TextContent(type="text", text=results_json_str)])
 
         except Neo4jError as e:
             logger.error(f"Neo4j Error executing read query: {e}\n{query}\n{params}")
@@ -214,11 +206,13 @@ async def write_neo4j_cypher(
             raise ValueError("Only write queries are allowed for write-query")
 
         try:
-            async with neo4j_driver.session(database=database) as session:
-                raw_results = await session.execute_write(_write, query, params)
-                counters_json_str = json.dumps(
-                    raw_results._summary.counters.__dict__, default=str
-                )
+            _, summary, _ = await neo4j_driver.execute_query(query, 
+                                                    parameters_=params, 
+                                                    routing_control=RoutingControl.WRITE, 
+                                                    database_=database,
+                                                    )
+            
+            counters_json_str = json.dumps(summary.counters.__dict__, default=str)
 
             logger.debug(f"Write query affected {counters_json_str}")