Ollama: cómo instalar y correr modelos de IA localmente en tu PC (2026)

¿Qué es Ollama y por qué deberías usarlo?

Ollama es la forma más sencilla de correr modelos de IA en tu propio PC, sin internet, sin API keys y sin coste. Con más de 500 modelos disponibles — incluyendo Llama, Qwen, DeepSeek, Gemma y muchos otros — Ollama te permite tener un asistente de IA completamente privado y gratuito.

A diferencia de ChatGPT o Claude, que envían tus datos a servidores externos, Ollama corre 100% en local. Tus conversaciones, tu código y tus documentos nunca salen de tu máquina.

Requisitos de hardware

El hardware determina qué modelos puedes correr. Aquí tienes una guía rápida:

Hardware	RAM/VRAM	Modelos recomendados
Laptop básica	8 GB RAM	Llama 3.2 (3B), Phi-3.5 (3.8B)
Laptop media	16 GB RAM	Llama 3.1 (8B), gpt-oss:20b, Qwen 2.5 Coder (7B)
PC con GPU	16-24 GB VRAM	Qwen 2.5 Coder (32B), Devstral (24B), DeepSeek R1 (14B)
Mac M4 (32 GB)	32 GB unificada	Qwen 2.5 (32B), Llama 3.3 (70B con offloading)
Workstation	48+ GB VRAM	Llama 3.3 (70B), Qwen 3 (235B con offloading)

Paso 1 — Instalar Ollama

Windows

La forma más sencilla es descargar el instalador:

# Opción 1: Descargar desde la web
# Visita https://ollama.com/download/windows y ejecuta el .exe

# Opción 2: Usar winget
winget install Ollama.Ollama

Después de instalar, Ollama se ejecuta como una app en segundo plano. La API estará disponible en http://localhost:11434.

macOS

# Opción 1: Descargar desde ollama.com (recomendado)
# Visita https://ollama.com/download y instala el .dmg

# Opción 2: Homebrew
brew install ollama

En macOS, Ollama se ejecuta como una app en la barra de menú. La aceleración Metal en Apple Silicon es automática.

Linux

# Instalación con un comando
curl -fsSL https://ollama.com/install.sh | sh

El script detecta automáticamente tu GPU (NVIDIA/AMD) y configura los drivers. Para NVIDIA, asegúrate de tener CUDA 11.8+ instalado.

Verificar la instalación

ollama --version
# Debe mostrar: ollama version is 0.30.x (o superior)

Paso 2 — Tu primer modelo

Descarga y ejecuta Llama 3.1 8B, el modelo recomendado para empezar:

ollama run llama3.1

La primera vez descarga el modelo (~4.7 GB). Las siguientes ejecuciones arrancan instantáneamente desde caché. Una vez cargado, puedes chatear directamente:

>>> ¿Cuál es la capital de Francia?
La capital de Francia es París.

>>> Escribe una función Python para ordenar una lista.
def ordenar_lista(lista):
    return sorted(lista)

# Pulsa Ctrl+D para salir

Modelos recomendados para empezar según tu hardware

# PC con 8 GB RAM
ollama run llama3.2:3b

# PC con 16 GB RAM  
ollama run llama3.1

# PC con GPU 24 GB o Mac 32 GB
ollama run qwen2.5:32b

# Workstation con 48+ GB
ollama run llama3.3:70b

Paso 3 — Comandos esenciales

Estos son los comandos que más vas a usar:

Gestión de modelos

# Listar modelos descargados
ollama list

# Descargar un modelo sin ejecutarlo
ollama pull qwen2.5-coder:7b

# Eliminar un modelo
ollama rm mistral

# Ver detalles de un modelo (tamaño, parámetros, template)
ollama show llama3.1

# Copiar un modelo (para crear variantes)
ollama cp llama3.1 mi-asistente

Ejecutar modelos

# Chat interactivo
ollama run llama3.1

# Prompt único (sin modo interactivo)
ollama run llama3.1 "Explica computación cuántica en un párrafo"

# Pasar contenido de un archivo
cat codigo.py | ollama run qwen2.5-coder:7b "Revisa este código en busca de bugs"

# Establecer system prompt
ollama run llama3.1 --system "Eres un tutor de Python paciente y claro"

Gestión del servidor

# Iniciar el servidor (macOS lo hace automáticamente)
ollama serve

# Ver modelos cargados en memoria
ollama ps

# Detener un modelo y liberar memoria
ollama stop llama3.1

Variables de entorno útiles

# Cambiar ubicación de almacenamiento (default: ~/.ollama/models)
export OLLAMA_MODELS=/ruta/a/modelos

# Cambiar puerto de la API (default: 11434)
export OLLAMA_HOST=0.0.0.0:11434

# Tiempo que los modelos permanecen en memoria (default: 5m)
export OLLAMA_KEEP_ALIVE=30m

# Limitar capas en GPU (para offloading parcial)
export OLLAMA_NUM_GPU=20

# Activar logging de debug
export OLLAMA_DEBUG=1

Paso 4 — Elegir el modelo correcto

La librería de Ollama tiene más de 500 modelos. Estos son los mejores en cada categoría para 2026:

Mejores modelos para programación

Modelo	Tamaño	Contexto	Ideal para
qwen3-coder:30b	19 GB	256K	Mejor calidad/VRAM — GPU 24-32 GB o Mac 32 GB
devstral:24b	14 GB	128K	Mejor score agéntico (46.8% SWE-Bench) — RTX 4090 o Mac 32 GB
gpt-oss:20b	14 GB	128K	Mejor en 16 GB RAM — OpenAI open weights
qwen2.5-coder:32b	19 GB	128K	Referencia de generación anterior, 92.7% HumanEval
qwen2.5-coder:7b	4.7 GB	128K	Mejor para laptops sin GPU dedicada

Mejores modelos para chat general

Modelo	Tamaño	Ideal para
llama3.3:70b	43 GB	Mejor calidad general, comparable a Llama 3.1 405B
qwen2.5:32b	19 GB	Excelente balance calidad/tamaño, multilingüe
gemma3:27b	17 GB	Multimodal (visión + texto), 140+ idiomas
phi3.5	3.8 GB	Ligero, ideal para laptops básicas

Mejores modelos para razonamiento y matemáticas

# DeepSeek R1 — razonamiento paso a paso
ollama run deepseek-r1:14b

# Qwen 2.5 — fuerte en matemáticas
ollama run qwen2.5:14b

Modelos para RAG (embeddings)

# Embeddings para búsqueda semántica
ollama pull nomic-embed-text
ollama pull mxbai-embed-large

Paso 5 — Aceleración GPU

NVIDIA (recomendado)

Ollama usa GPUs NVIDIA automáticamente si los drivers CUDA están instalados:

# Verificar que la GPU está detectada
nvidia-smi

# Verificar que Ollama usa la GPU
ollama ps
# La columna PROCESSOR debe mostrar "GPU"

Apple Silicon (Metal)

La aceleración Metal es automática en Mac M1/M2/M3/M4. La memoria unificada permite que el modelo use toda la RAM del sistema. Un Mac M4 Max con 32 GB corre modelos de 32B a velocidad casi nativa.

AMD (ROCm)

En Linux, instala ROCm 6.0+ y Ollama detectará GPUs AMD automáticamente. En Windows, el soporte de AMD es experimental.

Offloading parcial

Si tu modelo es demasiado grande para la VRAM, Ollama divide automáticamente entre GPU y CPU:

# Controlar manualmente las capas en GPU
OLLAMA_NUM_GPU=20 ollama run llama3.3:70b
# 0 = solo CPU, -1 = todas las capas en GPU

Paso 6 — Crear modelos personalizados con Modelfiles

Puedes crear modelos personalizados con system prompts y parámetros específicos:

# Crear un Modelfile
cat > Modelfile << 'EOF'
FROM llama3.1
SYSTEM "Eres un asistente técnico experto en Python y JavaScript. Responde en español, sé conciso y proporciona ejemplos de código."
PARAMETER temperature 0.7
PARAMETER num_ctx 8192
EOF

# Crear el modelo
ollama create mi-tutor -f Modelfile

# Ejecutarlo
ollama run mi-tutor

Paso 7 — Usar la API REST

Ollama expone una API REST en http://localhost:11434, compatible con OpenAI:

Chat endpoint (recomendado)

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.1",
  "messages": [
    {"role": "user", "content": "Hola, ¿qué puedes hacer?"}
  ]
}'

Endpoint compatible con OpenAI

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "llama3.1",
  "messages": [
    {"role": "user", "content": "Escribe un haiku sobre IA"}
  ]
}'

Usar desde Python

import requests

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "llama3.1",
        "messages": [{"role": "user", "content": "Explica RAG en español"}],
        "stream": False
    }
)
print(response.json()["message"]["content"])

Usar desde JavaScript/TypeScript

const response = await fetch("http://localhost:11434/api/chat", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "llama3.1",
    messages: [{ role: "user", content: "Explica RAG en español" }],
    stream: false
  })
});
const data = await response.json();
console.log(data.message.content);

Paso 8 — Instalar Open WebUI (interfaz visual)

Aunque la CLI funciona genial, muchos prefieren una interfaz visual. Open WebUI es la opción más popular, con soporte para subida de archivos, RAG, gestión de conversaciones y plugins.

# Instalar con Docker (recomendado)
docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

# Abrir en el navegador
# http://localhost:3000

Open WebUI detecta automáticamente Ollama en localhost:11434 y te da una interfaz tipo ChatGPT con cambio de modelos, historial de conversaciones y subida de documentos.

Paso 9 — Integrar Ollama con agentes de IA

Ollama es el backend perfecto para agentes de IA open source que soportan modelos locales:

Hermes Agent

# Configurar Ollama como proveedor en Hermes
hermes model
# Seleccionar Ollama y elegir el modelo

# O directamente:
ollama pull qwen2.5-coder:7b
hermes config set model ollama/qwen2.5-coder:7b

OpenClaw

# Configurar Ollama en OpenClaw
ollama pull llama3.1:8b
openclaw config set model ollama/llama3.1:8b

Solución de problemas

El modelo no descarga

# Verificar espacio disponible
df -h ~/.ollama

# Limpiar descargas parciales y reintentar
ollama rm nombre-modelo
ollama pull nombre-modelo

GPU no detectada

# NVIDIA: verificar driver
nvidia-smi

# Verificar que Ollama ve la GPU
OLLAMA_DEBUG=1 ollama serve 2>&1 | grep -i gpu

# Reiniciar Ollama
sudo systemctl restart ollama  # Linux
# O reinicia la app en macOS/Windows

Sin memoria (Out of Memory)

# Usar cuantización más pequeña
ollama pull llama3.1:8b-instruct-q2_K

# Reducir contexto en Modelfile
PARAMETER num_ctx 2048

# Usar un modelo más pequeño
ollama run phi3.5  # 3.8B en lugar de 8B

Generación lenta

1. Verifica que la GPU se está usando: ollama ps debe mostrar "GPU"
2. Reduce el contexto (num_ctx)
3. Cierra otras apps que usen GPU
4. Usa un modelo que quepa completamente en VRAM
5. Considera usar OLLAMA_KV_CACHE_TYPE=q8_0 para reducir el consumo de memoria del KV cache

Optimización de rendimiento

1. Cuantización adecuada: Ollama usa Q4_K_M por defecto (~4.5 bits por peso). Para programación, prefiere q8_0 cuando la VRAM lo permita — menos errores sutiles.
2. Optimiza el contexto: El contexto largo consume memoria. Un modelo 70B añade ~14 GB a 32K de contexto y 40+ GB a 128K.
3. Mantén modelos cargados: OLLAMA_KEEP_ALIVE=30m mantiene el modelo en memoria entre consultas.
4. Batch processing: Para múltiples consultas, usa la API con streaming para procesar en paralelo.
5. Monitoriza: Usa ollama ps para ver qué modelos están cargados y cuánta memoria consumen.

Conclusión

Ollama es la herramienta más accesible para correr IA localmente. En menos de 5 minutos puedes tener un modelo potente funcionando en tu PC, sin coste y sin enviar datos a ningún servidor. Ya sea para programar, chatear, hacer RAG con documentos privados o como backend para agentes como Hermes Agent y OpenClaw, Ollama te da control total sobre tu IA.

La clave está en elegir el modelo correcto para tu hardware y configurar bien el contexto. Empieza con Llama 3.1 8B, explora modelos especializados según tus necesidades, y cuando necesites una interfaz visual, añade Open WebUI.