DEV Community

Cover image for O que é o Código Kimi K2.7
Lucas
Lucas

Posted on • Originally published at apidog.com

O que é o Código Kimi K2.7

A Moonshot AI lançou o Kimi K2.7 Code, um modelo aberto focado em desenvolvimento de software e agentes de codificação. Ele mantém a escala de 1 trilhão de parâmetros da linha Kimi K2, adiciona entrada multimodal com visão e reduz o uso de "thinking-tokens" em relação ao Kimi K2.6. Se você já testou o Kimi K2.6 ou sua API, pense no K2.7 Code como a versão otimizada para codificação, com um agente de terminal chamado Kimi Code para competir com ferramentas como Claude Code e Codex.

Experimente o Apidog hoje

Neste guia, você verá o que mudou, como o modelo é estruturado, onde executá-lo e como testar a API compatível com OpenAI usando o Apidog.

TL;DR

  • O Kimi K2.7 Code é um modelo Mixture-of-Experts com 1 trilhão de parâmetros totais e 32 bilhões ativos por token.
  • Ele oferece janela de contexto de 256K tokens, entrada de imagem e vídeo via MoonViT e cerca de 30% menos "thinking-tokens" do que o K2.6.
  • Os pesos são públicos sob uma licença MIT modificada.
  • Você pode executá-lo com vLLM, SGLang ou KTransformers.
  • Nos benchmarks divulgados pela Moonshot, ele fica próximo, mas geralmente atrás de GPT-5.5 e Claude Opus em codificação e tarefas de agente.
  • O pacote inclui o Kimi Code, um agente de terminal/IDE, e uma API compatível com OpenAI que pode ser testada rapidamente no Apidog.

O que é o Kimi K2.7 Code

O Kimi K2.7 Code é a versão especializada em codificação da família K2 da Moonshot AI. Ele usa arquitetura esparsa Mixture-of-Experts, ativando apenas parte dos pesos a cada token. O foco do checkpoint não é chat geral, mas fluxos de desenvolvimento: leitura de repositórios, refatoração, depuração, chamadas de ferramentas e sessões longas com agentes.

Você pode usá-lo de quatro formas:

  1. Pelo aplicativo web Kimi.
  2. Pelo agente de terminal Kimi Code.
  3. Pela API hospedada da Moonshot.
  4. Baixando os pesos no Hugging Face e hospedando por conta própria.

O que mudou em relação ao Kimi K2.6

Se você já leu a explicação do Kimi K2.6, as mudanças práticas são estas:

Kimi K2.7 Code

1. Foco direto em código e agentes

O K2.6 era um modelo mais generalista. O K2.7 Code foi ajustado para tarefas como:

  • refatorar arquivos;
  • investigar bugs;
  • navegar por bases de código grandes;
  • executar comandos;
  • usar ferramentas em sequência;
  • manter contexto durante tarefas longas.

2. Menor custo de raciocínio

A Moonshot relata cerca de 30% menos uso de "thinking-tokens" para resultados comparáveis ao K2.6.

Isso importa porque agentes de codificação costumam seguir este ciclo:

ler arquivo -> raciocinar -> chamar ferramenta -> ler resultado -> raciocinar novamente -> editar arquivo
Enter fullscreen mode Exit fullscreen mode

Se cada etapa usa menos tokens de raciocínio, você reduz custo e latência.

3. Entrada multimodal

O K2.7 Code inclui um codificador de visão MoonViT de 400M parâmetros. Na prática, ele pode analisar:

  • screenshots de UI;
  • capturas de erro;
  • diagramas;
  • frames de vídeo;
  • mockups de interface.

Isso abre espaço para agentes que depuram uma tela quebrada, comparam uma UI com um design ou interpretam logs visuais.

Arquitetura do Kimi K2.7 Code

A arquitetura explica por que o modelo pode ter escala de 1T parâmetros sem ativar tudo a cada token.

Especificação Kimi K2.7 Code
Parâmetros totais 1 trilhão
Parâmetros ativos por token 32 bilhões
Especialistas 384 totais, 8 selecionados por token
Camadas 61, sendo 1 densa
Atenção Multi-head Latent Attention, MLA
Janela de contexto 256K tokens
Codificador de visão MoonViT, 400M parâmetros
Licença MIT modificada

O roteador escolhe 8 de 384 especialistas para cada token. Assim, embora o modelo tenha 1 trilhão de parâmetros totais, o custo de inferência por token se aproxima de um modelo com 32B parâmetros ativos.

A janela de contexto de 256K tokens é especialmente útil para desenvolvimento. Você pode enviar um serviço completo, testes, arquivos de configuração e instruções em um único prompt, reduzindo a necessidade de dividir a tarefa manualmente.

Benchmarks: como interpretar

A Moonshot publicou resultados contra GPT-5.5 e Claude Opus em benchmarks de codificação e uso de agentes.

Benchmarks do Kimi K2.7 Code

Codificação

Benchmark Kimi K2.7 Code GPT-5.5 Claude Opus
Kimi Code Bench v2 62.0 69.0 67.4
Program Bench 53.6 69.1 63.8
MLS Bench Lite 35.1 35.5 42.8

Agente e uso de ferramentas

Benchmark Kimi K2.7 Code GPT-5.5 Claude Opus
Kimi Claw 24/7 46.9 52.8 50.4
MCP Atlas 76.0 79.4 81.3
MCP Mark Verified 81.1 92.9 76.4

A leitura prática é: o K2.7 Code não lidera a maioria dos benchmarks contra modelos fechados de fronteira, mas fica competitivo. O diferencial é ter pesos abertos, custo menor de raciocínio e possibilidade de auto-hospedagem.

Também vale considerar que várias suítes são da própria Moonshot. Use os números como referência inicial, não como validação definitiva. Para decidir, rode seus próprios testes com tarefas reais do seu produto.

Se sua métrica principal é capacidade bruta de codificação, veja também a comparação DeepSeek V4 vs Claude Opus.

Por que a redução de "thinking-tokens" importa

Em agentes de codificação, o custo não vem apenas da resposta final. Ele aparece em cada etapa intermediária:

  • análise do repositório;
  • escolha do próximo comando;
  • interpretação de logs;
  • planejamento de edição;
  • validação de testes;
  • nova tentativa após erro.

Uma redução de ~30% em tokens de raciocínio pode impactar diretamente:

  • custo por tarefa;
  • tempo de resposta;
  • número de chamadas viáveis por usuário;
  • orçamento para sessões longas.

Se você está construindo um agente para uso contínuo, esse ganho pode ser mais importante do que alguns pontos em benchmark. Para outras estratégias de controle de custo, veja o guia sobre como reduzir custos de tokens de agente a partir do CLI.

Como usar o Kimi Code

O Kimi Code é o agente de codificação que acompanha o modelo. Ele roda no terminal e pode:

  • ler e editar arquivos;
  • executar comandos de shell;
  • pesquisar no codebase;
  • buscar conteúdo web;
  • usar subagentes para trabalho paralelo;
  • operar com chamadas de ferramentas em várias etapas.

Instale com:

curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash
Enter fullscreen mode Exit fullscreen mode

Depois, entre em um diretório de projeto e execute:

kimi
Enter fullscreen mode Exit fullscreen mode

Um fluxo inicial recomendado:

cd meu-projeto
kimi
Enter fullscreen mode Exit fullscreen mode

Peça uma tarefa limitada, por exemplo:

Analise este repositório e explique como a autenticação funciona. Não edite arquivos ainda.
Enter fullscreen mode Exit fullscreen mode

Depois avance para uma alteração controlada:

Adicione testes para o fluxo de login. Antes de editar, liste os arquivos que pretende modificar.
Enter fullscreen mode Exit fullscreen mode

Essa abordagem evita que o agente faça alterações grandes antes de você entender o plano.

Também há extensão para VS Code e suporte para JetBrains e Zed via protocolo ACP. Se você já usou o Kimi CLI, trate o Kimi Code como uma reconstrução do agente, não como uma atualização simples.

Onde executar o Kimi K2.7 Code

Você tem quatro opções principais.

1. Aplicativo web Kimi

Bom para:

  • perguntas rápidas;
  • protótipos;
  • análise de pequenos trechos de código;
  • testes sem configuração local.

2. Kimi Code CLI

Melhor opção para:

  • trabalhar dentro do repositório;
  • editar arquivos;
  • executar testes;
  • automatizar tarefas de desenvolvimento.

3. API compatível com OpenAI

A API da Moonshot usa um formato compatível com OpenAI.

Use:

https://api.moonshot.ai/v1
Enter fullscreen mode Exit fullscreen mode

Modelo:

kimi-k2.7-code
Enter fullscreen mode Exit fullscreen mode

Exemplo conceitual com um cliente compatível com OpenAI:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k2.7-code",
  messages: [
    {
      role: "system",
      content: "Você é um assistente de codificação. Responda de forma objetiva.",
    },
    {
      role: "user",
      content: "Explique como refatorar este endpoint Express para separar controller e service.",
    },
  ],
});

console.log(response.choices[0].message.content);
Enter fullscreen mode Exit fullscreen mode

Como o endpoint é compatível com OpenAI, ele pode ser integrado a ferramentas como Claude Code, Cursor e Cline alterando a URL base e o id do modelo.

Observação: a assinatura de taxa fixa do Kimi Code usa um id separado:

kimi-for-coding
Enter fullscreen mode Exit fullscreen mode

4. Pesos abertos

Os pesos estão disponíveis no Hugging Face.

A Moonshot recomenda servir com:

  • vLLM;
  • SGLang;
  • KTransformers.

Essa é a rota adequada se você precisa manter dados em infraestrutura própria por privacidade, compliance ou custo previsível.

Como testar a API Kimi K2.7 Code no Apidog

Antes de conectar o modelo ao seu agente, teste a requisição bruta. Isso ajuda a validar payload, headers, resposta e uso de tokens.

Passo 1: crie uma requisição HTTP

Abra o Apidog e crie uma nova requisição.

Configure:

POST https://api.moonshot.ai/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

Passo 2: adicione os headers

Use:

Authorization: Bearer <sua-chave>
Content-Type: application/json
Enter fullscreen mode Exit fullscreen mode

A chave deve ser obtida no console da plataforma Kimi.

Passo 3: envie um payload compatível com OpenAI

Exemplo:

{
  "model": "kimi-k2.7-code",
  "messages": [
    {
      "role": "system",
      "content": "Você é um assistente de codificação. Responda em português e seja direto."
    },
    {
      "role": "user",
      "content": "Crie uma função JavaScript que valide se uma string é um email simples."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Passo 4: valide a resposta

No Apidog, confira:

  • status HTTP;
  • JSON retornado;
  • conteúdo em choices;
  • campos de usage;
  • tempo de resposta;
  • erros de autenticação ou limite.

Você pode salvar a chamada como teste reutilizável. Um teste simples pode verificar, por exemplo:

pm.test("status é 200", function () {
  pm.response.to.have.status(200);
});

pm.test("resposta contém choices", function () {
  const json = pm.response.json();
  pm.expect(json.choices).to.be.an("array");
});
Enter fullscreen mode Exit fullscreen mode

Também é útil criar uma checagem de orçamento:

pm.test("completion_tokens dentro do limite", function () {
  const json = pm.response.json();
  pm.expect(json.usage.completion_tokens).to.be.below(1000);
});
Enter fullscreen mode Exit fullscreen mode

Se você estiver validando chamadas de ferramentas via MCP, veja o manual de teste de servidor MCP. Para acompanhar localmente, baixe o Apidog.

Quando escolher o Kimi K2.7 Code

Escolha o Kimi K2.7 Code se você está construindo:

  • agentes de codificação sensíveis a custo e latência;
  • ferramentas que precisam de contexto longo;
  • fluxos de refatoração em múltiplos arquivos;
  • produtos que precisam de auto-hospedagem;
  • workflows multimodais com screenshots, diagramas ou vídeo;
  • integrações que já usam formato compatível com OpenAI.

Mantenha um modelo fechado de fronteira se você precisa de:

  • melhor pontuação possível em uma única tentativa;
  • SLA gerenciado pelo fornecedor;
  • suporte corporativo dedicado;
  • menor responsabilidade operacional.

Para comparar outros modelos abertos, veja a análise MiniMax M3 vs DeepSeek V4 vs Qwen 3.7.

Checklist de implementação

Use esta lista antes de colocar o Kimi K2.7 Code em um fluxo real:

  • [ ] Definir se o uso será via API, CLI ou auto-hospedagem.
  • [ ] Criar uma chave da plataforma Kimi, se usar API.
  • [ ] Testar o endpoint /chat/completions no Apidog.
  • [ ] Medir prompt_tokens, completion_tokens e latência.
  • [ ] Criar prompts de teste com tarefas reais do seu repositório.
  • [ ] Comparar custo e qualidade com o modelo atual.
  • [ ] Validar comportamento com chamadas de ferramentas.
  • [ ] Definir limites de token por tarefa.
  • [ ] Criar testes de regressão para respostas críticas.
  • [ ] Revisar a licença antes de uso comercial ou redistribuição.

FAQ

O Kimi K2.7 Code é open source?

Os pesos são públicos sob uma licença MIT modificada. Você pode baixar, executar e ajustar, mas deve ler os termos da licença no card do modelo antes do uso comercial.

Qual é a janela de contexto?

256K tokens. Isso permite enviar grandes partes de um repositório, testes e configuração em uma única sessão.

Posso executá-lo localmente?

Sim. A Moonshot recomenda vLLM, SGLang ou KTransformers. Como o modelo é grande, planeje uso sério de GPU ou uma configuração quantizada.

Qual é o id do modelo na API?

Use:

kimi-k2.7-code
Enter fullscreen mode Exit fullscreen mode

Endpoint:

https://api.moonshot.ai/v1
Enter fullscreen mode Exit fullscreen mode

Para a assinatura de taxa fixa do Kimi Code, o id separado é:

kimi-for-coding
Enter fullscreen mode Exit fullscreen mode

Qual é a diferença para o Kimi K2.6?

O K2.7 Code é ajustado especificamente para codificação e agentes, adiciona visão e usa cerca de 30% menos "thinking-tokens" para resultados comparáveis.

Ele suporta chamadas de ferramentas e MCP?

Sim. O modelo foi projetado para raciocínio intercalado e chamadas de ferramentas multi-etapa. O Kimi Code também suporta o Model Context Protocol.

É gratuito?

Você pode conversar no aplicativo Kimi sem custo, e os pesos são gratuitos para download. O uso da API e do agente Kimi Code depende de planos com limites de cota.

Resumo

O Kimi K2.7 Code é a aposta da Moonshot em pesos abertos, contexto longo e menor custo de raciocínio para agentes de codificação. Ele traz 1T parâmetros totais, 32B ativos por token, janela de 256K tokens, visão e redução de ~30% em "thinking-tokens" frente ao K2.6.

Ele não supera GPT-5.5 ou Claude Opus na maioria dos benchmarks divulgados, mas chega perto enquanto oferece mais controle operacional. Para equipes que constroem ferramentas de codificação, agentes internos ou fluxos que exigem privacidade, vale executar um teste real.

Comece enviando uma requisição pelo Apidog, meça tokens e latência, e só então decida entre API hospedada, Kimi Code ou auto-hospedagem.

Top comments (0)