add logging to resources and tools

Author: a-s-g93

servers/mcp-neo4j-data-modeling/src/mcp_neo4j_data_modeling/server.py

@@ -20,61 +20,77 @@ def create_mcp_server() -> FastMCP:
     @mcp.resource("resource://init")
     def init() -> DataModel:
         """Create an empty data model."""
+        logger.info("Creating an empty data model.")
         return DataModel(nodes=[], relationships=[])
 
     @mcp.resource("resource://schema/node")
     def node_schema() -> dict[str, Any]:
         """Get the schema for a node."""
+        logger.info("Getting the schema for a node.")
         return Node.model_json_schema()
 
     @mcp.resource("resource://schema/relationship")
     def relationship_schema() -> dict[str, Any]:
         """Get the schema for a relationship."""
+        logger.info("Getting the schema for a relationship.")
         return Relationship.model_json_schema()
 
     @mcp.resource("resource://schema/property")
     def property_schema() -> dict[str, Any]:
         """Get the schema for a property."""
+        logger.info("Getting the schema for a property.")
         return Property.model_json_schema()
 
     @mcp.resource("resource://schema/data_model")
     def data_model_schema() -> dict[str, Any]:
         """Get the schema for a data model."""
+        logger.info("Getting the schema for a data model.")
         return DataModel.model_json_schema()
 
     @mcp.tool()
     def validate_node(node: Node) -> bool:
         "Validate a single node. Returns True if the node is valid, otherwise raises a ValueError."
+        logger.info("Validating a single node.")
         try:
             Node.model_validate(node, strict=True)
         except ValidationError as e:
+            logger.error(f"Validation error: {e}")
             raise ValueError(f"Validation error: {e}")
+        logger.info("Node validated successfully.")
         return True
 
     @mcp.tool()
     def validate_relationship(relationship: Relationship) -> bool:
         "Validate a single relationship. Returns True if the relationship is valid, otherwise raises a ValueError."
+        logger.info("Validating a single relationship.")
         try:
             Relationship.model_validate(relationship, strict=True)
         except ValidationError as e:
+            logger.error(f"Validation error: {e}")
             raise ValueError(f"Validation error: {e}")
+        logger.info("Relationship validated successfully.")
         return True
 
     @mcp.tool()
     def validate_data_model(data_model: DataModel) -> bool:
         "Validate the entire data model. Returns True if the data model is valid, otherwise raises a ValueError."
+        logger.info("Validating the entire data model.")
         try:
             DataModel.model_validate(data_model, strict=True)
         except ValidationError as e:
+            logger.error(f"Validation error: {e}")
             raise ValueError(f"Validation error: {e}")
+        logger.info("Data model validated successfully.")
         return True
 
     @mcp.tool()
     def visualize_data_model(data_model: DataModel) -> None:
         "Open an interactive graph visualization in the default web browser."
+        logger.info("Validating the data model.")
         try:
             dm_validated = DataModel.model_validate(data_model, strict=True)
         except ValidationError as e:
+            logger.error(f"Validation error: {e}")
             raise ValueError(f"Validation error: {e}")
 
         def open_html_in_browser(html_content, filename="temp.html"):
@@ -91,16 +107,19 @@ def open_html_in_browser(html_content, filename="temp.html"):
             file_url = 'file://' + os.path.realpath(filename)
             webbrowser.open_new_tab(file_url)
 
+        logger.info("Opening an interactive graph visualization in the default web browser.")
         open_html_in_browser(dm_validated.to_nvl().render().data)
 
     @mcp.tool()
     def load_from_arrows_json(arrows_data_model_dict: dict[str, Any]) -> DataModel:
         "Load a data model from the Arrows web application format. Returns a data model as a JSON string."
+        logger.info("Loading a data model from the Arrows web application format.")
         return DataModel.from_arrows(arrows_data_model_dict)
 
     @mcp.tool()
     def export_to_arrows_json(data_model: DataModel) -> str:
         "Export the data model to the Arrows web application format. Returns a JSON string."
+        logger.info("Exporting the data model to the Arrows web application format.")
         return data_model.to_arrows_json_str()
 
     return mcp