Como usar a API Kimi K2 Thinking — um guia prático

Kimi K2 Thinking é a mais recente variante de raciocínio agentivo da família Kimi K2: um modelo amplo, com uma mistura de especialistas (MoE), otimizado para realizar raciocínio sustentado e passo a passo, além de invocar ferramentas externas de forma confiável em fluxos de trabalho longos e com várias etapas. Neste guia, reúno as informações públicas mais recentes, explico o que é o Kimi K2 Thinking, como ele se compara aos principais modelos contemporâneos (GPT-5 e Claude Sonnet 4.5), como a API funciona, a configuração passo a passo e um exemplo de tarefa de raciocínio executável, considerações sobre preços e as melhores práticas recomendadas para produção — com exemplos de código para que você possa começar imediatamente.

O que Kimi K2 está pensando e por que isso está nas manchetes?

Alguem Pensamento K2 é o lançamento mais recente de "agente pensante" da Moonshot AI — um membro da família de especialistas (MoE) com um trilhão de parâmetros, explicitamente treinado e configurado para executar raciocínio de longo prazo e em várias etapas enquanto chama ferramentas externas de forma autônoma (busca, execução de Python, web scraping, etc.). O lançamento (anunciado no início de novembro de 2025) chamou a atenção por três motivos: (1) é de código aberto e com licença aberta (uma licença no estilo "MIT modificada"), (2) suporta contextos extremamente longos (janela de contexto de 256 mil tokens) e (3) demonstra melhorias significativas. agente Desempenho em benchmarks habilitados por ferramentas em comparação com vários modelos de ponta de código fechado líderes de mercado.

API de pensamento Kimi K2 O ecossistema oferece suporte à semântica de conclusão de bate-papo no estilo OpenAI, além de saídas estruturadas explícitas e padrões de invocação de ferramentas. Você envia um histórico de bate-papo + esquema da ferramenta; o modelo responde com uma representação da linha de raciocínio (se solicitado) e pode gerar JSON estruturado que aciona ferramentas externas. Os provedores expõem a capacidade de transmitir tokens e retornar tanto o texto visível para humanos quanto um bloco de invocação de ferramenta analisável por máquina. Isso permite a implementação de loops de agentes: modelo → ferramenta → observação → modelo.

Em termos simples: o K2 Thinking foi projetado não apenas para produzir uma resposta imediata a uma pergunta, mas para pensar em voz altaPlanejar, recorrer a ferramentas quando necessário, inspecionar resultados e iterar — ao longo de centenas de etapas, se preciso — sem perda de qualidade. Essa capacidade é o que a Moonshot chama de “agência estável de longo prazo”.

Quais são as principais características do Kimi K2 Thinking?

Características principais do modelo

• Arquitetura de mistura de especialistas (MoE) com aproximadamente 1 trilhão de parâmetros (32 bilhões ativados por passagem direta em configurações comuns).
• Janela de contexto de token de 256k Para lidar com documentos muito longos, pesquisas com múltiplas fontes e extensas cadeias de raciocínio.
• Quantização INT4 nativa / treinamento com reconhecimento de quantização, possibilitando grandes reduções na memória de inferência e ganhos de velocidade significativos em comparação com pesos de tamanho padrão.
• Chamada de ferramenta integrada e uma API que aceita uma lista de funções/ferramentas; o modelo decidirá autonomamente quando chamá-las e iterará sobre os resultados.

O que isso possibilita na prática

• Raciocínio profundo e passo a passo (saídas no estilo de cadeia de raciocínio que podem ser apresentadas ao solicitante como "conteúdo de raciocínio" separado).
• Fluxos de trabalho de agentes estáveis ​​em várias etapasO modelo consegue manter a coerência de objetivos em todas as situações. 200 a 300 chamadas de ferramentas sequenciais, um salto notável em relação aos modelos mais antigos que tendem a desviar após algumas dezenas de passos.
• Pesos abertos + API gerenciadaVocê pode executá-lo localmente se tiver o hardware necessário ou chamá-lo via Moonshot/CometAPI utilizando uma interface de API compatível com OpenAI.

O Kimi K2 Thinking expõe o comportamento agentivo por meio de dois mecanismos principais: (1) passar um ferramentas lista para que o modelo possa chamar funções e (2) o modelo emitindo tokens de raciocínio interno que a plataforma apresenta como texto (ou cadeias de pensamento estruturadas quando ativadas). Explicarei em detalhes com exemplos a seguir.

Como faço para usar a API Kimi K2 Thinking?

Pré-requisitos

1. Acesso à API / contaCrie uma conta na plataforma da Moonshot (platform.moonshot.ai) ou em um agregador de API compatível (CometAPI Oferece preços mais baixos que os preços oficiais. Após o cadastro, você pode criar uma chave de API no painel de controle.
2. Chave APIMantenha-o em segurança em variáveis ​​de ambiente ou em seu armazenamento secreto.
3. Bibliotecas clienteVocê pode usar o protocolo HTTP padrão (curl) ou os SDKs compatíveis com a OpenAI. A documentação da plataforma Moonshot fornece exemplos diretos. Configure seu ambiente Python. Você precisará do SDK Python da OpenAI, que é compatível com o... CometAPI API, pois ambas mantêm compatibilidade com OpenAI.

Se você precisar de hospedagem local/privadaHardware (GPU/cluster) que suporte MoE e INT4 — a Moonshot recomenda vLLM, SGLang e outros mecanismos de inferência para implantações em produção. Os pesos do modelo estão disponíveis no Hugging Face para hospedagem própria — muitas equipes preferem a API hospedada devido ao tamanho do modelo.

Fluxo de chamadas mínimo (alto nível)

1. Criar uma solicitação de bate-papo (mensagens do sistema + mensagens do usuário).
2. Incluir opcionalmente tools (uma matriz JSON descrevendo funções) para permitir que o modelo as chame autonomamente.
3. Envie a solicitação para o endpoint de chat/conclusões com o modelo definido para a variante K2 Thinking.
4. Transmita e/ou colete fragmentos de resposta e monte ambos. reasoning_content e o conteúdo final.
5. Quando o modelo solicitar uma chamada de ferramenta, execute a ferramenta do seu lado, retorne o resultado como uma mensagem subsequente (ou através do protocolo de retorno de função do provedor) e deixe o modelo continuar.

O parâmetro “reasoning_content” está exposto na API?

Sim. O Kimi K2 Thinking retorna explicitamente um campo de saída auxiliar (comumente chamado de output). reasoning_content) que contém o rastreamento intermediário do raciocínio do modelo. Os provedores e a documentação da comunidade mostram padrões de streaming que emitem reasoning_content deltas separadamente de content deltas — o que possibilita apresentar um fluxo de "raciocínio" legível para humanos enquanto uma resposta final está sendo composta. Observação: o streaming é recomendado para grandes registros de raciocínio, pois o tamanho da resposta aumenta.

cURL — primeiro, uma conclusão mínima de bate-papo, ：

curl -X POST "https://api.cometapi.com/v1/chat/completions" \
  -H "Authorization: Bearer $cometapi_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2-thinking",
    "messages": [
      {"role":"system","content":"You are a careful reasoning assistant. Show step-by-step reasoning."},
      {"role":"user","content":"Outline a 5-step experiment to validate a micro-SaaS idea with $200 budget."}
    ],
    "temperature": 0.2,
    "max_tokens": 2048,
    "stream": false
  }'

Isso retorna content e (para modelos de pensamento) um reasoning_content campo que você pode armazenar ou transmitir

Parâmetros recomendados para o modo de reflexão

A seguir, apresentamos os parâmetros iniciais recomendados para tarefas de raciocínio com várias etapas. Ajuste-os de acordo com a sua tarefa:

• model: escolha a variante K2 Thinking (moonshotai/Kimi-K2-Thinking or kimi-k2-thinking-turbo) — a família “Pensando” expõe reasoning_content.
• Os cartões do modelo de pensamento Kimi-K2 sugerem temperature = 1.0 Como base recomendada para uma exploração mais rica durante o raciocínio, utilize temperaturas mais altas para tarefas exploratórias e mais baixas para tarefas que exigem precisão.
• Número máximo de tokens/contexto: Os modelos de pensamento podem produzir grandes rastros internos — conjunto max_tokens Tenho nível suficiente e prefiro streaming.
• Transmissão: ativar streaming (stream=True) para apresentar tanto o raciocínio quanto o conteúdo final de forma progressiva.
• Esquema da ferramenta: incluir um tools/functions array descrevendo as funções disponíveis; o K2 decidirá autonomamente quando chamá-las. Forneça informações claras. description e esquemas JSON rigorosos para argumentos, a fim de evitar chamadas ambíguas.

Como faço para habilitar e usar a chamada de ferramentas com o K2 Thinking?

Inclua um tools matriz no corpo da requisição. Cada ferramenta é descrita por:

• name: string, identificador único da ferramenta.
• descriptionBreve explicação do modelo.
• parametersEsquema JSON detalhando os argumentos esperados.

Quando o modelo decide chamar uma ferramenta, ele emite um objeto de invocação de ferramenta (geralmente como um token estruturado). Seu ambiente de execução deve executar essa ferramenta (no servidor), capturar a saída e enviá-la de volta como uma mensagem de resposta da ferramenta para que o modelo possa continuar o raciocínio.

Guia passo a passo

O K2 Thinking oferece suporte a um esquema de função/ferramenta semelhante à chamada de função do OpenAI, mas com suporte explícito para repetição até que o modelo termine (ele pode solicitar várias chamadas de ferramenta). O padrão é:

1. Defina os esquemas das ferramentas (nome, descrição, esquema JSON dos parâmetros).
2. Passar tools para a chamada de conclusão do chat.
3. Em cada resposta que contém tool_calls, execute a(s) ferramenta(s) solicitada(s) e anexe as saídas da ferramenta de volta às mensagens como role: "tool".
4. Repita até que o modelo retorne uma conclusão normal.

Habilitar invocação de ferramenta (padrão de exemplo)

Quando você quiser que o modelo chame ferramentas, forneça os esquemas das ferramentas na solicitação, por exemplo, web_search, code_executor, inclua-os na solicitação e instrua o modelo sobre como usá-los.

{
  "model": "kimi-k2-thinking",
  "messages": [{"role":"system","content":"You can call available tools when needed. Return a JSON tool call when you want to invoke external code."},
               {"role":"user","content":"Find the latest CPU microarchitecture benchmarks for RISC-V and summarize differences."}],
  "tools": [
    {
      "name": "web_search",
      "description": "Performs a web query and returns top results as JSON",
      "input_schema": {"type":"object","properties":{"q":{"type":"string"}}}
    }
  ],
  "temperature": 0.1
}

O modelo pode responder com um tool_call objeto que o ambiente de execução do seu agente deve detectar e encaminhar para a ferramenta registrada.

Esse padrão suporta sequências arbitrariamente profundas de invocação de ferramenta → execução de ferramenta → continuação do modelo, e é por isso que o Kimi K2 Thinking enfatiza a estabilidade em detrimento de muitas chamadas sequenciais em seu projeto.

Qual o custo da API Kimi K2 Thinking?

A plataforma oficial Moonshot (Kimi) lista dois pontos finais principais com preços definidos Para Kimi K2 Pensando:

• kimi-k2-pensando (padrão) - tokens de entrada: $ 0.60 / 1 milhão (nível de falha de cache) e $ 0.15 / 1 milhão (nível de acerto de cache); tokens de saída: $ 2.50 / 1 milhão.
• kimi-k2-pensando-turbo (alta velocidade) — Nível de latência/taxa de transferência mais alto: entrada: $ 1.15 / 1 milhão; saída: $ 8.00 / 1 milhão (As páginas da plataforma/parceiros repetem isso).

CometAPI Possui vantagens em termos de preço, como: taxa de entrada muito baixa e uma taxa de token por saída menor do que modelos sofisticados comparáveis ​​— além de tokens de teste gratuitos para integração:

Considerações de custo

• Contextos longos (128 mil a 256 mil tokens) e extensas cadeias de chamadas de ferramentas multiplicam o consumo de tokens, portanto, projete instruções e interações com ferramentas para minimizar intermediários verbosos quando o custo for importante.
• Executar fluxos de agentes que produzem muitos resultados de ferramentas pode aumentar os gastos com tokens de saída mais do que um chat típico de turno único. Monitore e ajuste seu orçamento de acordo.

Comparação de benchmarks: Kimi K2 Thinking vs GPT-5 vs Claude Sonnet 4.5

Os indicadores de desempenho que acompanham o estudo revelam um panorama mais complexo: K2 Thinking supera GPT-5 e Claude Sonnet 4.5 da Anthropic em muitos habilitado para ferramentas e benchmarks de agentes (por exemplo, BrowseComp e variantes HLE habilitadas para ferramentas), enquanto o GPT-5 permanece mais forte em alguns benchmarks somente de texto ou médicos (por exemplo, HealthBench nas execuções relatadas do Moonshot).

Leve em conta: Kimi K2 Pensar é competitivo agente modelo — ele se destaca em tarefas de raciocínio que se beneficiam da intercalação de ferramentas e de contextos longos. Ele não supera uniformemente o GPT-5 e Soneto de Claude 4.5 Em todos os testes de benchmark (especialmente em algumas tarefas especializadas ou que exigem muito conhecimento), mas em muitos dos testes de comportamento ativo/navegação/longo prazo, apresenta resultados excelentes. No entanto, o baixo custo de chamadas e a natureza de código aberto do Kimi k2 thinking o tornam um verdadeiro rei da relação custo-benefício.

Quando escolher o Kimi K2 Thinking em vez de outros modelos?

• Escolha Kimi K2 Pensando Quando sua tarefa exige longas cadeias de raciocínio, muitas chamadas de ferramentas ou análises profundas de contextos muito grandes (bases de código, documentação extensa).
• Escolha GPT-5 Quando você precisa da integração multimodal mais completa, amplo suporte do ecossistema de terceiros ou ferramentas e estruturas de agentes específicos da OpenAI.
• Escolha Claude Soneto 4.5 Para cargas de trabalho que enfatizam a precisão na edição de código, fluxos de trabalho de edição determinísticos e o conjunto de ferramentas de segurança da Anthropic.

Melhores práticas

• Raciocínio de fluxoPara aplicativos voltados para o usuário, mostre uma interface de usuário "pensante" usando streaming. reasoning_contentO streaming reduz a latência e evita cargas úteis enormes. ()
• Ferramentas que priorizam o esquemaDefinir esquemas JSON rigorosos para ferramentas, a fim de reduzir chamadas ambíguas e erros de análise.
• Uso do contexto do ponto de verificação: manter os registros de raciocínio anteriores em um armazenamento de memória de longo prazo separado, em vez de incorporar um histórico enorme de registros no prompt ativo; usar a recuperação para reintroduzir apenas os segmentos relevantes.
• Monitoramento e guarda-corpos: registrar ambos reasoning_content e final content Para diagnosticar desvios, alucinações e uso indevido. Considere a redação ou o consentimento do usuário, dependendo da sensibilidade do caso.

Conclusão

Kimi K2 Thinking representa uma grande evolução da linha K2 em direção a uma capacidade de ação robusta e de longo prazo. A API é intencionalmente compatível com os padrões de cliente OpenAI/Anthropic e oferece um caminho prático para integrar o raciocínio agencial em aplicativos, ao mesmo tempo que permite aos desenvolvedores controlar a interface de chamada da ferramenta.

Se você quiser experimentar rapidamente, use API de pensamento Kimi K2 e comece a usar! Para começar, explore as funcionalidades do modelo em Playground e consulte o Guia de API para obter instruções detalhadas. Antes de acessar, certifique-se de ter feito login no CometAPI e obtido a chave da API. CometAPI oferecem um preço muito mais baixo que o preço oficial para ajudar você a se integrar.

Pronto para ir?→ Inscreva-se no CometAPI hoje mesmo !

Se você quiser saber mais dicas, guias e novidades sobre IA, siga-nos em VK, X e  Discord!