Atareao con Linux

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

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.

Durante el episodio de hoy te cuento exactamente cómo tengo desplegada esta solución en mi servidor doméstico.

Un detalle técnico fundamental que abordo en este episodio es el control y optimización del contexto.

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

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 Local

Ya 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 SQLite

A 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 natural

Capítulos:

• 00:00:00 El troleo a David y la importancia del feedback
• 00:00:41 Introducción a las Skills: Dale "poderes" a tu IA
• 00:01:14 Repaso a OpenCode y el paso a la soberanía digital
• 00:02:11 Mi hardware: Slimbook, Nvidia RTX 4060 Ti y el modelo Qwen
• 00:02:55 ¿Qué son realmente las Skills y por qué usarlas?
• 00:04:18 Ejemplo práctico: Instalando una Skill para Docker
• 00:04:58 Recomendación: La guía de Skills de Daniel Primo
• 00:06:08 Generando un Dockerfile complejo para Rust en dos etapas
• 00:07:34 Anatomía de una Skill: Front Matter, YAML y Markdown
• 00:09:25 Cómo el agente gestiona los tokens y las habilidades
• 00:10:48 Verificación del Dockerfile generado por la IA
• 00:12:11 Trabajando con bases de datos: Skill de SQLite Expert
• 00:13:24 Experiencia real: Revisando código Backend y Frontend
• 00:15:38 Consultas en lenguaje natural sobre la base de datos
• 00:17:40 Tipos de Skills: Percepción, Acción y Pensamiento Complejo
• 00:19:47 Conclusiones: Programar sin programar y modelos locales
• 00:20:29 Despedida y red de sospechosos habituales

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

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 OpenCode

La 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íbrido

Pero 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 actuar

Una 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 contenedores

Si 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 Marzal
• 00:01:08 Fartons y Podcast: Experiencias y agradecimientos
• 00:01:57 ¿Qué es OpenCode? Programar sin escribir código
• 00:02:54 Caso práctico: Herramienta en Rust para transcripciones de YouTube
• 00:05:10 Un agente de IA de código abierto y multimodelo
• 00:07:05 La importancia de no estar atado a un solo proveedor
• 00:07:44 Modelos híbridos: Cuándo usar IA local vs. nube
• 00:09:12 El peligro de los tokens: Mi experiencia con Stasis y el modo sleep
• 00:12:36 OpenCode Go: Suscripción y acceso a modelos abiertos
• 00:13:24 Configurando Ollama en local para programar
• 00:15:10 Refinando la herramienta: Mejoras en la descarga por defecto
• 00:17:58 Probando diferentes modelos: Qwen, DeepSeek y Kimi
• 00:20:18 Modos de OpenCode: Planificación frente a Ejecución
• 00:21:44 Implementando tests unitarios y de integración con el agente
• 00:23:43 Delegando tareas repetitivas en el desarrollo web
• 00:25:24 Seguridad: El futuro de ejecutar agentes en contenedores
• 00:26:14 Próximos pasos: Skills y recomendación de Web Reactiva
• 00:26:59 Despedida y comunidad Atareao en Telegram

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 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 UI
• 00:00:45 - Presentándome a mi propia IA local
• 00:01:38 - La importancia de la memoria y el contexto en los LLM
• 00: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óstico
• 00:06:20 - Ahorrando tokens: La importancia de ser conciso
• 00:07:24 - Planificando un entrenamiento basado en datos meteorológicos
• 00:10:02 - Cálculos de distancia y búsquedas web inteligentes
• 00:11:54 - Crea tus propias herramientas (Tools) con Python
• 00:14:32 - Configuración de herramientas personalizadas paso a paso
• 00:16:12 - Integración de APIs externas (Nominatim) en local
• 00:17:18 - Poniendo a prueba la memoria a largo plazo de la IA
• 00:19:53 - Análisis de perfil de GitHub y lenguajes preferidos
• 00:21:55 - Privacidad y ahorro: El fin de las subvenciones de las grandes Big Tech
• 00:23:44 - De Google AI Studio a Open Web UI: El flujo de trabajo
• 00: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

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 RAM

Capítulos del episodio:

• 00:00:00 Presentación: Exprimiendo OpenWeb UI
• 00:01:21 El experimento: Probando decenas de modelos locales
• 00:02:19 Organización y carpetas: La gran ventaja frente a ChatGPT
• 00:03:53 El núcleo del episodio: Modelos y Prompts
• 00:05:00 LLM FIT: Cómo encontrar el modelo ideal para tu hardware
• 00: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ón
• 00:10:38 Cómo modificar el contexto y crear modelos custom
• 00: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 tarea
• 00: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és
• 00: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 contexto
• 00:20:12 Calidad vs Velocidad: ¿Qué modelo elegir?
• 00:21:41 Organización real: Mis Prompts y carpetas en OpenWeb UI
• 00:24:33 Soberanía digital 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

¿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 Winkle

Una 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 diferencia

• Gestión de usuarios y grupos.
• Soberanía de datos con RAG.
• Búsqueda Web Privada
• Soporte para fórmulas y código.

Capítulos del episodio:

• 00:00:00 ¡Al rico modelo local! Introducción
• 00:00:27 El fin de la era "gratis" en la IA comercial
• 00:01:31 Privacidad y bolsillo: Las dos razones para el local
• 00:02:42 Más allá de la terminal: Buscando la interfaz ideal
• 00:03:47 Presentando Open WebUI: El cerebro de tu laboratorio
• 00:05:21 ¿Qué es exactamente Open WebUI?
• 00:06:28 Personalización extrema: Mi charla con Leslie Winkle
• 00:08:11 Gestión de usuarios y permisos granulares
• 00:09:48 PWA, Markdown y soporte para fórmulas matemáticas
• 00:10:55 Model Builder: Crea tus propios expertos a medida
• 00:12:12 Integrando Python y funciones avanzadas
• 00:13:34 Buscando en la web de forma privada con SearXNG
• 00:15:13 Integraciones en la nube y bases de datos vectoriales
• 00:16:08 Un vistazo al panel de administración y consumo
• 00:18:24 El arte del Prompting: Carpetas y roles de sistema
• 00:20:38 Mi infraestructura: Podman, Traefik y contenedores
• 00:22:56 Recursos, chuletas y el repositorio de GitHub
• 00:24:12 Despedida y red 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

¡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 Center
Todo 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 tensores

Para 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áximo

Por 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 propia

Como 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 NPU

Uno 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.cpp
• 01:35 - Crónica de las jornadas de IA en el Linux Center con Slimbook
• 03: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 puro
• 05:18 - Ollama: El orquestador que nos facilita la vida
• 06: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 Quadlets
• 10:48 - Leslie: Mi IA con personalidad propia en OpenWeb UI
• 12:44 - Cómo descargar modelos a mano con Rust HF Downloader
• 13:50 - Hardware para IA: Guía rápida de tarjetas NVIDIA
• 17:15 - La experiencia con el Slimbook One y su NPU integrada
• 18:05 - Anatomía de un modelo: Entendiendo los nombres
• 19:40 - La piedra de Rosetta de la cuantización
• 21:08 - Conclusiones y próximos pasos con OpenWeb UI

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