Desplegar LocalAI en Ubuntu 24.04 paso a paso

Si te cansaste de pagar por token y de mandarle datos sensibles a un servidor ajeno, desplegar LocalAI en Ubuntu 24.04 te deja correr modelos de lenguaje en tu propia máquina con una API idéntica a la de OpenAI. La guía de Vultr publicada el 23 de junio de 2026 lo arma con Docker Compose y Traefik resolviendo el HTTPS solo, y al terminar tenés un endpoint compatible sirviendo en tu dominio.

LocalAI es una plataforma open-source que ejecuta modelos de lenguaje grandes en local exponiendo una API compatible con OpenAI. Eso significa que podés enchufarla detrás del mismo código que ya usás con el SDK oficial, cambiando una sola línea: la URL base. No paga por token, no sale el dato del servidor y corre incluso sin GPU usando la imagen latest-aio-cpu.

¿Por qué correr modelos de IA en tu propio servidor y no en la nube?

Ponele que trabajás con historias clínicas, contratos o el código propietario de tu empresa. Cada vez que mandás eso a una API en la nube, estás confiando en que del otro lado nadie lo loguea, lo entrena ni lo filtra. Para muchos equipos en 2026, esa confianza ya no alcanza.

Correr el modelo en tu infraestructura cambia el cálculo. El dato no se mueve. No hay factura que crezca con cada request. Y no te frena un rate limit en el peor momento. Ya lo cubrimos antes en automatizar despliegues con herramientas modernas.

• Privacidad real: documentos legales, datos médicos o propiedad intelectual nunca salen del servidor que controlás vos.
• Costo fijo: pagás el servidor, no cada token. Si procesás millones de tokens por día, la diferencia es enorme.
• Sin límites de rate: el throughput depende de tu hardware, no de la cuota que te asignó un proveedor.
• Control total: elegís el modelo, la versión y cuándo actualizás. Nadie te deprecia un endpoint de un día para el otro.

Eso sí: nada es gratis. Lo que ahorrás en facturación lo pagás en mantenimiento y en latencia si no tenés GPU. Más abajo lo vemos.

¿Qué es LocalAI y en qué se diferencia de Ollama?

Según la documentación oficial de LocalAI, es un reemplazo directo de la API de OpenAI que corre modelos en hardware de consumo, sin necesidad de GPU. Soporta chat-completions, embeddings, generación de imágenes y audio, y carga formatos como los de la familia Llama, Mistral y muchos más en formato GGUF.

La pregunta que todos hacen: ¿y Ollama? Ollama es más simple de arrancar, ideal para probar un modelo en tu notebook en dos minutos. LocalAI es más completo: cubre más endpoints de la API de OpenAI (no solo chat), y está pensado para ponerlo detrás de un reverse proxy y servirlo como backend real.

Criterio	LocalAI	Ollama
Compatibilidad OpenAI	Amplia (chat, embeddings, imágenes, audio)	Chat y embeddings, parcial
Curva de arranque	Media (Compose + config)	Baja (un comando)
Caso ideal	Backend autohosteado en servidor	Pruebas locales rápidas
GPU obligatoria	No (imagen aio-cpu)	No
Reverse proxy / HTTPS	Pensado para Traefik	Manual

¿Qué requisitos previos necesitás en Ubuntu 24.04?

Antes de tocar nada, asegurate de tener la base lista. La guía asume un servidor limpio con Ubuntu 24.04 LTS.

• RAM: cuanta más, mejor; cada modelo consume memoria según su tamaño, así que conviene tener margen.
• Docker y Docker Compose: instalados y funcionando. LocalAI vive dentro de contenedores.
• Dominio con DNS público: hace falta un registro A apuntando a tu IP para que Traefik valide el certificado con Let’s Encrypt.
• GPU opcional: la imagen latest-aio-cpu funciona solo con procesador. Si tenés GPU, hay imágenes específicas, pero no es obligatorio.

Si todavía no tenés dónde montar esto, un VPS con buena RAM en donweb.com te sirve para arrancar sin complicarte con hardware propio.

¿Cómo configurar Docker Compose y Traefik para desplegar LocalAI?

El despliegue tiene tres piezas: la estructura de carpetas, el archivo de variables y el manifiesto de Compose. Empezá creando los directorios que van a persistir entre reinicios. En automatización entre Jenkins y GitHub Actions profundizamos sobre esto.

• ./models: guarda los archivos de modelo descargados. Si no persiste, cada reinicio vuelve a bajar todo.
• ./cache: mantiene la caché de inferencia entre arranques.
• ./letsencrypt: acá Traefik escribe el acme.json con los certificados emitidos.

El archivo .env lleva tu correo para Let’s Encrypt, en la variable LETSENCRYPT_EMAIL. Es el mail al que ACME asocia los certificados. Después agregás tu usuario al grupo docker para no andar con sudo en cada comando.

El corazón es el docker-compose.yaml. Traefik corre como reverse proxy y se encarga del redirect HTTP a HTTPS y del desafío ACME. Estos son los flags clave que aparecen en la guía:

services:
 traefik:
 image: traefik:latest
 command:
 - "--providers.docker=true"
 - "--providers.docker.exposedbydefault=false"
 - "--entrypoints.web.address=:80"
 - "--entrypoints.websecure.address=:443"
 - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
 - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
 - "--certificatesresolvers.le.acme.httpchallenge=true"
 - "--certificatesresolvers.le.acme.httpchallenge.entrypoint=web"
 - "--certificatesresolvers.le.acme.email=${LETSENCRYPT_EMAIL}"
 - "--certificatesresolvers.le.acme.storage=/letsencrypt/acme.json"
 volumes:
 - /var/run/docker.sock:/var/run/docker.sock:ro
 - ./letsencrypt:/letsencrypt

 localai:
 image: localai/localai:latest-aio-cpu
 volumes:
 - ./models:/models:cached
 - ./cache:/cache:cached

Fijate que exposedbydefault=false hace que Traefik ignore todo contenedor que no tenga sus labels. Es una buena práctica de seguridad: solo expone lo que vos marcás de forma explícita.

¿Cómo verificar que LocalAI está funcionando?

Levantás todo con docker compose up -d y mirás los logs. Acá va un consejo que ahorra dolores de cabeza: la primera vez que arranca, LocalAI descarga el modelo, y eso tarda. Si el health check tira error al toque, probablemente todavía esté bajando archivos. Sobre eso hablamos en optimizar para búsquedas en múltiples idiomas.

• Health check: el endpoint /readyz responde cuando el servicio está listo. Compose lo usa como healthcheck apuntando a http://localhost:8080/readyz.
• Logs: con docker compose logs localai seguís la descarga del modelo y cualquier error de carga.
• Prueba real: mandá un curl al endpoint de chat para confirmar que responde como la API de OpenAI.

curl https://tu-dominio.com/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "gpt-4",
 "messages": [{"role": "user", "content": "Hola, andas?"}]
 }'

Si te devuelve un JSON con la respuesta del modelo, ya está. Tenés tu propio servidor de inferencia.

¿Cómo integrar LocalAI en aplicaciones Python o Node.js?

Acá viene lo bueno: no reescribís nada. Si tu app ya habla con el SDK oficial de OpenAI, lo único que cambiás es el base_url y la clave (que con LocalAI puede ser cualquier cosa).

from openai import OpenAI

client = OpenAI(
 api_key="no-importa",
 base_url="https://tu-dominio.com/v1"
)

resp = client.chat.completions.create(
 model="gpt-4",
 messages=[{"role": "user", "content": "Resumime esto"}]
)
print(resp.choices.message.content)

El resto del código (manejo de errores, streaming, parsing de la respuesta) queda igual. En Node.js es lo mismo: instanciás el cliente con baseURL apuntando a tu instancia y listo. Migrar una app de prueba lleva minutos.

¿Cuáles son los desafíos reales al correr LocalAI en producción?

No todo es color de rosa. El trade-off más grande es la latencia: sin GPU, la inferencia es lenta. Para desarrollo, testing o cargas bajas, zafa. Para servir miles de requests concurrentes con baja latencia, la imagen aio-cpu no es la herramienta. Para más detalles técnicos, mirá agentes de IA completamente independientes.

• Latencia sin GPU: un modelo de 7B en CPU responde, pero con segundos de espera. Es el precio de no tener placa.
• Seguridad: el HTTPS automático de Traefik no es opcional. Una API de IA expuesta en HTTP plano es un regalo para cualquiera que esté mirando.
• Elección del modelo: Mistral 7B contra Llama u otros implica decidir entre tamaño, calidad y velocidad. Más parámetros, mejor respuesta, más RAM y más lentitud.
• Monitoreo de recursos: los modelos se comen la RAM. Si no vigilás el uso, el contenedor se cae cuando el sistema se queda sin memoria.

Errores comunes al desplegar LocalAI

• Creer que el health check falló cuando solo está descargando: en el primer arranque el modelo se baja y eso demora. Mirá los logs antes de asumir que algo se rompió.
• No persistir ./models: si te olvidás del volumen, cada reinicio vuelve a descargar gigabytes. Verificá que el bind mount esté en el Compose.
• DNS mal apuntado: si el registro A no resuelve a tu IP, Let’s Encrypt no puede validar el dominio y Traefik no emite el certificado. Confirmá el DNS antes de levantar todo.
• Exponer LocalAI sin autenticación: Traefik te da el HTTPS, pero no autentica usuarios. Si la instancia mira a internet, agregá una capa de auth o restringí por IP.

Preguntas Frecuentes

¿Qué es LocalAI y para qué sirve?

LocalAI es una plataforma open-source que corre modelos de lenguaje en tu propio servidor con una API compatible con OpenAI. Sirve para reemplazar servicios en la nube cuando necesitás privacidad de datos, costo fijo o control total sobre el modelo.

¿Puedo reemplazar la API de OpenAI con LocalAI?

Sí, es un reemplazo directo. Cambiás el base_url del cliente oficial de OpenAI por la dirección de tu instancia y el resto del código sigue igual. La compatibilidad cubre chat, embeddings y más endpoints.

¿Necesito GPU para correr LocalAI?

No es obligatoria. La imagen localai/localai:latest-aio-cpu funciona solo con CPU. El costo es la latencia: sin GPU la inferencia es más lenta, lo que la hace ideal para desarrollo y cargas bajas más que para producción de alta concurrencia.

¿Cuánta RAM necesito para desplegar LocalAI en Ubuntu?

Depende del modelo: los LLMs consumen memoria según su tamaño, así que cuanta más RAM tenga el servidor, más margen tenés para correr modelos grandes. Conviene monitorear el uso para que el contenedor no se quede sin memoria.

¿Cómo configuro HTTPS automático con Traefik?

Traefik gestiona el certificado con Let’s Encrypt usando el desafío HTTP (ACME httpchallenge). Configurás tu correo en LETSENCRYPT_EMAIL, apuntás el DNS de tu dominio a la IP del servidor y Traefik emite y renueva el certificado solo, redirigiendo HTTP a HTTPS.

Conclusión

Desplegar LocalAI en Ubuntu 24.04 con Docker Compose y Traefik te da un endpoint compatible con OpenAI, con HTTPS automático y los datos quedándose en tu servidor. Lo que cambió respecto a hace un par de años es que esto ya no es un experimento de fin de semana: con la imagen aio-cpu arrancás sin GPU y la integración es un cambio de una línea en el código.

¿Para quién tiene sentido? Para equipos que manejan datos sensibles o que procesan tanto volumen que la factura por token duele. El consejo concreto: probalo primero en un VPS para dev y testing, medí la latencia con tu caso real, y recién después decidí si vale sumar GPU para producción. Si lo tuyo es solo probar un modelo rápido, Ollama te resuelve en menos pasos.

Fuentes

• Documentación oficial de LocalAI – guía de instalación y configuración
• Vultr – Deploying LocalAI on Ubuntu 24.04 (23 de junio de 2026)
• Documentación de Traefik – reverse proxy y HTTPS con Let’s Encrypt