Por qué autoalojar sus modelos LLM en un VPS
Autoalojar un servidor de modelos significa mantener sus prompts y sus datos sensibles fuera de las API comerciales, eliminar la facturación por token y fijar usted mismo el modelo, su versión y su quantization. En un VPS, expone una API privada a sus aplicaciones internas (chatbots, RAG, asistentes de código) sin ninguna fuga hacia el exterior. Ollama destaca por su simplicidad radical: un comando para descargar y arrancar un modelo, una API limpia, una gestión automática de la memoria. LocalAI se posiciona como un sustituto 'drop-in' de la API de OpenAI: expone los mismos endpoints (chat, embeddings, imágenes, audio) y admite múltiples backends y formatos de modelos. La elección se juega entre una experiencia minimalista y la compatibilidad más amplia posible.
Las ventajas de un LLM autoalojado
- Prompts y datos confidenciales que nunca salen de su VPS
- Ninguna facturación por token, coste previsible ligado únicamente al servidor
- API privada conectada directamente a sus aplicaciones internas
- Elección libre del modelo, de su tamaño y de su nivel de quantization
- Compatibilidad con los SDK existentes mediante una API al estilo de OpenAI
- Ideal para el RAG: combine el LLM con su base de datos y con un motor de búsqueda autoalojado
Requisitos: modelos cuantizados y RAM realista
Sin GPU, quédese con modelos cuantizados ligeros. Un modelo 3B en GGUF Q4 funciona en un VPS de 4 vCPU y 8 GB de RAM con una latencia aceptable para pruebas; un modelo 7B/8B Q4 exige de 8 a 16 GB de RAM y una buena CPU para seguir siendo utilizable. Más allá, en CPU pura, la latencia se vuelve prohibitiva: para tiempo real con modelos grandes, un VPS con GPU es imprescindible. Prevea sobre todo un disco generoso: los pesos de varios modelos alcanzan enseguida decenas de GB. Necesita Docker y Compose, un volumen persistente para los modelos, un subdominio si expone la API, y un reverse proxy con autenticación.
Desplace la tabla
| Criterio | Ollama | LocalAI |
|---|---|---|
| Filosofía | Simplicidad, un comando por modelo | Sustituto drop-in de la API de OpenAI |
| Instalación | Muy rápida, imagen Docker oficial lista | Más configuración, numerosos backends |
| Compatibilidad API OpenAI | Endpoint compatible `/v1/chat/completions` | Nativa y muy completa, todos los endpoints |
| Modelos soportados | Biblioteca oficial en ollama.com/library | GGUF, GPTQ, ONNX, exllama2 y más |
| Soporte GPU | NVIDIA, AMD, Apple Metal — detección automática | NVIDIA, AMD, CPU — amplio soporte de hardware |
| Múltiples modelos simultáneos | Sí, carga/descarga automática | Sí, backends aislados por modelo |
| Interfaz web integrada | No (Open WebUI separado) | No (interfaz de terceros recomendada) |
| Caso de uso ideal | Empezar rápido, prototipar | Migrar una app OpenAI al self-hosting |
Desplegar Ollama (o LocalAI) en un VPS
Aprovisionar el almacenamiento y el volumen de modelos
Cree un volumen dedicado (
/srv/ollama/models) en un disco lo bastante grande. Como los pesos son voluminosos y reutilizables, deben persistir fuera del contenedor para evitar volver a descargarlos en cada reinicio.Arrancar el contenedor
Inicie
ollama/ollama(olocalai/localai) montando el volumen de modelos y vinculando el puerto11434/8080en local. En un VPS sin GPU, el modo CPU es automático; con GPU, active el runtime adecuado.Descargar un modelo
Con Ollama, ejecute
docker compose exec ollama ollama pull llama3.2:3b. Con LocalAI, declare el modelo en la galería o deposite el archivo GGUF en la carpeta de modelos, y luego compruebe su carga en los logs.Probar la API
Lance una llamada local:
curl http://127.0.0.1:11434/api/generatepara Ollama, o el endpoint compatible con OpenAIPOST /v1/chat/completionspara LocalAI. Valide que la generación funciona antes de cualquier exposición.Exponer detrás de un reverse proxy autenticado
Redirija llm.sudominio.com hacia el puerto local con Caddy o Nginx para el TLS, y añada una capa de autenticación (clave de API en la cabecera o basic auth). Una API LLM abierta en Internet es una puerta de entrada costosa que nunca debe quedar sin control.
Conectar sus aplicaciones
Apunte sus SDK existentes a su
base_urlprivada. Como LocalAI expone la API de OpenAI, la mayoría de las bibliotecas funcionan con solo cambiar la URL y la clave; en Ollama, use su API nativa o su endpoint compatible.
Gestionar los modelos: ollama pull, list y eliminación
Con Ollama, toda la gestión de modelos se realiza a través de la CLI o la API REST. ollama pull llama3.2 descarga la variante por defecto; ollama pull llama3.1:8b-instruct-q4_K_M descarga una variante cuantizada precisa de la biblioteca oficial en ollama.com/library. ollama list muestra los modelos locales con su tamaño en disco y su resumen (digest). ollama run mistral abre una sesión interactiva en el terminal. ollama rm llama3.2 elimina un modelo para liberar espacio. Con LocalAI, la lógica es diferente: los modelos residen en la carpeta /models montada dentro del contenedor. Descargue un archivo GGUF (formato llama.cpp) o GPTQ y colóquelo en ese directorio; LocalAI lo carga al inicio o bajo demanda. La galería de LocalAI ofrece configuraciones listas para los modelos populares. Un punto práctico: Ollama descarga automáticamente los modelos no utilizados para liberar RAM, mientras que LocalAI deja esto a su configuración.
Rendimiento y memoria: elegir la quantization adecuada
La quantization reduce la precisión de los pesos para reducir el tamaño del modelo y su consumo de memoria. Q4_K_M y Q5_K_S son los formatos más habituales en la práctica. Q4_K_M (4 bits, método K, tamaño M) ofrece el mejor equilibrio tamaño/calidad para la mayoría de los casos: un modelo Llama 3.1 8B en Q4_K_M consume alrededor de 4,7 GB de RAM, frente a unos 16 GB para la versión sin cuantizar en FP16 (fuente: ollama.com/library/llama3.1). Q5_K_S sube a unos 5,5 GB pero preserva mejor la coherencia en generaciones largas. En un VPS de 8 GB, apunte a modelos 3B o 7B en Q4; en 16 GB, un 7B/8B Q5_K_M se mantiene fluido. En CPU pura, espere de 3 a 10 tokens/s según el modelo y el número de núcleos — aceptable para uso asíncrono, demasiado lento para streaming interactivo. Con una GPU NVIDIA, Ollama detecta automáticamente CUDA y descarga las capas en la GPU; la misma lógica para AMD (ROCm) y Apple Silicon (Metal). LocalAI ofrece un control más fino sobre la asignación de capas GPU a través de los parámetros de configuración del backend, útil cuando GPU y CPU deben compartir la carga.
En un VPS sin GPU, el secreto de la fluidez es la quantization: un modelo en Q4_K_M ofrece un compromiso tamaño/calidad muy favorable y cabe en RAM allí donde la versión sin cuantizar se hunde. Limite también el context window a lo estrictamente necesario (por ejemplo 4096 tokens): un contexto sobredimensionado multiplica el consumo de memoria y la latencia sin beneficio real para la mayoría de las tareas.
Integración: Open WebUI, API de OpenAI y SDK
Open WebUI es la interfaz gráfica de referencia para Ollama: se despliega como un único contenedor Docker y se conecta a Ollama mediante la variable de entorno OLLAMA_BASE_URL=http://ollama:11434. Obtiene un chat completo con historial, selección de modelo, gestión de conversaciones — similar a ChatGPT pero alojado en su VPS. Para integraciones programáticas, Ollama expone /api/generate (generación simple) y /v1/chat/completions (compatible con OpenAI). Un cliente Python existente se reconfigura así: client = openai.OpenAI(base_url='http://localhost:11434/v1', api_key='ollama'). LocalAI expone exactamente la misma interfaz de OpenAI — POST /v1/chat/completions, POST /v1/embeddings, POST /v1/images/generations — lo que permite migrar una aplicación existente cambiando únicamente la URL base y la clave. Frameworks como LangChain, LlamaIndex y Semantic Kernel disponen de un conector Ollama u OpenAI compatible con ambas soluciones. Para el RAG, combine cualquiera de los dos con Weaviate, Qdrant o Chroma: el LLM genera, el motor vectorial filtra los contextos relevantes, todo permanece en su servidor.
Solución de errores frecuentes
Error OOM (Out of Memory): el modelo es demasiado grande para la RAM disponible. Compruebe el tamaño real del modelo con ollama list, reduzca la quantization (Q4 en lugar de Q5 o Q8), o elija un modelo más pequeño. Si el error persiste, reduzca num_ctx (ventana de contexto) en las opciones de generación. Modelo no encontrado: con Ollama, ollama pull puede fallar si el nombre es incorrecto — consulte el listado exacto en ollama.com/library; con LocalAI, verifique que el archivo GGUF esté en la carpeta /models y que su nombre coincida con el identificador declarado en la configuración. GPU no detectada: en un VPS con GPU NVIDIA, Ollama necesita el NVIDIA Container Toolkit instalado en el host y el parámetro runtime: nvidia en el Compose; compruebe con ollama ps que el modelo está realmente descargado en la GPU. Timeout en generaciones largas: aumente el timeout del reverse proxy (Nginx: proxy_read_timeout 300s) y el del cliente. Para un uso intensivo, prefiera el streaming ("stream": true) que devuelve los tokens a medida que se generan y evita los timeouts en respuestas largas.
¿Ollama o LocalAI? Cuál encaja con su perfil
Elija Ollama si está empezando con los LLM autoalojados, si quiere una experiencia de desarrollador similar a un gestor de paquetes, si su caso de uso es la creación rápida de prototipos, un chatbot interno o un asistente de código, o si planea conectar Open WebUI para una interfaz de usuario inmediata. Ollama gestiona por sí solo las descargas, la quantization y la conmutación CPU/GPU — no se necesita ninguna configuración más allá del Compose. Elija LocalAI si está migrando una aplicación existente que llama a la API de OpenAI y quiere evitar cambios de código en el lado del cliente, si necesita modalidades más allá del texto (generación de imágenes, TTS, STT) en un único contenedor, o si gestiona formatos de modelos variados (GPTQ, ONNX, exllama2) que el backend llama.cpp no cubre por sí solo. LocalAI exige más configuración inicial pero ofrece mayor control en producción.