Dá para rodar o Kimi K3 localmente? Guia de hardware, GGUF e vLLM (2026)
Sim, o Kimi K3 pode rodar localmente porque a Moonshot AI publica seus pesos no Hugging Face, mas ele é um modelo de 2,8 trilhões de parâmetros, então "local" significa cerca de 610 GB de RAM e VRAM combinadas para o menor GGUF de 1 bit, ou um nó Blackwell completo com 8 GPUs para os pesos nativos. Em uma única estação de trabalho com menos memória ele ainda carrega a partir do disco, só que muito devagar. Para a maioria dos desenvolvedores, rodar o K3 em GPUs alugadas ou chamá-lo por uma API sai mais barato do que comprar hardware.
Este guia cobre o que você precisa para rodar o Kimi K3 nas suas próprias máquinas em 24 de outubro de 2026: a licença, os requisitos exatos de memória por quantização, comandos passo a passo de llama.cpp e vLLM, como chamar seu servidor local a partir do código e uma comparação de custos com GPUs alugadas e APIs hospedadas. Os números vêm do model card da Moonshot AI, das receitas oficiais de vLLM e SGLang e da documentação da Unsloth; tudo o que estimamos está identificado como estimativa.
Kimi K3 em resumo
| Especificação | Valor |
|---|---|
| Desenvolvedor | Moonshot AI |
| Pesos | moonshotai/Kimi-K3 no Hugging Face |
| Arquitetura | Mistura de especialistas: 2,8T parâmetros no total, 104B ativos por token |
| Especialistas | 896 especialistas roteados, 16 selecionados por token, mais 2 compartilhados |
| Camadas | 93 (69 camadas de atenção linear KDA e 24 camadas MLA com gate) |
| Janela de contexto | 1.048.576 tokens |
| Entradas | Texto e imagens (codificador de visão MoonViT-V2, 401M parâmetros) |
| Precisão nativa | Pesos MXFP4 com ativações MXFP8 (treinamento com consciência de quantização) |
| Raciocínio | Pensamento sempre ativo; reasoning_effort low, high ou max (padrão max) |
| Licença | Kimi K3 License (MIT modificada) |
Fonte: o model card do Kimi K3, consultado em 24 de outubro de 2026.
Duas observações antes de começar. Primeiro, a Moonshot AI agora oferece o Kimi K3.1 Pro em sua API e chama o K3 de "carro-chefe da geração anterior", mas, em 24 de outubro de 2026, os pesos abertos mais recentes no Hugging Face ainda são os do Kimi K3, então o K3 é o modelo que você consegue rodar por conta própria. Segundo, o K3 funciona apenas no modo de pensamento: seu cliente precisa devolver reasoning_content e as chamadas de ferramentas em conversas de vários turnos, como descreve o model card.
Dá para usar o Kimi K3 comercialmente?
A Kimi K3 License é no estilo MIT, com duas condições extras, segundo o arquivo de licença no Hugging Face (outubro de 2026):
- Se você oferecer o K3 como negócio de modelo como serviço com mais de US$ 20 milhões de receita nos 12 meses anteriores, precisa de um acordo separado com a Moonshot AI.
- Se o seu produto tiver mais de 100 milhões de usuários ativos mensais ou mais de US$ 20 milhões de receita mensal, você deve exibir "Kimi K3" na interface do usuário.
O uso interno dentro da sua empresa não é restringido por essas condições. Para a maioria das startups e equipes, o uso local ou auto-hospedado é permitido; leia o texto completo da licença antes de lançar.
Quanto hardware o Kimi K3 precisa?
Quantizações GGUF (llama.cpp)
A Unsloth publica quantizações GGUF dinâmicas. A regra prática dela: sua RAM mais VRAM deve ser pelo menos do tamanho da quantização; caso contrário, o modelo será descarregado para o disco e rodará muito mais devagar.
| Quantização | Memória necessária (RAM + VRAM) | Observações |
|---|---|---|
1 bit dinâmico S (UD-IQ1_S) |
cerca de 610 GB | 594 GB de arquivos; o equilíbrio entre tamanho e qualidade recomendado pela Unsloth, cerca de 79% de acurácia top-1 |
| 1 bit dinâmico M | cerca de 665 GB | |
| 2 bits dinâmico XXS | cerca de 726 GB | |
| 2 bits dinâmico XL | cerca de 880 GB | A Unsloth relata cerca de 90% de acurácia para seu 2 bits dinâmico de 861 GB |
Q8 (UD-Q8_K_XL, sem perdas) |
cerca de 1,6 TB | 1,56 TB de arquivos; equivale aos pesos nativos MXFP4 |
A Unsloth relata cerca de 20 tokens por segundo de geração quando a quantização de 1 bit cabe em GPUs B200. Em máquinas centradas em CPU que mantêm a maior parte dos pesos na RAM do sistema, espere velocidades bem menores; não as medimos, então trate qualquer número que encontrar como estimativa até testar o seu próprio hardware.
O que isso significa na prática? Algumas configurações locais realistas:
| Configuração | Cabe o de 1 bit (610 GB)? | Expectativa (estimativa) |
|---|---|---|
| PC gamer: 1x RTX 4090 (24 GB) + 128 GB de RAM | Não | Só roda com muito descarregamento em disco; muito lento, útil apenas para testes |
| Estação de trabalho ou servidor: 1-2 GPUs + 768 GB DDR5 | Sim | Utilizável para experimentos de um único usuário em baixa velocidade |
| Servidor multi-GPU com 8x GPUs de 80-141 GB | Sim, na VRAM | Velocidade interativa para um ou poucos usuários |
| Nó 8x B300 / classe GB300 | Pesos nativos MXFP4 | Serviço em produção com vLLM ou SGLang |
Pesos nativos (vLLM e SGLang)
Para os pesos oficiais, a receita do vLLM para o Kimi K3 exige pelo menos 8x GPUs GB300 (ou pelo menos 8x MI355X ou MI350X no AMD ROCm), usando a imagem vllm/vllm-openai:kimi-k3, que requer CUDA 13 e driver NVIDIA r580 ou posterior. O cookbook do SGLang lista formatos de nó como B300 1x8, GB300 2x4, B200 2x8, GB200 4x4, H200 2x8, H100 4x8 e MI350X/MI355X 1x8, mas, em outubro de 2026, apenas a configuração B300 1x8 está marcada como verificada. Em outras palavras, implantações com H100 precisam de quatro nós de 8 GPUs, algo fora do alcance de quase todo mundo que roda "localmente".
Para se aprofundar no dimensionamento, veja nosso guia de requisitos de memória de GPU para LLMs e o guia de implantação com paralelismo de especialistas no vLLM.
Rodar o Kimi K3 localmente com llama.cpp (GGUF)
Estes passos seguem o guia da Unsloth. O suporte a visão do K3 atualmente exige o fork da Unsloth do llama.cpp; o uso apenas com texto segue os mesmos passos.
1. Compile o llama.cpp. Use -DGGML_CUDA=OFF se você não tiver GPU NVIDIA.
git clone https://github.com/unslothai/llama.cpp
cd llama.cpp
git fetch origin pull/48/head:kimi-k3-fullsize-vision
git checkout kimi-k3-fullsize-vision
cd ..
cmake llama.cpp -B llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first \
--target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
2. Baixe a quantização de 1 bit (cerca de 594 GB) e o projetor de visão. Verifique antes o espaço livre em disco.
pip install -U huggingface_hub
df -h . # need roughly 650 GB free
hf download unsloth/Kimi-K3-GGUF \
--local-dir unsloth/Kimi-K3-GGUF \
--include "*mmproj-BF16*" \
--include "*UD-IQ1_S*"
3. Converse no terminal. Use a amostragem recomendada pela Moonshot: temperature 1.0 e top_p 0.95 (top_p 1.0 para tarefas agênticas).
FIRST=$(ls unsloth/Kimi-K3-GGUF/UD-IQ1_S/*00001-of-*.gguf | head -1)
./llama.cpp/llama-cli --model "$FIRST" \
--mmproj unsloth/Kimi-K3-GGUF/mmproj-BF16.gguf \
--temp 1.0 --top-p 0.95
4. Sirva uma API compatível com OpenAI. O llama-server expõe /v1/chat/completions. Um tamanho de contexto menor economiza memória para o cache KV.
./llama.cpp/llama-server --model "$FIRST" \
--mmproj unsloth/Kimi-K3-GGUF/mmproj-BF16.gguf \
--ctx-size 32768 --temp 1.0 --top-p 0.95 \
--host 127.0.0.1 --port 8080
Servir o Kimi K3 com vLLM (nó completo)
Se você tem, ou aluga, um nó de 8 GPUs compatível, o vLLM oferece throughput de produção, chamada de ferramentas e o contexto completo de 1M. O comando básico da receita oficial:
docker run --gpus all --ipc=host -p 8000:8000 \
-v ~/.cache/huggingface:/root/.cache/huggingface \
vllm/vllm-openai:kimi-k3 \
moonshotai/Kimi-K3 --trust-remote-code \
--tensor-parallel-size 8 \
--tool-call-parser kimi_k3 --reasoning-parser kimi_k3 \
--enable-auto-tool-choice \
--max-model-len 1048576 \
--enable-prefix-caching --kv-cache-dtype fp8
A receita também observa que o formato das chamadas de ferramentas às vezes sai malformado, então valide os argumentos e tente novamente quando a análise falhar. Nosso guia de implantação do vLLM e o guia de inferência multi-GPU cobrem monitoramento e ajuste.
Chamar seu servidor local do Kimi K3
Tanto o llama-server (porta 8080 acima) quanto o vLLM (porta 8000) falam a API da OpenAI, então qualquer SDK da OpenAI funciona.
curl
curl -s http://127.0.0.1:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model":"moonshotai/Kimi-K3","temperature":1.0,"top_p":0.95,
"messages":[{"role":"user","content":"Write a bash one-liner that finds the 5 largest files in a directory."}]}'
Python
from openai import OpenAI
# Local vLLM server; use base_url="http://127.0.0.1:8080/v1" for llama-server
client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="local")
r = client.chat.completions.create(
model="moonshotai/Kimi-K3",
temperature=1.0, top_p=0.95,
messages=[{"role": "user", "content": "Explain MoE routing in 3 sentences."}],
)
msg = r.choices[0].message
print(getattr(msg, "reasoning_content", None)) # thinking trace, when the server returns it
print(msg.content)
Node.js
import OpenAI from "openai";
const client = new OpenAI({ baseURL: "http://127.0.0.1:8000/v1", apiKey: "local" });
const r = await client.chat.completions.create({
model: "moonshotai/Kimi-K3",
temperature: 1.0,
top_p: 0.95,
messages: [{ role: "user", content: "Give me a regex for ISO 8601 dates." }],
});
console.log(r.choices[0].message.content);
Em conversas de vários turnos, adicione ao histórico a mensagem do assistente com seu reasoning_content e quaisquer tool_calls antes do próximo turno, como o model card exige.
Local vs GPUs alugadas vs API: quanto custa o Kimi K3?
Alugar GPUs. O índice de preços de GPU da Flatkey (atualizado em 24 de outubro de 2026) lista tarifas em tempo real de US$ 7,49 por hora de GPU para B200, US$ 7,34 para B300, US$ 3,60 para H200 e US$ 2,48 para H100. Um nó 8x B200 custa, portanto, cerca de US$ 59,92 por hora, ou aproximadamente US$ 43.700 por mês rodando 24/7 (nossa estimativa: 8 x US$ 7,49 x 730 horas).
API hospedada. A plataforma oficial da Moonshot lista o Kimi K3 a US$ 3,00 por milhão de tokens de entrada, US$ 0,30 para entrada em cache e US$ 15,00 por milhão de tokens de saída. Na página do modelo na Flatkey, o Kimi K3 custa US$ 1,80 de entrada, US$ 0,18 de entrada em cache e US$ 9,00 de saída por milhão de tokens, com o mesmo contexto de 1.048.576 tokens (ambos consultados em 24 de outubro de 2026).
Ponto de equilíbrio (estimativa). Com uma proporção de entrada para saída de 3:1, o preço da Flatkey fica em cerca de US$ 3,60 por milhão de tokens combinados. US$ 43.700 por mês compram cerca de 12 bilhões de tokens combinados, ou cerca de 400 milhões de tokens por dia. Abaixo desse volume, uma API é mais barata que um nó 8x B200 dedicado, sem contar o tempo de engenharia.
| Opção | Custo inicial | Ideal para |
|---|---|---|
| GGUF de 1 bit local em uma estação com muita RAM | Hardware próprio | Experimentos sensíveis à privacidade, trabalho offline, aprendizado |
| Nó de 8 GPUs alugado com vLLM ou SGLang | Aluguel por hora | Controle dos dados com throughput de produção, pesquisa de fine-tuning |
| API hospedada (Moonshot ou Flatkey) | Nenhum | A maioria dos apps, protótipos e tráfego variável |
Você pode chamar o modelo hospedado com o mesmo código acima, trocando a base URL:
import os
from openai import OpenAI
client = OpenAI(base_url="https://router.flatkey.ai/v1", api_key=os.environ["FLATKEY_API_KEY"])
r = client.chat.completions.create(model="kimi-k3",
messages=[{"role": "user", "content": "Summarize the Kimi K3 license in two sentences."}])
print(r.choices[0].message.content)
Leia mais na nossa análise do custo por milhão de tokens de um LLM auto-hospedado, na comparação nuvem de GPU vs API de modelos e no guia de acesso à API do Kimi K3.
Solução de problemas
| Problema | Causa provável | Solução |
|---|---|---|
| A geração está extremamente lenta | O modelo não cabe em RAM + VRAM e está sendo lido do disco | Use uma quantização menor, adicione RAM ou mude para um servidor com GPU |
out of memory ao iniciar o llama-server |
Cache KV grande demais | Reduza --ctx-size |
| Entrada de imagem ignorada | Falta o arquivo do projetor ou build upstream do llama.cpp | Passe --mmproj e compile o fork da Unsloth |
| A imagem do vLLM não inicia | CUDA ou driver antigos demais | Use CUDA 13 com driver r580 ou posterior |
| Chamadas de ferramentas quebradas | Saída ocasionalmente malformada | Valide os argumentos e tente novamente |
| O segundo turno se comporta de forma estranha | O conteúdo de pensamento não foi devolvido | Inclua reasoning_content no histórico |
| O download trava | Transferência grande de vários arquivos | Execute hf download de novo; ele retoma |
Perguntas frequentes
O Kimi K3 pode rodar localmente?
Sim. Os pesos são públicos, e o menor GGUF de 1 bit precisa de cerca de 610 GB de RAM e VRAM combinadas para rodar em velocidade razoável. Com menos memória ele ainda roda, mas devagar, porque o llama.cpp lê os pesos do disco.
Posso rodar o Kimi em um PC gamer?
Não de forma útil. Uma única GPU de 24 GB com 64-128 GB de RAM fica muito abaixo dos cerca de 610 GB que a menor quantização exige, então você dependeria do descarregamento em disco. Use uma API ou alugue um servidor com GPU.
Quanta VRAM o Kimi K3 precisa?
Para os pesos nativos, a receita oficial do vLLM exige pelo menos 8x GPUs GB300. Para GGUF, o que importa é a soma de RAM e VRAM: cerca de 610 GB para 1 bit e cerca de 880 GB para 2 bits (Unsloth, outubro de 2026).
O Kimi K3 é realmente mais barato que outros modelos?
Pela API ele tem preço intermediário: US$ 3 / US$ 15 por milhão de tokens na plataforma da Moonshot e US$ 1,80 / US$ 9 na Flatkey em outubro de 2026. A auto-hospedagem só supera o preço da API em volumes muito altos e constantes.
O Kimi K3 é open source?
Os pesos são abertos sob a Kimi K3 License, uma licença MIT modificada com condições de atribuição e de uso comercial em grande escala.
Posso rodar o Kimi K3.1 Pro localmente?
Não. Em 24 de outubro de 2026, o Kimi K3.1 Pro é oferecido pela API da Moonshot, e o Kimi K3 é o modelo mais recente com pesos no Hugging Face.
Fontes
- Model card e licença do Kimi K3 (outubro de 2026)
- Guia do Kimi K3 da Unsloth e arquivos Kimi-K3-GGUF (outubro de 2026)
- Receita do vLLM para o Kimi K3 (outubro de 2026)
- Cookbook do SGLang para o Kimi K3 (outubro de 2026)
- Preços da plataforma de API do Kimi (outubro de 2026)
- Índice de preços de GPU da Flatkey (atualizado em 24 de outubro de 2026)
