Skip to content
Artwork for Atareao con Linux

Atareao con Linux

atareao

Disfruta conmigo de Linux y del Open Source.

Aquí encontrarás como sacarle el máximo partido a tu entorno de escritorio Linux, hasta como montar un servidor web, un WordPress, un proxy inverso, una base de datos o cualquier otro servicio que puedas imaginar.

Y todo ello, lo puedes montar en una Raspberry Pi, en un VPS, en tu propio ordenador o en cualquier servidor.

Vamos, cualquier cosa que quieras hacer con Linux, seguro, seguro, que la encontrarás aquí.

Play
  • 38 episodes
  • a few times a week
  • Avg 27 min
  • Spanish
Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • S8 · E819
    August 3 · 26 min

    ATA 819 RAG I con SQLite y Ollama, base de conocimiento desde cero

    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

  • S8 · E818
    July 30 · 20 min

    ATA 818 Olvídate de Termius y MobaXterm, SSHUB es lo que necesitas

    ¿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. Capítulos del episodio: 0:00 — Introducción: el problema de gestionar múltiples servidores SSH 1:50 — El script de 2019 y la necesidad de una herramienta moderna 3:40 — SSHub: la TUI open source que lo unifica todo 5:30 — Características principales: hosts, túneles, claves y auditoría 7:30 — Instalación de SSHub con Cargo 9:30 — Navegación y atajos de teclado 11:30 — SFTP de doble panel y transferencia de archivos 13:30 — Gestión de túneles y claves SSH 15:15 — Auditoría de conexiones 17:00 — Importación, exportación y personalización 18:45 — ¿Para quién es SSHub? 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

  • S8 · E817
    July 27 · 31 min

    ATA 817 Creando tu cerebro digital, busqueda con IA local

    ¿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

  • S8 · E816
    July 23 · 25 min

    ATA 816 jc, jq y gron, el tridente JSON para Linux

    ¿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

  • S8 · E815
    July 20 · 26 min

    ATA 815 Olvídate de n8n, automatiza con Python y IA en 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

  • S8 · E814
    July 16 · 28 min

    ATA 814 Automatiza el OCR en Linux con modelos de lenguaje locales

    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

  • S8 · E813
    July 13 · 33 min

    ATA 813 Implementé un cazador de ofertas con IA

    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

  • S8 · E812
    July 9 · 26 min

    ATA 812 ¿La terminal más espectacular de Linux? La he probado y tengo un dilema

    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

  • S8 · E811
    July 6 · 27 min

    ATA 811 El secreto para que Hermes trabaje el tripe (y te cueste mucho menos)

    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

  • S8 · E810
    July 2 · 24 min

    ATA 810 Las 3 herramientas que van a cambiar tu terminal Linux para siempre

    Hoy dejamos a un lado por un momento los modelos de lenguaje y la inteligencia artificial para volver a los clásicos de este pódcast: la optimización y el disfrute de nuestra terminal de Linux. He decidido intercalar estos temas para no aburrir a nadie. Sé que la inteligencia artificial es fascinante, pero de vez en cuando viene muy bien un respiro técnico para centrarnos en lo que siempre nos ha apasionado: exprimir al máximo nuestro sistema operativo favorito. Por eso, hoy te traigo lo que yo llamo el tridente de la terminal, un trío de herramientas que, cuando se integran y empiezan a trabajar juntas, cambian por completo tu flujo de trabajo. Te aseguro que, una vez que las pruebas, ya no hay vuelta atrás. El buscador difuso interactivo: FZF La primera pieza de nuestro tridente es FZF (Fuzzy Finder). Imagina que tienes una lista gigante de archivos o de comandos y quieres encontrar algo específico. En lugar de escribir el término de búsqueda exacto, FZF te permite realizar una búsqueda difusa. Si buscas, por ejemplo, la palabra firefox, te bastará con teclear ffx. El programa entenderá de inmediato lo que estás intentando buscar y te filtrará los resultados en tiempo real. Ripgrep (rg): Búsquedas en milisegundos La segunda herramienta que forma nuestro tridente es Ripgrep, conocida en la terminal simplemente como rg. Si vienes usando el comando grep de toda la vida, Ripgrep va a ser una revelación para ti. Está programada en Rust y su velocidad de búsqueda dentro de archivos es, sencillamente, abrumadora. Bat: El clásico cat rediseñado con superpoderes La tercera punta del tridente es Bat (en algunos sistemas Debian y Ubuntu lo encontrarás como batcat). Todos hemos usado el comando cat para imprimir el contenido de un archivo en la terminal. Bat viene a sustituirlo ofreciendo una visualización muy superior. Cómo armar el tridente: La fusión definitiva Lo verdaderamente potente de estas herramientas no es solo usarlas por separado, sino conectarlas. Combinando Ripgrep con FZF y Bat, consigues un sistema de búsqueda en vivo increíble. Puedes hacer que Ripgrep busque un término en todos tus documentos, pasarle esa lista a FZF para que te permita filtrar de forma interactiva y, mientras te mueves por los resultados, abrir una pequeña ventana en el lateral donde Bat te previsualice en tiempo real el contenido del archivo con la sintaxis coloreada. En el episodio te explico cómo definir estas funciones en tu archivo de configuración (Bash, Zsh o Fish). De este modo, puedes construirte utilidades personalizadas con solo unas pocas líneas de código: desde un explorador de commits de Git muy visual hasta tu propio gestor de notas Markdown, rápido y sin distracciones, eliminando la necesidad de recurrir a pesados programas con interfaz gráfica. Capítulos de este episodio Aquí tienes la estructura del episodio para que puedas moverte cómodamente por el contenido: 00:00:00 Introducción y el tridente de la terminal 00:01:22 FZF: El buscador difuso interactivo 00:03:00 Atajos de teclado esenciales para FZF 00:08:16 El autocompletado mágico de FZF 00:09:09 Ripgrep (rg): Búsquedas a la velocidad de la luz 00:12:47 Combinando Ripgrep y FZF 00:14:26 Bat: El comando "cat" con superpoderes 00:18:07 Armando el tridente: Cómo combinar las tres herramientas 00:19:48 Casos prácticos: Explorar commits, matar procesos y gestionar notas 00:21:49 El ecosistema completo de 5 herramientas 00:23:19 Integración con IA, despedida y conclusiones 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

  • S8 · E809
    June 29 · 27 min

    ATA 809 Deja de subir tus PDFs a ChatGPT. Crea tu propia IA ya

    Te traigo un tema que me tiene completamente entusiasmado: cómo exprimir todos tus documentos, notas, manuales o archivos locales sin tener que compartirlos con nadie. Te voy a dar una visión general de cómo puedes montar un sistema de recuperación de información para que una inteligencia artificial local se convierta en tu asistente personal definitivo. Todo esto sin salir de tu propia casa, sin APIs de pago y de forma completamente privada. ¿Reentrenar o buscar? El gran dilema Para solucionar esta tremenda limitación, el mundo de la tecnología nos ofrece dos caminos diferentes: hacer un reentrenamiento de un modelo ya existente (lo que conocemos como fine-tuning) o bien montar un sistema RAG (Retrieval-Augmented Generation), que podríamos traducir como generación aumentada por recuperación. En este episodio te desvelo por qué el fine-tuning no es la solución para el común de los mortales: requiere de tarjetas gráficas carísimas, es un proceso lento y estático, y además tus datos privados quedan incrustados dentro del propio modelo, por lo que si se lo entregas a un tercero, estarás regalando tu privacidad. En cambio, un RAG casero es infinitamente más barato, dinámico y respeta tus datos al cien por cien. Imagina que en lugar de obligar al modelo a memorizar toda la biblioteca (que es lo que hace el fine-tuning), le pones a su lado un bibliotecario listísimo que busca la página exacta de los apuntes que necesita antes de responderte. El modelo de lenguaje lee esa página en tiempo real y te contesta basándose únicamente en hechos reales, no en invenciones. La tubería de datos para tu cerebro artificial A lo largo del episodio te explico con todo detalle las piezas que componen esta tubería de datos (o pipeline) que permite hacer magia con tus archivos: La ingesta El troceado (o chunking) Los embeddings y vectores La base de datos La búsqueda híbrida Herramientas listas para usar y errores que debes evitar Si te da miedo el código, no te preocupes. Te hablo también de alternativas como OpenWeb UI. Y si te va la marcha del desarrollo, te cuento cómo con apenas diez líneas de Python y Streamlit puedes tener una aplicación web propia y completamente funcional. Además, repasamos los tropiezos más habituales que cometemos al empezar en este mundillo, como usar modelos de vectorización que solo entienden inglés para procesar textos en español, no limpiar las cabeceras y pies de página de los PDFs antes de procesarlos, o la importancia crucial de reindexar de forma automática para que tus nuevos documentos estén disponibles al instante. Capítulos del episodio 00:00:00 Introducción y de qué va este episodio 00:01:54 ¿A qué problema nos enfrentamos con los LLM? 00:05:08 Fine-tuning vs. RAG: ¿Cuál es mejor para tus datos? 00:08:29 El Pipeline del RAG: De la ingesta a la respuesta 00:10:45 ¿Qué es un "embedding" y qué modelos usar con Ollama? 00:12:02 El arte de trocear el texto (Chunking) 00:13:40 Búsqueda híbrida: Semántica frente a coincidencia exacta 00:14:50 Re-ranking: Ordenando los resultados por relevancia 00:15:53 El Stack: Ollama, PostgreSQL, pgvector y Podman 00:17:25 Alternativas vectoriales: ParadeDB, ChromaDB y Qdrant 00:18:36 Manos a la obra con Python y Streamlit 00:20:53 OpenWeb UI: La alternativa con RAG integrado y sin código 00:21:42 Cómo saber si funciona: El método de las 20 preguntas 00:22:51 Errores comunes que debes evitar al montar tu RAG 00:23:55 Lo que viene: GraphRAG y RAG agéntico 00:24:44 Resumen final 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

  • S8 · E808
    June 25 · 27 min

    ATA 808 Por qué deberías dejar de usar Cron hoy mismo (y qué uso yo)

    En este episodio vamos a hablar de una de esas herramientas míticas del ecosistema Linux y Unix que prácticamente todos hemos configurado alguna vez: Cron. Ese servicio fiel, un clásico entre los clásicos, que lleva décadas ejecutando nuestras copias de seguridad de madrugada o eliminando ficheros temporales. Sin embargo, las cosas cambian, la tecnología avanza y yo creo que ha llegado el momento de que todos jubilemos a Cron. Sí, como lo oyes. Ha llegado la hora de darle una merecida jubilación dorada y abrir los brazos a una alternativa mucho más moderna, integrada y potente: los Systemd Timers. ¿Por qué deberías jubilar a tu viejo Cron? Sé que puedes estar pensando: "Lorenzo, pero si a mí Cron me funciona de maravilla". Y es verdad, para un comando sencillo que se ejecute cada hora, Cron cumple. Pero a poco que intentes complicar la tarea, empiezan los problemas. El gran drama de Cron es que trabaja a ciegas y en absoluto silencio. Si tu script falla por falta de internet, por un error de permisos o porque un recurso no está disponible, no te vas a enterar a menos que te hayas tomado el trabajo de programar tus propios registros de log, gestionar lógicas de reintentos o configurar desvíos de errores dentro de tu script. El poder de los Systemd Timers Con los Systemd Timers todo esto se soluciona de forma completamente automática y sin añadir complejidad a tus scripts. Systemd se encarga de gestionar de manera integrada el estado de tu sistema y te ofrece superpoderes como: Logs centralizados automáticos Gestión inteligente de la persistencia Control de dependencias Aleatorización horaria La anatomía de una tarea en Systemd Para conseguir toda esta potencia, Systemd utiliza un enfoque muy limpio en el que dividimos la tarea en dos archivos de texto sencillos que se complementan a la perfección: El Servicio (.service) El Timer (.timer) Automatización sin root: Los timers de usuario Pero mi funcionalidad favorita, y la que utilizo en mi día a día para casi todo, es la posibilidad de ejecutar estos temporizadores en el espacio del usuario corriente, sin necesidad de tener privilegios de administrador ni usar el comando sudo. Estos temporizadores se guardan en tu propia carpeta de configuración personal de forma limpísima y se ejecutan dentro del contexto de tu sesión activa. Capítulos del audio 00:00:00 Introducción y el adiós definitivo a Cron 00:01:43 Los fallos silenciosos de Cron: Logs, reintentos y dependencias 00:03:06 Las grandes ventajas de usar Systemd Timers 00:05:21 La anatomía de la automatización: Timer y Servicio 00:06:48 Configuración de la sección [Timer], OnCalendar y persistencia 00:07:55 Tareas relativas: OnBootSec y aleatorización de tiempos 00:10:00 Comandos de systemctl para gestionar tus tareas programadas 00:10:33 Ejemplos prácticos en el sistema: Backups y limpiezas 00:12:13 Notificaciones de escritorio e integración con el entorno gráfico 00:14:11 Timers de usuario: Automatización segura sin usar root o sudo 00:15:25 El truco de Linger para mantener tareas activas en VPS 00:16:53 Sincronización continua de notas y cambio automático de fondo 00:20:07 Cómo ver los logs y depurar fallos de forma sencilla con journalctl 00:21:25 Evita estos errores típicos y valida con systemd-analyze 00:24:51 El futuro de la automatización, modelos de lenguaje 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

  • S8 · E807
    June 22 · 31 min

    ATA 807 Configura Hermes Agent de verdad (lo que nadie te cuenta)

    Si has estado atento a los últimos episodios del podcast, ya te habrás dado cuenta de que estoy completamente enfocado en exprimir la inteligencia artificial local y el software libre. En concreto, hay dos herramientas que se han convertido en mis compañeras inseparables de fatigas en el día a día: OpenCode, que me ayuda a programar de una forma increíble, y Hermes Agent, un asistente digital del que hoy te lo quiero contar absolutamente todo. El dilema de la instalación: ¿Docker o en tu propia máquina? Como ya me conoces, sabes bien lo mucho que me gusta a mí levantar "al rico contenedor" y solucionar cualquier despliegue con Docker. Sin embargo, en mis pruebas con Hermes Agent he preferido dar un paso atrás y realizar una instalación directa sobre el sistema operativo, utilizando un entorno virtual de Python. El peligro de la ventana de contexto y la sangría de tokens Aquí está uno de los grandes secretos que casi nadie te explica al principio. Cuando ejecutas el asistente de configuración inicial de Hermes Agent, te entran ganas de activar absolutamente todas las características que te ofrece: herramientas de visión, utilidades del sistema, navegación web, traducción... ¡todo suena fantástico! Pero hay una trampa invisible en la que es muy fácil caer. El superpoder de los perfiles aislados (Profiles) La solución definitiva a este problema de consumo y rendimiento tiene un nombre: perfiles. Hermes Agent te permite crear tantos perfiles aislados como consideres oportuno. Modelando el Alma y la Memoria de tu Agente En el podcast te detallo cómo dar personalidad a tu agente a través del archivo de alma. A mi asistente personal, que he bautizado como Chloe, le he configurado un tono sarcástico, irónico y burlón. Me encanta interactuar con ella de esta manera porque rompe completamente con la clásica respuesta robótica y aburrida de otras inteligencias artificiales comerciales; se siente como hablar con un colega de verdad. Eso sí, te doy pautas para redactar este archivo con cuidado, ya que un "alma" demasiado extensa también te comerá espacio de contexto útil de forma innecesaria. Ampliando fronteras: MCP, Telegram y automatizaciones automáticas Por último, abordamos el fantástico protocolo MCP (Model Context Protocol), que nos permite dotar de "manos y ojos" a nuestro agente. Y para rematar la jugada, la integración con Telegram y Matrix. Es una auténtica delicia poder ir caminando, mandarle un audio desde el móvil a mi bot de Telegram, que este use Whisper en local para transcribir mi voz, procese lo que le pido y me conteste con otro audio sintetizado a la velocidad que yo le he configurado de antemano. Todo ello combinado con tareas programadas (Cron) y un tablero de Kanban interno con el que el propio agente se organiza y ejecuta flujos de trabajo de forma completamente autónoma. Te invito a que te prepares un buen café, te pongas los auriculares y disfrutes de este viaje de configuración avanzada de 0 a 100. CAPÍTULOS DEL AUDIO: 00:00:00 Introducción: Mi día a día con OpenCode y Hermes Agent 00:01:26 El problema de los tutoriales básicos e instalación 00:03:00 Configuración inicial y la sangría de tokens 00:04:47 Archivos clave y estructura interna de Hermes 00:05:56 Creando "Skills" personalizadas y configurando API Keys 00:08:15 Perfiles aislados (Profiles): Qué son y por qué los necesitas 00:11:00 Cómo clonar y gestionar tus perfiles sin romper nada 00:13:35 soul.md: Diseñando el "Alma" y el tono de tu asistente 00:15:28 memory.md: El gran desafío de la memoria y el RAG en Rust 00:17:38 Expandiendo capacidades con MCP y conversión de voz 00:20:47 Llevando tu agente a Telegram con Cron y Kanban integrado 00:27:18 Reglas de oro para optimizar tu contexto y despedida

  • S8 · E806
    June 18 · 26 min

    ATA 806 No memorices más comandos. Que Linux y tu IA trabajen para ti

    Seguro que si eres de los míos, de los que disfrutan pasando el rato en la terminal o montando servicios en casa, te habrás dado cuenta de que acabamos haciendo tareas repetitivas casi sin querer. Para poner fin a este caos cotidiano te traigo una herramienta espectacular que se llama Just. Pero la verdadera razón por la que he querido dedicarle este pódcast a Just de nuevo es por una experiencia divertidísima que he tenido estos últimos días con mi asistente de inteligencia artificial local, al que cariñosamente llamo Hermes. Yo soy una persona bastante perezosa para ciertas tareas repetitivas y me gusta poner a trabajar a las máquinas por mí. Normalmente, al acabar mis entrenamientos de carrera, le dicto un audio a Hermes detallando la distancia, las pulsaciones y el ritmo para que él los registre. Pero el otro día, llevado por la vaguería máxima, decidí simplemente hacer una captura de pantalla de la aplicación del móvil y enviársela por Telegram. Hermes, que es una maravilla de asistente, aplicó un sistema de lectura de imágenes (OCR) llamado Tesseract, extrajo todos los datos de mi carrera y los guardó en un periquete. Yo me quedé encantado y pensé que la vida ya estaba resuelta. Sin embargo, al día siguiente repetí el proceso y... ¡sorpresa! Hermes se había olvidado por completo de cómo lo había hecho. Me preguntó qué quería que hiciese con la imagen y, cuando le recordé lo del día anterior, me soltó que no tenía la herramienta de lectura instalada en su entorno de trabajo. Tuve que guiarle de nuevo de la mano paso a paso. Ahí fue donde se me encendió la bombilla. Las inteligencias artificiales a veces se despistan y tienen una memoria muy volátil para los flujos de trabajo técnicos. La mejor forma de darles estabilidad es crearles un recetario claro, un archivo "justfile" donde tengan todas sus habilidades documentadas y listas para ejecutar con un simple comando. Así, Hermes nunca más olvidará cómo procesar una imagen o cómo gestionar un contenedor, porque solo tiene que invocar la receta correspondiente. En este episodio quiero animarte a que pruebes Just en tu propio día a día, uses o no inteligencia artificial. Capítulos del episodio: 00:00:00 Introducción: Olvídate de repetir comandos 00:01:33 El problema con Hermes: Por qué las IA también se despistan 00:03:04 ¿Qué es Just y cómo funciona? 00:04:59 Cómo instalar Just en Linux 00:05:31 Comparativa: Just contra Make y Task 00:06:42 Gestión de variables, argumentos y funciones 00:08:49 Atributos de receta para afinar su comportamiento 00:10:00 El comportamiento de las líneas y el poder del Shebang 00:11:00 Funciones integradas y ajustes globales 00:12:00 Operadores, expresiones y dependencias complejas 00:13:00 Usando intérpretes alternativos (Bash, Python, Node) en Just 00:14:18 Recetas normales frente a recetas Shebang y scripts 00:15:33 Módulos e importación de recetas externas 00:16:38 El selector interactivo con búsqueda difusa (just choose) 00:17:37 Alias, grupos y autocompletado en tu shell 00:18:09 Casos prácticos de uso real (Sysadmin, Docker, Backups) 00:19:18 Documentación viva y ejecutable para todo el mundo 00:20:17 Control de versiones con Git y límites de Just 00:21:10 Una historia de pereza, Hermes, deporte y OCR que se olvida 00:22:59 Conclusiones: Simplifica tu vida con este ejecutor de comandos 00:24:58 Cierre del episodio 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

  • S8 · E805
    June 15 · 32 min

    ATA 805 El fin de los programadores? Qué es el Vibe Coding y cómo te cambia la vida

    Hoy en Atareao con Linux vamos a hablar largo y tendido sobre el Vibe Coding y cómo está cambiando por completo las reglas del juego en este 2026. Si estás escuchando esto mientras vas al trabajo, cocinas o das un paseo, y crees que esto no va contigo porque nunca has tocado una sola línea de código... ¡espera! No toques el botón de siguiente episodio. Este podcast es precisamente para ti. ¿Alguna vez has tenido esa pequeña idea en la cabeza de una aplicación sencilla que te solucionaría la vida, pero la has descartado porque no sabes programar o no tienes tiempo para aprender? El Vibe Coding es el puente que te va a permitir cruzar esa brecha y hacer realidad tus ideas explicándoselas a la tecnología igual que me las explicarías a mí, con tus propias palabras. El nacimiento de un nuevo paradigma: Del "Vibe" al Agentic Engineering Para entender esta auténtica locura nos tenemos que remontar a febrero de 2025. Andrej Karpathy, una de las mentes más brillantes en el mundo de la Inteligencia Artificial (ex OpenAI y ex Tesla), lanzó un tuit que corrió como la pólvora por todo internet. En ese mensaje acuñó el término Vibe Coding: una nueva forma de programar en la que te dejas llevar por las vibraciones, abrazas el crecimiento exponencial y te olvidas de que el código realmente existe. La idea caló de tal forma que se convirtió en la palabra del año para el diccionario Collins y hoy, un año después, el 84% de los programadores la integran en su rutina. Mi experimento en directo: Una aplicación a medida por dos céntimos A mí no me gusta hablar de oídas, así que al principio del episodio me he puesto manos a la obra. He abierto mi terminal de Linux, he lanzado una herramienta de código abierto maravillosa llamada OpenCode y le he pedido que crease una aplicación para la terminal en Rust para gestionar mis tareas (un TODO clásico) ¿Qué herramientas tenemos a nuestro alcance en 2026? • Cursor • Lovable • Claude Code Por otro lado, si eres de los míos y te apasiona el código abierto: • OpenCode. • Cline. • OpenHands • Aider El lado oscuro: Las trampas de la falsa seguridad No todo es perfecto y es de vital importancia hablar del lado oscuro de esta tecnología. Es una trampa cognitiva de falsa confianza de manual. La conclusión: La IA no te quitará el trabajo, pero sí cambiará el juego Capítulos del episodio: 00:00:00 Introducción al Vibe Coding y la revolución del desarrollo00:01:40 El origen del Vibe Coding y cómo empezar con un prompt00:05:50 ¿Qué es realmente el Vibe Coding y qué es el Agentic Engineering?00:08:20 ¿Para quién sirve el Vibe Coding? Productividad, MVPs y aprendizaje00:09:40 Herramientas privativas de Vibe Coding: Cursor, Lovable y Claude Code00:13:25 Alternativas de Código Abierto (Open Source): OpenCode, Cline, OpenHands y Aider00:17:05 Demostración en vivo: Ejecutando nuestra aplicación TODO en Rust por dos céntimos00:22:50 El lado oscuro del Vibe Coding: Seguridad, vulnerabilidades y deuda técnica00:26:30 Cómo aprovechar la Inteligencia Artificial sin arruinar tu código00:30:05 El futuro del desarrollo de software 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

  • S8 · E804
    June 11 · 30 min

    ATA 804 El editor que uso en mis servidores (y no es NeoVim)

    Si has estado escuchando los últimos capítulos, te habrás dado cuenta de que he estado sumergido de lleno en el fascinante (y a veces abrumador) mundo de la Inteligencia Artificial. De vez en cuando mi mente me pide a gritos un descanso. Y para mí, descansar significa volver a los orígenes: ponerme a cacharrear con la terminal y escribir código en Rust. En el episodio de hoy quiero cambiar completamente de tercio. Te voy a contar mi experiencia de las últimas semanas saliendo de mi zona de confort con un editor de texto modal que me tiene maravillado en los servidores, y te presentaré cuatro herramientas que he desarrollado en Rust para solucionar pequeños problemas del día a día directamente en la consola de comandos. Así que, ponte cómodo mientras cocinas, vas de camino al trabajo o das un paseo, ¡porque nos vamos directos al turrón! El gran dilema de la terminal: ¿Por qué uso Helix en mis servidores si soy fiel a NeoVim? Los que me seguís desde hace tiempo sabéis que mi editor de cabecera en mi equipo de trabajo habitual es NeoVim. Llevo muchísimos años puliendo mi configuración y, a día de hoy, tengo más de cien plugins instalados que hacen que mi entorno sea espectacular: autocompletado instantáneo, una barra de estado genial, un explorador lateral de archivos y un sistema de análisis de código brutal. Pero, ¿qué pasa cuando me conecto por SSH a mis servidores de producción? Normalmente, estos servidores corren distribuciones Ubuntu de soporte a largo plazo con paquetes más antiguos, por lo que mi configuración de NeoVim moderna empieza a fallar estrepitosamente. Instalar y mantener más de cien plugins en cada uno de los servidores que gestiono es un dolor de cabeza inmanejable. Para solucionar esto sin renunciar a la agilidad de un editor modal en terminal, decidí darle una oportunidad a Helix. Peleándome con la memoria muscular Tengo que confesarte que adaptarme a Helix ha sido un ejercicio duro para mis dedos. Cuando llevas años interiorizando los comandos de Vim, tu cerebro automatiza la edición. Mis herramientas caseras desarrolladas en Rust Aquí te hablo de ellas en detalle: 1. mkdr (Markdown Reader/Render): Como todos mis artículos de atareao.es y mis notas personales están guardados en formato Markdown, necesitaba un renderizador potente para leerlos cómodamente desde la consola de comandos. 2. id3cli: Automatizar los metadatos de los episodios de este podcast es crucial para mí. 3. rustled: Para que mi asistente de inteligencia artificial, Cloe, pudiera comunicarse conmigo por voz, necesitaba una herramienta de texto a voz (Text-to-Speech) flexible 4. ssrs: Si en algún momento no dispongo de conexión a internet o prefiero que los textos se procesen con absoluta privacidad, recurro a susurros. 00:00:00 Introducción y un descanso de la Inteligencia Artificial 00:00:56 ¿Qué es Helix y por qué me costó al principio? 00:02:27 El problema de llevar NeoVim (y sus plugins) a los servidores 00:06:23 Primeros pasos con Helix: el tutor y las diferencias con Vim 00:09:34 Pantalla dividida, multicursor y velocidad extrema 00:10:54 Temas, resaltado de sintaxis de serie y comandos 00:15:12 Mis propias herramientas: renderizar Markdown en terminal con mkdr 00:18:40 Navegación estilo Wiki y otras ventajas de mkdr 00:20:18 id3click: gestionando etiquetas MP3 sin depender de terceros 00:21:52 Dándole voz a Cloe: raslet y la API de Microsoft Edge TTS 00:24:35 susurros: generación de voz 100% en local con Rust 00:26:55 El futuro: ssrs (Whisper en Rust) y conclusiones 00:28:35 Recomendación de podcast: Legalmente Productivos 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

  • S8 · E803
    June 8 · 26 min

    ATA 803 Planifica tu menú y compra con IA. RAG, MCP y Skills para humanos

    Olvídate de hacerle preguntas genéricas a ChatGPT; hoy vamos a ver cómo sacarle partido real y práctico a la tecnología para solucionar problemas cotidianos y quitarnos de encima la fatiga de decisión diaria. Seguro que te suena la película: post-its en la nevera, hojas de cálculo que se quedan desactualizadas y el clásico "¿qué cenamos hoy?" que acaba en improvisación o en una compra desorganizada. Para evitar esto, he diseñado un ecosistema de agentes basados en cuatro cajas de herramientas que llamamos MCP (Model Context Protocol). Estos protocolos permiten que la IA no solo responda preguntas, sino que interactúe de forma directa con mis datos y aplicaciones externas. Te explico de forma muy sencilla las piezas que componen este sistema: El RAG Semántico para las recetas: Tengo una base de datos vectorial con unas 1.700 recetas cargadas en PostgreSQL mediante pgvector. La clave es que no busco platos por coincidencia exacta de palabras. Si le digo que quiero "algo rápido y ligero con verdura", el sistema realiza una búsqueda semántica, entiende lo que busco y me propone las mejores opciones. Todo esto se procesa de forma económica mediante OpenRouter sin necesidad de tener una potente GPU en local. Los Skills y SQLite: Los "Skills" definen los procesos exactos que debe seguir el modelo. Le he marcado unas pautas sencillas: platos únicos mediterráneos para comer y cenas ligeras. Toda esta información se gestiona en una base de datos SQLite muy ligera. Lógica difusa en la lista de la compra: El asistente es capaz de agrupar ingredientes similares. Si dos recetas piden tomates en formatos distintos (por ejemplo, "tomates a granel" y "100g de tomates"), la lógica difusa los unifica bajo un mismo concepto para evitar duplicados en la lista de la compra, organizando además los productos por pasillos o secciones (como frutería o carnicería). Typst para exportar a PDF: Para ver el menú en una tablet o imprimirlo para la nevera, utilizo Typst, una alternativa moderna a LaTeX que me genera unos documentos PDF impecables en cuestión de segundos. Además, te cuento cómo puedes montar todo esto en local de manera gratuita con Ollama, y aprovecho para actualizarte sobre mis andanzas de vuelta al "cacharreo" puro en Linux: desde mis experiencias recientes con el editor Helix y "mkdr" (mi renderizador de Markdown para terminal), hasta "podcli", una pequeña utilidad para exprimir los feeds de podcast desde la consola. Espero que disfrutes de este episodio tanto como yo montando todo este tinglado. ¡A cacharrear! Capítulos del episodio: 00:00:00 Agentes de IA que de verdad nos facilitan la vida 00:01:42 El ejemplo práctico: Automatizar nuestro menú semanal 00:03:51 La fatiga de decisión y por qué la disciplina humana falla 00:05:38 Mi caja de herramientas: 4 MCPs (Model Context Protocol) 00:06:58 Buscando comida con IA: El RAG semántico de 1700 recetas 00:08:45 Búsqueda híbrida y embeddings económicos sin usar GPU local 00:10:00 Simplificando las comidas: El papel de los "Skills" 00:11:58 Organizando la base de datos de manera sencilla con SQLite 00:13:31 Lógica difusa: Evitando duplicados en la lista de la compra 00:15:23 Creando PDFs bonitos con Typst (la alternativa moderna a LaTeX) 00:17:03 Demostración en directo: Generando el menú de la semana 00:19:12 Automatización total: Generación automática de menús con Cron 00:20:19 Revisión del menú, las recetas y la alternativa local con Ollama 00:23:12 De vuelta al "cacharrero" de Linux: Helix, mkdr y Podcli 00:24:51 Próximos episodios: Instalación desde cero a producción de Hermes 00:25:38 Despedida y cierre del episodio 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

  • S8 · E802
    June 4 · 27 min

    ATA 802 Conectado Hermes Agent a Internet y YouTube

    Si en el episodio anterior te hice una pequeña introducción de lo que es capaz de hacer este agente, hoy quiero bajar al barro contigo y contarte cómo le he dado ojos a nuestro modelo para que pueda explorar internet, documentarse y encontrar la mejor información de forma completamente soberana, libre de anuncios y con el máximo respeto por nuestra privacidad. En este episodio nos vamos a centrar en dos "conectores" brutales que he integrado en su arsenal: uno para realizar búsquedas en la web general y otro para realizar búsquedas avanzadas en YouTube. SearXNG: Tu propio Google privado y sin publicidad La primera pieza de este rompecabezas es SearXNG. Es una herramienta maravillosa que actúa como un buscador de buscadores. En lugar de ser un motor de búsqueda que rastrea la web entera por su cuenta, SearXNG lo que hace es consultar de forma simultánea a los grandes del sector: Google, Bing, Brave, DuckDuckGo y los que tú decidas. Recopila las respuestas de todos ellos, limpia los molestos rastreadores que intentan identificarte, elimina los anuncios y te devuelve una lista limpia de resultados. Invidious: Buscando en YouTube con total soberanía La segunda herramienta que le he dado a Hermes es Invidious, y tiene un propósito muy claro: facilitarle el acceso a la inmensa base de conocimientos que es YouTube. La magia de los subagentes paralelos Lo que me tiene entusiasmado de este sistema es la capacidad de Hermes de combinar ambas herramientas de forma autónoma gracias a los subagentes. Imagina que le pido a Hermes que me recomiende cómo aprender a programar en el lenguaje Rust. En lugar de darme una respuesta estática, Hermes decide de forma inteligente lanzar dos subagentes: uno se va a la web a través de SearXNG a buscar documentación oficial y artículos de referencia, mientras que el otro se va a YouTube a través de Invidious para buscar cursos en vídeo. Ambos asistentes virtuales regresan con sus hallazgos y Hermes hace un cruce de datos espectacular. El poder de los contenedores Docker Para montar todo esto sin complicarme la vida ni ensuciar el sistema operativo de mi equipo principal, he recurrido a mis queridos contenedores Docker. Cada herramienta corre en su propio compartimento aislado. Da igual que SearXNG use unas librerías de Python concretas o que Invidious requiera otras dependencias distintas; al estar encapsulados, nunca entran en conflicto. Si quiero actualizar algo, simplemente descargo la nueva versión del contenedor y listo. En la entrada del blog te dejaré las plantillas de Docker Compose preparadas para que tú también puedas desplegarlas en tu servidor y empezar a cacharrear hoy mismo. CAPÍTULOS DEL EPISODIO: 00:00:00 Presentación: El asistente de IA definitivo y la soberanía digital 00:01:40 ¿Qué es un MCP (Model Context Protocol)? 00:03:26 SearXNG: Tu propio motor de búsqueda privado y sin anuncios 00:05:53 Poniendo a prueba las búsquedas web con Hermes 00:07:32 Cómo está montada la infraestructura de búsqueda con Docker 00:08:48 Automatización real: Creación de documentos con información web 00:09:38 Invidious: YouTube sin publicidad y sin rastreo 00:11:43 Buscando y analizando vídeos de YouTube con Hermes 00:16:20 Superpoderes combinados: Búsqueda web + YouTube 00:20:40 Por qué autoalojar todo en contenedores Docker independientes 00:22:04 Analizando la recomendación razonada de la IA para aprender Rust 00:24:09 Próximo episodio: Planificación de menús y bases de datos vectoriales 00:25:09 Taller presencial en Linux Center de Slimbook (¡ven a cacharrear!) 00:26:00 Despedida y cierre del episodio 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

Showing 21–38 of 38 episodes