# Ollama

La forma más fácil de ejecutar LLMs localmente en GPU de CLORE.AI.

{% hint style="info" %}
**Versión actual: v0.6+** — Esta guía cubre Ollama v0.6 y posteriores. Las nuevas funciones clave incluyen salidas estructuradas (aplicación de esquema JSON), un endpoint de embeddings compatible con OpenAI (`/api/embed`), y carga concurrente de modelos (ejecuta varios modelos simultáneamente sin intercambio). Consulta [Novedades en v0.6+](#new-in-v06) para más detalles.
{% endhint %}

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Mercado de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Requisitos del servidor

| Parámetro          | Mínimo        | Recomendado |
| ------------------ | ------------- | ----------- |
| RAM                | 8 GB          | 16 GB+      |
| VRAM               | 6 GB          | 8 GB+       |
| Red                | 100 Mbps      | 500 Mbps+   |
| Tiempo de arranque | \~30 segundos | -           |

{% hint style="info" %}
Ollama es ligero y funciona en la mayoría de los servidores GPU. Para modelos más grandes (13B+), elige servidores con 16 GB+ de RAM y 12 GB+ de VRAM.
{% endhint %}

## ¿Por qué Ollama?

* **Configuración con un solo comando** - Sin Python, sin dependencias
* **Biblioteca de modelos** - Descarga modelos con `ollama pull`
* **API compatible con OpenAI** - Reemplazo directo
* **Aceleración por GPU** - Detección automática de CUDA
* **Multimodelo** - Ejecuta varios modelos simultáneamente (v0.6+)

## Despliegue rápido en CLORE.AI

**Imagen de Docker:**

```
ollama/ollama
```

**Puertos:**

```
22/tcp
11434/http
```

**Comando:**

```bash
ollama serve
```

### Verifica que funciona

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos** y prueba:

```bash
# Reemplaza con tu URL http_pub real
curl https://your-http-pub.clorecloud.net/

# Respuesta esperada: "Ollama is running"
```

{% hint style="warning" %}
Si obtienes HTTP 502, espera 30-60 segundos: el servicio todavía se está iniciando.
{% endhint %}

## Acceso a tu servicio

Cuando se despliega en CLORE.AI, accede a tu instancia de Ollama a través de la `http_pub` URL:

```bash
# Encuentra tu http_pub en Mis pedidos, luego:
curl https://your-http-pub.clorecloud.net/api/tags

# Para llamadas a la API, usa tu URL http_pub:
curl https://your-http-pub.clorecloud.net/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'
```

{% hint style="info" %}
Todos `localhost:11434` los ejemplos siguientes funcionan cuando te conectas vía SSH. Para acceso externo, reemplaza por tu `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## Instalación

### Usando Docker (recomendado)

```bash
docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
```

### Instalación manual

```bash
curl -fsSL https://ollama.com/install.sh | sh
```

Este único comando instala la última versión de Ollama, configura el servicio systemd y configura automáticamente la detección de GPU. Funciona en Ubuntu, Debian, Fedora y la mayoría de las distribuciones Linux modernas.

## Ejecución de modelos

### Descargar y ejecutar

```bash
# Descargar modelo
ollama pull llama3.2

# Ejecutar chat interactivo
ollama run llama3.2

# Ejecutar con prompt
ollama run llama3.2 "Explain quantum computing"
```

### Modelos populares

| Modelo              | Tamaño  | Caso de uso              |
| ------------------- | ------- | ------------------------ |
| `llama3.2`          | 3B      | Rápido, de uso general   |
| `llama3.1`          | 8B      | Mejor calidad            |
| `llama3.1:70b`      | 70B     | Mejor calidad            |
| `mistral`           | 7B      | Rápido, buena calidad    |
| `mixtral`           | 47B     | MoE, alta calidad        |
| `codellama`         | 7-34B   | Generación de código     |
| `deepseek-coder-v2` | 16B     | Mejor para código        |
| `deepseek-r1`       | 7B-671B | Modelo de razonamiento   |
| `deepseek-r1:32b`   | 32B     | Razonamiento equilibrado |
| `qwen2.5`           | 7B      | Multilingüe              |
| `qwen2.5:72b`       | 72B     | Mejor calidad de Qwen    |
| `phi4`              | 14B     | Lo último de Microsoft   |
| `gemma2`            | 9B      | Modelo de Google         |

### Variantes del modelo

```bash
# Variantes de cuantización
ollama pull llama3.1:8b-instruct-q4_K_M   # 4 bits (más pequeño, más rápido)
ollama pull llama3.1:8b-instruct-q8_0     # 8 bits (mejor calidad)
ollama pull llama3.1:8b-instruct-fp16     # Precisión completa

# Variantes de tamaño
ollama pull llama3.1:8b    # 8 mil millones de parámetros
ollama pull llama3.1:70b   # 70 mil millones de parámetros

# Nuevos modelos (era v0.6+)
ollama pull deepseek-r1:7b      # Razonamiento, económico
ollama pull deepseek-r1:14b     # Razonamiento, eficiente
ollama pull deepseek-r1:32b     # Razonamiento, equilibrado
ollama pull deepseek-r1:70b     # Razonamiento, alta calidad
ollama pull qwen2.5:72b         # Qwen más grande, calidad máxima
ollama pull phi4                # Microsoft Phi-4 14B
```

## Novedades en v0.6+

Ollama v0.6 introdujo varias funciones importantes para cargas de trabajo de producción:

### Salidas estructuradas (JSON Schema)

Fuerza que las respuestas del modelo coincidan con un esquema JSON específico. Útil para construir aplicaciones que necesitan salidas fiables y analizables:

```bash
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Tell me about Canada."}],
  "format": {
    "type": "object",
    "properties": {
      "name": {"type": "string"},
      "capital": {"type": "string"},
      "population": {"type": "integer"},
      "languages": {
        "type": "array",
        "items": {"type": "string"}
      }
    },
    "required": ["name", "capital", "population", "languages"]
  },
  "stream": false
}'
```

Ejemplo en Python con salidas estructuradas:

```python
from openai import OpenAI
import json

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

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "List 3 programming languages with their main use cases"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "languages",
            "schema": {
                "type": "object",
                "properties": {
                    "languages": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "use_case": {"type": "string"},
                                "popularity_rank": {"type": "integer"}
                            }
                        }
                    }
                }
            }
        }
    }
)

data = json.loads(response.choices[0].message.content)
print(data)
```

### Endpoint de embeddings compatible con OpenAI (`/api/embed`)

Novedad en v0.6+: el `/api/embed` endpoint es totalmente compatible con OpenAI y admite entradas por lotes:

```bash
# Embedding de texto único
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Hello world"
}'

# Embeddings por lotes (nuevo en v0.6)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["First document", "Second document", "Third document"]
}'
```

El cliente de OpenAI funciona directamente con `/v1/embeddings`:

```python
from openai import OpenAI
import numpy as np

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

# Primero descarga el modelo de embeddings: ollama pull nomic-embed-text
response = client.embeddings.create(
    model="nomic-embed-text",
    input=["Hello world", "Goodbye world"]
)

emb1 = np.array(response.data[0].embedding)
emb2 = np.array(response.data[1].embedding)

# Similitud coseno
similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print(f"Similarity: {similarity:.4f}")
```

Modelos de embeddings populares:

```bash
ollama pull nomic-embed-text      # 137M, rápido, buena calidad
ollama pull mxbai-embed-large     # 335M, mayor calidad
ollama pull all-minilm            # 23M, el más rápido
```

### Carga concurrente de modelos

Antes de v0.6, Ollama descargaba un modelo para cargar otro. v0.6+ permite ejecutar varios modelos simultáneamente, limitado solo por la VRAM disponible:

```bash
# Cargar dos modelos al mismo tiempo
ollama run llama3.2 &
ollama run deepseek-r1:7b &

# Ver qué está ejecutándose
curl http://localhost:11434/api/ps
```

Configurar concurrencia:

```bash
# Permitir hasta 4 modelos cargados simultáneamente
OLLAMA_MAX_LOADED_MODELS=4 ollama serve

# Cada runner en un proceso separado (mejor aislamiento)
OLLAMA_NUM_PARALLEL=2 ollama serve
```

Esto es especialmente útil para:

* Pruebas A/B de diferentes modelos
* Modelos especializados para distintas tareas (código + chat)
* Mantener en VRAM modelos usados con frecuencia

## Uso de la API

### Finalización de chat

```bash
# Mediante http_pub (acceso externo):
curl https://your-http-pub.clorecloud.net/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'

# Mediante túnel SSH (localhost):
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'
```

{% hint style="info" %}
Añade `"stream": false` para obtener la respuesta completa de una vez en lugar de en streaming.
{% endhint %}

### Endpoint compatible con OpenAI

```python
from openai import OpenAI

# Para acceso externo, usa tu URL http_pub:
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="ollama"  # cualquier cadena funciona
)

# O mediante túnel SSH:
# client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "user", "content": "What is machine learning?"}
    ]
)

print(response.choices[0].message.content)
```

### Streaming

```python
stream = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")
```

### Embeddings

```bash
# Endpoint heredado (todavía funciona)
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "Hello world"
}'

# Nuevo endpoint v0.6+ (soporte por lotes, compatible con OpenAI)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["Hello world", "Another text"]
}'
```

### Generación de texto (no chat)

```bash
curl https://your-http-pub.clorecloud.net/api/generate -d '{
  "model": "llama3.2",
  "prompt": "The meaning of life is",
  "stream": false
}'
```

## Referencia completa de la API

Todos los endpoints funcionan con ambos `http://localhost:11434` (vía SSH) y `https://your-http-pub.clorecloud.net` (externo).

### Gestión de modelos

| Endpoint       | Método | Descripción                                            |
| -------------- | ------ | ------------------------------------------------------ |
| `/api/tags`    | GET    | Listar todos los modelos descargados                   |
| `/api/show`    | POST   | Obtener detalles del modelo                            |
| `/api/pull`    | POST   | Descargar un modelo                                    |
| `/api/delete`  | DELETE | Eliminar un modelo                                     |
| `/api/ps`      | GET    | Listar los modelos que se están ejecutando actualmente |
| `/api/version` | GET    | Obtener la versión de Ollama                           |

#### Listar modelos

```bash
curl https://your-http-pub.clorecloud.net/api/tags
```

Respuesta:

```json
{
  "models": [
    {"name": "llama3.2:latest", "size": 2019393189, "digest": "...", "modified_at": "..."}
  ]
}
```

#### Mostrar detalles del modelo

```bash
curl https://your-http-pub.clorecloud.net/api/show -d '{"name": "llama3.2"}'
```

#### Descargar modelo vía API

```bash
curl https://your-http-pub.clorecloud.net/api/pull -d '{
  "name": "mistral:7b",
  "stream": false
}'
```

Respuesta:

```json
{"status": "success"}
```

{% hint style="warning" %}
Los modelos grandes pueden tardar varios minutos en descargarse. Para modelos muy grandes (30 GB+), considera usar SSH y la CLI: `ollama pull model-name`
{% endhint %}

#### Eliminar modelo

```bash
curl -X DELETE https://your-http-pub.clorecloud.net/api/delete -d '{"name": "mistral:7b"}'
```

#### Listar modelos en ejecución

```bash
curl https://your-http-pub.clorecloud.net/api/ps
```

Respuesta:

```json
{
  "models": [
    {"name": "llama3.2:latest", "size": 2019393189, "expires_at": "2025-01-25T12:00:00Z"}
  ]
}
```

#### Obtener versión

```bash
curl https://your-http-pub.clorecloud.net/api/version
```

Respuesta:

```json
{"version": "0.6.8"}
```

### Endpoints de inferencia

| Endpoint               | Método | Descripción                                                 |
| ---------------------- | ------ | ----------------------------------------------------------- |
| `/api/generate`        | POST   | Finalización de texto                                       |
| `/api/chat`            | POST   | Finalización de chat                                        |
| `/api/embeddings`      | POST   | Generar embeddings (heredado)                               |
| `/api/embed`           | POST   | Generar embeddings v0.6+ (por lotes, compatible con OpenAI) |
| `/v1/chat/completions` | POST   | Chat compatible con OpenAI                                  |
| `/v1/embeddings`       | POST   | Embeddings compatibles con OpenAI                           |

### Creación de modelos personalizados

Crea modelos personalizados con prompts de sistema específicos a través de la API:

```bash
curl https://your-http-pub.clorecloud.net/api/create -d '{
  "name": "my-assistant",
  "modelfile": "FROM llama3.2\nSYSTEM You are a helpful coding assistant."
}'
```

## Configuración de GPU

### Comprobar uso de GPU

```bash
# En contenedor o servidor
nvidia-smi

# Ollama muestra la GPU en los registros
ollama run llama3.2 --verbose
```

### Multi-GPU

Ollama usa automáticamente las GPU disponibles. Para una GPU específica:

```bash
CUDA_VISIBLE_DEVICES=0 ollama serve
```

### Gestión de memoria

```bash
# Establecer límite de memoria de GPU
OLLAMA_GPU_MEMORY=8GiB ollama serve

# Mantener el modelo cargado
OLLAMA_KEEP_ALIVE=24h ollama serve

# Permitir modelos concurrentes (v0.6+)
OLLAMA_MAX_LOADED_MODELS=3 ollama serve
```

## Modelos personalizados (Modelfile)

Crea modelos personalizados con prompts de sistema:

```dockerfile
# Modelfile
FROM llama3.2

SYSTEM You are a helpful coding assistant. Always provide code examples.

PARAMETER temperature 0.7
PARAMETER top_p 0.9
```

```bash
ollama create coding-assistant -f Modelfile
ollama run coding-assistant
```

## Ejecutar como servicio

### Systemd

```ini
# /etc/systemd/system/ollama.service
[Unit]
Description=Servicio de Ollama
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/ollama serve
Restart=always
Environment="OLLAMA_HOST=0.0.0.0"

[Install]
WantedBy=multi-user.target
```

```bash
systemctl enable ollama
systemctl start ollama
```

## Consejos de rendimiento

1. **Usa la cuantización adecuada**
   * Q4\_K\_M para velocidad
   * Q8\_0 para calidad
   * fp16 para la máxima calidad
2. **Ajusta el modelo a la VRAM**
   * 8 GB: modelos de 7B (Q4)
   * 16 GB: modelos de 13B o 7B (Q8)
   * 24 GB: modelos de 34B (Q4)
   * 48 GB+: modelos de 70B
3. **Mantén el modelo cargado**

   ```bash
   OLLAMA_KEEP_ALIVE=1h ollama serve
   ```
4. **Un SSD rápido mejora el rendimiento**
   * La carga del modelo y la caché KV se benefician del almacenamiento rápido
   * Los servidores con SSD NVMe pueden lograr un rendimiento 2-3x mejor

## Benchmarks

### Velocidad de generación (tokens/seg)

| Modelo               | RTX 3060 | RTX 3090 | RTX 4090 | A100 40 GB |
| -------------------- | -------- | -------- | -------- | ---------- |
| Llama 3.2 3B (Q4)    | 120      | 160      | 200      | 220        |
| Llama 3.1 8B (Q4)    | 60       | 100      | 130      | 150        |
| Llama 3.1 8B (Q8)    | 45       | 80       | 110      | 130        |
| Mistral 7B (Q4)      | 70       | 110      | 140      | 160        |
| Mixtral 8x7B (Q4)    | -        | 35       | 55       | 75         |
| Llama 3.1 70B (Q4)   | -        | -        | 18       | 35         |
| DeepSeek-R1 7B (Q4)  | 65       | 105      | 135      | 155        |
| DeepSeek-R1 32B (Q4) | -        | -        | 22       | 42         |
| Qwen2.5 72B (Q4)     | -        | -        | 15       | 30         |
| Phi-4 14B (Q4)       | -        | 50       | 75       | 90         |

*Benchmarks actualizados en enero de 2026. Las velocidades reales pueden variar según la configuración del servidor.*

### Tiempo hasta el primer token (ms)

| Modelo | RTX 3090 | RTX 4090 | A100 |
| ------ | -------- | -------- | ---- |
| 3B     | 50       | 35       | 25   |
| 7-8B   | 120      | 80       | 60   |
| 13B    | 250      | 150      | 100  |
| 34B    | 600      | 350      | 200  |
| 70B    | -        | 1200     | 500  |

### Longitud de contexto vs VRAM (Q4)

| Modelo | Ctx 2K | Ctx 4K | Ctx 8K | Ctx 16K |
| ------ | ------ | ------ | ------ | ------- |
| 7B     | 5 GB   | 6 GB   | 8 GB   | 12 GB   |
| 13B    | 8 GB   | 10 GB  | 14 GB  | 22 GB   |
| 34B    | 20 GB  | 24 GB  | 32 GB  | 48 GB   |
| 70B    | 40 GB  | 48 GB  | 64 GB  | 96 GB   |

## Requisitos de GPU

| Modelo | VRAM Q4 | VRAM Q8 |
| ------ | ------- | ------- |
| 3B     | 3 GB    | 5 GB    |
| 7-8B   | 5 GB    | 9 GB    |
| 13B    | 8 GB    | 15 GB   |
| 34B    | 20 GB   | 38 GB   |
| 70B    | 40 GB   | 75 GB   |

## Estimación de costos

Tarifas típicas del mercado CLORE.AI:

| GPU                                                                                                | VRAM  | Precio/día | Bueno para             |
| -------------------------------------------------------------------------------------------------- | ----- | ---------- | ---------------------- |
| [RTX 3090](https://clore.ai/rent-3090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=ollama) | 24 GB | $0.30–1.00 | Modelos de 13B-34B     |
| [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=ollama) | 24 GB | $0.50–2.00 | Modelos de 34B, rápido |
| RTX 4070                                                                                           | 12 GB | $0.20–0.50 | Modelos de 7B          |
| A100 80 GB                                                                                         | 80 GB | $1.50–3.00 | Modelos de 70B         |

*Precios en USD/día. Las tarifas varían según el proveedor — consulta* [*Mercado de CLORE.AI*](https://clore.ai/marketplace) *para conocer las tarifas actuales.*

## Solución de problemas

### El modelo no se carga

```bash
# Comprueba la memoria disponible
nvidia-smi

# Prueba una cuantización menor
ollama pull llama3.1:8b-q4_0
```

### Generación lenta

```bash
# Comprueba si se usa la GPU
ollama run llama3.2 --verbose

# Asegúrate de que CUDA esté disponible
nvidia-smi
```

### Conexión rechazada

```bash
# Asegúrate de que el servidor esté en ejecución
ollama serve

# Comprueba si está enlazando a todas las interfaces
OLLAMA_HOST=0.0.0.0 ollama serve
```

### HTTP 502 en la URL http\_pub

Esto significa que el servicio todavía se está iniciando. Espera 30-60 segundos y vuelve a intentarlo:

```bash
# Comprueba si el servicio está listo
curl https://your-http-pub.clorecloud.net/

# Esperado: "Ollama is running"
# Si 502: espera y vuelve a intentarlo
```

## Siguientes pasos

* [Open WebUI](/guides/guides_v2-es/modelos-de-lenguaje/open-webui.md) - Interfaz de chat hermosa para Ollama
* [vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) - Servicio de producción de alto rendimiento
* [DeepSeek-R1](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-r1.md) - Modelo de razonamiento
* [DeepSeek-V3](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v3.md) - Mejor modelo general
* [Qwen2.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen25.md) - Alternativa multilingüe
* [Text Generation WebUI](/guides/guides_v2-es/modelos-de-lenguaje/text-generation-webui.md) - Funciones avanzadas


---

# 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/modelos-de-lenguaje/ollama.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.