Dos sparks y una idea loca: así nació El Laboratorio

Todo empezó con una pregunta demasiado simple: “¿Y si montamos nuestra propia IA?”

No la de la web, no la del móvil. La nuestra. En nuestra casa. Con nuestro hardware. Que no se cayera cuando se cayera el de los demás. Que no nos leyera nadie.

Los protagonistas

• Dos NVIDIA Spark (apodados cariñosamente gx10-1 y gx10-2): cada una con un chip GB10, 20 núcleos ARM y —lo importante— 128GB de memoria unificada. Es hardware de laboratorio disfrazado de mini-PC.
• OlmillosServer: un servidor donde viven ya nuestras apps (y que aguanta todo lo que le echamos con una paciencia infinita).
• Dos humanos: Toni y Jaume, con más entusiasmo que experiencia en sistemas (al principio) y con experiencia suficiente parameter (ahora).

La promesa de los 128GB

Aquí está el truco que nos enamoró: en una GPU normal, la VRAM es escasa y cara (una 4090 tiene 24GB y cuesta lo que un riñón). En la Spark, la memoria es unificada: el CPU y la GPU comparten los 128GB. Traducción: puedes cargar modelos gigantes que en una GPU convencional ni entran.

¿Qué cabe en 128GB? Modelos de 70B cuantizados con comodidad, MoE gigantes tipo DeepSeek-V3 o GLM-4.5 recortados, contextos larguísimos… La primera vez que vimos correr un modelo de 97GB en nuestro propio salón, hubo un silencio en la habitación y luego un “¿esto lo tenemos NOSOTROS?”.

Primer arranque: la euforia

La euforia duró hasta el primer htop. Nuestra primera lección real de IA local:

Los 128GB suenan a infinito. No lo son. El sistema operativo, el escritorio, 4 contenedores Docker y 47 pestañas de Chrome también beben de ahí. Y cuando la memoria unificada se llena, la Spark se ralentiza con toda su dignidad.

Ahora vivimos con ~120GB ocupados de forma organizada: un modelo grande por máquina, cache compartida, y disciplina de monje.

El cluster que no esperábamos montar

La segunda Spark llegó para hacer de worker: una como cabeza y otra como secuela (trabajo repartido). El resultado: inferencia distribuida con EXL3 y serving paralelo. No es un centro de datos de Google, pero para un podcast casero… vernos correr un MoE de 100GB+ entre dos cajitas silenciosas sigue pareciendo magia.

Lo que tenemos corriendo habitualmente:

• llama.cpp con modelos GGUF para chat diario.
• vLLM para servir con API compatible OpenAI (todo nuestro software “habla OpenAI” hacia nuestra casa, no hacia California).
• EXL3 para los experimentos de máxima velocidad.
• n8n, Whisper, TTS… y todo lo que cocinamos cada semana.

Lo que hemos cagado (lista parcial, habrá más)

Porque enseñar los éxitos es fácil; enseñar los fracasos es útil:

1. La noche del disco lleno: 91% de disco ocupado, un modelo nuevo que no cabía, y descubriendo (a las 2AM) que los checkpoint de descargas incompletas se comían 50GB.
2. El contexto infinito: pusimos 256K de contexto “porque podíamos”. La KV cache nos comió 40GB y todo el sistema empezó a hacer swap. Aprendimos: contexto no es gratis.
3. Los portales de autenticación: SSD con PasswordAuthentication, claves SSH que no eran las que creíamos, y un servidor que solo aceptaba publickey. (Spoiler: ya está arreglado, y aprendimos lo que significa sshd_config.d/ en carne propia).
4. La thermal party: modelo grande + benchmark + verano = temperatura de secadora. Los ventiladores de la Spark suenan “determinados” cuando están a tope.

Lo que viene

Este blog va a ser el diario de bitácora de la aventura: cada experimento, cada receta que funciona (y las que no), cada truco de hardware, cada modelo que probamos en español.

Si alguna vez has pensado “yo esto no lo puedo montar”: nosotros tampoco podíamos. Y mira esto. Todo lo que hay en este blog, lo hemos aprendido haciendo. Nosotros primero nos cagamos, luego contamos cómo quedar bien.

Próxima entrega: la receta completa para montar tu propio cluster de dos sparks, paso a paso, con los errores ya cometidos para que tú no los repitas. 🚀