Bienvenida: qué es correr un modelo en tu laptop y cómo funciona este taller

Qué bueno que estés aquí. Este taller es para una primera vez de verdad: no das por sabido nada sobre modelos de IA ni sobre cómo funcionan por dentro. Al terminar vas a tener un modelo de lenguaje corriendo en tu propia laptop, un script de Python que le habla, y sobre todo vas a entender qué está pasando y cuándo conviene hacerlo así.

Cuándo y dónde

Miércoles 14 de octubre de 2026, de 5:30 p. m. a 7:00 p. m., hora de la Ciudad de México.
En vivo, por videollamada. El enlace para entrar está en la página del taller, en la plataforma, con tu sesión iniciada.
Queda grabado. La grabación llega por correo a quienes apartaron su lugar.

Primero lo primero: dónde vive la IA que usas hoy

Casi toda la IA que usas (un chat, un asistente, un agente) funciona igual: tu computadora manda un texto por internet a los servidores de una empresa, ahí un modelo de lenguaje lo lee y produce una respuesta, y la respuesta regresa. El modelo nunca estuvo en tu computadora.

Eso tiene ventajas: los modelos de la nube son enormes, rápidos y muy buenos. Y tiene tres costos:

Pagas por cada llamada (o tienes un límite si es gratis).
Un tercero ve tus datos: todo lo que mandas viaja a sus servidores.
Dependes de internet y de que el servicio esté arriba.

Hoy vamos a hacer lo contrario: traer el modelo a tu laptop. Lo descargas una vez, lo cargas en la memoria de tu computadora y le hablas sin que nada salga de tu máquina.

La analogía del taller: el restaurante y la cocina de tu casa

Vamos a usar una sola analogía de principio a fin, y cada término del taller tiene su lugar en ella. Si en algún momento te pierdes, vuelve a esta página.

Usar un modelo en la nube es comer en un restaurante. El cocinero es excelente y rápido, pero te cobran cada plato y el restaurante ve todo lo que pides.
Correr un modelo local es cocinar en tu casa. Contratas a un cocinero que viene a tu cocina. No cobra por plato y nadie ve tus ingredientes, pero tiene que caber en tu cocina, y un cocinero que cabe en una cocina chica sabe menos que el chef del restaurante.

Vocabulario del taller

No hace falta que te lo aprendas ahora: cada término se explica otra vez cuando aparece. Esta tabla es el mapa para volver.

El modelo y lo que pasa dentro de tu laptop

Término	Qué es	En la analogía
Modelo (de lenguaje)	La IA: un programa que recibe texto y produce texto	El cocinero
Prompt	El texto que le mandas al modelo: tu pregunta o tu instrucción	El pedido que le haces al cocinero
Token	Un pedazo de palabra: la unidad en que el modelo lee y escribe	Un bocado
Velocidad (tokens por segundo)	Cuántos pedazos de palabra escribe el modelo por segundo	Qué tan rápido sirve el cocinero
Parámetros (4B, 8B...)	Los números que el modelo aprendió al entrenarse. 4B son 4 mil millones	La experiencia del cocinero: más experiencia, más sabe, pero ocupa más espacio
Archivo del modelo	El modelo empaquetado en un archivo de varios GB que descargas	El cocinero, con todo lo que sabe en la cabeza
Cuantización	Guardar los parámetros con menos precisión para que el archivo pese menos	El recetario de bolsillo: las mismas recetas en letra chica
Disco	Donde tu computadora guarda todo, aunque no lo esté usando	La bodega: ahí espera el cocinero cuando no trabaja
Memoria RAM	Donde tu computadora pone lo que está usando en este momento. Rápida y más chica que el disco	Tu cocina: el cocinero y su mesa tienen que caber
Cargar un modelo	Copiarlo del disco a la RAM para que pueda contestar	Traer al cocinero de la bodega a la cocina
Contexto	Todo el texto que el modelo tiene delante en un pedido: las instrucciones, tu prompt y lo que ya respondió	La mesa de trabajo del cocinero, dentro de tu cocina
Temperatura	Cuánto se permite variar el modelo al elegir cada token	Cuánto improvisa el cocinero con la receta

Cómo le hablas al modelo

Término	Qué es	En la analogía
LM Studio	La aplicación que descarga el modelo, lo carga y lo atiende	El encargado de tu cocina: trae al cocinero de la bodega y atiende la ventanilla
Servidor local	La parte de LM Studio que recibe pedidos de otros programas	La ventanilla de pedidos de tu cocina
`localhost` y puerto	`localhost` es tu propia computadora; el puerto (`1234`) es el número donde atiende el servidor	Tu casa, y el número de la ventanilla
API	El formato acordado para hacer un pedido entre programas	La comanda: el papelito con el pedido
Script	Un archivo de Python (`.py`) con instrucciones que tú corres	Tu lista de pedidos, por escrito
Librería `openai` y cliente	Código ya hecho que sabe escribir y mandar la comanda; el cliente es la pieza que la manda	El mesero que lleva la comanda a la ventanilla
Proveedor en la nube	Una empresa con modelos en sus servidores (OpenRouter, por ejemplo)	El restaurante
Llave (API key)	Tu identificador secreto ante un proveedor	Tu número de cliente del restaurante. En casa no hace falta

Cuando el modelo usa herramientas

Término	Qué es	En la analogía
Función	Un bloque de código con nombre que hace una tarea y devuelve un resultado	Una tarea que tú sabes hacer en la cocina
Herramienta	Una función de tu código que el modelo puede pedir que se ejecute	El cocinero te pide "tráeme esto de la despensa" y tú se lo traes
Tus datos (`expenses.csv`)	El archivo con los gastos de ejemplo	La despensa

La idea más importante del vocabulario está en la fila de la API: la ventanilla de tu cocina acepta la misma comanda que el restaurante. LM Studio imita el formato de los proveedores en la nube. Por eso el mismo código de Python sirve para los dos: solo cambias a qué dirección mandas el pedido.

El mapa del taller

   TU LAPTOP                                       LA NUBE (opcional)
+-----------------------------------------+      +-------------------------+
|                                         |      |                         |
|   Tu script de Python                   |      |   OpenRouter            |
|   (chat.py, measure.py, agent.py)       |      |   (el restaurante)      |
|        |                    |           |      |          |              |
|        | pedido local       | pedido    |      |          v              |
|        v                    | nube -------------->  Modelo grande        |
|   LM Studio                 |           |      |   (en sus servidores)   |
|   (tu ventanilla)           |           |      |                         |
|        |                    |           |      +-------------------------+
|        v                                |
|   Modelo pequeño                        |
|   (en la RAM de tu laptop)              |
|                                         |
+-----------------------------------------+

   LA SESION EN VIVO, EN 5 PARTES
+------------+   +------------+   +------------+   +------------+   +------------+
| 1. Elegir  |-->| 2. Tu      |-->| 3. Medir:  |-->| 4. Darle   |-->| 5. Cuando  |
|  modelo y  |   |  codigo le |   |  laptop    |   |  herramien-|   |  ir local  |
|  que cabe  |   |  habla a   |   |  contra    |   |  tas a un  |   |  y cuando  |
|  en tu RAM |   |  tu laptop |   |  la nube   |   |  modelo    |   |  no        |
|            |   |            |   |            |   |  pequeno   |   |            |
+------------+   +------------+   +------------+   +------------+   +------------+

Fíjate en dos cosas. Primera: la flecha local nunca sale de tu laptop. Con el modelo local, tus datos no viajan a ningún lado. Segunda: la nube aparece como opcional. La usamos para comparar en la parte 3, y para eso necesitas una llave gratuita de OpenRouter. Si no la tienes, puedes hacer todo el taller solo con tu laptop.

Qué vamos a hacer en vivo

Con las manos en el teclado:

Entender qué es el archivo de un modelo, por qué tiene que caber en tu RAM y elegir uno.
Encender el servidor de LM Studio y mandarle pedidos desde un script de Python.
Medir: los mismos pedidos contra tu laptop y contra un modelo en la nube. Tiempo, velocidad y aciertos.
Darle herramientas al modelo pequeño y ver qué aguanta y dónde se rompe.
Armar el criterio: cuándo conviene ir local y cuándo no.

Qué vas a entender al final (no solo hacer)

Al terminar vas a poder explicar con tus palabras:

Qué es el archivo de un modelo y por qué uno de 4B cabe en una laptop y uno enorme no.
Qué hace LM Studio y por qué tu código no nota la diferencia entre tu laptop y la nube.
Qué es un token y cómo se mide la velocidad de un modelo.
En qué se equivoca más un modelo pequeño y en qué tareas rinde igual que uno grande.
Cuándo ir local: privacidad, costo, volumen y calidad, puestos en una balanza.

Cómo encajan los tres módulos

+-------------------+      +-------------------+      +-------------------+
|  1. ANTES         |      |  2. EN VIVO       |      |  3. DESPUES       |
|                   |      |                   |      |                   |
|  Preparas Python, | ---> |  Le hablas a tu   | ---> |  Sigues probando  |
|  instalas LM      |      |  modelo, lo mides |      |  y ves hacia      |
|  Studio y bajas   |      |  y le das         |      |  donde seguir     |
|  el modelo        |      |  herramientas     |      |                   |
+-------------------+      +-------------------+      +-------------------+

Momento	Qué hay	Por qué va ahí	Cuándo
Antes	Preparar Python y la carpeta, instalar LM Studio y descargar el modelo	La descarga pesa varios GB y depende de tu internet: en vivo detiene a todos	Antes del miércoles
En vivo	Una sola lección con las cinco partes, con código y comandos listos para copiar	Es donde conviene tener ayuda si algo falla	Durante la sesión
Después	Hacia dónde seguir y cómo obtener tu constancia	Lo que no se repite se olvida	En los días siguientes

Durante la sesión, ten esta página abierta en otra pestaña. Así copias el código en vez de transcribirlo de la pantalla compartida: un espacio de más en Python es el error más común de una primera vez.

Lo único que te pedimos antes

Haz las dos lecciones que siguen:

Preparar tu laptop: revisar cuánta RAM tienes, tener Python, crear la carpeta de práctica e instalar la librería que usa el código.
Instalar LM Studio y descargar el modelo: la aplicación, el modelo (unos 2.5 GB) y, si quieres comparar con la nube, tu llave gratuita de OpenRouter.

Si llegas sin hacerlas no pasa nada: los primeros minutos de la sesión son para que todos tengamos el entorno listo. Pero la descarga del modelo depende de tu internet y no hay forma de apurarla, así que si solo puedes hacer una cosa, que sea esa.

Para comprobar que entendiste

1. Si el modelo corre en tu laptop, ¿por qué no necesitas una llave?

Porque la llave sirve para que un proveedor sepa a quién cobrarle y a quién dejar pasar. Con el modelo local no hay proveedor: el pedido va de tu script a LM Studio, dentro de tu propia computadora. En la analogía, en tu casa no necesitas número de cliente.

2. ¿Por qué el mismo código de Python puede hablarle a tu laptop y a la nube?

Porque LM Studio imita el formato de pedido (la API) de los proveedores en la nube. El código arma la misma comanda; lo único que cambia es la dirección a la que la manda.

3. ¿Por qué conviene descargar el modelo antes de la sesión?

Porque pesa varios GB y la velocidad depende de tu internet. Instalar LM Studio y preparar Python toma poco, pero una descarga lenta en vivo te deja atrás del grupo.

Resumen

La IA que usas hoy vive en la nube: rápida y buena, pero cobra por llamada, ve tus datos y depende de internet. Hoy traemos un modelo pequeño a tu laptop con LM Studio.
La analogía del taller: la nube es un restaurante; lo local es un cocinero en tu cocina. Tiene que caber en tu RAM, no cobra por plato y nadie ve tus ingredientes.
LM Studio acepta la misma comanda que la nube, así que el mismo código sirve para los dos.
El taller es el miércoles 14 de octubre, de 5:30 p. m. a 7:00 p. m. hora de la Ciudad de México, y queda grabado. Antes de la sesión: prepara tu laptop y descarga el modelo. Siguiente lección.