updated with help from Gemini

app.py

@@ -1,39 +1,29 @@
-#!/usr/bin/env python3
-"""
-Complete Clean Terraform MCP Server
-Single responsibility: Terraform code generation, validation, and workflows
-No external dependencies beyond MCP and standard library
-"""
-
-import logging
-logging.basicConfig(level=logging.DEBUG,
-                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-logger.debug("Script started: Setting DEBUG log level.") # This should be the very first log
-
-
+import os
 import asyncio
 import json
 import re
-import os
+import uvicorn # Used for running the FastAPI application
 from typing import Dict, List, Optional, Any
 from dataclasses import dataclass
 from datetime import datetime
 import logging
 
+# FastAPI imports
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
+
 # MCP Server imports
 import mcp.types as types
-from mcp.server.models import InitializationOptions
-from mcp.server import NotificationOptions, Server
-from mcp.server.stdio import stdio_server
+from mcp.server import Server, NotificationOptions, InitializationOptions
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+# Set a very low level for debugging if needed, usually INFO for production
+logging.basicConfig(level=logging.INFO,
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # ============================================================================
-# TERRAFORM CODE TEMPLATES AND GENERATORS
+# TERRAFORM CODE TEMPLATES AND GENERATORS (Existing code, slightly adjusted formatting for consistency)
 # ============================================================================
 
 class TerraformTemplates:
@@ -140,7 +130,7 @@ variable "environment" {
   default     = "dev"
   
   validation {
-    condition     = contains(["dev", "staging", "prod"], var.environment)
+    condition   = contains(["dev", "staging", "prod"], var.environment)
     error_message = "Environment must be dev, staging, or prod."
   }
 }'''
@@ -163,7 +153,7 @@ variable "environment" {
   default     = "dev"
   
   validation {
-    condition     = contains(["dev", "staging", "prod"], var.environment)
+    condition   = contains(["dev", "staging", "prod"], var.environment)
     error_message = "Environment must be dev, staging, or prod."
   }
 }'''
@@ -203,7 +193,7 @@ variable "vpc_cidr" {{
   default     = "{cidr}"
   
   validation {{
-    condition     = can(cidrhost(var.vpc_cidr, 0))
+    condition   = can(cidrhost(var.vpc_cidr, 0))
     error_message = "VPC CIDR must be a valid IPv4 CIDR block."
   }}
 }}
@@ -219,10 +209,10 @@ module "{name}_vpc" {{
   public_subnets  = [for k, v in {azs} : cidrsubnet(var.vpc_cidr, 8, k)]
   private_subnets = [for k, v in {azs} : cidrsubnet(var.vpc_cidr, 8, k + 10)]
   
-  enable_nat_gateway   = {str(enable_nat).lower()}
-  enable_vpn_gateway   = false
+  enable_nat_gateway    = {str(enable_nat).lower()}
+  enable_vpn_gateway    = false
   enable_dns_hostnames = true
-  enable_dns_support   = true
+  enable_dns_support    = true
   
   public_subnet_tags = {{
     Type = "Public"
@@ -329,7 +319,7 @@ module "{name}_instance" {{
   
   name = "{name}-instance"
   
-  instance_type          = var.instance_type
+  instance_type         = var.instance_type
   ami                   = data.aws_ami.app_ami.id
   key_name              = var.key_pair_name
   monitoring            = true
@@ -500,7 +490,7 @@ module "{name}_s3_bucket" {{
   lifecycle_configuration = {{
     rule = [
       {{
-        id     = "delete_incomplete_multipart_uploads"
+        id      = "delete_incomplete_multipart_uploads"
         status = "Enabled"
         
         abort_incomplete_multipart_upload = {{
@@ -508,7 +498,7 @@ module "{name}_s3_bucket" {{
         }}
       }},
       {{
-        id     = "transition_to_ia"
+        id      = "transition_to_ia"
         status = "Enabled"
         
         transition = [
@@ -647,10 +637,10 @@ module "vpc" {{
   public_subnets  = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
   private_subnets = ["10.0.11.0/24", "10.0.12.0/24", "10.0.13.0/24"]
   
-  enable_nat_gateway   = true
-  single_nat_gateway   = true
+  enable_nat_gateway    = true
+  single_nat_gateway    = true
   enable_dns_hostnames = true
-  enable_dns_support   = true
+  enable_dns_support    = true
   
   public_subnet_tags = {{
     "kubernetes.io/role/elb" = "1"
@@ -669,11 +659,11 @@ module "vpc" {{
 module "eks" {{
   source = "terraform-aws-modules/eks/aws"
   
-  cluster_name    = var.cluster_name
+  cluster_name  = var.cluster_name
   cluster_version = var.kubernetes_version
   
-  vpc_id                         = module.vpc.vpc_id
-  subnet_ids                     = module.vpc.private_subnets
+  vpc_id                = module.vpc.vpc_id
+  subnet_ids            = module.vpc.private_subnets
   cluster_endpoint_public_access = true
   
   cluster_addons = {{
@@ -697,9 +687,9 @@ module "eks" {{
       
       instance_types = [var.node_instance_type]
       
-      min_size     = var.node_group_min_size
-      max_size     = var.node_group_max_size
-      desired_size = var.node_group_desired_size
+      min_size       = var.node_group_min_size
+      max_size       = var.node_group_max_size
+      desired_size   = var.node_group_desired_size
       
       disk_size = 50
       
@@ -790,7 +780,7 @@ variable "address_space" {{
 
 # Resource Group
 resource "azurerm_resource_group" "{name}_rg" {{
-  name     = "${{var.environment}}-{name}-rg"
+  name      = "${{var.environment}}-{name}-rg"
   location = var.location
   
   tags = {{
@@ -804,9 +794,9 @@ module "{name}_vnet" {{
   source = "Azure/vnet/azurerm"
   
   resource_group_name = azurerm_resource_group.{name}_rg.name
-  location           = azurerm_resource_group.{name}_rg.location
-  vnet_name          = "${{var.environment}}-{name}-vnet"
-  address_space      = var.address_space
+  location            = azurerm_resource_group.{name}_rg.location
+  vnet_name           = "${{var.environment}}-{name}-vnet"
+  address_space       = var.address_space
   
   subnet_prefixes = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
   subnet_names    = ["subnet1", "subnet2", "subnet3"]
@@ -839,7 +829,7 @@ output "resource_group_name" {{
 }}'''
 
 # ============================================================================
-# TERRAFORM VALIDATION AND UTILITIES
+# TERRAFORM VALIDATION AND UTILITIES (Existing code)
 # ============================================================================
 
 class TerraformValidator:
@@ -1045,217 +1035,20 @@ class TerraformModuleConverter:
         return '\n\n'.join(outputs)
 
 # ============================================================================
-# MCP SERVER IMPLEMENTATION
+# TERRAFORM AGENT HANDLERS (Core Logic, adapted from CleanTerraformMCPServer)
+# This class now holds the business logic, separate from the MCP Server instance
+# and FastAPI endpoints.
 # ============================================================================
 
-class CleanTerraformMCPServer:
-    """Clean Terraform MCP Server - focused on code generation and validation"""
+class TerraformAgentHandlers:
+    """Handles the core logic for Terraform tool operations."""
     
     def __init__(self):
-        self.server = Server("terraform-mcp-server")
         self.code_generator = TerraformCodeGenerator()
         self.validator = TerraformValidator()
         self.workflows = TerraformWorkflows()
         self.module_converter = TerraformModuleConverter()
-        self._setup_handlers()
-    
-    def _setup_handlers(self):
-        """Setup MCP server handlers"""
-        
-        @self.server.list_tools()
-        async def handle_list_tools() -> list[types.Tool]:
-            logger.debug("Handling ListToolsRequest") # Add debug
-            """List all available Terraform tools"""
-            return [
-                types.Tool(
-                    name="generate_terraform_config",
-                    description="Generate complete Terraform configuration for infrastructure resources",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "resource_type": {
-                                "type": "string",
-                                "description": "Type of infrastructure resource",
-                                "enum": ["vpc", "ec2", "s3", "eks", "rds", "vnet", "compute", "aks"]
-                            },
-                            "provider": {
-                                "type": "string",
-                                "description": "Cloud provider",
-                                "enum": ["aws", "azurerm", "google"]
-                            },
-                            "name": {
-                                "type": "string",
-                                "description": "Name for the infrastructure resources"
-                            },
-                            "options": {
-                                "type": "object",
-                                "description": "Resource-specific configuration options",
-                                "properties": {
-                                    "cidr": {"type": "string", "description": "CIDR block for VPC"},
-                                    "azs": {"type": "array", "items": {"type": "string"}, "description": "Availability zones"},
-                                    "instance_type": {"type": "string", "description": "EC2 instance type"},
-                                    "key_pair_name": {"type": "string", "description": "SSH key pair name"},
-                                    "enable_nat_gateway": {"type": "boolean", "description": "Enable NAT gateway"},
-                                    "versioning": {"type": "boolean", "description": "Enable S3 versioning"},
-                                    "encryption": {"type": "boolean", "description": "Enable encryption"},
-                                    "node_instance_type": {"type": "string", "description": "EKS node instance type"},
-                                    "min_nodes": {"type": "integer", "description": "Minimum nodes"},
-                                    "max_nodes": {"type": "integer", "description": "Maximum nodes"},
-                                    "desired_nodes": {"type": "integer", "description": "Desired nodes"},
-                                    "kubernetes_version": {"type": "string", "description": "Kubernetes version"}
-                                }
-                            }
-                        },
-                        "required": ["resource_type", "provider", "name"]
-                    }
-                ),
-                types.Tool(
-                    name="validate_terraform_config",
-                    description="Validate Terraform configuration syntax and best practices",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "config_content": {
-                                "type": "string",
-                                "description": "Terraform configuration content to validate"
-                            },
-                            "check_best_practices": {
-                                "type": "boolean",
-                                "description": "Include best practices validation",
-                                "default": True
-                            },
-                            "strict_mode": {
-                                "type": "boolean",
-                                "description": "Enable strict validation rules",
-                                "default": False
-                            }
-                        },
-                        "required": ["config_content"]
-                    }
-                ),
-                types.Tool(
-                    name="get_deployment_workflow",
-                    description="Generate step-by-step Terraform deployment workflow",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "workflow_type": {
-                                "type": "string",
-                                "description": "Type of deployment workflow",
-                                "enum": ["basic", "production", "module_development"],
-                                "default": "basic"
-                            },
-                            "backend_type": {
-                                "type": "string",
-                                "description": "Backend storage type",
-                                "enum": ["local", "s3", "azurerm", "gcs"],
-                                "default": "local"
-                            },
-                            "environment": {
-                                "type": "string",
-                                "description": "Target environment",
-                                "enum": ["development", "staging", "production"],
-                                "default": "development"
-                            }
-                        }
-                    }
-                ),
-                types.Tool(
-                    name="convert_to_module",
-                    description="Convert Terraform configuration to reusable module structure",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "config_content": {
-                                "type": "string",
-                                "description": "Terraform configuration to convert"
-                            },
-                            "module_name": {
-                                "type": "string", 
-                                "description": "Name for the module"
-                            },
-                            "extract_variables": {
-                                "type": "boolean",
-                                "description": "Extract hardcoded values as variables",
-                                "default": True
-                            },
-                            "generate_examples": {
-                                "type": "boolean",
-                                "description": "Generate usage examples",
-                                "default": True
-                            }
-                        },
-                        "required": ["config_content", "module_name"]
-                    }
-                ),
-                types.Tool(
-                    name="format_terraform_code",
-                    description="Format and standardize Terraform code",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "config_content": {
-                                "type": "string",
-                                "description": "Terraform configuration to format"
-                            },
-                            "sort_blocks": {
-                                "type": "boolean",
-                                "description": "Sort resource blocks alphabetically",
-                                "default": True
-                            }
-                        },
-                        "required": ["config_content"]
-                    }
-                ),
-                types.Tool(
-                    name="generate_terraform_docs",
-                    description="Generate documentation for Terraform configuration",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "config_content": {
-                                "type": "string",
-                                "description": "Terraform configuration to document"
-                            },
-                            "module_name": {
-                                "type": "string",
-                                "description": "Name of the module"
-                            },
-                            "include_examples": {
-                                "type": "boolean",
-                                "description": "Include usage examples",
-                                "default": True
-                            }
-                        },
-                        "required": ["config_content"]
-                    }
-                )
-            ]
-        
-        @self.server.call_tool()
-        async def handle_call_tool(name: str, arguments: dict) -> list[types.TextContent]:
-            logger.debug("Handling CallToolRequest for tool: {name} ") # Add debug here
-            """Handle tool calls"""
-            try:
-                if name == "generate_terraform_config":
-                    return await self._handle_generate_config(arguments)
-                elif name == "validate_terraform_config":
-                    return await self._handle_validate_config(arguments)
-                elif name == "get_deployment_workflow":
-                    return await self._handle_deployment_workflow(arguments)
-                elif name == "convert_to_module":
-                    return await self._handle_convert_to_module(arguments)
-                elif name == "format_terraform_code":
-                    return await self._handle_format_code(arguments)
-                elif name == "generate_terraform_docs":
-                    return await self._handle_generate_docs(arguments)
-                else:
-                    return [types.TextContent(type="text", text=f"❌ Unknown tool: {name}")]
-            
-            except Exception as e:
-                logger.error(f"Tool execution error: {e}")
-                return [types.TextContent(type="text", text=f"❌ Error executing {name}: {str(e)}")]
-    
+
     async def _handle_generate_config(self, args: dict) -> list[types.TextContent]:
         """Handle Terraform configuration generation"""
         resource_type = args.get("resource_type")
@@ -1471,15 +1264,15 @@ Converting Terraform configuration to a reusable module structure.
 
 ```
 modules/{module_name}/
-├── main.tf                 # Main configuration
-├── variables.tf            # Input variables
-├── outputs.tf              # Output values
-├── versions.tf             # Provider requirements
-├── README.md               # Documentation
+├── main.tf           # Main configuration
+├── variables.tf      # Input variables
+├── outputs.tf        # Output values
+├── versions.tf       # Provider requirements
+├── README.md         # Documentation
 └── examples/
     └── basic/
-        ├── main.tf         # Example usage
-        └── README.md       # Example documentation
+        ├── main.tf   # Example usage
+        └── README.md # Example documentation
 ```
 
 """
@@ -1755,62 +1548,315 @@ module "{module_name}" {{
         
         return [types.TextContent(type="text", text=response)]
 
+
 # ============================================================================
-# MAIN ENTRY POINT FOR HF SPACES
+# FASTAPI APP AND MCP SERVER INSTANCE
 # ============================================================================
 
-async def main():
-    logger.info("🚀 Clean Terraform MCP Server starting...")
-    logger.info("🔧 Available tools: generate_terraform_config, validate_terraform_config, get_deployment_workflow, convert_to_module, format_terraform_code, generate_terraform_docs")
-    logger.info("📦 No external dependencies - pure Terraform tooling")
+# Create FastAPI app
+app = FastAPI(title="Terraform MCP Server")
 
-    terraform_server = CleanTerraformMCPServer()
+# Create an instance of the TerraformAgentHandlers to manage tool logic
+terraform_agent_handlers = TerraformAgentHandlers()
 
-    logger.debug("Attempting to initialize stdio_server context...")
-    try:
-        async with stdio_server() as (read_stream, write_stream):
-            logger.debug("stdio_server context entered successfully. Attempting to run MCP server...")
-            server_task = asyncio.create_task(
-                terraform_server.server.run(
-                    read_stream,
-                    write_stream,
-                    InitializationOptions(
-                        server_name="terraform-mcp-server",
-                        server_version="1.0.0",
-                        capabilities=terraform_server.server.get_capabilities(
-                            notification_options=NotificationOptions(),
-                            experimental_capabilities={}
-                        )
-                    )
-                )
-            )
-            # This is the crucial part: keep the main event loop running.
-            # The server_task is now running in the background.
-            # We need to explicitly await it or another task that keeps the event loop alive.
-            # asyncio.Future() creates a Future that never completes, effectively blocking main.
-            # Or you can await the server_task if it's meant to run indefinitely.
-            # Given your log "MCP server.run() completed", it suggests it exits.
-            # So, we need something *after* it that blocks.
-
-            # Option 1: Await the server task, assuming it will block indefinitely (but your logs contradict this)
-            # await server_task
-
-            # Option 2: Keep the event loop running indefinitely if server_task completes
-            logger.debug("MCP server task created. Keeping event loop alive...")
-            await asyncio.Future() # This creates a future that never resolves, keeping the event loop running
-
-            logger.debug("This line should theoretically not be reached if asyncio.Future() keeps the loop alive.")
+# Create MCP server instance
+mcp_server_instance = Server("terraform-mcp-server")
 
-    except Exception as e:
-        logger.critical(f"Unhandled exception during stdio_server or server.run: {e}", exc_info=True)
-        raise
+# ============================================================================
+# MCP SERVER HANDLERS (Decorated on the global mcp_server_instance)
+# ============================================================================
 
-if __name__ == "__main__":
+@mcp_server_instance.list_tools()
+async def list_tools_for_mcp(): # Renamed to avoid conflict with `list_tools` in the Linux example
+    """List all available Terraform tools"""
+    logger.debug("MCP ListToolsRequest received.")
+    return [
+        types.Tool(
+            name="generate_terraform_config",
+            description="Generate complete Terraform configuration for infrastructure resources",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "resource_type": {
+                        "type": "string",
+                        "description": "Type of infrastructure resource",
+                        "enum": ["vpc", "ec2", "s3", "eks", "rds", "vnet", "compute", "aks"]
+                    },
+                    "provider": {
+                        "type": "string",
+                        "description": "Cloud provider",
+                        "enum": ["aws", "azurerm", "google"]
+                    },
+                    "name": {
+                        "type": "string",
+                        "description": "Name for the infrastructure resources"
+                    },
+                    "options": {
+                        "type": "object",
+                        "description": "Resource-specific configuration options",
+                        "properties": {
+                            "cidr": {"type": "string", "description": "CIDR block for VPC"},
+                            "azs": {"type": "array", "items": {"type": "string"}, "description": "Availability zones"},
+                            "instance_type": {"type": "string", "description": "EC2 instance type"},
+                            "key_pair_name": {"type": "string", "description": "SSH key pair name"},
+                            "enable_nat_gateway": {"type": "boolean", "description": "Enable NAT gateway"},
+                            "versioning": {"type": "boolean", "description": "Enable S3 versioning"},
+                            "encryption": {"type": "boolean", "description": "Enable encryption"},
+                            "node_instance_type": {"type": "string", "description": "EKS node instance type"},
+                            "min_nodes": {"type": "integer", "description": "Minimum nodes"},
+                            "max_nodes": {"type": "integer", "description": "Maximum nodes"},
+                            "desired_nodes": {"type": "integer", "description": "Desired nodes"},
+                            "kubernetes_version": {"type": "string", "description": "Kubernetes version"}
+                        }
+                    }
+                },
+                "required": ["resource_type", "provider", "name"]
+            }
+        ),
+        types.Tool(
+            name="validate_terraform_config",
+            description="Validate Terraform configuration syntax and best practices",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "config_content": {
+                        "type": "string",
+                        "description": "Terraform configuration content to validate"
+                    },
+                    "check_best_practices": {
+                        "type": "boolean",
+                        "description": "Include best practices validation",
+                        "default": True
+                    },
+                    "strict_mode": {
+                        "type": "boolean",
+                        "description": "Enable strict validation rules",
+                        "default": False
+                    }
+                },
+                "required": ["config_content"]
+            }
+        ),
+        types.Tool(
+            name="get_deployment_workflow",
+            description="Generate step-by-step Terraform deployment workflow",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "workflow_type": {
+                        "type": "string",
+                        "description": "Type of deployment workflow",
+                        "enum": ["basic", "production", "module_development"],
+                        "default": "basic"
+                    },
+                    "backend_type": {
+                        "type": "string",
+                        "description": "Backend storage type",
+                        "enum": ["local", "s3", "azurerm", "gcs"],
+                        "default": "local"
+                    },
+                    "environment": {
+                        "type": "string",
+                        "description": "Target environment",
+                        "enum": ["development", "staging", "production"],
+                        "default": "development"
+                    }
+                }
+            }
+        ),
+        types.Tool(
+            name="convert_to_module",
+            description="Convert Terraform configuration to reusable module structure",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "config_content": {
+                        "type": "string", 
+                        "description": "Terraform configuration to convert"
+                    },
+                    "module_name": {
+                        "type": "string",  
+                        "description": "Name for the module"
+                    },
+                    "extract_variables": {
+                        "type": "boolean",
+                        "description": "Extract hardcoded values as variables",
+                        "default": True
+                    },
+                    "generate_examples": {
+                        "type": "boolean",
+                        "description": "Generate usage examples",
+                        "default": True
+                    }
+                },
+                "required": ["config_content", "module_name"]
+            }
+        ),
+        types.Tool(
+            name="format_terraform_code",
+            description="Format and standardize Terraform code",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "config_content": {
+                        "type": "string",
+                        "description": "Terraform configuration to format"
+                    },
+                    "sort_blocks": {
+                        "type": "boolean",
+                        "description": "Sort resource blocks alphabetically",
+                        "default": True
+                    }
+                },
+                "required": ["config_content"]
+            }
+        ),
+        types.Tool(
+            name="generate_terraform_docs",
+            description="Generate documentation for Terraform configuration",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "config_content": {
+                        "type": "string",
+                        "description": "Terraform configuration to document"
+                    },
+                    "module_name": {
+                        "type": "string",
+                        "description": "Name of the module"
+                    },
+                    "include_examples": {
+                        "type": "boolean",
+                        "description": "Include usage examples",
+                        "default": True
+                    }
+                },
+                "required": ["config_content"]
+            }
+        )
+    ]
+    
+@mcp_server_instance.call_tool()
+async def call_tool_for_mcp(name: str, arguments: dict) -> list[types.TextContent]: # Renamed
+    """Handle tool calls from MCP client via SSE"""
+    logger.info(f"MCP CallToolRequest received for tool: {name}")
     try:
-        logger.debug("Script execution started via __main__.")
-        asyncio.run(main())
-        logger.debug("Script finished execution (normal exit).") # This might not be reached with asyncio.Future()
-    except asyncio.CancelledError:
-        logger.info("Application received cancellation signal. Exiting gracefully.")
+        if name == "generate_terraform_config":
+            return await terraform_agent_handlers._handle_generate_config(arguments)
+        elif name == "validate_terraform_config":
+            return await terraform_agent_handlers._handle_validate_config(arguments)
+        elif name == "get_deployment_workflow":
+            return await terraform_agent_handlers._handle_deployment_workflow(arguments)
+        elif name == "convert_to_module":
+            return await terraform_agent_handlers._handle_convert_to_module(arguments)
+        elif name == "format_terraform_code":
+            return await terraform_agent_handlers._handle_format_code(arguments)
+        elif name == "generate_terraform_docs":
+            return await terraform_agent_handlers._handle_generate_docs(arguments)
+        else:
+            return [types.TextContent(type="text", text=f"❌ Unknown tool: {name}")]
     except Exception as e:
-        logger.critical(f"Fatal unhandled exception in main execution block: {e}", exc_info=True)
+        logger.exception(f"Error executing Terraform tool {name}")
+        return [types.TextContent(type="text", text=f"❌ Error executing {name}: {str(e)}")]
+
+# ============================================================================
+# FASTAPI WEB ENDPOINTS
+# ============================================================================
+
+@app.get("/")
+async def root():
+    """Status endpoint"""
+    logger.info("GET / requested - sending status.")
+    return {
+        "service": "terraform-mcp-server", 
+        "status": "running",
+        "mcp_endpoint": "/mcp/sse",
+        "tools": len(await list_tools_for_mcp()), # Dynamically list tools
+        "categories": ["infrastructure_generation", "validation", "workflow_management", "module_conversion", "documentation"]
+    }
+
+@app.get("/health")
+async def health():
+    """Health check endpoint for Hugging Face Spaces"""
+    logger.debug("GET /health requested - sending healthy status.")
+    return {"status": "healthy", "service": "terraform-mcp-server"}
+
+@app.get("/mcp/sse")
+async def mcp_sse_endpoint(request: Request):
+    """MCP SSE endpoint for agent connections"""
+    logger.info("GET /mcp/sse requested - starting SSE stream.")
+
+    async def event_stream():
+        # MCP uses this internally for server initialization and handling client requests
+        # The mcp_server_instance will manage the SSE communication within its run() method.
+        # This wrapper is needed to hook mcp_server_instance.run() into FastAPI's StreamingResponse.
+
+        # Create dummy readers/writers for mcp_server_instance.run()
+        # In a real-world scenario, mcp.server might provide an HTTP/SSE specific run method
+        # or expect a custom transport. For this setup, we'll try to adapt.
+
+        # The MCP library's Server.run() method expects streams, so we need to mock or
+        # adapt it to FastAPI's request/response cycle.
+        # However, the most direct approach for MCP and FastAPI is to let MCP handle the HTTP
+        # part if it has a specific HTTP/SSE server implementation, or have FastAPI
+        # call MCP's core logic directly (as I did in the Gradio example).
+
+        # Given the Linux example, the MCP server is directly serving the /mcp/sse.
+        # This implies mcp.server.Server has a mechanism to do this, or the StreamingResponse
+        # content generator is the key.
+
+        # Let's align with the Linux code provided:
+        # The Linux example *does not* call `mcp_app.run()` inside the SSE endpoint directly.
+        # Instead, it uses `mcp_app.list_tools()` and `mcp_app.call_tool()` as decorators
+        # on global functions, and the FastAPI endpoint just sends keepalives.
+        # The communication over SSE is typically initiated by a client *sending* an MCP message
+        # to the server, and the server *sending* responses back.
+
+        # For a simple SSE endpoint that only sends keepalives and doesn't handle incoming MCP calls via SSE directly
+        # (which is what your Linux /mcp/sse seems to do with just keepalives):
+        try:
+            while True:
+                if await request.is_disconnected():
+                    logger.info("Client disconnected from /mcp/sse.")
+                    break
+                
+                # Send a keepalive signal to maintain the connection
+                yield f"data: {json.dumps({'type': 'keepalive'})}\n\n"
+                await asyncio.sleep(30) # Send keepalive every 30 seconds
+                
+        except asyncio.CancelledError:
+            logger.info("SSE event stream cancelled.")
+        except Exception as e:
+            logger.error(f"Error in SSE event stream: {e}", exc_info=True)
+
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Access-Control-Allow-Origin": "*", # Important for CORS if consumed by a frontend
+        }
+    )
+
+# ============================================================================
+# MAIN ENTRY POINT FOR FASTAPI/UVICORN
+# ============================================================================
+
+def main():
+    """Main entry point to run the FastAPI application with Uvicorn."""
+    port = int(os.getenv("PORT", 7860)) # Default to 7860, used by Hugging Face Spaces
+    
+    logger.info(f"🚀 Starting Terraform MCP Server with FastAPI/Uvicorn on port {port}")
+    print(f"📊 Status Endpoint: http://0.0.0.0:{port}/")
+    print(f"❤️  Health Check: http://0.0.0.0:{port}/health")
+    print(f"🔗 MCP SSE Endpoint: http://0.0.0.0:{port}/mcp/sse")
+    print(f"🛠️  Available Tools: generate_terraform_config, validate_terraform_config, get_deployment_workflow, convert_to_module, format_terraform_code, generate_terraform_docs")
+    
+    # Run the FastAPI application using Uvicorn
+    # This will bind to the specified host and port, handling HTTP requests.
+    uvicorn.run(app, host="0.0.0.0", port=port, log_level="info")
+
+if __name__ == "__main__":
+    main()