GLM 5.1 em execução local: a alternativa open-weight a conhecer

#Por que usar o GLM 5.1 localmente

Três razões concretas levam você a testar o GLM 5.1 em vez de um Qwen 3.5 ou um Gemma 4 equivalente. Primeiro, sua licença permissiva: a versão de pesos abertos (disponível em 9B e 32B) permite uso comercial, o que não é nada óbvio no ecossistema open-source. Em seguida, a chamada nativa de ferramentas: o GLM 5.1 foi treinado desde o início para chamar ferramentas, o que o torna especialmente adequado para agentes locais sem precisar improvisar com prompts.

Por fim, a relação qualidade/tamanho: o 9B alcança o nível de um Gemma 4 12B em vários benchmarks de código e raciocínio, tornando-se uma escolha interessante se você estiver limitado a 12 GB de VRAM. O 32B visa um nível mais alto e compete com modelos de 24 a 35B como Qwen 3.8 27B ou Mistral Small 24B.

#O que caracteriza o GLM 5.1

GLM 5.1 mantém a arquitetura Transformer densa das versões anteriores — sem Mixture-of-Experts aqui, ao contrário de Qwen 3.6 35B-A3B ou DeepSeek V4. Essa escolha simplifica a inferência e garante que a taxa de geração não despenque em perguntas que acionam especialistas pouco usuais.

Tamanhos

9B e 32B com pesos abertos. Existe uma versão 100B+, mas ela continua acessível apenas pela API da Zhipu e não está disponível para download.

Contexto

128k tokens nos dois tamanhos, com extensão para 1M via escalonamento YaRN no modelo 32B (com degradação acima de 200k).

Tokenizer

Tokenizer bilíngue chinês/inglês otimizado, com cobertura razoável do francês. Prever aproximadamente 5% mais tokens do que com um Mistral para um texto equivalente em francês.

Tool calling

Formato nativo compatível com o esquema tools da OpenAI. Não é necessária engenharia de prompt para acioná-lo; o modelo sabe quando chamar uma função.

Licença

Licença GLM (variante da Apache 2.0 com cláusula de atribuição). Uso comercial autorizado, redistribuição sob os mesmos termos.

Multimodal

Somente texto no 9B e 32B de pesos abertos. A versão com visão (GLM-V) é um modelo separado, que deve ser baixado à parte.

#Pré-requisitos

Ollama ≥ 0.5

Para a versão do Ollama. As builds mais antigas não reconhecem o template de chat do GLM 5.1.

llama.cpp recente

Build de 2026 ou posterior. O suporte à arquitetura GLM foi estabilizado no fim de 2025.

Espaço em disco

6 GB para o 9B Q4, 19 GB para o 32B Q4. Duplique para Q8, quadruplicate para FP16.

VRAM mínima

8 GB para o 9B Q4, 24 GB para o 32B Q4. Com menos VRAM, parte do processamento passa para a CPU e a taxa de geração cai para 3-5 tok/s.

Driver da GPU atualizado

CUDA 12.x para NVIDIA, ROCm 6.x para AMD, Metal nativo para Apple Silicon.

#1. Instalação com Ollama

Ollama é o caminho mais curto. O modelo é disponibilizado com o nome glm5.1 na biblioteca oficial, com as tags habituais por tamanho e quantização.

ollama run glm5.1:9b

Para o 32B, o procedimento é o mesmo, mas conte com vários minutos de download e pelo menos 24 GB de VRAM ou de memória unificada.

ollama pull glm5.1:9b           # alias de 9b-instruct-q4_K_M
ollama pull glm5.1:9b-q8_0      # qualité supérieure, +60% VRAM
ollama pull glm5.1:32b          # 32B Q4 par défaut
ollama pull glm5.1:32b-q5_K_M   # le sweet spot 32B sur 24 Go

Depois de baixar o modelo, o endpoint do Ollama compatível com OpenAI escuta por padrão em http://localhost:11434, e glm5.1 responde como qualquer modelo servido pelo Ollama.

#2. Instalação com llama.cpp

Com llama.cpp, você baixa um GGUF do Hugging Face e o executa pela CLI ou pelo servidor HTTP. Essa é a opção preferível se você quiser ajustar com precisão o cache KV e o modelo auxiliar (draft model) para decodificação especulativa, ou se estiver usando várias GPUs.

# 9B en Q4_K_M (recommandé)
wget https://huggingface.co/zhipuai/glm-5.1-9b-chat-gguf/resolve/main/glm-5.1-9b-chat-Q4_K_M.gguf

# 32B en Q4_K_M
wget https://huggingface.co/zhipuai/glm-5.1-32b-chat-gguf/resolve/main/glm-5.1-32b-chat-Q4_K_M.gguf

./llama-server \
  -m glm-5.1-9b-chat-Q4_K_M.gguf \
  -c 16384 \
  -ngl 99 \
  -fa \
  --host 0.0.0.0 --port 8080

-c 16384

Janela de contexto. 16k é um bom valor padrão para francês/código; aumente para 32k ou mais se tiver VRAM suficiente.

-ngl 99

Tudo na GPU. Defina um valor mais baixo para transferir camadas para a CPU se ultrapassar a capacidade da GPU.

-fa

Flash Attention. Essencial acima de 8k para evitar que o consumo de memória KV dispare.

--host 0.0.0.0

Expõe o servidor na rede. Use 127.0.0.1 se você quiser restringi-lo à máquina local.

#3. VRAM por quantização

Os números abaixo contabilizam os pesos + um KV-cache para 8k de contexto. Para chegar a 32k ou 128k, adicione de 2 a 8 GB, conforme o tamanho.

GLM 5.1 9B — Q4_K_M

≈ 6 GB de VRAM. Cabe na GTX 1660 de 6 GB com pouca margem e roda com folga na RTX 3050/3060/4060 de 8 GB.

GLM 5.1 9B — Q5_K_M

≈ 7 GB de VRAM. Relevante a partir de 8 GB, com alguma margem.

GLM 5.1 9B — Q8_0

≈ 10 GB de VRAM. Alvo: RTX 3060 12 GB, 4070 12 GB ou Mac com 16 GB+.

GLM 5.1 32B — Q4_K_M

≈ 19 GB de VRAM. Sweet spot: RTX 3090, 4090, 5090, RX 7900 XTX, Mac Studio.

GLM 5.1 32B — Q5_K_M

≈ 23 GB de VRAM. Perto do limite dos 24 GB; buscar um Mac com 48 GB ou mais ou uma configuração multi-GPU para ter folga.

GLM 5.1 32B — Q8_0

≈ 34 GB de VRAM. Reservado para a RTX 5090 32 GB, para os Mac Studio Ultra ou para múltiplas GPUs (2× 3090, 2× 4090).

#4. Qualidade em francês e em código

O GLM 5.1 é treinado principalmente com conteúdo em chinês e inglês, mas se sai razoavelmente bem em francês — não no nível de um Mistral nativo, mas acima de um Gemma 4 12B na mesma faixa de tamanho. Os erros típicos envolvem expressões idiomáticas e alguns casos raros de concordância; nada que prejudique o uso como assistente geral ou em RAG.

Francês — 9B

Sólido para resumo, tradução, RAG em documentos em francês. Alguns anglicismos pontuais. Preferir uma temperatura baixa (0,2-0,4) para minimizar os desvios.

Francês — 32B

Muito bem escrito. No mesmo nível do Mistral Small 24B em qualidade de escrita, ligeiramente abaixo dos grandes modelos proprietários.

Código — 9B

Excelente para seu tamanho. Geração de código de qualidade em Python, JS, Go e Rust. Supera um Granite 4.2 8B generalista e compete bem com Qwen 3.5 9B em código.

Código — 32B

Muito bom desempenho. Em HumanEval, MBPP e MultiPL-E, está no grupo de ponta dos modelos open-weight. Bom em refatoração de múltiplos arquivos graças ao contexto de 128k.

Raciocínio

Cadeia de pensamento explícita, se solicitada, sem um token especial <think> como no DeepSeek R1. O modelo de 32B tem desempenho sólido em AIME, GPQA e MATH.

Tool calling

Formato nativo compatível com as ferramentas da OpenAI. O modelo decide por conta própria chamar uma função e formata os argumentos JSON sem erros.

#5. GLM 5.1 vs Qwen 3.5 e Gemma 4

Três famílias open-weight ocupam a mesma classe de tamanho em 2026: GLM 5.1, Qwen (3.5 9B / 3.8 27B) e Gemma 4 (12B / 26B-A4B). A tabela honesta:

Velocidade pura (tok/s)

Com o mesmo tamanho de modelo e a mesma quantidade de VRAM, o GLM 5.1 está na mesma faixa que o Qwen 3.5 denso e o Gemma 4. Não há diferença significativa — a velocidade depende principalmente do backend (Ollama vs llama.cpp vs vLLM) e da GPU.

Qualidade em francês

Mistral Small 24B nativo > Qwen 3.5 ≈ GLM 5.1 > Gemma 4 com tamanho equivalente. Se o francês for crucial, Mistral continua à frente; GLM 5.1 é uma sólida segunda opção aberta.

Código

Qwen3-Coder 30B / Devstral 24B > GLM 5.1 ≈ Qwen 3.8 generalista > Gemma 4 com o mesmo tamanho. GLM 5.1 32B é competitivo em relação a Qwen 3.8 27B, ligeiramente atrás dos modelos especializados em código.

Tool calling

GLM 5.1 ≈ Qwen 3.5 > Gemma 4. Os dois primeiros foram treinados explicitamente para usar ferramentas; o Gemma exige um pouco mais de engenharia de prompt.

Contexto longo

Qwen 3.5 256k nativo (Qwen 3.8 27B: 262k) > GLM 5.1 128k (1M via YaRN) > Gemma 4 128k. Para analisar uma base de código inteira, o Qwen continua à frente.

Licença

GLM (licença semelhante à Apache) ≈ Qwen (Apache 2.0 na maioria das variantes) ≈ Gemma 4 (Apache 2.0 desde abril de 2026). Três licenças simples para uso empresarial, já que o Gemma abandonou sua cláusula personalizada.

Ecossistema

Qwen > Gemma 4 > GLM 5.1. O Qwen agora tem o maior número de fine-tunes da comunidade, o Gemma 4 vem logo atrás, e o GLM 5.1 continua menos difundido — menos variantes, menos tutoriais em francês.

#Dicas e armadilhas

System prompt curto

O GLM 5.1 segue bem os prompts de sistema, mas fica um pouco sobrecarregado se você usar 800 palavras. Procure usar de 200 a 400 palavras, com um texto claro e estruturado.

Temperatura baixa para o francês

0,2 a 0,4 para minimizar anglicismos e problemas de concordância. Acima de 0,7, a qualidade da escrita em francês começa a oscilar.

Tokens de parada

O modelo utiliza <|endoftext|> e <|user|> como delimitadores. Se você desenvolver seu próprio cliente, adicione essas duas strings aos tokens de parada para evitar que ele continue falando sozinho.

Streaming via Ollama

Os endpoints /api/chat e /v1/chat/completions suportam stream=true. Nenhuma peculiaridade específica no GLM 5.1, ao contrário de alguns modelos MoE.

Fine-tuning LoRA

O GLM 5.1 9B é viável em LoRA em uma RTX 4090 de 24 GB com Unsloth. O 32B exige múltiplas GPUs ou um Mac com bastante memória unificada.

Modelfile Ollama

Para fixar um prompt de sistema e parâmetros, crie um Modelfile baseado em glm5.1:9b e depois execute ollama create monassistant -f Modelfile. O modelo derivado aparece em ollama list como qualquer outro.

#Para se aprofundar

O GLM 5.1 está funcionando, e você já tem seus primeiros resultados. Algumas ideias para avançar:

Escolher sua quantização (Q4, Q5, Q8, FP16)

Para decidir com precisão o compromisso entre qualidade e VRAM nos seus casos de uso.

Qwen3.6 35B-A3B localmente: teste e requisitos de VRAM

O concorrente direto da família Qwen, com arquitetura MoE. Comparativo útil se você estiver em dúvida.

Open WebUI com Ollama: guia completo

Uma interface semelhante à do ChatGPT sobre o GLM 5.1: conversas, RAG, suporte a múltiplos usuários.

Criar um agente de IA local em Python com LangChain e Ollama

Para usar o recurso nativo de chamada de ferramentas do GLM 5.1 e fazer com que ele chame suas próprias funções.