Pourquoi avez-vous besoin de WhichLLM ?

Exécuter localement des grands modèles de langage (LLM) est devenu la nouvelle norme pour les développeurs. Que vous utilisiez Ollama pour faire tourner Qwen, llama.cpp pour gérer les GGUF, ou LM Studio pour charger des modèles, les développeurs font face à un problème commun :

Quels modèles mon matériel peut-il exécuter ? Quel modèle offre les meilleures performances sur mon appareil ?

HuggingFace héberge des centaines de milliers de modèles, avec des spécifications allant de 1,5 milliard à 72 milliards de paramètres. Les méthodes de quantification incluent Q4_K_M, Q5_K_M, Q8_0... Télécharger aveuglément un modèle de 70 milliards de paramètres, attendre des heures pour découvrir que la VRAM est insuffisante, c'est perdre du temps inutilement.

WhichLLM a été créé pour résoudre ce problème. Il détecte automatiquement la configuration de votre matériel, compare les données de benchmark réelles (plutôt que le nombre de paramètres) et fournit en une seconde les recommandations de modèles les plus adaptées à votre matériel.

Aperçu des fonctionnalités principales

Fonctionnalité Description
Détection automatique Identifie automatiquement la configuration NVIDIA/AMD/Apple Silicon/CPU
Classement intelligent Basé sur des benchmarks réels (LiveBench, Aider, Open LLM Leaderboard, etc.), pas juste sur le nombre de paramètres
Conscience temporelle Les anciens modèles ne passent pas devant les nouveaux simplement grâce à leurs scores historiques
Simulation GPU Estimez les performances avant de changer de carte graphique : whichllm --gpu "RTX 5090"
Chat en un clic Téléchargez et lancez une conversation interactive après la recommandation
Extraits de code Générez du code Python d'inférence directement exécutable
Planification de mise à niveau Comparez les différences entre votre machine actuelle et les options candidates

Méthodes d'installation

WhichLLM propose plusieurs méthodes d'installation. Nous recommandons l'utilisation de uv ou Homebrew :

Méthode 1 : uv (recommandé, exécution sans installation)

BASH 
# Exécution unique (sans installation)
uvx whichllm@latest

# Installation globale
uv tool install whichllm

# Mise à jour
uv tool upgrade whichllm

Méthode 2 : Homebrew

BASH 
brew install andyyyy64/whichllm/whichllm

Méthode 3 : pip

BASH 
pip install whichllm

Une fois l'installation terminée, exécutez simplement whichllm pour l'utiliser.

Démarrage rapide

Détection automatique et recommandation de modèles

Aucune configuration nécessaire, exécutez simplement :

BASH 
whichllm

Exemple de sortie :

#1 Qwen/Qwen3.6-27B 27.8B Q5_K_M  score 92.8  27 t/s
#2 Qwen/Qwen3-32B  32.0B Q4_K_M  score 83.0  31 t/s
#3 Qwen/Qwen3-30B-A3B 30.0B Q5_K_M  score 82.7  102 t/s

WhichLLM détecte automatiquement votre GPU/CPU/RAM, recommande les modèles les plus adaptés et les trie par score global. Notez que la troisième place est occupée par un modèle MoE (Mixture of Experts) — bien que le nombre total de paramètres soit élevé, les paramètres actifs sont peu nombreux, donc la vitesse est beaucoup plus rapide.

Affichage des informations matérielles

BASH 
whichllm hardware

Exemple de sortie :

GPU: NVIDIA RTX 4090 (24 GB VRAM)
CPU: AMD Ryzen 9 7950X (16 cœurs)
RAM: 64 GB

Cela est très utile pour connaître la configuration de votre matériel, surtout si vous n'êtes pas sûr du modèle de GPU ou de la taille de la VRAM.

Fonctionnalités avancées

Simulation GPU : testez avant d'acheter une carte graphique

Vous envisagez de passer à la RTX 5090, mais voulez savoir quels modèles elle peut exécuter ? WhichLLM peut simuler n'importe quel GPU :

BASH 
# Simuler une RTX 5090
whichllm --gpu "RTX 5090"

# Simuler une RTX 4060
whichllm --gpu "RTX 4060"

# VRAM personnalisée
whichllm --gpu "RTX 5060 16"

Exemple de sortie :

#1 Qwen/Qwen3.6-27B 27.8B Q6_K    score 94.7  ~40 t/s
#2 Qwen/Qwen3-32B  32.0B Q5_K_M  score 88.0  ~38 t/s

C'est très pratique pour prendre des décisions avant d'acheter du matériel.

Planification de mise à niveau : comparez les gains potentiels

Vous voulez savoir quelle amélioration vous obtiendriez en passant d'une RTX 4090 à une RTX 5090 ?

BASH 
whichllm upgrade "RTX 4090" "RTX 5090" "H100"

La sortie affiche les modèles recommandés, les scores et les vitesses pour chaque configuration, clairement et simplement.

Planification inversée : quel GPU faut-il pour exécuter un modèle spécifique ?

BASH 
# De quel GPU ai-je besoin pour exécuter Llama 3 70B ?
whichllm plan "llama 3 70b"

# Exécuter la version quantifiée Q8_0 de Qwen2.5-72B
whichllm plan "Qwen2.5-72B" --quant Q8_0

# Scénario de contexte long
whichllm plan "mistral 7b" --context-length 32768

La sortie vous indiquera la quantité de VRAM nécessaire, le type de GPU recommandé et le niveau de performance attendu.

Chat en un clic : utilisez immédiatement après la recommandation

Après avoir reçu une recommandation de modèle, vous pouvez démarrer une conversation directement :

BASH 
# Télécharger et discuter avec un modèle spécifique
whichllm run "qwen 2.5 1.5b gguf"

# Sélectionner automatiquement le meilleur modèle et discuter
whichllm run

WhichLLM créera automatiquement un environnement isolé, téléchargera le modèle et lancera une conversation interactive.

Génération d'extraits de code Python

Si vous souhaitez utiliser un certain modèle dans votre propre application, WhichLLM peut générer du code Python directement exécutable :

BASH 
whichllm snippet "qwen 7b"

Sortie :

PYTHON 
from llama_cpp import Llama

llm = Llama.from_pretrained(
    repo_id="Qwen/Qwen2.5-7B-Instruct-GGUF",
    filename="qwen2.5-7b-instruct-q4_k_m.gguf",
    n_ctx=4096,
    n_gpu_layers=-1,
    verbose=False,
)

output = llm.create_chat_completion(
    messages=[{"role": "user", "content": "Hello!"}],
)
print(output["choices"][0]["message"]["content"])

Copiez et collez directement pour l'utiliser, sans avoir à parcourir la documentation.

Options de configuration avancées

Filtrage par cas d'usage

WhichLLM prend en charge le filtrage des modèles par type de tâche :

BASH 
# Sélectionner le modèle le plus adapté au codage
whichllm --profile code

# Conversation générale
whichllm --profile general

# Raisonnement mathématique
whichllm --profile math

# Vision/multimodal
whichllm --profile vision

Filtrage par précision de quantification

BASH 
# Recommander uniquement la quantification Q4_K_M
whichllm --quant Q4_K_M

# Afficher plus de résultats
whichllm --top 20

# Exigence de vitesse minimale
whichllm --min-speed 30

Contrôle du niveau de preuve

WhichLLM annotate le niveau de preuve pour le score de chaque modèle. Vous pouvez contrôler la fiabilité des recommandations :

BASH 
# Mode strict : recommander uniquement les modèles avec des données de benchmark directes
whichllm --evidence strict

# Mode basique : autoriser la correspondance inter-générationnelle au sein de la même série de modèles
whichllm --evidence base

Sortie JSON : intégration de scripts

Intégrez WhichLLM dans vos flux de travail automatisés :

BASH 
# Obtenir l'ID HuggingFace du meilleur modèle
whichllm --top 1 --json | jq -r '.models[0].model_id'

# Obtenir les informations complètes du meilleur modèle de codage
whichllm --profile code --top 3 --json | jq '.models[] | {name: .model_id, score: .score, speed: .estimated_tok_per_sec}'

Exemple de sortie :

JSON 
{
  "models": [
    {
      "model_id": "Qwen/Qwen3.6-27B-GGUF",
      "score": 92.8,
      "estimated_tok_per_sec": 27.3,
      "speed_confidence": "high",
      "quant": "Q5_K_M"
    }
  ]
}

Détails du mécanisme de notation

Le mécanisme de notation de WhichLLM est son point fort principal et mérite une explication séparée.

Sources de données

WhichLLM agrège les données de benchmark suivantes :

  • LiveBench — Évaluations générées en temps réel
  • Artificial Analysis — Plateforme de test indépendante tierce
  • Aider — Benchmark d'assistant de programmation IA
  • Chatbot Arena ELO — Score crowdsourcé de LMSYS
  • Open LLM Leaderboard — Classement officiel de HuggingFace
  • Évaluations multimodales/vision — Lorsque applicable

Règles de notation

  1. Plus grand n'est pas mieux : Un modèle de 27 milliards de paramètres sera classé devant un modèle de 32 milliards s'il obtient un score plus élevé
  2. Décroissance temporelle : Un modèle de 2024 ne supprimera pas un nouveau modèle de 2026 simplement grâce à un score historique élevé
  3. Niveaux de confiance : Chaque score est annoté avec un niveau de preuve : - direct — Le modèle et la méthode de quantification ont des données de benchmark directes - variant — Données de différentes versions de quantification du même modèle - base — Données du modèle de base (inférence inter-générationnelle) - interpolated — Estimation par interpolation - self-reported — Données rapportées par les développeurs eux-mêmes
  4. Mécanisme anti-fraude : Rejette les données fausses non fiables pour empêcher les petits modèles modifiés d'emprunter les scores des grands modèles

Tests réels : meilleurs choix pour différents matériels

Selon les dernières données de WhichLLM (juin 2026), les recommandations pour différentes configurations matérielles sont les suivantes :

Matériel VRAM Meilleure recommandation Vitesse
RTX 5090 32 GB Qwen3.6-27B Q6_K (score 94.7) ~40 t/s
RTX 4090 / 3090 24 GB Qwen3.6-27B Q5_K_M (score 92.8) ~27 t/s
RTX 4060 8 GB Qwen3-14B Q3_K_M (score 71.0) ~22 t/s
Apple M3 Max 36 GB Qwen3.6-27B Q5_K_M (score 89.4) ~9 t/s
Exécution CPU pure — gpt-oss-20b (MoE) Q4_K_M (score 45.2) ~6 t/s

💡 Remarque : Les paramètres actifs des modèles MoE (Mixture of Experts) sont bien inférieurs au nombre total de paramètres, donc ils sont plus rapides sur le même matériel. Le mécanisme de notation de WhichLLM prend déjà cela en compte.

Comparaison avec des outils similaires

Fonctionnalité WhichLLM Ollama LM Studio LocalAI
Recommandation automatique du meilleur modèle ✅ ❌ ❌ ❌
Simulation GPU ✅ ❌ ❌ ❌
Classement par données de benchmark ✅ ❌ ❌ ❌
Planification de mise à niveau ✅ ❌ ❌ ❌
Génération d'extraits de code ✅ ❌ ❌ ❌
Chat en un clic ✅ ✅ ✅ ✅
Sortie JSON ✅ ✅ ❌ ❌
CLI léger ✅ ✅ ❌ ✅

Ollama reste un bon choix pour exécuter des modèles, mais WhichLLM résout le problème de la sélection de modèles — ces deux outils sont complémentaires : utilisez WhichLLM pour trouver le meilleur modèle, puis utilisez Ollama ou d'autres outils pour l'exécuter.

Scénarios pratiques

Scénario 1 : Décision d'achat d'une nouvelle carte graphique

Vous voulez passer d'une RTX 3060, avec un budget suffisant pour acheter une RTX 5070 ou une RTX 4090 d'occasion :

BASH 
# Simuler le matériel actuel
whichllm --gpu "RTX 3060"

# Simuler les options de mise à niveau
whichllm upgrade "RTX 3060" "RTX 5070" "RTX 4090"

Comparez les résultats de sortie pour voir quels modèles chaque carte peut exécuter et à quelle vitesse, afin de prendre une décision rationnelle.

Scénario 2 : Conseils de sélection de modèles pour un projet

Votre équipe souhaite développer un système RAG local et doit choisir un modèle d'inférence :

BASH 
# Tester avec la configuration du serveur CI
whichllm --gpu "RTX 4090" --profile code --json | jq

Utilisez la sortie JSON pour l'intégrer directement dans vos documents de décision.

Scénario 3 : Déploiement sur des appareils edge

BASH 
# Mode CPU uniquement
whichllm --cpu-only --top 10

Trouvez les petits modèles les plus adaptés à l'inférence CPU pour les scénarios IoT ou embarqués.

Questions fréquentes

Q : WhichLLM va-t-il télécharger des modèles localement ?

R : Par défaut, whichllm interroge uniquement l'API HuggingFace et les données mises en cache localement, sans télécharger de modèles. Seule la commande whichllm run télécharge des modèles.

Q : Comment mettre à jour les données des modèles ?

BASH 
whichllm --refresh

Forcez l'actualisation du cache pour obtenir les derniers modèles de HuggingFace.

Q : Que faire en l'absence de connexion réseau ?

R : WhichLLM intègre un mécanisme de mise en cache et utilisera des données snapshot pré-mises en cache en mode hors ligne.

Q : Prend-il en charge les cartes graphiques AMD ?

R : Oui, WhichLLM prend en charge NVIDIA, AMD, Apple Silicon et le mode CPU pur.

Résumé

WhichLLM résout un problème central auquel sont confrontés les développeurs de LLM locaux : trouver celui qui convient le mieux à leur matériel parmi une multitude de modèles. Ses points forts sont :

  1. Classement intelligent basé sur des preuves — Pas simplement trié par taille de paramètres, mais combinant des données de benchmark réelles et la temporalité
  2. Fonction de simulation GPU — Testez les performances avant d'acheter du matériel, évitant les achats impulsifs
  3. Intégration en un clic — De la recommandation au chat en passant par la génération de code, un outil résout tout
  4. Scriptable — La sortie JSON facilite l'intégration dans les flux de travail automatisés

Que vous soyez un développeur débutant dans les LLM locaux ou une équipe en train de construire un environnement de production, WhichLLM peut vous faire gagner des heures de temps d'essai et d'erreur.

Informations sur le projet : - GitHub: github.com/Andyyyy64/whichllm - Licence: MIT - Installation: pip install whichllm ou brew install andyyyy64/whichllm/whichllm