Ollama Docker Compose: Ejecuta IA Localmente En Tu PC 2025

Ollama Docker Compose es la solución definitiva para ejecutar modelos de inteligencia artificial de gran tamaño directamente en tu equipo, sin depender de servicios en la nube ni APIs de pago. En esta guía completa aprenderás a desplegar Ollama de manera profesional, configurar aceleración GPU con NVIDIA, gestionar modelos como Llama 3.3, Mistral y Gemma, y crear tu propio asistente de IA local completamente privado.

¿Qué es Ollama?

Ollama es una plataforma open-source diseñada para ejecutar modelos de lenguaje grandes (LLMs) de forma local en tu hardware. A diferencia de ChatGPT o Claude que requieren conexión a internet y procesan tus datos en servidores externos, Ollama te permite ejecutar modelos similares completamente offline en tu PC, servidor o homelab.

La herramienta ha ganado enorme popularidad en 2025, acumulando más de 100 millones de descargas gracias a su facilidad de uso y la creciente demanda de soluciones de IA privadas. Soporta una amplia biblioteca de modelos preentrenados incluyendo Llama 3.3 (con 70B y 405B parámetros), Mistral 7B, Gemma 3 (hasta 27B), DeepSeek-R1, y modelos especializados como CodeLlama para programación.

Ventajas de Usar Ollama Docker Compose

Desplegar ollama docker compose ofrece múltiples beneficios frente a instalaciones tradicionales:

Privacidad total: Tus conversaciones y datos nunca salen de tu red local
Cero costos de API: No pagas por tokens ni suscripciones mensuales
Aislamiento: El contenedor mantiene Ollama separado de tu sistema operativo
Portabilidad: Migra tu configuración entre servidores con un simple archivo YAML
Escalabilidad: Añade interfaces web, bases de datos vectoriales o múltiples GPUs fácilmente
Reproducibilidad: La misma configuración funciona en desarrollo, staging y producción
Gestión simplificada: Actualiza Ollama con un solo comando sin reinstalaciones complejas

Requisitos Previos

Antes de instalar ollama docker compose, asegúrate de contar con:

Hardware Mínimo

RAM: Mínimo 8 GB (para modelos de 7B parámetros), 16 GB recomendado para modelos de 13B, 32 GB o más para modelos de 70B
Almacenamiento: 20-50 GB de espacio libre para modelos (cada modelo ocupa entre 4-40 GB según tamaño)
GPU (opcional pero recomendada): NVIDIA con 6+ GB VRAM para aceleración. Compatible con tarjetas RTX 3060, 4060, 4090, etc.
CPU: Cualquier procesador moderno de 4+ núcleos (la GPU acelera significativamente el rendimiento)

Software Necesario

Docker Engine 20.10 o superior
Docker Compose v2.0 o superior
NVIDIA Container Toolkit (solo si usas GPU NVIDIA)
Sistema operativo: Linux (Ubuntu/Debian recomendado), Windows con WSL2, o macOS

Para verificar tu instalación de Docker:

docker --version
docker compose version

Instalar Ollama Docker Compose: Configuración Básica

Vamos a crear una configuración básica de ollama docker compose sin GPU, ideal para probar la herramienta o ejecutar modelos pequeños en CPU.

Paso 1: Crear la Estructura de Directorios

mkdir -p ~/ollama-stack
cd ~/ollama-stack

Paso 2: Archivo docker-compose.yml Básico

Crea el archivo de configuración:

version: '3.8'

services:
  ollama:
    container_name: ollama
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=24h
      - OLLAMA_NUM_PARALLEL=2
    restart: unless-stopped

volumes:
  ollama_data:
    driver: local

Explicación de la Configuración

Puertos: El puerto 11434 expone la API REST de Ollama
Volumen ollama_data: Persiste modelos descargados entre reinicios del contenedor
OLLAMA_HOST=0.0.0.0: Permite conexiones desde fuera del contenedor (necesario para interfaces web)
OLLAMA_KEEP_ALIVE=24h: Mantiene modelos en memoria durante 24 horas para respuestas más rápidas
OLLAMA_NUM_PARALLEL=2: Procesa hasta 2 solicitudes simultáneas

Paso 3: Levantar el Servicio

docker compose up -d

Verifica que el contenedor está corriendo:

docker ps
docker logs ollama

Paso 4: Descargar y Probar un Modelo

Descarga el modelo Llama 3.1 de 8B parámetros (aproximadamente 4.7 GB):

docker exec -it ollama ollama pull llama3.1:8b

Prueba el modelo con una consulta:

docker exec -it ollama ollama run llama3.1:8b "¿Cuál es la capital de España?"

Configurar Ollama Docker Compose con GPU NVIDIA

La aceleración por GPU reduce dramáticamente los tiempos de respuesta de los modelos. Una consulta que toma 30 segundos en CPU puede ejecutarse en 2-3 segundos con GPU.

Paso 1: Instalar NVIDIA Container Toolkit

En Ubuntu/Debian:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Verifica la detección de GPU:

docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu22.04 nvidia-smi

Paso 2: docker-compose.yml con Soporte GPU

Actualiza tu configuración de ollama docker compose para incluir GPU:

version: '3.8'

services:
  ollama:
    container_name: ollama
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=24h
      - OLLAMA_NUM_PARALLEL=4
      - OLLAMA_GPU_OVERHEAD=1073741824
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama_data:
    driver: local

Reinicia el stack:

docker compose down
docker compose up -d

Verifica en los logs que la GPU fue detectada:

docker logs ollama | grep -i nvidia

Deberías ver un mensaje similar a: Nvidia GPU detected via cudart

Stack Completo: Ollama Docker Compose + Open WebUI

Open WebUI es una interfaz web similar a ChatGPT que se conecta a tu servidor Ollama, ofreciendo una experiencia visual profesional con historial de conversaciones, gestión de modelos, y soporte multimodal.

docker-compose.yml Completo

version: '3.8'

services:
  ollama:
    container_name: ollama
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=24h
      - OLLAMA_NUM_PARALLEL=4
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  open-webui:
    container_name: open-webui
    image: ghcr.io/open-webui/open-webui:latest
    ports:
      - "3000:8080"
    volumes:
      - open_webui_data:/app/backend/data
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - WEBUI_AUTH=false
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama_data:
    driver: local
  open_webui_data:
    driver: local

Levanta el stack completo:

docker compose up -d

Accede a la interfaz en: http://localhost:3000

Desde la interfaz podrás descargar modelos, crear conversaciones, ajustar parámetros de temperatura y top_p, y gestionar múltiples asistentes personalizados.

Modelos Recomendados para Ollama Docker Compose

Selecciona modelos según tu hardware:

Para 8 GB de RAM (CPU o GPU con 6 GB VRAM)

llama3.1:8b – Modelo general de Meta, excelente balance calidad/velocidad
mistral:7b – Muy rápido, ideal para consultas simples
gemma:2b – Ultraligero, perfecto para recursos limitados
phi:3.8b – Especializado en razonamiento y matemáticas

Para 16 GB de RAM (GPU con 12+ GB VRAM)

llama3.1:13b – Mayor capacidad de razonamiento
codellama:13b – Especializado en programación
qwen2.5:14b – Soporte multilingüe excepcional

Para 32+ GB de RAM (GPU con 24+ GB VRAM)

llama3.1:70b – Rendimiento comparable a GPT-4
deepseek-r1:70b – Razonamiento avanzado
qwen2.5:72b – Uno de los mejores modelos open-source

Descarga modelos con:

docker exec -it ollama ollama pull <nombre-modelo>

Lista modelos instalados:

docker exec -it ollama ollama list

Variables de Entorno Avanzadas

Optimiza tu configuración de ollama docker compose con estas variables:

OLLAMA_MAX_LOADED_MODELS=3 – Carga hasta 3 modelos simultáneamente en RAM
OLLAMA_FLASH_ATTENTION=1 – Activa Flash Attention para mayor velocidad (requiere GPU compatible)
OLLAMA_GPU_OVERHEAD=1073741824 – Reserva 1 GB de VRAM para overhead del sistema (ajusta según tu GPU)
OLLAMA_MODELS=/models – Cambia la ubicación de almacenamiento de modelos
OLLAMA_DEBUG=1 – Activa logs detallados para troubleshooting

Troubleshooting Común en Ollama Docker Compose

Error: «No GPU detected»

Verifica que el NVIDIA Container Toolkit está instalado y Docker reiniciado. Ejecuta:

docker run --rm --gpus all nvidia/cuda:12.2.0-base-ubuntu22.04 nvidia-smi

Error: «Cannot connect to Ollama API»

Asegúrate de que OLLAMA_HOST=0.0.0.0 está configurado. Verifica conectividad:

curl http://localhost:11434/api/tags

Modelo Muy Lento en CPU

Es normal. Los modelos de 7B+ son extremadamente lentos sin GPU. Usa modelos más pequeños (2B-3B) o considera añadir una GPU.

Error: «Out of Memory»

El modelo requiere más VRAM/RAM de la disponible. Reduce OLLAMA_NUM_PARALLEL a 1, o usa un modelo más pequeño.

Mejores Prácticas y Optimización

Usa volúmenes nombrados: Facilita backups y migraciones
Configura límites de recursos: Evita que Ollama consuma toda la RAM del host
Implementa reverse proxy: Usa Traefik o Nginx para SSL y acceso remoto seguro
Monitoriza rendimiento: Integra con Prometheus/Grafana para métricas de uso
Automatiza backups: Respalda el volumen ollama_data periódicamente
Actualiza regularmente: Ollama recibe mejoras de rendimiento frecuentes

Actualizar Ollama:

docker compose pull
docker compose up -d

Casos de Uso Reales

Asistente de código privado: Usa CodeLlama para autocompletado y refactoring sin enviar código propietario a APIs externas
Chatbot empresarial: Implementa asistentes internos con documentación confidencial sin riesgos de filtración
Análisis de documentos: Procesa PDFs, contratos y reportes con modelos multimodales localmente
Educación: Crea tutores personalizados sin costos de API para estudiantes
Investigación: Experimenta con fine-tuning y personalización de modelos sin restricciones

Enlaces Relacionados

Si te interesa expandir tu stack de IA y Docker Compose, revisa estos artículos:

Preguntas Frecuentes sobre Ollama Docker Compose

¿Puedo usar Ollama Docker Compose sin GPU?

Sí, pero el rendimiento será significativamente más lento. Los modelos pequeños (2B-7B) funcionan aceptablemente en CPU moderna, pero modelos grandes (13B+) requieren GPU para ser prácticos.

¿Cuánto espacio necesito para los modelos?

Depende de los modelos que descargues. Un modelo de 7B ocupa aproximadamente 4-5 GB, uno de 13B ocupa 8-10 GB, y los de 70B pueden ocupar 40+ GB. Reserva al menos 50 GB para tener varios modelos instalados.

¿Ollama funciona con GPUs AMD?

El soporte oficial es para NVIDIA. Existe soporte experimental para AMD ROCm, pero requiere configuración adicional y no está completamente estable en Docker.

¿Puedo acceder a Ollama desde otros dispositivos en mi red?

Sí, siempre que OLLAMA_HOST=0.0.0.0 esté configurado. Accede usando http://IP-DEL-SERVIDOR:11434. Para acceso externo seguro, implementa un reverse proxy con SSL.

¿Cuál es el mejor modelo para empezar?

Para la mayoría de usuarios, llama3.1:8b ofrece el mejor balance entre calidad de respuestas, velocidad y requisitos de hardware. Es versátil y funciona bien tanto en CPU como GPU.

Conclusión

Ollama docker compose democratiza el acceso a modelos de IA de última generación, permitiendo ejecutar asistentes inteligentes completamente privados en tu propio hardware. Ya sea que busques privacidad, ahorro de costos, o experimentación sin límites, esta solución ofrece flexibilidad incomparable.

Con la configuración presentada en esta guía, puedes desplegar desde un servidor básico con CPU hasta un stack profesional con aceleración GPU, interfaz web y múltiples modelos simultáneos. La comunidad de Ollama crece exponencialmente, con nuevos modelos y mejoras lanzadas constantemente.

¿Listo para tener tu propio ChatGPT privado? Implementa ollama docker compose hoy mismo y toma control total de tu infraestructura de IA.

Integración de Ollama Docker Compose con otras Herramientas

Una de las grandes ventajas de desplegar ollama docker compose es su fácil integración con el ecosistema Docker. Puedes combinar Ollama con múltiples servicios para crear soluciones avanzadas de IA.

Ollama + n8n para Automatización con IA

n8n es una plataforma de automatización que puede conectarse a tu servidor ollama docker compose para crear workflows inteligentes. Por ejemplo, puedes automatizar respuestas a emails, procesar documentos PDF con extracción de información, o generar resúmenes de reuniones grabadas.

Añade n8n a tu docker-compose.yml:

  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    environment:
      - N8N_HOST=0.0.0.0
      - WEBHOOK_URL=http://localhost:5678/
    depends_on:
      - ollama
    restart: unless-stopped

Ollama + Qdrant para Búsqueda Semántica

Qdrant es una base de datos vectorial que, combinada con Ollama, te permite crear sistemas RAG (Retrieval Augmented Generation) para que tus modelos consulten documentación personalizada, bases de conocimiento empresariales, o colecciones de PDFs.

  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant
    ports:
      - "6333:6333"
    volumes:
      - qdrant_data:/qdrant/storage
    restart: unless-stopped

Ollama + LangChain para Aplicaciones IA Avanzadas

LangChain es un framework Python/JavaScript que simplifica la creación de aplicaciones complejas con LLMs. Puede conectarse directamente a tu API de ollama docker compose para crear agentes, cadenas de razonamiento, y sistemas multimodales.

Ejemplo de conexión desde Python:

from langchain_community.llms import Ollama

llm = Ollama(
    base_url="http://localhost:11434",
    model="llama3.1:8b"
)

response = llm.invoke("Explica qué es Docker Compose")
print(response)

Seguridad y Acceso Remoto para Ollama Docker Compose

Si planeas acceder a tu instalación de ollama docker compose desde internet, es fundamental implementar medidas de seguridad adecuadas.

Implementar Reverse Proxy con Traefik

Traefik genera certificados SSL automáticamente con Let’s Encrypt y gestiona el enrutamiento de manera elegante. Aquí un ejemplo de configuración:

services:
  traefik:
    image: traefik:v3.0
    container_name: traefik
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "[email protected]"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - letsencrypt_data:/letsencrypt
    restart: unless-stopped

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    volumes:
      - ollama_data:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.ollama.rule=Host(`ollama.tudominio.com`)"
      - "traefik.http.routers.ollama.entrypoints=websecure"
      - "traefik.http.routers.ollama.tls.certresolver=letsencrypt"
      - "traefik.http.services.ollama.loadbalancer.server.port=11434"
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama_data:
  letsencrypt_data:

Autenticación Básica

Si usas Open WebUI, habilita autenticación cambiando la variable de entorno:

environment:
  - WEBUI_AUTH=true
  - WEBUI_SECRET_KEY=cambia-esto-por-una-clave-segura-aleatoria

Acceso Remoto Seguro con Cloudflare Tunnel

Cloudflare Tunnel permite exponer tu servidor Ollama sin abrir puertos en tu router ni configurar certificados SSL manualmente. Es una alternativa segura y gratuita para acceso remoto.

Monitorización y Logs en Ollama Docker Compose

Para mantener un despliegue de ollama docker compose saludable en producción, es esencial implementar monitorización.

Revisar Logs del Contenedor

# Ver logs en tiempo real
docker logs -f ollama

# Ver últimas 100 líneas
docker logs --tail 100 ollama

# Buscar errores específicos
docker logs ollama | grep -i error

Limitar Tamaño de Logs

Evita que los logs consuman todo el espacio en disco:

services:
  ollama:
    image: ollama/ollama:latest
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

Métricas de Uso de GPU

Monitoriza el uso de GPU en tiempo real:

watch -n 1 nvidia-smi

Para métricas avanzadas, integra Prometheus y Grafana con exportadores específicos para NVIDIA.

Migración y Backup de Ollama Docker Compose

Los modelos descargados representan gigabytes de datos. Respaldarlos adecuadamente previene tener que descargarlos nuevamente.

Backup del Volumen de Datos

# Crear backup del volumen ollama_data
docker run --rm \
  -v ollama_data:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/ollama-backup-$(date +%Y%m%d).tar.gz /data

Restaurar Backup

# Restaurar backup
docker run --rm \
  -v ollama_data:/data \
  -v $(pwd):/backup \
  alpine tar xzf /backup/ollama-backup-20250119.tar.gz -C /

Migrar a otro Servidor

Para migrar tu configuración de ollama docker compose a otro servidor:

Exporta el backup del volumen (comando anterior)
Copia el archivo docker-compose.yml al nuevo servidor
Copia el archivo .tar.gz del backup
Restaura el volumen en el nuevo servidor
Ejecuta docker compose up -d

Los modelos y configuraciones se preservarán completamente.

Comparativa: Ollama vs Alternativas Cloud

¿Vale la pena autoalojar ollama docker compose frente a usar APIs comerciales? Analicemos:

Característica	Ollama Docker Compose	OpenAI API	Anthropic Claude
Costo mensual	$0 (solo electricidad)	$20-200+ según uso	$20-200+ según uso
Privacidad	Total (datos locales)	Datos en servidores externos	Datos en servidores externos
Latencia	Baja (red local)	Depende de internet	Depende de internet
Offline	Funciona sin internet	Requiere conexión	Requiere conexión
Personalización	Completa (fine-tuning)	Limitada	Limitada
Calidad respuestas	Muy buena (modelos 70B+)	Excelente	Excelente

Para empresas que manejan datos sensibles, desarrolladores que experimentan constantemente, o usuarios con alto volumen de consultas, ollama docker compose ofrece un ROI superior tras la inversión inicial en hardware.

Recursos Externos y Documentación Oficial

Para profundizar en ollama docker compose, consulta estos recursos oficiales:

Repositorio oficial de Ollama en GitHub – Código fuente, issues y contribuciones
Biblioteca de modelos Ollama – Catálogo completo de modelos disponibles
Documentación oficial de Docker Compose – Referencia completa de sintaxis y configuración

Ollama Docker Compose: Ejecuta IA Localmente en tu PC 2025