# Servicio de LLM: Ollama vs vLLM vs TGI

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

{% hint style="success" %}
Todas las opciones disponibles en [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**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.
{% endhint %}

## 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  |

{% hint style="info" %}
Los errores HTTP 502 durante el inicio son normales: el servicio todavía se está inicializando.
{% endhint %}

***

## 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

```bash
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

```bash
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

```python
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

```bash
# 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

```bash
# 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

```python
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

```python
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

```bash
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

```bash
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

```python
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

```bash
# 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

```bash
# 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

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

### Uso de la API

```python
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

```python
# 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.

```bash
# 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](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) - Configuración más fácil
* [Guía de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) - Mayor rendimiento
* [Guía de LocalAI](/guides/guides_v2-es/modelos-de-lenguaje/localai-openai-compatible.md) - Soporte multimodal
* [Guía de DeepSeek-R1](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1.md) - Modelos de razonamiento
* [Configuración multi-GPU](/guides/guides_v2-es/avanzado/multi-gpu-setup.md) - Escala a modelos más grandes
* [Integración de API](/guides/guides_v2-es/avanzado/api-integration.md) - Construir aplicaciones


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/comparaciones/llm-serving-comparison.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.