DEV Community

Cover image for Como Usar a API Kimi K2.6: Tutorial Completo
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Usar a API Kimi K2.6: Tutorial Completo

O anúncio do Kimi K2.6 da Moonshot AI posiciona esse modelo como o novo topo de código aberto para codificação, execução de longo prazo e enxames de agentes. A API é compatível com OpenAI, hospedada em https://api.moonshot.ai/v1 e possui documentação na plataforma. Com o SDK OpenAI instalado, você envia requisições reais em minutos.

Experimente o Apidog hoje

Este guia prático cobre autenticação, primeira requisição, streaming, chamada de ferramentas, entrada de visão e vídeo, modo de pensamento, execução de Enxame de Agentes (Agent Swarm) com até 300 sub-agentes e como testar cada endpoint com o Apidog antes de integrar no código.

💡 Caminho rápido: Teste a API Kimi K2.6 visualmente no Apidog antes de codificar. Importe a especificação, adicione o token Bearer e faça requisições reais em streaming com histórico e validação de schema. Baixe o Apidog gratuitamente.

TL;DR: API Kimi K2.6 em 60 segundos

  • URL Base: https://api.moonshot.ai/v1
  • Endpoint: POST /chat/completions
  • IDs de Modelo: kimi-k2.6, kimi-k2.6-thinking
  • Autenticação: Authorization: Bearer $KIMI_API_KEY
  • Formato: Esquema de completações de chat do OpenAI (mensagens, ferramentas, stream, etc.)
  • Contexto: 262.144 tokens de entrada, até 98.304 tokens de saída para raciocínio
  • Padrões: temperatura 1.0, top-p 1.0 (orientação oficial)

Curl mínimo:

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "Write a Python function that reverses a string."}]
  }'
Enter fullscreen mode Exit fullscreen mode

O restante do guia detalha integrações avançadas, incluindo Agent Swarm e limites de execução.

Kimi K2.6

O que você pode realmente fazer com esta API

Segundo o anúncio oficial:

  • Agentes de codificação com execução superior a 12h em uma tarefa (ex: Qwen3.5-0.8B Mac: 4.000+ chamadas de ferramenta, throughput de 15→193 tokens/s).
  • Gerenciamento de infraestrutura autônoma em sessões de vários dias respondendo a incidentes.
  • Confiabilidade em Rust, Go, Python, Zig.
  • Enxames de até 300 sub-agentes coordenando mais de 4.000 passos.
  • Geração de apps full-stack a partir de um prompt (com autenticação e banco de dados).
  • Pipelines de Visão + Ferramentas Python (MathVision: 93,2%).

Construa ferramentas na categoria de uso de computador Claude Code, seu próprio Claude Code ou Cursor Composer 2 substituindo diretamente o modelo.

Passo 1: Obtenha uma chave de API

  1. Acesse platform.moonshot.ai ou platform.kimi.ai e crie sua conta (email ou Google OAuth).
  2. Verifique sua conta (internacionais: SMS).
  3. Adicione informações de cobrança (geralmente saldo gratuito inicial).
  4. No painel, abra API Keys e clique em Create Key.
  5. Copie a chave imediatamente.
  6. Exporte a variável: 
export KIMI_API_KEY="sk-..."
Enter fullscreen mode Exit fullscreen mode

Adicione ao .zshrc, .bashrc ou a um gerenciador de segredos. Nunca faça commit.

Durante o desenvolvimento, veja Como usar o Kimi K2.6 gratuitamente (Cloudflare Workers AI, pesos open-source, créditos).

Passo 2: Escolha seu SDK

A API aceita os SDKs OpenAI: basta alterar a URL base.

Opção Instalação Melhor para
curl embutido Testes rápidos, CI
OpenAI Python pip install openai Serviços Python
OpenAI Node npm install openai Apps JS/TS

Python 

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

print(response.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Node.js 

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

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

curl 

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'
Enter fullscreen mode Exit fullscreen mode

Todos retornam o mesmo formato de resposta.

Passo 3: Entenda o corpo da requisição

Use o mesmo schema de completações de chat do OpenAI:

{
  "model": "kimi-k2.6",
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    { "role": "user", "content": "Your prompt here." }
  ],
  "temperature": 1.0,
  "top_p": 1.0,
  "max_tokens": 8192,
  "stream": false,
  "tools": [],
  "tool_choice": "auto",
  "thinking": { "type": "disabled" }
}
Enter fullscreen mode Exit fullscreen mode

Observações Moonshot:

  • Padrões altos: Use temperatura 1.0 e top-p 1.0 (não transfira hábitos OpenAI de temp 0.2).
  • thinking: Ativa rastreamento do raciocínio em kimi-k2.6-thinking. Use {"type": "disabled"} para respostas rápidas.

Passo 4: Streaming

Para UIs ou tarefas longas, habilite stream. A saída pode chegar a 98.304 tokens.

Python 

stream = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Write a 500-word essay on MoE models."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
Enter fullscreen mode Exit fullscreen mode

Node.js 

const stream = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "Write a 500-word essay on MoE models." }],
  stream: true,
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}
Enter fullscreen mode Exit fullscreen mode

Funciona para chamadas de ferramentas; argumentos chegam como deltas JSON.

Passo 5: Chamada de Ferramentas

Kimi K2.6 usa o padrão OpenAI para função/tool calling.

Definir ferramentas (exemplo Python) 

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]
Enter fullscreen mode Exit fullscreen mode

Primeira chamada (modelo decide): 

import json

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

resp = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

msg = resp.choices[0].message
messages.append(msg)

if msg.tool_calls:
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = fetch_weather(args["location"], args.get("unit", "celsius"))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
Enter fullscreen mode Exit fullscreen mode

Segunda chamada (resposta final): 

final = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
)
print(final.choices[0].message.content)
Enter fullscreen mode Exit fullscreen mode

Para fluxos multi-passos, Kimi Code e fluxos Claude Code seguem o mesmo loop.

Passo 6: Entrada de Visão

Kimi aceita imagens no formato OpenAI image_url:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in one sentence."},
                {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Para arquivos locais (base64):

import base64
with open("photo.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")
image_url = f"data:image/jpeg;base64,{b64}"
Enter fullscreen mode Exit fullscreen mode

Para OCR ou diagramas, combine instrução clara + imagem. Para matemática, habilite interpretador Python.

Passo 7: Entrada de Vídeo

Envie URL de vídeo ou sequência de frames:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Summarize what happens in this video."},
                {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}}
            ]
        }
    ],
)
Enter fullscreen mode Exit fullscreen mode

Clipes <30s funcionam em uma chamada. Vídeos longos: use streaming.

Passo 8: Modo de Pensamento

kimi-k2.6-thinking retorna rastro de raciocínio (reasoning).

Pensamento ligado (padrão):

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Prove sqrt(2) is irrational."}],
)
Enter fullscreen mode Exit fullscreen mode

Pensamento desligado:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Quick: what's 17 * 23?"}],
    extra_body={"thinking": {"type": "disabled"}},
)
Enter fullscreen mode Exit fullscreen mode

O rastro pode ser ocultado do usuário final ou enviado para logs.

Passo 9: Enxame de Agentes (Agent Swarm)

Execute tarefas com até 300 sub-agentes e 4.000 passos:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": "Build a 5-page marketing site for a coffee brand with responsive design and a newsletter signup."
    }],
    extra_body={
        "agent": {
            "type": "swarm",
            "max_agents": 30,
            "max_steps": 4000
        }
    },
)
Enter fullscreen mode Exit fullscreen mode

Dicas práticas:

  1. Use streaming para monitorar progresso.
  2. Limite max_agents (10-30 é mais estável).
  3. Registre usage para controlar consumo de tokens.

O blog do Kimi mostra execuções de 4.000+ linhas de código em 13h. Só habilite para workloads que exigem persistência.

Passo 10: Teste tudo com Apidog

Cada endpoint pode ter um corpo/cabeçalho/resposta diferente. O Apidog transforma o ciclo de debug em um fluxo visual.

Apidog

Configuração do Kimi K2.6 no Apidog

  1. Baixe o Apidog e crie um projeto.
  2. Crie ambiente kimi-prod com:
    • BASE_URL = https://api.moonshot.ai/v1
    • KIMI_API_KEY = sk-...
  3. Nova requisição: POST {{BASE_URL}}/chat/completions
  4. Cabeçalhos:
    • Authorization: Bearer {{KIMI_API_KEY}}
    • Content-Type: application/json
  5. Corpo (exemplo streaming): 
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
Enter fullscreen mode Exit fullscreen mode
  1. Clique em Send para visualizar tokens em tempo real.

O que o Apidog adiciona

  • Validação de schema contra o OpenAI.
  • Histórico de requisições para fácil repetição/debug.
  • Alternância de ambiente (dev/staging/prod) instantânea.
  • Compartilhamento em equipe (veja para times de 50+).
  • Servidores mock para testes offline.
  • Suporte a stream SSE (diferencial frente a outras ferramentas).

Também disponível como extensão do VS Code. Se você usa Postman, veja como migrar.

Tratamento de erros sem dor de cabeça

Moonshot usa códigos HTTP padrão:

  • 400: requisição inválida (corpo malformado/modelo errado).
  • 401: autenticação falhou (chave ausente/expirada).
  • 429: limite de taxa/cota.
  • 500: erro do servidor (use backoff exponencial).
  • 529: sobrecarga (tente mais tarde).

Wrapper de retentativa Python:

import time
from openai import OpenAI, RateLimitError, APIError

def call_kimi(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="kimi-k2.6",
                messages=messages,
            )
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
    raise RuntimeError("Kimi K2.6 failed after retries")
Enter fullscreen mode Exit fullscreen mode

Para streams interrompidos, rastreie tokens recebidos e reinicie com "continue daqui". Streams longos são normais devido ao teto de 98.304 tokens.

Controle de custos

Moonshot publica preços em kimi.com/membership/pricing.

Dicas para produção:

  • Limite max_tokens ao necessário (ex: 2048 para chat).
  • Cache de prompts de sistema para economizar tokens.
  • Registre usage (prompt_tokens, completion_tokens, total_tokens) e envie para seu sistema de métricas.

Padrão de produção: resolvedor de issues do GitHub

Exemplo de agente que lê uma issue, busca código, propõe fix e executa testes:

from openai import OpenAI
import os, json

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

tools = [
    {"type": "function", "function": {
        "name": "read_file",
        "description": "Read a file in the repo.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
        }
    }},
    {"type": "function", "function": {
        "name": "search_code",
        "description": "Ripgrep the codebase for a pattern.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }},
    {"type": "function", "function": {
        "name": "run_tests",
        "description": "Run the project test suite.",
        "parameters": {"type": "object", "properties": {}}
    }},
]

def tool_dispatch(name, args):
    if name == "read_file":
        with open(args["path"]) as f:
            return f.read()
    if name == "search_code":
        return run_ripgrep(args["query"])
    if name == "run_tests":
        return run_pytest()
    raise ValueError(f"Unknown tool: {name}")

messages = [
    {"role": "system", "content": "You are a senior engineer. Fix the described bug."},
    {"role": "user", "content": "Issue: login form submits twice on slow networks."}
]

while True:
    resp = client.chat.completions.create(
        model="kimi-k2.6",
        messages=messages,
        tools=tools,
    )
    msg = resp.choices[0].message
    messages.append(msg)

    if not msg.tool_calls:
        print(msg.content)
        break

    for call in msg.tool_calls:
        result = tool_dispatch(call.function.name, json.loads(call.function.arguments))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })
Enter fullscreen mode Exit fullscreen mode

Para Enxame de Agentes, adicione extra_body de configuração. Se quiser checkpoints humanos, veja a pilha Hermes multi-agente.

FAQ

  • Preciso de SDK Moonshot? Não, use OpenAI Python/Node alterando base_url.
  • Limite de taxa? Sim, varia por nível/histórico. Veja no painel.
  • Funciona com LangChain, LlamaIndex, Vercel AI SDK? Sim, qualquer framework compatível com OpenAI.
  • Suporta modo JSON? Sim: response_format: {"type": "json_object"} ou schema estrito.
  • Tamanho da janela de contexto? 262.144 tokens de entrada, 98.304 de saída (blog oficial).
  • Fine-tuning via API? Ainda não. Use pesos open-source.
  • Diferença kimi-k2.6 vs kimi-k2.6-thinking? kimi-k2.6 é rápido, kimi-k2.6-thinking expõe raciocínio e é ajustado para lógica/plano complexo.
  • Nível gratuito? Veja o guia de acesso gratuito ao Kimi K2.6.

Resumo

A API Kimi K2.6 se integra a qualquer stack compatível com OpenAI: basta mudar a URL base e usar sua chave. Você recebe janela de contexto de 262K, Agent Swarm com 300 sub-agentes, chamada de ferramentas com 96,60% de sucesso e fallback open-source.

Ao começar uma integração, use o Apidog para validar endpoints e fluxos antes de codificar. Assim, você captura erros de schema, streaming e autenticação cedo e porta fluxos para Python ou Node.js com confiança.

Referências e leitura adicional

Top comments (0)