¡Tu IA es TONTA! Dale manos y cerebro

Llevamos un par de años escuchando hablar de las maravillas de la Inteligencia Artificial. Que si es capaz de escribir código por ti, que si redacta correos electrónicos de forma impecable, que si te resume textos infinitos en un abrir y cerrar de ojos… Todo eso está muy bien, y no te voy a negar que resulta espectacular la primera vez que lo ves. Pero en cuanto intentas dar un paso más allá y llevar la IA al mundo real para que te ayude en tu día a día, de forma verdaderamente autónoma, te das de bruces con la cruda realidad. La realidad es que, tal y como nos las venden, las inteligencias artificiales tradicionales son increíblemente limitadas. En muchos aspectos, son tontas. Sí, lo he dicho bien: son tremendamente ineficientes cuando se trata de integrarse en nuestros flujos de trabajo locales. Hoy nos vamos a meter de lleno en el barro del cacharreo para desgranar por qué ocurre esto y, sobre todo, cómo podemos solucionarlo construyendo nuestro propio «ecosistema agéntico» en local, sin depender de servicios de terceros y utilizando herramientas abiertas.

0:00 / 0:00

El triple aislamiento de los modelos de lenguaje actuales

Para entender cómo podemos mejorar nuestra relación con la Inteligencia Artificial, primero tenemos que comprender cuáles son las limitaciones que arrastran de fábrica. Los Modelos de Lenguaje Grande (los famosos LLM) son, en esencia, motores estadísticos de predicción de texto. Han sido entrenados con montañas gigantescas de datos y son capaces de adivinar qué palabra debería ir después de otra con una precisión asombrosa. Sin embargo, carecen de tres capacidades fundamentales que cualquier colaborador humano tiene desde su primer día de trabajo. Yo lo llamo el triple aislamiento.

El aislamiento temporal

Cuando un modelo de lenguaje termina su proceso de entrenamiento, su conocimiento se congela por completo en ese preciso instante. Si un modelo se entrenó en una fecha concreta, todo lo que haya sucedido en el mundo a partir de ese segundo simplemente no existe para él. No sabe si ha salido una nueva versión de tu distribución de Linux favorita, no conoce las últimas actualizaciones de seguridad y, por supuesto, no tiene ni la más remota idea de lo que escribiste ayer en tus notas personales. Está atrapado en el pasado de forma irremediable, a menos que el proveedor del servicio gaste millones de dólares en volver a entrenarlo, lo cual no ocurre todos los días.

El aislamiento del entorno

Un LLM es un lector pasivo. Vive dentro de una caja de texto en una página web o detrás de una API en la nube. No sabe qué hora es, no sabe qué sistema operativo estás usando, no puede ver los archivos que tienes guardados en tu disco duro y no tiene forma de comunicarse con otros servicios de tu red local. Si le pides que te organice una carpeta con imágenes o que consulte si tienes contenedores Docker caídos en tu servidor local, no puede hacer absolutamente nada. Está completamente ciego respecto a lo que le rodea y es incapaz de interactuar con el mundo físico o digital por sí mismo.

El aislamiento del proceso

Los modelos estándar no saben «cómo» hacer las cosas de acuerdo a tus preferencias personales o flujos de trabajo específicos. Desconocen los procedimientos que tú sigues para, por ejemplo, redactar un artículo para tu blog, preparar el guion de un vídeo o gestionar tus tareas pendientes. No tienen memoria de proceso. Cada vez que abres un chat nuevo, tienes que volver a explicarle todo el contexto desde el principio, lo cual resulta agotador, ineficiente y consume una cantidad absurda de tiempo y recursos.

Cuando intentas que una IA aislada en el tiempo, en el entorno y en el proceso trabaje para ti, lo único que consigues es frustración. Si no sabe algo sobre tu proyecto privado, en lugar de decir «no lo sé», empezará a inventarse datos, nombres de funciones y configuraciones con una seguridad aplastante. Es lo que en el mundillo llamamos «alucinaciones», y te aseguro que pueden arruinarte una tarde de desarrollo en un santiamén.

La analogía del nuevo empleado: Cómo estructurar las soluciones

Para romper este triple aislamiento y transformar una IA pasiva en un colaborador activo que trabaje a nuestro lado de forma autónoma, necesitamos dotar al sistema de tres elementos clave. Para que lo entiendas de la forma más sencilla y divulgativa posible, me gusta utilizar la analogía de la contratación de un nuevo programador o empleado para tu equipo de trabajo.

Imagínate que publicas una oferta de empleo y seleccionas al mejor candidato disponible. El lunes por la mañana, este nuevo empleado cruza la puerta de tu oficina listo para darlo todo. Sin embargo, para que empiece a ser productivo de verdad, vas a necesitar proporcionarle tres cosas esenciales:

La formación previa y la experiencia (Habilidades / Skills): Esto es lo que el empleado ya trae aprendido en su propio cerebro. Sabe cómo programar, entiende la lógica de la informática, habla idiomas y sabe cómo estructurar un documento de texto. En nuestro ecosistema agéntico, esto equivale a las Skills o habilidades procedimentales que le enseñamos a nuestra IA.
La documentación de la empresa (RAG / Conocimiento factual): Por muy buen programador que sea tu nuevo fichaje, si no le das los manuales internos, el histórico del proyecto y las guías de estilo de tu empresa, estará completamente perdido. Necesita saber qué habéis hecho hasta ahora y bajo qué reglas jugáis. En nuestro sistema de IA, esto es el RAG (Generación Recuperada por Búsqueda), que actúa como la base de conocimiento privado y actualizado.
Las herramientas y accesos de trabajo (MCP / Interacción con el entorno): Tu programador puede ser un genio y haberse leído todos los manuales de tu empresa de memoria, pero si no le das un ordenador con teclado, acceso a los servidores, credenciales para la base de datos y permisos para enviar correos, no podrá escribir ni una sola línea de código útil. Estará de brazos cruzados. En el mundo de la IA, esto equivale al Model Context Protocol (MCP), que proporciona las «manos» y las herramientas necesarias para que la IA actúe en el mundo real.

¿Qué pasa si nos falta alguna de estas tres patas en nuestra mesa de trabajo?

Sin Skills (Habilidades): El empleado tiene acceso a todos tus manuales y a los servidores, pero no sabe programar ni estructurar tareas. No sabrá cómo empezar un proyecto ni qué pasos lógicos seguir. Está completamente vendido.
Sin RAG (Conocimiento): El empleado sabe programar de maravilla y tiene acceso a las herramientas, pero no conoce tu empresa. Trabajará basándose en teorías genéricas, cometiendo errores constantemente porque ignora cómo funciona tu negocio por dentro.
Sin MCP (Herramientas): El empleado es un genio y conoce tu empresa al dedillo, pero no puede tocar nada. Solo puede darte consejos teóricos a través de una pantalla de chat, obligándote a ti a hacer todo el trabajo manual de copiar, pegar y ejecutar comandos.

Como ves, si queremos un asistente agéntico real, necesitamos orquestar estas tres tecnologías en nuestro propio host local para que colaboren entre sí de forma armoniosa.

Primera pata: RAG, la memoria dinámica de tu asistente

Hablemos en primer lugar de la memoria de nuestro asistente, de ese conocimiento factual que necesita para no hablar de oídas. El RAG (Retrieval-Augmented Generation o Generación Recuperada por Búsqueda) es una técnica fantástica que nos permite conectar a nuestra IA con cualquier fuente de información externa en tiempo real, sin necesidad de realizar un costoso proceso de reentrenamiento del modelo.

¿Por qué es mejor el RAG que el reentrenamiento o el Fine-Tuning?

Cuando la gente quiere que su IA conozca sus datos privados, lo primero en lo que suele pensar es en el «Fine-Tuning» o ajuste fino. Esto consiste en coger un modelo existente y someterlo a una nueva fase de entrenamiento utilizando tus propios documentos. Aunque suena muy profesional, la realidad para quienes nos gusta el self-hosting y el cacharreo en casa es que el Fine-Tuning es un auténtico dolor de cabeza.

En primer lugar, requiere una potencia de cálculo descomunal (tarjetas gráficas que cuestan un ojo de la cara y que consumen electricidad como si no hubiera un mañana). En segundo lugar, requiere muchísimo tiempo. Y lo peor de todo: es un proceso estático. Si hoy haces un ajuste fino con tus notas personales y mañana escribes una nota nueva, tu modelo ya vuelve a estar desactualizado. Tendrías que repetir todo el proceso de entrenamiento una y otra vez. Una locura inviable para el día a día.

El RAG soluciona esto de un plumazo. En lugar de meter la información dentro de las conexiones neuronales de la IA, lo que hacemos es crear una biblioteca externa ultraeficiente. Cuando tú le haces una pregunta a la IA, el sistema busca en esa biblioteca los fragmentos de texto que contienen la respuesta, se los adjunta a la pregunta de forma invisible y le dice a la IA: «Por favor, responde a la pregunta del usuario utilizando únicamente este texto que te adjunto aquí». De esta forma, la IA no tiene que recordar nada de memoria; simplemente lee la documentación relevante que le acabamos de proporcionar en tiempo real y redacta una respuesta coherente.

El viaje de tus notas a la base de datos vectorial

¿Cómo funciona este proceso por dentro sin entrar en matemáticas complicadas? Todo se reduce a tres conceptos clave: troceado, embeddings y bases de datos vectoriales.

Imagínate que tienes una carpeta llena de archivos de texto con notas sobre tus servidores, tus artículos del blog o tus recetas de cocina. El primer paso del RAG es el troceado (o chunking). Cogemos esos archivos y los dividimos en pequeños fragmentos manejables, por ejemplo, de unos pocos párrafos cada uno. No podemos pasarle un libro entero a la IA de golpe porque saturaríamos su capacidad de atención (el contexto), así que es mejor trabajar con porciones pequeñas y bien definidas.

El segundo paso es convertir esos trozos de texto en algo que los ordenadores entiendan de verdad: números. Para ello utilizamos un modelo de embeddings. Este modelo coge un fragmento de texto (por ejemplo, «cómo configurar un contenedor de Nginx») y lo traduce en una lista gigante de números llamada vector. Lo maravilloso de estos vectores es que representan el significado semántico del texto. Si dos fragmentos de texto hablan de temas similares (aunque usen palabras diferentes, como «configurar Nginx» y «levantar un servidor web»), sus vectores resultantes estarán muy cerca unos de otros en un espacio geométrico imaginario.

Por último, guardamos estos vectores en una base de datos vectorial. En mi caso particular, como soy un firme defensor de utilizar herramientas robustas y consolidadas, estoy utilizando actualmente PostgreSQL con la extensión PG Vector en un contenedor local. Es una solución espectacular que funciona de maravilla, es súper rápida y se integra perfectamente en cualquier flujo de trabajo autohospedado.

Cuando tú le haces una pregunta a tu asistente, el sistema convierte tu pregunta en un vector usando el mismo modelo de embeddings. Luego, busca en PostgreSQL los vectores que están más cerca del vector de tu pregunta. Extrae los fragmentos de texto correspondientes a esos vectores cercanos, se los pasa al modelo de lenguaje junto con tu prompt original, y ¡listo! Tienes una respuesta precisa, veraz y totalmente basada en tus propios documentos locales, sin inventos ni alucinaciones extrañas.

Cacharreo en Rust: Mi indexador Markdown propio

Como no me gusta depender de software propietario ni de soluciones complejas que te atan a ecosistemas cerrados, me he liado la manta a la cabeza y he desarrollado mi propia herramienta en Rust para gestionar todo este proceso de indexación.

¿Por qué en Rust? Porque es un lenguaje rápido como el rayo, ultraeficiente con la memoria y que me permite crear binarios compilados que funcionan en cualquier sitio sin necesidad de instalar pesadas dependencias o entornos virtuales gigantescos de Python.

He creado dos aplicaciones complementarias. La primera de ellas se encarga exclusivamente de vigilar mi carpeta de documentos en Markdown. Cada vez que modifico un archivo, añado una nota nueva o elimino un documento viejo, la aplicación de Rust lo detecta al instante, trocea el texto, genera los embeddings correspondientes en local y actualiza de forma automática nuestra base de datos en PostgreSQL. De este modo, mi base de conocimiento está permanentemente actualizada en tiempo real sin que yo tenga que hacer absolutamente nada de forma manual. ¡Una auténtica delicia para cualquier amante de la automatización!

Segunda pata: MCP, el estándar que da «manos» a tu IA

Ya tenemos solucionada la memoria de nuestro asistente gracias al RAG, pero ahora necesitamos solucionar el aislamiento del entorno. Queremos que nuestro colaborador digital pueda hacer cosas por nosotros en la máquina local. Y aquí es donde entra en juego una de las tecnologías más revolucionarias y emocionantes de los últimos tiempos: el Model Context Protocol (MCP).

La revolución del Model Context Protocol

Presentado originalmente por la gente de Anthropic a finales del año 2024, el Model Context Protocol es un estándar abierto de comunicación diseñado específicamente para resolver el problema de la conexión entre los modelos de IA y el mundo real.

Hasta la aparición del MCP, si querías que una IA se conectara a una base de datos, tenías que escribir código a medida para esa base de datos concreta. Si luego querías que se conectara a GitHub, tenías que volver a escribir otro bloque de código específico para la API de GitHub. Al final, los desarrolladores pasábamos más tiempo escribiendo integraciones manuales de usar y tirar que mejorando el propio asistente. El desarrollo se volvía caótico y muy difícil de escalar.

El MCP soluciona esto actuando como una especie de puerto USB-C universal para la Inteligencia Artificial. Establece un protocolo de comunicación estándar de tipo cliente-servidor basado en mensajes JSON-RPC 2.0 súper sencillos. La arquitectura se compone de tres piezas muy fáciles de entender:

El Host: Es la aplicación principal de Inteligencia Artificial que coordina todo el sistema (por ejemplo, tu interfaz de chat o tu agente local).
El Cliente: Es el componente dentro del Host que se encarga de iniciar y gestionar las conexiones de red con los distintos servicios.
El Servidor: Es una aplicación independiente y especializada que expone de forma estandarizada una serie de recursos, herramientas o plantillas de prompts al exterior.

Gracias a esta arquitectura modular, tú puedes desarrollar un servidor MCP pequeñito en Python o en Rust que se encargue únicamente de una tarea específica (como leer y escribir archivos en una carpeta local, o consultar el tiempo que hace en la calle). Una vez que tu servidor MCP cumple con el estándar, cualquier cliente compatible con el protocolo MCP puede conectarse a él y empezar a usar sus herramientas de forma inmediata, sin cambiar una sola línea de código del asistente principal. ¡Es sencillamente espectacular!

Construyendo servidores MCP a medida con Python y OpenCode

En estos últimos días me lo he pasado pipa y he estado desarrollando mis propios servidores MCP locales. Aunque existen decenas de servidores ya programados por la comunidad en internet, a los que nos gusta cacharrear siempre nos parece que podemos adaptarlos mejor a nuestras manías y necesidades particulares, o simplemente disfrutamos enormemente aprendiendo cómo se hacen las cosas desde cero.

Para agilizar el proceso de desarrollo, he utilizado una herramienta espectacular de la que ya te hablé en episodios anteriores: OpenCode. Con la ayuda de OpenCode, programar un servidor MCP en Python es un juego de niños. El flujo que he seguido es súper divertido:

Diseñé un primer servidor MCP básico en Python que simplemente exponía una herramienta para leer y escribir notas de texto locales.
Una vez verifiqué que el protocolo funcionaba de forma impecable y que el cliente lo detectaba correctamente, utilicé ese primer código como plantilla.
Para los siguientes servidores, simplemente le decía a OpenCode: «Quiero que me programes un nuevo servidor MCP que se conecte a este servicio específico, estructurando el código exactamente igual que en mi plantilla original».

De este modo, he sido capaz de levantar una flota de unos siete u ocho servidores MCP locales en un tiempo récord, dotando a mi asistente de una versatilidad increíble.

Mis servidores MCP locales favoritos

Para que veas el potencial real de lo que puedes llegar a hacer en tu propia casa, déjame que te cuente qué herramientas he puesto a disposición de mi asistente a través de estos servidores MCP:

Búsquedas en internet con SearXNG: No quería que mi asistente usara motores de búsqueda comerciales que rastrean cada uno de tus pasos y comercian con tus datos de navegación. Así que levanté mi propio motor de búsqueda privado SearXNG en un contenedor local y programé un servidor MCP que se conecta a su API. Ahora, cuando mi asistente necesita buscar información actualizada en internet, realiza la consulta de forma totalmente anónima a través de mi propio SearXNG local.
Búsqueda de vídeos con Invidious: De la misma manera, he integrado un servidor MCP que se comunica con Invidious (una interfaz alternativa y respetuosa con la privacidad para YouTube). Mi asistente puede buscar videotutoriales o documentación en vídeo directamente en local, libre de anuncios y rastreadores molestos.
Listas de tareas (To-Do) y recordatorios: He creado un servidor MCP específico que interactúa con un archivo de base de datos local donde gestiono mis tareas pendientes de la semana. Mi asistente puede añadir tareas nuevas, listar las que tengo pendientes, marcar tareas como completadas o crear recordatorios automáticos para que no se me olvide publicar el podcast los lunes.
Gestión de archivos Markdown: He desarrollado una combinación súper potente entre RAG y MCP. Mi asistente no solo lee mis notas de forma pasiva gracias al RAG, sino que a través de este servidor MCP específico puede modificar los archivos, crear notas nuevas, reorganizar carpetas y mantener mi documentación local perfectamente ordenada y al día.

Tercera pata: Las Skills, la guía del proceso paso a paso

Ya tenemos a nuestro asistente con una memoria fabulosa (RAG) y con la capacidad de ejecutar acciones en nuestra máquina local (MCP). Pero nos falta la tercera dimensión del aislamiento: el proceso. Necesitamos guiar a nuestra IA para que sepa cómo trabajar de forma estructurada, ordenada y lógica, sin volverse loca y sin derrochar recursos. Aquí es donde entran en juego las Skills o habilidades procedimentales.

El problema invisible: La economía de los tokens

Cuando trabajamos con Inteligencia Artificial, hay un factor técnico crucial que muchas veces pasamos por alto pero que tiene un impacto directo en el rendimiento de nuestra máquina (y en nuestro bolsillo si usamos APIs de pago): el consumo de tokens.

Cada palabra que enviamos o recibimos de la IA se traduce en tokens. Si para que el asistente realice una tarea sencilla tenemos que enviarle en cada prompt un texto gigantesco explicándole paso a paso todo lo que tiene que hacer, cómo queremos que lo haga, qué herramientas tiene disponibles y qué formato de salida esperamos, acabaremos consumiendo miles de tokens en cada mensaje de forma totalmente innecesaria. El sistema se volverá lento, pesado y sumamente ineficiente.

Las Skills solucionan este problema de raíz. Una Skill no es más que un flujo de trabajo lógico y estructurado, un pequeño manual de instrucciones que le cargamos al asistente únicamente cuando va a realizar una tarea concreta.

La gran ventaja es que no necesitamos tener todo el conocimiento del proceso cargado en memoria de forma permanente. Cargamos una definición mínima de lo que hace cada habilidad (una especie de índice rápido) y el asistente, de forma autónoma, selecciona y carga la Skill completa en el momento exacto en el que detecta que el usuario necesita realizar esa tarea. Una vez completada, la descarga de la memoria, manteniendo el sistema ligero, rápido y eficiente.

Ejemplo de flujo de trabajo guiado por una Skill

Para que veas cómo funciona en el mundo real, imagínate que quieres automatizar la preparación del menú semanal de tu casa. Sin una Skill, tendrías que ir dándole instrucciones paso a paso a la IA, esperando sus respuestas en un diálogo infinito: «Busca menús de comida… ahora sácame los ingredientes… ahora escríbeme la lista… ahora dime las recetas…». Todo un rollo propenso a errores.

Con una Skill bien estructurada, el proceso se automatiza por completo en un único flujo guiado:

La IA activa la habilidad de «Planificación de Menús».
El primer paso de la Skill le indica que debe conectarse a internet a través del servidor MCP de SearXNG para buscar propuestas de menús saludables basadas en tus preferencias (que previamente ha leído de tus notas locales gracias al RAG).
Una vez seleccionado el menú, el segundo paso de la Skill guía a la IA para que analice de forma estructurada cada plato y extraiga la lista completa de ingredientes necesarios.
El tercer paso le ordena que compare esa lista de ingredientes con lo que ya tienes en la despensa (consultando una nota de inventario local a través del RAG).
Por último, la Skill ordena a la IA que use el servidor MCP de tareas para crearte la lista de la compra definitiva y guardarte las recetas paso a paso en tu carpeta de Markdown locales.

Todo el flujo se ejecuta de forma secuencial, automática y limpia, sin que tú tengas que intervenir para nada más que para disfrutar del resultado final.

La matriz definitiva de capacidades: ¿Cómo se complementan?

Para que tengas una visión global y súper clara de cómo interactúan estas tres fantásticas tecnologías en tu host local, he preparado esta sencilla matriz de capacidades que resume el papel de cada una de ellas de un solo vistazo:

Tecnología	Rol Principal	Analogía Corporal	Flujo de Información
RAG	Conocimiento Factual (Datos)	La Memoria del sistema	Recupera información externa hacia el modelo de IA
MCP	Acción e Interacción (Herramientas)	Las Manos del sistema	Ejecuta herramientas y comandos desde el modelo de IA
Skills	Conocimiento Procedimental (Procesos)	El Manual de instrucciones	Guía la lógica y el flujo de trabajo alrededor del modelo

Al final de todo, tu asistente local actúa como el gran coordinador o director de orquesta. No es simplemente un modelo de chat; va mucho más allá. Es un software que se encarga de orquestar el RAG, el MCP y las Skills para ofrecerte una experiencia de automatización real, fluida y sumamente gratificante.

Del chat reactivo al colaborador activo con Hermes

Durante mucho tiempo, la relación del ser humano con la tecnología de IA ha sido puramente reactiva. Tú escribías algo en una caja de texto, la IA te contestaba y ahí se acababa la historia. Era un diálogo rígido, estanco y que requería que tú hicieras todo el trabajo duro de integrar esa respuesta en tu ordenador, copiar los archivos, ejecutar los programas y organizar las carpetas.

Hoy en día, gracias a la unión del RAG, el MCP y las Skills en nuestro propio ecosistema local, estamos presenciando el nacimiento del futuro agéntico. Hemos pasado de hablar con un chat reactivo a colaborar estrechamente con un asistente activo. Un asistente que no solo responde a tus preguntas, sino que te propone soluciones, ejecuta acciones por ti en tu terminal, mantiene tus notas perfectamente ordenadas y se encarga de las tareas repetitivas y aburridas del día a día para que tú puedas centrarte en lo que de verdad te divierte.

En mi caso particular, he bautizado a mi asistente personal con el nombre de Hermes. Y te puedo asegurar que hoy en día, Hermes es un colaborador indispensable en mi rutina diaria. Me ayuda a redactar la documentación de mis proyectos, me organiza las tareas que tengo pendientes para el blog, me genera los borradores de los guiones del podcast basándose en mis notas de investigación previas y se encarga de un montón de pequeñas automatizaciones en mi servidor doméstico. Todo ello corriendo en mi propio hardware, de forma completamente privada, segura y bajo mi absoluto control. ¡Una auténtica maravilla de la tecnología autohospedada!

¿Y ahora qué? El camino a seguir en los próximos episodios

Sé perfectamente lo que estás pensando en este momento: «Lorenzo, todo esto suena espectacular y me muero de ganas de meterle mano, pero… ¿cómo lo monto yo en mi propia casa con mi servidor Linux?».

No te preocupes lo más mínimo. Soy plenamente consciente de que en este episodio te he dado una visión teórica muy amplia, dejándote con la miel en los labios al no entrar en el proceso de instalación y configuración práctica. Pero es que era absolutamente necesario asentar primero las bases y comprender de verdad de qué va toda esta película antes de ponernos a picar código y levantar contenedores a lo loco.

¡Prepárate porque lo que se viene en las próximas semanas va a ser una auténtica fiesta del cacharreo! Este es el plan de ruta que tengo preparado para ti:

En el próximo episodio: Nos meteremos de lleno en el barro con el RAG. Te explicaré al milímetro cómo he montado la base de datos vectorial en PostgreSQL con PG Vector usando Docker. Te daré acceso completo a mi repositorio de GitHub para que puedas descargar y probar mi aplicación compilada en Rust para indexar tus propios archivos Markdown de forma automática en local.
En el siguiente episodio: Abriremos la caja de herramientas del MCP. Analizaremos en detalle varios de los servidores MCP que he implementado en mi máquina local (SearXNG, Invidious, gestión de archivos y tareas) y te enseñaré cómo puedes programar tus propios servidores a medida en Python usando OpenCode como un auténtico profesional.
Y para rematar la faena: Te presentaré a Hermes. Montaremos el cliente completo que orquesta todo este ecosistema para que tengas exactamente el mismo asistente personal que tengo yo en mi casa, listo para trabajar para ti desde el primer segundo.

Así que mantén tus terminales calientes, ten tus contenedores de Docker preparados y estate muy atento a los próximos episodios, porque te garantizo que nos lo vamos a pasar en grande montando todo esto juntos.

Más información,

Episodio 797 — OpenCode Go vs OpenRouter: Comparativa de Tarifas y Precios — Episodio dedicado exclusivamente a las skills, complemento perfecto para entender la parte procedural del agente.
Episodio 795 — OpenCode, el agente de IA que PROGRAMA por ti — Introducción a OpenCode como agente de IA open source, la base sobre la que se construye todo lo demás.
Episodio 794 — Exprimiendo OpenWebUI — Open WebUI como centro de mando para modelos de IA en local, el ecosistema donde todo se integra.
Episodio 789 — Tu propio Laboratorio de IA — Cómomontar un laboratorio de IA en local con Ollama y Docker, la filosofía «local-first» que subyace en todo.

Más recursos,

¡Tu IA es TONTA! Dale manos y cerebro Vistas: 8