Servicio de LLM: Ollama vs vLLM vs TGI

Compara vLLM vs SGLang vs Ollama vs TGI vs LocalAI para servir LLMs

Elige la solución de servicio LLM adecuada para tus necesidades en CLORE.AI.

Todas las opciones disponibles en CLORE.AI Marketplace.

Actualización 2025: SGLang ha surgido como un marco de primer nivel, a menudo superando a vLLM en puntos de referencia de rendimiento y TTFT. Tanto vLLM v0.7 como SGLang v0.4 se recomiendan para cargas de trabajo en producción.

Guía rápida de decisión

Caso de uso	Mejor elección	Por qué
Pruebas rápidas y chat	Ollama	Configuración más fácil, inicio más rápido
API de producción (máximo rendimiento)	SGLang o vLLM	Mayor rendimiento en 2025
Modelos de razonamiento (DeepSeek-R1)	SGLang	Mejor soporte para cadenas de razonamiento
Integración con HuggingFace	TGI	Soporte nativo de HF
Desarrollo local	Ollama	Funciona en todas partes
Alta concurrencia	SGLang o vLLM	Batching continuo
Multimodal (TTS, STT, Embeddings)	LocalAI	Solución todo en uno
Aplicaciones de streaming	vLLM o SGLang	Ambos excelentes

Comparación de tiempo de inicio

Solución	Inicio típico	Notas
Ollama	30-60 segundos	El más rápido, ligero
SGLang	3-8 minutos	Descarga el modelo desde HF
vLLM	5-15 minutos	Descarga el modelo desde HF
TGI	3-10 minutos	Descarga el modelo desde HF
LocalAI	5-10 minutos	Precarga múltiples modelos

Los errores HTTP 502 durante el inicio son normales: el servicio todavía se está inicializando.

---

Comparación general

Función	Ollama	vLLM	SGLang	TGI	LocalAI
Facilidad de configuración	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐
Rendimiento	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐
Compatibilidad con modelos	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
Compatibilidad de API	Personalizado + OpenAI	OpenAI	OpenAI	Personalizado + OpenAI	OpenAI
Multi-GPU	Limitado	Excelente	Excelente	Bueno	Limitado
Eficiencia de memoria	Bueno	Excelente	Excelente	Muy buena	Bueno
Multimodal	Solo visión	Solo visión	Solo visión	No	TTS, STT, Embeddings
Tiempo de inicio	30 seg	5-15 min	3-8 min	3-10 min	5-10 min
Modelos de razonamiento	Limitado	Bueno	Excelente	Bueno	Limitado
Mejor para	Desarrollo	Producción	Producción + Razonamiento	Ecosistema HF	Multimodal

---

Benchmarks 2025: DeepSeek-R1-32B

TTFT, TPOT y rendimiento (A100 80GB, batch=32, input=512, output=512)

Framework	TTFT (ms)	TPOT (ms/tok)	Rendimiento (tok/s)	Notas
SGLang v0.4	180	14	2,850	Mejor en general 2025
vLLM v0.7	240	17	2,400	Excelente, cercano a SGLang
llama.cpp	420	28	1,100	CPU+GPU, cuantizado
Ollama	510	35	820	Prioridad en facilidad de uso

TTFT = Tiempo hasta el primer token (latencia). TPOT = Tiempo por token de salida. Menor es mejor en ambos.

Comparación de rendimiento (RTX 4090, Llama 3.1 8B, 10 usuarios concurrentes)

Framework	Tokens/seg	Usuarios concurrentes	Notas
SGLang v0.4	920	20-30	Caché de atención radix
vLLM v0.7	870	20-30	PagedAttention
TGI	550	10-20
Ollama	160*	—	Secuencial por defecto

*Ollama atiende las solicitudes secuencialmente por defecto

---

SGLang

Resumen

SGLang (Structured Generation Language) es un marco de servicio LLM de alto rendimiento desarrollado por investigadores de UC Berkeley y LMSYS. En benchmarks de 2025 con frecuencia iguala o supera a vLLM, especialmente para modelos de razonamiento como DeepSeek-R1.

Pros

• ✅ A menudo el TTFT y rendimiento más rápidos en benchmarks de 2025

• ✅ Atención radix para reutilización eficiente de la caché KV

• ✅ Excelente soporte para modelos de razonamiento (DeepSeek-R1, QwQ)

• ✅ API compatible con OpenAI

• ✅ Batching continuo y caché de prefijos

• ✅ Soporte de decodificación especulativa

• ✅ Paralelismo tensorial multi-GPU

Contras

• ❌ Ecosistema más nuevo, menos recursos comunitarios que vLLM

• ❌ Configuración más compleja que Ollama

• ❌ Solo Linux

Inicio rápido

pip install sglang[all]

# Servir un modelo
python -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 8000

DeepSeek-R1 con SGLang

python -m sglang.launch_server \
    --model-path deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 \
    --port 8000 \
    --tp 2 \
    --reasoning-parser deepseek-r1

Uso de la API

from openai import OpenAI

client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')

response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'user', 'content': 'Explain quantum entanglement'}
    ],
    temperature=0.7,
    max_tokens=512
)
print(response.choices[0].message.content)

Multi-GPU

# 2 GPUs (paralelismo tensorial)
python -m sglang.launch_server \
    --model-path meta-llama/Llama-3.1-70B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --tp 2

Mejor para

• 🎯 Máximos APIs de producción con alto rendimiento

• 🎯 Modelos de razonamiento (DeepSeek-R1, QwQ, estilo o1)

• 🎯 Aplicaciones de baja latencia (TTFT)

• 🎯 Cargas de trabajo con muchos prefijos (alta reutilización de caché KV)

---

Ollama

Resumen

Ollama es la forma más fácil de ejecutar LLMs localmente. Perfecto para desarrollo, pruebas y uso personal.

Pros

• ✅ Instalación y ejecución con un solo comando

• ✅ Biblioteca de modelos integrada

• ✅ Excelente experiencia CLI

• ✅ Funciona en Mac, Linux, Windows

• ✅ Cuantización automática

• ✅ Bajo uso de recursos

Contras

• ❌ Menor rendimiento que las alternativas

• ❌ Soporte multi-GPU limitado

• ❌ Menos listo para producción

• ❌ Menos opciones de optimización

Inicio rápido

# Instalar
curl -fsSL https://ollama.com/install.sh | sh

# Ejecutar cualquier modelo
ollama run llama3.2
ollama run mistral
ollama run codellama

# Servir API
ollama serve

Uso de la API

import requests

# Generar
response = requests.post('http://localhost:11434/api/generate', json={
    'model': 'llama3.2',
    'prompt': 'Explain quantum computing',
    'stream': False
})
print(response.json()['response'])

# Chat
response = requests.post('http://localhost:11434/api/chat', json={
    'model': 'llama3.2',
    'messages': [
        {'role': 'user', 'content': '¡Hola!'}
    ]
})

Compatibilidad con OpenAI

from openai import OpenAI

client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')

response = client.chat.completions.create(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Hello!'}]
)

Rendimiento

Modelo	GPU	Tokens/seg
Llama 3.2 3B	RTX 3060	45-55
Llama 3.1 8B	RTX 3090	35-45
Llama 3.1 70B	A100 40GB	15-20

Mejor para

• 🎯 Prototipado rápido

• 🎯 Asistente de IA personal

• 🎯 Aprendizaje y experimentación

• 🎯 Despliegues simples

---

vLLM

Resumen

vLLM es un motor de inferencia LLM de alto rendimiento y probada eficacia para producción. v0.7 (2025) trae mejoras en rendimiento, mejor soporte de cuantización y nuevas opciones de decodificación especulativa.

Pros

• ✅ Máximo rendimiento (batching continuo + PagedAttention)

• ✅ PagedAttention para memoria eficiente

• ✅ Excelente soporte multi-GPU

• ✅ API compatible con OpenAI

• ✅ Listo para producción, gran comunidad

• ✅ Soporta muchos formatos de cuantización (AWQ, GPTQ, FP8)

• ✅ Decodificación especulativa en v0.7

Contras

• ❌ Configuración más compleja

• ❌ Mayor uso de memoria al inicio

• ❌ Solo Linux (sin soporte nativo para Windows/Mac)

• ❌ Requiere más configuración

Inicio rápido

pip install vllm

# Servir modelo (vLLM v0.7)
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \
    --host 0.0.0.0 \
    --port 8000

Despliegue con Docker

docker run --gpus all -p 8000:8000 \
    vllm/vllm-openai:v0.7.0 \
    --model meta-llama/Llama-3.1-8B-Instruct

Uso de la API

from openai import OpenAI

client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')

# Completado de chat
response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'system', 'content': 'You are helpful.'},
        {'role': 'user', 'content': 'Write a haiku about coding'}
    ],
    temperature=0.7,
    max_tokens=100
)

# Transmisión
stream = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': 'Tell me a story'}],
    stream=True
)
for chunk in stream:
    print(chunk.choices[0].delta.content, end='')

Multi-GPU

# 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 2

# 4 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4

Rendimiento

Modelo	GPU	Tokens/seg	Usuarios concurrentes
Llama 3.1 8B	RTX 3090	80-100	10-20
Llama 3.1 8B	RTX 4090	120-150	20-30
Llama 3.1 70B	A100 40GB	25-35	5-10
Llama 3.1 70B	2x A100	50-70	15-25

Mejor para

• 🎯 APIs de producción con gran comunidad

• 🎯 Aplicaciones de alto tráfico

• 🎯 Servicios de chat multiusuario

• 🎯 Necesidades de máximo rendimiento

---

Text Generation Inference (TGI)

Resumen

Servidor de producción de HuggingFace, estrechamente integrado con el ecosistema HF.

Pros

• ✅ Integración nativa con HuggingFace

• ✅ Ideal para modelos HF

• ✅ Buen soporte multi-GPU

• ✅ Funciones de seguridad integradas

• ✅ Métricas Prometheus

• ✅ Bien documentado

Contras

• ❌ Rendimiento ligeramente inferior a vLLM/SGLang

• ❌ Más intensivo en recursos

• ❌ Configuración compleja

• ❌ Tiempos de inicio más largos

Inicio rápido

# Docker (recomendado)
docker run --gpus all -p 8080:80 \
    ghcr.io/huggingface/text-generation-inference:latest \
    --model-id meta-llama/Llama-3.1-8B-Instruct

# Con token de HF para modelos restringidos
docker run --gpus all -p 8080:80 \
    -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
    ghcr.io/huggingface/text-generation-inference:latest \
    --model-id meta-llama/Llama-3.1-8B-Instruct

Rendimiento

Modelo	GPU	Tokens/seg	Usuarios concurrentes
Llama 3.1 8B	RTX 3090	60-80	8-15
Llama 3.1 8B	RTX 4090	90-120	15-25
Llama 3.1 70B	A100 40GB	20-30	3-8

Mejor para

• 🎯 Usuarios de modelos HuggingFace

• 🎯 Entornos de investigación

• 🎯 Necesitan funciones de seguridad integradas

• 🎯 Necesidades de monitorización Prometheus

---

LocalAI

Resumen

LocalAI es una API compatible con OpenAI que soporta múltiples modalidades: LLMs, TTS, STT, embeddings y generación de imágenes.

Pros

• ✅ Soporte multimodal (LLM, TTS, STT, embeddings)

• ✅ Reemplazo directo compatible con OpenAI

• ✅ Modelos preconstruidos disponibles

• ✅ Soporta modelos GGUF

• ✅ Soporte de reordenamiento (reranking)

• ✅ Documentación Swagger UI

Contras

• ❌ Mayor tiempo de inicio (5-10 minutos)

• ❌ Menor rendimiento de LLM que vLLM/SGLang

• ❌ La generación de imágenes puede tener problemas con CUDA

• ❌ Más complejo para uso puramente LLM

Inicio rápido

docker run --gpus all -p 8080:8080 localai/localai:master-aio-gpu-nvidia-cuda-12

Uso de la API

from openai import OpenAI

client = OpenAI(base_url='http://localhost:8080/v1', api_key='dummy')

# Chat
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Hello!'}]
)

# TTS
audio = client.audio.speech.create(model='tts-1', input='Hello world', voice='alloy')

# STT
transcript = client.audio.transcriptions.create(model='whisper-1', file=open('audio.mp3', 'rb'))

# Embeddings
embeddings = client.embeddings.create(model='text-embedding-ada-002', input='Hello world')

Mejor para

• 🎯 Necesitas múltiples modalidades (TTS, STT, LLM)

• 🎯 Quieres compatibilidad con la API de OpenAI

• 🎯 Ejecutando modelos GGUF

• 🎯 Flujos de trabajo de reordenamiento de documentos

---

Comparación de rendimiento (2025)

Rendimiento (tokens/segundo) — Usuario único

Modelo	Ollama	vLLM v0.7	SGLang v0.4	TGI
Llama 3.1 8B (RTX 3090)	40	90	100	70
Llama 3.1 8B (RTX 4090)	65	140	160	110
Llama 3.1 70B (A100 40GB)	18	30	35	25

Rendimiento — Usuarios múltiples (10 concurrentes)

Modelo	Ollama	vLLM v0.7	SGLang v0.4	TGI
Llama 3.1 8B (RTX 4090)	150*	800	920	500
Llama 3.1 70B (A100 40GB)	50*	200	240	150

*Ollama sirve secuencialmente por defecto

Uso de memoria

Modelo	Ollama	vLLM v0.7	SGLang v0.4	TGI
Llama 3.1 8B	5GB	6GB	6GB	7GB
Llama 3.1 70B (Q4)	38GB	40GB	39GB	42GB

Tiempo hasta el primer token (TTFT) — DeepSeek-R1-32B

Framework	TTFT (A100 80GB)	TPOT (ms/tok)
SGLang v0.4	180ms	14ms
vLLM v0.7	240ms	17ms
llama.cpp	420ms	28ms
Ollama	510ms	35ms

---

Comparación de características

Función	Ollama	vLLM v0.7	SGLang v0.4	TGI	LocalAI
API de OpenAI	✅	✅	✅	✅	✅
Streaming	✅	✅	✅	✅	✅
Agrupamiento por lotes	Básico	Continuo	Continuo	Dinámico	Básico
Multi-GPU	Limitado	Excelente	Excelente	Bueno	Limitado
Cuantización	GGUF	AWQ, GPTQ, FP8	AWQ, GPTQ, FP8	bitsandbytes, AWQ	GGUF
LoRA	✅	✅	✅	✅	✅
Decodificación especulativa	❌	✅	✅	✅	❌
Caché de prefijos	❌	✅	✅ (Radix)	✅	❌
Modelos de razonamiento	Limitado	Bueno	Excelente	Bueno	Limitado
Métricas	Básico	Prometheus	Prometheus	Prometheus	Prometheus
Llamadas a funciones	✅	✅	✅	✅	✅
Modelos de Visión	✅	✅	✅	✅	Limitado
TTS	❌	❌	❌	❌	✅
STT	❌	❌	❌	❌	✅
Embeddings	✅	Limitado	Limitado	Limitado	✅

---

Cuándo usar qué

Usa Ollama cuando:

• Quieres comenzar en 5 minutos

• Estás prototipando o aprendiendo

• Necesitas un asistente de IA personal

• Estás en Mac o Windows

• La simplicidad importa más que la velocidad

Usa SGLang cuando:

• Necesitas la latencia absolutamente más baja (TTFT)

• Estás sirviendo modelos de razonamiento (DeepSeek-R1, QwQ, estilo o1)

• Tienes cargas de trabajo con fuerte compartición de prefijos (RAG, prompts del sistema)

• Necesitas rendimiento de primera categoría en los benchmarks de 2025

• Quieres optimizaciones de vanguardia (atención Radix)

Usa vLLM cuando:

• Necesitas el máximo rendimiento con un framework maduro y bien soportado framework

• Estás atendiendo a muchos usuarios a escala

• Necesitas fiabilidad de producción con una gran comunidad

• Quieres un reemplazo directo de OpenAI

• Tienes configuraciones multi-GPU

• Necesitas amplio soporte de formatos de modelo (AWQ, GPTQ, FP8)

Usa TGI cuando:

• Estás en el ecosistema HuggingFace

• Necesitas características de seguridad integradas

• Quieres métricas detalladas en Prometheus

• Necesitas servir modelos HF directamente

• Estás en un entorno de investigación

Usa LocalAI cuando:

• Necesitas TTS y STT junto con LLM

• Quieres embeddings para RAG

• Necesitas reordenamiento de documentos

• Quieres una solución todo-en-uno

• Estás construyendo aplicaciones con capacidad de voz

---

Guía de migración

De Ollama a SGLang

# Ollama
client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')
response = client.chat.completions.create(model='llama3.2', ...)

# SGLang - solo cambia la URL y el nombre del modelo
client = OpenAI(base_url='http://localhost:8000/v1', api_key='dummy')
response = client.chat.completions.create(model='meta-llama/Llama-3.2-3B-Instruct', ...)

De vLLM a SGLang

Ambos soportan la API de OpenAI - solo cambia la URL del endpoint. Las APIs son totalmente compatibles.

# vLLM
python -m vllm.entrypoints.openai.api_server --model ... --port 8000

# SGLang (equivalente)
python -m sglang.launch_server --model-path ... --port 8000

---

Recomendaciones por GPU

GPU	Usuario único	Multiusuario	Modelos de razonamiento
RTX 3060 12GB	Ollama	Ollama	Ollama
RTX 3090 24GB	Ollama	vLLM	SGLang
RTX 4090 24GB	SGLang/vLLM	SGLang/vLLM	SGLang
A100 40GB+	SGLang	SGLang	SGLang

---

Próximos pasos

• Guía de Ollama - Configuración más fácil

• Guía de vLLM - Mayor rendimiento

• Guía de LocalAI - Soporte multimodal

• Guía de DeepSeek-R1 - Modelos de razonamiento

• Configuración multi-GPU - Escala a modelos más grandes

• Integración de API - Construir aplicaciones