# Mistral Small 24B medido: velocidad, memoria y español

> Medimos Mistral Small 24B (Q4_K_M) en una DGX Spark: 14,4 tokens por segundo, 19,8 GB cargado y tres tareas de oficina en español bien resueltas.

- Publicado: 2026-04-11
- Revisado: 2026-11-15
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: modelos, codigo-abierto, edge-ai, analisis
- URL canónica: https://vorluxai.com/blog/mistral-small-24b-instruct-2501-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar este artículo sabrás cuánto corre Mistral Small 24B en una máquina nuestra, cuánta memoria ocupa y cómo escribe en español. También tendrás los comandos para repetir la prueba en la tuya.

Lo medimos el 15 de noviembre de 2026. Si tu equipo tiene 16 GB, este modelo no es tu punto de partida: empieza con uno de 7-8B de nuestra [tabla por hardware y tarea](https://vorluxai.com/blog/mejores-llm-locales-segun-hardware-tarea-es/).

> **TL;DR**
> - **Velocidad:** 14,4 tok/s generando y 0,36 s hasta el primer token. En la misma caja, gemma4:26b dio 68,2 tok/s y qwen3.6:35b 75,8 tok/s.
> - **Memoria:** el archivo ocupa 14,33 GB. Cargado con 8 ranuras de 4k de contexto, 19,79 GB; con 8 ranuras de 8k, 25,64 GB.
> - **Español:** resolvió bien las tres tareas de nuestra prueba de oficina, algo que ningún modelo de 7-8B consiguió. Tardó casi tres veces más.
> - **Veredicto:** tiene sentido si tu máquina se queda en 24-32 GB y prefieres mejor redacción a rapidez. Con más memoria, no es nuestra elección.

## Qué necesitas

* [Ollama](https://vorluxai.com/blog/instalar-ollama-primer-llm-local-es/) y 14,33 GB de disco para la descarga
* Memoria para el modelo cargado: mira la tabla de memoria antes de descargar
* Python 3 con `requests` y nuestros scripts `scripts/bench/local_model_benchmark.py` y `scripts/bench/spanish_small_models.py`

## El archivo y las condiciones

Medimos `mistral-small:24b` de la biblioteca de Ollama, descargado el mismo día. Ollama lo describe así: GGUF, cuantización Q4_K_M, 23,6B parámetros, modelo base Mistral Small 2501 (Instruct), contexto nativo de 32.768 tokens y licencia Apache 2.0. Compruébalo en tu máquina:

```bash
ollama pull mistral-small:24b
ollama show mistral-small:24b      # cuantización, parámetros, contexto, licencia
```

* **Máquina:** nuestra segunda NVIDIA DGX Spark (GB10, 128 GB de memoria unificada), con Ollama 0.34.0.
* **Contexto:** fijado en cada petición con `num_ctx`. Ese servidor atiende 8 peticiones en paralelo, así que reserva 8 ranuras del contexto que pidas.
* **No estaba sola.** En la caja había otro modelo residente en Ollama (22,7 GB) y un motor vLLM con unos 19 GB de memoria de GPU. No registramos el uso de la GPU durante la prueba, así que no podemos demostrar que estuvieran en reposo. Las 15 generaciones cronometradas quedaron entre 14,1 y 14,4 tok/s.
* **Sin carga en frío.** El archivo recién descargado seguía en la caché de disco, y por eso no publicamos el tiempo de carga.

## Paso 1: mide la velocidad

El protocolo de nuestra [guía de 30 minutos](https://vorluxai.com/blog/benchmark-modelo-local-tu-ordenador-30-minutos-es/): un prompt de 278 palabras, temperatura 0, semilla fija y 200 tokens de salida. La primera ejecución se descarta y se publica la segunda.

```bash
python3 scripts/bench/local_model_benchmark.py \
  --models mistral-small:24b --num-ctx 4096 --runs 3 \
  --out mistral-velocidad.json
```

Si Ollama corre en otra máquina, añade `--ollama http://TU-SERVIDOR:11434 --ssh tu-servidor` y el script leerá la memoria del servidor. Nosotros lo lanzamos así.

## Qué medimos: velocidad

Medido el 15 de noviembre de 2026 en la DGX Spark descrita arriba, con el comando del paso 1. Datos completos: [contexto de 4k](https://vorluxai.com/data/measurements/mistral-small-24b-speed-ctx4k-2026-11-15.json) y [contexto de 8k](https://vorluxai.com/data/measurements/mistral-small-24b-speed-ctx8k-2026-11-15.json).

| Contexto pedido | Generación | Lectura del prompt | Primer token | 200 tokens completos |
|---|---|---|---|---|
| 4.096 (8 ranuras) | 14,4 tok/s | 1.509,7 tok/s | 0,36 s | 14,3 s |
| 8.192 (8 ranuras) | 14,3 tok/s | 1.485,1 tok/s | 0,365 s | 14,4 s |

El tamaño del contexto no cambió la velocidad. Para situar la cifra, estos son otros modelos Q4_K_M medidos con el mismo script y el mismo prompt, en otras sesiones:

| Modelo | Dónde y cuándo | Archivo | Generación | Primer token |
|---|---|---|---|---|
| mistral-small:24b | Segunda Spark, 15-11-2026 | 14,33 GB | 14,4 tok/s | 0,36 s |
| gemma4:26b | Segunda Spark, 2-11-2026 | 17,99 GB | 68,2 tok/s | 0,212 s |
| qwen3.6:35b | Segunda Spark, 2-11-2026 | 23,94 GB | 75,8 tok/s | 0,243 s |
| llama3.1:8b | Primera Spark (Ollama 0.30.10), 17-10-2026 | 4,92 GB | 40,2 tok/s | 0,365 s |

Fuentes de las tres últimas filas: [dgx-spark-review-spark2-2026-11-02.json](https://vorluxai.com/data/measurements/dgx-spark-review-spark2-2026-11-02.json) y [local-model-benchmark-2026-10-17.json](https://vorluxai.com/data/measurements/local-model-benchmark-2026-10-17.json).

Frente a llama3.1:8b, el archivo es casi tres veces mayor y la velocidad, algo más de un tercio. Frente a los dos modelos grandes de la misma caja, Mistral Small es unas cinco veces más lento con un archivo más pequeño. Nuestros datos no explican esa diferencia; solo la muestran.

## Qué medimos: memoria

Medido el 15 de noviembre de 2026 en la misma DGX Spark. «Cargado» es el tamaño que da `ollama ps`. La memoria disponible es `MemAvailable` de Linux, leída en el servidor antes de cargar y con el modelo residente.

| Contexto pedido | Tamaño cargado | Disponible antes | Disponible con el modelo |
|---|---|---|---|
| 4.096 × 8 ranuras | 19,79 GB | 65,4 GB | 45,6 GB |
| 8.192 × 8 ranuras | 25,64 GB | 65,4 GB | 40,1 GB |

Doblar el contexto costó 5,85 GB más con el mismo archivo. Lo explicamos con más modelos en [cuánta memoria cuesta el contexto en Ollama](https://vorluxai.com/blog/ollama-longitud-contexto-memoria-medida-es/).

Lo que no medimos:

* **Una sola ranura.** En un equipo de una persona puedes arrancar Ollama con `OLLAMA_NUM_PARALLEL=1` y reservar menos contexto. No lo probamos así.
* **16k y 32k.** Con 8 ranuras habrían ocupado memoria que esa caja necesita para sus otros modelos.
* **Una GPU de 24 GB.** Los 19,79 GB caben sobre el papel, pero no hemos medido la velocidad en una tarjeta así.

## Paso 2: prueba su español

Las tres tareas de oficina que usamos con los modelos pequeños: responder a un cliente que discute una factura, resumir un acta en tres viñetas y extraer una factura a JSON. Temperatura 0, semilla 42, contexto de 4.096 tokens y tres repeticiones.

```bash
python3 scripts/bench/spanish_small_models.py \
  --models mistral-small:24b --reps 3 --out mistral-espanol.json
```

El script comprueba tildes, palabras inglesas coladas y el JSON. La redacción se puntúa aparte, de 1 a 5.

## Qué medimos: español

Medido el 15 de noviembre de 2026 en la misma DGX Spark. Respuestas completas en [mistral-small-24b-spanish-2026-11-15.json](https://vorluxai.com/data/measurements/mistral-small-24b-spanish-2026-11-15.json) y notas con su motivo en [mistral-small-24b-spanish-2026-11-15-scores.json](https://vorluxai.com/data/measurements/mistral-small-24b-spanish-2026-11-15-scores.json).

Las filas de los modelos pequeños son del 8 de octubre de 2026, en nuestra primera Spark con Ollama 0.30.10: [resultados](https://vorluxai.com/data/measurements/spanish-small-models-2026-10-08.json) y [notas](https://vorluxai.com/data/measurements/spanish-small-models-2026-10-08-scores.json).

| Modelo (Q4) | tok/s | Correo (C/T/R) | Resumen (C/T/R) | Campos extraídos | JSON estricto |
|---|---|---|---|---|---|
| mistral-small:24b | 14,2 a 14,3 | 4 / 5 / 4 | 4 / 4 / 5 | 6 de 6 | No (con bloque de código) |
| llama3.1:8b | 39,3 a 39,7 | 3 / 4 / 3 | 4 / 4 / 4 | 6 de 6 | No (con bloque de código) |
| qwen2.5vl:7b | 40,7 a 42,2 | 4 / 5 / 4 | 3 / 2 / 3 | 5 de 6 | Sí |
| qwen2.5-coder:7b | 42,2 a 42,4 | 3 / 3 / 3 | 4 / 3 / 4 | 5 de 6 | No (con bloque de código) |
| llava:7b | 50,8 a 51,3 | 2 / 3 / 3 | no es un resumen | 5 de 6 | No (antes, una negativa) |

C = corrección, T = tarea, R = registro, cada uno sobre 5.

**Quién puso las notas.** Nuestro asistente de IA (Claude) leyó cada respuesta con la misma rúbrica que en octubre. Es un solo lector, no un panel, y sabía qué modelo leía. No usamos ningún modelo local como juez. Las comprobaciones del script sí son objetivas: todas las palabras de nuestra lista llevaban su tilde, no se coló ninguna palabra inglesa y los seis campos de la factura eran correctos.

Qué hizo bien:

* **Persona y modo verbal coherentes.** Escribió «pondremos a Marta en copia» y «facilítanos su correo electrónico». Los modelos pequeños fallaron justo ahí.
* **El total como número.** Devolvió `1512.50`, con punto decimal, como pedía la instrucción. Tres de los cuatro pequeños fallaron ese campo.

Qué corregiría una persona antes de enviar:

* El asunto con mayúsculas a la inglesa: «Aclaración sobre Factura 2026-0412 y Cambio de Plazo de Pago».
* «Lamentamos informarte que», donde en España se espera «de que».
* Dos huecos sin rellenar en la firma, como «[Tu Nombre]».
* El resumen omitió las altas en la Seguridad Social.
* El JSON llegó envuelto en un bloque de código. Si lo va a leer un programa, fuerza el formato como contamos en [salida JSON con Ollama](https://vorluxai.com/blog/ollama-salida-json-facturas-medido-es/).

Un detalle más: el mismo correo de prueba le costó 490 tokens de entrada, frente a los 348 de llama3.1:8b, así que el contexto se te llena antes.

El precio es el tiempo. Con el modelo ya cargado, el correo tardó 20,3 segundos; a llama3.1:8b le llevó 7,7. El resumen, 7,2 segundos frente a 3,9.

## Lo que dice el fabricante

Esto es contexto y no lo hemos medido nosotros. [Mistral AI](https://mistral.ai/) publicó el modelo en enero de 2025. Su [ficha en Hugging Face](https://huggingface.co/mistralai/Mistral-Small-24B-Instruct-2501), consultada el 9 de octubre de 2026, nombra once idiomas, español incluido, y da un 66,3 % en MMLU-Pro y un 84,8 % en HumanEval. Son cifras del fabricante, con sus condiciones, y no incluyen ninguna prueba de redacción en español.

## Veredicto

**Úsalo si** tu máquina tiene entre 24 y 32 GB para modelos, redactas en español y puedes esperar unos 20 segundos por correo. En nuestra prueba fue el único que resolvió bien las tres tareas, y sus fallos se arreglan con una lectura rápida.

**Elige otro si** tienes memoria para un modelo mayor. En nuestra Spark, gemma4:26b y qwen3.6:35b generan unas cinco veces más rápido, y por eso son los que usamos a diario. Un aviso: a esos dos no les hemos pasado la prueba de español, así que no sabemos si escriben mejor o peor que Mistral Small.

**Quédate con un 7-8B si** importa la respuesta inmediata o solo tienes 16 GB. Escriben peor, pero casi tres veces más rápido, y una persona revisa el texto de todos modos.

**No te fíes sin repetirlo.** Es una máquina, un día, una instrucción por tarea y un solo lector. Los modelos pequeños se midieron cinco semanas antes, en la otra caja. Repite la prueba con tus documentos.

## Próximos pasos

* Calcula si te cabe con [cuánta VRAM necesitas para un LLM local](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/).
* Mira qué corre en cada nivel de memoria en nuestro [análisis de la DGX Spark tras 7 semanas](https://vorluxai.com/blog/dgx-spark-review-7-semanas-medido-es/).
* Si dudas entre Q4 y Q8, lee [cómo elegir el archivo GGUF para tu máquina](https://vorluxai.com/blog/gguf-quantization-pick-the-right-file-for-your-hardware-es/).

## Trabaja con nosotros

Podemos hacer esta prueba con tus documentos reales antes de que elijas modelo o hardware. Una llamada gratuita de 15 minutos basta para saber si tiene sentido en tu caso: [reserva la llamada](https://vorluxai.com/contact/?ref=blog-mistral) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
