whichllm: как за одну команду подобрать лучший локальный LLM под вашу видеокарту — VogueTech

Что нового

whichllm — это консольный инструмент, который подбирает лучший локальный LLM под ваш конкретный компьютер, а не просто самый большой, который влезает в видеопамять.

Ключевые новшества и цифры:

Автоопределение конфигурации: NVIDIA, AMD, Apple Silicon и CPU-only. whichllm сам считывает GPU, CPU, объём RAM и свободное место на диске.
Подбор моделей по реальным бенчмаркам, а не по размеру:
- LiveBench
- Artificial Analysis Index
- Aider
- мультимодальные и vision-тесты
- Chatbot Arena ELO
- Open LLM Leaderboard
Примеры реальных рекомендаций (снимок мая 2026, данные подтягиваются онлайн из Hugging Face):
- RTX 5090, 32 ГБ VRAM → Qwen3.6-27B, квантизация Q6_K, оценка 94.7, скорость ~40 токенов/с
- RTX 4090 / 3090, 24 ГБ VRAM → Qwen3.6-27B, Q5_K_M, оценка 92.8, ~27 токенов/с
- RTX 4060, 8 ГБ VRAM → Qwen3-14B, Q3_K_M, оценка 71.0, ~22 токенов/с
- Apple M3 Max, 36 ГБ → Qwen3.6-27B, Q5_K_M, оценка 89.4, ~9 токенов/с
- CPU-only → gpt-oss-20b (MoE), Q4_K_M, оценка 45.2, ~6 токенов/с
whichllm учитывает поколение моделей: более свежий Qwen3.6-27B (27.8B параметров, Q5_K_M, 92.8 балла, 27 токенов/с) может оказаться выше, чем более крупный Qwen3-32B (32B, Q4_K_M, 83.0 балла, 31 токен/с), если новый даёт лучший результат в тестах.
Для MoE-моделей whichllm разделяет:
- качество — по общему числу параметров
- скорость — по активным параметрам (пример: Qwen3-30B-A3B даёт 82.7 балла и 102 токена/с)
Один флаг --gpu позволяет «примерить» любую видеокарту до покупки: whichllm --gpu "RTX 5090".
Встроенная команда run сразу скачивает и запускает чат с выбранной моделью, без ручной установки фреймворков.
Команда snippet печатает готовый Python-код для выбранной модели — можно просто скопировать и вставить в проект.
Модели подбираются с учётом квантизации (Q3_K_M, Q4_K_M, Q5_K_M, Q6_K и т.д.), типа железа и ожидаемой скорости.

Как это работает

whichllm — это CLI-инструмент на Python 3.11+, который строит рейтинг моделей локального инференса по нескольким слоям данных.

Автоопределение железа

При запуске без параметров (whichllm) инструмент:

считывает данные о GPU:
- NVIDIA — через nvidia-ml-py
- AMD — через dbgpu/ROCm
- Apple Silicon — через Metal
проверяет CPU: название, количество ядер, поддержку AVX
смотрит объём RAM и свободное место на диске

Эта информация превращается в структуру HardwareInfo, с которой дальше работает движок.

Оценка VRAM и скорости

whichllm моделирует потребление видеопамяти и скорость инференса для каждой кандидатной модели:

VRAM = веса модели + KV-кэш (с учётом GQA) + активации + накладные расходы фреймворка (~500 МБ)
Скорость (токенов/с) считается из пропускной способности памяти GPU (справочник в constants.py) с поправкой на:
- тип квантизации (Q4_K_M, Q5_K_M, Q6_K и т.п.)
- выбранный backend (llama-cpp, transformers + autoawq / auto-gptq)
- режим (полное размещение в VRAM, частичная выгрузка на RAM, CPU-only)
- для MoE — разницу между общими и активными параметрами

Результат — тип совместимости: полноценно на GPU, частичный offload или только CPU.

Сбор моделей и бенчмарков

whichllm напрямую ходит в Hugging Face API и забирает только релевантные модели:

text-generation модели с хорошими скачиваниями и свежими апдейтами
GGUF-версии (отдельный запрос для покрытия локального инференса)
vision-модели (image-text-to-text), когда вы включаете профиль --profile vision или мультимодальные задачи

Данные кешируются в ~/.cache/whichllm/:

models.json — TTL 6 часов
benchmark.json — TTL 24 часа

Бенчмарки приходят из двух уровней:

Текущий уровень (живые данные, когда доступен интернет):
- LiveBench
- Artificial Analysis Index
- Aider
- собственный индекс мультимодальных/vision-тестов
Замороженный уровень:
- Open LLM Leaderboard v2
- Chatbot Arena ELO

Старые результаты по поколениям моделей понижаются: модель 2024 года не сможет обогнать Qwen3.6 2026 года только за счёт старого лидерборда.

Система доказательств по бенчмаркам

Каждая оценка модели помечается по происхождению и получает свой коэффициент доверия:

direct — точное совпадение ID модели (максимальное доверие)
variant — совпадение после отсечения суффиксов вроде -Instruct
base_model — оценка базовой модели из cardData
line_interp — интерполяция по размеру внутри семейства моделей
self_reported — авторамодельные результаты, сильно занижаются по весу

Самодельные завышенные результаты и попытки «унаследовать» скор от гораздо более крупной модели внутри семейства whichllm отбрасывает. Если параметры модели отличаются больше чем в 2 раза от доминирующего члена семейства, наследование не срабатывает.

Система скоринга 0–100

Каждая модель получает итоговый балл от 0 до 100. На него влияют:

Качество по бенчмаркам (ядро) — агрегат LiveBench, Artificial Analysis, Aider, Vision, Arena ELO, Open LLM Leaderboard с весами по доверию к источнику.
Размер модели (до 35 баллов) — логарифмическая шкала по числу параметров как прокси для «мировых знаний». Для MoE учитывается общее количество параметров.
Квантизация — низкие биты получают мультипликативный штраф к качеству.
Доверие к доказательствам — коэффициент от 0.55 до 1.0:
- self-reported или без данных — ×0.55
- унаследованные или интерполированные — ×0.78
- прямые совпадения — ×1.0
Режим запуска — от ×0.50 до 1.0:
- CPU-only — ×0.50
- частичный offload — ×0.72
- полный запуск на GPU — ×1.0
Скорость — от −8 до +8 баллов, чтобы отсечь слишком медленные варианты относительно минимального порога токенов/с для данного железа.
Доверие к источнику — от −5 до +5: официальный орг-бейдж получает бонус, известный «перепаковщик» — штраф.
Популярность — скачивания и лайки на Hugging Face как тай-брейкер, влияние уменьшается по мере роста качества доказательств.

Маркеры в выводе:

~ (жёлтый) — нет прямых бенчмарков, оценка унаследована или интерполирована внутри семейства.
? (жёлтый) — нет данных по бенчмаркам.

CLI и JSON-режим

whichllm — это утилита на Typer (src/whichllm/cli.py). Она поддерживает несколько режимов:

whichllm — автоопределение железа и список лучших моделей
whichllm --gpu "RTX 4090" — симуляция конкретной видеокарты
whichllm plan "llama 3 70b" — подбор железа под заданную модель
whichllm run — скачать и сразу запустить чат с лучшей моделью
whichllm snippet "qwen 7b" — вывести готовый Python-код
whichllm --json — вывод в JSON для пайплайнов

Данные можно легко парсить через jq и использовать в shell-скриптах.

Что это значит для вас

Когда whichllm действительно полезен

Вы хотите запускать LLM локально, но не хотите разбираться в сотнях моделей.

Вместо того чтобы наугад ставить «самую большую, которая лезет в VRAM», вы получаете модель, которая:
- гарантированно помещается в память
- показывает высокие результаты в бенчмарках
- даёт приемлемую скорость на вашем железе
Вы подбираете видеокарту под локальный LLM.

Команда:
```
whichllm --gpu "RTX 4090"
whichllm --gpu "RTX 5090"
```
покажет, что вы реально получите на этих картах: какую Qwen, в какой квантизации, с каким скором (например, 40 токенов/с на RTX 5090 для Qwen3.6-27B Q6_K).
Вы пишете код вокруг локальных моделей.

whichllm snippet выдаёт готовый Python-код для llama-cpp или transformers. Не нужно вручную искать правильный файл *.gguf, нужную квантизацию и параметры n_ctx.
Вы используете Ollama или свои пайплайны.

whichllm умеет работать как «мозг» выбора модели, а вы уже решаете, чем её запускать. Пример с Ollama ниже.
Вы хотите чётко понимать, за что платите ресурсами.

whichllm прозрачно показывает:
- сколько VRAM съест модель
- будет ли offload в RAM
- какую скорость примерно ждать

Где инструмент не поможет

Если вы работаете только с облачными моделями вроде GPT-4o или Claude 3, и локальный инференс не нужен.
Если вы не готовы разбираться с Python и консолью. Интерфейс текстовый, без графики.
Если вы рассчитываете на точное совпадение скорости до токена: расчёт даёт оценку, а не лабораторный замер.

VPN и доступность

whichllm тянет данные и модели с Hugging Face и использует Python-пакеты из PyPI, а также может интегрироваться с Ollama. Для пользователей из России часть этих сервисов может открываться только через VPN. Если Hugging Face или PyPI недоступны, инструмент будет использовать кеш и заранее подготовленные списки, но это ограничит свежесть моделей и бенчмарков.

Место на рынке

whichllm конкурирует не с конкретной моделью, а с набором утилит и подходов: «поставлю Llama 3 70B, раз влезает», «посмотрю первую страницу Hugging Face», «возьму то, что есть в Ollama». На их фоне whichllm даёт более структурированный подход.

Ключевые отличия от типичного сценария «берём самое большое»:

whichllm может поставить Qwen3.6-27B выше Qwen3-32B, хотя 32B формально крупнее. Причина — 27B даёт 92.8 балла против 83.0 по собранным бенчмаркам и относится к более свежему поколению.
Для MoE-моделей whichllm учитывает, что они могут давать 102 токена/с (пример Qwen3-30B-A3B) при сопоставимом качестве, а не просто смотрит на «30B параметров».
Инструмент интегрирует сразу несколько источников бенчмарков с разным весом, а не опирается на один лидерборд.

Прямых цифр сравнения с GPT-4o, GPT-4.1, Claude 3.5 Sonnet или другими облачными моделями у whichllm нет. Инструмент фокусируется на локальных LLM из Hugging Face и не пытается оценивать платные API.

С точки зрения экосистемы локального инференса whichllm дополняет:

Ollama — как подборщик модели: whichllm выбирает ID, Ollama её запускает.
llama-cpp-python, transformers, autoawq, auto-gptq — как слой запуска, которым управляет whichllm через run и snippet.

Если вы уже пользуетесь Ollama или вручную собираете стеки на llama-cpp/transformers, whichllm закрывает именно вопрос выбора модели под железо и задачу.

Установка

pipx (рекомендуется)

pipx install whichllm

Homebrew

brew tap Andyyyy64/whichllm
brew install whichllm

pip

pip install whichllm

Разработка из исходников

git clone https://github.com/Andyyyy64/whichllm.git
cd whichllm
uv sync --dev
uv run whichllm
uv run pytest

Требуется Python 3.11+. Для NVIDIA whichllm использует nvidia-ml-py, который ставится вместе с зависимостями. AMD и Apple Silicon определяются автоматически.

Как запустить

Базовое использование

Автоопределение железа и список лучших моделей под вашу систему:

# Автоопределить GPU/CPU/RAM и показать лучшие модели
whichllm

Симуляция видеокарты — удобно при планировании покупки:

# Пример: планируете брать RTX 4090 или 5090
whichllm --gpu "RTX 4090"
whichllm --gpu "RTX 5090"

Только CPU-режим:

whichllm --cpu-only

Больше результатов и фильтры:

whichllm --top 20            # показать топ-20
whichllm --quant Q4_K_M      # зафиксировать квантизацию
whichllm --min-speed 30      # минимальная скорость 30 токенов/с

# Фильтрация по типу доказательств
whichllm --evidence base     # разрешить совпадения по base_model
whichllm --evidence strict   # только точные ID (то же, что --direct)
whichllm --direct            # только прямые бенчмарки

JSON-вывод для скриптов:

whichllm --json

Принудительное обновление кеша:

whichllm --refresh

Вывести только информацию о железе:

whichllm hardware

Планирование железа под модель

Подбор GPU под конкретную модель:

# Что нужно, чтобы комфортно запускать Llama 3 70B?
whichllm plan "llama 3 70b"

# План под Qwen2.5-72B с квантизацией Q8_0
whichllm plan "Qwen2.5-72B" --quant Q8_0

# План под Mistral 7B с контекстом 32 768 токенов
whichllm plan "mistral 7b" --context-length 32768

Быстрый запуск чата с моделью

Команда run создаёт изолированное окружение через uv, ставит зависимости, скачивает модель и запускает интерактивный чат.

# Чат с конкретной GGUF-моделью (подберётся лучший вариант файла)
whichllm run "qwen 2.5 1.5b gguf"

# Автовыбор лучшей модели под ваше железо и запуск чата
whichllm run

# Принудительно CPU-only
whichllm run "phi 3 mini gguf" --cpu-only

Поддерживаемые форматы:

GGUF — через llama-cpp-python (лёгкий и быстрый backend)
AWQ / GPTQ — через transformers + autoawq / auto-gptq
FP16 / BF16 — через transformers

Генерация Python-сниппетов

Если вы хотите встроить модель в свой код, whichllm snippet выдаёт готовый пример.

whichllm snippet "qwen 7b"

Пример вывода:

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"])

Дополнительно можно задать квантизацию и формат, например:

whichllm snippet "llama 3 8b gguf" --quant Q5_K_M

Интеграции

Ollama

whichllm легко подружить с Ollama: первая выбирает лучшую модель, вторая её запускает.

Запустить лучшую модель через Ollama:

# Выбрать топ-1 модель и сразу отдать её в ollama run
whichllm --top 1 --json \
  | jq -r '.models[0].model_id' \
  | xargs ollama run

Найти лучшую модель для кода (профиль coding) и запустить:

whichllm --profile coding --top 1 --json \
  | jq -r '.models[0].model_id' \
  | xargs ollama run

Удобно оформить это алиасом в shell:

# Добавьте в .bashrc или .zshrc
alias bestllm='whichllm --top 1 --json | jq -r ".models[0].model_id"'

# Использование
ollama run $(bestllm)

Как устроен проект внутри

Для тех, кто хочет доработать whichllm под себя, полезно понимать структуру:

src/whichllm/
├── cli.py           # Typer CLI: main, plan, run, snippet, hardware
├── constants.py     # Пропускная способность GPU, байты на квант, compute capability
├── hardware/
│   ├── detector.py  # Оркестратор GPU/CPU/RAM-детекции
│   ├── nvidia.py    # NVIDIA через nvidia-ml-py
│   ├── amd.py       # AMD (Linux)
│   ├── apple.py     # Apple Silicon (Metal)
│   ├── cpu.py       # CPU: имя, ядра, AVX
│   ├── memory.py    # RAM и свободный диск
│   ├── gpu_simulator.py # Реализация флага --gpu
│   └── types.py     # GPUInfo, HardwareInfo
├── models/
│   ├── fetcher.py   # Hugging Face API, парсинг моделей и evalResults
│   ├── benchmark.py # Arena ELO, Leaderboard (parquet/rows API)
│   ├── grouper.py   # Группировка в семейства по base_model и имени
│   ├── cache.py     # JSON-кеш с TTL
│   └── types.py     # ModelInfo, GGUFVariant, ModelFamily
├── engine/
│   ├── vram.py      # Расчёт VRAM: веса + KV + активации + оверхед
│   ├── compatibility.py # Тип запуска, проверка диска, compute/OS-предупреждения
│   ├── performance.py   # Оценка токенов/с из пропускной способности
│   ├── quantization.py  # Байты на вес, штрафы за квантизацию, не-GGUF инференс
│   ├── ranker.py        # Скоринг, фильтрация по доказательствам, профили задач
│   └── types.py         # CompatibilityResult
└── output/
    └── display.py   # Таблицы в терминале, JSON, вывод hardware/plan

Проект распространяется под лицензией MIT. Авторы открыты к pull request'ам, подробности — в CONTRIBUTING.md.

Кому whichllm особенно зайдёт

Разработчикам, которые хотят локальный LLM на своём железе, но не хотят тратить дни на перебор моделей.
MLOps-инженерам, которые планируют закупку GPU под внутренние ассистенты, кодовые помощники или RAG-системы.
Энтузиастам, которые уже используют Ollama, llama-cpp или transformers и хотят системный способ выбирать модели.

Если вам нужен быстрый ответ «что поставить на мой RTX 4060» или «какой GPU взять под Qwen3.6-27B», whichllm закрывает этот вопрос одной командой.