llmfit

Ferramenta de terminal escrita em Rust que detecta o hardware do sistema e indica quais modelos LLM rodam bem localmente. Avalia RAM, CPU e GPU, pontua cada modelo em múltiplas dimensões e recomenda a melhor quantização disponível. Possui TUI interativa (padrão) e modo CLI clássico.

Repositório: https://github.com/AlexsJones/llmfit
Licença: MIT
Linguagem principal: Rust (78,5%)

Instalação

macOS / Linux

# Via script
curl -fsSL https://llmfit.axjns.dev/install.sh | sh
 
# Via Homebrew (binário pré-compilado)
brew install AlexsJones/llmfit/llmfit

Windows

scoop install llmfit

uv / pip

uv tool install -U llmfit
# ou sem instalar:
uvx llmfit

Docker

docker run ghcr.io/alexsjones/llmfit

A partir do código-fonte

git clone https://github.com/AlexsJones/llmfit.git
cd llmfit
cargo build --release

Uso

TUI (padrão)

llmfit

Mostra specs do sistema no topo e tabela de modelos ordenada por score. Principais atalhos:

Tecla	Ação
`↑`/`↓` ou `j`/`k`	Navegar modelos
`/`	Busca por nome, provedor, params ou uso
`f`	Filtrar por fit: All, Runnable, Perfect, Good, Marginal
`s`	Ordenar por coluna: Score, Params, Mem%, Ctx, Date, Use Case
`v` / `V`	Modo Visual (seleção múltipla) / Modo Select (filtro por coluna)
`p`	Modo Plan — estima hardware necessário para um modelo
`S`	Simulação de hardware (override RAM/VRAM/CPU)
`A`	Configuração avançada (tuning de scoring e estimativa de TPS)
`D`	Download Manager (histórico, deleção, config de diretório)
`b`	Leaderboard comunitário (dados reais via localmaxxing.com)
`I`	Inference Bench — benchmark real contra provedores locais
`d`	Baixar modelo selecionado (abre seletor de provedor se houver mais de um)
`t`	Trocar tema de cores (10 temas, salvo automaticamente)
`h`	Ajuda com todos os atalhos
`q`	Sair

CLI

llmfit --cli                          # Tabela de todos os modelos
llmfit fit --perfect -n 5             # Top 5 modelos com fit perfeito
llmfit system                         # Specs do hardware detectado
llmfit search "llama 8b"              # Busca por nome/provedor/tamanho
llmfit info "Mistral-7B"              # Detalhes de um modelo
llmfit recommend --json --limit 5     # Top 5 recomendações em JSON
llmfit recommend --json --use-case coding --limit 3
llmfit plan "Qwen/Qwen3-4B-MLX-4bit" --context 8192   # Hardware necessário p/ um modelo
llmfit bench --provider ollama llama3.2               # Benchmark real de inferência
llmfit serve --host 0.0.0.0 --port 8787               # API REST (scheduler/agregador)

Overrides úteis

# Forçar VRAM/RAM/CPU manualmente (quando autodetecção falha)
llmfit --memory=24G --ram=64G --cpu-cores=8 fit
 
# Limitar contexto para estimativa de memória
llmfit --max-context 4096 --cli
 
# Hardware como JSON
llmfit --json system

Dashboard web

Ao rodar llmfit (modo não-JSON), inicia automaticamente um dashboard em http://<ip>:8787. Desabilitar com --no-dashboard.

Como funciona

1. Detecção de hardware

RAM e CPU via sysinfo
NVIDIA: nvidia-smi (multi-GPU, agrega VRAM)
AMD: rocm-smi
Intel Arc: sysfs / lspci
Apple Silicon: system_profiler (VRAM = RAM unificada)
Ascend: npu-smi

2. Base de modelos

Centenas de modelos do HuggingFace, embutidos no binário em tempo de compilação (data/hf_models.json). Suporte a arquiteturas MoE (Mixtral, DeepSeek): estima apenas os experts ativos por token, reduzindo a VRAM necessária significativamente (ex.: Mixtral 8x7B cai de 23,9 GB para ~6,6 GB com offload).

3. Quantização dinâmica

Testa de Q8_0 (melhor qualidade) até Q2_K (mais comprimido), escolhendo a melhor que cabe na memória disponível. Se nada couber no contexto total, tenta meio contexto.

4. Score multidimensional (0–100 cada)

Dimensão	O que mede
Quality	Params, reputação do modelo, penalidade de quantização
Speed	Tokens/s estimados por backend e quantização
Fit	Eficiência de uso de memória (ideal: 50–80%)
Context	Tamanho da janela de contexto vs. caso de uso

Pesos variam por categoria: Chat prioriza Speed (0.35); Reasoning prioriza Quality (0.55).

5. Estimativa de velocidade

Inferência é limitada por banda de memória: (banda_GB_s / tamanho_modelo_GB) × fator_eficiência (padrão 0.55, ajustável em A). Tabela cobre ~80 GPUs (NVIDIA, AMD, Apple Silicon).

6. Modos de execução e fit

Modo	Descrição
GPU	Modelo cabe na VRAM — inferência rápida
MoE	Experts ativos na VRAM, inativos na RAM
CPU+GPU	VRAM insuficiente, spill para RAM com offload parcial
CPU	Sem GPU, tudo na RAM do sistema

Fit	Condição
Perfect	Memória recomendada disponível na GPU
Good	Cabe com margem (MoE offload ou CPU+GPU)
Marginal	Fit apertado ou CPU-only
Too Tight	Sem memória suficiente

Integração com provedores locais

Provedor	Endpoint padrão	Observação
Ollama	`http://localhost:11434`	detecção e pull via API (`/api/tags`, `/api/pull`)
llama.cpp	—	requer `llama-cli`/`llama-server` no PATH; baixa GGUF da HF
MLX	—	Apple Silicon; usa repos `mlx-community/*`
Docker Model Runner	`http://localhost:12434`	Docker Desktop, naming `ai/<tag>`
LM Studio	`http://127.0.0.1:1234`	aceita nomes HF diretamente

Cada provedor pode rodar remoto via variáveis de ambiente (OLLAMA_HOST, LMSTUDIO_HOST, DOCKER_MODEL_RUNNER_HOST). Quando há mais de um provedor compatível, d na TUI abre um seletor.

Funcionalidades adicionais

Community Leaderboard (b): dados reais de tok/s, TTFT e VRAM de outros usuários, via localmaxxing.com. Suporta API key opcional (LOCALMAXXING_API_KEY).
Inference Bench (I): benchmark real (não estimado) contra Ollama/vLLM/MLX rodando localmente.
Hardware Simulation (S): recalcula toda a tabela contra RAM/VRAM/CPU simulados, sem alterar o hardware real.
Advanced Configuration (A): ajusta fatores de eficiência de TPS e pesos de scoring.
Download Manager (D): histórico de downloads, deleção de modelos, config de diretório GGUF.
REST API (llmfit serve): expõe os mesmos dados de fit/score via HTTP, útil para schedulers de cluster.
OpenClaw skill: llmfit pode ser instalado como skill do agente OpenClaw para recomendação e auto-configuração de modelos.

Estrutura do projeto

src/
  main.rs        # Entrypoint, parsing CLI, launch TUI
  hardware.rs    # Detecção de RAM/CPU/GPU
  models.rs      # Base de modelos e quantização
  fit.rs         # Scoring multidimensional, estimativa de velocidade, MoE
  providers.rs   # Integração Ollama/llama.cpp/MLX/Docker/LM Studio
  display.rs     # Renderização CLI + JSON
  tui_app.rs     # Estado da TUI
  tui_ui.rs      # Renderização (ratatui)
  tui_events.rs  # Eventos de teclado (crossterm)
data/
  hf_models.json # Base de modelos
scripts/
  scrape_hf_models.py  # Scraper da API HuggingFace
  update_models.sh     # Atualização automatizada da base

Referências

Repositório: https://github.com/AlexsJones/llmfit
Lista de modelos: https://github.com/AlexsJones/llmfit/blob/main/MODELS.md
Documentação de arquitetura: https://github.com/AlexsJones/llmfit/blob/main/AGENTS.md
Leaderboard comunitário: https://localmaxxing.com
Projeto relacionado (agentes em Kubernetes): https://github.com/sympozium-ai/sympozium
Alternativa (Node.js, benchmark real via Ollama, sem suporte a MoE): https://github.com/Pavelevich/llm-checker

Alisson's Notes

Explorador

LLMFit