Atareao con Linux

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 locales
Demo 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 episodio
00:00:00 Cambio de estrategia: ¿Por qué necesitas un agente?
00:03:36 Presentación de Lara y su cerebro local
00:05:32 Demo 1: Búsqueda y análisis de información en Internet
00:07:53 Demo 2: Multitarea paralela con subagentes
00:09:51 Demo 3: Recetas de cocina y compra inteligente
00:13:58 La importancia de la búsqueda semántica en tus notas
00:14:48 Demo 4: El sistema de notas y tareas conectadas
00:16:51 Demo 5: Controlando mis entrenamientos con Strava
00:19:14 De la teoría al caos: Demos aleatorias sin red
00:20:21 Demo 6: Noticias de tecnología e IA al día
00:22:29 Demo 7: Resumen inteligente de textos extensos
00:26:14 Taller presencial de Valencia: Trasteando con Hermes
00:28:51 Hermes vs OpenClaw: La experiencia real de Daniel Primo
00:29:52 Privacidad y hardware: Modelos ejecutados en CPU local
00:30:26 Cierre del episodio y comunidad Atareao

¡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 Rust
Para 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 directo
Durante 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 IA
Un 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 Habituales

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

En 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 Quadlets
Para 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 anterior
00:00:43 El problema de los modelos estáticos de IA
00:01:29 El ejemplo práctico: Preguntando el tiempo
00:03:20 Ahorro extremo de tokens con MCP
00:04:49 Taller de IA agéntica y automatización con Slimbook
00:06:22 Cacharreando con DeepSeek V4 Flash en OpenCode
00: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 errores
00:12:40 Cómo conectar un MCP a Open Web UI paso a paso
00:14:18 Probando la previsión meteorológica en vivo
00:15:37 El motor bajo el capó: Open-Meteo, Nominatim y Docker
00:17:25 Codegraph: Analizando código para ahorrar tokens
00:18:22 Próximo episodio: Guardar tareas persistentes con MCP To Do
00:19:48 Otros MCPs listos para el taller de IA
00:21:22 El futuro del podcast: RAG local, notas y más cacharreo
00:22:50 Despedida, enlaces de interés y cierre

Má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

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ácil
00:06:14 La analogía del nuevo empleado en tu empresa
00:07:38 El agente de IA como el gran director de orquesta
00:08:21 ¿Qué es el RAG? (Conocimiento en tiempo real sin fine-tuning)
00:11:17 Mi RAG propio en Rust para archivos Markdown
00: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 real
00:16:14 Mis servidores MCP: SearXNG, Invidious y listas de tareas
00:18:10 Skills: Ahorro de tokens y flujos de trabajo inteligentes
00:20:11 La matriz definitiva: Memoria, Manos y Manuales
00:22:04 De un chat reactivo a un colaborador activo (Mi asistente Hermes)
00:23:54 Próximos pasos, descargas de código y despedida

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

¿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 suficiente
Qué es OpenRouter y cómo usar 400+ modelos (algunos gratis)
Comparativa directa de precios, modelos, ventajas y desventajas
Cuál elegir según tu caso de uso
Caso práctico: cómo mejoré mi herramienta Shul con skills de Rust y React
Por qué las skills son el verdadero game-changer de los agentes de IA
Tambié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 dinero
02:30 — ¿Qué es OpenCode?
04:50 — OpenCode Go: la suscripción de $10/mes
08:20 — OpenRouter: el agregador de 400+ modelos
10:50 — Comparativa directa
13:00 — Caso práctico: mejorando Shul con Skills
16:00 — El poder de las Skills
19:00 — Conclusiones y cuál elegir
22:00 — Próximos episodios

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

Si 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!