Home Assistant mit Claude Code: Vollzugriff per MCP, Filesystem und API

Was wäre, wenn du deinem KI-Assistenten einfach sagen könntest: “Erstell mir eine Home Assistant Automation, die das Licht im Flur bei Bewegung einschaltet” – und er setzt es sofort live um? Keine YAML-Datei manuell öffnen, keine Home Assistant UI, kein Copy-Paste. Einfach eine natürliche Anweisung, und Sekunden später läuft die Automation.

Genau das ist mein Setup. Claude Code hat Vollzugriff auf meine Home Assistant-Instanz – über drei parallele Zugriffsschichten, die zusammen ein System ergeben, das sich anfühlt wie ein persönlicher Smart-Home-Entwickler, der rund um die Uhr bereitsteht.

In diesem Artikel zeige ich dir die komplette Architektur: Wie die Infrastruktur aufgebaut ist, welche Zugriffsschichten Claude Code nutzt, und wie der Workflow in der Praxis aussieht – von der Idee bis zur laufenden Automation in unter einer Minute.

Was dieses Setup in der Praxis bringt, zeigen die echten Heizkostendaten meiner Heizperiode 2025/26 — über 1.700 € weniger als im Vorjahr, ermöglicht durch die intelligente Steuerung mit Home Assistant.

Inhaltsverzeichnis

Home Assistant auf Proxmox: Infrastruktur und Monitoring
Drei Zugriffsschichten: Warum eine nicht reicht
MCP – Der semantische Zugang
Filesystem-Mount – Direkter Zugriff auf die Konfiguration
REST API und SSH – Der operative Hebel
Die Konfigurationsstruktur: Packages statt Monolith
Der Workflow in der Praxis
Praxisbeispiele: Was Claude Code in Sekunden umsetzt
Sicherheit und Grenzen
FAQ: Häufige Fragen zum Setup
Fazit: Smart Home mit KI-Vollzugriff

Home Assistant auf Proxmox: Infrastruktur und Monitoring

Das Fundament des Setups ist ein Proxmox-Host auf einem Mini-PC, auf dem Home Assistant OS (HAOS) als dedizierte VM läuft. Diese Trennung zwischen Hypervisor und Smart-Home-System ist kein Zufall – sie ermöglicht Snapshots, einfache Backups und die Isolation von anderen Services.

Die Kernkomponenten

Komponente	Adresse	Funktion
Home Assistant OS	`192.168.1.50:8123`	Smart-Home-Zentrale
Externer Zugang	`https://ha.example.de`	Zugriff von unterwegs
Prometheus + Grafana	`192.168.1.51`	Langzeit-Monitoring auf separatem Mini-PC
Proxmox Host	Hypervisor	VM-Management, Snapshots

Der separate Prometheus/Grafana-Stack auf einer eigenen Maschine übernimmt die Langzeitdatenspeicherung mit 10 Jahren Retention. Home Assistants integrierter Recorder ist für kurzfristige Daten ausgelegt – wer historische Trends über Jahre analysieren will, braucht ein dediziertes Monitoring. Stromverbrauch, Heizkosten, Temperaturverläufe: Alles wird langfristig erfasst und steht für Analysen bereit.

Die Proxmox-Virtualisierung bringt einen weiteren Vorteil: Vor größeren Änderungen kann ein VM-Snapshot erstellt werden. Geht etwas schief, ist der vorherige Zustand in Sekunden wiederhergestellt. Das gibt Sicherheit, wenn Claude Code tiefgreifende Konfigurationsänderungen vornimmt.

Drei Zugriffsschichten: Warum eine nicht reicht

Die meisten Home-Assistant-Nutzer kennen einen Zugangsweg: die Web-UI. Fortgeschrittene nutzen vielleicht die REST API oder editieren YAML-Dateien per SSH. Mein Setup kombiniert drei parallele Zugriffsschichten, die Claude Code gleichzeitig nutzt – jede mit eigener Stärke.

Claude Code Session
├── 🔌 MCP (Model Context Protocol)     → Semantischer Zugang: Geräte steuern, Zustände lesen
├── 📁 Filesystem-Mount (/mnt/haos/)    → Direkter Dateizugriff: YAML lesen und schreiben
└── 🌐 REST API + SSH                   → Operativer Zugang: Reload, Restart, Diagnose

Warum nicht nur MCP? Weil MCP allein keine Konfigurationsdateien bearbeiten kann. Warum nicht nur Filesystem? Weil Dateiänderungen erst nach einem Reload wirksam werden. Warum nicht nur die API? Weil sie keinen Zugriff auf die YAML-Struktur bietet. Erst die Kombination aller drei Schichten ergibt den Vollzugriff, der Claude Code zum echten Smart-Home-Assistenten macht.

MCP – Der semantische Zugang

Das Model Context Protocol (MCP) ist die interessanteste Schicht in diesem Setup. MCP wurde von Anthropic entwickelt, um KI-Modellen standardisierten Zugang zu externen Systemen zu geben – und der Home Assistant MCP Server ist eine der ausgereiftesten Implementierungen.

Was MCP kann

Über MCP stehen Claude Code spezialisierte Tools zur Verfügung:

Tool-Kategorie	Beispiele	Funktion
Entity-Steuerung	`control`, `get_entity_state`	Geräte schalten, Zustände abfragen
Licht	`lights_control`	Helligkeit, Farbe, Szenen
Automation	`automation`	Automationen erstellen, triggern, deaktivieren
Suche	`search_entities`	Entities nach Name, Bereich, Typ finden
Diagnose	`get_history`, `get_error_log`	Verlaufsdaten, Fehleranalyse

Der entscheidende Vorteil von MCP gegenüber der REST API: Semantik. Claude Code muss nicht wissen, welchen API-Endpunkt es aufrufen soll oder wie die JSON-Payload aussehen muss. Es nutzt einfach mcp__homeassistant__get_entity_state mit dem Entity-Namen – fertig. Die Abstraktion macht den Zugriff natürlich und fehlerfrei.

MCP in der Praxis

Wenn ich sage: “Wie warm ist es gerade im Wohnzimmer?” – dann passiert Folgendes:

Claude Code ruft mcp__homeassistant__search_entities auf, um den passenden Temperatursensor zu finden
Es nutzt mcp__homeassistant__get_entity_state, um den aktuellen Wert abzurufen
Es antwortet: “Der Sensor sensor.wohnzimmer_temperatur zeigt aktuell 21.3°C”

Kein Bash-Befehl, kein curl, kein JSON-Parsing. Reiner semantischer Zugriff.

Filesystem-Mount – Direkter Zugriff auf die Konfiguration

Die zweite Zugriffsschicht ist ein direkter Filesystem-Mount der Home-Assistant-Konfiguration in den Arbeitsrechner:

/mnt/haos/config/
├── automations.yaml           # Alle Automationen (~40 Stück)
├── configuration.yaml         # Hauptkonfiguration
├── scripts.yaml               # Scripts
├── scenes.yaml                # Szenen
├── integrations/              # Package-System (modular)
│   ├── energy.yaml             # Energiemonitoring + Verbrauchsoptimierung
│   ├── recorder.yaml          # Datenbank-Konfiguration
│   ├── templates.yaml         # Template-Sensoren
│   └── ...
└── custom_components/         # 20+ HACS-Komponenten
    ├── dwd_weather/           # Deutscher Wetterdienst
    ├── evcc_intg/             # Wallbox/PV-Steuerung
    ├── frigate/               # Kamera-NVR
    └── ...

Warum ein Mount statt SSH?

Claude Code hat dedizierte File-Tools: Read, Edit, Write, Glob, Grep. Diese Tools sind für Dateioperationen optimiert – mit Syntax-Highlighting, Diff-Ansicht und atomaren Edits. Über den Filesystem-Mount nutzt Claude Code diese Tools direkt auf den HA-Konfigurationsdateien.

Der Unterschied zu SSH-basiertem Zugriff:

Kein scp oder rsync – Dateien liegen direkt im Dateisystem
Kein Editor auf dem HA-Host nötig – Claude Code nutzt sein eigenes Edit-Tool
Glob-Suche über alle Configs – z.B. “Finde alle Automationen, die binary_sensor.haustuer referenzieren”
Grep durch die gesamte Konfiguration – z.B. “Welche Integrations nutzen platform: template?”

Das macht den Filesystem-Mount zum mächtigsten Werkzeug für Konfigurationsänderungen. Claude Code kann die gesamte HA-Konfiguration durchsuchen, verstehen und präzise bearbeiten – als wäre es ein lokales Projekt.

REST API und SSH – Der operative Hebel

Die dritte Schicht schließt die Lücke zwischen Konfigurationsänderung und Live-Betrieb. Wenn Claude Code eine automations.yaml bearbeitet hat, muss Home Assistant diese Änderung auch laden.

Reload per REST API (bevorzugt)

# Automation Reload – kein Neustart nötig
curl -s -X POST http://192.168.1.50:8123/api/services/automation/reload \
  -H "Authorization: Bearer $HA_TOKEN" \
  -H "Content-Type: application/json"

# Script Reload
curl -s -X POST http://192.168.1.50:8123/api/services/script/reload \
  -H "Authorization: Bearer $HA_TOKEN"

# Scene Reload
curl -s -X POST http://192.168.1.50:8123/api/services/scene/reload \
  -H "Authorization: Bearer $HA_TOKEN"

Der REST-API-Reload ist nicht-destruktiv: Laufende Automationen werden nicht unterbrochen, der HA-Core startet nicht neu. Die geänderte Konfiguration wird einfach neu eingelesen. Das dauert typischerweise unter zwei Sekunden.

SSH nur bei Bedarf

Für tiefergreifende Änderungen – etwa an der configuration.yaml oder an Integrations-Packages – ist ein vollständiger Core-Restart nötig:

ssh root@homeassistant "ha core restart"

Dieser Befehl wird bewusst selten eingesetzt, weil ein Restart alle laufenden Automationen kurzzeitig unterbricht. Claude Code weiß, wann ein Reload reicht und wann ein Restart notwendig ist – und wählt automatisch den schonendsten Weg.

Die Konfigurationsstruktur: Packages statt Monolith

Ein Schlüssel zur wartbaren HA-Konfiguration ist das Package-System. Statt alles in eine riesige configuration.yaml zu packen, nutze ich !include_dir_named für thematisch getrennte Konfigurationsdateien:

# configuration.yaml
homeassistant:
  packages: !include_dir_named integrations

Die Package-Struktur

Datei	Inhalt
`integrations/energy.yaml`	Energiemonitoring, Verbrauchssensoren, Schwellwert-Automationen
`integrations/templates.yaml`	Alle Template-Sensoren (berechnete Werte)
`integrations/recorder.yaml`	Datenbank-Excludes, Retention-Policies
`integrations/kalika/`	Projektspezifische Konfigurationen
`automations.yaml`	Alle ~40 Automationen in einer Datei

Warum Packages für KI-Zugriff ideal sind

Diese Struktur ist nicht nur für Menschen übersichtlich – sie ist auch für Claude Code optimal:

Kontextisolierung: Wenn ich sage “Optimiere das Energiemonitoring”, muss Claude Code nur integrations/energy.yaml lesen – nicht die gesamte Konfiguration
Gezielte Edits: Änderungen beschränken sich auf eine Datei, das Risiko unbeabsichtigter Seiteneffekte sinkt
Schnelle Suche: Glob("integrations/*.yaml") listet sofort alle thematischen Bereiche auf
Unabhängige Reloads: Package-Änderungen können oft ohne vollständigen Restart geladen werden

Die Kombination aus Package-System und Claude Codes File-Tools ist mächtig: Claude Code kann die gesamte Konfigurationslandschaft in Sekunden erfassen und versteht die Zusammenhänge zwischen Packages, Automationen und Entities.

Der Workflow in der Praxis

Der typische Ablauf, wenn Claude Code eine Änderung an Home Assistant vornimmt, folgt einem konsistenten Fünf-Schritte-Muster:

Schritt 1: Kontext erfassen (MCP)

→ mcp__homeassistant__search_entities("bewegungsmelder flur")
→ mcp__homeassistant__get_entity_state("binary_sensor.flur_bewegung")
→ mcp__homeassistant__get_entity_state("light.flur_decke")

Claude Code identifiziert die beteiligten Entities, prüft deren aktuellen Zustand und versteht die verfügbaren Attribute.

Schritt 2: Bestehende Konfiguration lesen (Filesystem)

→ Read("/mnt/haos/config/automations.yaml")
→ Grep("flur", path="/mnt/haos/config/")

Claude Code liest die vorhandene Konfiguration und sucht nach bestehenden Automationen, die den gleichen Bereich betreffen – um Konflikte zu vermeiden.

Schritt 3: Konfiguration bearbeiten (Filesystem)

→ Edit("/mnt/haos/config/automations.yaml",
    old_string: "# Ende der Automationen",
    new_string: "- id: 'flur_bewegungslicht'\n  alias: 'Flur Bewegungslicht'\n  ...")

Claude Code fügt die neue Automation mit korrekter YAML-Syntax ein. Es kennt die HA-Automation-Struktur: Trigger, Conditions, Actions, Modes.

Schritt 4: Reload auslösen (REST API)

→ curl -s -X POST http://192.168.1.50:8123/api/services/automation/reload

Die geänderte Konfiguration wird geladen – ohne Restart, ohne Unterbrechung.

Schritt 5: Verifizieren (MCP)

→ mcp__homeassistant__get_entity_state("automation.flur_bewegungslicht")

Claude Code prüft, ob die neue Automation korrekt geladen wurde und den erwarteten Zustand hat. Bei Fehlern analysiert es das Error-Log und korrigiert die Konfiguration.

Gesamtdauer: Unter 60 Sekunden – von der natürlichsprachlichen Anforderung bis zur laufenden Automation.

Praxisbeispiele: Was Claude Code in Sekunden umsetzt

Beispiel 1: Bewegungslicht mit Helligkeitsanpassung

Anforderung: “Mach mir ein Bewegungslicht im Flur. Tagsüber 100%, abends 30%, nachts aus.”

Claude Code erstellt eine Home Assistant Automation mit zeitabhängiger Helligkeitssteuerung, passenden Conditions für die Tageszeit und einem Auto-Off-Timer. Die gesamte YAML-Struktur – inklusive choose-Blöcken für die Tageszeitlogik – wird in einem Edit-Schritt eingefügt und sofort aktiviert.

Beispiel 2: Energieüberwachung mit Benachrichtigung

Anforderung: “Schick mir eine Pushbenachrichtigung, wenn der Stromverbrauch im Haus über 3 kW liegt und das länger als 10 Minuten anhält.”

Claude Code prüft über MCP die verfügbaren Energie-Entities, liest die bestehende Konfiguration für Benachrichtigungsintegrations und erstellt eine Automation mit numeric_state-Trigger, for-Dauer und einer Action, die den aktuellen Verbrauchswert direkt in die Push-Nachricht einbettet.

Beispiel 3: Debugging bestehender Automationen

Anforderung: “Die Garagentor-Automation triggert nicht mehr. Was ist los?”

Claude Code prüft per MCP den Entity-Zustand, liest die Automation aus der YAML-Datei, gleicht Trigger-Events mit dem HA-Log ab und identifiziert das Problem – zum Beispiel einen umbenannten Entity oder eine fehlende Integration. Dann korrigiert es die Konfiguration und verifiziert den Fix.

Beispiel 4: Bulk-Operationen

Anforderung: “Füge allen Licht-Automationen eine Übergangszeit von 2 Sekunden hinzu.”

Claude Code durchsucht per Grep alle Automationen, die Licht-Entities steuern, und ergänzt in jedem relevanten Action-Block den transition: 2-Parameter. Ein einzelner Reload aktiviert alle Änderungen gleichzeitig.

Praxisergebnis: Die mit Home Assistant gesteuerte Energieautomatisierung hat messbare Ergebnisse gebracht — die Details findest du im Heizkosten-Erfahrungsbericht 2025/26.

Sicherheit und Grenzen

Vollzugriff bedeutet auch Verantwortung. Einige wichtige Aspekte zum sicheren Betrieb:

Was gut funktioniert

Nicht-destruktive Reloads: Claude Code bevorzugt Reloads gegenüber Restarts
Proxmox-Snapshots: Vor größeren Umbauten kann ein VM-Snapshot als Sicherheitsnetz dienen
YAML-Validierung: Claude Code kennt die HA-YAML-Syntax und produziert selten syntaktisch fehlerhafte Konfigurationen
Verifizierung nach Änderung: Jede Änderung wird über MCP auf Korrektheit geprüft
Permission-System: Claude Codes eigenes Berechtigungssystem fragt bei kritischen Operationen nach Bestätigung

Worauf man achten sollte

Kein blindes Vertrauen: Bei sicherheitsrelevanten Automationen (Alarmanlagen, Türschlösser) die generierte YAML immer manuell prüfen
Backups: Regelmäßige Proxmox-Snapshots und Git-Versionierung der HA-Config sind Pflicht
Token-Sicherheit: Der HA Long-Lived Access Token sollte mit minimalen Rechten konfiguriert sein — wer mehr über sichere KI-Tool-Nutzung wissen will, findet hier ein warnendes Beispiel
Netzwerk-Segmentierung: Der HA-Host gehört in ein separates VLAN, der Mount nur vom Arbeitsrechner erreichbar

Einschränkungen des Setups

Nicht alles lässt sich über diesen Weg lösen:

Add-on-Installation: HACS-Komponenten und Supervisor-Add-ons erfordern teilweise die Web-UI
Geräte-Pairing: Zigbee/Z-Wave-Geräte müssen über die UI angelernt werden
Dashboard-Design: Lovelace-Dashboards sind visuell – hier ist die UI oft effizienter als YAML
Firmware-Updates: Device-Updates laufen über die jeweiligen Integrations-UIs

FAQ: Häufige Fragen zum Setup

Brauche ich Programmierkenntnisse für Home Assistant mit Claude Code?

Grundlegendes YAML-Verständnis hilft, ist aber nicht zwingend nötig. Claude Code erklärt die generierten Konfigurationen auf Wunsch und kann auch bestehende Automationen in natürlicher Sprache zusammenfassen. Für die Einrichtung des Filesystem-Mounts und der MCP-Verbindung sind allerdings Linux-Grundkenntnisse erforderlich.

Funktioniert MCP auch mit anderen KI-Assistenten außer Claude Code?

Das MCP-Protokoll ist ein offener Standard. Theoretisch kann jeder MCP-fähige KI-Assistent die gleichen Tools nutzen. Die Kombination mit Filesystem-Mount und REST API ist jedoch spezifisch für Claude Code, da es die entsprechenden File-Tools (Read, Edit, Glob, Grep) mitbringt.

Wie schnell setzt Claude Code eine Home Assistant Automation um?

Eine typische Automation-Erstellung dauert 30 bis 60 Sekunden End-to-End. Der Reload selbst benötigt unter zwei Sekunden. MCP-Abfragen antworten in der Regel innerhalb von 200 bis 500 Millisekunden.

Was passiert bei einem YAML-Fehler in der Home Assistant Konfiguration?

Home Assistant validiert die Konfiguration beim Reload. Bei Syntaxfehlern wird die alte Konfiguration beibehalten und ein Fehler ins Log geschrieben. Claude Code kann diesen Fehler über MCP (get_error_log) auslesen, die Ursache identifizieren und die Konfiguration korrigieren – alles in der gleichen Session.

Ist der Filesystem-Mount sicher?

Der Mount läuft über das lokale Netzwerk und ist nur vom Arbeitsrechner erreichbar. Zusätzlich empfiehlt sich eine Firewall-Regel, die den NFS/CIFS-Port auf die IP des Arbeitsrechners beschränkt. Der HA-Token für die REST API sollte als Umgebungsvariable gespeichert und nicht im Klartext in Konfigurationsdateien stehen.

Kann Claude Code Home Assistant Add-ons und HACS-Integrationen installieren?

Teilweise. Supervisor-API-Calls sind möglich, aber die meisten Add-on-Installationen erfordern Bestätigungen über die Web-UI. In der Praxis nutze ich die UI für Installationen und Claude Code für die anschließende Konfiguration.

Fazit: Smart Home mit KI-Vollzugriff

Dieses Setup verändert grundlegend, wie ich mit Home Assistant arbeite. Statt mich durch YAML-Dokumentation zu graben, Syntax nachzuschlagen und Reload-Befehle manuell abzusetzen, formuliere ich einfach, was ich will – und Claude Code setzt es um.

Die drei Zugriffsschichten ergänzen sich perfekt:

MCP für semantischen Zugriff: Zustände lesen, Geräte steuern, Automationen triggern
Filesystem-Mount für Konfigurationsarbeit: YAML lesen, bearbeiten, durchsuchen
REST API + SSH für operative Kontrolle: Reload, Restart, Diagnose

Home Assistant liefert die Plattform, Claude Code die Geschwindigkeit bei der Umsetzung, und Prometheus die Langzeitdaten, die schwarz auf weiß zeigen, was funktioniert und was nicht.

Die Einrichtung neuer Automationen, Sensoren und Steuerungslogiken ist mit Claude Code im Vollzugriff eine Sache von Minuten statt Stunden. Du beschreibst, was du willst, Claude Code setzt es um, und nach einem Reload läuft es. Das gilt für Beleuchtung, Sicherheit, Energiemanagement oder jede andere Home-Assistant-Domain gleichermaßen.

Tipp zum Einstieg: Beginne mit dem MCP-Server und einer einzelnen Automation. Schon damit erlebst du den Unterschied zwischen manuellem YAML-Editing und natürlichsprachlicher Konfiguration. Der Rest wächst organisch.

Du nutzt Home Assistant und willst Claude Code anbinden? Teile deine Erfahrungen in den Kommentaren — mich interessiert besonders: Welche Automationen habt ihr als erstes umgesetzt?