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 Marketplace de CLORE.AI.

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

Guía rápida de decisión

Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai. Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como bare metal bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

Caso de uso	Mejor opció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	El mayor rendimiento en 2025
Modelos de razonamiento (DeepSeek-R1)	SGLang	Mejor soporte para cadenas de razonamiento
Integración con HuggingFace	TGI	Compatibilidad nativa con HF
Desarrollo local	Ollama	Funciona en todas partes
Alta concurrencia	SGLang o vLLM	Agrupación continua
Multimodal (TTS, STT, embeddings)	LocalAI	Solución todo en uno
Aplicaciones en streaming	vLLM o SGLang	Ambos son excelentes

Comparación del 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 varios 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 de modelos	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐
Compatibilidad de API	Personalizada + OpenAI	OpenAI	OpenAI	Personalizada + OpenAI	OpenAI
Multi-GPU	Limitado	Excelente	Excelente	Bueno	Limitado
Eficiencia de memoria	Bueno	Excelente	Excelente	Muy bueno	Bueno
Multimodal	Solo visión	Solo visión	Solo visión	No	TTS, STT, incrustaciones
Tiempo de inicio	30 s	5-15 min	3-8 min	3-10 min	5-10 min
Modelos de razonamiento	Limitado	Bueno	Excelente	Bueno	Limitado
Ideal para	Desarrollo	Producción	Producción + razonamiento	Ecosistema HF	Multimodal

---

Puntos de referencia de 2025: DeepSeek-R1-32B

TTFT, TPOT y rendimiento (A100 80GB, batch=32, entrada=512, salida=512)

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

TTFT = Tiempo hasta el primer token (latencia). TPOT = Tiempo por token de salida. Menor es mejor para 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 sirve solicitudes secuencialmente por defecto

---

SGLang

Descripción general

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

Ventajas

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

• ✅ Atención Radix para un uso eficiente del KV-cache

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

• ✅ API compatible con OpenAI

• ✅ Agrupación continua y caché de prefijos

• ✅ Soporte para decodificación especulativa

• ✅ Paralelismo tensorial multi-GPU

Desventajas

• ❌ Ecosistema más nuevo, menos recursos de la comunidad 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': 'Explica el entrelazamiento cuántico'}
    ],
    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

Ideal para

• 🎯 API de producción con máximo rendimiento

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

• 🎯 Aplicaciones de baja latencia (TTFT)

• 🎯 Cargas de trabajo con muchos prefijos (alto uso compartido de KV-cache)

---

Ollama

Descripción general

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

Ventajas

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

• ✅ Biblioteca de modelos integrada

• ✅ Gran experiencia de CLI

• ✅ Funciona en Mac, Linux y Windows

• ✅ Cuantización automática

• ✅ Baja sobrecarga de recursos

Desventajas

• ❌ 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': 'Explica la computación cuántica',
    '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': '¡Hola!'}]
)

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

Ideal para

• 🎯 Prototipado rápido

• 🎯 Asistente de IA personal

• 🎯 Aprendizaje y experimentación

• 🎯 Implementaciones sencillas

---

vLLM

Descripción general

vLLM es un motor de inferencia LLM de alto rendimiento, probado en producción. v0.7 (2025) aporta mejor rendimiento, mejor compatibilidad con cuantización y nuevas opciones de decodificación especulativa.

Ventajas

• ✅ Máximo rendimiento (agrupación continua + PagedAttention)

• ✅ PagedAttention para una memoria eficiente

• ✅ Excelente soporte multi-GPU

• ✅ API compatible con OpenAI

• ✅ Listo para producción, gran comunidad

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

• ✅ Decodificación especulativa en v0.7

Desventajas

• ❌ Configuración más compleja

• ❌ Mayor sobrecarga de memoria al inicio

• ❌ Solo Linux (sin Windows/Mac nativos)

• ❌ 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')

# Finalización de chat
response = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[
        {'role': 'system', 'content': 'Eres útil.'},
        {'role': 'user', 'content': 'Escribe un haiku sobre programación'}
    ],
    temperature=0.7,
    max_tokens=100
)

# Streaming
stream = client.chat.completions.create(
    model='meta-llama/Llama-3.1-8B-Instruct',
    messages=[{'role': 'user', 'content': 'Cuéntame una historia'}],
    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

Ideal para

• 🎯 API de producción con gran comunidad

• 🎯 Aplicaciones de alto tráfico

• 🎯 Servicios de chat multiusuario

• 🎯 Necesidades de máximo rendimiento

---

Text Generation Inference (TGI)

Descripción general

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

Ventajas

• ✅ Integración nativa con HuggingFace

• ✅ Excelente para modelos de HF

• ✅ Buen soporte multi-GPU

• ✅ Funciones de seguridad integradas

• ✅ Métricas de Prometheus

• ✅ Bien documentado

Desventajas

• ❌ Rendimiento ligeramente inferior al de 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 HF para modelos con acceso restringido
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

Ideal para

• 🎯 Usuarios de modelos HuggingFace

• 🎯 Entornos de investigación

• 🎯 Necesitas funciones de seguridad integradas

• 🎯 Necesidades de monitoreo con Prometheus

---

LocalAI

Descripción general

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

Ventajas

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

• ✅ Reemplazo directo de OpenAI

• ✅ Modelos preconstruidos disponibles

• ✅ Compatible con modelos GGUF

• ✅ Soporte de reranking

• ✅ Documentación de Swagger UI

Desventajas

• ❌ Tiempo de inicio más largo (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 exclusivo de 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': '¡Hola!'}]
)

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

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

# Incrustaciones
embeddings = client.embeddings.create(model='text-embedding-ada-002', input='Hola mundo')

Ideal para

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

• 🎯 Quieres compatibilidad con la API de OpenAI

• 🎯 Ejecutar modelos GGUF

• 🎯 Flujos de trabajo de reranking 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 — Múltiples usuarios (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	7 GB
Llama 3.1 70B (Q4)	38 GB	40 GB	39 GB	42 GB

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

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

---

Comparación de características

Función	Ollama	vLLM v0.7	SGLang v0.4	TGI	LocalAI
API de OpenAI	✅	✅	✅	✅	✅
Transmisión	✅	✅	✅	✅	✅
Agrupación	Básico	Continua	Continua	Dinámica	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
Llamada a funciones	✅	✅	✅	✅	✅
Modelos de visión	✅	✅	✅	✅	Limitado
TTS	❌	❌	❌	❌	✅
STT	❌	❌	❌	❌	✅
Embeddings	✅	Limitado	Limitado	Limitado	✅

---

Cuándo usar qué

Usa Ollama cuando:

• Quieres empezar 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 absoluta más baja (TTFT)

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

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

• Necesitas el máximo rendimiento 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 gran escala

• Necesitas fiabilidad de producción con una gran comunidad

• Quieres un reemplazo directo de OpenAI

• Tienes configuraciones multi-GPU

• Necesitas compatibilidad amplia con formatos de modelo (AWQ, GPTQ, FP8)

Usa TGI cuando:

• Estás en el ecosistema de HuggingFace

• Necesitas funciones de seguridad integradas

• Quieres métricas detalladas de 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 reranking de documentos

• Quieres una sola solución todo en uno

• Estás construyendo aplicaciones con 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 admiten la API de OpenAI: solo cambia la URL del endpoint. Las API 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

---

Siguientes pasos

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

• Guía de vLLM - Mayor rendimiento

• Guía de LocalAI - Compatibilidad multimodal

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

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

• Integración de API - Crear aplicaciones