Cómo montar tu propio servidor de IA local con Ollama y Open WebUI en Linux

¿Cansado de los límites de uso, las suscripciones mensuales y la preocupación de que tus conversaciones con una IA sean almacenadas en servidores de terceros? Existe una alternativa real: montar tu propio servidor de inteligencia artificial en casa, con hardware que probablemente ya tienes o puedes conseguir por una fracción del costo de una suscripción anual.

En este artículo te explico exactamente cómo lo hice, qué hardware usé, qué software necesitas y cómo dejarlo funcionando desde cualquier dispositivo de tu red local.

¿Por qué correr una IA localmente?

Antes de entrar al tutorial, vale la pena entender por qué tiene sentido hacer esto:

Privacidad total: tus conversaciones, tu código y tus documentos nunca salen de tu red. Nadie los lee, nadie los usa para entrenar modelos.
Sin costo por uso: una vez que tienes el hardware, el costo marginal de cada consulta es prácticamente cero (electricidad).
Sin límites de mensajes: no hay “has alcanzado tu límite diario” ni planes de pago por niveles.
Funciona offline: no dependes de internet ni de la disponibilidad de servidores externos.
Control total: tú decides qué modelos corres, con qué configuración y quién tiene acceso.

¿Qué es Ollama y qué es Open WebUI?

Ollama es una herramienta open source que permite descargar, gestionar y servir modelos de lenguaje grandes (LLMs) localmente. Funciona como un servidor con API REST, lo que significa que cualquier aplicación en tu red puede hacer consultas a tus modelos como si fuera una API de OpenAI.

Open WebUI es una interfaz web tipo ChatGPT que se conecta a Ollama. Te da una experiencia visual amigable desde cualquier navegador, sin necesidad de usar la terminal para interactuar con los modelos.

Juntos forman un stack completo: Ollama gestiona los modelos y la inferencia, Open WebUI le da la interfaz. Docker se encarga de que todo corra de forma aislada y reproducible.

Requerimientos de hardware

La clave para un servidor de IA funcional es la GPU. Los modelos de lenguaje corren dramáticamente más rápido en GPU que en CPU — hablamos de una diferencia de 10x a 15x en velocidad de generación.

Hardware mínimo recomendado

CPU: procesador x86-64 de 6 o más núcleos (AMD Ryzen o Intel Core de generación reciente)
RAM: 16 GB DDR4 mínimo, 32 GB recomendado. La RAM del sistema sirve como desbordamiento cuando los modelos no caben completamente en la VRAM de la GPU
GPU: NVIDIA con mínimo 8 GB de VRAM. La RTX 3060 de 12 GB es el punto dulce en relación precio/rendimiento para modelos locales
Almacenamiento: SSD de 256 GB para el sistema operativo y Docker. Un disco adicional (HDD o SSD) de al menos 500 GB para almacenar los modelos, ya que cada uno pesa entre 4 y 20 GB
Sistema operativo: Debian 12 (Bookworm) o Ubuntu 22.04/24.04 LTS

Hardware real usado en este tutorial

El servidor que uso como base para esta guía tiene las siguientes especificaciones:

Placa madre: MSI MPG B550 Gaming Plus
CPU: AMD Ryzen 7 5700G (8 núcleos)
RAM: 32 GB DDR4 a 3200 MHz
GPU: Gigabyte GeForce RTX 3060 12 GB
SSD: 256 GB M.2 NVMe PCIe 4.0 (sistema y Docker)
HDD: 1.8 TB (almacenamiento de modelos)
Sistema operativo: Debian 12 Bookworm

Con este hardware, modelos de 14B parámetros corren completamente en GPU a 25-35 tokens por segundo, y modelos más pequeños como Gemma4:e4b alcanzan 73 tokens por segundo, más rápido de lo que puedes leer.

Nota sobre GPU: aunque este tutorial usa una RTX 3060 de NVIDIA (que funciona con CUDA, el estándar de la industria), también es posible usar GPUs AMD con ROCm, aunque requiere configuración adicional. Si tu presupuesto es limitado, busca una RTX 3060 de 12 GB de segunda mano — es específicamente la versión de 12 GB, no la Ti que tiene 8 GB.

Software necesario

Antes de empezar, estos son los componentes de software que vamos a instalar:

Docker + Docker Compose: para ejecutar Ollama y Open WebUI como contenedores
Drivers NVIDIA: para que Linux reconozca y use la GPU
NVIDIA Container Toolkit: para que Docker pueda acceder a la GPU
Ollama (imagen Docker): el servidor de modelos
Open WebUI (imagen Docker): la interfaz web

Instalación paso a paso

Paso 1: Instalar Docker en Debian

Primero agrega los repositorios oficiales de Docker para Debian:

# Instalar dependencias
apt update && apt install -y ca-certificates curl gnupg

# Agregar la clave GPG de Docker
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg

# Agregar el repositorio de Docker para Debian
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  tee /etc/apt/sources.list.d/docker.list > /dev/null

# Instalar Docker
apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

Verifica que Docker quedó instalado correctamente:

docker --version

Paso 2: Instalar drivers NVIDIA

Primero hay que agregar los repositorios non-free de Debian. Edita el archivo de fuentes:

nano /etc/apt/sources.list

Asegúrate de que cada línea incluya contrib non-free non-free-firmware:

deb http://deb.debian.org/debian/ bookworm main contrib non-free non-free-firmware
deb http://security.debian.org/debian-security bookworm-security main contrib non-free non-free-firmware
deb http://deb.debian.org/debian/ bookworm-updates main contrib non-free non-free-firmware

Luego instala el driver:

apt update
apt install -y nvidia-driver firmware-misc-nonfree

# Deshabilitar el driver genérico nouveau
echo "blacklist nouveau" >> /etc/modprobe.d/blacklist-nouveau.conf
echo "options nouveau modeset=0" >> /etc/modprobe.d/blacklist-nouveau.conf
update-initramfs -u

reboot

Después del reinicio, verifica que el driver funciona:

nvidia-smi

Deberías ver tu GPU listada con el uso de VRAM y la versión del driver.

Paso 3: Instalar NVIDIA Container Toolkit

Este paquete permite que los contenedores Docker accedan a la GPU:

# Agregar el repositorio de NVIDIA
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

apt update
apt install -y nvidia-container-toolkit

# Configurar Docker para usar NVIDIA
nvidia-ctk runtime configure --runtime=docker
systemctl restart docker

Paso 4: Crear el docker-compose.yml

Crea un directorio de trabajo y el archivo de configuración:

mkdir -p ~/ollama
cd ~/ollama
nano docker-compose.yml

Pega el siguiente contenido:

services:
  ollama:
    image: ollama/ollama
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - /ruta/a/tu/disco/ollama:/root/.ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_NUM_THREADS=8
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - /opt/open-webui:/app/backend/data
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    depends_on:
      - ollama

Importante: en la línea de volumen de Ollama, sustituye /ruta/a/tu/disco/ollama por la ruta real donde quieres almacenar los modelos. Si tienes un disco secundario montado (recomendado), apunta ahí. Los modelos pueden ocupar desde 4 GB hasta 20 GB cada uno.

Paso 5: Levantar los servicios

cd ~/ollama
docker compose up -d

Verifica que ambos contenedores están corriendo:

docker ps

Deberías ver ollama y open-webui en estado Up.

Paso 6: Verificar que Ollama usa la GPU

# Verificar que el contenedor ve la GPU
docker exec -it ollama nvidia-smi

Si ves tu GPU listada, todo está funcionando correctamente.

Paso 7: Descargar tu primer modelo

# Descargar Gemma4:e4b (recomendado para empezar)
docker exec -it ollama ollama pull gemma4:e4b

# Verificar que se descargó
docker exec -it ollama ollama list

Paso 8: Acceder a Open WebUI

Desde cualquier dispositivo en tu red local, abre el navegador y ve a:

http://IP_DE_TU_SERVIDOR:8080

La primera vez te pedirá crear una cuenta de administrador. Es local, no sale a internet. Una vez dentro, selecciona el modelo que descargaste y empieza a chatear.

Modelos recomendados para empezar

Con una GPU de 12 GB de VRAM, estos son los modelos que mejor funcionan:

Para uso general y velocidad máxima

docker exec -it ollama ollama pull gemma4:e4b

El modelo estrella para hardware como el nuestro. Cabe completamente en los 12 GB de VRAM, genera a 73 tokens por segundo (más rápido de lo que puedes leer), soporta imágenes y audio, y tiene thinking mode. Es el punto de partida ideal.

Para razonamiento y código

docker exec -it ollama ollama pull qwen3:14b

Excelente para tareas que requieren más razonamiento: analizar arquitecturas de software, revisar código, resolver problemas complejos. Genera a unos 30 tokens por segundo con buena calidad de respuesta.

Para máxima calidad de respuesta

docker exec -it ollama ollama pull mistral-small3.2:24b

Este modelo de 24B parámetros usa arquitectura MoE (Mixture of Experts), lo que le permite ofrecer la calidad de un modelo grande con un consumo razonable. Ocupa algo más de VRAM y desborda un poco a RAM del sistema, pero la calidad de sus respuestas es notablemente superior para análisis complejos.

Para autocomplete en el editor de código

docker exec -it ollama ollama pull deepcoder:1.5b

Un modelo ultraligero especializado en código. Solo ocupa 2 GB de VRAM y se puede dejar cargado en background para autocomplete en tiempo real desde VS Code o Visual Studio.

Verificar que todo funciona

Para confirmar que un modelo está corriendo en GPU y no en CPU:

docker exec -it ollama ollama ps

En la columna PROCESSOR deberías ver 100% GPU. Si ves CPU, revisa que el NVIDIA Container Toolkit esté instalado y que el docker-compose tenga la sección de GPU correctamente.

También puedes monitorear el uso de GPU en tiempo real mientras el modelo genera:

watch -n 1 nvidia-smi

Acceder desde otros dispositivos de la red

Una vez que el servidor está funcionando, cualquier dispositivo en tu red WiFi o LAN puede usar la IA:

Desde el navegador: http://IP_DEL_SERVIDOR:8080 para la interfaz web
Desde VS Code: instala la extensión Continue.dev y apunta el modelo a http://IP_DEL_SERVIDOR:11434
Desde Visual Studio: instala EntwineLLM y configura la misma URL
Desde Claude Code: configura las variables de entorno para apuntar a tu servidor local

Conclusión

Montar un servidor de IA local no es tan complicado como parece, y los beneficios son inmediatos: privacidad total, sin límites de uso y sin costo recurrente. Con una GPU de 12 GB de VRAM como la RTX 3060, puedes correr modelos que compiten de tú a tú con herramientas de pago para tareas cotidianas de desarrollo.

En la próxima publicación de esta serie hago un análisis detallado de los diferentes modelos que probé en este mismo servidor, incluyendo datos reales de velocidad, consumo de VRAM y calidad de respuesta para cada uno.

¿Tienes preguntas sobre algún paso de la instalación o quieres saber si tu hardware es compatible? Déjame un comentario abajo.

Cómo montar tu propio servidor de IA local con Ollama y Open WebUI en Linux — Guía completa 2026