Generic Model Context Protocol server that automatically discovers your Loxone Generation 1 devices and exposes only available features to AI assistants. Supports natural language commands in German, English, or mixed languages.
Natural commands in German, English, or mixed languages. "Licht an", "turn off lights", or "Rolladen OG runter" - automatically adapts to your system's available devices.
Intelligent capability detection automatically discovers lights, blinds, weather sensors, security devices, and more - only exposing features your system actually has.
Smart device discovery analyzes your Loxone structure and automatically categorizes devices by type, room, and function - no manual configuration needed.
Universal device control with intelligent action mapping - automatically handles lights, blinds, switches, sensors based on your specific configuration.
Advanced reconnection system with automatic token refresh, WebSocket monitoring, and connection health checks for reliable 24/7 operation.
Configuration-aware AI assistance - prevents attempts to control non-existent devices and provides clear guidance on what your system can actually do.
Direct integration with Claude Desktop app for conversational smart home control through natural language.
Web-based API server for integration with n8n, Home Assistant, webhooks, and browser applications.
Direct command-line interface for scripting, automation, and integration with shell scripts.
Containerized deployment with Docker Compose for production environments and service integration.
Install uv/uvx (Python package manager), clone the repository, and sync dependencies. Requires Python 3.11+ and Git.
Secure setup storing credentials in your local system keychain - never in files or cloud
Select your preferred deployment method: Claude Desktop, HTTP Server, CLI, or Docker
# 1. Install uv (Python package manager)
# macOS/Linux:
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows:
# powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
# 2. Clone and setup project
git clone https://github.com/avrabe/mcp-loxone-gen1.git
cd mcp-loxone-gen1
uv sync
# 3. Configure credentials (one-time setup)
uvx --from . loxone-mcp setup
Self-Signed & mkcert: Quick setup for local development with trusted certificates. Interactive setup script guides you through certificate generation and configuration.
Let's Encrypt & Commercial: Production-ready deployment with automatic certificate management. Reverse proxy configurations for nginx and Traefik included.
End-to-End Protection: Encrypted API key transmission, browser compatibility, timing attack prevention, and production security compliance standards.
# Interactive setup wizard
./scripts/setup-https.sh
# Options available:
# 1. Development: Self-signed certificate
# 2. Development: mkcert (trusted by browsers)
# 3. Production: Use existing certificates
# 4. Production: Generate CSR for CA signing
# 5. Show current configuration
# Quick self-signed setup
./scripts/generate-self-signed-cert.sh
# Start HTTPS server
export LOXONE_SSE_USE_HTTPS=true
uvx --from . loxone-mcp-sse
# Docker with HTTPS
docker-compose -f docker-compose.ssl.yml up
# Nginx reverse proxy with Let's Encrypt
docker-compose -f docker-compose.prod.yml up
# Environment variables for HTTPS
export LOXONE_SSE_USE_HTTPS=true
export LOXONE_SSL_CERT=certs/server.crt
export LOXONE_SSL_KEY=certs/server.key
export LOXONE_SSL_PORT=8443
# Test HTTPS endpoint with API key
curl -H "Authorization: Bearer your-api-key" \
https://your-domain.com:8443/health
{
"mcpServers": {
"loxone": {
"command": "uvx",
"args": ["--from", "/path/to/mcp-loxone-gen1", "loxone-mcp-server"],
"env": {
"LOXONE_LOG_LEVEL": "INFO"
}
}
}
}
# Setup HTTPS certificates first
./scripts/setup-https.sh
# Start HTTPS SSE server with authentication
LOXONE_SSE_USE_HTTPS=true uvx --from . loxone-mcp-sse
# HTTP fallback for development only
uvx --from . loxone-mcp-sse
# Production HTTPS with custom API key
LOXONE_SSE_USE_HTTPS=true \
LOXONE_SSE_API_KEY=your-secure-key \
uvx --from . loxone-mcp-sse
# Use API key with HTTPS endpoints:
curl -H "Authorization: Bearer " https://localhost:8443/sse
curl -H "X-API-Key: " https://localhost:8443/health
# Direct MCP protocol via STDIN
echo '{"method":"list_rooms","params":{},"id":1}' | \
uvx --from . loxone-mcp-server
# For scripts and automation
uv run python -m loxone_mcp
# Pipe commands from files
cat commands.json | uvx --from . loxone-mcp-server
# HTTP deployment (development)
docker-compose -f docker-compose.sse.yml up
# HTTPS deployment (production)
./scripts/setup-https.sh # Generate certificates
docker-compose -f docker-compose.ssl.yml up
# Environment variables for production
LOXONE_HOST=192.168.1.100
LOXONE_USER=your-username
LOXONE_PASS=your-password
LOXONE_SSE_REQUIRE_AUTH=true
LOXONE_SSE_API_KEY=your-secure-api-key
# HTTPS configuration (optional)
LOXONE_SSE_USE_HTTPS=true
LOXONE_SSL_PORT=8443
# Test authenticated HTTPS endpoint
curl -H "Authorization: Bearer " \
https://localhost:8443/health
# Check what your system can do first
get_available_capabilities() # Shows only your available features
# Auto-discovery finds your devices
discover_all_devices() # Analyzes your specific setup
get_devices_by_category("Lighting") # Only shows if you have lights
# Configuration-aware control
control_device("your_room_light", "on") # Only works if device exists
get_weather_data() # Only available if weather sensors found
get_security_status() # Only works with security devices
# Each feature automatically checks availability
if capabilities.has_weather:
get_weather_data() # Only if weather stations exist
if capabilities.has_security:
get_security_status() # Only if security devices found
# Error handling with helpful guidance
> get_audio_zones()
{"error": "No audio devices available",
"available_features": ["lighting", "blinds", "weather"]}
# Adaptive to your configuration - no hardcoded assumptions!
OS-Level Encryption: All credentials stored in system keychain (macOS Keychain, Windows Credential Manager, Linux Secret Service). Zero cloud storage - complete local privacy with OS-managed encryption.
Loxone Protocol: HMAC-based JWT token exchange with automatic refresh. Secure authentication flow using Gen 1 Miniserver's token API with connection health monitoring and graceful reconnection.
Web Integration Security: SSE server with HTTPS/TLS encryption and API key authentication. Bearer token transmission over encrypted channels. Self-signed certificates for development, Let's Encrypt for production.
Defense in Depth: Environment variable override, constant-time comparisons, request logging, health check endpoints. Production-ready with Docker support and systematic credential management.
Zero External Dependencies: All communication stays within your home network. No cloud services, no external APIs. VPN recommended for remote access. Complete network isolation design.
Adaptive Authentication: Setup wizard detects your environment and configures appropriate security. Skip SSE if unneeded, auto-generate keys, environment overrides for CI/CD workflows.