MTP no LM Studio: ativar Multi-Token Prediction

#Por que o MTP acelera a inferência

A inferência de um LLM é limitada pela memória: a cada token gerado, é necessário reler todos os pesos do modelo a partir da VRAM. Em um modelo de 32B em Q4, cerca de 19 GB são transferidos a cada passo. Mesmo com uma RTX 4090, a largura de banda máxima é de cerca de 1 TB/s, o que limita mecanicamente a taxa a algumas dezenas de tokens por segundo.

O MTP contorna essa barreira de forma simples: gerar vários tokens por passagem forward, em vez de apenas um. Se for possível produzir 2 ou 3 tokens válidos com uma única ida e volta à memória, a taxa de geração aumenta na mesma proporção — sem precisar comprar uma placa mais rápida. Isso diferencia o MTP das demais “otimizações” que apenas aproveitam melhor o processamento (Flash Attention, prefix caching): aqui, atacamos diretamente a restrição dominante.

#O que o MTP realmente faz

Concretamente, um modelo treinado com MTP não tem apenas uma cabeça de previsão. Ele tem duas, três ou quatro, em cascata: a primeira prevê o token N+1, a segunda tenta prever o token N+2, etc. Durante o treinamento, essas cabeças auxiliares aprendem a prever os tokens seguintes a partir dos estados ocultos intermediários. Após o treinamento, o modelo pode utilizar essas cabeças na inferência para gerar vários candidatos de uma só vez.

Durante a geração, dois esquemas coexistem nos runtimes atuais:

MTP em speculative decoding

As cabeças auxiliares produzem um rascunho de 2-4 tokens, e então o modelo principal verifica em um único forward se os valida. Todo token rejeitado é regenerado. Essa é a implementação padrão no llama.cpp para DeepSeek V3.

MTP como modelo de rascunho interno

Variante em que as cabeças secundárias servem apenas como um pequeno modelo de rascunho, e o runtime trata isso como um modelo de rascunho padrão, mas hospedado no mesmo arquivo GGUF. Mais simples de servir, mas com ganho mais modesto.

#Quais modelos realmente são compatíveis com MTP

O MTP não é uma configuração que se pode ativar em qualquer modelo: é necessário que o modelo tenha sido treinado com as cabeças MTP e que os pesos correspondentes estejam presentes no arquivo GGUF. Atualmente, a lista útil para uso local no LM Studio é curta:

DeepSeek V3 (base e chat)

O pioneiro. Arquitetura MoE de 671B com 4 cabeças MTP. Para uso local, buscam-se variantes com quantização agressiva (Q2_K_XL, IQ3_XS) ou modelos destilados.

DeepSeek V3.1 / V3.2 / V4 Flash

Toda a linha DeepSeek herdou o MTP. As versões Flash (≈300B MoE) são as únicas que realmente cabem em um Mac Studio Ultra ou em uma configuração multi-GPU com 80 a 100 GB de VRAM.

Qwen3 MoE (seleção de variantes)

Várias variantes Qwen3 MoE têm pesos GGUF publicados com cabeças MTP. Verifique a página do modelo no Hugging Face: a presença de um campo «mtp_layers» ou de um sufixo -mtp no nome é um bom indicador.

Modelos densos clássicos (Gemma 4, Mistral Small, Qwen 3.5)

Sem MTP nativo. O LM Studio não fará nada de especial. Para esses modelos, o único equivalente disponível é a decodificação especulativa clássica com um modelo de rascunho separado.

#Pré-requisitos no LM Studio

LM Studio recente

Versão 0.3.10 ou superior. As versões mais antigas usam um runtime llama.cpp anterior ao suporte a MTP, e a opção simplesmente não aparece na UI.

Runtime llama.cpp atualizado

O suporte a MTP no llama.cpp chegou no final de 2024 e foi estabilizado ao longo de 2025. O LM Studio inclui várias versões de runtime; é necessário selecionar explicitamente a mais recente na aba Runtimes.

VRAM ou memória unificada suficiente

O MTP adiciona pouca sobrecarga de memória (as cabeças auxiliares são pequenas), mas ainda é necessário carregar o modelo inteiro. Considere a VRAM padrão para o tamanho desejado, mais 5 a 10% para o cache KV estendido usado durante a verificação.

GPU detectada corretamente

O ganho com MTP só aparece se a inferência for limitada pela GPU. No modo somente CPU, o benefício existe, mas é muito pequeno e, às vezes, negativo em modelos pequenos.

#1. Ativar o runtime atualizado

Antes de mexer no modelo, verifique se o LM Studio usa uma versão do llama.cpp que ofereça suporte ao MTP. Essa é a etapa mais esquecida.

1. 01
   Abrir as configurações de Runtimes

   No LM Studio, clique no ícone de engrenagem (Settings) e depois acesse a seção “Runtimes” (ou “LM Runtimes”, dependendo da versão). Lá você verá os runtimes instalados: CUDA, Metal, Vulkan, CPU.
2. 02
   Instalar a versão mais recente

   Clique em « Check for updates » ao lado do runtime da sua plataforma. O LM Studio baixa uma versão recente do llama.cpp embutido. O suporte MTP está presente em todas as builds a partir de 2025.
3. 03
   Verificar a versão ativa

   Na mesma seção, a versão usada atualmente é exibida (por exemplo, « llama.cpp v0.3.x — CUDA »). Confirme que ela é posterior a novembro de 2024. Se vários runtimes coexistirem, selecione o mais recente como padrão.

#2. Carregar um modelo com cabeça MTP

Baixe um modelo compatível com MTP pela aba de pesquisa integrada. Digite “DeepSeek V3” ou “Qwen3 MoE” e filtre pelas builds GGUF recentes que mencionem MTP. Se não encontrar, acesse diretamente o Hugging Face e arraste o arquivo GGUF para a pasta de modelos do LM Studio.

# Linux / macOS
~/.lmstudio/models/

# Windows
%USERPROFILE%\.lmstudio\models\

Quando o modelo estiver visível na biblioteca, carregue-o normalmente pela aba Chat ou pela aba Local Server. Antes de clicar em « Load », abra o painel « Advanced Configuration »: é ali que as opções MTP aparecem quando o modelo as declara.

#3. Ajustar os parâmetros MTP

A seção Advanced Configuration geralmente apresenta três parâmetros relacionados ao MTP. Os nomes variam conforme a versão do LM Studio, mas o princípio permanece o mesmo.

Enable MTP (ou Use MTP heads)

Interruptor principal. Ativar. Quando ele está desativado, o modelo ignora suas cabeças auxiliares e se comporta como um modelo clássico.

MTP draft tokens (n_draft)

Número de tokens propostos por passagem. Valor típico: 3 ou 4. Acima disso, a taxa de aceitação cai e o ganho desaparece. Abaixo (1-2), o custo de verificação se torna comparável ao ganho.

MTP acceptance threshold

Limiar de confiança para aceitar um token proposto. Por padrão, geralmente em torno de 0,7. Mais alto = mais segurança, mas menos ganho. Mais baixo = mais rápido, mas a qualidade da saída pode se desviar sutilmente.

{
  "mtp": {
    "enabled": true,
    "n_draft": 3,
    "acceptance_threshold": 0.7
  },
  "gpu_layers": -1,
  "context_length": 8192
}

#4. Medir o ganho real na sua máquina

Ativar o MTP sem medir é abrir mão de metade do benefício do guia. LM Studio exibe a taxa de transferência na parte inferior do chat (tok/s) após cada geração. O método honesto:

1. 01
   Prepare 3 prompts representativos

   Um prompt de código (muito estruturado, com uma alta taxa de aceitação esperada), um prompt factual em francês, um prompt criativo livre. Salve-os para poder executá-los novamente exatamente da mesma forma.
2. 02
   Desativar MTP, medir a linha de base

   Descarregar o modelo da memória, desativar o MTP e recarregar. Executar cada prompt e anotar a média de tok/s em 3 repetições. Não esquecer de ignorar a primeira execução (prefill não comparável).
3. 03
   Ativar MTP, medir

   Descarregar, reativar MTP, recarregar com exatamente os mesmos parâmetros (contexto, temperatura, etc.). Repetir os mesmos prompts.
4. 04
   Comparar

   Calcular a razão por prompt. É esperado um fator de 1,5 a 2× para código, de 1,3 a 1,7× para textos factuais em francês e de 1,1 a 1,4× para textos criativos. Abaixo de 1,2× em todos os casos, algo está errado (runtime muito antigo, cabeças MTP ausentes ou GPU saturada por outra atividade).

DeepSeek V3 destilado 32B Q4, RTX 4090

Baseline de ~25 tok/s, MTP ativado ~42 tok/s em um prompt de código Python. Em prosa francesa, ~30 tok/s.

DeepSeek V4 Flash no Mac Studio M2 Ultra 192 GB

Baseline ~14 tok/s, MTP ativado ~24 tok/s em código. Em texto livre, ~18 tok/s. O ganho é claro mesmo em Apple Silicon.

Qwen3 MoE 30B-A3B Q4, RTX 4070 Ti

Baseline ~38 tok/s, MTP ativado ~55 tok/s em JSON. Em texto criativo, ganho limitado a ~46 tok/s.

#Configurações avançadas e combinações

O MTP combina bem com outras otimizações disponíveis no LM Studio. Algumas combinações que funcionam:

MTP + Flash Attention

Ativar ao mesmo tempo. Flash Attention reduz o consumo de memória do KV-cache durante a verificação dos rascunhos, o que ajuda quando n_draft é alto.

MTP + Q4_K_M (vs Q8)

O MTP preserva a qualidade mesmo em Q4 agressivo. Não há motivo para subir para Q8 «para compensar» — mantenha Q4_K_M e economize VRAM.

MTP + contexto longo

O KV-cache ocupa mais espaço com MTP (a verificação armazena mais estados intermediários). Em um 32B com contexto de 32k, conte com 1–2 GB adicionais de VRAM.

MTP + processamento em lote (Local Server)

Se você atende a várias requisições simultâneas pelo servidor do LM Studio compatível com OpenAI, o ganho com MTP se soma ao ganho com batching. É aí que se observam as maiores diferenças.

#Solução de problemas

A opção MTP não aparece

Ou o ambiente de execução é antigo demais (verifique a versão em Settings → Runtimes), ou o modelo GGUF não contém as cabeças MTP. Baixe uma variante explicitamente marcada como MTP.

MTP ativado, mas nenhum ganho medido

Verifique se a GPU é realmente o alvo da execução (gpu_layers = -1 ou igual ao total de camadas). Usando apenas a CPU, o MTP às vezes custa mais do que rende. Verifique também se nenhum outro processo está saturando a VRAM.

Saída que deriva ou repetições estranhas

Acceptance threshold muito baixo. Aumente-o para 0,75-0,8. Se o problema persistir, desative o MTP: existem casos patológicos com prompts muito atípicos.

O LM Studio trava ao carregar

Um GGUF mal convertido com cabeças MTP corrompidas pode travar o runtime. Tente outra quantização do mesmo modelo ou um arquivo de outro publisher no Hugging Face.

Ganho visível no chat, mas não pela API

Verifique se o Local Server está usando a mesma configuração do chat — há uma página de configurações separada para o servidor, onde o MTP deve ser reativado de forma independente.

#Para se aprofundar

O MTP é uma das formas de melhorar o desempenho que realmente funcionam na execução local. Algumas dicas complementares para ir além:

Começar com o LM Studio

Se você chegou aqui sem ter instalado o LM Studio, o guia de primeiros passos cobre o básico antes de você mexer nas configurações avançadas.

Transformar LM Studio em servidor de API

Para expor um endpoint compatível com OpenAI e aproveitar o MTP em todos os seus clientes (Continue.dev, Aider, scripts Python).

Plugins LM Studio: quais instalar e como

Além do MTP, o ecossistema de plugins e o SDK lmstudio-js/python abrem outras possibilidades.