Atareao con Linux

¿Cansado de perder 15 minutos cada mañana revisando el tiempo, las noticias, las ofertas y el estado de tu servidor? En este episodio te muestro cómo automatizar todo ese proceso con un script en Python, un timer de systemd y un modelo de lenguaje local. Sin n8n, sin agentes, sin servicios externos de pago.
Mucha gente piensa que para automatizar cualquier cosa necesitas un agente con montones de herramientas MCP, skills y configuración. Pero la realidad es que para muchas tareas cotidianas, un agente es como usar un lanzamisiles para matar una mosca. Consume demasiado contexto, demasiados recursos y al final no es la solución más eficiente.
En este episodio te presento el patrón de las tres capas: un script que hace el trabajo, un timer que lo ejecuta a una hora determinada y un sistema de notificaciones que te envía el resultado. Con esto puedes automatizar cualquier cosa de forma sencilla, eficiente y completamente bajo tu control.
Te explico cómo he creado el nightly-runner, un script en Python que cada madrugada recopila información de cuatro fuentes distintas. Primero consulta el tiempo en wttr.in, que te devuelve un JSON con la temperatura, el viento, la humedad y los rayos ultravioleta. Luego hace scraping con IA de tus fuentes de noticias favoritas, extrayendo titulares y valorando su relevancia. Después busca ofertas de zapatillas de running en varias tiendas, comparando los precios con los del día anterior. Y por último recoge información del sistema con df, free, uptime y ps aux para saber si tu disco se está llenando o te estás quedando sin RAM.
Toda esa información se guarda en archivos JSON y luego se pasa por un modelo de lenguaje local, Llama 3.2 con Ollama, que genera un resumen en lenguaje natural. El resultado es un mensaje de Telegram con un tono cercano que te da los buenos días, te cuenta el tiempo que va a hacer, te destaca las noticias importantes, te avisa si hay una oferta que no puedes dejar pasar y te informa del estado de tu servidor. Todo en un solo mensaje.
El timer de systemd con Persistent=true se asegura de que si tu equipo estaba apagado a las 4 de la mañana, el script se ejecute en cuanto se encienda. Y cada capa es tolerante a fallos: si wttr.in está caído, el script simplemente omite el tiempo y el resumen dice que no hay información meteorológica disponible. Si no hay ofertas nuevas, no las menciona. Si Ollama no responde, envía el resumen sin procesar.
Lo mejor de todo es que no necesitas saber Python para montar esto. Puedes usar Open Code o Gemini para que te genere el script con solo explicarle lo que quieres. Y para ejecutarlo, Llama 3.2 en local es más que suficiente. Sin gastar un euro en APIs.
Capítulos:
0:00 - Crítica a los agentes como solución universal
2:00 - El problema: 15 minutos perdidos cada mañana
4:00 - La solución: tres capas (script, timer, notificación)
5:30 - wttr.in: el tiempo en JSON con un curl
7:30 - Noticias: scraping con IA para extraer titulares
9:30 - Zapatillas: comparativa de precios contra caché
11:00 - Sistema: df, free, uptime y ps aux
13:00 - El resumen: todos los JSONs pasan por Llama 3.2
16:00 - Systemd timer con Persistent=true
18:00 - Notificaciones a Telegram y notify-send
20:00 - Tolerancia a fallos en cada capa
21:30 - Genera el script con IA aunque no sepas Python
23:00 - Comparación con Hermes: menos es más
Este podcast pertenece a la red de Sospechosos Habituales. Más información en atareao.es

Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

En este episodio te enseño a combinar ImageMagick, Tesseract y Llama 3.2 para crear un pipeline de OCR inteligente en Linux. Olvídate de reescribir capturas de pantalla a mano.
¿Cuántas veces te ha pasado que alguien te envía una captura de pantalla con información que necesitas y tienes que copiarla a mano? O peor aún, tienes un PDF escaneado del que no puedes seleccionar texto. Hasta ahora la solución era pasar horas transcribiendo o conformarte con un OCR básico que devuelve texto lleno de errores. En este episodio te muestro cómo construir un pipeline completo que automatiza todo el proceso.
Primero capturas la imagen o la recibes, luego la preprocesas con ImageMagick para mejorar el contraste y eliminar ruido, después aplicas Tesseract para el OCR y por último pasas el resultado por un modelo de lenguaje local, Llama 3.2, que corrige los errores y da formato al texto. Todo con herramientas de código abierto, sin enviar tus datos a servidores externos.
El script ocr_ai.py que he creado es capaz de detectar automáticamente el tipo de contenido que estás procesando. Si es código fuente, aplica un pipeline de preprocesamiento más agresivo con threshold y sharpen intensivos, y un prompt de IA específico para restaurar la indentación y la sintaxis sin cambiar nombres de variables. Si es una tabla, preserva la estructura de filas y columnas, corrigiendo números mal reconocidos pero sin rellenar celdas vacías. Si es prosa, simplemente corrige acentos, puntuación y caracteres mal interpretados sin alterar el significado del texto.
También te explico cómo monitorizar un directorio con inotifywait para que cualquier imagen que caiga en él se procese automáticamente, ideal para combinarlo con carpetas compartidas de Nextcloud o Syncthing y tener OCR automático desde el móvil. Y cómo combinar todo con wl-copy en Wayland o xclip en X11 para tener el texto directamente en el portapapeles con un solo atajo de teclado.
Cubrimos Tesseract 5 y su motor LSTM, los modos de segmentación de página (PSM 3, 6, 7 y 11), los diccionarios personalizados con --user-words para dominios específicos, las operaciones de ImageMagick v7 como colorspace gray, normalize, threshold, deskew, sharpen, negate y morphology, y cómo ajustar cada parámetro según el tipo de imagen. Además hablamos de OCRmyPDF para añadir capa de texto a PDFs escaneados y convertir cualquier PDF en un documento seleccionable y buscable.
El episodio incluye consejos prácticos para troubleshooting: cómo ajustar el threshold cuando el texto es borroso (valores entre 40% y 65%), cómo reducir el ruido con filtros de morfología, cómo redimensionar imágenes con texto muy pequeño usando -resize 200%, cómo manejar fotos de documentos con -median 3, y cómo crear diccionarios personalizados con --user-words para mejorar el reconocimiento en dominios específicos como facturas, logs o código fuente.
Capítulos:
0:00 - El problema de las capturas de pantalla
2:00 - Motivación: running, Hermes y el pipeline completo
4:00 - Captura y preprocesamiento con ImageMagick
6:30 - Operaciones clave: normalize, threshold, deskew y sharpen
8:30 - Pipelines personalizados según el tipo de imagen
10:30 - Tesseract: instalación, modos y diccionarios
14:00 - ocr_ai.py: detección automática del contenido
18:00 - Corrección con Llama 3.2 y prompts específicos
23:00 - Monitorización de directorios y automatización
24:30 - Consejos prácticos y cierre
Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

En este episodio de Atareao con Linux nos vamos a remangar para hablar de una de esas tecnologías que, una vez las dominas, te cambian la vida por completo: el Web Scraping asistido por Inteligencia Artificial.
Seguro que te ha pasado alguna vez. Quieres comprar un producto concreto, como unas zapatillas de running (yo las cambio cada 800 kilómetros y es un goteo constante), o quieres extraer todas las recetas de cocina de una web para montarte tu propio planificador semanal. Lo ideal sería que estas páginas tuvieran una API pública para descargar la información de forma limpia. Pero la cruda realidad es que casi ninguna te lo pone fácil. Ahí es donde entra el scraping: la técnica de extraer la información directamente de la página web.
En este episodio te cuento por qué el scraping clásico (ese que utiliza Beautiful Soup en Python y depende de identificar las etiquetas HTML y las clases CSS) tiene los días contados para tareas complejas. Basta con que un desarrollador cambie el diseño de la web para que tu script se rompa por completo. Además, con la llegada de las webs dinámicas, los tests A/B y los sistemas anti-bloqueo como Cloudflare, mantener un scraper tradicional es un auténtico dolor de muelas.
La gran alternativa: Inteligencia Artificial en local
¿Y si en lugar de pelearnos con el código fuente dejamos que un modelo de lenguaje (LLM) entienda la página exactamente igual que lo haría un humano? Un LLM comprende perfectamente qué es un "precio" o el "nombre de un producto", sin importar cómo esté maquetada la web ni el idioma en el que esté escrita. Y lo mejor de todo: ¡lo podemos hacer 100% gratis en local usando Ollama!
Te detallo mis pruebas ejecutando modelos en mi Slimbook One utilizando únicamente la CPU (¡sin gastar un céntimo en nubes ni necesitar tarjetas gráficas carísimas!). Hablaremos de cómo rinden modelos como Llama 3.2, Qwen, Mistral y DeepSeek R1, y cuál es el punto de equilibrio perfecto para no eternizarnos esperando la respuesta.
También te desvelo mi fórmula secreta para procesar la información. No podemos enviarle 2 Megabytes de HTML ruidoso a la IA. Te explico los 5 pasos que utilizo en Python para eliminar la basura (scripts, estilos, navegación) y reducir el HTML hasta en un 93%, permitiendo que el modelo extraiga los datos en segundos y nos devuelva un JSON estructurado impecable.
Por último, vemos cómo montar un auténtico vigilante de ofertas automatizado en segundo plano. Un sistema que compare los precios de varias tiendas en paralelo.
Capítulos del episodio:
00:00:00 Introducción al Web Scraping con Inteligencia Artificial
00:01:22 ¿Para qué sirve extraer datos? Ejemplos prácticos
00:02:42 El gran talón de Aquiles del scraping tradicional
00:04:31 La revolución de la IA: Entender la web sin saber HTML
00:07:36 Los problemas habituales: Selectores rotos y webs dinámicas
00:10:00 Cómo un modelo de lenguaje (LLM) procesa la información
00:13:17 Cuándo elegir scraping clásico vs. scraping con IA
00:15:28 Comparación de costes: Enfoque clásico, IA local e IA en la nube
00:17:19 ¿Qué modelos usar? Pruebas con Llama, Qwen, Mistral y DeepSeek
00:18:19 Detrás de escena: Mi script de Python y la limpieza del HTML
00:21:05 Creando el prompt perfecto para extraer un JSON estructurado
00:24:34 Ejemplo real: Comparativa paralela entre tiendas
00:28:38 Diseñando un vigilante de ofertas automatizado (24/7)
00:30:17 Casos de uso prácticos y mejoras para evitar bloqueos
00:32:02 Cierre y detalles del próximo tutorial de scraping
Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

Si alguna vez habías pensado que en el mundo de los emuladores de terminal ya estaba todo inventado y que no había margen para la sorpresa, déjame decirte que estás muy equivocado. Yo también lo pensaba, de verdad. Pero la innovación no descansa y en este episodio te voy a presentar una propuesta que cambia por completo las reglas del juego.
En mi búsqueda constante de la herramienta ideal para mi día a día, he pasado por Alacritty, por WezTerm, por mi queridísima Kitty y, recientemente, estuve dándole una oportunidad de oro a Ghostty. Sin embargo, me topé con un pequeño pero molesto inconveniente con la escritura de acentos que me obligó a volver a los brazos de Kitty. Pero como soy incapaz de resistirme a probar cualquier terminal nueva que caiga en mis manos, hoy quiero hablarte a fondo de Wave. ¿Es una terminal? ¿Es un navegador? ¿Es un entorno de desarrollo? Te lo adelanto ya: es todo eso a la vez y estructurado de una manera que te va a volar la cabeza.
Un nuevo paradigma: El espacio de trabajo por bloques
Wave no es una terminal corriente como las que estás acostumbrado a usar.
En el episodio de hoy te detallo cuáles son los cinco bloques fundamentales que incluye de serie y cómo cambian por completo la forma en que nos enfrentamos a la línea de comandos:
Bloques de Terminal
Bloques de Visor de Archivos
Bloques Web
Bloques de Editor
Bloques de Inteligencia Artificial

La magia de los Layouts y los espacios de trabajo
Otro de los grandes aciertos de Wave es la posibilidad de guardar y gestionar tus disposiciones de pantalla o "Layouts".
SSH Durable: Conexiones indestructibles para administradores
Si trabajas habitualmente con servidores remotos, este superpoder te va a encantar. Las conexiones SSH convencionales son muy sensibles: si cambias de la red Wi-Fi de tu casa a los datos móviles, si se produce un microcorte o si simplemente cierras la tapa de tu portátil para cambiar de sitio, la conexión muere y pierdes todo lo que estabas haciendo.
Inteligencia Artificial local para máxima privacidad
La IA también está integrada de forma nativa en este entorno. Lo realmente interesante es que Wave te permite configurar tanto servicios en la nube (OpenAI, Anthropic) como modelos de lenguaje locales (por ejemplo, usando Llama).
¿Y por qué me sigo quedando con Kitty?
Al final del episodio abordo este dilema. Aunque Wave me parece una de las propuestas más originales, potentes y visuales de los últimos años, sigo prefiriendo la ligereza de Kitty combinada con gestores de terminal rápidos como Yazi.
Capítulos del episodio:
00:00:00 El dilema de las terminales: de Kitty a Ghostty y Wave
00:02:11 ¿Qué es Wave? ¿Hacía falta otra terminal Open Source?00:03:41 El concepto revolucionario de los bloques
00:06:07 Los 5 tipos de bloques: terminal, visor, web, editor e IA
00:08:43 Cómo moverte entre bloques como un profesional
00:09:43 Creando tus propios espacios de trabajo (Layouts)
00:13:20 Renderizado gráfico y el explorador de archivos integrado
00:16:30 Inteligencia Artificial nativa y modelos locales
00:18:00 Extendiendo la terminal con TypeScript y React
00:20:47 SSH durable: conexiones indestructibles que sobreviven a todo
00:22:13 Gestor de conexiones y contraseñas seguro
00:23:11 Trucos rápidos y por qué me sigo quedando con Kitty
00:25:24 Despedida y dónde encontrarnos para seguir cacharreando

Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao

Si has estado siguiendo mis últimos episodios, sabrás que ando entusiasmado con Hermes, este increíble agente autónomo de Inteligencia Artificial que se ha convertido en mi mano derecha para automatizar todo tipo de tareas en mi servidor. Sin embargo, me he dado cuenta de que he pasado muy de puntillas sobre una de sus características más potentes y que de verdad marca la diferencia cuando queremos exprimir al máximo sus capacidades: los subagentes.
🧠 El gran problema del contexto: Por qué tu IA se vuelve lenta y cara
Para entender la magia de los subagentes, primero tenemos que hablar del principal cuello de botella de los modelos de lenguaje: la ventana de contexto. I
Si estás utilizando un modelo comercial muy potente con una ventana de contexto enorme, puede parecer que no hay problema. El problema es que en cuanto te descuidas, esa conversación ya ha consumido 20.000 o 30.000 tokens. Esto tiene tres consecuencias directas que te van a doler:
Menor rendimiento
Costes disparados
Asfixia en local
🕵️ ¿Qué es un subagente y por qué es el ayudante ideal?
Un subagente es, en esencia, un hilo de ejecución completamente nuevo y aislado que hereda una tarea hiperespecífica de su "padre" (el agente con el que estás chateando directamente). Piensa en él como en un ayudante temporal al que le asignas una misión muy concreta y que cuenta con una serie de ventajas diseñadas para la eficiencia:
Aislamiento total
Terminal independiente
Herramientas restringidas (Toolsets)
Modelos flexibles
Cuando el subagente termina su labor, redacta un resumen escueto con el resultado final y se lo entrega al padre.
📏 La regla de oro: ¿Cuándo delegar y cuándo ejecutar directamente?
⏱️ Estructura temporal del episodio
Si quieres saltar directamente a una sección concreta del programa, aquí tienes la guía de capítulos completa de este episodio:
00:00:00 Introducción a los subagentes de Hermes
00:01:10 ¿Qué es un subagente y por qué lo necesitas?
00:03:21 El problema del contexto y cómo solucionarlo
00:05:15 Los tres pilares: Objetivo, Contexto y Herramientas
00:06:19 La regla de oro: ¿Delegar o ejecutar código directamente?
00:08:19 Cómo definir tareas de forma específica y segura
00:11:12 Qué pasa dentro de un subagente (Aislamiento y límites)
00:12:05 Ejemplos prácticos: Búsquedas de ofertas y análisis de sistema en paralelo
00:16:30 Límites de configuración: Concurrencia y profundidad de agentes
00:19:40 El futuro de Hermes: Delegación síncrona vs. asíncrona
00:21:54 Casos de uso reales y errores comunes que debes evitar
00:24:02 Conclusiones y un adelanto sobre RAG y Ollama
00:25:58 Despedida y canales de la comunidad
🚀 Dos experimentos prácticos que vas a escuchar hoy
En este episodio te detallo dos pruebas reales que he estado haciendo en mi laboratorio para que veas el potencial de trabajar de forma paralela:
Por un lado, la búsqueda de ofertas multitarea.
Por otro lado, la auditoría de recursos concurrentes.

Más información y enlaces en las notas del episodio
🌐 Aquí lo puedes encontrar todo 👉 https://atareao.es
✈️ Telegram (el grupo) 👉 https://t.me/atareao_con_linux
✈️ Telegram (el canal) 👉 https://t.me/canal_atareao
🦣 Mastodon 👉 https://mastodon.social/@atareao
🐦 Twitter 👉 https://twitter.com/atareao
🐙 GitHub 👉 https://github.com/atareao