Ollama en tant que service réseau local : déploiement et intégration

Ollama permet d'exécuter des modèles de langage localement sur GPU. Ce guide présente une architecture de déploiement en tant que service réseau : un serveur Ollama centralisé auquel plusieurs clients se connectent par HTTP. Cette approche optimise l'utilisation des ressources GPU, réduit la redondance d'installation, et facilite la gestion des modèles.

Au lieu de maintenir une copie isolée d'Ollama sur chaque poste de travail, cette architecture centralise le service sur un serveur avec GPU. Les clients accèdent aux modèles via l'API réseau.

Ce document détaille les étapes de configuration, de validation, et d'optimisation pour un POC fonctionnel, incluant la résolution des problèmes courants et les recommandations de déploiement.

Comprendre l'architecture réseau

Avant de vous lancer, visualisons ce qu'on veut construire.

Poste 1 → [Ollama + GPU local] rapide, consomme des ressources
Poste 2 → [Ollama + GPU local] rapide, coûteux, gaspillage
Poste 3 → [Ollama + GPU local] rapide, coûteux, gaspillage

Serveur → [Ollama + GPU RTX 3080] ← Poste 1
                                  ← Poste 2
                                  ← Poste 3
Tous accèdent par HTTP, un seul GPU, une seule installation.

L'architecture est simple : un serveur avec GPU exécute Ollama en écoute sur le port 11434 (accessible sur le réseau), et chaque poste client se connecte par HTTP.

Avantages

• Centralisation : une seule installation, une seule mise à jour
• Économies : partage du GPU entre plusieurs utilisateurs
• Flexibilité : changez de poste sans réinstaller
• Performance : GPU dédié pour tous

Inconvénients

• Latence réseau mineure (négligeable en local)
• Dépendance au serveur

Prérequis : installer les drivers NVIDIA

C'est LE piège numéro un. Sans driver GPU, Ollama tourne sur CPU et devient inutilisable.

Vérifier la présence d'un GPU

Connectez-vous à votre serveur et lancez :

ssh [email protected]
lspci | grep -i nvidia

Résultat attendu :

01:00.0 VGA compatible controller: NVIDIA Corporation
GA102 [GeForce RTX 3080]

Si vous ne voyez rien, vérifiez que le GPU est bien présent physiquement et activé dans le BIOS.

Installer le driver

sudo apt update
sudo apt install nvidia-driver-550 -y
sudo reboot

Après le reboot, vérifiez :

nvidia-smi

Vous devriez voir une table affichant votre GPU, la VRAM, la température, etc. Si vous voyez ça, c'est bon, vous pouvez continuer.

Installer et configurer Ollama pour le réseau

Étape 1 : Installation basique

curl -fsSL https://ollama.com/install.sh | sh

Vérifiez :

which ollama
# /usr/local/bin/ollama

Étape 2 : Configuration réseau (la clé)

Par défaut, Ollama écoute seulement sur 127.0.0.1:11434 (machine locale). Pour l'ouvrir au réseau, vous devez changer ça.

Créer un override systemd :

sudo systemctl edit ollama

L'éditeur s'ouvre avec deux blocs ### délimitant une section vide. Ajoutez ceci entre les deux :

[Service]
Environment="OLLAMA_HOST=0.0.0.0"

Sauvegardez (Ctrl+X, Y, Enter dans nano).

Étape 3 : Démarrer le service

sudo systemctl daemon-reload
sudo systemctl enable ollama
sudo systemctl start ollama

Vérifiez :

sudo systemctl status ollama
ss -tlnp | grep 11434

Résultat attendu :

● ollama.service - Ollama Service
     Active: active (running)

LISTEN 0      4096               *:11434            *:*

Le *:11434 (et non 127.0.0.1:11434) signifie qu'Ollama écoute sur TOUTES les interfaces réseau. C'est ce qu'on veut.

Télécharger et tester les modèles

Modèles recommandés

Pour du prototypage rapide (léger) :

ollama pull qwen2.5:0.5b

• Taille : 755 MB
• Temps réponse : ~2-5 secondes
• Usage VRAM : ~2 GB

Pour le code et les tâches complexes (recommandé) :

ollama pull qwen2.5-coder:7b

• Taille : 4.9 GB
• Temps réponse : ~10-20 secondes
• Usage VRAM : ~6 GB (sur RTX 3080)

Tester depuis un poste client

Depuis une autre machine de votre réseau :

curl http://192.168.0.240:11434/api/generate -d '{
  "model": "qwen2.5-coder:7b",
  "prompt": "Écris une fonction Python qui calcule la suite de Fibonacci",
  "stream": false
}'

Résultat attendu :

{
  "model": "qwen2.5-coder:7b",
  "response": "def fibonacci(n):\n    if n <= 1:\n        return n...",
  "done": true
}

Si ça marche, bravo ! Ollama est accessible depuis le réseau.

Vérifier l'utilisation du GPU

Sur le serveur, vérifiez que les modèles tournent bien sur GPU :

ollama ps

NAME                ID              SIZE      PROCESSOR    CONTEXT
qwen2.5-coder:7b    dae161e27b0e    5.2 GB    100% GPU     8192

NAME                ID              SIZE      PROCESSOR    CONTEXT
qwen2.5-coder:7b    dae161e27b0e    4.9 GB    100% CPU     8957

Intégrer avec Aider (CLI recommandée)

Aider est un client CLI pour générer du code avec Ollama. C'est la meilleure option pour développer localement.

Installation

pip install aider-chat

Configuration

Lancez Aider avec votre serveur Ollama :

OLLAMA_API_BASE=http://192.168.0.240:11434 \
aider --model ollama/qwen2.5-coder:7b

Ou si aider n'est pas dans votre PATH :

OLLAMA_API_BASE=http://192.168.0.240:11434 \
~/.local/bin/aider --model ollama/qwen2.5-coder:7b

Utilisation

aider> Add a function that validates email addresses with regex

aider> Create unit tests for the email validator

aider> Explain the performance implications of this function

Conseil : Créez un alias pour ne pas retaper la commande complète :

# Dans ~/.bashrc ou ~/.zshrc
alias aider-ollama="OLLAMA_API_BASE=http://192.168.0.240:11434 \
aider --model ollama/qwen2.5-coder:7b"

Puis simplement :

aider-ollama

Troubleshooting courant

Problème : Timeout de connexion depuis le client

curl: (7) Failed to connect to 192.168.0.240
port 11434: Connection refused

Diagnostic :

1. Vérifiez que le serveur Ollama est bien en cours d'exécution : sudo systemctl status ollama
2. Vérifiez que le port 11434 est bien ouvert : ss -tlnp | grep 11434
3. Vérifiez la connexion réseau : ping 192.168.0.240

Problème : GPU ne s'utilise pas (100% CPU)

Cela signifie que les drivers NVIDIA ne sont pas détectés.

nvidia-smi

Si vous voyez une erreur, réinstallez les drivers :

sudo apt install --reinstall nvidia-driver-550 -y
sudo reboot

Problème : VRAM insuffisante

Si vous avez moins de 6 GB de VRAM libre, Ollama ne pourra pas charger le modèle 7B.

Solutions :

1. Utiliser un modèle plus petit : qwen2.5:0.5b (755 MB)
2. Augmenter la VRAM disponible (arrêter les applications gourmandes)
3. Utiliser la quantization : ollama pull qwen2.5-coder:7b-q4 (4-bit, ~2 GB)

Problème : Modèle reste en mémoire après utilisation

Si vous en avez marre d'utiliser votre VRAM pour rien :

# Lister les modèles
ollama ps
# Stopper un modèle
ollama stop <model_name>

Cas d'usage réels et résultats

Test 1 : Génération de code simple

Prompt :

Écris une fonction Python qui additionne deux nombres

Résultats :

• Temps réponse : ~12 secondes
• Tokens : 618 envoyés, 124 reçus
• Qualité : Code correct, docstring incluse

Test 2 : Génération complexe avec mémoïsation

Prompt :

Crée une fonction qui calcule la factorielle
avec mémoïsation et gestion d'erreurs

Résultats :

• Temps réponse : ~18 secondes
• Tokens : 812 envoyés, 249 reçus
• Qualité : Gestion d'erreurs correcte, docstring, exemples d'usage

Benchmark GPU

Machine serveur :

• OS : Ubuntu 22.04
• GPU : NVIDIA RTX 3080 (10 GB VRAM)
• Driver : NVIDIA 550.163.01
• CUDA : 12.4

Utilisation GPU en charge :

VRAM utilisée : 6031 MiB / 10240 MiB
(58.9%)
Température : 45°C
Puissance : 24W / 340W
Processus Ollama : 100% GPU

Performances excellentes, pas de throttling thermique.

Limitations et alternatives

Limitation : Claude Code Router n'est pas compatible

En décembre 2025, Claude Code force le mode "extended thinking" qui n'est pas supporté par Ollama. Claude Code Router reste bloqué sur cette limitation. Pour Claude Code, utilisez Aider en alternative.

Limitation : Latence réseau

Même en local, il y a une petite latence (~50-100ms) comparée à un appel local. Négligeable pour du développement.

Pour aller plus loin : Interface Claude Code-like

Une suite complète ollama-code est disponible en téléchargement. Elle automatise toute la configuration et fournit des scripts prêts à l'emploi.

Installation du package (3 étapes)

1. Extraire et installer

unzip ollama-code-package.zip
cd ollama-code-package
bash bin/ollama-code-setup

2. Vérifier l'installation

ollama-code --help

3. Utiliser dans un projet

ollama-code ~/my-project
# Ou avec l'alias
code ~/my-project

Ce que vous gagnez

Scripts automatisés :

• ollama-code - Lancer Aider dans un projet avec auto-config
• ollama-code-setup - Configuration complète en une commande
• ollama-code-demo - Demo interactive des capacités

Configuration centralisée :

• Une seule configuration pour tous les projets
• Création automatique de .aider.conf.yml par projet
• Ignore patterns optimisés
• Guidelines de code intégrées

Commandes principales (dans Aider) :

/map               # Structure du codebase
/add file.py       # Ajouter un fichier
/ask               # Mode questions
/code              # Mode édition (default)
/diff              # Voir les changements
/commit            # Valider
/help              # Toutes les commandes

Workflows avec ollama-code

Ajouter une feature :

$ ollama-code .
> /add src/main.py
> Ajoute une fonction pour calculer le PGCD
> /diff
> /commit

Analyser du code :

$ ollama-code --ask .
> Explique l'architecture du projet
> /code
> Améliore la gestion d'erreurs

Checklist de déploiement

Conclusion

Ollama comme service réseau, c'est transformer un GPU unique en ressource partagée sur votre réseau local.

Résultats du POC : déploiement entièrement fonctionnel en 2 heures. Les temps de réponse (15-20 secondes) sont acceptables pour la génération de code.