Aprende a crear agentes en Hermes con una ruta práctica y verificable: instalación, modelos, herramientas, memoria, habilidades, canales y automatización.

¿Por qué Hermes es útil para automatizar tareas?

Hermes es una plataforma de código abierto que permite crear agentes de IA locales con memoria persistente, acceso a herramientas y capacidad de automatización. A diferencia de los chatbots tradicionales, que olvidan el contexto tras cada conversación, Hermes puede:

• Recordar información entre sesiones (ej.: tus preferencias, datos históricos o configuraciones).
• Ejecutar herramientas como búsqueda web, operaciones con archivos, cálculos o código.
• Automatizar flujos de trabajo mediante programación horaria o disparadores externos.
• Integrarse con canales como Telegram, Discord o Slack para interactuar desde cualquier dispositivo.

Esto lo hace ideal para tareas repetitivas que requieren contexto, como:

• Seguimiento de mercados financieros (ej.: cotizaciones de bolsa en tiempo real).
• Importación y procesamiento de noticias desde fuentes RSS.
• Generación de informes diarios basados en datos actualizados.
• Monitoreo de sistemas o alertas personalizadas.

En esta guía, te mostraremos cómo configurar Hermes desde cero y, como ejemplo práctico, crearemos dos agentes completos:
1) Un agente de seguimiento de bolsa que monitorea cotizaciones de acciones y genera alertas, y
2) un importador de noticias RSS que recopila y resume titulares de tus fuentes favoritas.

¿Qué es Hermes?

Hermes Agent es un asistente de inteligencia artificial que puedes ejecutar en tu computadora. Su diseño se centra en tres pilares:

• Memoria persistente: guarda el contexto de las conversaciones y los datos que le proporcionas, incluso después de cerrar la sesión.
• Herramientas integradas: puede buscar en la web, leer/escribir archivos, ejecutar código o interactuar con APIs externas.
• Automatización: permite programar tareas recurrentes o conectarse a canales de mensajería para operar en segundo plano.

La documentación oficial lo describe como un sistema que:

• Se ejecuta mediante interfaz de línea de comandos o escritorio.
• Soporta múltiples proveedores de modelos (Ollama, Anthropic, OpenRouter, etc.).
• Permite reconfigurar modelos, herramientas y canales mediante comandos dedicados.

En términos prácticos, Hermes actúa como una capa de orquestación: el modelo de lenguaje responde a tus preguntas, pero Hermes decide cómo iniciar la sesión, qué herramientas usar, cómo mantener el contexto y cuándo ejecutar acciones automatizadas.

Instalación de Hermes

La instalación oficial está documentada para macOS, Windows y Linux. A continuación, los métodos recomendados:

Opción 1: macOS (Terminal)

Ejecuta el siguiente comando en la terminal:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

El script instalará automáticamente:

• Gestor de paquetes wv (para Python).
• Paquete de Hermes Agent.
• Node.js y npe (para funciones de gateway).
• Autocompletado de shell.

Tras la instalación, cierra y vuelve a abrir la terminal y verifica con:

hermes version

Versión esperada: v0.15.1 o superior.

Opción 2: Windows 11 (PowerShell)

Ejecuta en PowerShell como administrador:

iex (irm https://hermes-agent.nousresearch.com/install.ps1)

El instalador gestionará dependencias como Python, Node.js, ripgrep y ffmpeg. Tras la instalación, verifica con:

hermes version

Opción 3: Docker (para aislamiento completo)

Si prefieres un entorno aislado, sigue estos pasos para crear un contenedor Docker con Ubuntu:

1. Habilitar WSL2 en Windows:
   • Abre Panel de Control > Programas > Activar o desactivar características de Windows.
   • Marca: Hyper-V, Plataforma de Máquina Virtual y Subsistema de Windows para Linux.
   • Reinicia el equipo.
   • Ejecuta en PowerShell: bcdedit /set hypervisorlaunchtype auto.
2. Instalar Ubuntu:wsl --install -d Ubuntu
3. Instalar Docker Desktop:
   • Descarga Docker Desktop para Windows 11.
   • Ejecuta el instalador como administrador.
   • Activa la integración con WSL en Configuración > Recursos.
4. Crear el contenedor:Crea una carpeta docker-hermes y dentro de ella, los siguientes archivos:
   • .env:

     ROOT_PASSWORD=tu_contraseña_root
     USER_PASSWORD=tu_contraseña_usuario

   • Dockerfile:

     FROM ubuntu:24.04
     ARG ROOT_PASSWORD
     ARG USER_PASSWORD
     RUN apt-get update && apt-get install -y openssh-server vim sudo git curl
     RUN mkdir /var/run/sshd
     RUN echo "root:$ROOT_PASSWORD" | chpasswd
     RUN useradd -m -s /bin/bash hermesuser && \
         echo "hermesuser:$USER_PASSWORD" | chpasswd && \
         usermod -aG sudo hermesuser
     RUN sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \
         echo 'PasswordAuthentication yes' >> /etc/ssh/sshd_config
     EXPOSE 22
     CMD ["/usr/sbin/sshd", "-D"]

   • docker-compose.yml:

     services:
       hermes-dev:
         build:
           context: .
           args:
             - ROOT_PASSWORD=$ROOT_PASSWORD
             - USER_PASSWORD=$USER_PASSWORD
         container_name: hermes-dev
         ports:
           - "2222:22"
         volumes:
           - ./hermes_data:/home/hermesuser
         restart: unless-stopped

5. Compilar y lanzar el contenedor:docker compose up -d --build

   docker compose ps

6. Instalar Hermes dentro del contenedor:ssh hermesuser@localhost -p 2222

   curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

   Verifica con: hermes version

—

Verificación inicial

Antes de crear un agente, verifica que todo funciona correctamente:

1. Versión: hermes version (debe mostrar v0.15.1 o superior).
2. Diagnóstico: hermes doctor (debe mostrar todos los checks en verde).
3. Estado: hermes status (muestra la configuración actual).

Si alguno de estos pasos falla, no continúes. Resuelve los errores primero.

Configuración de modelos

Hermes soporta múltiples proveedores de modelos. Para esta guía, usaremos Ollama Cloud (recomendado para principiantes) o Modelos locales con Ollama.

Opción 1: Ollama Cloud (recomendado)

1. Crear cuenta en Ollama:
   • Regístrate en ollama.com.
   • Suscríbete al plan Pro ($20/mes) para acceso a modelos avanzados como glm-5.1:cloud o kimi-k2.6:cloud.
2. Obtener la API key:
   • Ve a Configuración > Claves API.
   • Crea una nueva clave y cópiala.
3. Configurar en Hermes:Edita el archivo de entorno:

   nano ~/.hermes/.env

   Agrega:

   OLLAMA_API_KEY=tu_clave_api_aquí

   Guarda el archivo y verifica con:

   Advertisement

   hermes model

4. Seleccionar modelo:hermes config set model glm-5.1:cloud

   Verifica con: hermes status (debe mostrar el modelo seleccionado).

Opción 2: Ollama local (para modelos sin cloud)

1. Instalar Ollama: curl -fsSL https://ollama.com/install.sh | sh
2. Descargar un modelo: ollama pull llama3.2 (o el modelo que prefieras).
3. Conectar a Hermes:ollama launch hermes

   O configura manualmente el endpoint:

   http://127.0.0.1:11434/v1

Recomendación: Para los ejemplos de esta guía, usa glm-5.1:cloud (bueno para razonamiento largo) o kimi-k2.6:cloud (ideal para código y multimodal).

Herramientas esenciales

Hermes incluye herramientas integradas para interactuar con el mundo real. Para los ejemplos de esta guía, necesitarás:

• Búsqueda web: para consultar información en línea.
• Archivos: para leer y escribir datos.
• Código: para ejecutar scripts de Python o terminal.
• HTTP: para hacer peticiones a APIs externas.

Actívalas con:

/tools enable search files code http

O desde la terminal:

hermes tools enable search files code http

Ejemplo completo: Agente de seguimiento de bolsa

En este ejemplo, crearemos un agente que:

1. Consulta las cotizaciones de acciones específicas (ej.: AAPL, GOOGL).
2. Guarda los datos históricos en un archivo CSV.
3. Genera alertas si una acción sube o baja más de un 5% en un día.
4. Envía un resumen diario por Telegram.

Paso 1: Crear el script de seguimiento

Crea un archivo ~/hermes_bolsa/seguimiento_bolsa.py con el siguiente contenido:

import requests
import csv
from datetime import datetime
import os

# Configuración
ACCIONES = ["AAPL", "GOOGL", "MSFT"]  # Símbolos de acciones
API_KEY = "TU_API_KEY_ALPHA_VANTAGE"  # Reemplaza con tu clave de Alpha Vantage
ARCHIVO_CSV = "~/hermes_bolsa/historico_bolsa.csv"

def obtener_cotizacion(simbolo):
    """Obtiene la cotización actual de una acción usando Alpha Vantage."""
    url = f"https://www.alphavantage.co/query?function=GLOBAL_QUOTE&symbol={simbolo}&apikey={API_KEY}"
    response = requests.get(url)
    data = response.json()
    if "Global Quote" in data:
        return {
            "simbolo": simbolo,
            "precio": float(data["Global Quote"]["05. price"]),
            "cambio": float(data["Global Quote"]["09. change"]),
            "porcentaje": float(data["Global Quote"]["10. change percent"].strip("%")),
            "fecha": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }
    return None

def guardar_datos(cotizaciones):
    """Guarda las cotizaciones en un archivo CSV."""
    file_exists = os.path.isfile(ARCHIVO_CSV)
    with open(ARCHIVO_CSV, mode='a', newline='') as file:
        writer = csv.DictWriter(file, fieldnames=["fecha", "simbolo", "precio", "cambio", "porcentaje"])
        if not file_exists:
            writer.writeheader()
        for cot in cotizaciones:
            writer.writerow(cot)

def generar_alertas(cotizaciones):
    """Genera alertas si hay cambios significativos."""
    alertas = []
    for cot in cotizaciones:
        if abs(cot["porcentaje"]) > 5:  # Más del 5% de cambio
            alertas.append(
                f"🚨 ALERTA: {cot['simbolo']} ha cambiado un {cot['porcentaje']:.2f}% (Precio: ${cot['precio']:.2f})"
            )
    return alertas

def main():
    cotizaciones = []
    for simbolo in ACCIONES:
        cot = obtener_cotizacion(simbolo)
        if cot:
            cotizaciones.append(cot)

    guardar_datos(cotizaciones)
    alertas = generar_alertas(cotizaciones)

    # Resumen
    resumen = "📊 **Resumen de bolsa**\n"
    for cot in cotizaciones:
        resumen += f"{cot['simbolo']}: ${cot['precio']:.2f} ({cot['porcentaje']:.2f}%)\n"

    if alertas:
        resumen += "\n🚨 **Alertas:**\n" + "\n".join(alertas)

    return resumen

if __name__ == "__main__":
    print(main())

Paso 2: Configurar la API de Alpha Vantage

1. Regístrate en Alpha Vantage para obtener una clave API gratuita.
2. Reemplaza TU_API_KEY_ALPHA_VANTAGE en el script con tu clave.

Paso 3: Probar el script manualmente

Ejecuta el script para verificar que funciona:

python3 ~/hermes_bolsa/seguimiento_bolsa.py

Deberías ver un resumen con las cotizaciones y alertas (si las hay).

Paso 4: Crear una habilidad en Hermes

Crea un directorio para la habilidad:

mkdir -p ~/.hermes/skills/seguimiento_bolsa

Dentro de él, crea un archivo SKILL.md con el siguiente contenido:

---
name: seguimiento_bolsa
description: Monitorea cotizaciones de bolsa y genera alertas si hay cambios significativos.
trigger: ["bolsa", "cotizaciones", "acciones", "mercado"]
version: 1.0
---

# Habilidad: Seguimiento de bolsa

**Instrucciones:**
1. Ejecuta el script `~/hermes_bolsa/seguimiento_bolsa.py` usando la herramienta `code_execution`.
2. Analiza el resultado y genera un resumen claro.
3. Si hay alertas, destácalas en el mensaje final.
4. Guarda el resumen en un archivo `~/hermes_bolsa/resumen_diario_{fecha}.md`.

**Ejemplo de uso:**
- "Dame el estado actual del mercado."
- "¿Hay alertas en las acciones que sigo?"
- "Genera el resumen diario de bolsa."

Paso 5: Automatizar la ejecución

Configura una tarea programada para que el agente ejecute el seguimiento cada hora:

1. 1. Abre el archivo de configuración de Hermes:

nano ~/.hermes/config.yaml

1. 1. Agrega la siguiente configuración bajo cron::

cron:
  - name: "Seguimiento de bolsa"
    command: "python3 ~/hermes_bolsa/seguimiento_bolsa.py"
    schedule: "0 * * * *"  # Cada hora
    output_file: "~/hermes_bolsa/resumen_horario_{fecha}.md"

1. 1. Reinicia Hermes para aplicar los cambios:

hermes restart

Paso 6: Conectar a Telegram (opcional)

Para recibir alertas en Telegram:

1. 1. Crea un bot en Telegram con @BotFather y obtén tu TELEGRAM_BOT_TOKEN.
   2. Agrega el token a ~/.hermes/.env:

TELEGRAM_BOT_TOKEN=tu_token_aquí

1. 1. Configura el gateway de Telegram:

hermes gateway setup telegram

1. 1. Modifica el script seguimiento_bolsa.py para enviar alertas a Telegram:

def enviar_a_telegram(mensaje):
    import requests
    bot_token = os.getenv("TELEGRAM_BOT_TOKEN")
    chat_id = "TU_CHAT_ID"  # Reemplaza con tu ID de chat
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage?chat_id={chat_id}&text={mensaje}"
    requests.get(url)

# Al final de main(), agrega:
if alertas:
    for alerta in alertas:
        enviar_a_telegram(alerta)

Paso 7: Probar el agente

Inicia Hermes y prueba la habilidad:

hermes --tui

Dentro del chat, escribe:

Dame el estado actual del mercado.

El agente debería ejecutar el script y mostrarte el resumen con las cotizaciones y alertas.

Ejemplo completo: Importador de noticias RSS

En este ejemplo, crearemos un agente que:

1. Lee noticias desde fuentes RSS (ej.: El País, BBC, Reuters).
2. Filtra las noticias por palabras clave (ej.: “tecnología”, “IA”).
3. Guarda los titulares en un archivo Markdown.
4. Envía un resumen diario por correo o Telegram.

Paso 1: Crear el script de importación

Crea un archivo ~/hermes_rss/importar_noticias.py con el siguiente contenido:

import feedparser
import os
from datetime import datetime

# Fuentes RSS
FUENTES = {
    "El País Tecnología": "https://feeds.elpais.com/mrss-s/pages/ep/site/elpais.com/tecnologia",
    "BBC Technology": "http://feeds.bbci.co.uk/news/technology/rss.xml",
    "Reuters Tech": "http://feeds.reuters.com/reuters/technologyNews"
}

# Palabras clave para filtrar
PALABRAS_CLAVE = ["IA", "inteligencia artificial", "tecnología", "innovación", "Hermes"]

def leer_rss(url):
    """Lee un feed RSS y devuelve los artículos."""
    feed = feedparser.parse(url)
    return feed.entries

def filtrar_noticias(articulos):
    """Filtra artículos por palabras clave."""
    noticias_filtradas = []
    for articulo in articulos:
        titulo = articulo.get("title", "").lower()
        if any(palabra.lower() in titulo for palabra in PALABRAS_CLAVE):
            noticias_filtradas.append({
                "titulo": articulo.title,
                "enlace": articulo.link,
                "fecha": articulo.get("published", "Sin fecha"),
                "fuente": articulo.feed.title if hasattr(articulo, "feed") else "Desconocida"
            })
    return noticias_filtradas

def guardar_noticias(noticias):
    """Guarda las noticias en un archivo Markdown."""
    fecha = datetime.now().strftime("%Y-%m-%d")
    archivo = f"~/hermes_rss/noticias_{fecha}.md"
    with open(archivo, "w", encoding="utf-8") as f:
        f.write(f"# Noticias de tecnología - {fecha}\n\n")
        for noticia in noticias:
            f.write(f"## {noticia['titulo']}\n")
            f.write(f"- **Fuente:** {noticia['fuente']}\n")
            f.write(f"- **Fecha:** {noticia['fecha']}\n")
            f.write(f"- **Enlace:** {noticia['enlace']}\n\n")
    return archivo

def main():
    todas_las_noticias = []
    for nombre, url in FUENTES.items():
        articulos = leer_rss(url)
        noticias_filtradas = filtrar_noticias(articulos)
        todas_las_noticias.extend(noticias_filtradas)

    if todas_las_noticias:
        archivo = guardar_noticias(todas_las_noticias)
        resumen = f"📰 **Se importaron {len(todas_las_noticias)} noticias**\n"
        resumen += f"Archivo guardado en: {archivo}\n\n"
        resumen += "**Títulos:**\n"
        for noticia in todas_las_noticias:
            resumen += f"- {noticia['titulo']}\n"
        return resumen
    else:
        return "No se encontraron noticias relevantes hoy."

if __name__ == "__main__":
    print(main())

Paso 2: Instalar dependencias

Instala la librería feedparser para leer feeds RSS:

pip install feedparser

Paso 3: Probar el script manualmente

Ejecuta el script para verificar que funciona:

python3 ~/hermes_rss/importar_noticias.py

Deberías ver un resumen con las noticias filtradas y el archivo Markdown generado.

Paso 4: Crear una habilidad en Hermes

Crea un directorio para la habilidad:

mkdir -p ~/.hermes/skills/importar_noticias

Dentro de él, crea un archivo SKILL.md con el siguiente contenido:

---
name: importar_noticias
description: Importa noticias desde fuentes RSS y las filtra por palabras clave.
trigger: ["noticias", "RSS", "titulares", "actualidad"]
version: 1.0
---

# Habilidad: Importador de noticias RSS

**Instrucciones:**
1. Ejecuta el script `~/hermes_rss/importar_noticias.py` usando la herramienta `code_execution`.
2. Analiza el resultado y genera un resumen con los títulos más relevantes.
3. Guarda el resumen en un archivo `~/hermes_rss/resumen_noticias_{fecha}.md`.
4. Si no hay noticias, notifica que no se encontraron resultados.

**Ejemplo de uso:**
- "Importa las noticias de tecnología de hoy."
- "¿Qué titulares nuevos hay sobre IA?"
- "Genera un resumen de las noticias filtradas."

Paso 5: Automatizar la ejecución

Configura una tarea programada para que el agente importe noticias cada 6 horas:

1. 1. Abre el archivo de configuración de Hermes:

nano ~/.hermes/config.yaml

1. 1. Agrega la siguiente configuración bajo cron::

cron:
  - name: "Importar noticias RSS"
    command: "python3 ~/hermes_rss/importar_noticias.py"
    schedule: "0 */6 * * *"  # Cada 6 horas
    output_file: "~/hermes_rss/resumen_noticias_{fecha}.md"

1. 1. Reinicia Hermes para aplicar los cambios:

hermes restart

Paso 6: Probar el agente

Inicia Hermes y prueba la habilidad:

hermes --tui

Dentro del chat, escribe:

Importa las noticias de tecnología de hoy.

El agente debería ejecutar el script y mostrarte el resumen con las noticias filtradas.

Canales de mensajería (opcional)

Para interactuar con tus agentes desde Telegram o Discord:

1. Crear un bot en Telegram:
   • Abre Telegram y escribe a @BotFather.
   • Envía /newbot y sigue las instrucciones.
   • Copia el token del bot (ej.: 123456789:ABCdefGHIjklMNOpqrsTUVwxyZ).
2. Configurar el token en Hermes:Edita ~/.hermes/.env y agrega:

   TELEGRAM_BOT_TOKEN=tu_token_aquí

3. Habilitar el gateway:hermes gateway setup telegram
4. Probar el bot:Envía un mensaje a tu bot en Telegram con:

   Dame el resumen de bolsa o Importa las noticias de hoy.

Nota: Para Discord, sigue un proceso similar con el token de tu bot en Discord Developer Portal.

Seguridad y buenas prácticas

Al crear agentes automatizados, sigue estas recomendaciones:

• Alcance limitado: cada agente debe tener una función clara y específica.
• Herramientas mínimas: activa solo las herramientas necesarias para la tarea.
• Revisión humana: verifica las salidas importantes antes de publicarlas o ejecutarlas.
• Permisos prudentes: evita acciones destructivas (ej.: eliminar archivos) sin supervisión.
• Pruebas manuales: valida el comportamiento del agente antes de automatizarlo.
• Límites de iteración: usa hermes config set agent.max_iterations 20 para evitar bucles infinitos.

Comandos útiles

Comandos básicos para gestionar Hermes:

• hermes: Inicia el agente en modo CLI.
• hermes --tui: Inicia el agente con interfaz de texto mejorada.
• hermes version: Muestra la versión instalada.
• hermes doctor: Diagnostica problemas de instalación.
• hermes status: Muestra el estado actual (modelo, herramientas, etc.).
• hermes model: Configura o lista los modelos disponibles.
• hermes tools: Lista las herramientas activas.
• hermes skills list: Muestra las habilidades disponibles.
• hermes gateway setup: Configura canales de mensajería.
• hermes restart: Reinicia el agente.

Ejemplo de uso avanzado: Combinar ambos agentes

Puedes crear un agente maestro que coordine el seguimiento de bolsa y la importación de noticias. Por ejemplo:

1. 1. Crea un script ~/hermes_maestro/agente_maestro.py que:
      • Ejecuta seguimiento_bolsa.py.
      • Ejecuta importar_noticias.py.
      • Genera un resumen combinado.
   2. Configura una habilidad en Hermes para ejecutar este script:

---
name: resumen_diario
description: Genera un resumen diario con bolsa y noticias.
trigger: ["resumen diario", "informes"]
version: 1.0
---

# Habilidad: Resumen diario

**Instrucciones:**
1. Ejecuta el script `~/hermes_maestro/agente_maestro.py` usando `code_execution`.
2. Analiza los resultados y genera un resumen combinado.
3. Guarda el resumen en `~/hermes_maestro/resumen_diario_{fecha}.md`.
4. Envía el resumen por Telegram si hay alertas o noticias importantes.

1. 1. Programa la ejecución diaria:

cron:
  - name: "Resumen diario"
    command: "python3 ~/hermes_maestro/agente_maestro.py"
    schedule: "0 8 * * *"  # Todos los días a las 8 AM

Hermes es una herramienta poderosa para automatizar tareas repetitivas que requieren contexto, memoria y acción. Con los ejemplos de esta guía, ya tienes dos agentes funcionales:

• Seguimiento de bolsa: monitorea cotizaciones y genera alertas.
• Importador de noticias: recopila y filtra titulares desde fuentes RSS.

Estos agentes pueden ejecutarse localmente en tu máquina, sin depender de servicios en la nube (excepto para las APIs externas como Alpha Vantage o los feeds RSS). Además, puedes conectarlos a Telegram o Discord para recibir actualizaciones en tiempo real.

El siguiente paso es personalizarlos: ajusta las acciones, fuentes o criterios de filtrado según tus necesidades. También puedes explorar otras herramientas de Hermes, como el acceso a bases de datos o la integración con APIs personalizadas.