Ollama

Ejecuta LLMs localmente con Ollama en GPUs de Clore.ai

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

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+ para más detalles.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Mercado de CLORE.AI.

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	-

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.

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

ollama serve

Verifica que funciona

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

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

# Respuesta esperada: "Ollama is running"

Si obtienes HTTP 502, espera 30-60 segundos: el servicio todavía se está iniciando.

Acceso a tu servicio

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

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

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.

Instalación

Usando Docker (recomendado)

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

Instalación manual

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

# 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

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

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:

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:

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

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:

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:

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

# 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

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

Añade "stream": false para obtener la respuesta completa de una vez en lugar de en streaming.

Endpoint compatible con OpenAI

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

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

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

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

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

Respuesta:

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

Mostrar detalles del modelo

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

Descargar modelo vía API

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

Respuesta:

{"status": "success"}

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

Eliminar modelo

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

Listar modelos en ejecución

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

Respuesta:

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

Obtener versión

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

Respuesta:

{"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:

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

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

CUDA_VISIBLE_DEVICES=0 ollama serve

Gestión de memoria

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

# Modelfile
FROM llama3.2

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

PARAMETER temperature 0.7
PARAMETER top_p 0.9

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

Ejecutar como servicio

Systemd

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

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

   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	24 GB	$0.30–1.00	Modelos de 13B-34B
RTX 4090	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 para conocer las tarifas actuales.

Solución de problemas

El modelo no se carga

# Comprueba la memoria disponible
nvidia-smi

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

Generación lenta

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

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

Conexión rechazada

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

# 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 - Interfaz de chat hermosa para Ollama

• vLLM - Servicio de producción de alto rendimiento

• DeepSeek-R1 - Modelo de razonamiento

• DeepSeek-V3 - Mejor modelo general

• Qwen2.5 - Alternativa multilingüe

• Text Generation WebUI - Funciones avanzadas