Ollama: cómo correr LLMs en local desde tu homelab (sin nube, sin API keys)

Hace tiempo que tengo Ollama corriendo en mi servidor, y todavía me sorprende lo que es posible hacer con hardware razonablemente normal. No tienes que tener una GPU de datacenter para correr modelos de lenguaje útiles. Con lo que ya tienes en el homelab, probablemente puedas empezar hoy mismo.

Esta es la guía que me hubiera gustado encontrar cuando empecé: sin rodeos, con números reales, y con los problemas que me encontré por el camino.

Qué es Ollama y por qué importa

#

Ollama es una herramienta que simplifica enormemente correr modelos de lenguaje de forma local. Antes, desplegar un LLM localmente requería navegar entre dependencias de Python, CUDA, formatos de modelo incompatibles y configuraciones crípticas. Ollama empaqueta todo eso en algo que funciona con un solo comando.

La propuesta es simple: ollama run llama3.2 descarga el modelo y abre una sesión de chat interactiva. Eso es todo. Por debajo gestiona la descarga, el formato de cuantización, la memoria necesaria y el servidor de inferencia.

Lo que me motivó a montarlo no fue solo la privacidad (aunque eso importa). Fue el coste. Usando modelos de lenguaje de forma intensiva para automatizaciones, análisis de texto y asistencia en código, las facturas de API pueden crecer rápido. Con hardware propio, el coste marginal es prácticamente cero.

Hardware: qué necesitas realmente

#

Aquí es donde mucha gente se pierde. Los requisitos dependen de qué modelos quieres correr:

Solo CPU (sin GPU): funciona, pero es lento. Un modelo de 7B parámetros en CPU tarda varios segundos por respuesta. Para un chatbot personal que espera tus respuestas, puede ser aceptable. Para automatizaciones que procesan muchos textos, es demasiado lento.

GPU con VRAM limitada (4-8GB): puedes correr modelos de 7B cuantizados (Q4 o Q5) sin problema. Con 8GB de VRAM llegas cómodamente a modelos de 7-8B, que ya son capaces de tareas complejas.

GPU con 12-16GB VRAM: modelos de 13-14B cuantizados, o modelos de 7B con cuantización de mayor calidad. Aquí ya tienes algo serio para el día a día.

24GB VRAM o más: modelos de 34B cuantizados, o modelos más pequeños sin pérdida de calidad. Resultados muy buenos en casi cualquier tarea.

En mi servidor uso dos NVIDIA A2000 de 12GB cada una. No son las GPUs más modernas, pero para inferencia local funcionan bien. Con una A2000, corro modelos de 7B a buena velocidad y modelos de 14B a velocidad aceptable.

Si no tienes GPU, un servidor con CPU potente y mucha RAM también da resultados decentes para uso personal. Con 64GB de RAM puedes cargar modelos de hasta 32B en CPU (lento, pero funcional).

Instalación: en Linux/servidor

#

La instalación en Linux es directa:

1

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

El script detecta si tienes GPU NVIDIA o AMD y configura los drivers necesarios. Después de instalar, el servicio arranca automáticamente.

Si prefieres instalarlo manualmente (útil en entornos más controlados):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Descargar el binario directamente
wget https://github.com/ollama/ollama/releases/latest/download/ollama-linux-amd64
chmod +x ollama-linux-amd64
sudo mv ollama-linux-amd64 /usr/local/bin/ollama

# Crear usuario del servicio
sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama

# Crear el servicio systemd
sudo tee /etc/systemd/system/ollama.service > /dev/null <<EOF
[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/local/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="HOME=/usr/share/ollama"

[Install]
WantedBy=default.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable --now ollama

Para verificar que el servicio está corriendo:

1
2

systemctl status ollama
curl http://localhost:11434/api/version

Configuración para acceso remoto

#

Por defecto, Ollama solo escucha en localhost. Para acceder desde otros dispositivos de tu red, necesitas cambiar esto:

1
2
3
4
5
6

# En el archivo de servicio systemd, añade:
Environment="OLLAMA_HOST=0.0.0.0:11434"

# Recargar y reiniciar
sudo systemctl daemon-reload
sudo systemctl restart ollama

En producción, no expongas Ollama directamente a internet. Ponle un reverse proxy con autenticación por delante, o accede a través de Tailscale si usas VPN mesh.

Descargar y correr modelos

#

Una vez instalado, descargar un modelo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Modelos pequeños y rápidos (recomendados para empezar)
ollama pull llama3.2:3b      # 2GB, muy rápido
ollama pull mistral:7b       # 4GB, buen equilibrio
ollama pull qwen2.5:7b       # 4.7GB, muy bueno en código y castellano

# Modelos más capaces
ollama pull llama3.1:8b      # 4.7GB, el estándar actual
ollama pull llama3.2:11b     # 7.9GB, con capacidades de visión
ollama pull mistral:latest   # 4.1GB, excelente para instrucciones

# Modelos de código
ollama pull deepseek-coder-v2:16b  # 9GB, especializado en código
ollama pull qwen2.5-coder:7b       # 4.4GB, muy bueno para código

Para arrancar una sesión interactiva:

1

ollama run llama3.1:8b

Para listar los modelos que tienes:

1

ollama list

Para ver cuánta VRAM y RAM usa un modelo mientras está cargado:

1

ollama ps

Rendimiento real: números de mi setup

#

Para que te hagas una idea de qué esperar, estos son tiempos reales en mi servidor con una A2000 12GB:

“Tokens/segundo” es la velocidad de generación. Un token es aproximadamente 0.75 palabras. A 38 tokens/segundo, lees una respuesta de 200 palabras en unos 7 segundos. Usable para chat interactivo, aunque no tan fluido como GPT-4.

En CPU (sin GPU), un i9-12900K con 64GB DDR5:

CPU pura es lenta, pero funcional para uso personal sin urgencia.

Open WebUI: la interfaz gráfica

#

La línea de comandos está bien para pruebas, pero para uso diario quieres una interfaz. Open WebUI es el frontend más completo para Ollama:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# docker-compose.yml
version: "3.9"
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    restart: unless-stopped
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://192.168.1.100:11434
    volumes:
      - open-webui-data:/app/backend/data

volumes:
  open-webui-data:

Cambia 192.168.1.100 por la IP de tu servidor donde corre Ollama. Después de docker compose up -d, accedes desde el navegador en el puerto 3000.

Open WebUI tiene bastante más de lo básico: historial de conversaciones, carga de documentos para RAG básico, gestión de múltiples modelos, creación de “personalidades” preconfiguradas con system prompts, y soporte para imágenes con modelos multimodales.

Lo que me parece más útil en el día a día es poder tener un perfil preconfigurado por tarea. Uno para revisar código (con instrucciones específicas para ese modelo), otro para borradores de texto, otro para análisis de datos. Cambiar entre ellos es dos clics.

Integración con la API

#

Ollama expone una API REST compatible con la API de OpenAI. Esto es fundamental porque significa que cualquier herramienta que soporte OpenAI puede apuntar a tu instancia local con un cambio mínimo.

Para usar Ollama con cualquier cliente compatible con OpenAI:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from openai import OpenAI

client = OpenAI(
    base_url="http://tu-servidor.local:11434/v1",
    api_key="no-necesaria"  # Ollama no requiere API key
)

response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[
        {"role": "user", "content": "Explícame qué es un namespace en Kubernetes"}
    ]
)

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

Uso esto para automatizaciones en n8n, para scripts de procesamiento de texto, y para integrar el LLM en flujos de trabajo sin tocar ninguna API de pago.

Modelos multilingues y castellano

#

Una pregunta frecuente: ¿qué tal funcionan estos modelos en castellano?

La respuesta corta es: mejor de lo que la gente espera, pero no igual que en inglés.

Los modelos Llama 3.1 y Qwen 2.5 entienden y generan castellano de forma bastante natural. La calidad cae un poco comparado con inglés en tareas complejas de razonamiento, pero para uso general (redacción, resúmenes, análisis de texto) funciona bien.

Qwen 2.5 tiene en mi experiencia la mejor relación calidad/velocidad para castellano entre los modelos de 7B. Mistral también da buenos resultados.

Para tareas que mezclan castellano e inglés (documentación técnica, código con comentarios), Llama 3.1 8B es el que mejor maneja el cambio de idioma sin “contaminarse” entre uno y otro.

Gestionar el espacio en disco

#

Los modelos ocupan bastante espacio. Un modelo de 7B cuantizado a Q4 ocupa entre 4 y 5GB. Si empiezas a acumular modelos sin orden, llenas el disco rápido.

Para ver cuánto ocupa todo:

1
2
3

ollama list
# o ver el directorio directamente:
du -sh ~/.ollama/models/

Para borrar un modelo que ya no usas:

1

ollama rm nombre-del-modelo

Ollama guarda los modelos en ~/.ollama/models/ por defecto. Si quieres cambiarlo a otro disco con más espacio:

1
2

# Añadir a la configuración del servicio:
Environment="OLLAMA_MODELS=/ruta/a/disco/grande/ollama"

Yo tengo un disco dedicado para modelos con 500GB, lo que me da margen para experimentar sin preocuparme del espacio.

Problemas que me encontré

#

Modelo cargándose en CPU cuando debería ir a GPU: pasa cuando la VRAM no es suficiente para el modelo completo. Ollama carga lo que puede en GPU y el resto en RAM/CPU, lo que reduce mucho el rendimiento. La solución es usar una cuantización menor (Q4 en vez de Q8, por ejemplo) o elegir un modelo más pequeño.

Para ver si un modelo está usando GPU:

1
2

ollama ps
# Muestra el porcentaje cargado en GPU vs CPU

Respuestas lentas aunque hay GPU disponible: revisa con nvidia-smi si la GPU está siendo utilizada. Si el porcentaje de uso es bajo, puede ser que el proceso de Ollama no tenga permisos para acceder a la GPU, especialmente si instalaste con usuario sin privilegios.

Open WebUI no conecta con Ollama: verifica que Ollama esté escuchando en la IP correcta (OLLAMA_HOST=0.0.0.0:11434) y que no haya un firewall bloqueando el puerto 11434 entre el contenedor de Open WebUI y el host.

El modelo se descarga lento: los modelos vienen de los servidores de Ollama. Con conexiones lentas, la descarga de un modelo de 5GB puede tardar mucho. No hay mirror oficial, pero puedes descargar los modelos desde Hugging Face en formato GGUF y cargarlos manualmente con ollama create.

Modelfiles: personaliza tus modelos

#

Una función que poca gente usa al principio son los Modelfiles. Puedes crear versiones personalizadas de cualquier modelo base con parámetros y system prompts fijos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FROM llama3.1:8b

PARAMETER temperature 0.7
PARAMETER num_ctx 4096

SYSTEM """
Eres un asistente técnico especializado en administración de sistemas Linux y Kubernetes. 
Respondes siempre con ejemplos de comandos concretos y explicas qué hace cada uno.
Cuando no estés seguro de algo, lo dices claramente en vez de inventarlo.
"""

Para crear el modelo:

1
2

ollama create mi-asistente-sysadmin -f Modelfile
ollama run mi-asistente-sysadmin

Esto aparece como un modelo independiente en ollama list y en Open WebUI. La utilidad práctica es tener perfiles optimizados para cada caso de uso sin tener que reconfigurar el system prompt cada vez.

Lo que espero de aquí en adelante

#

El ritmo de mejora en modelos locales es brutal. Hace un año, los modelos de 7B locales eran claramente inferiores a GPT-3.5 en la mayoría de tareas. Hoy, modelos como Llama 3.1 8B o Qwen 2.5 7B están a un nivel que los hace genuinamente útiles para trabajo real.

La privacidad es el argumento más obvio para ir local. Todo lo que le das a un LLM externo (tu código, tus documentos, tus ideas) pasa por servidores de otra empresa. Con Ollama, nada sale de tu red.

El argumento económico también es sólido para uso intensivo. Si usas modelos de lenguaje para automatizaciones que procesan cientos de textos al día, el coste de API se acumula. Con hardware propio, eso desaparece.

No es para todo el mundo. Si usas ChatGPT tres veces a la semana para cosas puntuales, la complejidad de montar esto no vale la pena. Pero si ya tienes homelab, probablemente tienes el hardware que necesitas, y el tiempo de instalación es de menos de una hora.

¿Ya tienes Ollama montado? ¿Qué modelos usas más? Cuéntame en los comentarios, especialmente si tienes algo que funcione bien en castellano.