Atareao con Linux

Epizode

• ATA 801 Hermes Agent y subagentes en directo. ¿Qué puede salir mal? 01.06.2026 31min

  Hoy te traigo un episodio que se sale completamente de lo habitual y que ha supuesto un auténtico terremoto en mi forma de plantear los contenidos. Todo viene de un cambio de estrategia radical que decidí tomar tras pararme a analizar las estadísticas de los últimos programas. Me di cuenta de un detalle muy tonto pero crucial: te estaba hablando de herramientas increíbles, de los maravillosos conectores MCP y de bases de datos súper avanzadas... ¡pero no te había mostrado al verdadero protagonista de la película! Te estaba hablando de accesorios y complementos sin enseñarte el agente de Inteligencia Artificial que los gobierna a todos. Es como si te diera un manual de bujías sin mostrarte el motor del coche. Así que he decidido pausar el resto de temas técnicos y traerte directamente a Hermes Agent. Y para hacerlo de la manera más honesta y didáctica posible, hoy no te lo voy a contar yo solo: he dejado que mi propio agente de IA local tome el control del micrófono para demostrarte de lo que es capaz en tiempo real, sin nubes y sin cortes.El cerebro que vas a escuchar hablar a lo largo de este podcast se llama Lara. Es el agente que he configurado utilizando como cimiento el proyecto de código abierto Hermes Agent.Para demostrar que este tipo de tecnologías está al alcance de cualquiera y no requiere un hardware inalcanzable, he configurado a Lara para que funcione en un Slimbook One de lo más modesto. No cuenta con tarjeta gráfica (GPU) ni coprocesadores de IA (NPU); corre única y exclusivamente tirando de CPU, de procesador clásico. Para que podamos comunicarnos con ella y escucharla, utilizamos herramientas locales tanto para el reconocimiento de voz (Whisper) como para el paso de texto a voz (TTS). Al no disponer de un hardware de aceleración dedicado, notarás que la voz de Lara suena con ese puntito robótico clásico del software local y que a veces pronuncia de forma un tanto peculiar palabras en inglés como "YouTube" o "skills". Pero te aseguro que, en cuanto la escuchas interactuar un rato y negociar el guion del programa, le coges un cariño increíble. Especialmente porque Lara no tiene esa amabilidad artificial y empalagosa de los asistentes comerciales que te dicen "claro, con gusto te ayudo"; ella tiene su propia personalidad.En este programa vas a poder escuchar de primera mano cómo funciona este sistema a través de siete demostraciones reales y en tiempo real. Aunque preparamos un guion base inicial, las últimas pruebas las hicimos completamente al azar y sin red para ver hasta dónde podíamos exprimir la CPU del Slimbook:Demo 1: Lara realiza una búsqueda en vivo en Internet sobre las últimas tendencias y vídeos de agentes de IA localesDemo 3: Mi demostración favorita. Conectamos una base de datos local con más de 1600 recetas a nuestra lista de la compra inteligente.Demo 4: Accedemos a mi archivo personal de más de 3300 notas de texto y tareas pendientes integradas.Demo 5: Conectamos a Lara con mis datos de Strava del último mes. Demos 6 y 7: El experimento final sin red. Lara resume las noticias de tecnología más destacadas.Capítulos del episodio00:00:00 Cambio de estrategia: ¿Por qué necesitas un agente?00:03:36 Presentación de Lara y su cerebro local00:05:32 Demo 1: Búsqueda y análisis de información en Internet00:07:53 Demo 2: Multitarea paralela con subagentes00:09:51 Demo 3: Recetas de cocina y compra inteligente00:13:58 La importancia de la búsqueda semántica en tus notas00:14:48 Demo 4: El sistema de notas y tareas conectadas00:16:51 Demo 5: Controlando mis entrenamientos con Strava00:19:14 De la teoría al caos: Demos aleatorias sin red00:20:21 Demo 6: Noticias de tecnología e IA al día00:22:29 Demo 7: Resumen inteligente de textos extensos00:26:14 Taller presencial de Valencia: Trasteando con Hermes00:28:51 Hermes vs OpenClaw: La experiencia real de Daniel Primo00:29:52 Privacidad y hardware: Modelos ejecutados en CPU local00:30:26 Cierre del episodio y comunidad Atareao
• ATA 800 Enseña a tu IA a recordar tareas y ahorra tokens 28.05.2026 27min

  ¡Episodio 800 de Atareao con Linux! Parece que fue ayer cuando empecé a grabar las primeras entregas compartiendo mis andanzas en el mundo de los servidores y el código abierto, y mirad hasta dónde hemos llegado. Muchísimas gracias de todo corazón por acompañarme en este viaje, por cada comentario, por cada descarga y por estar siempre ahí al otro lado del auricular trasteando y cacharreando conmigo.Para conmemorar este número tan redondo, hoy vamos a seguir explorando el apasionante mundo del Model Context Protocol (MCP), esa tecnología que está revolucionando la forma en la que interactuamos con la Inteligencia Artificial de forma local. Si en el episodio anterior nos centramos en una herramienta pasiva para consultar la previsión del tiempo, hoy vamos a dar un paso de gigante hacia la acción. Te voy a explicar en detalle cómo he diseñado e implementado un servidor MCP ToDo que dota a tu IA local de una memoria persistente a largo plazo. Sí, has escuchado bien: ¡vamos a curar de una vez por todas la amnesia de los modelos de lenguaje!Mi propuesta: Un gestor de tareas local programado en RustPara atajar este problema, me puse manos a la obra y programé un servidor MCP específico para la gestión de tareas utilizando Rust.Poniéndolo a prueba en vivo y en directoDurante el episodio de hoy te cuento exactamente cómo tengo desplegada esta solución en mi servidor doméstico.Optimización de tokens: El arte de no saturar a la IAUn detalle técnico fundamental que abordo en este episodio es el control y optimización del contexto.Capítulos del episodio: 00:00:00 Intro: El hito del episodio 800 y el problema de la memoria en las IA 00:00:32 El consumo de tokens y los límites de la ventana de contexto 00:01:22 Herramientas externas para dotar de memoria a los modelos de lenguaje 00:03:26 Solucionando la "amnesia" de la IA con una base de datos local 00:04:44 Implementación técnica: Un servidor MCP rápido en Rust con Podman y Docker 00:06:14 Cómo configurar la integración del MCP ToDo en OpenWeb UI paso a paso 00:08:29 Demostración en vivo: Listar, añadir y consultar tareas pendientes 00:09:56 El reto del lenguaje natural, el formato de fechas y los logs internos 00:12:05 Gestión avanzada: Marcar tareas completadas y asignar etiquetas 00:14:52 ¿Cómo funciona bajo el capó? Operaciones CRUD y base de datos relacional 00:16:42 Por qué elegí SQLite frente a JSON (búsquedas rápidas con FTS5) 00:18:22 El truco para evitar que tu IA colapse: Paginación y control de tokens 00:20:20 Seguridad de archivos: El rol del MCP como intermediario seguro 00:22:16 El siguiente nivel: De la consulta pasiva de información a la escritura activa 00:23:21 El puente definitivo hacia las bases de datos vectoriales y RAG 00:23:58 Próximo Workshop presencial sobre IA local en Linux Center (Slimbook) 00:24:52 Código abierto en GitHub, infografías de Atareao y avance del próximo episodio 00:25:54 Despedida, comunidad y la red de podcasts de Sospechosos HabitualesMá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
• ATA 799 Rompe la caja de cristal de tu IA. Conéctala a la VIDA 25.05.2026 24min

  En el episodio anterior te estuve hablando de tres pilares fundamentales que cambian por completo las reglas del juego cuando queremos ir un paso más allá de los modelos de lenguaje convencionales: el RAG (la memoria), las habilidades y las herramientas. Hoy no nos vamos a quedar en las nubes de la teoría. Hoy nos arremangamos y vamos directos al turrón con un ejemplo totalmente práctico, porque al final lo que queremos es ver cómo se hace, cómo se lleva a cabo en nuestro propio servidor y cómo podemos empezar a sacarle partido a estas tecnologías desde ya.¿Por qué Rust es el rey del cacharreo con MCPs?Si buscas tutoriales en la red, verás que la inmensa mayoría de servidores MCP se desarrollan en Python. No me malinterpretes, Python es fantástico para escribir código rápido, pero en el mundo de los microservicios autohospedados y los contenedores tiene ciertos inconvenientes difíciles de ignorar. Python tarda más en arrancar y consume una cantidad considerable de memoria RAM por el simple hecho de existir.Por este motivo decidí programar todos mis MCPs utilizando Rust. Rust nos compila un binario nativo, limpio y directo. No hay intérpretes pesados de por medio. La latencia de respuesta es prácticamente cero, el consumo de memoria es insignificante y se ejecuta a una velocidad de vértigo. Además, gracias a editores modernos equipados con IA como OpenCode, una vez que logras pulir y estructurar tu primer MCP en Rust (por ejemplo, el del tiempo), crear el siguiente es sencillísimo. Solo tienes que proporcionarle a tu herramienta de código la estructura de tu primer desarrollo y pedirle que adapte esa misma lógica para conectar cualquier otra API o base de datos que necesites. ¡Es una delicia ver cómo escala el sistema!Bajo el capó: APIs públicas, Docker y QuadletsPara hacer realidad este MCP meteorológico, he combinado el poder de dos APIs públicas muy conocidas:Nominatim (OpenStreetMap): Como las APIs del tiempo necesitan coordenadas geográficas (latitud y longitud), Nominatim se encarga de traducir textos legibles como "Valencia" o "Tokio" en datos numéricos de localización.Open-Meteo: Recibe las coordenadas enviadas por el MCP y devuelve la previsión meteorológica actual, horaria o diaria sin necesidad de usar claves de API complejas ni registros restrictivos.Todo este flujo de datos se empaqueta de forma elegante en un contenedor de Docker y se gestiona mediante un Quadlet de Podman para garantizar que se inicie de forma nativa e integrada con el sistema operativo de nuestro servidor.Y más adelante nos sumergiremos en el fascinante universo del RAG local.Capítulos del episodio:00:00:00 Introducción y repaso del episodio anterior00:00:43 El problema de los modelos estáticos de IA00:01:29 El ejemplo práctico: Preguntando el tiempo00:03:20 Ahorro extremo de tokens con MCP00:04:49 Taller de IA agéntica y automatización con Slimbook00:06:22 Cacharreando con DeepSeek V4 Flash en OpenCode00:07:33 ¿Qué es y cómo funciona un MCP?00:09:13 Por qué desarrollo mis MCPs en Rust (y no en Python)00:11:13 Limpieza de datos y gestión de errores00:12:40 Cómo conectar un MCP a Open Web UI paso a paso00:14:18 Probando la previsión meteorológica en vivo00:15:37 El motor bajo el capó: Open-Meteo, Nominatim y Docker00:17:25 Codegraph: Analizando código para ahorrar tokens00:18:22 Próximo episodio: Guardar tareas persistentes con MCP To Do00:19:48 Otros MCPs listos para el taller de IA00:21:22 El futuro del podcast: RAG local, notas y más cacharreo00:22:50 Despedida, enlaces de interés y cierreMás información, enlaces y notas en https://atareao.es/podcast/799🌐 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
• ATA 798 ¡Tu IA es TONTA! Dale manos y cerebro 21.05.2026 25min

  Este episodio nos vamos a meter de lleno en el barro del cacharreo del bueno para hablar de algo que me tiene completamente entusiasmado y sin dormir de la emoción en los últimos días: el maravilloso e increíble mundo del futuro agéntico. Sí, sí, has oído bien. Vamos a desgranar cómo dar el salto definitivo de esos chats de Inteligencia Artificial tan aburridos en los que solo escribes una pregunta y esperas una respuesta, a tener un auténtico colaborador activo que haga tareas reales por ti en tu propia máquina.Seguro que te ha pasado alguna vez. Estás usando un modelo de lenguaje, le pides ayuda para tu proyecto personal o para organizar tus notas de Linux, y de repente te das cuenta de que la IA se ha quedado congelada en el tiempo. Su conocimiento es completamente estático, no tiene ni la más remota idea de tus datos, de tus notas en Markdown, de tus contenedores ni de tus flujos de trabajo. Y lo peor de todo: cuando no sabe algo, en lugar de callarse, ¡se lo inventa con una tranquilidad que asusta! Básicamente, alucina. Las IAs de hoy en día, tal y como nos las venden de fábrica, están completamente aisladas del entorno, del tiempo y de tus propios procesos de trabajo. Son como un trozo de corcho flotando a la deriva en mitad del océano: muy ligeras y con potencial, pero incapaces de hacer nada útil de forma autónoma.¿Y cuál es la solución para dejar de tener una IA "tonta" y aislada? No se trata de una única tecnología mágica, sino de combinar con cabeza tres piezas fundamentales que le darán superpoderes a tu asistente: el RAG (la memoria), los MCP (las manos) y las Skills (los manuales de instrucciones).Cuando consigues orquestar estas tres piezas en tu propio host local, la magia ocurre. Consigues crear un asistente de verdad, como mi querido Hermes, que es capaz de redactar los textos que necesito para este podcast, gestionar mis recordatorios y organizar mis notas de forma totalmente autónoma mientras yo me lo paso pipa programando.Capítulos del episodio:00:00:00 ¡Bienvenidos al futuro agéntico!00:01:21 Lo que se viene en este episodio (y en los próximos)00:02:42 ¿Por qué las IAs hoy en día son "tontas" e inútiles?00:04:36 La solución: Skills, RAG y MCP explicados fácil00:06:14 La analogía del nuevo empleado en tu empresa00:07:38 El agente de IA como el gran director de orquesta00:08:21 ¿Qué es el RAG? (Conocimiento en tiempo real sin fine-tuning)00:11:17 Mi RAG propio en Rust para archivos Markdown00:12:39 ¿Qué es el MCP? (La revolución de Anthropic)00:14:55 Cómo usar MCP para conectar tu IA con el mundo real00:16:14 Mis servidores MCP: SearXNG, Invidious y listas de tareas00:18:10 Skills: Ahorro de tokens y flujos de trabajo inteligentes00:20:11 La matriz definitiva: Memoria, Manos y Manuales00:22:04 De un chat reactivo a un colaborador activo (Mi asistente Hermes)00:23:54 Próximos pasos, descargas de código y despedidaMá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
• ATA 797 Como Usar Agentes de IA sin arruninarte. Opencode Go y Openrouter 18.05.2026 24min

  ¿Quieres usar agentes de IA para programar sin arruinarte? En este episodio de atareao con Linux comparo las dos opciones más interesantes para desarrolladores en 2026: OpenCode Go y OpenRouter.Durante las últimas semanas he estado completamente volcado con OpenCode, usándolo tanto para generar código como para revisar código existente. Y en el proceso me he encontrado con una pregunta clave: ¿cómo accedo a los modelos de IA sin arruinarme?La respuesta no es trivial. Tienes dos opciones clásicas: comprar hardware dedicado o pagar servicios en la nube como ChatGPT o Gemini. Pero hay una tercera vía: combinar herramientas open source con servicios de bajo coste.En este episodio te cuento:Qué es OpenCode Go y por qué $10/mes pueden ser suficienteQué es OpenRouter y cómo usar 400+ modelos (algunos gratis)Comparativa directa de precios, modelos, ventajas y desventajasCuál elegir según tu caso de usoCaso práctico: cómo mejoré mi herramienta Shul con skills de Rust y ReactPor qué las skills son el verdadero game-changer de los agentes de IATambién te adelanto lo que viene en los próximos episodios: flujo de trabajo completo con skills, RAG, MCPs... la cosa se pone muy caliente.Capítulos:00:00 — Introducción: el dilema de la IA y el dinero02:30 — ¿Qué es OpenCode?04:50 — OpenCode Go: la suscripción de $10/mes08:20 — OpenRouter: el agregador de 400+ modelos10:50 — Comparativa directa13:00 — Caso práctico: mejorando Shul con Skills16:00 — El poder de las Skills19:00 — Conclusiones y cuál elegir22:00 — Próximos episodiosMá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/atareaoSi te ha gustado, deja una reseña en Spotify y comparte el episodio con alguien que esté interesado en la IA aplicada al desarrollo. ¡Nos escuchamos el próximo jueves!
• ATA 796 Lleva la IA a otro nivel! Descubre el POTENCIAL de las SKILLS 14.05.2026 21min

  En el episodio de hoy, el número 796, vengo con muchas ganas de contarte algo que me tiene completamente fascinado.Pero vamos a lo importante: las Skills o habilidades. Si creías que la inteligencia artificial era solo un chat donde escribir preguntas y recibir respuestas, prepárate, porque hoy vamos a ver cómo dotar a nuestros modelos de lenguaje de auténticos "superpoderes" técnicos.¿Qué son realmente las Skills?Imagina que en lugar de darle instrucciones genéricas a tu modelo (lo que conocemos como prompt), le proporcionas una estructura especializada. Una Skill es una herramienta transversal que le enseña al modelo a comportarse como un experto en una materia concreta. Lo maravilloso es que estas habilidades no dependen de un solo modelo; puedes usarlas con Claude, con OpenCode, con Hermes o con cualquier otro agente. Es una forma de democratizar el conocimiento técnico y hacerlo reutilizable.En este episodio te cuento mi experiencia personal utilizando estas habilidades para tareas que, de normal, nos llevarían bastante tiempo de configuración. Desde crear contenedores Docker optimizados hasta gestionar bases de datos complejas sin escribir una sola línea de SQL.Soberanía Digital y Potencia LocalYa sabes que me encanta el lema de "yo me lo guiso, yo me lo como". Aunque existen servicios externos muy económicos para correr estos modelos, nada supera la sensación de tener el control total. Te hablo de mi configuración actual: un Slimbook con una Nvidia GeForce RTX 4060 Ti de 16 GB de VRAM. Con este hardware estoy corriendo modelos como el Qwen de 35 billones de parámetros con una fluidez espectacular. Aquí es donde la soberanía digital cobra sentido: mis datos, mis reglas y mi hardware.Ejemplos prácticos: Docker y SQLiteA lo largo del audio, te guío por dos ejemplos que me han dejado con la boca abierta:Docker Expert.SQLite Expert.La Anatomía de una Skill: Bajo el capóMenciono también el increíble trabajo de Daniel Primo en Web Reactiva, quien ha profundizado muchísimo en este tema de las Skills y cuya guía ha sido una fuente de inspiración fundamental para experimentar con todo esto.Conclusión: El futuro es el lenguaje naturalCapítulos:00:00:00 El troleo a David y la importancia del feedback00:00:41 Introducción a las Skills: Dale "poderes" a tu IA00:01:14 Repaso a OpenCode y el paso a la soberanía digital00:02:11 Mi hardware: Slimbook, Nvidia RTX 4060 Ti y el modelo Qwen00:02:55 ¿Qué son realmente las Skills y por qué usarlas?00:04:18 Ejemplo práctico: Instalando una Skill para Docker00:04:58 Recomendación: La guía de Skills de Daniel Primo00:06:08 Generando un Dockerfile complejo para Rust en dos etapas00:07:34 Anatomía de una Skill: Front Matter, YAML y Markdown00:09:25 Cómo el agente gestiona los tokens y las habilidades00:10:48 Verificación del Dockerfile generado por la IA00:12:11 Trabajando con bases de datos: Skill de SQLite Expert00:13:24 Experiencia real: Revisando código Backend y Frontend00:15:38 Consultas en lenguaje natural sobre la base de datos00:17:40 Tipos de Skills: Percepción, Acción y Pensamiento Complejo00:19:47 Conclusiones: Programar sin programar y modelos locales00:20:29 Despedida y red de sospechosos habitualesMás información, enlaces y notas en https://atareao.es/podcast/796🌐 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
• ATA 795 OpenCode, el agente de IA que PROGRAMA por ti 11.05.2026 28min

  Si eres de los que piensa que para crear tus propias herramientas necesitas pasarte años estudiando sintaxis complejas o que estás vendido a lo que digan las grandes corporaciones de la Inteligencia Artificial, prepárate, porque hoy vamos a romper esos mitos con OpenCode.Democratizando el código con OpenCodeLa gran estrella de hoy es OpenCode. Imagina un agente de inteligencia artificial especializado en programación que no te obliga a usar un solo modelo. A diferencia de otras soluciones cerradas, OpenCode es de código abierto. Esto significa que tú tienes el control total: puedes conectarlo con modelos en la nube como Claude o GPT-4, o lo que es más emocionante para los que amamos el auto-alojamiento, puedes usarlo con modelos locales a través de Ollama. En el episodio de hoy, te cuento cómo he puesto a trabajar a este agente para crear, desde cero, una aplicación en Rust que descarga transcripciones de vídeos de YouTube. Yo solo le he dado las instrucciones de lo que quería conseguir y el agente se ha encargado de proponer el plan, elegir las librerías adecuadas (como YouTube Transcript o Anyhow) y escribir cada línea de código mientras yo grababa este podcast. ¡Es como tener un compañero de programación que nunca se cansa!El dilema de los tokens y el modelo híbridoPero no todo es magia. También te cuento mis "penas" con los tokens. Te explico una anécdota real donde un modelo de IA se puso a "pensar" demasiado para solucionar un problema sencillísimo con un script para evitar que mis pantallas se apagaran (usando Stasis). De aquí sacamos una lección fundamental: la importancia de los modelos híbridos. En este episodio te explico por qué deberías delegar las tareas más pesadas y repetitivas a modelos locales que corren en tu propio equipo (gratis y privados) y reservar la potencia de la nube solo para cuando necesites un razonamiento complejo. Además, exploramos OpenCode Go, una opción de bajo coste para acceder a modelos abiertos sin arruinarse.Planificación y Tests: La IA que piensa antes de actuarUna de las funciones que más me han volado la cabeza es la capacidad de OpenCode para diferenciar entre planificar y ejecutar.Seguridad y el futuro en contenedoresSi alguna vez has tenido una idea para una aplicación pero te daba pereza empezar o no sabías por dónde hincarle el diente, este episodio es la señal que necesitabas. Es el momento de recuperar esos proyectos del cajón y empezar a materializarlos.Capítulos para no perderte nada:00:00:00 El truco de los 5 segundos y David Marzal00:01:08 Fartons y Podcast: Experiencias y agradecimientos00:01:57 ¿Qué es OpenCode? Programar sin escribir código00:02:54 Caso práctico: Herramienta en Rust para transcripciones de YouTube00:05:10 Un agente de IA de código abierto y multimodelo00:07:05 La importancia de no estar atado a un solo proveedor00:07:44 Modelos híbridos: Cuándo usar IA local vs. nube00:09:12 El peligro de los tokens: Mi experiencia con Stasis y el modo sleep00:12:36 OpenCode Go: Suscripción y acceso a modelos abiertos00:13:24 Configurando Ollama en local para programar00:15:10 Refinando la herramienta: Mejoras en la descarga por defecto00:17:58 Probando diferentes modelos: Qwen, DeepSeek y Kimi00:20:18 Modos de OpenCode: Planificación frente a Ejecución00:21:44 Implementando tests unitarios y de integración con el agente00:23:43 Delegando tareas repetitivas en el desarrollo web00:25:24 Seguridad: El futuro de ejecutar agentes en contenedores00:26:14 Próximos pasos: Skills y recomendación de Web Reactiva00:26:59 Despedida y comunidad Atareao en TelegramMá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
• ATA 794 Cómo crear tus propias herramientas de IA (GRATIS y en local) 07.05.2026 25min

  Si en los últimos episodios te he hablado de las bondades de Open Web UI, hoy vamos a ensuciarnos las manos (de forma figurada, claro) para exprimir esta herramienta al máximo. No se trata solo de instalar un contenedor y ver qué pasa; se trata de convertir a tu inteligencia artificial en un asistente que realmente te conoce y tiene "superpoderes" gracias a herramientas personalizadas.Seguro que te ha pasado alguna vez: estás hablando con una IA y, de repente, parece que se le ha olvidado lo que le dijiste hace cinco minutos. Esto es lo que conocemos como el problema de la ventana de contexto. Los modelos tienen un límite de información que pueden procesar a la vez. En este episodio, te muestro cómo Open Web UI gestiona la memoria para que el asistente recuerde quién eres, cuáles son tus aficiones y hasta tus lenguajes de programación preferidos. Es fascinante ver cómo, tras una búsqueda en GitHub o en redes sociales, la IA es capaz de guardar esos detalles en su "cerebro" local para usarlos más adelante.Pero lo que de verdad me ha volado la cabeza es la posibilidad de crear herramientas (Tools). Imagina que necesitas calcular la distancia exacta entre dos ciudades para planificar una ruta de entrenamiento. Normalmente, la IA haría una búsqueda web más o menos precisa, pero ¿y si le pudiéramos enseñar a usar un script de Python específico para eso? En el podcast te cuento cómo la propia IA es capaz de programar su propia herramienta, dándote el código y las instrucciones para que la integres en tu interfaz. ¡Es el sueño de cualquier amante de la automatización!Además, tocamos un tema fundamental en los tiempos que corren: la privacidad y el coste. Las grandes tecnológicas se están dando cuenta de que mantener estos modelos cuesta una fortuna y ya estamos empezando a ver cómo suben cuotas o limitan el uso. Al trabajar en local, no solo te ahorras suscripciones, sino que te aseguras de que tus datos no salen de tu casa. Es soberanía tecnológica en estado puro.Lo que vamos a tratar en este episodio:00:00:00 - Introducción: Exprimiendo Open Web UI00:00:45 - Presentándome a mi propia IA local00:01:38 - La importancia de la memoria y el contexto en los LLM00:02:11 - Herramientas de búsqueda: ¿Qué sabe internet de Atareao?00:04:37 - Guardando información relevante en la memoria (RAG)00:05:04 - Consultas en tiempo real: El tiempo y el pronóstico00:06:20 - Ahorrando tokens: La importancia de ser conciso00:07:24 - Planificando un entrenamiento basado en datos meteorológicos00:10:02 - Cálculos de distancia y búsquedas web inteligentes00:11:54 - Crea tus propias herramientas (Tools) con Python00:14:32 - Configuración de herramientas personalizadas paso a paso00:16:12 - Integración de APIs externas (Nominatim) en local00:17:18 - Poniendo a prueba la memoria a largo plazo de la IA00:19:53 - Análisis de perfil de GitHub y lenguajes preferidos00:21:55 - Privacidad y ahorro: El fin de las subvenciones de las grandes Big Tech00:23:44 - De Google AI Studio a Open Web UI: El flujo de trabajo00:24:45 - Conclusiones y adelanto del próximo episodio: ¡Open Code!Te cuento también mi flujo de trabajo actual, cómo he pasado de herramientas en la nube como Google AI Studio a tenerlo todo bajo mi control con Open Web UI. Y ojo, que esto es solo el principio. En el próximo episodio abandonaremos un poco la interfaz de chat para meternos de lleno en Open Code, buscando siempre esa independencia tecnológica que tanto nos gusta.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
• ATA 793 Cómo elegir el modelo de IA ideal y por qué a veces se emborracha 04.05.2026 25min

  Hoy vamos a meternos de lleno en las tripas de la inteligencia artificial local, porque sigo dándole vueltas a una herramienta que me tiene completamente robado el corazón: OpenWeb UI.Seguramente habrás oído hablar de ChatGPT, Gemini o Claude. Son herramientas increíbles, pero tienen un problema: no son tuyas. En este episodio, y probablemente en el siguiente, quiero contarte cómo estoy consiguiendo que mi propia IA en local no solo iguale a estas opciones comerciales, sino que en muchos aspectos las supere, especialmente en algo que a veces olvidamos: la soberanía digital y la capacidad de organización.¿Por qué OpenWeb UI es un cambio de juego?Lo que me ha volado la cabeza de OpenWeb UI es cómo reúne lo mejor de cada casa. He estado probando decenas —y no exagero, de verdad, decenas— de modelos distintos estos días. Mi objetivo era claro: ver cuánto consumen, qué rapidez de respuesta tienen y, sobre todo, hasta qué punto puedo sustituir mi flujo de trabajo en la nube por algo que corra en mi propio hardware. Una de las funciones que más me han gustado es el sistema de carpetas. Poder asignar un modelo específico a una carpeta de proyectos de Rust, y otro modelo distinto para resúmenes de artículos, es una maravilla que me permite "cacharrear" con una precisión que no encontraba en Gemini o ChatGPT.El misterio de la IA que se "emborracha"¿Te ha pasado que estás hablando con una IA y de repente empieza a decir cosas sin sentido o se olvida de lo primero que le dijiste? Eso es lo que yo llamo "borrachera de datos", y la culpa la tiene la ventana de contexto. En este episodio te explico qué es exactamente este espacio de memoria a corto plazo del modelo. Me encontré con un problema frustrante: mi IA local parecía tener memoria de pez. Y después de mucho investigar, descubrí que Ollama, el servidor de modelos que utilizo, define por defecto una ventana de contexto muy pequeña, a veces de solo 2.048 o 4.096 tokens.Para que te hagas una idea (esta es la regla de la servilleta que cuento en el audio): 4.000 tokens equivalen a unas 5 o 6 páginas de texto. Si le pasas unas instrucciones iniciales largas (el system prompt), le haces un par de preguntas y la IA te responde, ¡pum!, se acabó el espacio. En cuanto llegas al límite, la IA empieza a descartar lo primero que le dijiste. Por eso parece que se olvida de quién es o de qué le habías pedido.Matemáticas para no volverse loco con la RAMCapítulos del episodio:00:00:00 Presentación: Exprimiendo OpenWeb UI00:01:21 El experimento: Probando decenas de modelos locales00:02:19 Organización y carpetas: La gran ventaja frente a ChatGPT00:03:53 El núcleo del episodio: Modelos y Prompts00:05:00 LLM FIT: Cómo encontrar el modelo ideal para tu hardware00:06:14 ¿Qué es la ventana de contexto y por qué es vital?00:07:08 El límite oculto de Ollama: ¿Por qué tu IA tiene memoria de pez?00:08:33 Automatización: Ollama Audit y scripts de personalización00:10:38 Cómo modificar el contexto y crear modelos custom00:11:42 Matemáticas de la RAM: ¿Cuántos tokens caben en tu equipo?00:13:00 Guía rápida: Ventanas de contexto recomendadas según la tarea00:14:23 El equilibrio: Peso del cerebro vs Memoria de trabajo (KV Cache)00:15:42 El idioma importa: Tokens en español vs Inglés00:16:35 Por qué 4.000 tokens se quedan cortos (System Prompt e Historial)00:18:27 La analogía de la servilleta: Ejemplos de uso del contexto00:20:12 Calidad vs Velocidad: ¿Qué modelo elegir?00:21:41 Organización real: Mis Prompts y carpetas en OpenWeb UI00:24:33 Soberanía digital y despedidaMá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
• ATA 792 Open WebUI, el ChatGPT PRO que puedes tener GRATIS y 100% local 30.04.2026 25min

  ¿Te has fijado en que el panorama de la inteligencia artificial está cambiando a pasos agigantados? Lo que hasta hace dos días era un campo de juegos gratuito, donde podíamos probarlo todo sin soltar un euro, se está transformando rápidamente en un servicio de suscripción más, como la luz o el teléfono. Pero no solo es una cuestión de dinero. Hay algo que me preocupa mucho más: tu privacidad y la propiedad de tus datos.En este episodio número 792 de Atareao con Linux, quiero invitarte a dar un paso adelante en tu camino hacia la soberanía digital. Vamos a hablar de cómo montar tu propio laboratorio de inteligencia artificial en casa, utilizando una herramienta que es, sencillamente, una maravilla: Open WebUI. Olvídate de depender de servidores externos para tareas sensibles; es hora de que el motor de la IA corra en tus propias máquinas.¿Por qué Open WebUI?Si ya has escuchado episodios anteriores, sabrás que soy un gran fan de Ollama para ejecutar modelos en local desde la terminal. Pero seamos sinceros: la terminal es fantástica para muchas cosas, pero para mantener una conversación fluida con un modelo de lenguaje, todos preferimos una interfaz visual. Open WebUI es ese "vestido elegante" que le ponemos a nuestros modelos locales. Es una interfaz web que, nada más verla, te va a resultar familiar porque se parece muchísimo a ChatGPT o Gemini, pero con una diferencia fundamental: tú tienes el control total.Personalización y diversión: El caso de Leslie WinkleUna de las cosas que más me apasiona de esta herramienta es su "Model Builder". No se trata solo de elegir un modelo como Llama 3 o Gemma y empezar a escribir. Puedes ir mucho más allá. En el podcast te cuento cómo he creado un modelo específico con la personalidad de Leslie Winkle, el personaje de Big Bang Theory. Le he dado instrucciones precisas sobre cómo comportarse, quiénes son sus aliados y quiénes sus enemigos. El resultado es una IA con la que puedo "pelear" intelectualmente y que me llama "cerebro de corcho". Es divertido, sí, pero también demuestra el poder de crear asistentes especializados para tareas concretas de tu trabajo o tu día a día.Características que marcan la diferenciaGestión de usuarios y grupos.Soberanía de datos con RAG.Búsqueda Web PrivadaSoporte para fórmulas y código.Capítulos del episodio:00:00:00 ¡Al rico modelo local! Introducción00:00:27 El fin de la era "gratis" en la IA comercial00:01:31 Privacidad y bolsillo: Las dos razones para el local00:02:42 Más allá de la terminal: Buscando la interfaz ideal00:03:47 Presentando Open WebUI: El cerebro de tu laboratorio00:05:21 ¿Qué es exactamente Open WebUI?00:06:28 Personalización extrema: Mi charla con Leslie Winkle00:08:11 Gestión de usuarios y permisos granulares00:09:48 PWA, Markdown y soporte para fórmulas matemáticas00:10:55 Model Builder: Crea tus propios expertos a medida00:12:12 Integrando Python y funciones avanzadas00:13:34 Buscando en la web de forma privada con SearXNG00:15:13 Integraciones en la nube y bases de datos vectoriales00:16:08 Un vistazo al panel de administración y consumo00:18:24 El arte del Prompting: Carpetas y roles de sistema00:20:38 Mi infraestructura: Podman, Traefik y contenedores00:22:56 Recursos, chuletas y el repositorio de GitHub00:24:12 Despedida y red de Sospechosos HabitualesMá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
• ATA 791 ¿Ollama o Llama.cpp? Cuál elegir para montar tu propia Inteligencia Artificial 27.04.2026 22min

  ¡Hola, muy buenas! Soy Lorenzo y hoy te traigo el episodio número 791 de Atareao con Linux. Si has estado siguiendo mis últimas aventuras tecnológicas, sabrás que me he sumergido de lleno en el fascinante mundo de los modelos de lenguaje locales. Sin embargo, a raíz de mis vídeos y artículos sobre Ollama, ha surgido una pregunta recurrente en la comunidad: ¿Por qué usar Ollama y no Llama.cpp directamente? ¿O es que acaso uno es mejor que el otro? En este episodio me he propuesto despejar todas tus dudas y, de paso, contarte algunas novedades sobre hardware que te van a dejar con la boca abierta.El origen: Entre amigos y tecnología en el Linux CenterTodo esto empezó a fraguarse en las recientes jornadas de Inteligencia Artificial que vivimos en el Linux Center junto a los amigos de Slimbook. Fue una experiencia increíble donde pude compartir charla con Alejandro López y Manuel Lemos. Ver el interés de la gente y cómo el curso se llenó por completo me dio una pista clara: todos queremos tener el control de nuestra propia IA. Alejandro, que es un gran impulsor de estos temas, me prestó un equipo que ha sido clave para mis pruebas actuales y del cual te hablo un poco más adelante en este audio.Llama.cpp: El quirófano de los tensoresPara entender la diferencia, hay que saber qué es cada cosa. Llama.cpp es el motor puro. Imagínate que es el motor de un coche de competición donde puedes ajustar hasta la última tuerca. Está escrito en C++ por Georgi Gerganov con un objetivo claro: el máximo rendimiento. Ollama: La experiencia de usuario elevada al máximoPor otro lado, tenemos a Ollama. Muchas veces se ven como rivales, pero la realidad es que Ollama utiliza Llama.cpp por debajo. La diferencia es que Ollama es un "envoltorio" o orquestador escrito en Go que nos facilita la vida de una manera brutal. Se encarga de gestionar la memoria de tu tarjeta gráfica (VRAM) de forma inteligente.Cacharreando con contenedores y personalidad propiaComo no podía ser de otra forma, yo he montado Llama.cpp usando Podman y Quadlets, integrándolo totalmente en mi flujo de trabajo. En este episodio te cuento cómo he configurado mi NVIDIA RTX 4060 Ti de 16GB para que vuele, permitiéndome usar contextos de hasta 128K.Hardware: NVIDIA y el silencio de las NPUUno de los grandes temas de este episodio es el hardware. Hago un repaso por las tarjetas de NVIDIA, desde la serie 30 hasta la potente serie 50. Pero la verdadera sorpresa ha sido el Slimbook One con NPU (Neural Processing Unit). La anatomía de los modelos: Rompiendo el código¿Alguna vez has visto nombres de modelos como "Mistral-7B-Instruct-v3-Q4_K_M.gguf" y te has sentido perdido?Capítulos del episodio para que no te pierdas nada:00:00 - Bienvenidos al episodio 791: Ollama vs Llama.cpp01:35 - Crónica de las jornadas de IA en el Linux Center con Slimbook03:34 - ¿Por qué hay tanta polémica entre Ollama y Llama.cpp?04:42 - Llama.cpp: El "quirófano" de los tensores y el rendimiento puro05:18 - Ollama: El orquestador que nos facilita la vida06:40 - Comparativa: ¿Qué hace uno que no haga el otro?07:59 - ¿Eres de IKEA o de fabricar tus propios muebles?09:00 - Cacharreando con Llama.cpp, Podman y Quadlets10:48 - Leslie: Mi IA con personalidad propia en OpenWeb UI12:44 - Cómo descargar modelos a mano con Rust HF Downloader13:50 - Hardware para IA: Guía rápida de tarjetas NVIDIA17:15 - La experiencia con el Slimbook One y su NPU integrada18:05 - Anatomía de un modelo: Entendiendo los nombres19:40 - La piedra de Rosetta de la cuantización21:08 - Conclusiones y próximos pasos con OpenWeb UIMá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
• ATA 790 ¡Exprime tu IA local! Domina Ollama desde la terminal 🚀 23.04.2026 21min

  ¡Hola! Soy Lorenzo y esto es Atareao con Linux. Bienvenidos al episodio número 790, la segunda entrega de nuestra serie dedicada a montar nuestro propio laboratorio de Inteligencia Artificial local.Antes de meternos en harina, quiero darte las gracias de todo corazón. El primer episodio de esta serie ha tenido una acogida espectacular, y eso me llena de satisfacción y me da muchísima energía para seguir compartiendo contigo todo este camino. Parece que no soy el único que tiene ganas de recuperar el control de sus datos y de jugar con estos modelos de lenguaje sin depender de servicios externos.En el episodio anterior estuvimos centrados en la infraestructura: montamos Ollama usando Quadlets y dejamos todo listo para empezar a funcionar. Pero hoy vamos a cambiar el tercio. Hoy vamos a dejar de hablar de configuraciones de sistemas para empezar a hablar, literalmente, con la inteligencia. Y lo vamos a hacer de la forma más pura y directa posible: a través de la terminal.Seguramente te preguntarás: "¿Pero Lorenzo, para qué voy a usar la terminal si ya hay interfaces web que son una maravilla?". Pues te lo cuento con todo el entusiasmo del mundo: para entender qué está pasando de verdad. En este episodio vamos a exprimir Ollama desde la línea de comandos, bajando al barro, porque hay opciones y configuraciones que en las interfaces gráficas a veces quedan ocultas o simplificadas. Si queremos ser verdaderos "cacharreros" de la IA, tenemos que saber qué pasa bajo el capó.Hardware y monitorización en tiempo realEn este episodio te cuento cómo estoy viviendo la experiencia con mi hardware. Estoy utilizando una tarjeta Nvidia GeForce RTX 4060 en un equipo Slimbook que va como un tiro. Te explico cómo monitorizo el uso de la GPU y cómo puedes ver, de forma casi mágica, el momento exacto en el que el modelo se carga en los 16 GB de memoria y empieza a consumir recursos. Es fascinante ver cómo el uso de la tarjeta pasa del 0% al 100% mientras la IA genera una respuesta para nosotros. Entender esta relación entre el hardware y el software es fundamental para saber qué modelos podemos ejecutar y cuáles nos van a mandar a "freír espárragos".Dominando los meta-comandos de OllamaA lo largo del audio, vamos a desgranar una serie de comandos que te van a convertir en un maestro de la IA local:Información detalladaPersonalidad y roles.Rendimiento puro.Creatividad bajo control.Capítulos del episodio:00:00:00 - Bienvenida y agradecimientos por la acogida00:00:40 - El laboratorio de IA: Recapitulando el episodio anterior00:01:34 - ¿Por qué bajar al barro con la terminal?00:03:31 - Preparando el entorno y monitorizando la GPU Nvidia00:05:00 - Flujo de trabajo: Arrancar el contenedor y el modelo00:05:35 - Comandos de ejecución, Podman y atajos útiles00:06:40 - Regalo: Una chuleta (cheat-sheet) para dominarlos a todos00:07:48 - Hablando con Ollama de forma interactiva00:08:24 - Meta-comandos: Descubriendo las tripas del modelo00:09:12 - Licencias y parámetros técnicos del modelo00:10:05 - Configurando el rol de experto desarrollador00:11:15 - Midiendo el rendimiento: Tokens por segundo00:12:00 - Modo silencioso y generación de scripts00:12:55 - Atajos de teclado y ayuda rápida00:13:35 - Ajustando la temperatura y la creatividad00:14:40 - Cómo guardar y cargar tus modelos personalizados00:15:20 - Poniendo a prueba a la IA: Verificación de código00:16:15 - Monitorización en tiempo real de CPU y GPU00:17:40 - Cómo elegir el modelo ideal según tu hardware00:19:08 - Próximos pasos: La REST API de Ollama00:20:30 - Despedida y consejos de vidaMá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
• ATA 789 Tu propio Laboratorio de IA (adios a las subscripciones) 20.04.2026 23min

  ¡Hola! Soy Lorenzo y esto es Atareao con Linux. Bienvenidos al episodio número 789, un episodio que marca el inicio de una aventura que me tiene especialmente emocionado: vamos a montar nuestro propio laboratorio de Inteligencia Artificial en local.Durante los últimos meses, y gracias a las "pullas" constructivas de amigos como Carlos Castillo de Reflex, RedFone o incluso mi archienemigo favorito Rafa de Leña al Mono, no he parado de darle vueltas a cómo exprimir la IA. Pero hay algo que me inquietaba: casi todo lo que hacía dependía de la nube. Por eso, tras cerrar el ciclo de Podman, he decidido que es el momento de tomar las riendas de nuestra soberanía digital y traernos los modelos de lenguaje a casa.¿Por qué quieres una IA local?Seguro que te lo has preguntado. ¿Para qué complicarse la vida si ya tienes Gemini o ChatGPT? Pues bien, en este episodio te cuento las tres razones fundamentales que me han llevado a este "cacharrreo" intensivo:Privacidad absoluta.Control de costes.Inmediatez.El Stack Técnico: Podman, Quadlets y OllamaNo esperes que te enseñe a instalar cosas "a lo bruto" en tu sistema operativo. Fiel a mi estilo, vamos a usar contenedores, pero con un giro de tuerca profesional. Te explico por qué he elegido Podman sobre Docker para este proyecto, centrándome en la seguridad del modo rootless y la limpieza que nos ofrece. Además, profundizamos en el uso de Quadlets para que nuestra IA sea un servicio más de Linux, perfectamente integrado con Systemd.Una serie para dominarlos a todosEste no es un episodio aislado. Hoy inauguramos una serie de 32 capítulos donde iremos de cero a cien. No me interesan los tutoriales de "IA en 5 minutos" que no enseñan nada. Aquí vamos a profundizar en:Crear un cerebro digital usando RAG (Generación Aumentada por Recuperación) con nuestros propios archivos Markdown.Desarrollar agentes y skills que realicen tareas por nosotros.Integrar el stack con hardware NVIDIA para sacar hasta el último teraflop de potencia.Automatizarlo todo con scripts en Rust, Python y mi querido shell Fish.Si te apasiona el open source y quieres dejar de ser un mero espectador de la IA para convertirte en el dueño de tu propia tecnología, este es tu sitio. ¡Prepárate porque nos lo vamos a pasar pipa!Contenido detallado del episodio:00:00:00 Introducción y el fin de la era Podman00:01:21 El empujón de Slimbook y el Linux Center00:02:15 El problema de depender exclusivamente de la nube00:03:15 El plan maestro: 32 episodios de IA práctica00:05:33 Tres razones para la IA local: Privacidad, pasta y latencia00:07:25 Filosofía "Juan Palomo": Exprimir los modelos con scripts00:08:08 El stack técnico: ¿Por qué Podman y no Docker?00:09:40 Ventajas del rootless y la seguridad en IA00:10:59 Quadlets: Integración total con Systemd00:11:53 Herramientas: Fish shell, Rust y Go al servicio de la IA00:13:20 Creando nuestra propia memoria digital (RAG)00:14:00 Estructura de directorios y repositorio Git00:15:37 El truco de los enlaces simbólicos para Quadlets00:16:02 Hardware: NVIDIA y el aprovechamiento de la GPU00:16:40 Desmenuzando el contenedor de Ollama00:17:54 QCTL: Mi herramienta para gestionar Quadlets fácilmente00:20:20 Comprobando que Ollama responde (CURL y API)00:21:15 Monitorización con NVTOP y VTOP00:22:13 Despedida y próximos pasos en el laboratorio localMá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
• ATA 788 Cuatro herramientas de IA para Spotify y YouTube 16.04.2026 18min

  ¡Hola! ¿Cómo estás? Soy Lorenzo y te doy la bienvenida a un nuevo episodio de Atareao con Linux. Hoy te quiero abrir las puertas de mi laboratorio personal para contarte algo que me tiene entusiasmado: cómo he conseguido que la inteligencia artificial y la automatización se conviertan en mis mejores aliadas para sacar adelante este proyecto.Las herramientas de la revoluciónPara que entiendas cómo funciona mi flujo de trabajo actual, te voy a desglosar las cuatro herramientas que se han vuelto imprescindibles en mi equipo:1. Whisper (de OpenAI): Es el punto de partida. Esta maravilla de la tecnología es capaz de escuchar mis audios y transcribirlos a texto con una precisión que da miedo. Gracias a que utilizo una tarjeta gráfica Nvidia y soporte para CUDA, el proceso es rapidísimo. Whisper no solo me ahorra tener que escribir notas a mano, sino que me da la base para todo lo que viene después.2. Google AI Studio y el poder de los Prompts: Una vez tengo la transcripción, el siguiente paso es pasarle ese texto a Google AI Studio. He diseñado un "prompt" (unas instrucciones) muy detallado que le dice a la IA exactamente qué necesito: que extraiga el minutaje de los temas tratados, que redacte una descripción amena para YouTube y Spotify, y que prepare los metadatos SEO para la web.3. Nano Banana (Gemini) y la generación de imágenes: Para las carátulas que ves en las plataformas, ahora confío plenamente en el modelo de generación de imágenes de Google. Aunque a veces es un poco testarudo con las dimensiones —yo le pido un tamaño y él me da otro—, la calidad visual es impresionante. Para domar a esta IA, he creado mis propios scripts en Fish Shell que se encargan de comprobar si la imagen es cuadrada o rectangular y de ajustarla automáticamente a lo que necesito para cada plataforma.4. Real-ESRGAN y el escalado inteligente: A veces, la imagen que genera la IA es demasiado pequeña para los estándares de calidad actuales. Aquí es donde entran en juego las redes neuronales de Real-ESRGAN. Esta herramienta es capaz de "inventarse" los detalles que faltan para agrandar una imagen sin que pierda nitidez.5. ImageMagick (o "Magic"): No podíamos olvidarnos de los clásicos. ImageMagick es la navaja suiza que utilizo para las conversiones finales, para optimizar el peso de las imágenes antes de subirlas a la web y para asegurar que todo cumple con los formatos estándar. Es una herramienta de terminal que todo amante de Linux debería conocer.Capítulos del episodio:00:00:00 La mejor inversión: Atareao.es00:01:38 Mi evolución técnica: Del hosting al VPS y Docker00:02:17 Los modelos de lenguaje entran en juego00:03:00 Resultados brutales con menos esfuerzo00:04:20 Herramienta 1: Whisper, el arte de transcribir audio00:05:11 Fish Shell: El alma de mis automatizaciones00:07:04 Herramienta 2: Google AI Studio y la magia de los Prompts00:08:41 Mi flujo de trabajo: Del guion al minutaje00:09:30 Herramienta 3: Nano Banana (Gemini) para crear carátulas00:10:50 Automatizando el formato de imagen con Fish00:12:00 Reals-ESRGAN: Escalando imágenes con redes neuronales00:13:50 Herramienta 4: ImageMagick (Magic), la navaja suiza00:15:41 El procesado de audio: Normalización y filtros00:16:45 Conclusiones: Automatizar para disfrutar más00:18:04 Despedida y red de podcastComo siempre digo, la vida son dos días y uno ya ha pasado, así que disfruta como si no hubiera un mañana y, si puede ser con Linux y "cacharreando" con estas herramientas, ¡mucho mejor! Un saludo y nos escuchamos pronto.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
• ATA 787 Tu terminal REACCIONA a todo. Eventos personalizados en Fish 13.04.2026 16min

  ¡Hola a todos! Bienvenidos una semana más a atareao con Linux. Hoy os traigo el "premio" que me guardé en el episodio 785. Si pensabas que tu terminal ya era lista, prepárate, porque hoy vamos a ver cómo dotarla de un sistema nervioso propio mediante los eventos personalizados en Fish.En este episodio nos centramos en dos herramientas brutales: emit y on-event. Te voy a explicar, de la forma más sencilla posible, por qué esto cambia las reglas del juego cuando te pones a automatizar tareas en tu servidor o en tu equipo de escritorio.¿Por qué deberías usar eventos en tus scripts? Limpieza absoluta: Olvídate de esos archivos .sh infinitos. Ahora puedes tener pequeñas funciones especializadas que solo actúan cuando ocurre algo concreto. Flexibilidad total: ¿Quieres añadir una nueva acción a un proceso que ya funciona? No toques el código original, simplemente crea una función nueva que escuche el mismo evento. Desacoplamiento: Es la palabra clave. Separamos la lógica de "qué ocurre" de la lógica de "qué hacemos cuando ocurre".Te cuento cómo he aplicado esto para monitorizar mis proyectos de Rust. Uso herramientas como inotifywait para que, en cuanto guardo un cambio en el código, se dispare una cadena de eventos: compilación, tests y despliegue en contenedores. Si algo falla por el camino, el sistema lo sabe y me avisa de inmediato. ¡Es como tener un asistente personal dentro de la shell!También hablamos de la introspección. Te enseño cómo consultar qué eventos tienes registrados y qué funciones están asignadas a cada uno mediante el comando Functions --handlers. Así nunca perderás el hilo de lo que está pasando en tu sistema.Si quieres llevar tu terminal al siguiente nivel y empezar a cacharrear de verdad con la automatización inteligente, este podcast es para ti.Contenido del episodio:00:00:00 Introducción: Lo mejor de Fish se quedó para el final00:01:28 Qué son los eventos y por qué van a simplificar tu vida00:02:40 Cómo declarar eventos con emit y on-event00:04:02 Ejemplo práctico: Notificaciones de escritorio y avisos en Telegram00:06:40 Las 3 grandes ventajas: Desacoplamiento, múltiples receptores y limpieza00:09:20 Introspección en Fish: Cómo ver tus handlers y eventos registrados00:11:05 Caso de éxito: Automatizando la compilación y despliegue de Rust00:13:58 Gestión de errores: Cómo evitar que un proceso falle en cascada00:15:14 Conclusión y despedida: ¡A cacharrear con los eventos!¡Espero que te lo pases pipa escuchándolo tanto como yo explicándolo! Al rico contenedor y... ¡nos escuchamos el jueves!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
• ATA 786 ¿Por qué WordPress sigue dominando internet? (Y cómo dominarlo tú) 09.04.2026 22min

  ¿WordPress es una porquería o es que no sabemos usarlo? Mi nuevo flujo con Podman¡Hola! Muy buenas, ¿cómo estás? Soy Lorenzo y hoy quiero que hablemos de tecnología, de pragmatismo y, sobre todo, de WordPress. Últimamente parece que está de moda criticar a WordPress entre los creadores de contenido. Que si es pesado, que si tiene vulnerabilidades, que si es tecnología del siglo pasado... Pero claro, cuando miras los números y ves que WordPress impulsa más del 42% de los sitios web del planeta, te das cuenta de que algo estarán haciendo bien.En este episodio número 786 de Atareao con Linux, quiero romper una lanza a favor de este CMS y, sobre todo, explicarte cómo he transformado mi forma de trabajar con él para que sea algo divertido, eficiente y, por encima de todo, profesional. Vamos a dejar de lado las críticas vacías y vamos a centrarnos en el "cacharrero" del bueno: montando un entorno de desarrollo con Podman, utilizando Valkey para que todo vuele y automatizando las tareas con una herramienta que me tiene fascinado: Just.WordPress: El gigante incomprendidoLo cierto es que entiendo las críticas cuando son razonadas. Es verdad que WordPress puede tener vulnerabilidades, pero ¿qué software masivo no las tiene? Al final, es una cuestión de números: cuanto más se usa algo, más se intenta atacar. Pero no podemos olvidar que grandes corporaciones, tiendas de e-commerce masivas e incluso la propia Casa Blanca confían en WordPress. Si estás buscando una oportunidad de negocio, aprender a dominar WordPress por dentro —creando tus propios temas y complementos— es una de las mejores inversiones que puedes hacer hoy en día.El salto a los contenedores con PodmanHoy en día, desarrollar sin contenedores me parece un error fundamental. Los contenedores te dan la libertad de usar exactamente la misma versión de PHP o MariaDB que tienes en tu servidor de producción, sin importar lo que soporte tu sistema operativo local. Y como no podía ser de otra forma, he montado todo este tinglado con Podman.Mi nuevo stack de desarrollo incluye: WordPress con PHP-FPM: Para un rendimiento óptimo. MariaDB: Nuestra base de datos de confianza. Valkey: El reemplazo de código abierto para Redis. Espectacular para cachear consultas y acelerar la web. Nginx: Como proxy inverso para gestionar imágenes, estilos y la conexión con PHP de forma eficiente.Contenido del episodio por capítulos: 00:00:00 Introducción y por qué critican a WordPress 00:01:22 WordPress: El gigante que domina internet 00:03:08 Más allá del blog: E-commerce y grandes empresas 00:03:40 WordPress como oportunidad de negocio y carrera 00:04:52 La historia de Atareao.es sobre WordPress (desde 2009) 00:06:30 De temas de terceros a un desarrollo propio complejo 00:07:57 Borrón y cuenta nueva: Buscando la sencillez 00:08:50 El error de no usar contenedores para desarrollar 00:10:03 Mi stack con Podman: PHP-FPM, MariaDB y Valkey 00:12:07 Just: El gestor de tareas que sustituye a Make 00:13:54 Automatizando con Just: Install, Start y Status 00:16:30 Entornos idénticos: De local a producción 00:17:15 Gestión inteligente de secretos y configuración de Nginx 00:19:23 Estrategia de copias de seguridad y restauración de la DB 00:20:26 Resumen: Un entorno profesional en cuatro pasos 00:22:17 Despedida y cierre del episodioMá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
• ATA 785 Tu Terminal ahora es mucho mas inteligente (gracias a Fish) 06.04.2026 19min

  ¡Hola a todos! Bienvenidos al episodio 785. Hoy nos metemos de lleno en las entrañas de FISH, una de las herramientas más potentes para cualquier amante de Linux. Si alguna vez has sentido que tu terminal podría trabajar un poco más por ti, este es tu episodio.Los eventos en FISH son como pequeños disparadores que te permiten ejecutar acciones automáticamente en respuesta a lo que haces. Vamos a ver casos de uso reales: desde cómo configurar alertas inteligentes hasta cómo evitar errores catastróficos. También descubrirás mi secreto personal para no volver a perder nunca más un comando largo que hayas borrado por error al presionar la combinación de teclas prohibida.Temas destacados:La diferencia entre FISH y otras shells clásicas.Cómo implementar un sistema de auditoría básica.Ejemplos prácticos para mejorar tu productividad diaria.Cómo manejar el portapapeles directamente desde la terminal.Índice:00:00:00 Introducción al episodio 78500:00:26 ¿Qué es FISH y por qué lo uso?00:02:33 El poder de los eventos en FISH00:04:49 ¿Dónde configurar tus eventos?00:08:42 Ejemplo 1: Avisos automáticos en proyectos RAST00:09:41 Ejemplo 2: Auditoría de comandos críticos00:10:59 Ejemplo 3: Manejo elegante de errores00:12:19 Ejemplo 4: Acciones al cerrar sesión00:13:35 Truco Pro: Recuperar comandos borrados con CTRL+C00:17:35 Conclusiones y próximos pasosEspero que disfrutes de este contenido tanto como yo al prepararlo. ¡Prepárate para llevar tu terminal al siguiente nivel!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
• ATA 784 Lo mejor de dos mundos. Despliega Docker Compose en Podman con Dockge 02.04.2026 17min

  ¿Es posible mantener la extrema sencillez de Dockge mientras aprovechamos la robustez y seguridad de Podman? La respuesta es un rotundo sí, y en este episodio te explico exactamente cómo lo he configurado en mi propia infraestructura.Llevo semanas explorando alternativas para la gestión de contenedores, pero siempre acabo volviendo a Dockge. Su capacidad para levantar un stack simplemente pegando un Docker Compose es imbatible para quienes disfrutamos probando nuevas herramientas cada día. Sin embargo, mi migración a Podman planteaba un reto: no quería perder esa agilidad ni tampoco comprometer la seguridad del sistema.En este podcast detalle mi "fórmula ganadora":Quadlets: Cómo he encapsulado Dockge y Traefik para que se comporten como servicios nativos del sistema.Seguridad Rootless: La ventaja de correr Dockge bajo un usuario sin privilegios, eliminando riesgos de escalada de privilegios.Persistencia: La gestión de volúmenes y cómo Dockge almacena los archivos Compose de forma transparente en el sistema de archivos.Hibridación: Mi estrategia para decidir qué servicios van en Quadlets y cuáles se quedan en Dockge.Además, comentamos características fundamentales como el terminal web interactivo incorporado, ideal para solventar problemas rápidos (como borrar un volumen rebelde) cuando estás fuera de casa y solo tienes una tablet a mano. Si te interesa el self-hosting, la administración de servidores Linux y quieres simplificar tu flujo de trabajo con contenedores, este episodio es para ti.Capítulos del episodio:00:00:00 Introducción y el dilema de la gestión de contenedores00:01:41 El miedo a la migración: De Docker a Podman00:02:46 La gran noticia: Dockge funcionando como Quadlet00:03:09 ¿Qué es Dockge? La alternativa sencilla a Portainer00:05:14 Características clave: Editor interactivo y terminal web00:06:09 Gestión remota: El uso de agentes y múltiples VPS00:07:33 Funciones avanzadas: De comandos Docker a Compose00:08:55 La ventaja competitiva: Podman Rootless y seguridad00:09:41 Anatomía de un Quadlet para Dockge00:10:45 Configuración de volúmenes y persistencia de Stacks00:11:24 Integración con Traefik y Health Checks en Podman00:12:22 Cómo gestionar tus archivos Compose y Dotfiles00:13:58 El gran debate: ¿Cuándo usar Quadlets vs Dockge?00:15:53 Conclusiones: Seguridad, simplicidad y futuro00:17:12 Despedida y comunidad Atareao con LinuxÚnete a la conversación en nuestro grupo de Telegram y descubre más 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
• ATA 783 El Poltergeist de Docker que casi borra toda mi información 30.03.2026 19min

  ¿Alguna vez has sentido el terror de un comando mal ejecutado?En este episodio número 783, te sumerjo en una historia real de "poltergeist" en Docker que me mantuvo en vilo durante horas. Te cuento cómo una serie de eventos desafortunados, mezclados con un poco de nerviosismo técnico, me llevaron a cometer uno de los errores más temidos por cualquier administrador de sistemas: un borrado masivo de volúmenes que no debía ocurrir.Hablamos a fondo sobre la arquitectura de servicios self-hosted. Te explico por qué prefiero mantener una base de datos independiente para cada aplicación, analizando los pros y contras en cuanto a consumo de recursos y flexibilidad de versiones. Esta decisión, que normalmente me ahorra problemas, fue el escenario de un comportamiento errático donde las imágenes de PostgreSQL empezaron a mutar de forma extraña, cambiando tamaños y arquitecturas sin intervención directa.A lo largo del audio, descubrirás cómo logré identificar al culpable (spoiler: Watchtower y WhatsApp Docker tienen mucho que ver) utilizando modelos de lenguaje como Gemini para realizar un análisis forense de los logs. Esta experiencia ha sido el empujón final que necesitaba para confirmar mi transición total hacia Podman.Lo que aprenderás en este episodio: La importancia de taguear correctamente las imágenes y evitar el uso de "latest". Cómo reaccionar (y cómo no hacerlo) ante un contenedor que entra en bucle de reinicio. Las ventajas críticas de Podman sobre Docker en la gestión de actualizaciones y rollbacks automáticos. El papel de la IA como asistente en la resolución de problemas técnicos complejos.Marcadores de tiempo:00:00:00 Introducción: Una historia de terror en Linux00:02:04 Mi estrategia: Un contenedor de base de datos por servicio00:03:19 El dilema del consumo vs. la independencia de versiones00:05:58 El inicio del caos: Notificaciones de Matrix y reinicios00:07:34 Investigando el fallo: ¿Versiones desalineadas o brujería?00:09:38 El misterio del Release Candidate y el engorde de imágenes00:11:24 El error fatal: Un "System Prune" sin prejuicios00:12:31 Análisis forense con Gemini: Encontrando al culpable00:13:36 El culpable revelado: WhatsApp Docker y Watchtower00:15:36 Reflexiones post-catástrofe: La migración definitiva a Podman00:16:40 Ventajas de Podman: Actualizaciones nativas y Rollbacks00:18:11 Despedida y red de podcastSi quieres compartir tus propias historias de terror o aprender más sobre el mundo Linux, únete a nuestra comunidad en Telegram buscando "Atareao con Linux". ¡Disfruta 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
• ATA 782 Buildah vs Dockerfile. La guía definitiva para construir imágenes 26.03.2026 18min

  ¡Hola! Soy Lorenzo y bienvenidos a un nuevo episodio de Atareao con Linux. Hoy te traigo una noticia importante: mi equipo personal ya es 100% libre de Docker. He completado la transición total al ecosistema de Podman, pero el camino no termina aquí. Ahora me toca enfrentarme a la migración de la infraestructura de producción de atareao.es, y en este proceso he descubierto el verdadero potencial de la construcción de imágenes con Buildah.En este episodio, exploramos por qué Buildah es el compañero perfecto para Podman. Te explico las razones detrás de su nombre y, lo más importante, cómo cambia las reglas del juego al permitirnos construir imágenes mediante scripting puro. Si te gusta el control total y la flexibilidad de Bash o Fish, Buildah te va a encantar.¿Qué vas a aprender en este episodio? Adiós a las capas infinitas: Cómo Buildah gestiona el sistema de archivos de forma directa y eficiente. Scripting vs. Declarativo: Las ventajas de usar un lenguaje imperativo frente al tradicional Dockerfile. Seguridad extrema: Mi caso de uso real creando un servidor WebDAV con Nginx en modo rootless y sin usuario root interno. Criterios de elección: Cuándo te conviene seguir usando Dockerfiles por compatibilidad y cuándo Buildah es la herramienta quirúrgica que necesitas.Hablamos de transparencia, control, eficiencia de capas y, por supuesto, de los desafíos técnicos que supone aprender una nueva forma de trabajar. Si eres un apasionado de los contenedores y quieres llevar tu productividad en Linux al siguiente nivel, no te puedes perder este análisis detallado.Capítulos: 00:00:00 Introducción: Adiós definitivo a Docker 00:01:13 El reto de migrar atareao.es a Podman 00:02:17 Construcción de imágenes: La pieza que faltaba 00:03:19 ¿Por qué se llama Buildah? Curiosidades y Naming 00:04:15 Diferencias filosóficas: Buildah vs Docker 00:05:40 El poder del Scripting en la creación de imágenes 00:07:54 Comparativa técnica: Transparencia vs Control 00:09:38 Eficiencia de capas y el "Squashing" nativo 00:11:32 Ventajas de Buildah: Pruebas atómicas y variables dinámicas 00:12:46 Inconvenientes: Dependencia del host y curva de aprendizaje 00:14:46 ¿Cuándo usar cada uno? Consejos para equipos personales y CI/CD 00:16:32 Caso práctico: WebDAV con Nginx, Rootless y sin Root 00:18:03 Conclusiones y próximos pasosMá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