Ollama multi-modèles en parallèle : configuration Qwen, Llama et DeepSeek

Depuis Ollama 0.2, plusieurs modèles peuvent tourner en parallèle. Plus besoin de passer de ollama run deepseek-coder au code à ollama run qwen2.5 pour la traduction, avec un rechargement de dix secondes à chaque fois. Un seul service, trois modèles à la demande : DeepSeek pour le code, Qwen pour le chinois, Llama pour les questions générales.

Trois variables d’environnement activent le parallélisme : OLLAMA_MAX_LOADED_MODELS limite le nombre de modèles chargés, OLLAMA_NUM_PARALLEL le parallélisme par modèle, OLLAMA_KEEP_ALIVE la durée de veille en mémoire. Cet article détaille la configuration, les forces de chaque modèle et la gestion mémoire — précharger les modèles fréquents, charger les autres à la demande, emprunter la RAM système si la VRAM ne suffit pas.

Configuration de base du parallélisme multi-modèles Ollama

Bonne nouvelle d’abord : depuis Ollama 0.2, le parallélisme multi-modèles est natif. Pas de plugin supplémentaire ni de fichier de config complexe. Quelques variables d’environnement suffisent pour garder plusieurs modèles prêts.

La mauvaise : si la VRAM manque, ces modèles peuvent saturer la RAM système et ralentir fortement la machine.

Trois variables d’environnement clés

Ouvrez un terminal et regardez ces trois variables :

# Nombre maximal de modèles chargés en même temps
export OLLAMA_MAX_LOADED_MODELS=3

# Nombre maximal de requêtes simultanées par modèle
export OLLAMA_NUM_PARALLEL=2

# Longueur maximale de la file d'attente (au-delà, les nouvelles requêtes sont refusées)
export OLLAMA_MAX_QUEUE=512

OLLAMA_MAX_LOADED_MODELS est la clé. À 3, vous pouvez faire tourner Qwen, Llama et DeepSeek en parallèle. Ne montez pas la valeur trop haut — elle dépend du matériel. Les besoins mémoire sont détaillés plus bas.

OLLAMA_NUM_PARALLEL règle la concurrence par modèle. Si votre service reçoit plusieurs requêtes en même temps, vous pouvez l’augmenter. Pour un usage personnel, la valeur par défaut suffit en général.

Configuration du service système (Linux)

Avec systemd (cas le plus courant sous Linux), c’est simple :

sudo systemctl edit ollama.service

Ajoutez dans l’éditeur :

[Service]
Environment="OLLAMA_MAX_LOADED_MODELS=3"
Environment="OLLAMA_NUM_PARALLEL=2"
Environment="OLLAMA_KEEP_ALIVE=30m"

Enregistrez, puis redémarrez :

sudo systemctl restart ollama

OLLAMA_KEEP_ALIVE contrôle combien de temps un modèle reste en mémoire après chargement. À 30m, il reste prêt 30 minutes ; le prochain appel évite le rechargement. Pour le garder indéfiniment, utilisez -1.

La mémoire suffit-elle ? Une méthode rapide

Configuration faite — mais la mémoire tient-elle la route ?

KiloClaw - OpenClaw managé pour l’entreprise : orchestration d’agents IA et routage intelligent

Commencer →Pub

Estimation grossière : un modèle 7B demande environ 4 à 5 Go de VRAM (quantification FP16), un 14B environ 8 à 10 Go. Trois modèles 7B chargés en même temps impliquent au moins 16 Go de VRAM.

Ma RTX 3060 n’a que 12 Go : deux modèles 7B passent bien, le troisième emprunte la RAM système — la vitesse chute nettement. Sur Mac (Apple Silicon), mémoire unifiée partagée : 32 Go suffisent largement pour trois modèles.

Trois modèles : forces et stratégie de choix

Configuration en place — comment choisir ? Au début, j’hésitais aussi : trois modèles installés, sans savoir lequel appeler. Après quelques essais, une logique s’est dégagée.

Qwen : référence pour le chinois et le multilingue

La série Qwen d’Alibaba excelle en chinois. Je l’ai utilisée pour de la doc en chinois et des traductions techniques depuis l’anglais, avec de bons résultats. Selon les données officielles, Qwen couvre plus de 100 langues — pas seulement chinois et anglais, mais aussi japonais, coréen, français, espagnol, etc.

Pour du contenu chinois ou de la traduction multilingue, Qwen est le premier choix. Avec qwen2.5:7b, j’ai traduit un document technique de 5 000 caractères, souvent mieux que des outils en ligne — surtout pour les termes techniques, sans transformer « API endpoint » en absurdités.

Llama : le plus équilibré en usage général

La série Llama de Meta est un pilier des modèles open source. En cas de doute sur le type de tâche, Llama est un choix sûr.

Atout majeur : licence commerciale souple. Tant que votre produit reste sous 7 millions d’utilisateurs actifs mensuels, usage commercial gratuit — important pour les indépendants et petites équipes.

Autre avantage : grande fenêtre de contexte. Llama 3.2 monte à 128K tokens — de quoi tenir un roman entier. Utile pour de très longs documents.

DeepSeek : code et raisonnement

J’utilise DeepSeek depuis peu, surtout pour le code : qualité élevée et explications claires de la logique générée.

Selon un rapport Premai, le coût de raisonnement de DeepSeek est environ 95 % inférieur à des modèles comparables — un avantage concret pour enchaîner beaucoup de tâches de raisonnement sur du matériel limité.

Comment choisir ? Un tableau

Mon habitude : DeepSeek pour le code, Qwen pour la doc en chinois, Llama pour l’anglais ou l’incertitude. Trois rôles distincts, peu d’hésitation.

Bascule entre modèles et gestion mémoire

Au début, ma principale frustration était la lenteur des changements de modèle : rechargement, ventilateur GPU — l’attente gâchait le flux. Ce délai peut être optimisé.

D’où vient la latence de bascule ?

Comptez environ 10 à 30 secondes selon la taille du modèle, la vitesse du disque et l’état de la mémoire. Un 7B du disque vers le GPU : 10 à 15 s ; un 14B : 20 à 30 s.

En pratique, c’est pénible : vous générez une fonction avec DeepSeek, puis voulez traduire les commentaires avec Qwen — et vous attendez.

keep_alive : garder les modèles « en veille »

La solution : OLLAMA_KEEP_ALIVE.

Principe : une fois chargé, le modèle reste en mémoire. Le prochain appel au même modèle est immédiat.

Configuration globale :

🔥 Ne perdez plus des mois sur des produits sans demande ! Validez vos promesses SaaS avec Adsterra à petit budget →

Tester l'MVP →Pub

export OLLAMA_KEEP_ALIVE=30m  # 30 minutes après chargement
# ou
export OLLAMA_KEEP_ALIVE=-1   # indéfiniment, jusqu'à déchargement manuel

Ou par requête :

curl http://localhost:11434/api/generate \
  -d '{"model": "qwen2.5:7b", "prompt": "", "keep_alive": "60m"}'

Une requête vide (prompt vide) charge le modèle et le garde en mémoire — bon moyen de précharger les modèles fréquents pour des réponses instantanées ensuite.

Décharger un modèle manuellement

Si la mémoire est tendue :

curl http://localhost:11434/api/generate \
  -d '{"model": "qwen2.5:7b", "keep_alive": 0}'

keep_alive à 0 décharge immédiatement la mémoire sans supprimer les fichiers du modèle.

Besoins mémoire selon la taille du modèle

Tableau indicatif (retours communautaires et mes tests) :

Ma RTX 3060 (12 Go VRAM) en Q4 peut tenir un 14B et un 7B, ou trois 7B — le troisième emprunte la RAM système, plus lent mais stable.

VRAM insuffisante mais 32 Go+ de RAM système : inférence CPU possible, beaucoup plus lente mais utilisable.

Astuce : prioriser les modèles fréquents

Je garde le modèle le plus utilisé sur le GPU en permanence ; les autres se chargent à la demande, parfois en RAM système.

Exemple : DeepSeek le plus souvent → toujours sur GPU. Qwen et Llama moins souvent → chargement à l’appel.

Les tâches fréquentes restent rapides, les rares un peu plus lentes — bon compromis global. Adaptez l’ordre à votre usage.

Scénarios d’application

Théorie posée — usages concrets. Voici ce que j’utilise le plus souvent.

Assistant de code : code + documentation

Scénario le plus fréquent, deux modèles en duo :

• DeepSeek : logique, explications, débogage
• Qwen : commentaires en chinois, doc en chinois

Exemple API : d’abord DeepSeek pour le squelette :

curl http://localhost:11434/api/generate \
  -d '{"model": "deepseek-coder:6.7b", "prompt": "写一个 Express.js 的 RESTful API，处理用户注册和登录"}'

Puis Qwen pour traduire les commentaires :

curl http://localhost:11434/api/generate \
  -d '{"model": "qwen2.5:7b", "prompt": "把这段代码的英文注释翻译成中文：\n[代码内容]"}'

Deux rôles, plus efficace qu’un seul modèle pour tout.

Vultr - Serveur cloud NVMe haute performance, 32 emplacements mondiaux, déploiement Docker en un clic

Voir les tarifs →Pub

Support client bilingue

Pour un public international :

• Llama pour l’anglais
• Qwen pour le chinois

Détection de langue puis routage :

import requests

def get_response(user_input, language):
    model = "llama3.2:3b" if language == "en" else "qwen2.5:7b"

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": user_input, "stream": False}
    )

    return response.json()["response"]

Chaque utilisateur reçoit une réponse naturelle dans sa langue.

Q&R : raisonnement + conversation

Selon le type de question :

• DeepSeek pour le raisonnement (« pourquoi », « comment »)
• Llama pour l’ouverture (« qu’en pensez-vous », discussion libre)

DeepSeek structure mieux l’analyse ; Llama sonne plus conversationnel.

Indices simples : « pourquoi », « cause », « principe » → DeepSeek ; « qu’en pensez-vous », « discutons » → Llama.

Exemple d’appel complet

Script Python minimal avec sélection automatique :

import requests

def call_ollama(task_type, prompt):
    """Choisir le modèle selon le type de tâche"""

    model_map = {
        "code": "deepseek-coder:6.7b",
        "chinese": "qwen2.5:7b",
        "english": "llama3.2:3b",
        "reasoning": "deepseek-coder:6.7b",
        "general": "llama3.2:3b"
    }

    model = model_map.get(task_type, "llama3.2:3b")

    # Préchargement optionnel
    requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": "", "keep_alive": "30m"}
    )

    # Appel effectif
    response = requests.post(
        "http://localhost/11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )

    return response.json()["response"]

# Exemple
result = call_ollama("code", "写一个 Python 函数，计算斐波那契数列的第 N 项")
print(result)

Base pour un orchestrateur multi-modèles : types de tâches, logique plus riche, fusion de réponses, etc.

Pour les bases Ollama, voir les deux premiers articles de la série : Ollama pour débutants : première étape pour exécuter un LLM en local et Paramètres Modelfile Ollama en détail. Celui-ci complète avec le déploiement multi-modèles.

Tableau de configuration rapide

Résumé

En bref, trois points :

1. Trois variables d’environnement suffisent pour le parallélisme : OLLAMA_MAX_LOADED_MODELS pour la quantité, OLLAMA_KEEP_ALIVE pour la veille.

2. Choisir selon la tâche : DeepSeek pour le code, Qwen pour le chinois, Llama pour le général.

3. Gérer la mémoire : précharger l’essentiel, charger le reste à la demande, emprunter la RAM si la VRAM manque.

Avec 16 Go+ de VRAM ou 32 Go+ de mémoire unifiée sur Mac, essayez trois modèles en parallèle. Un peu de réglage au départ, puis fluidité : moins de bascules, moins d’attente au chargement.

Des questions ou des galères ? Laissez un commentaire — j’apprends aussi, et votre cas a peut-être déjà une réponse de mon côté.