Agente de hogar inteligente con IA local
Qué cubre este artículo sobre agentes de hogar inteligente
- Qué es un agente de hogar inteligente y cómo funciona.
- Cómo el agente toma decisiones autónomas.
- Cómo funciona el tool-calling para controlar Home Assistant.
- Ejemplos prácticos para energía, seguridad, confort y mantenimiento.
- Mejores prácticas para seguridad, confiabilidad y planes de contingencia.
Introducción: El agente de hogar inteligente explicado
Un agente de hogar inteligente es un agente de IA que controla tu hogar de forma autónoma. Observa sensores, toma decisiones y ejecuta acciones, no solo con reglas si-entonces, sino de manera inteligente: “Hace calor, pero hay gente en casa → ventilar en lugar de enfriar”. El agente planifica, actúa y aprende.
Este artículo está dirigido a usuarios avanzados que quieren implementar agentes de IA en el hogar inteligente. Encontrarás los fundamentos en Agentes de IA y Home Assistant con IA.
¿Por qué necesito un agente de hogar inteligente?
La automatización clásica dice: “Si la temperatura > 25°, activa el aire acondicionado”. Un agente dice: “Hace calor, pero las ventanas están abiertas y la temperatura exterior es más baja → ventilar en lugar de enfriar”. El agente entiende el contexto y toma decisiones inteligentes.
Agente de hogar inteligente en pocas palabras
Agente = LLM + Herramientas + Objetivo. El agente observa sensores, planifica acciones, las ejecuta y verifica el resultado. Con Ollama en local, usando Home Assistant como capa de actuación.
La idea central es: no solo reaccionar, sino actuar de manera inteligente.
Para quién es este artículo
- Usuarios avanzados que construyen sistemas autónomos de hogar inteligente.
- Desarrolladores de agentes de IA que usan tool-calling en el hogar inteligente.
- Power users de Home Assistant que van más allá de las automatizaciones.
- Entusiastas que construyen sistemas experimentales con IA.
Conceptos clave
- Agente de IA - Actor autónomo. Útil cuando: necesitas el concepto.
- Tool-Calling - Invocar herramientas. Útil cuando: ejecutas acciones.
- Ollama - Servidor de modelos local. Útil cuando: necesitas el backend.
- Home Assistant - Plataforma de hogar inteligente. Útil cuando: ejecutas acciones.
- Node-RED - Para flujos complejos. Útil cuando: necesitas complementos.
- Aprobación humana - Seguridad. Útil cuando: actúas sobre cosas críticas.
Arquitectura
Sensores (Temperatura, Movimiento, Ventanas, ...)
│
▼
Agente (Ollama + Herramientas)
│
├─ Observar: Leer datos de sensores
├─ Planificar: ¿Qué hacer? (LLM decide)
├─ Actuar: Invocar herramientas (Servicios de HA)
└─ Verificar: ¿Funcionó?
│
▼
Acciones (Home Assistant Services)
│
├─ light.turn_on / light.turn_off
├─ climate.set_temperature
├─ cover.open / cover.close
├─ media_player.play / media_player.stop
└─ notify.notify (Notificación)Ejemplo práctico 1: Agente de energía
class EnergyAgent:
"""Agent para gestión de energía"""
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. Observar
state = await self.observe()
# 2. Planificar (LLM decide)
plan = await self.plan(state)
# 3. Actuar
for action in plan["actions"]:
await self.execute(action)
# 4. Verificar
result = await self.verify()
return result
async def plan(self, state):
"""LLM planifica acciones"""
prompt = f"""Eres un agente de gestión de energía.
Estado actual: {state}
Acciones disponibles:
- turn_on_device(device): Encender dispositivo
- turn_off_device(device): Apagar dispositivo
- get_energy_price(): Consultar precio de electricidad
Objetivo: Minimizar costos de energía, mantener el confort.
Planifica las siguientes acciones como JSON:
{{"reasoning": "...", "actions": [{{"tool": "...", "params": {{...}}}}]}}"""
response = await ollama.generate(prompt)
return json.loads(response)Ejemplo práctico 2: Agente de seguridad
class SecurityAgent:
"""Agent para monitoreo de seguridad"""
async def on_motion(self, sensor, time):
"""Al detectar movimiento"""
context = await self.gather_context()
# IA analiza
analysis = await ollama.generate(f"""
Movimiento detectado:
- Sensor: {sensor}
- Hora: {time}
- Personas en casa: {context['people']}
- Alarmas recientes: {context['recent_alarms']}
- Estado de ventanas: {context['windows']}
¿Es esto sospechoso? Responde como JSON:
{{"verdict": "normal|sospechoso|critico", "reason": "...", "actions": [...]}}""")
result = json.loads(analysis)
if result["verdict"] == "critico":
await self.execute_emergency(result["actions"])
elif result["verdict"] == "sospechoso":
await self.notify_owner(result)
async def execute_emergency(self, actions):
"""Acciones críticas con aprobación humana"""
for action in actions:
if action["type"] == "critical":
# Esperar aprobación humana
approved = await self.request_human_approval(action)
if approved:
await self.execute(action)
else:
await self.execute(action)Ejemplo práctico 3: Agente de confort
class ComfortAgent:
"""Agent para optimización de confort"""
async def optimize(self):
"""Optimizar confort"""
state = await self.observe()
# IA decide
decision = await ollama.generate(f"""
Estado:
- Temperatura: {state['temp']}°C
- Humedad: {state['humidity']}%
- Luz: {state['light']}
- Personas: {state['people']}
- Hora del día: {state['time']}
- Clima: {state['weather']}
¿Qué se debe hacer para un confort óptimo?
Responde como JSON: {{"actions": [...], "reason": "..."}}""")
for action in json.loads(decision)["actions"]:
await self.execute(action)Tool-Calling para Home Assistant
# Definir herramientas
tools = [
{
"type": "function",
"function": {
"name": "light_control",
"description": "Controlar iluminación",
"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": "Controlar clima",
"parameters": {
"type": "object",
"properties": {
"entity": {"type": "string"},
"temperature": {"type": "number"},
"mode": {"type": "string", "enum": ["heat", "cool", "off"]}
}
}
}
}
]
# Ollama con herramientas
response = requests.post("http://ollama:11434/api/chat", json={
"model": "llama3.1",
"messages": [
{"role": "system", "content": "Eres un agente de hogar inteligente. Utiliza herramientas para las acciones."},
{"role": "user", "content": "Hace calor, hazlo más frío."}
],
"tools": tools,
"stream": False
})
# Procesar invocaciones de herramientas
for tool_call in response.json()["message"].get("tool_calls", []):
await execute_tool(tool_call)Notas de seguridad
- Aprobación humana: Las acciones críticas (abrir puerta, activar alarma) requieren aprobación. Consulta Aprobación humana.
- Fallback: Si el agente falla, las automatizaciones críticas deben ejecutarse en HA.
- Registro: Registra todas las decisiones del agente. Consulta Registro.
- Permisos: El agente solo debe tener los permisos necesarios. Consulta Permisos de herramientas.
- Validación: Valida las salidas del agente antes de ejecutar acciones.
Errores comunes
- Demasiada autonomía: El agente no debe tomar todas las decisiones solo. Las acciones críticas necesitan aprobación.
- Sin fallback: Si el agente falla, la automatización se detiene. Necesitas un fallback en HA.
- Demasiadas herramientas: Más de 5-7 herramientas abruman al modelo. Menos es mejor.
- Descripciones de herramientas imprecisas: El modelo decide basándose en la descripción. Formula con precisión.
- Sin límite de iteraciones: Los agentes pueden quedar atrapados en bucles. Establece un máximo de iteraciones.
Enlaces relacionados
- Agentes IA - Conceptos básicos de agentes.
- Home Assistant con IA - HA + IA.
- Asistente de voz local - Control por voz.
- Automatización del hogar - Descripción general.
- Permisos de herramientas - Seguridad.
- Aprobación humana - Aprobación.
- Node-RED Home Assistant - Para flujos complejos.
Puntos clave:
- Agente para casa inteligente: observa, planifica, actúa, valida, opera autónomamente.
- Tool-calling para controlar Home Assistant.
- Las acciones críticas requieren aprobación humana.
- Fallback en HA para automatizaciones críticas.
- IA local: todos tus datos permanecen privados.
Preguntas frecuentes
¿Qué es un agente para casa inteligente?
Un agente IA que controla tu hogar de forma autónoma: monitorea sensores, toma decisiones y ejecuta acciones. Más inteligente que la automatización clásica si-entonces.
¿Agente o automatización clásica?
Automatización clásica para reglas simples si-entonces. Agente para decisiones complejas con contexto. Ambos pueden trabajar juntos.
¿Es seguro un agente?
Sí, si está bien configurado: limita los permisos de las herramientas, requiere aprobación humana para acciones críticas, usa fallback en HA y registra todas las decisiones.
¿Cómo funciona el tool-calling?
El agente dispone de herramientas (light_control, climate_control, etc.). El modelo decide cuál usar. Las herramientas ejecutan servicios de Home Assistant.
¿Cuánta VRAM necesito?
llama3.1:8b requiere aproximadamente 5 GB. Para buena calidad de agente se recomienda al menos 8B. Los modelos más grandes son mejores pero más lentos.
¿Qué pasa si el agente falla?
Las automatizaciones críticas deben ejecutarse como fallback en Home Assistant. El agente es la capa inteligente, no la única.
¿Cuánto cuesta?
Nada. Ollama, Home Assistant y Node-RED son software de código abierto. Solo pagas por el hardware del servidor.
¿Mis datos permanecen privados?
Completamente. Todo se procesa localmente. Ningún dato de sensores ni comando de control abandona tu red.
Fuentes y lecturas complementarias
- Ollama - Servidor de modelos local.
- Home Assistant - Plataforma de automatización del hogar.
- LangChain Agents - Conceptos de agentes.
- ReAct - Razonamiento + Acción.