Mettre en place une IA chez soi (Docker + Ollama + Open WebUI)

L'idée de cet article est de montrer comment héberger sa propre IA directement dans son homelab. C'est super simple ; la seule difficulté, c'est la puissance de la machine… (moment parfait pour acheter de la RAM en ce moment).

Prérequis

Pour ce tutoriel, j'ai utilisé mon serveur Proxmox avec une VM aux specs suivantes :

• 16 Go de RAM
• 4 vCPU
• Docker installé et fonctionnel
• OS : Ubuntu Server
• Accès réseau OK

💡 À savoir — Avec 16 Go de RAM on peut déjà faire tourner pas mal de choses, mais il faut choisir son modèle en fonction des ressources disponibles. Les détails sur les modèles arrivent plus loin.

Les technos utilisées

Trois technologies pour ce projet :

Docker

Docker va héberger les deux outils suivants dans des conteneurs. Approche stable et scalable pour ce genre de projet.

Ollama

Ollama est le moteur qui exécute les modèles IA en local. Il gère le téléchargement des modèles et expose une API sur le port 11434 pour que d'autres outils (comme Open WebUI) puissent l'utiliser. Par défaut, c'est très orienté terminal.

Open WebUI

Open WebUI rend l'utilisation de l'IA beaucoup plus agréable, avec une interface web type ChatGPT.

I. Installation d'Ollama avec Docker

On commence par lancer Ollama dans un conteneur. Deux variantes : version classique CPU only, et une version pour GPU NVIDIA.

Version CPU

Ici, j'ai utilisé la version CPU :

# Lancer Ollama (CPU uniquement)
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Ce que fait la commande :

• docker run -d : lance le conteneur en arrière-plan
• -v ollama:/root/.ollama : volume Docker pour stocker les modèles (évite de tout retélécharger)
• -p 11434:11434 : expose l'API d'Ollama sur le port 11434
• --name ollama : nom du conteneur
• ollama/ollama : image officielle d'Ollama

Version GPU

La commande pour la version GPU :

# Lancer Ollama (avec GPU NVIDIA)
docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

💡 GPU NVIDIA — La différence c'est --gpus=all : ça donne accès au GPU dans le conteneur. Avec une NVIDIA compatible et les bons drivers, on a de meilleures perfs et on peut envisager des modèles plus gros.

II. Télécharger et lancer un modèle

Une fois Ollama démarré, il faut télécharger un modèle puis le lancer. Je préfère séparer les deux étapes pour la clarté, mais on peut aussi tout faire en même temps.

Je vais montrer le téléchargement de deux modèles : Llama2 (le classique) puis une version « mini » (Phi-3 Mini). Je reviens juste après sur leurs différences.

Installation de Llama2

Téléchargement :

docker exec -it ollama ollama pull llama2

Lancement :

docker exec -it ollama ollama run llama2

Installation d'une version « mini » : Phi-3 Mini

Téléchargement :

docker exec -it ollama ollama pull phi3:mini

Lancement :

docker exec -it ollama ollama run phi3:mini

✅ Vérifier les modèles installés — docker exec -it ollama ollama list

Démonstration en terminal

Voici un exemple de Phi-3 Mini en action dans le terminal :

Différences entre Llama2 et Phi-3 Mini

Les deux modèles ne jouent pas dans la même catégorie. Llama2 est plus généraliste et plus lourd, alors que Phi-3 Mini est pensé pour être très léger, rapide et utilisable sur des petites machines comme la nôtre.

III. Installer Open WebUI (interface web)

Ollama, par défaut, c'est full terminal. Ça dépanne, mais pour un usage quotidien, une interface web c'est mieux. La suite c'est donc Open WebUI, qui se connecte à Ollama et donne un chat accessible depuis le navigateur.

Version GPU (NVIDIA)

# Open WebUI avec GPU
docker run -d -p 3000:8080 --gpus=all -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Version CPU

# Open WebUI en CPU
docker run -d -p 3000:8080 -v ollama:/root/.ollama -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:ollama

Ce que fait la commande :

• -p 3000:8080 : interface accessible sur http://IP_DE_LA_MACHINE:3000
• --gpus=all (optionnel) : donne accès au GPU si dispo
• -v ollama:/root/.ollama : réutilise le volume où sont stockés les modèles
• -v open-webui:/app/backend/data : stocke les données de l'interface (utilisateur, réglages…)
• --restart always : redémarre automatiquement au reboot
• ghcr.io/open-webui/open-webui:ollama : image Open WebUI prévue pour Ollama

Accès à l'interface

Ouvrir :

• http://localhost:3000 sur la machine
• http://IP_DE_LA_MACHINE:3000 depuis une autre machine du réseau

On crée son compte, on choisit son modèle (llama2, phi3:mini, etc.), et on peut commencer à discuter via l'interface web.

IV. Mesure de l'utilisation des ressources

À la fin, ce qui m'intéressait c'était de voir concrètement combien ça consomme quand on l'utilise vraiment. Pour mesurer ça facilement :

# Surveiller la consommation des conteneurs
docker stats

💡 Comment mesurer — Lancer une conversation dans Open WebUI pendant 30 secondes et regarder la RAM utilisée par ollama, par open-webui, et le CPU (surtout en CPU only). On peut aussi faire un free -h côté VM pour l'impact global.

Conclusion

Avec ça, on a une IA qui tourne chez soi, sans abonnement, et qu'on contrôle. Ollama gère l'exécution et les modèles, Open WebUI donne l'interface, Docker permet de tout déployer proprement.

Ensuite on peut améliorer le setup comme on veut : modèles plus gros, GPU, accès depuis l'extérieur via VPN, reverse proxy, sauvegardes des volumes Docker, etc.

🚀 Prochaines étapes — tester des modèles plus gros si on monte en RAM ou en GPU, passer par un reverse proxy type Traefik pour avoir un accès HTTPS, rendre le service accessible depuis l'extérieur via VPN, automatiser les sauvegardes des volumes Docker.

Sources

• Ollama — GitHub
• Ollama — Documentation officielle
• Open WebUI — GitHub