O Kimi K2.7 Code é o modelo agêntico focado em código da Moonshot AI construído sobre o Kimi K2.6, ajustado para engenharia de software do mundo real e descrito pela Moonshot como seu modelo dedicado a código, que segue instruções de forma mais confiável em contextos longos e completa tarefas de código com taxas de sucesso mais altas.
- Entrada
- texto imagem vídeo $0.95/M
- Saída
- texto $4/M
- Leitura de cache
- $0.19/M
- Contexto
- 256K
- vs GPT-4o
- ~81% mais barato
Benchmarks
Publicado pelos provedores: Alibaba (Qwen) Moonshot OpenAI Z.ai
O preço em contexto
Posição do preço entre 68 modelos comparáveis
A barra mostra onde fica o preço deste modelo entre todos os modelos do mesmo tipo na Synthorai. Nas extremidades aparecem o mais barato e o mais caro. São as tarifas base; os descontos de batch, região e escrita de cache estão na página de preços.
Especificações e limites
Tokens
| Janela de contexto (especificação do provedor) | 256.000 |
|---|---|
| Saída máxima (especificação do provedor) | 32.768 |
Cache de prompts
| Modo | automático |
|---|
Raciocínio
| Parâmetro do provedor | thinking.type + thinking.keep |
|---|---|
| Valores aceitos | type accepts only enabled; keep accepts only all |
| Valor padrão | raciocínio ativado, com Preserved Thinking ativado usado quando a requisição não define nada |
| Pode ser desativado | Não |
| Comportamento do raciocínio | Passar type disabled retorna erro; como o Preserved Thinking é forçado no servidor, o reasoning_content de toda mensagem de assistente do histórico precisa ser devolvido como está. |
| Parâmetro | reasoning_effort |
| Valores | minimal · low · medium · high parâmetros expostos pelo gateway; vale o mapeamento do provedor indicado acima |
Modelo
| Modalidades | texto + imagem + vídeo → texto |
|---|---|
| Parâmetros | 1T no total · 32B ativos MoE |
| Licença | Modified-MIT |
- Modelo agêntico focado em código, construído sobre o K2.6: MoE de 1T com 32B ativos, contexto de 256K
- raciocínio sempre ativo, com raciocínio preservado entre turnos
- cerca de 30% menos tokens de raciocínio que o K2.6
conforme documentação oficial da Moonshot ↗
Um prompt, medido pelo gateway
Kimi K2.7 Code passou · 3 sentences
Enabling reasoning mode causes the model to generate an internal chain-of-thought before producing each answer, and that hidden reasoning text is billed like any other output. Those extra reasoning tokens typically add up to much more than the final response itself, so every API call now costs significantly more than before. Because our overall usage volume did not change, the doubled bill reflects that each query consumes roughly twice as many billable tokens.
saída 259 tok (+174 raciocínio) latência 5.4 s
Se a instrução é seguida (exatamente três frases, dá para contar), a adequação ao público (tom para um CFO) e a diferença de cobrança causada pelo raciocínio oculto, que os medidores de tokens abaixo deixam à mostra.
Kimi K2.7 Code passou · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The bug is that the function counts *transitions* between equal neighbors instead of counting the items themselves, so a single-element list never enters the loop and returns `0` instead of `1`. Likewise, resetting `cur` to `0` on a mismatch forgets the current item that starts a new run, which causes runs that end at the last index to be undercounted. Initializing both `best` and `cur` to `1` and resetting `cur` to `1` fixes both issues.
saída 410 tok (+222 raciocínio) latência 9.4 s
Se a correção está mesmo certa (dá para executar), a densidade da explicação e a eficiência em tokens em uma tarefa bem delimitada.
Kimi K2.7 Code passou · 5/5 fields, guidance "withheld pending the Q4 close"
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "withheld pending the Q4 close" } ```
saída 721 tok (+663 raciocínio) latência 13.2 s
Aderência ao schema (sem campos inventados), pressão para alucinar (o texto diz explicitamente que o guidance não foi divulgado) e diferenças no caminho de saída estruturada.
Kimi K2.7 Code passou · 120 words, 0 banned, 1 question
We're introducing Prompt Cache for our API Gateway, a new capability that stores prompt responses across multiple AI providers. By caching replies, you reduce redundant calls, lower latency, and cut costs without changing how you build. Teams using several model providers can now reuse identical prompt results instantly, keeping traffic consistent and budgets predictable. Responses are keyed by provider, model, and exact prompt, so you always get the right result. Configure TTL, hit thresholds, and eviction rules from a single dashboard. It fits into your existing routing and requires no code changes. Setup takes minutes and works with your current endpoints. Want to see how much latency and spend you can trim? Check the docs to enable Prompt Cache today.
saída 2375 tok (+2235 raciocínio) latência 38.6 s
Respeito às restrições (limite de palavras, lista de palavras proibidas, uma única pergunta), a marca de estilo de cada modelo e o controle do tamanho.
Use o Kimi K2.7 Code em 30 segundos
Compatível com OpenAI: troque a base_url, mantenha seu SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="kimi-k2.7-code",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "kimi-k2.7-code",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k2.7-code",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "kimi-k2.7-code",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("kimi-k2.7-code")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));Sobre o Kimi K2.7 Code
- Ele mantém a arquitetura Mixture-of-Experts de 1T de parâmetros com 32B ativados por token (384 especialistas, oito por token mais um compartilhado) e um contexto de 256K, aceita entrada de imagem junto ao texto e roda sempre em modo thinking, com o conteúdo de raciocínio preservado entre conversas de múltiplos turnos.
- O modo non-thinking não é apenas desaconselhado, mas rejeitado: a documentação afirma que o modelo não o suporta e que desativar o raciocínio retorna um erro, com o thinking preservado forçado no lado do servidor.
- O raciocínio chega em reasoning_content antes da resposta, e o guia é explícito de que você precisa devolver esse campo junto à mensagem do assistente nos turnos de chamada de ferramentas, ou a requisição dá erro, que é o erro de integração mais comum com este modelo.
- Oficialmente, ele fortalece a conclusão de tarefas de ponta a ponta em fluxos complexos de engenharia de software usando cerca de 30% menos tokens de raciocínio que o K2.6, e suporta uso agêntico de ferramentas pelo ecossistema MCP, com raciocínio intercalado ao longo de chamadas de ferramentas em múltiplas etapas.
- A Moonshot aconselha deixar folga generosa em max_tokens porque o raciocínio a consome.
- Os pesos são abertos sob uma licença Modified MIT.
- Acesse o Kimi K2.7 Code na Synthorai pelo endpoint compatível com OpenAI.
Perguntas frequentes
A API do Kimi K2.7 Code é gratuita para testar?
Sim. Contas novas recebem 10 chamadas de teste e até $1 em créditos gratuitos, sem precisar de cartão. A $0.95/M de tokens de entrada, só esse crédito já cobre cerca de 131 requisições de ~8K tokens ao Kimi K2.7 Code.
Em que o Kimi K2.7 Code é melhor?
Cerca de 30% menos tokens de raciocínio; raciocínio preservado ao longo de conversas de múltiplos turnos; ajustado para engenharia de software do mundo real. Veja na seção Sobre o quadro completo, tirado das notas de lançamento do próprio provedor.
Quanto custa o Kimi K2.7 Code?
Na Synthorai, o Kimi K2.7 Code custa $0.95 por milhão de tokens de entrada e $4 por milhão de tokens de saída. É o preço de tabela do provedor, sem markup da plataforma. Tokens de entrada em cache são cobrados a $0.19/M.
Qual é a janela de contexto do Kimi K2.7 Code?
O Kimi K2.7 Code tem uma janela de contexto de 256K tokens na Synthorai. Uma única resposta pode ter até 32,768 tokens.
O Kimi K2.7 Code suporta cache de prompts?
Sim, automaticamente: prompts servidos pela Moonshot entram em cache sem nenhuma mudança no código. Tokens de entrada em cache são cobrados a $0.19/M, contra $0.95/M sem cache. Guia de cache de prompts →
Como obtenho acesso ao Kimi K2.7 Code?
Aponte o SDK da OpenAI que você já usa para base_url="https://synthorai.io/v1", defina model="kimi-k2.7-code" e pronto. Uma única chave de API cobre todos os modelos do gateway.
O Kimi K2.7 Code é open source?
Sim, os pesos são publicados sob a licença Modified-MIT. Se preferir dispensar as GPUs, a versão hospedada aqui tem pagamento por uso e nenhuma infraestrutura para operar. Como rodar modelos de pesos abertos →
Modelos relacionados
Comparar
Cada valor desta página foi transcrito da documentação do provedor, com link acima, e traz a data em que foi verificado. Os preços são comparados em todo o catálogo; já as especificações que cada provedor define de um jeito aparecem com a diferença indicada, em vez de irem para um gráfico. Nada aqui foi medido por nós, e nada recebe nota.