llama.cpp: o que é e é preciso deixar de usar o Ollama? ?

#llama.cpp em resumo

O projeto foi lançado em março de 2023 por Georgi Gerganov, com um objetivo simples: rodar o modelo LLaMA da Meta em um MacBook, sem Python nem dependências pesadas. Ele é publicado sob licença MIT. Três anos depois, o repositório (agora sob a organização ggml-org) oferece suporte a centenas de arquiteturas, e o formato de arquivo definido pelo projeto em agosto de 2023, o GGUF, tornou-se o padrão de fato para distribuir um modelo quantizado.

Duas escolhas técnicas explicam esse sucesso. A primeira é a quantização: o llama.cpp sabe executar pesos comprimidos de 2 a 8 bits, o que permite que um modelo de 8 bilhões de parâmetros caiba em 5 GB em vez de 16. A segunda é a divisão entre processador e placa gráfica: quando um modelo não cabe inteiro na VRAM, parte das camadas permanece na RAM e o restante vai para o GPU. Isso é mais lento que um carregamento completo, mas funciona, e poucos motores oferecem essa possibilidade.

#O que está dentro da caixa

llama-cli

O chat na linha de comando. Útil para testar um modelo ou um ajuste em poucos segundos.

llama-server

Um servidor HTTP com API compatível com OpenAI e interface web integrada, na porta 8080. É o componente que a maioria dos usuários avançados mantém em execução continuamente.

llama-bench

O utilitário de medição. Ele fornece separadamente a velocidade de leitura do prompt e a velocidade de geração, permitindo comparar dois ajustes sem se iludir.

llama-quantize

Converte um GGUF em precisão completa para uma quantização mais leve (Q4_K_M, Q5_K_M, Q8_0).

• llama-server: montar uma API OpenAI local, passo a passo
• GGUF e safetensors: entender os formatos dos modelos
• Documentação oficial do formato GGUF — Hugging Face

#O que as camadas extras adicionam e escondem

Ollama, LM Studio e KoboldCpp oferecem o que o llama.cpp não faz: um catálogo de modelos, download com um único comando, interface, carregamento e descarregamento automáticos. Em troca, eles definem valores padrão. A tabela abaixo não compara desempenhos, apenas indica quem decide sobre o que.

A última linha conta mais do que parece. Quando uma nova arquitetura de modelo é lançada, ela é primeiro suportada pelo llama.cpp, depois pelas camadas superiores alguns dias ou semanas depois. Se você quer testar um modelo na semana de seu lançamento, muitas vezes é o único caminho.

#Os quatro ajustes que mudam tudo

-ngl (n-gpu-layers)

O número de camadas do modelo colocadas na VRAM. O valor 99 significa “tudo o que couber”. Se o modelo exceder a capacidade da sua VRAM, reduza esse número até que o carregamento seja concluído com sucesso: cada camada deixada na CPU torna a geração mais lenta, mas um modelo que roda a 8 tokens por segundo é melhor do que um modelo que não inicia.

-c (ctx-size)

A janela de contexto alocada. O cache KV aumenta com ela: em um modelo de 8B, passar de 8.000 para 32.000 tokens custa vários GB de VRAM. Aloque o que você precisa, não o máximo anunciado pelo modelo.

-fa (flash-attn)

Ativa o Flash Attention, que reduz o uso de memória e acelera a leitura de prompts longos. É também um pré-requisito para quantizar o cache KV.

--n-cpu-moe

Para modelos MoE, mantém os especialistas de um determinado número de camadas na RAM e deixa o restante na GPU. É isso que permite rodar um MoE com 30 ou 120 bilhões de parâmetros em uma placa de 16 GB a uma velocidade utilizável.

• Flash Attention: ative no llama.cpp, Ollama e vLLM
• Quantizar o cache KV para economizar VRAM
• Distribuir um modelo em vários GPUs com tensor-split
• Documentação oficial do llama-server (lista completa das opções)

#O que mudou: --fit ajusta -ngl por você

Por muito tempo, ajustar -ngl manualmente foi o primeiro reflexo de qualquer guia do llama.cpp: definir 99 para enviar tudo para a GPU e depois reduzir o valor por tentativa e erro se o carregamento falhasse. Essa etapa já não é obrigatória. O projeto adicionou uma opção --fit, ativada por padrão, que ajusta automaticamente os parâmetros não especificados (incluindo -ngl) para que o modelo caiba na memória disponível. Em uma placa modesta, isso evita a alternância habitual entre uma tentativa de execução que falha e uma redução manual de -ngl.

#Qual backend para a sua placa

llama.cpp é compilado ou baixado para um backend de cálculo específico. A escolha correta depende exclusivamente do seu hardware. A tabela lista as famílias de nossa base de 90 configurações.

• Compilar llama.cpp com CUDA
• Compilar o llama.cpp com Metal no Mac
• llama.cpp com Vulkan, o backend universal

#Nossas medições com llama.cpp

llama.cpp é o motor de referência da nossa bancada de testes, precisamente porque funciona da mesma forma em todas as plataformas. Aqui estão as velocidades de geração registradas com Llama 3.1 8B em Q4, contexto de 2 048 tokens, uma única requisição e Flash Attention ativada.

Duas conclusões. Primeiro, a diferença entre uma RTX 3060 e o uso apenas do processador é de um fator de cinco a seis: mesmo uma placa de entrada muda a experiência. Segundo, esses números seriam praticamente os mesmos no Ollama ou no LM Studio nas mesmas máquinas, já que o motor de cálculo é o mesmo.

• Todas as nossas medições: seis máquinas, seis modelos
• Nossa metodologia de medição

#Continuar usando o Ollama ou passar para o llama.cpp

• Ollama vs llama.cpp: o comparativo completo
• No Mac: MLX ou llama.cpp?

#Iniciar em dez minutos

Nada precisa ser compilado para testar. Binários pré-compilados são publicados para Windows, macOS e Linux a cada versão, e os gerenciadores de pacotes fazem o resto. O comando abaixo baixa um modelo pequeno do Hugging Face e abre a interface web no http://localhost:8080.

# macOS et Linux (Homebrew)
brew install llama.cpp

# Windows
winget install llama.cpp

# Télécharger un modèle et ouvrir l'interface web
llama-server -hf ggml-org/gemma-3-4b-it-GGUF -ngl 99 -c 8192

Para um modelo mais ambicioso do catálogo, baixe o arquivo GGUF de sua escolha e indique esse arquivo com a opção -m. A compilação a partir do código-fonte só se torna útil para ativar um backend específico ou acompanhar o desenvolvimento dia a dia.

• Repositório oficial do llama.cpp no GitHub
• Escolher um modelo no catálogo QuelLLM

#Erros mais comuns de carregamento

A maioria dos problemas com llama.cpp se resume a três causas: o uso de memória excede a capacidade disponível, um arquivo GGUF é incompatível com o build instalado ou uma opção está escrita incorretamente. A mensagem de erro exibida na linha de comando quase sempre indica qual das três é a causa, desde que você a leia até o final em vez de fechá-la e executar novamente.

Vale a pena ler uma vez, por inteiro, a linha de carregamento exibida ao iniciar o servidor: ela indica o número de camadas realmente enviadas à GPU, o tamanho efetivo do contexto e o tipo de cache KV utilizado. Muitas vezes, isso é mais rápido do que adicionar opções ao acaso até funcionar. Fique também de olho na versão instalada: o llama.cpp publica versões noturnas com muita frequência, e às vezes uma correção para sua placa ou seu modelo já foi lançada, mas ainda não chegou ao pacote do Homebrew ou do winget que você instalou na semana anterior.

#FAQ