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.
Qué necesitas
- Una máquina que ya ejecute un modelo de 7B. Nuestra guía de instalación de Ollama te lleva hasta ahí en un portátil.
- Docker, si quieres probar vLLM.
- Python 3 y nuestro script
scripts/bench/openwebui_concurrency.pydel 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:
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 cajaLa 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 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:
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.
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.jsonQué 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 y 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_PARALLELsube 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.
- Calcula la memoria antes de elegir modelo: ¿Cuánta VRAM necesito?.
- Ciérralo: la lista de seguridad de Ollama en 10 minutos. Para sacar tu propia versión de estas tablas en tu máquina, empieza por Mide un modelo local en 30 minutos.
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.