VPS05 Ollama

Nous avons préparé le VPS, installé Docker et mis en place Traefik. Docker Compose nous permet maintenant de décrire chaque nouveau composant dans un fichier de configuration reproductible. Nous allons installer Ollama, le moteur qui permettra d'exécuter des modèles d'intelligence artificielle sur notre serveur.

Nous allons créer son environnement, démarrer le conteneur, télécharger un premier modèle et vérifier son fonctionnement. Nous préparerons également l'accès à son API pour pouvoir connecter ultérieurement AnythingLLM.

1. Vérifier les ressources du VPS

Avant d'installer un modèle, vérifions les ressources disponibles. Ollama peut fonctionner sur CPU, mais les performances dépendent notamment du processeur, de la mémoire disponible et de la taille du modèle.

free -h
df -h /

Les modèles peuvent occuper plusieurs gigaoctets. Nous devons conserver suffisamment d'espace disque et de mémoire pour les autres services déjà installés sur le VPS.

Pour ce premier essai, nous utiliserons qwen3:1.7b, un modèle relativement compact. Ce choix permet de commencer avec un modèle de petite taille, sans garantir pour autant une vitesse particulière sur notre VPS.

2. Créer le répertoire d'Ollama

Nous allons conserver les fichiers de configuration d'Ollama dans son propre répertoire, conformément à l'organisation modulaire du LABO Web-Soul. Les données des modèles seront conservées dans un volume Docker distinct du fichier Compose.

mkdir -p /opt/labo/ollama
cd /opt/labo/ollama

Le fichier compose.yaml sera enregistré dans ce répertoire. Le volume Docker conservera les modèles téléchargés, même si le conteneur est recréé.

3. Préparer le réseau Docker

Nous allons utiliser un réseau Docker dédié aux communications entre les futurs composants IA. Ce réseau sera partagé avec les services que nous ajouterons dans les prochains articles, notamment AnythingLLM.

docker network inspect labo-ia >/dev/null 2>&1 || docker network create labo-ia

Si le réseau existe déjà, il est simplement conservé. Dans le cas contraire, Docker le crée et renvoie son identifiant.

4. Créer le fichier Compose

Nous allons utiliser l'image Docker officielle d'Ollama. Le conteneur fonctionnera avec un redémarrage automatique et un volume persistant pour les modèles. Le port de l'API sera publié uniquement sur l'interface locale du VPS pour nos premiers tests.

nano /opt/labo/ollama/compose.yaml

Copions le contenu suivant dans le fichier. Il définit le service Ollama, le stockage persistant des modèles, la publication locale du port et le réseau Docker partagé.

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "127.0.0.1:11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - labo-ia

networks:
labo-ia:
external: true
name: labo-ia

volumes:
ollama_data:

Dans Nano, enregistrons le fichier avec Ctrl+O, validons le nom avec Entrée, puis quittons avec Ctrl+X.

Important : nous n'ajoutons pas de règle Traefik pour exposer directement l'API Ollama sur Internet. Les futurs services IA pourront communiquer avec Ollama par le réseau Docker partagé. L'accès local permettra de tester l'API depuis le VPS.

5. Vérifier et démarrer le service

Avant de démarrer Ollama, vérifions que Docker Compose accepte notre fichier de configuration. Cette étape permet de repérer une erreur de syntaxe ou de déclaration avant le lancement du conteneur.

cd /opt/labo/ollama
docker compose config

Si la configuration est valide, démarrons le service en arrière-plan.

docker compose up -d

Vérifions maintenant l'état du conteneur.

docker compose ps

Si le conteneur ne démarre pas correctement, consultons ses journaux pour identifier l'origine du problème.

docker compose logs --tail=100 ollama

6. Télécharger un premier modèle

Pour notre premier test, nous utiliserons qwen3:1.7b, un modèle relativement compact qui nous permettra de valider le fonctionnement d'Ollama sans commencer par un modèle plus exigeant en ressources. Ce choix est provisoire : un modèle doit être sélectionné en fonction de son utilisation, de ses capacités et du matériel disponible. Pour comprendre les critères de sélection et comparer les différentes possibilités, consultez notre fiche Wiki-Soul : Choisir un modèle d'intelligence artificielle.

Ollama est maintenant installé, mais aucun modèle n'a encore été téléchargé. Nous allons ajouter qwen3:1.7b pour effectuer notre premier test. Le téléchargement dépend de la connexion Internet et de l'espace disque disponible.

docker compose exec ollama ollama pull qwen3:1.7b

Le téléchargement peut prendre plusieurs minutes. Une fois terminé, affichons la liste des modèles disponibles.

docker compose exec ollama ollama list

Si le modèle n'apparaît pas, vérifions les messages d'erreur et l'espace disque disponible avant de relancer le téléchargement.

7. Exécuter une première génération

Nous allons maintenant demander au modèle de produire une réponse. Cette opération vérifie qu'Ollama peut charger le modèle et effectuer une génération de texte.

docker compose exec ollama ollama run qwen3:1.7b

Lorsque l'invite apparaît, saisissons une question simple, par exemple : Explique en deux phrases le rôle d'un reverse proxy. Ollama doit afficher une réponse générée par le modèle. Pour quitter la session interactive, saisissons /bye.

Le premier chargement peut prendre plus de temps que les générations suivantes. Sur un VPS sans GPU dédié, les performances dépendront principalement du processeur, de la mémoire disponible et de la taille du modèle.

8. Tester l'API HTTP d'Ollama

Ollama expose une API HTTP que les autres applications peuvent utiliser pour interroger les modèles. Nous allons vérifier qu'elle répond correctement depuis le VPS.

curl http://127.0.0.1:11434/api/tags

La réponse doit être un document JSON contenant les informations sur les modèles installés.

Testons ensuite une véritable génération à travers l'API. L'option stream: false demande une réponse complète plutôt qu'un flux de fragments successifs.

curl http://127.0.0.1:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3:1.7b",
    "prompt": "Explique en deux phrases le rôle de Docker Compose.",
    "stream": false
  }'

Si la réponse contient le champ response avec le texte généré, le test est concluant. Nous avons vérifié le conteneur, le téléchargement du modèle, la génération de texte et l'accès à l'API.

9. Comprendre ce qui a été installé

Nous disposons maintenant d'un service Ollama indépendant, géré par Docker Compose. Le fichier compose.yaml décrit le conteneur et ses paramètres, tandis que le volume Docker conserve les modèles téléchargés.

Le réseau labo-ia prépare les communications entre les composants IA. Nous pourrons l'utiliser pour relier Ollama à AnythingLLM sans publier l'API du moteur sur Internet.

Le modèle installé est un premier point de départ. Nous pourrons ensuite comparer d'autres modèles en fonction de leurs capacités, de leur consommation mémoire et des performances réellement observées sur notre VPS.

À retenir

Ollama est installé et géré par Docker Compose. Un modèle a été téléchargé, une première génération a été exécutée et l'API HTTP a été testée.

La prochaine étape consistera à installer AnythingLLM et à le connecter à Ollama. Nous pourrons alors disposer d'une interface pour exploiter le modèle avant d'ajouter une base de connaissances spécialisée avec Qdrant et le RAG.