Atareao con Linux

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

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

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