Ollama: ejecuta LLMs en tu propio hardware

Primer modelo en tres comandos

Una vez instalado Ollama, ejecutar tu primer modelo es inmediato. Si ollama run no encuentra el modelo localmente, lo descarga automáticamente de la biblioteca oficial.

# Ejecutar Llama 3.2 (3B parámetros, ~2 GB)
ollama run llama3.2

# Listar modelos descargados
ollama list

# Descargar un modelo sin ejecutarlo
ollama pull deepseek-r1:7b

# Ver informacion de un modelo
ollama show llama3.2

La primera vez que ejecutas un modelo, Ollama lo descarga en ~/.ollama/models/. Los modelos se almacenan en formato GGUF y se cargan directamente en VRAM si hay GPU disponible, o en RAM si no. Puedes consultar la biblioteca completa en ollama.com/library.

Para ver todos los modelos disponibles y sus variantes de cuantización visita ollama.com/library. Puedes explorar los modelos por categoría: código, razonamiento, visión, embedding o multimodal. La nomenclatura de etiquetas sigue el patrón modelo:tamaño-cuantización, por ejemplo deepseek-r1:14b-instruct-q4_K_M. Si no específicas etiqueta, Ollama descarga la variante recomendada para uso general.

Además de los modelos de la biblioteca oficial, puedes importar cualquier modelo en formato GGUF descargado desde Hugging Face u otras fuentes mediante ollama create y un archivo Modelfile. Esto te permite usar modelos ajustados (fine-tuned) o modelos propietarios que hayas entrenado internamente. Consulta la documentación oficial en github.com/ollama/ollama para el formato exacto del Modelfile.

API compatible con OpenAI

Ollama expone el endpoint http://localhost:11434/v1/ que implementa el mismo esquema de la API de OpenAI. Esto significa que puedes usar el SDK oficial de OpenAI, LangChain, LlamaIndex u otras bibliotecas simplemente cambiando la URL base y el modelo.

# Con Python y el SDK de OpenAI
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1/",
    api_key="ollama",  # puede ser cualquier cadena
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "system", "content": "Eres un asistente util."},
        {"role": "user", "content": "Explica que es un agente de IA en dos parrafos."},
    ],
)
print(response.choices[0].message.content)

API nativa de Ollama

La API nativa de Ollama en http://localhost:11434/api/ ofrece funcionalidades adicionales como streaming nativo, gestión de modelos y acceso a metadatos del modelo. Es la recomendada si construyes integraciones específicas para Ollama.

# Chat con la API nativa (curl)
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Que diferencia hay entre LLM y un agente de IA?"}
  ],
  "stream": false
}'

# Listar modelos instalados via API
curl http://localhost:11434/api/tags

# Verificar que Ollama esta corriendo
curl http://localhost:11434/api/version

Embeddings con Ollama

Ollama también soporta generación de embeddings, necesarios para implementar búsqueda semántica y RAG (Retrieval Augmented Generation). Los modelos de embedding más usados son nomic-embed-text y mxbai-embed-large.

# Generar embeddings
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "El agente de IA proceso la solicitud del usuario."
}'

Iniciar Ollama con Docker

# Solo CPU
docker run -d \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

# Con GPU NVIDIA (requiere nvidia-container-toolkit)
docker run -d \
  --gpus=all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

# Ejecutar un modelo dentro del contenedor
docker exec -it ollama ollama run llama3.2

Docker Compose con interfaz web

La forma más completa de desplegar Ollama es combinarlo con Open WebUI, una interfaz gráfica web compatible que permite usar Ollama desde el navegador de forma similar a ChatGPT, con soporte para múltiples usuarios y gestión de conversaciones.

# docker-compose.yml
services:
  ollama:
    image: ollama/ollama
    volumes:
      - ollama:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    depends_on:
      - ollama

volumes:
  ollama:

Con esta configuración accedes a la interfaz web en http://localhost:3000. Open WebUI también soporta la API de OpenAI, por lo que puedes conectar tanto Ollama como proveedores cloud desde la misma interfaz. Para entornos sin GPU, elimina el bloque deploy.resources del docker-compose.

¿Qué nivel de cuantización elegir?

La cuantización reduce la precisión numérica de los pesos del modelo para que ocupen menos memoria. Ollama usa el formato GGUF con varios niveles:

• Q4_K_M: el equilibrio más recomendado. Reduce el tamaño a aproximadamente un 35% del original con una pérdida de calidad apenas perceptible. Es la variante por defecto en la mayoría de modelos de la biblioteca de Ollama.
• Q5_K_M: un poco más grande que Q4_K_M pero con mejor calidad. Buena opción si tienes VRAM de sobra y quieres maximizar precisión.
• Q8_0: prácticamente equivalente al modelo en precisión completa. Ocupa el doble que Q4_K_M. Recomendado cuando la calidad es crítica y el hardware lo permite.
• F16: el modelo sin cuantizar. Solo tiene sentido en hardware con gran cantidad de VRAM o para fines de investigación.

Si tu GPU no tiene suficiente VRAM para cargar el modelo completo, Ollama distribuye automáticamente las capas entre VRAM y RAM del sistema (offloading). El rendimiento baja significativamente cuando hay offloading, pero el modelo sigue siendo funcional. Puedes ver cuántas capas se cargan en GPU con ollama ps.

Hardware compatible con Ollama

• NVIDIA: cualquier GPU con CUDA 12+ y al menos 4 GB de VRAM. Las series RTX 3000, 4000 y 5000 son las más comunes en entornos de desarrollo.
• AMD: GPUs con ROCm 5.7+ en Linux. Soporte experimental en Windows.
• Apple Silicon: M1, M2, M3 y M4 con aceleración Metal nativa. La memoria unificada (hasta 128 GB en Mac Pro) permite ejecutar modelos muy grandes.
• Solo CPU: funciona pero es significativamente más lento. Recomendable solo para modelos de 3B o menores, o para desarrollo y pruebas.

DeepSeek-R1 es un modelo de razonamiento desarrollado por la empresa china DeepSeek que compite con los mejores modelos de OpenAI en tareas de matemáticas, código y lógica, pero con un tamaño mucho más eficiente en relación con su rendimiento. Las variantes más pequeñas (7B y 14B parámetros) son ejecutables en hardware de consumo con GPU de gama media-alta.

La popularidad de la combinación Ollama + DeepSeek se debe a varios factores:

• Razonamiento en cadena visible: DeepSeek-R1 muestra su proceso de pensamiento en bloques <think>, lo que lo hace ideal para tareas que requieren transparencia en el razonamiento.
• Rendimiento en código: supera a la mayoría de modelos de su tamaño en benchmarks de generación y explicación de código. Es una alternativa local sólida a GPT-4 para asistentes de programación.
• Bajo coste de hardware: la variante de 7B funciona correctamente en GPUs con 8 GB de VRAM, accesibles desde 300-400 euros en el mercado de segunda mano.

# Descargar y ejecutar DeepSeek-R1 de 7B (recomendado para empezar)
ollama pull deepseek-r1:7b

# O la variante de 14B para mayor calidad (requiere 16 GB VRAM)
ollama pull deepseek-r1:14b

# Ejecutar con contexto extendido
ollama run deepseek-r1:7b --verbose

# Via API (compatible OpenAI)
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:7b",
    "messages": [{"role": "user", "content": "Implementa un algoritmo de busqueda binaria en Python con tests."}]
  }'

Para profundizar en DeepSeek y sus variantes, tenemos una guía específica en Ollama con DeepSeek: guía completa. Puedes además comparar modelos de razonamiento local frente a los modelos cloud en nuestra sección de comparativas.

Elige Ollama si eres desarrollador, trabajas principalmente desde terminal y necesitas integraciones programáticas rápidas. Es también la mejor opción para configurar modelos locales como backend de herramientas como Claude Code u otros agentes de coding. Para una comparativa detallada entre Ollama y LM Studio, visita Ollama vs LLM Studio.

Elige LM Studio si prefieres una interfaz gráfica, quieres explorar modelos visualmente sin tocar el terminal o no tienes experiencia con herramientas CLI. Elige llama.cpp si necesitas el máximo control y rendimiento posible, o si integras la inferencia directamente en tu código C/C++. Elige vLLM si tienes un caso de producción con múltiples usuarios concurrentes y necesitas maximizar el throughput: vLLM implementa PagedAttention y otras optimizaciones que lo hacen significativamente más eficiente que Ollama para cargas altas.

Para el desarrollo de modelos LLM en general y la arquitectura de agentes que los consumen, consulta nuestra guía de frameworks para agentes de IA donde comparamos tanto opciones cloud como locales en el contexto completo de un agente en producción.