Loxone MCP Server

Instructions

Implementation Reference

• src/loxone_mcp/simple_server.py:333-428 (handler)

  The handler function `loxone_test_connection` which performs the connection test to the Loxone Miniserver.

  async def loxone_test_connection(
      host: str | None = None,
      username: str | None = None,
      password: str | None = None,
      port: int = 80,
  ) -> dict[str, Any]:
      """
      Test connection to Loxone Miniserver.
  
      Args:
          host: Loxone Miniserver host/IP address (uses LOXONE_HOST env var if not provided)
          username: Loxone username (uses LOXONE_USERNAME env var if not provided)
          password: Loxone password (uses LOXONE_PASSWORD env var if not provided)
          port: Loxone port (uses LOXONE_PORT env var or default: 80)
  
      Returns:
          Connection test result
      """
  
      try:
          # Import here to avoid import issues when running as script
          import sys
          from pathlib import Path
  
          # Add the parent directory to path for imports
          parent_dir = Path(__file__).parent
          if str(parent_dir) not in sys.path:
              sys.path.insert(0, str(parent_dir))
  
          from .config import LoxoneConfig
          from .loxone_client import LoxoneClient
  
          # Use environment variables as primary source, parameters as override
          try:
              if not all([host, username, password]):
                  # Load from environment
                  env_config = LoxoneConfig.from_env()
                  host = host or env_config.host
                  username = username or env_config.username
                  password = password or env_config.password
                  port = port if port != 80 else env_config.port
          except ValueError as e:
              return {
                  "success": False,
                  "error": f"Configuration error: {e}",
                  "error_code": "MISSING_PARAMETERS",
              }
  
          logger.info(f"Testing connection to {host}:{port}")
  
          # Create configuration
          config = LoxoneConfig(host=host, username=username, password=password, port=port)
  
          # Create and test client connection
          client = LoxoneClient(config)
  
          logger.info(f"Connecting to Loxone Miniserver at {host}:{port}...")
          connected = await client.connect()
  
          if not connected:
              return {
                  "success": False,
                  "error": f"Failed to connect to Loxone Miniserver at {host}:{port}",
                  "error_code": "CONNECTION_FAILED",
                  "host": host,
                  "port": port,
              }
  
          try:
              # Test basic functionality
              logger.info("Testing structure retrieval...")
              structure = await client.get_structure()
  
              structure_info = {
                  "rooms": len(structure.get("rooms", {})),
                  "controls": len(structure.get("controls", {})),
                  "categories": len(structure.get("categories", {})),
              }
  
              logger.info(f"Connection test successful: {structure_info}")
  
              return {
                  "success": True,
                  "message": "Connection successful",
                  "host": host,
                  "port": port,
                  "structure_info": structure_info,
              }
  
          finally:
              # Always disconnect
              await client.disconnect()
  
      except Exception as e:
          logger.error(f"Connection test failed: {e}", exc_info=True)
          return {

• src/loxone_mcp/simple_server.py:332-333 (registration)

  Tool registration for `loxone_test_connection` using `@mcp.tool()` decorator.

  @mcp.tool()
  async def loxone_test_connection(