Atareao con Linux

Este episodio va de ser vago. Pero vago en el buen sentido, eh. De esos que prefieren que una herramienta haga el trabajo pesado mientras tú te quedas con lo divertido. Resulta que hay todo un ecosistema de herramientas TUI con el prefijo "lazy" que te evitan tener que memorizar cientos de flags y opciones de comandos como git, docker, rsync o SQL. Y no, no es cutrez: son interfaces de terminal que funcionan a golpe de tecla, sin ratón, sin salir de la terminal, y encima molan.

Te cuento cómo nació todo esto, quién es Jesse Duffield (el creador de lazygit y lazydocker, con más de 80K y 52K estrellas en GitHub respectivamente) y por qué esta filosofía de "una tecla, una acción" ha enganchado a tanto linuxero. Y lo mejor: te hago demo de las cuatro herramientas principales para que veas cómo funcionan en vivo y en directo, con sus paneles, sus atajos y sus trucos.

Empezamos con lazygit, el rey indiscutible del ecosistema. 80.900 estrellas en GitHub, escrito en Go, y con una comunidad que no para de crecer. Desde stage línea a línea hasta rebase interactivo, pasando por undo/redo vía reflog. Te enseño cómo hacer commits, gestionar ramas, stash y hasta cherry-pick sin tener que acordarte de los flags raros de git.

Seguimos con lazysql, el gestor de bases de datos en terminal de Jorge Rojas. Soporta MySQL, PostgreSQL, SQLite, MongoDB, MSSQL y Oracle. Navegación por teclado, autocompletado de queries, exportación a CSV y configuración por proyecto. Ideal para cuando no te apetece abrir DataGrip o DBeaver solo para hacer una consulta rápida.

Luego viene lazyrsync, escrito en Rust con ratatui, y con una filosofía muy clara: que no se te olvide el flag ese que evita que borres todo. Perfiles reutilizables, dry-run con previsualización, protección contra --delete accidentales y paths dinámicos con variables. Perfecto para backups sin sustos.

Y cerramos con lazydocker, también de Jesse Duffield. Cuatro paneles: contenedores, métricas, imágenes y logs en vivo. Con un vistazo ves qué contenedor consume más CPU, entras en el terminal de uno con una tecla, o ejecutas docker-compose sin acordarte del comando. Y sí, también funciona con Podman.

Además te menciono otras herramientas del ecosistema: lazyssh, lazyjj para Jujutsu, lazykube, lazyprune para limpiar node_modules olvidados... Vamos, que hay lazy para todo.

Capítulos del episodio:

0:00 — Introducción: el problema de memorizar comandos

2:05 — La filosofía lazy: scripts, TUIs y el ecosistema lazy

4:30 — LazyGit: historia, filosofía "una tecla una acción" y +80K estrellas

6:45 — LazyGit: demo de paneles, stage, commits, ramas y stash

9:10 — LazySQL: Jorge Rojas, 4K estrellas y soporte multi-base de datos11:30 — LazySQL: demo con autocompletado, consultas y exportación CSV

14:00 — LazyRsync: dry-run, perfiles y protección contra errores

16:30 — LazyRsync: demo con columnas de estado y confirmación de borrado

19:10 — LazyDocker: Jesse Duffield, 52K estrellas y soporte para Podman

21:45 — Otras herramientas lazy: lazy-ssh, lazy-jj, lazy-kube, lazy-npm

23:15 — Cierre: sé un vago inteligente, valoración y despedida

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

Llevo 15 años escribiendo notas, artículos y tutoriales. El resultado: unos 5000 archivos markdown repartidos por mi disco duro. Y, como te puedes imaginar, encontrar algo ahí dentro es como buscar una aguja en un pajar. Por eso en este episodio me he puesto manos a la obra para montar un sistema RAG (Retrieval-Augmented Generation) 100% local, sin depender de APIs externas, sin enviar tus datos a la nube, y con herramientas que ya conoces: SQLite, Ollama y Python.

Este es el primero de dos episodios sobre RAG. Aquí nos centramos en construir la base de conocimiento: un pipeline que escanea tus documentos, los trocea en fragmentos manejables, extrae los metadatos del frontmatter YAML, genera embeddings con el modelo bge-m3 de Ollama, y lo guarda todo en una base de datos SQLite con búsqueda FTS5. Todo esto, además, con detección incremental de cambios: la primera ejecución tarda lo que tenga que tardar, pero las siguientes son cuestión de segundos porque solo reprocesa lo que ha cambiado.

El stack es sencillo pero potente. SQLite con FTS5 para búsqueda textual, Ollama con bge-m3 para los embeddings, y seis scripts Python que suman unas 1300 líneas. Nada de LangChain, nada de frameworks pesados. Código limpio, comentado y que entiendes de un vistazo. El chunking respeta las cabeceras markdown, usa tiktoken para contar tokens con precisión, y los embeddings se almacenan como BLOBs en la propia SQLite. En el próximo episodio (el 821) usaremos esta base de conocimiento para hacer búsqueda semántica con similitud de coseno, búsqueda híbrida combinando FTS5 con embeddings, y hasta un plugin para Neovim.

Puntos clave del episodio:
- El problema: 15 años de notas, 5000 archivos, cero capacidad de búsqueda
- La solución: RAG local con SQLite + FTS5 + Ollama, todo en tu máquina
- Chunking híbrido que respeta cabeceras markdown y usa tiktoken
- Pipeline incremental con detección de cambios mediante MD5
- Embeddings con bge-m3 (568M parámetros, 1024 dimensiones)
- Búsqueda FTS5 con snippet(), colores ANSI y sintaxis avanzada
- Errores comunes y cómo solucionarlos

Si te gusta el contenido, ya sabes: dale a seguir, compártelo con quien creas que le puede interesar, y déjame un comentario si tienes dudas o sugerencias. La semana que viene, en el episodio 821, montamos la búsqueda semántica y el plugin para Neovim. No te lo pierdas.

Capítulos del episodio:
0:00 - Introducción: RAG y base de conocimiento local
2:12 - El problema: 15 años de notas sin buscar
4:58 - La solución: SQLite + FTS5 + Ollama, 100% local
7:00 - Escaneo de archivos y extracción de front matter
10:20 - Preparación del entorno: Ollama, uv y dependencias
12:00 - Chunking: cómo trocear los documentos
15:45 - Estructura de la base de datos SQLite
17:46 - Pipeline incremental con detección de cambios
19:22 - Demo en vivo: consultas y resultados
22:44 - Errores comunes y cómo solucionarlos
24:10 - Resumen y adelanto del episodio 821
25:15 - Despedida 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

¿Tienes 5, 10 o 20 servidores SSH y no sabes cómo gestionarlos sin tener mil terminales abiertas? En este episodio te hablo de SSHub, una TUI open source escrita en Rust que unifica hosts, sesiones, túneles, SFTP y auditoría en una sola interfaz. Todo desde la terminal, sin salir de ella y sin necesidad de instalar nada más que un único binario compilado con cargo install de Rust.

Te cuento cómo pasé de un script en Bash que usaba desde 2019 para conectarme a mis servidores, a esta herramienta moderna que lee tu ~/.ssh/config y lo combina con una base de datos SQLite propia. Sin migraciones, sin complicaciones, sin tener que cambiar nada de lo que ya tienes configurado. Además la comparo con Termius y MobaXterm, que son de pago y cerradas, frente a SSHub que es gratis, multiplataforma y con licencia AGPL-3.0.

Voy paso a paso: instalación con cargo install sshub, navegación con atajos estilo Vim (teclas j/k), el cliente SFTP de doble panel con cola de transferencia y barra de progreso, la gestión de túneles con reconexión automática y backoff exponencial, el registro de auditoría que te salva de conectar al servidor equivocado, y hasta el modo broadcast para ejecutar comandos en varios servidores a la vez. También te explico cómo importar hosts desde Termius, PuTTY o mRemoteNG de forma sencilla.

Lo mejor de todo es que SSHub respeta tu configuración SSH existente. No la sustituye, la complementa. Detecta cambios al vuelo con un file watcher, así que cualquier modificación que hagas en tu config aparece al instante en la interfaz. Y si eres de los que prefiere la línea de comandos, tiene modo headless: sshub list, sshub connect, sshub sftp get/put... todo sin abrir la interfaz.

Si gestionas más de 10 servidores, usas túneles habitualmente o vienes de Termius buscando una alternativa open source, este episodio te va a interesar. Y si además te gusta hacer las cosas desde la terminal sin depender de aplicaciones gráficas, SSHub te va a encantar. Dale una oportunidad, que es gratis y no tienes nada que perder. Te espero dentro.

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

¿Sabías que puedes convertir cualquier texto en coordenadas de 1024 dimensiones y hacer búsquedas inteligentes, clasificación automática o detección de duplicados sin depender de servicios en la nube? En este episodio te enseño a utilizar los embeddings con Ollama para potenciar tus documentos, correos y apuntes desde tu propio equipo Linux.

Los embeddings son una de las tecnologías más fascinantes de la inteligencia artificial actual. Básicamente, convierten palabras, frases o párrafos enteros en vectores numéricos que capturan su significado. Esto permite que un ordenador entienda que "gato" está más cerca de "felino" que de "nevera", y mucho más: desde búsqueda semántica hasta clasificación sin entrenamiento, pasando por deduplicación de documentos y sistemas de recomendación.

Lo mejor de todo es que no necesitas una GPU potente ni una cuenta en ningún servicio externo. Con Ollama ejecutándose en local y el modelo BGE-M3 (multilenguaje, con soporte para español), puedes generar embeddings desde la terminal con una simple llamada curl o con unas pocas líneas de Python. Y si necesitas escalar, ChromaDB te ofrece una base de datos vectorial completa con persistencia en disco y filtros por metadatos.

Capítulos del episodio:
0:00 - Introducción y concepto de embeddings
2:42 - ¿Qué son los embeddings exactamente?
5:13 - Modelos de embeddings: BGE-M3, all-MiniLM-L6-v2
7:25 - Cómo generar embeddings con Ollama y curl
8:01 - Búsqueda semántica: más allá de grep
11:57 - Búsqueda semántica con Python y NumPy
14:29 - Bases de datos vectoriales para escalar
14:53 - Clasificación sin entrenar el modelo
18:20 - Clasificación de sentimientos y categorías
20:02 - Deduplicación de documentos con embeddings
24:50 - Sistema de recomendaciones con similitud semántica
27:15 - ChromaDB: base de datos vectorial persistente
29:02 - Casos de uso y próximos episodios sobre RAG

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

¿Todavía usando awk para extraer información de ps aux o df? En 2026 hay herramientas mucho mejores. En este episodio te presento tres herramientas que forman un tridente imbatible para trabajar con información del sistema en formato JSON: jc, jq y gron.

jc es un conversor de comandos Linux a JSON. Se instala con pip y un simple pipe convierte la salida de ps, df, free, ss, systemctl, lsblk y hasta 60 comandos más en JSON estructurado. Olvídate de awk y de los scripts frágiles que se rompen cuando cambia el orden de las columnas. Con jc, el JSON no depende del formato de salida. Tiene parsers específicos para cada comando, incluyendo crontab, last, lsof, pip list, lsmod, date y más. Si no encuentra el parser que necesitas, puedes crear el tuyo. Está escrito en Python y tiene licencia MIT.

jq es la navaja suiza de los JSON. Te permite filtrar, ordenar, agrupar, seleccionar y transformar cualquier JSON con una sintaxis potente. Está escrito en Go y es maduro, estable y rapidísimo. Combinado con jc, puedes listar los procesos que más RAM consumen, los discos por encima del 80% de ocupación o los servicios que han fallado, todo en una sola línea. Si la sintaxis te parece liosa, puedes pedirle a cualquier modelo de lenguaje que te genere la expresión que necesitas.

gron es el menos conocido pero igual de útil. Aplana un JSON convirtiendo cada valor en una línea independiente con su ruta completa. ¿Para qué sirve? Para poder usar grep directamente sobre un JSON. Si alguna vez has hecho un curl a una API y has intentado hacer grep sobre el resultado, sabes que no funciona porque todo está en una línea. Con gron, cada valor tiene su propia línea y puedes buscar con grep. Además permite la operación inversa con --ungron: modificas el JSON aplanado con sed y lo reconstruyes.

En el episodio presento sysreport.py, un script en Python que junta toda la información del sistema en un solo JSON usando jc y luego te permite hacer preguntas en lenguaje natural usando Llama 3.2 con Ollama. Le preguntas qué procesos consumen más RAM, qué servicios están caídos o si hay algún disco lleno, y él te responde en lenguaje natural. Todo corriendo en local, sin gastar un euro en APIs.

El script se puede usar como API local, se combina con watch para monitorización en tiempo real y con notify-send para notificaciones en el escritorio. Además se integra directamente con el nightly-runner del episodio 815 para incluir el estado del sistema en el resumen matutino.

Capítulos:

• 0:00 - Introducción: el problema de la salida en texto plano
• 2:30 - jc: convierte comandos Linux a JSON
• 5:00 - jq: la navaja suiza de los JSON
• 8:00 - gron: haz greppable cualquier JSON
• 10:30 - Combinando jc y jq para consultas del sistema
• 13:00 - sysreport.py: el script que lo junta todo
• 16:00 - Preguntando al sistema en lenguaje natural
• 19:00 - Monitorización con watch y notificaciones
• 21:00 - Ventajas: local, sin coste y sin dependencias
• 23:00 - Cierre: el tridente JSON

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

¿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