> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/comparaciones/llm-serving-comparison.md).

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

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

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

## Guía rápida de decisión

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

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

{% 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 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

```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': 'Explica el entrelazamiento cuántico'}
    ],
    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
```

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

```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': '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

```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': '¡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

```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')

# 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

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

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

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

```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': '¡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

```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 admiten la API de OpenAI: solo cambia la URL del endpoint. Las API 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                  |

***

## Siguientes pasos

* [Guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) - Configuración más sencilla
* [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) - Compatibilidad 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) - Escalar a modelos más grandes
* [Integración de API](/guides/guides_v2-es/avanzado/api-integration.md) - Crear aplicaciones


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.