Smart Home Agent mit lokaler KI
Was dieser Artikel über Smart Home Agents behandelt
- Was ein Smart Home Agent ist und wie er funktioniert.
- Wie der Agent autonome Entscheidungen trifft.
- Wie Tool-Calling für Home-Assistant-Steuerung funktioniert.
- Praxisbeispiele für Energie, Sicherheit, Komfort und Wartung.
- Best Practices für Sicherheit, Zuverlässigkeit und Fallbacks.
Einleitung: Smart Home Agent verständlich erklärt
Ein Smart Home Agent ist ein KI-Agent, der Dein Zuhause autonom steuert. Er beobachtet Sensoren, trifft Entscheidungen und führt Aktionen aus, nicht nur wenn-dann, sondern intelligent: „Es ist warm, aber jemand ist zu Hause → lüften statt kühlen”. Der Agent plant, handelt und lernt.
Dieser Artikel richtet sich an fortgeschrittene Anwender, die KI-Agenten im Smart Home einsetzen wollen. Grundlagen findest Du in KI-Agenten und Home Assistant mit KI.
Warum brauche ich einen Smart Home Agent?
Klassische Automatisierung: „Wenn Temperatur > 25°, dann Klima an”. Ein Agent: „Es ist warm, aber die Fenster sind offen und die Außentemperatur ist niedriger → lüften statt kühlen”. Der Agent versteht Kontext und trifft intelligente Entscheidungen.
Smart Home Agent kurz erklärt
Agent = LLM + Tools + Ziel. Der Agent beobachtet Sensoren, plant Aktionen, führt sie aus und prüft das Ergebnis. Mit Ollama lokal, mit Home Assistant als Aktionsschicht.
Der Kerngedanke lautet: Nicht nur reagieren, sondern intelligent handeln.
Für wen ist dieser Artikel gedacht?
- Fortgeschrittene, die autonome Smart-Home-Systeme bauen.
- KI-Agenten-Entwickler, die Tool-Calling im Smart Home nutzen.
- Home-Assistant-Power-User, die über Automatisierungen hinausgehen.
- Tinkerer, die experimentelle KI-Systeme bauen.
Wichtige Begriffe
- KI-Agent - Autonomer Akteur. Wann nützlich: das Konzept.
- Tool-Calling - Werkzeuge aufrufen. Wann nützlich: für Aktionen.
- Ollama - Lokaler Modellserver. Wann nützlich: das Backend.
- Home Assistant - Smart-Home-Plattform. Wann nützlich: für Aktionen.
- Node-RED - Für komplexe Flows. Wann nützlich: als Ergänzung.
- Menschliche Freigabe - Sicherheit. Wann nützlich: für kritische Aktionen.
Architektur
Sensoren (Temperatur, Bewegung, Fenster, ...)
│
▼
Agent (Ollama + Tools)
│
├─ Beobachten: Sensordaten lesen
├─ Planen: Was tun? (LLM entscheidet)
├─ Handeln: Tools aufrufen (HA-Services)
└─ Prüfen: Hat es funktioniert?
│
▼
Aktionen (Home Assistant Services)
│
├─ light.turn_on / light.turn_off
├─ climate.set_temperature
├─ cover.open / cover.close
├─ media_player.play / media_player.stop
└─ notify.notify (Benachrichtigung)Praxisbeispiel 1: Energie-Agent
class EnergyAgent:
"""Agent für Energie-Management"""
def __init__(self):
self.tools = {
"get_energy_price": self.get_energy_price,
"turn_on_device": self.turn_on_device,
"turn_off_device": self.turn_off_device,
"get_consumption": self.get_consumption
}
async def run(self):
"""Agent-Loop"""
# 1. Beobachten
state = await self.observe()
# 2. Planen (LLM entscheidet)
plan = await self.plan(state)
# 3. Handeln
for action in plan["actions"]:
await self.execute(action)
# 4. Prüfen
result = await self.verify()
return result
async def plan(self, state):
"""LLM plant Aktionen"""
prompt = f"""Du bist ein Energie-Management-Agent.
Aktueller Zustand: {state}
Verfügbare Aktionen:
- turn_on_device(device): Gerät einschalten
- turn_off_device(device): Gerät ausschalten
- get_energy_price(): Strompreis abfragen
Ziel: Energiekosten minimieren, Komfort erhalten.
Plane die nächsten Aktionen als JSON:
{{"reasoning": "...", "actions": [{{"tool": "...", "params": {{...}}}}]}}"""
response = await ollama.generate(prompt)
return json.loads(response)Praxisbeispiel 2: Sicherheits-Agent
class SecurityAgent:
"""Agent für Sicherheits-Monitoring"""
async def on_motion(self, sensor, time):
"""Bei Bewegung"""
context = await self.gather_context()
# KI analysiert
analysis = await ollama.generate(f"""
Bewegung erkannt:
- Sensor: {sensor}
- Zeit: {time}
- Personen zu Hause: {context['people']}
- Letzte Alarme: {context['recent_alarms']}
- Fensterstatus: {context['windows']}
Ist das verdächtig? Antworte als JSON:
{{"verdict": "normal|verdaechtig|kritisch", "reason": "...", "actions": [...]}}""")
result = json.loads(analysis)
if result["verdict"] == "kritisch":
await self.execute_emergency(result["actions"])
elif result["verdict"] == "verdaechtig":
await self.notify_owner(result)
async def execute_emergency(self, actions):
"""Kritische Aktionen mit menschlicher Freigabe"""
for action in actions:
if action["type"] == "critical":
# Warte auf menschliche Freigabe
approved = await self.request_human_approval(action)
if approved:
await self.execute(action)
else:
await self.execute(action)Praxisbeispiel 3: Komfort-Agent
class ComfortAgent:
"""Agent für Komfort-Optimierung"""
async def optimize(self):
"""Komfort optimieren"""
state = await self.observe()
# KI entscheidet
decision = await ollama.generate(f"""
Zustand:
- Temperatur: {state['temp']}°C
- Luftfeuchtigkeit: {state['humidity']}%
- Licht: {state['light']}
- Personen: {state['people']}
- Tageszeit: {state['time']}
- Wetter: {state['weather']}
Was sollte für optimalen Komfort getan werden?
Antworte als JSON: {{"actions": [...], "reason": "..."}}""")
for action in json.loads(decision)["actions"]:
await self.execute(action)Tool-Calling für Home Assistant
# Tools definieren
tools = [
{
"type": "function",
"function": {
"name": "light_control",
"description": "Licht steuern",
"parameters": {
"type": "object",
"properties": {
"entity": {"type": "string", "description": "light.entity_id"},
"action": {"type": "string", "enum": ["turn_on", "turn_off", "toggle"]},
"brightness": {"type": "integer", "minimum": 0, "maximum": 255}
},
"required": ["entity", "action"]
}
}
},
{
"type": "function",
"function": {
"name": "climate_control",
"description": "Klima steuern",
"parameters": {
"type": "object",
"properties": {
"entity": {"type": "string"},
"temperature": {"type": "number"},
"mode": {"type": "string", "enum": ["heat", "cool", "off"]}
}
}
}
}
]
# Ollama mit Tools
response = requests.post("http://ollama:11434/api/chat", json={
"model": "llama3.1",
"messages": [
{"role": "system", "content": "Du bist ein Smart-Home-Agent. Nutze Tools für Aktionen."},
{"role": "user", "content": "Es ist warm, mach es kühler."}
],
"tools": tools,
"stream": False
})
# Tool-Aufrufe verarbeiten
for tool_call in response.json()["message"].get("tool_calls", []):
await execute_tool(tool_call)Sicherheitshinweise
- Menschliche Freigabe: Kritische Aktionen (Tür öffnen, Alarm) brauchen Freigabe. Siehe Menschliche Freigabe.
- Fallback: Bei Agent-Ausfall sollten kritische Automatisierungen in HA laufen.
- Logging: Protokolliere alle Agenten-Entscheidungen. Siehe Protokollierung.
- Berechtigungen: Agent sollte nur nötige Berechtigungen haben. Siehe Tool-Berechtigungen.
- Validierung: Agent-Ausgaben prüfen, bevor Aktionen ausgeführt werden.
Typische Stolpersteine
- Zu autonom: Agent sollte nicht alles alleine entscheiden. Kritische Aktionen brauchen Freigabe.
- Kein Fallback: Bei Agent-Ausfall stoppt die Automatisierung. Fallback in HA nötig.
- Zu viele Tools: Mehr als 5-7 Tools überfordern das Modell. Weniger ist mehr.
- Schlechte Tool-Beschreibungen: Das Modell entscheidet anhand der Beschreibung. Präzise formulieren.
- Keine Iterationsgrenze: Agenten können in Schleifen landen. Max iterations setzen.
Weiterführende Links
- KI-Agenten - Agenten-Grundlagen.
- Home Assistant mit KI - HA + KI.
- Lokaler Sprachassistent - Sprachsteuerung.
- Heimautomatisierung - Übersicht.
- Tool-Berechtigungen - Sicherheit.
- Menschliche Freigabe - Freigabe.
- Node-RED Home Assistant - Für komplexe Flows.
Key Takeaways:
- Smart Home Agent: Beobachtet, plant, handelt, prüft, autonom.
- Tool-Calling für Home-Assistant-Steuerung.
- Kritische Aktionen brauchen menschliche Freigabe.
- Fallback in HA für kritische Automatisierungen.
- Lokale KI: alle Daten bleiben privat.
FAQ
Was ist ein Smart Home Agent?
Ein KI-Agent, der Dein Zuhause autonom steuert: Er beobachtet Sensoren, trifft Entscheidungen und führt Aktionen aus. Intelligenter als klassische Wenn-Dann-Automatisierung.
Agent oder klassische Automatisierung?
Klassische Automatisierung für einfache Wenn-Dann. Agent für komplexe Entscheidungen mit Kontext. Beide können kombiniert werden.
Ist ein Agent sicher?
Ja, wenn richtig konfiguriert: Tool-Berechtigungen einschränken, kritische Aktionen mit menschlicher Freigabe, Fallback in HA, alle Entscheidungen loggen.
Wie funktioniert Tool-Calling?
Der Agent hat Tools (light_control, climate_control, …). Das Modell entscheidet, welches Tool es aufruft. Die Tools führen Home-Assistant-Services aus.
Wie viel VRAM brauche ich?
llama3.1:8b: ~5 GB. Für gute Agenten-Qualität mindestens 8B empfohlen. Größere Modelle sind besser, aber langsamer.
Was, wenn der Agent ausfällt?
Kritische Automatisierungen sollten als Fallback in Home Assistant laufen. Der Agent ist die intelligente Schicht, nicht die einzige.
Was kostet das?
Kostenlos. Ollama, Home Assistant und Node-RED sind Open Source. Nur Hardware-Kosten für den Server.
Bleiben meine Daten privat?
Ja, komplett. Alle Verarbeitung lokal. Keine Sensordaten oder Steuerbefehle verlassen Dein Netzwerk.
Quellen und weiterführende Literatur
- Ollama - Lokaler Modellserver.
- Home Assistant - Smart-Home-Plattform.
- LangChain Agents - Agenten-Konzepte.
- ReAct - Reasoning + Acting.