API Kimi K2: descontinuação e migração para K3.1 Pro

Migre as integrações com kimi-k2.6 e kimi-k2.7-code para kimi-k3.1-pro antes da descontinuação prevista para o fim de dezembro de 2026. Defina o esforço de raciocínio e o limite de geração, depois valide o histórico das ferramentas e os custos antes de alterar o tráfego de produção. Em 2026-11-05, as restrições para contas novas já estão ativas.

Quando o Kimi K2 deixará de funcionar?

Contas existentes elegíveis mantêm acesso por enquanto, mas esses avisos não informam o dia nem o horário exatos do encerramento.

O aviso na página de preços informa que o K2 ficou indisponível para novos usuários a partir de 31 de outubro de 2026. A Kimi planeja retirar todos os modelos K2 de serviço até o fim de dezembro de 2026.

A atual lista de modelos usa uma formulação um pouco diferente. Ela informa que usuários cadastrados antes de 1 de novembro podem continuar usando kimi-k2.6, kimi-k2.7-code e kimi-k2.7-code-highspeed. A descontinuação está prevista para o fim de dezembro de 2026.

Se você criou sua conta perto dessas datas, confira o acesso efetivo dela. As formulações não definem um único momento exato de corte. Para novas implantações, comece com K3.1 Pro.

Não suponha que toda falha de acesso ao K2 retorne o mesmo erro. O registro de alterações de agosto confirma 404 “model not found” para os modelos descontinuados kimi-k2.5 e moonshot-v1. Essa declaração não especifica a resposta que a API retornará após descontinuar K2.6 ou K2.7 Code.

Altere o formato das requisições antes de mudar o tráfego

Atualize o corpo das requisições e o armazenamento das conversas juntos. A atual comparação de parâmetros da Kimi documenta diferenças que uma simples troca do nome do modelo pode deixar passar.

Configuração	`kimi-k2.6`	`kimi-k2.7-code`	`kimi-k3.1-pro`
Raciocínio	Ativado por padrão; pode ser desativado	Sempre ativado	Sempre ativado; remova o objeto `thinking` do K2
`reasoning_effort`	Sem suporte	Sem suporte	Campo de nível superior: `low`, `high` ou `max`; padrão `max`
`temperature`	Fixo em `1.0` com raciocínio; `0.6` sem raciocínio	Fixo em `1.0`	Fixo em `1.0`; omita o campo
Limite de geração padrão documentado	`max_tokens`: `32768`	`max_tokens`: `32768`	`max_completion_tokens`: `131072`

O K2.7 Code já exigia raciocínio e preservava esse conteúdo entre interações. Essas exigências representam uma mudança maior para aplicações que usavam o modo sem raciocínio do K2.6.

O guia rápido do K3.1 Pro também fixa top_p=0.95, n=1, presence_penalty=0 e frequency_penalty=0. Omita esses campos e temperature. Confira também os padrões do cliente: ele pode inserir um valor de amostragem que sua aplicação nunca definiu.

Use max_completion_tokens nas novas requisições de Chat Completions. A referência da API marca max_tokens como obsoleto, mas não informa que o campo foi removido. Para K3.1 Pro, o máximo configurável é 1048576, limitado pelo espaço disponível no contexto.

O limite de geração define um teto, não o consumo obrigatório de tokens em cada requisição. Escolha um limite para sua tarefa em vez de herdar o padrão maior.

Para o esforço de raciocínio, comece com low em testes de conexão e consultas de escopo limitado. Experimente high para tarefas comuns de programação. Use max quando seus testes de regressão justificarem o raciocínio adicional. low reduz o esforço, mas não desativa o raciocínio.

Faça um teste limitado da API e da chamada de ferramenta

Verifique a API diretamente antes de investigar a configuração de um agente.

Crie uma chave de API na Global Kimi Open Platform. Os requisitos de acesso em 2026-11-05 exigem uma recarga bem-sucedida de pelo menos $1. Use uma chave da plataforma correspondente a https://api.moonshot.ai. Para erros de conta no Kimi Code, comece pelo guia separado de limites do Kimi Code.

No Bash, leia a chave sem exibi-la:

read -rs MOONSHOT_API_KEY && export MOONSHOT_API_KEY

O comando Bash abaixo usa a biblioteca padrão do Python 3. Ele envia duas requisições cobradas e executa uma multiplicação local. O limite de geração 4096 serve para esse teste aritmético, não como orçamento geral de programação.

python3 - <<'PY'
import json
import os
import urllib.error
import urllib.request

tools = [{
    "type": "function",
    "function": {
        "name": "multiply",
        "description": "Multiply two integers.",
        "parameters": {
            "type": "object",
            "properties": {
                "a": {"type": "integer"},
                "b": {"type": "integer"}
            },
            "required": ["a", "b"],
            "additionalProperties": False
        }
    }
}]

def chat(messages, choice):
    payload = {
        "model": "kimi-k3.1-pro",
        "messages": messages,
        "reasoning_effort": "low",
        "max_completion_tokens": 4096,
        "tools": tools,
        "tool_choice": choice
    }
    request = urllib.request.Request(
        "https://api.moonshot.ai/v1/chat/completions",
        data=json.dumps(payload).encode("utf-8"),
        headers={
            "Authorization": "Bearer " + os.environ["MOONSHOT_API_KEY"],
            "Content-Type": "application/json"
        },
        method="POST"
    )
    try:
        with urllib.request.urlopen(request, timeout=120) as response:
            data = json.load(response)
    except urllib.error.HTTPError as error:
        raise SystemExit(f"HTTP {error.code}: check access and request parameters.")
    if data.get("model") != "kimi-k3.1-pro":
        raise RuntimeError("Unexpected response model.")
    if data["choices"][0]["finish_reason"] == "length":
        raise RuntimeError("Generation limit reached; do not accept this result.")
    return data

messages = [{
    "role": "user",
    "content": "Use multiply to calculate 6 times 7, then report the result."
}]
first = chat(messages, "required")
assistant = first["choices"][0]["message"]
calls = assistant.get("tool_calls") or []
if not calls:
    raise RuntimeError("Expected a tool call.")
messages.append(assistant)

for call in calls:
    function = call["function"]
    arguments = json.loads(function["arguments"])
    if function["name"] != "multiply":
        raise RuntimeError("Unexpected tool.")
    if not isinstance(arguments, dict) or set(arguments) != {"a", "b"}:
        raise RuntimeError("Unexpected arguments.")
    if any(type(arguments[key]) is not int for key in ("a", "b")):
        raise RuntimeError("Expected integer arguments.")
    result = arguments["a"] * arguments["b"]
    messages.append({
        "role": "tool",
        "tool_call_id": call["id"],
        "content": json.dumps({"result": result})
    })

final = chat(messages, "none")
choice = final["choices"][0]
answer = choice["message"].get("content") or ""
if choice["finish_reason"] != "stop" or not answer.strip():
    raise RuntimeError("Expected a completed final answer.")
print(answer)
print(json.dumps({"first": first["usage"], "final": final["usage"]}))
PY

Espere uma resposta final contendo 42, seguida pelos objetos de uso das duas requisições. O teste rejeita a ausência de chamadas de ferramentas, um modelo inesperado, argumentos inválidos, geração truncada e uma resposta final incompleta.

A operação central é messages.append(assistant). Ela preserva a mensagem completa retornada, incluindo reasoning_content e tool_calls. Depois, cada resultado de ferramenta usa o tool_call_id correspondente. Siga essa regra de preservação do histórico no armazenamento das conversas em produção.

O teste usa deliberadamente chamadas de ferramentas obrigatórias e proibidas para verificar as duas etapas. Em um ciclo normal de agente, use auto quando o modelo deve decidir se precisa chamar outra ferramenta.

Se a requisição falhar, use a referência de erros para escolher a próxima verificação:

Para 401, confira a plataforma da chave e o endpoint, depois repita o mesmo teste.
Para 400 na aplicação existente, inspecione o JSON enviado em busca de configurações thinking do K2 ou alterações nos parâmetros fixos de amostragem.
Para 404, confira tanto o ID do modelo quanto o acesso da conta. O código não comprova um erro de digitação.
Para finish_reason="length", trate a resposta como incompleta. Ajuste a tarefa, o esforço ou o limite de geração antes de aceitá-la.

Em 2026-11-05, a BetterToken também lista kimi-k3.1-pro. Sua API compatível com OpenAI usa https://www.bettertoken.ai/v1 com sua própria chave de API da BetterToken. Confira os preços atuais e as regras de requisição separadamente; as regras de cache da Moonshot não determinam o comportamento desse gateway.

Atualize OpenCode e Claude Code

Altere todas as rotas que podem selecionar K2, incluindo tarefas em segundo plano e subagentes. Uma conversa principal bem-sucedida não valida essas rotas.

OpenCode: selecione o provedor Moonshot

Use o provedor integrado Moonshot AI e atualize o catálogo de modelos. Seu ID é moonshotai, e ele lê a chave de MOONSHOT_API_KEY.

Os comandos a seguir usam a interface do OpenCode v1.19.5. Execute-os na mesma sessão do Bash:

opencode models moonshotai --refresh
opencode run --model moonshotai/kimi-k3.1-pro --variant high \
  "Inspect the current project and identify the test command. Do not edit files."

A lista atualizada deve conter moonshotai/kimi-k3.1-pro. A execução deve retornar uma resposta específica sobre seu projeto usando esse provedor e modelo. Se o modelo não aparecer, confira a versão instalada do cliente e a atualização do catálogo antes de prosseguir.

A referência do CLI documenta as duas opções. Para manter a seleção, defina "model": "moonshotai/kimi-k3.1-pro" no opencode.json do projeto ou no arquivo global ~/.config/opencode/opencode.json. Siga as regras de precedência da configuração quando ambos existirem.

O comando define high para essa execução. Em uma sessão interativa, selecione o esforço com /variants antes de enviar o primeiro prompt. Se também atualizar o cliente, confira as mudanças de permissões do OpenCode 2 antes de permitir alterações no repositório.

Claude Code: atualize todos os aliases de modelo

A Moonshot documenta um caminho compatível com Claude Code. A documentação de gateways da Anthropic informa que não dá suporte ao roteamento do Claude Code para modelos de outros fornecedores. Trate essa conexão como o caminho do adaptador da Moonshot e valide-a com seu cliente instalado.

Primeiro, inspecione ~/.claude/settings.json e as configurações do projeto. Revise valores antigos de endpoint, credenciais, modelo e esforço nos blocos env. A Moonshot alerta que variáveis definidas no arquivo de configuração podem sobrescrever as exportadas no terminal.

O exemplo atual ainda mapeia Haiku para kimi-k2.7-code. A configuração Bash abaixo propõe direcionar todos os níveis listados para o modelo de destino:

unset ANTHROPIC_API_KEY
export ANTHROPIC_BASE_URL="https://api.moonshot.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="$MOONSHOT_API_KEY"
export ANTHROPIC_MODEL="kimi-k3.1-pro"
export ANTHROPIC_DEFAULT_OPUS_MODEL="$ANTHROPIC_MODEL"
export ANTHROPIC_DEFAULT_SONNET_MODEL="$ANTHROPIC_MODEL"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="$ANTHROPIC_MODEL"
export ANTHROPIC_DEFAULT_FABLE_MODEL="$ANTHROPIC_MODEL"
export CLAUDE_CODE_SUBAGENT_MODEL="$ANTHROPIC_MODEL"
export CLAUDE_CODE_EFFORT_LEVEL="high"

claude --model kimi-k3.1-pro

Isso reutiliza a chave exportada para o teste da API. Verifique se restam configurações antigas do K2, incluindo ANTHROPIC_SMALL_FAST_MODEL.

Execute /status e confira a URL base e o modelo. Depois, solicite uma resposta simples e uma tarefa que leia um arquivo local. Confirme o esforço efetivo nos controles de configuração do modelo.

O Claude Code usa o protocolo Messages. Separe estes campos de Kimi Messages dos campos de Chat Completions:

Finalidade	Chat Completions	Kimi Messages
Esforço de raciocínio	`reasoning_effort`	`output_config.effort`
Limite de geração	`max_completion_tokens`	Campo obrigatório `max_tokens`
Duração do cache	`prompt_cache_options.ttl`	`cache_control.ttl` no objeto de nível superior

Não renomeie o campo max_tokens de Messages porque a versão de Chat Completions está obsoleta.

Confira os custos do cache sem contar tokens duas vezes

Separe a entrada em leituras do cache, gravações no cache e entrada sem cache. O K3.1 Pro cobra as gravações no cache separadamente. Inclua essas cobranças no cálculo de custos.

Para Chat Completions, leia:

Entrada total: usage.prompt_tokens.
Leituras do cache: usage.prompt_tokens_details.cached_tokens.
Gravações no cache: usage.prompt_tokens_details.cache_write_tokens.
Saída total: usage.completion_tokens.

Pelas regras de contabilização da API, as três categorias de entrada não se sobrepõem. A saída já inclui os tokens de raciocínio e da resposta.

Use tarifas na mesma moeda por 1,000,000 tokens:

uncached = prompt_tokens - cached_tokens - cache_write_tokens

token_cost = (
    uncached * miss_rate
    + cached_tokens * hit_rate
    + write_5m * write_5m_rate
    + write_1h * write_1h_rate
    + completion_tokens * output_rate
) / 1_000_000

Neste cálculo, write_5m + write_1h deve ser igual a cache_write_tokens. Obtenha as tarifas na página de preços atuais do provedor. O cálculo estima a cobrança por tokens; confira o resultado com a fatura.

A Kimi usa automaticamente o cache de 5m quando você omite as opções de cache. Para requisições separadas por intervalos maiores, avalie "prompt_cache_options": {"mode": "implicit", "ttl": "1h"}.

O guia de cache especifica que uma entrada existente mantém sua duração original. Enviar 1h não altera a duração de uma entrada ativa de 5m. Capture os cabeçalhos de resposta Msh-Usage-Cache-Write-Tokens-5m e Msh-Usage-Cache-Write-Tokens-1h para identificar as quantidades efetivamente gravadas em cada faixa.

Teste requisições repetidas com um prefixo representativo e inalterado. O teste aritmético pode ser pequeno demais para demonstrar um efeito útil do cache, pois blocos parciais não são gravados. Mantenha o esforço de raciocínio constante durante o teste: alterá-lo invalida os acertos no cache do prefixo.

Em aplicações com respostas em streaming, defina também stream_options.include_usage=true. Siga o guia de streaming para reunir fragmentos de raciocínio, resposta e chamadas de ferramentas. Leia o fragmento final com os dados de uso mesmo quando o array choices estiver vazio.

Defina verificações de regressão antes da troca

Encaminhe uma pequena parte do tráfego somente depois que a nova rota passar nos seus testes de aceitação existentes.

Use a mesma revisão do repositório, os mesmos prompts, definições de ferramentas e comandos de teste em cada comparação. Execute low, high e max em sessões separadas. Registre a qualidade do resultado, o tempo até a resposta completa e as categorias de tokens de entrada. Anote também a saída total, as novas tentativas e o custo cobrado.

Inclua estes cenários nas verificações de regressão:

Uma tarefa com várias interações que depende de uma resposta anterior do assistente.
Uma chamada de ferramenta seguida por outra resposta do modelo.
Uma chamada de ferramenta em streaming com argumentos JSON fragmentados.
Uma tarefa próxima do limite de geração configurado.
Tarefas em segundo plano ou subagentes que possam continuar usando um alias do K2.

Escolha o menor esforço que atenda aos seus requisitos de qualidade e latência. Se high falhar em uma tarefa importante que max conclui consistentemente nos seus testes, mantenha max para essa classe de tarefas.

Mantenha a opção de voltar ao K2 apenas enquanto sua conta ainda tiver acesso. Antes da janela de descontinuação, teste uma rota alternativa que não dependa do K2. Remova IDs antigos do K2 das tarefas agendadas, das rotas de novas tentativas e da configuração dos agentes.