# Ollama o vLLM para 1 a 10 usuarios: mismo modelo, misma caja, medido

> Qwen2.5-7B-Instruct con Ollama y con vLLM en dos DGX Spark idénticas, medido con 1, 2, 5 y 10 usuarios a la vez. Cuál necesita tu oficina y desde cuánta gente.

- Publicado: 2026-11-02
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: Ollama, vLLM, Benchmarks, Autoalojado, IA local
- URL canónica: https://vorluxai.com/blog/ollama-o-vllm-oficina-pequena-medido-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar este artículo sabrás cuál de los dos servidores de modelos locales más usados encaja con tu equipo, y a partir de cuántas personas cambia la respuesta. Puedes decidirlo en la máquina que ya tienes: los dos son gratuitos, de código abierto y ejecutan los mismos pesos. Lanzamos la misma petición a cada uno, en dos cajas idénticas, con una a diez personas pulsando Enter a la vez.

> **En corto**
> - **Te llevas:** dos tablas con lo que siente una persona (tokens por segundo, pausa hasta la primera palabra) y lo que entrega la caja cuando preguntan dos, cinco o diez a la vez.
> - **Cuesta:** nada en software; la factura es una hora de montaje y la luz de una máquina que ya tienes.
> - **Veredicto:** **Ollama** si pregunta una persona cada vez. **vLLM** en cuanto dos pueden preguntar a la vez: con la configuración por defecto, la segunda persona esperó 16 segundos en Ollama y 0,08 en vLLM.

## Qué necesitas

- Una máquina que ya ejecute un modelo de 7B. Nuestra [guía de instalación de Ollama](https://vorluxai.com/blog/instalar-ollama-primer-llm-local-es/) te lleva hasta ahí en un portátil.
- Docker, si quieres probar vLLM.
- Python 3 y nuestro script `scripts/bench/openwebui_concurrency.py` del repositorio, para lanzar las mismas peticiones a los dos.
- Una hora, casi toda descargas: el modelo de 16 bits pesa 15 GB por servidor.

## Paso 1: instala Ollama y sirve el modelo

Ollama es un comando para instalar y otro para descargar un modelo. Bajamos la etiqueta de 16 bits a propósito, para que los dos servidores ejecuten los mismos pesos con la misma precisión:

```bash
curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5:7b-instruct-fp16
ollama ps   # tras la primera petición: 16,4 GB cargados con contexto de 32k en nuestra caja
```

La etiqueta por defecto, `qwen2.5:7b`, es de 4 bits: un tercio del tamaño y más rápida. No la usamos aquí porque entonces compararíamos una cuantización, no un servidor. Si solo vas a usar Ollama, usa la de 4 bits; nuestra [guía de GGUF](https://vorluxai.com/blog/gguf-quantization-pick-the-right-file-for-your-hardware-es/) explica el intercambio.

## Paso 2: arranca vLLM en Docker

vLLM quiere los pesos originales de Hugging Face y una GPU donde dejarlos fijos. Este es el archivo compose de nuestra segunda caja, recortado a lo que importa:

```yaml
services:
  vllm:
    image: nvcr.io/nvidia/vllm:26.04-py3
    ports: ["8200:8200"]
    volumes: ["${HOME}/.cache/huggingface:/root/.cache/huggingface"]
    ipc: host
    command: >
      vllm serve Qwen/Qwen2.5-7B-Instruct
      --host 0.0.0.0 --port 8200
      --gpu-memory-utilization 0.16
      --max-model-len 32768
      --served-model-name default
    deploy:
      resources:
        reservations:
          devices: [{driver: nvidia, count: all, capabilities: [gpu]}]
```

`--gpu-memory-utilization 0.16` es la parte de la memoria de la caja que vLLM puede ocupar con pesos y caché: el 16 % de 128 GB aquí, porque la caja sirve otros modelos. En una GPU dedicada lo pondrías más alto. El primer arranque descarga 15 GB y compila núcleos; cuenta minutos, no segundos. Después los dos servidores hablan la misma API al estilo OpenAI, y por eso un solo script prueba a ambos.

## Paso 3: lanza las mismas peticiones a los dos

La petición es una tarea de oficina: un correo de un cliente sobre una factura, 384 tokens de entrada, una respuesta de 250 tokens, temperatura 0,7, en streaming. El script envía N peticiones en el mismo instante, tres veces por nivel, y anota cuándo llega la primera palabra y cuándo termina la respuesta.

```bash
python3 scripts/bench/openwebui_concurrency.py --base-url http://localhost:11434/v1 \
  --model qwen2.5:7b-instruct-fp16 --levels 1,2,5,10 --reps 3 --max-tokens 250 \
  --out docs/measurements/ollama-concurrency-prime-2026-11-02.json

python3 scripts/bench/openwebui_concurrency.py --base-url http://<segunda-caja>:8200/v1 \
  --model default --levels 1,2,5,10 --reps 3 --max-tokens 250 \
  --out docs/measurements/vllm-concurrency-spark2-2026-11-02.json
```

## Qué medimos

Medido el 2 de noviembre de 2026 en dos NVIDIA DGX Spark (GB10, 128 GB de memoria unificada cada una): Ollama 0.30.10 en la primera, vLLM 0.19.0 (contenedor de NVIDIA 26.04) en la segunda, así que los servidores nunca compartieron GPU. Mismos pesos (Qwen2.5-7B-Instruct, 16 bits), mismo prompt, medianas de tres repeticiones; "máx" es la petición más lenta. Archivos completos: [ollama-concurrency-prime-2026-11-02.json](https://vorluxai.com/data/measurements/ollama-concurrency-prime-2026-11-02.json) y [vllm-concurrency-spark2-2026-11-02.json](https://vorluxai.com/data/measurements/vllm-concurrency-spark2-2026-11-02.json).

**Ollama** (`qwen2.5:7b-instruct-fp16`, 16,4 GB cargados, contexto de 32k, `OLLAMA_NUM_PARALLEL` en su valor por defecto):

| Usuarios a la vez | Primera palabra, mediana (máx) | Respuesta completa, mediana (máx) | tok/s por usuario | tok/s total |
|---|---|---|---|---|
| 1 | 0,21 s (0,23 s) | 15,9 s (16,9 s) | 16,0 | 15,8 |
| 2 | 8,0 s (16,0 s) | 23,3 s (31,6 s) | 15,9 | 15,7 |
| 5 | 31,2 s (62,6 s) | 46,5 s (79,2 s) | 16,0 | 15,9 |
| 10 | 71,7 s (146,4 s) | 86,6 s (162,9 s) | 15,8 | 15,7 |

**vLLM** (`Qwen/Qwen2.5-7B-Instruct` BF16, `--gpu-memory-utilization 0.16`, `--max-model-len 32768`):

| Usuarios a la vez | Primera palabra, mediana (máx) | Respuesta completa, mediana (máx) | tok/s por usuario | tok/s total |
|---|---|---|---|---|
| 1 | 0,08 s (0,08 s) | 18,2 s (18,3 s) | 13,8 | 13,7 |
| 2 | 0,08 s (0,09 s) | 14,8 s (15,4 s) | 16,9 | 32,1 |
| 5 | 0,10 s (0,18 s) | 14,9 s (15,7 s) | 16,6 | 80,1 |
| 10 | 0,17 s (0,18 s) | 15,1 s (15,2 s) | 16,6 | 158,6 |

Las filas de vLLM reproducen nuestra medición del 8 de octubre de 2026 en la misma caja con un margen del 2 %, que es el tipo de resultado aburrido que quieres de una medición.

Tres cosas que dicen las tablas.

**A solas, Ollama es más rápido.** Una persona obtuvo 16,0 tokens por segundo de Ollama y 13,8 de vLLM, y la respuesta completa dos segundos antes. Si esa es tu oficina, ya está: instala Ollama y deja de leer.

**El cruce está en dos.** Con dos personas, la segunda de Ollama esperó 16 segundos para ver una palabra, porque la primera petición tenía que terminar. vLLM dio a las dos su primera palabra en 0,08 segundos y sus respuestas en 15. Mira la columna por usuario: los usuarios de vLLM fueron más rápidos con dos que con uno, porque su procesamiento por lotes aprovecha mejor la GPU con más de un flujo.

**Con diez, es una cola contra un mostrador.** Las diez peticiones de Ollama vieron su primera palabra a los 0,2, 15,7, 31,6, 47,1, 63,0, 79,5, 94,9, 109,3, 124,8 y 140,2 segundos: de una en una, cada una de unos 15,6 segundos, con la salida total clavada en los 15,7 tokens por segundo de un solo usuario. vLLM atendió a las diez juntas, primera palabra en menos de 0,2 segundos, cada respuesta en unos 15 segundos, 158,6 tokens por segundo saliendo de la caja.

## Lo que no te dice la ficha técnica

- **La cola de Ollama es un ajuste, no una ley.** Ejecuta un número fijo de ranuras paralelas y encola el resto; `OLLAMA_NUM_PARALLEL` sube ese número, y cada ranura cuesta memoria para su propia caché de contexto. Medimos el valor por defecto con el que venía nuestra instalación y no medimos otros, así que este artículo no afirma nada sobre ellos. Los otros valores los medimos después: Ollama con varios usuarios a la vez, medido.
- **Aquí la precisión era igual; por defecto no lo es.** Las etiquetas habituales de Ollama son de 4 bits, más pequeñas y rápidas que el archivo de 16 bits que usamos. vLLM ejecuta los pesos originales salvo que le pases un modelo cuantizado.
- **vLLM fija su memoria al arrancar; Ollama la toma prestada.** vLLM coge su parte de la GPU cuando arranca el contenedor y se la queda. Ollama carga con la primera petición y descarga tras `OLLAMA_KEEP_ALIVE` (10 minutos en nuestra caja). En una máquina compartida esa diferencia decide quién más puede correr.
- **Las dos cajas estaban ocupadas.** Durante la medición de Ollama otro cliente cargó un modelo de 8B en la misma caja, y por eso una petición del nivel de 2 usuarios tardó 2 min 34 s en el archivo completo; las medianas de arriba no cambian. La caja de vLLM mantuvo residente un modelo de chat de 21 GB todo el tiempo. Eso es normal en nuestra pila y seguramente en la tuya.

## Veredicto

- **Ollama.** Una persona cada vez, o un trabajo por lotes que lanza una petición tras otra. Más rápido por token, un comando, nada que configurar.
- **vLLM.** Dos o más personas que pueden preguntar a la vez, o cualquier página de chat donde una pausa de 70 segundos sea una queja. Diez personas recibieron su respuesta en 15 segundos cada una.
- **Ninguno todavía.** Si no has ejecutado un modelo de 7B en la máquina que tienes, hazlo primero con Ollama y vuelve cuando alguien tenga que esperar.

## Cuándo no hacerlo

Medimos un modelo, una longitud de prompt y respuestas de 250 tokens. Pega un contrato de 30 páginas y cada petición lleva miles de tokens; la primera palabra tarda más y la memoria por usuario crece en los dos servidores. No hemos medido ese caso. También usamos dos cajas, y por eso el servidor perdedor no costó nada: si tu oficina tiene una sola GPU y los dos tienen que compartirla, vuelve a pasar el script antes de decidir. Y si la oficina hace tres preguntas al día, el modelo en la nube que ya pagas sirve.

## Próximos pasos

- Pon el servidor detrás de una página con usuarios: [Open WebUI para una oficina de 10](https://vorluxai.com/blog/open-webui-office-accounts-models-logs-es/).
- Calcula la memoria antes de elegir modelo: [¿Cuánta VRAM necesito?](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/).
- Ciérralo: la [lista de seguridad de Ollama en 10 minutos](https://vorluxai.com/blog/keep-your-local-ai-patched-ollama-security-checklist-es/). Para sacar tu propia versión de estas tablas en tu máquina, empieza por [Mide un modelo local en 30 minutos](https://vorluxai.com/blog/benchmark-modelo-local-tu-ordenador-30-minutos-es/).

## 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](https://vorluxai.com/contact/) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
