Ver todos los artículos
DGX SparkHardwareOllamaBenchmarksIA local

DGX Spark tras 7 semanas: qué corre de verdad en 128 GB, medido

JG
Jacobo González Jaspe
|

Revisado:

Ilustración abstracta: columnas de vidrio de distintas alturas; la más alta brilla en ámbar. Merece la pena
Ilustración generada con IA en nuestra máquina.
Este artículo también está en inglés:NVIDIA DGX Spark After 7 Weeks: What 128 GB Runs, Measured

Al terminar este artículo sabrás qué hace una NVIDIA DGX Spark con modelos reales, a qué velocidad, con cuánta memoria de sobra, y si tú eres la persona para la que se diseñó. Casi nadie lo es, y la respuesta más barata es el portátil que ya tienes o un sobremesa mucho más barato. Lo decimos primero porque tenemos dos y nos gustan.

Qué necesitas

Para reproducir nuestra tabla sirve cualquier máquina con Ollama:

  • Ollama instalado (nosotros usamos la 0.30.10 en la primera caja y la 0.34.0 en la segunda).
  • Nuestro script de medición, scripts/bench/local_model_benchmark.py, explicado paso a paso en Mide un modelo local en 30 minutos.
  • Unos 30 minutos.

Paso 1: qué estás comprando

La DGX Spark es una caja pequeña de sobremesa con el chip GB10 Grace Blackwell de NVIDIA: una CPU Arm de 20 núcleos (10 Cortex-X925 y 10 Cortex-A725) y una GPU Blackwell que comparten 128 GB de memoria LPDDR5x en un bus de 256 bits a 273 GB/s. Admite hasta 4 TB de NVMe, tiene un puerto de 10 GbE y red ConnectX para unir hasta cuatro unidades. NVIDIA anuncia “hasta 1 PFLOP FP4”; no lo hemos medido. Todo esto sale de la ficha técnica de NVIDIA, leída el 2 de noviembre de 2026.

De esa ficha importan dos números, y ninguno es el petaflop: 128 GB marca el tamaño máximo del modelo y 273 GB/s la velocidad a la que un usuario recibe tokens de un modelo que la llene.

Precio: en España, el NVIDIA Marketplace listaba la Founders Edition a 7.490 EUR el 16 de noviembre de 2026; el enlace está en nuestro catálogo de hardware. Mira la tienda el día que compres.

Paso 2: cómo usamos dos

J4SGON S.L. funciona sobre dos unidades desde el 15 de septiembre de 2026. La primera (PRIME) lleva el escritorio, la compilación de esta web, unos cuarenta contenedores Docker, tres instancias de Ollama y nuestros agentes. La segunda, sin monitor, sirve los modelos grandes: vLLM, los de Ollama de 17 y 23 GB y uno de visión.

Las une un cable QSFP en los puertos ConnectX. El 15 de septiembre de 2026 medimos el enlace con iperf3 -c <segunda-caja> -P 8 -f g: 107 Gbit/s con ocho flujos, 28 Gbit/s con uno, 0,26 ms de latencia. Un archivo de modelo de 40 GB cruza en unos tres segundos: un modelo en la segunda caja es un modelo local.

Paso 3: reproduce la tabla

Desde la primera caja:

bash
python3 scripts/bench/local_model_benchmark.py \
  --models llama3.1:8b,qwen2.5-coder:7b,deepseek-r1:14b,qwen2.5vl:7b,gemma4:26b \
  --runs 3 --max-tokens 200 --think false \
  --out docs/measurements/dgx-spark-review-prime-2026-11-02.json

Contra la segunda caja, desde la primera:

bash
python3 scripts/bench/local_model_benchmark.py \
  --ollama http://<segunda-caja>:11434 \
  --models qwen3.6:35b,gemma4:26b \
  --runs 3 --max-tokens 200 --think false --max-model-gb 25 \
  --out docs/measurements/dgx-spark-review-spark2-2026-11-02.json

El script rechaza por defecto archivos de más de 20 GB; el punto 1 de más abajo explica por qué solo subimos ese límite en la caja sin escritorio.

Qué medimos

Medido el 2 de noviembre de 2026 en nuestras dos NVIDIA DGX Spark (GB10, 128 GB de memoria unificada). El mismo prompt de 278 palabras (un acta de reunión que resumir) para todos los modelos, temperatura 0, semilla fija, 200 tokens de salida, razonamiento desactivado. La ejecución 1 es una carga en frío y se descarta; se publica la ejecución 2. Los resultados completos, cargas en frío incluidas, están en dgx-spark-review-prime-2026-11-02.json y dgx-spark-review-spark2-2026-11-02.json.

Modelo (etiqueta de Ollama, todos Q4_K_M)Caja, contextoTamaño cargadoGeneración tok/sPrimer tokenCarga en frío desde disco
llama3.1:8b (denso)PRIME, 32k9,2 GB43,70,39 s3,8 s
qwen2.5-coder:7b (denso)PRIME, 32k6,6 GB46,60,31 s3,8 s
qwen2.5vl:7b (visión, denso)PRIME, 32k6,6 GB43,30,31 s15,8 s
deepseek-r1:14b (denso)PRIME, 32k15,3 GB22,40,43 s20,1 s
gemma4:26b (MoE, 128 expertos, 8 por token)PRIME, 32k17,5 GB61,10,69 s61,9 s
gemma4:26b (mismo archivo)spark2, 16k22,6 GB68,20,21 s5,9 s
qwen3.6:35b (MoE, 256 expertos, 8 por token)spark2, 16k23,1 GB75,80,24 s4,6 s

El número de expertos sale del /api/show de Ollama (expert_count, expert_used_count), leído el mismo día.

Tres cosas de la tabla merecen otra mirada.

Los modelos más rápidos son los más grandes. El 35B y el 26B superan al 8B con holgura. Los dos son modelos de mezcla de expertos: cada token pasa por 8 expertos de 256 o de 128, así que la GPU lee una fracción de los pesos por token. El 14B denso, que lee todos sus pesos cada vez, es la fila más lenta. Los parámetros te dicen cuánta memoria necesitas, no a qué velocidad irás.

Mismo archivo, dos tamaños. gemma4:26b ocupa 17,5 GB en la primera caja con contexto de 32k y 22,6 GB en la segunda con 16k. La segunda caja lleva Ollama 0.34, que dimensiona la caché y las ranuras paralelas de otra manera. Lee ollama ps después de cada actualización, no el tamaño del archivo en la página de descarga.

La carga en frío depende de la caché de disco. gemma4 tardó 62 segundos en PRIME, donde el archivo había salido de la memoria, y 6 en spark2, donde seguía en caché. No midas nunca una primera ejecución.

La clase de los 70B

Hoy no cargamos un 70B denso (límite de 20 GB en la caja del escritorio, punto 1). Nuestra propia ejecución de qwen2.5vl:72b (Q4_K_M, 49 GB residentes, contexto de 8k) dio 3,2 tok/s en frío y 2,7 tok/s en la segunda ejecución en PRIME, medido el 9 de septiembre de 2026 con otros servicios compartiendo la caja, antes de que guardáramos un archivo de resultados por cada prueba, así que de esta no hay recibo; el detalle está en nuestro análisis de Qwen2.5-72B. El blog de Ollama (23 de octubre de 2025, no es nuestra medición) da 4,4 tok/s de generación y 1.911 tok/s de lectura para llama3.1:70b en una DGX Spark.

La aritmética coincide con ambas. Cada token generado lee todos los pesos una vez. A 273 GB/s, un modelo cuyos pesos ocupan 43 GB no puede pasar de unos 6 tokens por segundo (273 entre 43) para un solo usuario. El techo lo pone el ancho de banda de memoria, no los FLOPS. Nuestro análisis de Llama 3.3 70B explica qué tareas justifican esa velocidad de todos modos.

Lo que no te dice la ficha técnica

  1. La memoria unificada no tiene red de seguridad para la GPU. En un PC con tarjeta gráfica, un modelo que no cabe falla al cargar. Aquí la GPU, el escritorio y los contenedores comparten los mismos 128 GB, y cuando se agotan el síntoma es un escritorio congelado y NV_ERR_NO_MEMORY en el registro del controlador. Tras una congelación de más fijamos dos reglas: dejar 16 GB libres en la caja que lleva el escritorio y no cargar nunca en ella un archivo de más de 20 GB. Esos van a la segunda unidad.
  2. El ancho de banda limita la velocidad de un solo usuario. La máquina rinde mejor con modelos de 17 a 60 GB y varias personas preguntando a la vez, no con una persona esperando a un 70B denso.
  3. Los valores por defecto de Ollama cambian entre versiones. La 0.34 dimensionaba la caché de un modelo para toda su longitud de contexto (262.144 tokens en qwen3.6) multiplicada por las ranuras paralelas. En la segunda caja eso hizo fallar las cargas hasta que fijamos OLLAMA_CONTEXT_LENGTH. Mira ollama ps tras cada actualización.
  4. Es Arm (aarch64). Casi todo funciona. Algunas ruedas de Python y compilaciones de CUDA 13 no se publican para Arm y hay que compilarlas. Reserva una tarde la primera vez.
  5. Los modelos de mezcla de expertos son el punto dulce. Dos de ellos generan más rápido que un 8B denso usando entre 17 y 23 GB. Esa es la forma de modelo para la que existe esta memoria.
  6. Consumo y ruido. Todavía no le hemos puesto un medidor de enchufe, así que este artículo no lleva ni vatios ni decibelios. Oímos la habitación, no la caja, y eso es una impresión, no una medida. Publicaremos la lectura cuando la tengamos.

Veredicto

  • Compra. Necesitas CUDA y más de 32 GB para modelos, sirves a varios usuarios a la vez, ajustas adaptadores LoRA o quieres dos cajas unidas a 200 GbE. Nada de este tamaño hace las cuatro.
  • Espera. Tu lista de modelos cabe en 24 a 32 GB. Una tarjeta gráfica usada de 24 GB en el PC que ya tienes, o un Mac con 64 GB, lo cubre por menos. El catálogo de hardware los nombra con precios.
  • Sáltatelo. Eres una persona chateando con modelos de 7B a 14B. El portátil que tienes lo hace hoy; en el catálogo, un Mac mini M6 de 16 GB costaba 1.069 EUR (Apple, 16-11-2026) y un 14B cabe justo.

Cuándo no comprarla

Si tu trabajo con modelos grandes es un documento largo al mes, alquila la nube esa hora y mantén un modelo pequeño en local para lo demás. Si tus modelos caben en la memoria que ya tienes, comprar más memoria no acelera nada: un modelo 8B cabe en una caja mucho más barata. Compra la Spark por los modelos y las personas que solo ella puede alojar.

Próximos pasos

Trabaja con nosotros

Podemos hacer este análisis con tus datos reales antes de recomendar hardware. Una llamada gratuita de 15 minutos basta para saber si tiene sentido en tu caso: reserva la llamada o mira cómo trabajamos en consultoría.

Diagrama
Compartir: LinkedIn X
Veredicto semanal

Recibe las guías nuevas antes que nadie

Suscríbete y te avisamos cuando publiquemos guías, plantillas y workflows nuevos. Un correo a la semana, sin spam.

Ya publicados: 101 guías y 25 plantillas. Todo gratis y sin registro.

Bonus: el kit de inicio de IA local en PDF al suscribirte
1x por semana Sin spam Cancela cuando quieras

Ver qué recibes