Como rodar o Spark-X2.5-4B com 1M de contexto

Se o seu assistente de código local trava ao abrir um repositório grande, o gargalo costuma ser o cache KV. O Spark-X2.5-4B ataca isso com atenção híbrida e chega a um teto de 1.048.576 tokens, mas o orçamento de memória real muda a decisão sobre qual janela usar.

O que é o Spark-X2.5-4B e por que 1M de contexto importa

O Spark-X2.5-4B é um modelo de 4 bilhões de parâmetros com janela de contexto nativa de 1.048.576 tokens, pensado para rodar em hardware de consumidor. Ele não ativa só uma fração dos pesos como um mixture of experts: todos os 4B parâmetros entram em cada token gerado. A questão central de um LLM local com 1M de contexto não é carregar os pesos, mas o que acontece na memória durante a conversa.

Vale separar os dois números do cartão do modelo. O 4B descreve os parâmetros aprendidos, armazenados nos pesos. O 1.048.576 descreve o espaço disponível para a conversa. Tokens são pedaços de texto, então isso não equivale a um milhão de palavras nem a um número fixo de arquivos de código.

O gargalo aparece na leitura. Conforme o modelo processa o prompt, a atenção cria representações do texto anterior que tokens seguintes podem consultar: são as chaves e valores do cache KV, as anotações de trabalho daquela conversa específica. Quanto maior a conversa, maior essa segunda conta de memória.

Atenção híbrida: 27 camadas locais e 9 globais

A atenção híbrida do Spark-X2.5-4B combina 27 camadas de janela deslizante, limitadas a 512 tokens recentes, com 9 camadas de atenção global. A configuração repete três camadas locais e uma global ao longo de 36 camadas, e é isso que segura o crescimento do cache na maior parte da rede.

Numa camada de atenção completa, o token atual pode olhar posições anteriores em todo o contexto disponível. Numa camada local, essa visão direta fica restrita às posições recentes. Quando uma instrução antiga sai da janela de 512 tokens, aquela camada não consegue mais olhar diretamente para a posição original da regra.

Isso não significa que o modelo esquece tudo depois de 512 tokens. A informação circula entre camadas, e as camadas globais mantêm um caminho para o conteúdo distante. O que se descreve aqui é quais posições anteriores cada camada acessa diretamente, não a memória total do modelo.

O design de armazenamento reforça essa economia. O Spark tem 16 cabeças de consulta, mas apenas quatro conjuntos de chaves e valores. Várias cabeças de consulta compartilham as mesmas anotações, o que é grouped query attention: consultas diferentes sem uma cópia separada do histórico de chaves e valores para cada cabeça.

Quanto de RAM o cache KV do Spark-X2.5-4B exige

Na janela cheia de 1.048.576 tokens, com chaves e valores em 16 bits e caches locais limitados, o cache KV do Spark-X2.5-4B fica em cerca de 39 GB. Cada token armazenado consome aproximadamente 4,1 kilobytes por camada de atenção, somando chave e valor. As nove camadas globais respondem por quase todo esse armazenamento.

Essa é uma estimativa calculada a partir da configuração publicada, não uma medição feita em um notebook. O número exclui os pesos do modelo, buffers temporários de processamento e o software que os executa. Para comparar, as mesmas dimensões com as 36 camadas mantendo histórico completo dariam cerca de 155 GB.

O ganho fica evidente quando você escolhe uma janela menor, e a conta muda de escala:

• 32.768 tokens: cerca de 1,3 GB de cache em 16 bits.
• 131.000 tokens: cerca de 4,9 GB de cache em 16 bits.
• Parte local: praticamente estável depois que a janela de 512 tokens enche.
• Parte global: cresce junto com a conversa.

Duas ressalvas práticas. Estratégias de alocação variam entre runtimes, e conversas simultâneas multiplicam o consumo. O cálculo serve como orçamento inicial, não como promessa de que uma placa específica comporta a carga inteira.

A compressão de pesos é uma decisão separada. O download GGUF em precisão total tem cerca de 8,2 GB, o arquivo de 8 bits fica em torno de 4,4 GB e o de 4 bits em torno de 2,6 GB. São tamanhos de arquivo: escolher o menor não encolhe automaticamente um cache de conversa em 16 bits.

Benchmarks publicados: onde o Spark ganha e onde perde

Os números divulgados pelo desenvolvedor do Spark-X2.5-4B mostram força em codificação e uso de ferramentas, mas não um domínio universal. São avaliações publicadas em modo de raciocínio, com algumas pontuações de concorrentes retiradas de outros cartões ou artigos. Não são resultados reproduzidos de forma independente para cada download comprimido.

Veja a comparação entre o Spark e o Qwen 3.5 4B nos testes citados:

Benchmark	Spark-X2.5-4B	Qwen 3.5 4B	Qwen 9B
SWE-bench Pro	44,4	29,4	—
SWE-bench Verified	41,6	—	53,1
GPQA	67,4	—	77,2

A linha de SWE-bench Verified inverte o sinal: o Spark fica atrás do Qwen 9B. Os outros títulos divulgados são 40,9 no BrowseComp, 54,6 no MCP-Atlas e 90,7 no AIME 2026. Cada um cobre um trabalho diferente, de navegação e tarefas com ferramentas até matemática de competição.

O quadro menos favorável também importa. Em GPQA, benchmark de conhecimento, o Spark marca 67,4 contra 77,2 do Qwen 9B. Em instruções, o Spark lidera os modelos Qwen listados no IFEval e no IFBench, mas perde para o Gemma 4 12B. A conclusão sensata depende da tarefa e do modelo de comparação.

Suporte de runtime: llama.cpp, MLX e o aviso sobre 4 bits

O suporte de runtime do Spark-X2.5-4B deixou de exigir builds personalizados. O cartão atual do modelo lista versões mínimas para runtimes locais, e as notas de versão do llama.cpp confirmam a inclusão do suporte. Um guia verifica se o runtime instalado reconhece o Spark antes de tratar o comando anunciado como setup testado.

As opções de download já vão além de um arquivo em precisão total. Há GGUF oficiais, um checkpoint INT8 oficial, quantizações GGUF da comunidade, conversões MLX de 4 e 8 bits e uma exportação ONNX. São pacotes diferentes para caminhos de execução diferentes, e o nome do arquivo informa como os pesos estão guardados, não se o seu aplicativo entende a arquitetura.

A rota MLX merece atenção própria. Os cartões da conversão apontam para o runtime dedicado do Spark em vez da biblioteca padrão. Esse projeto também documenta o carregamento dos checkpoints originais em Apple silicon ou Linux com o processador ou hardware gráfico suportado. As duas rotas são documentadas, mas as instruções de instalação não são intercambiáveis.

Para agentes, a orientação do runtime é direta: use pesos em 8 bits ou precisão total para chamada de ferramentas, porque pesos de 4 bits podem reduzir a precisão de argumentos estruturados. É recomendação do mantenedor, não um teste de qualidade de cada conversão. Se o modelo só cabe quebrando os argumentos que o seu fluxo precisa, a memória economizada não comprou um agente funcional.

A licença é Apache 2.0, e o cartão anuncia mais de 200 idiomas. Cobertura ampla de idiomas não garante qualidade igual em todos eles. Inclua comentários do seu repositório ou documentos de suporte no teste se um benchmark em inglês não representa esse trabalho.

Como testar o Spark-X2.5-4B no seu próprio repositório

O teste útil começa com um repositório cujo comportamento esperado você conhece bem. Coloque uma instrução relevante no início do material e peça uma mudança que dependa dela. Depois inspecione o patch e rode os testes.

1. Escolha um repositório com resultado previsível e uma regra clara que possa ser colocada no início do contexto.
2. Peça uma alteração que só faça sentido se o modelo usar essa regra antiga.
3. Inspecione o patch, rode a suíte de testes e registre memória e tempo até a primeira resposta.
4. Repita em algumas janelas de contexto diferentes, incluindo 32k e 128k.
5. Em agentes, valide também os argumentos das ferramentas, não só o texto final.

Esse é um roteiro de avaliação, não um resultado divulgado. Anote o tempo até a primeira resposta junto com a memória: reduzir o número de camadas globais não elimina o trabalho de atenção de longo alcance. Cabe um milhão de tokens no papel não estabelece que processá-los pareça interativo na prática.

Antes de investir na janela cheia, compare processar o contexto inteiro com selecionar primeiro os arquivos relevantes. Uma janela maior remove parte do trabalho de empacotamento, mas não remove a necessidade de conferir se o modelo usou a evidência certa.

Perguntas frequentes sobre o Spark-X2.5-4B

• O Spark-X2.5-4B roda com 1M de tokens em um PC comum? Em teoria sim, mas o cache KV na janela cheia em 16 bits fica em cerca de 39 GB, sem contar pesos e buffers. Na prática, 32k (cerca de 1,3 GB) e 128k (cerca de 4,9 GB) são as faixas realistas para estações de trabalho locais.

• O que é atenção híbrida e por que ela reduz a memória? É a combinação de 27 camadas de janela deslizante de 512 tokens com 9 camadas de atenção global em 36 camadas totais. Um runtime que gerencia as janelas corretamente mantém os caches locais limitados, enquanto as camadas globais preservam o alcance longo e continuam crescendo.

• Quantizar os pesos em 4 bits também reduz o cache KV? Não automaticamente. O arquivo de 4 bits tem cerca de 2,6 GB, mas o cache de conversa em 16 bits segue o mesmo. O mantenedor recomenda 8 bits ou precisão total para chamada de ferramentas, porque 4 bits pode prejudicar argumentos estruturados.

• O Spark-X2.5-4B é melhor que o Qwen em programação? Depende do teste. Ele marca 44,4 no SWE-bench Pro contra 29,4 do Qwen 3.5 4B, mas fica em 41,6 no SWE-bench Verified contra 53,1 do Qwen 9B. Nenhum resultado cobre a categoria inteira.

• Quais runtimes já suportam o Spark-X2.5-4B nativamente? As notas de versão do llama.cpp confirmam a inclusão do suporte, e o cartão do modelo lista versões mínimas para outros runtimes locais. A conversão MLX aponta para o runtime dedicado do Spark, com instruções de instalação próprias.

Source video