Atareao con Linux

Episodios

• ATA 814 Automatiza el OCR en Linux con modelos de lenguaje locales 16.07.2026 28m

  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 pantalla2:00 - Motivación: running, Hermes y el pipeline completo4:00 - Captura y preprocesamiento con ImageMagick6:30 - Operaciones clave: normalize, threshold, deskew y sharpen8:30 - Pipelines personalizados según el tipo de imagen10:30 - Tesseract: instalación, modos y diccionarios14:00 - ocr_ai.py: detección automática del contenido18:00 - Corrección con Llama 3.2 y prompts específicos23:00 - Monitorización de directorios y automatización24:30 - Consejos prácticos y cierreMá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 813 Implementé un cazador de ofertas con IA 13.07.2026 33m

  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 Artificial00:01:22 ¿Para qué sirve extraer datos? Ejemplos prácticos00:02:42 El gran talón de Aquiles del scraping tradicional00:04:31 La revolución de la IA: Entender la web sin saber HTML00:07:36 Los problemas habituales: Selectores rotos y webs dinámicas00:10:00 Cómo un modelo de lenguaje (LLM) procesa la información00:13:17 Cuándo elegir scraping clásico vs. scraping con IA00:15:28 Comparación de costes: Enfoque clásico, IA local e IA en la nube00:17:19 ¿Qué modelos usar? Pruebas con Llama, Qwen, Mistral y DeepSeek00:18:19 Detrás de escena: Mi script de Python y la limpieza del HTML00:21:05 Creando el prompt perfecto para extraer un JSON estructurado00:24:34 Ejemplo real: Comparativa paralela entre tiendas00:28:38 Diseñando un vigilante de ofertas automatizado (24/7)00:30:17 Casos de uso prácticos y mejoras para evitar bloqueos00:32:02 Cierre y detalles del próximo tutorial de scrapingMá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 812 ¿La terminal más espectacular de Linux? La he probado y tengo un dilema 09.07.2026 26m

  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 bloquesWave 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 TerminalBloques de Visor de ArchivosBloques WebBloques de EditorBloques de Inteligencia ArtificialLa magia de los Layouts y los espacios de trabajoOtro de los grandes aciertos de Wave es la posibilidad de guardar y gestionar tus disposiciones de pantalla o "Layouts". SSH Durable: Conexiones indestructibles para administradoresSi 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 privacidadLa 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 Wave00:02:11 ¿Qué es Wave? ¿Hacía falta otra terminal Open Source?00:03:41 El concepto revolucionario de los bloques00:06:07 Los 5 tipos de bloques: terminal, visor, web, editor e IA00:08:43 Cómo moverte entre bloques como un profesional00:09:43 Creando tus propios espacios de trabajo (Layouts)00:13:20 Renderizado gráfico y el explorador de archivos integrado00:16:30 Inteligencia Artificial nativa y modelos locales00:18:00 Extendiendo la terminal con TypeScript y React00:20:47 SSH durable: conexiones indestructibles que sobreviven a todo00:22:13 Gestor de conexiones y contraseñas seguro00:23:11 Trucos rápidos y por qué me sigo quedando con Kitty00:25:24 Despedida y dónde encontrarnos para seguir cacharreandoMá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 811 El secreto para que Hermes trabaje el tripe (y te cueste mucho menos) 06.07.2026 27m

  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 caraPara entender la magia de los subagentes, primero tenemos que hablar del principal cuello de botella de los modelos de lenguaje: la ventana de contexto. ISi 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 rendimientoCostes disparadosAsfixia 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 totalTerminal independienteHerramientas restringidas (Toolsets)Modelos flexiblesCuando 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 episodioSi 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 Hermes00:01:10 ¿Qué es un subagente y por qué lo necesitas?00:03:21 El problema del contexto y cómo solucionarlo00:05:15 Los tres pilares: Objetivo, Contexto y Herramientas00:06:19 La regla de oro: ¿Delegar o ejecutar código directamente?00:08:19 Cómo definir tareas de forma específica y segura00: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 paralelo00:16:30 Límites de configuración: Concurrencia y profundidad de agentes00:19:40 El futuro de Hermes: Delegación síncrona vs. asíncrona00:21:54 Casos de uso reales y errores comunes que debes evitar00:24:02 Conclusiones y un adelanto sobre RAG y Ollama00:25:58 Despedida y canales de la comunidad🚀 Dos experimentos prácticos que vas a escuchar hoyEn 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
• ATA 810 Las 3 herramientas que van a cambiar tu terminal Linux para siempre 02.07.2026 24m

  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: FZFLa 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 milisegundosLa 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 superpoderesLa 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 definitivaLo 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 episodioAquí tienes la estructura del episodio para que puedas moverte cómodamente por el contenido:00:00:00 Introducción y el tridente de la terminal00:01:22 FZF: El buscador difuso interactivo00:03:00 Atajos de teclado esenciales para FZF00:08:16 El autocompletado mágico de FZF00:09:09 Ripgrep (rg): Búsquedas a la velocidad de la luz00:12:47 Combinando Ripgrep y FZF00:14:26 Bat: El comando "cat" con superpoderes00:18:07 Armando el tridente: Cómo combinar las tres herramientas00:19:48 Casos prácticos: Explorar commits, matar procesos y gestionar notas00:21:49 El ecosistema completo de 5 herramientas00:23:19 Integración con IA, despedida y conclusionesMá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 809 Deja de subir tus PDFs a ChatGPT. Crea tu propia IA ya 29.06.2026 27m

  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 dilemaPara 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 artificialA 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 ingestaEl troceado (o chunking)Los embeddings y vectoresLa base de datosLa búsqueda híbridaHerramientas listas para usar y errores que debes evitarSi 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 episodio00:00:00 Introducción y de qué va este episodio00: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 respuesta00: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 exacta00:14:50 Re-ranking: Ordenando los resultados por relevancia00:15:53 El Stack: Ollama, PostgreSQL, pgvector y Podman00:17:25 Alternativas vectoriales: ParadeDB, ChromaDB y Qdrant00:18:36 Manos a la obra con Python y Streamlit00:20:53 OpenWeb UI: La alternativa con RAG integrado y sin código00:21:42 Cómo saber si funciona: El método de las 20 preguntas00:22:51 Errores comunes que debes evitar al montar tu RAG00:23:55 Lo que viene: GraphRAG y RAG agéntico00:24:44 Resumen final 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 808 Por qué deberías dejar de usar Cron hoy mismo (y qué uso yo) 25.06.2026 27m

  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 TimersCon 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áticosGestión inteligente de la persistenciaControl de dependenciasAleatorización horariaLa anatomía de una tarea en SystemdPara 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 usuarioPero 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 audio00:00:00 Introducción y el adiós definitivo a Cron00:01:43 Los fallos silenciosos de Cron: Logs, reintentos y dependencias00:03:06 Las grandes ventajas de usar Systemd Timers00:05:21 La anatomía de la automatización: Timer y Servicio00:06:48 Configuración de la sección [Timer], OnCalendar y persistencia00:07:55 Tareas relativas: OnBootSec y aleatorización de tiempos00:10:00 Comandos de systemctl para gestionar tus tareas programadas00:10:33 Ejemplos prácticos en el sistema: Backups y limpiezas00:12:13 Notificaciones de escritorio e integración con el entorno gráfico00:14:11 Timers de usuario: Automatización segura sin usar root o sudo00:15:25 El truco de Linger para mantener tareas activas en VPS00:16:53 Sincronización continua de notas y cambio automático de fondo00:20:07 Cómo ver los logs y depurar fallos de forma sencilla con journalctl00:21:25 Evita estos errores típicos y valida con systemd-analyze00:24:51 El futuro de la automatización, modelos de lenguaje 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 807 Configura Hermes Agent de verdad (lo que nadie te cuenta) 22.06.2026 31m

  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 tokensAquí 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 AgenteEn 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áticasPor ú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 Agent00:01:26 El problema de los tutoriales básicos e instalación00:03:00 Configuración inicial y la sangría de tokens00:04:47 Archivos clave y estructura interna de Hermes00:05:56 Creando "Skills" personalizadas y configurando API Keys00:08:15 Perfiles aislados (Profiles): Qué son y por qué los necesitas00:11:00 Cómo clonar y gestionar tus perfiles sin romper nada00:13:35 soul.md: Diseñando el "Alma" y el tono de tu asistente00:15:28 memory.md: El gran desafío de la memoria y el RAG en Rust00:17:38 Expandiendo capacidades con MCP y conversión de voz00:20:47 Llevando tu agente a Telegram con Cron y Kanban integrado00:27:18 Reglas de oro para optimizar tu contexto y despedida
• ATA 806 No memorices más comandos. Que Linux y tu IA trabajen para ti 18.06.2026 26m

  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 comandos00:01:33 El problema con Hermes: Por qué las IA también se despistan00:03:04 ¿Qué es Just y cómo funciona?00:04:59 Cómo instalar Just en Linux00:05:31 Comparativa: Just contra Make y Task00:06:42 Gestión de variables, argumentos y funciones00:08:49 Atributos de receta para afinar su comportamiento00:10:00 El comportamiento de las líneas y el poder del Shebang00:11:00 Funciones integradas y ajustes globales00:12:00 Operadores, expresiones y dependencias complejas00:13:00 Usando intérpretes alternativos (Bash, Python, Node) en Just00:14:18 Recetas normales frente a recetas Shebang y scripts00:15:33 Módulos e importación de recetas externas00:16:38 El selector interactivo con búsqueda difusa (just choose)00:17:37 Alias, grupos y autocompletado en tu shell00:18:09 Casos prácticos de uso real (Sysadmin, Docker, Backups)00:19:18 Documentación viva y ejecutable para todo el mundo00:20:17 Control de versiones con Git y límites de Just00:21:10 Una historia de pereza, Hermes, deporte y OCR que se olvida00:22:59 Conclusiones: Simplifica tu vida con este ejecutor de comandos00:24:58 Cierre del episodio 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 805 El fin de los programadores? Qué es el Vibe Coding y cómo te cambia la vida 15.06.2026 32m

  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 EngineeringPara 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éntimosA 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 CodePor otro lado, si eres de los míos y te apasiona el código abierto:• OpenCode.• Cline.• OpenHands • AiderEl lado oscuro: Las trampas de la falsa seguridadNo 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 juegoCapí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 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 804 El editor que uso en mis servidores (y no es NeoVim) 11.06.2026 30m

  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 muscularTengo 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 RustAquí 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) flexible4. 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 Artificial00: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 servidores00:06:23 Primeros pasos con Helix: el tutor y las diferencias con Vim00:09:34 Pantalla dividida, multicursor y velocidad extrema00:10:54 Temas, resaltado de sintaxis de serie y comandos00:15:12 Mis propias herramientas: renderizar Markdown en terminal con mkdr00:18:40 Navegación estilo Wiki y otras ventajas de mkdr00:20:18 id3click: gestionando etiquetas MP3 sin depender de terceros00:21:52 Dándole voz a Cloe: raslet y la API de Microsoft Edge TTS00:24:35 susurros: generación de voz 100% en local con Rust00:26:55 El futuro: ssrs (Whisper en Rust) y conclusiones00:28:35 Recomendación de podcast: Legalmente Productivos 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 803 Planifica tu menú y compra con IA. RAG, MCP y Skills para humanos 08.06.2026 26m

  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 vida00:01:42 El ejemplo práctico: Automatizar nuestro menú semanal00:03:51 La fatiga de decisión y por qué la disciplina humana falla00:05:38 Mi caja de herramientas: 4 MCPs (Model Context Protocol)00:06:58 Buscando comida con IA: El RAG semántico de 1700 recetas00:08:45 Búsqueda híbrida y embeddings económicos sin usar GPU local00:10:00 Simplificando las comidas: El papel de los "Skills"00:11:58 Organizando la base de datos de manera sencilla con SQLite00:13:31 Lógica difusa: Evitando duplicados en la lista de la compra00:15:23 Creando PDFs bonitos con Typst (la alternativa moderna a LaTeX)00:17:03 Demostración en directo: Generando el menú de la semana00:19:12 Automatización total: Generación automática de menús con Cron00:20:19 Revisión del menú, las recetas y la alternativa local con Ollama00:23:12 De vuelta al "cacharrero" de Linux: Helix, mkdr y Podcli00:24:51 Próximos episodios: Instalación desde cero a producción de Hermes00:25:38 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 802 Conectado Hermes Agent a Internet y YouTube 04.06.2026 27m

  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 publicidadLa 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íaLa 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 paralelosLo 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 DockerPara 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 digital00:01:40 ¿Qué es un MCP (Model Context Protocol)?00:03:26 SearXNG: Tu propio motor de búsqueda privado y sin anuncios00:05:53 Poniendo a prueba las búsquedas web con Hermes00:07:32 Cómo está montada la infraestructura de búsqueda con Docker00:08:48 Automatización real: Creación de documentos con información web00:09:38 Invidious: YouTube sin publicidad y sin rastreo00:11:43 Buscando y analizando vídeos de YouTube con Hermes00:16:20 Superpoderes combinados: Búsqueda web + YouTube00:20:40 Por qué autoalojar todo en contenedores Docker independientes00:22:04 Analizando la recomendación razonada de la IA para aprender Rust00:24:09 Próximo episodio: Planificación de menús y bases de datos vectoriales00:25:09 Taller presencial en Linux Center de Slimbook (¡ven a cacharrear!)00:26:00 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 801 Hermes Agent y subagentes en directo. ¿Qué puede salir mal? 01.06.2026 31m

  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 27m

  ¡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 24m

  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 25m

  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 24m

  ¿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 21m

  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 28m

  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