llmfit - ferramenta de terminal que encontra e otimiza automaticamente o modelo LLM ideal para o seu hardware

• Ferramenta que, entre centenas de modelos e provedores de LLM, encontra com um único comando os modelos que realmente podem rodar na RAM, CPU e GPU do seu sistema
• Pontua cada modelo por qualidade, velocidade, adequação e contexto, indicando se ele é executável, com suporte tanto a TUI (interface de terminal) quanto a modo CLI
• Suporta múltiplas GPUs, arquitetura MoE, quantização dinâmica, estimativa de velocidade e integração com runtimes locais (Ollama, llama.cpp, MLX)
• Analisa, para cada modelo, os modos de execução (GPU, CPU+GPU, CPU) e os níveis de adequação (Perfect, Good, Marginal, Too Tight) para sugerir a melhor combinação
• Oferece automação da escolha de modelos com base no hardware para desenvolvedores que querem usar LLMs com eficiência em ambiente local

---

Visão geral dos principais recursos

• llmfit é uma ferramenta de terminal que detecta as especificações de hardware do sistema e avalia se um modelo LLM pode realmente ser executado
  • Lê informações de RAM, CPU e GPU para calcular, por modelo, pontuações de qualidade, velocidade, adequação e contexto
  • Os resultados são exibidos em uma TUI interativa ou em formato CLI tradicional
• Suporte a múltiplas GPUs, Mixture-of-Experts (MoE), seleção dinâmica de quantização, estimativa de velocidade e integração com runtimes locais
• Suporta Ollama, llama.cpp e MLX como runtimes locais, com detecção automática de modelos instalados e possibilidade de download
• Com o modo Plan, é possível calcular de forma inversa o hardware mínimo e o recomendado para um modelo específico
• Funciona em diversas plataformas, incluindo macOS, Linux, Windows e Ascend

Instalação e execução

• No macOS/Linux, pode ser instalado com brew install llmfit ou curl -fsSL https://llmfit.axjns.dev/install.sh | sh
• No Windows, a instalação pode ser feita com cargo install llmfit
• Ao executar o comando llmfit, a TUI é aberta exibindo as especificações do sistema e a lista de modelos
• No modo CLI, são oferecidos vários subcomandos, como llmfit --cli, llmfit fit --perfect -n 5 e llmfit recommend --json

Como funciona

• Detecção de hardware: coleta informações de RAM, CPU e GPU usando sysinfo, nvidia-smi, rocm-smi, system_profiler etc.
• Banco de dados de modelos: obtém centenas de modelos via API do HuggingFace e os armazena em data/hf_models.json
  • Inclui modelos importantes como Meta Llama, Mistral, Qwen, Google Gemma, Microsoft Phi, DeepSeek e IBM Granite
• Quantização dinâmica: percorre níveis de Q8_0 a Q2_K e seleciona automaticamente a quantização de maior qualidade dentro da memória disponível
• Estimativa de velocidade: usa a fórmula baseada na largura de banda da memória da GPU (bandwidth_GB_s / model_size_GB) × 0.55
  • Inclui uma tabela interna de largura de banda para cerca de 80 GPUs
• Análise de adequação: avalia a possibilidade de execução e a margem de memória nos modos GPU, CPU+GPU e CPU

Interface do usuário

• Teclas de controle da TUI:
  • f para filtro de adequação, a para filtro de disponibilidade, s para alterar o critério de ordenação
  • p para entrar no modo Plan, d para baixar modelo, t para mudar o tema
• No modo Plan, é possível ajustar comprimento de contexto, quantização, velocidade-alvo de tokens etc. para calcular VRAM/RAM/CPU necessários
• Temas: oferece 6 temas de cores integrados, incluindo Default, Dracula, Solarized, Nord, Monokai e Gruvbox

Runtime e recursos de integração

• Integração com Ollama: conecta-se a instâncias locais ou remotas do Ollama (variável de ambiente OLLAMA_HOST) para detectar modelos instalados e fazer downloads
• Integração com llama.cpp: baixa arquivos GGUF do HuggingFace para o cache local e indica se estão instalados
• Integração com MLX: suporte a cache de modelos e integração com servidor para Apple Silicon
• Integração com OpenClaw: por meio da skill llmfit-advisor, o agente OpenClaw recomenda e configura automaticamente modelos adequados ao hardware

Gerenciamento do banco de dados de modelos

• O script scripts/scrape_hf_models.py gera automaticamente a lista de modelos a partir da API do HuggingFace
• O comando make update-models atualiza os dados e recompila o binário
• Os modelos são classificados em categorias como geral, coding, reasoning, multimodal, chat e embedding
• O cache de fontes GGUF (data/gguf_sources_cache.json) armazena em cache por 7 dias os caminhos de download

Suporte de plataforma

• Linux/macOS (Apple Silicon): suporte completo
• Windows: suporte a detecção de RAM/CPU e GPU NVIDIA (nvidia-smi)
• Em caso de falha na detecção de GPU, é possível definir manualmente a VRAM com a opção --memory=

Licença

• Licença MIT

[GN⁺]

Comentários no Hacker News

• Este projeto parece bem legal e útil, mas eu preferiria que fosse um site
  Fico receoso de rodar um executável. Acho que esse tipo de funcionalidade daria para implementar tranquilamente na web

  • Esta ferramenta depende de detecção de hardware, então há limitações na web
    Segundo a explicação no GitHub, ela precisa ler em nível de sistema a quantidade de RAM, número de GPUs e o tipo de backend (CUDA, Metal etc.)
    Por causa das restrições de sandbox do navegador, o JavaScript não consegue acessar diretamente esse tipo de informação
    Para criar uma versão web, seria preciso que o usuário enviasse um relatório do .spx no macOS ou do inxi no Linux, ou então selecionasse manualmente a configuração de hardware
    Essa abordagem é menos conveniente, mas tem a vantagem de permitir testar combinações de hardware hipotéticas
  • O Hugging Face também oferece algo parecido, mas exige inserir manualmente as informações de hardware
    Na verdade, acho raro que alguém rodando modelos locais não saiba qual hardware tem
  • Vi recentemente um site chamado whatmodelscanirun.com, pode servir de referência
  • O Hugging Face também já tem uma funcionalidade embutida
  • Também existe o site de banco de dados de modelos LLM baseado na comunidade inferbench.com. Ele compartilha velocidade em tokens e informações de configuração

• Este projeto é realmente excelente
  Na prática, tudo de que se precisa é do tamanho do LLM e da largura de banda da memória
  Dá para determinar se o modelo cabe com uma fórmula simples
  Por exemplo, para rodar um modelo 32B em 4bit, são necessários pelo menos 16GB de VRAM
  Se calcular com tok/s = memory_bandwidth / llm_size, uma RTX3090 (960GB/s) dá algo em torno de 60 tok/s
  Em modelos MoE, o número de parâmetros ativos é o que determina a velocidade
  Se acrescentar uma margem de uns 10%, vira uma estimativa realista

  • O cache KV é fácil de fazer swap porque há poucas gravações por token
    Se você carregar os parâmetros do modelo com mmap, dá para escalar sem perda de desempenho quando há RAM suficiente
  • É uma boa regra prática. Mas, na maioria dos casos, conforme o tamanho da janela de contexto aumenta, o uso de RAM cresce exponencialmente
  • Eu não conhecia essa fórmula, obrigado por compartilhar

• Visualmente é legal, mas no meu computador o Qwen 3.5 roda bem e a ferramenta diz que não é possível
  No fim, parece que esse tipo de ferramenta só dá para usar como referência aproximada
  Se aplicar ajustes customizados como os do Unsloth, na prática dá para rodar ainda mais modelos
  Os modelos estão saindo rápido demais, então imagino que também não seja fácil fazer a manutenção

  • Talvez esteja acontecendo swap entre disco e RAM
    Esse tipo de abordagem pode reduzir a vida útil do disco no longo prazo

• A ideia é boa, mas os modelos recomendados estão meio desatualizados
  Ele recomenda Qwen 2.5 ou Starcoder 2 para o meu M4 MacBook Pro (128GB RAM)

• Como várias pessoas já disseram, isso seria melhor como site do que como ferramenta CLI
  Basta colocar CPU, RAM e especificações da GPU em um formulário para fazer o cálculo

• Não entendo por que precisa baixar e executar isso
  Seria melhor apenas selecionar as especificações em menus suspensos e ver o resultado

• Cobre bem a maioria dos casos, mas em situações como iGPU da AMD, onde ROCm não é compatível, ainda dá para rodar com base em Vulkan
  Com configurações de driver para usar a RAM do sistema como se fosse VRAM, dá para carregar modelos que normalmente seriam impossíveis
  Isso é especialmente útil para offload de camadas ou modelos MoE quantizados

• O Claude também faz recomendações bem razoáveis de modelos se você inserir as especificações do sistema

  • Eu também perguntei ao Claude “qual é o melhor LLM local que posso rodar neste computador?”, e ele recomendou o modelo que eu já tinha instalado mais outro
    Não tenho certeza se a informação estava atualizada. Testei com base em Ollama e LM Studio

• Eu costumo pedir ao Claude ou ao Codex para testar vários modelos em sequência com Ollama e avaliar o desempenho automaticamente
  Em uns 30 minutos dá para encontrar um modelo adequado ao meu sistema

  • Fiquei curioso para saber se você poderia compartilhar esse prompt