O Kimi K2.7 Code está disponível na Novita AI com o ID do modelo moonshotai/kimi-k2.7-code, endpoint chat/completions compatível com OpenAI, janela de contexto de 262.144 tokens e suporte a entradas de texto, imagem e vídeo. Este guia rápido aborda a configuração para desenvolvedores: autentique-se, envie sua primeira solicitação, use entrada de visão, adicione chamada de função e entenda os preços antes de começar a desenvolver. Para uma visão mais ampla sobre posicionamento e casos de uso, consulte a Visão geral do Kimi K2.7 Code na Novita AI. Para conectar o Kimi K2.7 Code ao Claude Code via endpoint compatível com Anthropic, consulte Como usar o Kimi K2.7 Code no Claude Code.
Configuração da API do Kimi K2.7 Code
Comece com três itens de configuração:
| Item | Valor |
|---|---|
| Chave da API | Crie e armazene uma chave de API da Novita AI em uma variável de ambiente, como NOVITA_API_KEY. |
| URL base compatível com OpenAI | https://api.novita.ai/openai |
| Endpoint de chat completions | POST https://api.novita.ai/openai/v1/chat/completions |
| ID do modelo | moonshotai/kimi-k2.7-code |
O índice de documentação da Novita AI lista a URL base compatível com OpenAI, e a referência da API de chat completions documenta todos os campos de solicitação e resposta.
Mantenha a chave da API fora do controle de versão. Exporte-a no seu shell para desenvolvimento local:
export NOVITA_API_KEY="your_api_key"
Se sua aplicação já usa o SDK da OpenAI, a mudança é mínima: aponte a URL base para a Novita AI e defina o modelo como moonshotai/kimi-k2.7-code.
Preços e Limites do Kimi K2.7 Code
Use o ID exato do modelo no código. Na interface voltada ao usuário, use o nome de exibição “Kimi K2.7 Code”.
| Campo | Valor atual da Novita |
|---|---|
| Nome de exibição | Kimi K2.7 Code |
| ID do modelo na API | moonshotai/kimi-k2.7-code |
| Série do modelo | MoonshotAI |
| Arquitetura | MoE, 1T de parâmetros no total, 32B ativados |
| Famílias de endpoints | chat/completions, anthropic |
| Modalidades de entrada | Texto, imagem, vídeo |
| Modalidade de saída | Texto |
| Janela de contexto | 262.144 tokens |
| Máximo de tokens de saída | 262.144 tokens |
| Recursos | Chamada de função, saídas estruturadas, raciocínio |
Em 16 de junho de 2026, a Novita lista os seguintes preços de tokens para moonshotai/kimi-k2.7-code:
| Tipo de token | Preço listado |
|---|---|
| Tokens de entrada | US$ 0,95 por 1M de tokens |
| Tokens de saída | US$ 4,00 por 1M de tokens |
| Tokens de entrada lidos do cache | US$ 0,19 por 1M de tokens |
Preços, disponibilidade e limites de taxa podem mudar. Consulte a página do modelo Kimi K2.7 Code e a página de preços da Novita AI antes do lançamento em produção ou de qualquer compromisso de custo.
Exemplo de cURL do Kimi K2.7 Code
Comece com uma solicitação somente de texto para confirmar autenticação, roteamento do modelo e análise da resposta antes de adicionar visão ou chamadas de ferramenta.
curl "https://api.novita.ai/openai/v1/chat/completions" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${NOVITA_API_KEY}" \
-d '{
"model": "moonshotai/kimi-k2.7-code",
"messages": [
{
"role": "system",
"content": "You are a concise code review assistant."
},
{
"role": "user",
"content": "List three common mistakes when implementing retry logic in Python."
}
],
"max_tokens": 512,
"temperature": 0.2
}'
Uma resposta bem-sucedida retorna o formato padrão de chat completions: um array choices, uma mensagem com content, metadados de model/created e um objeto usage com contagens de tokens de prompt, conclusão e total.
Use este teste rápido para verificar:
- A chave da API é válida e o cabeçalho de autorização está formatado corretamente.
- O ID do modelo é aceito sem erro 404 ou modelo não encontrado.
- Seu cliente consegue analisar
choices[0].message.content. - O uso de tokens é registrado para que você possa monitorar o custo desde a primeira solicitação.
Exemplo em Python com Kimi K2.7 Code
O SDK Python da OpenAI funciona com a Novita AI quando você define a URL base da Novita. Fixe a versão do SDK de acordo com sua própria política de dependências.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/openai",
api_key=os.environ["NOVITA_API_KEY"],
)
response = client.chat.completions.create(
model="moonshotai/kimi-k2.7-code",
messages=[
{"role": "system", "content": "You are a concise code review assistant."},
{
"role": "user",
"content": "Review this Python function for off-by-one errors and missing edge cases:\n\ndef get_items(lst, start, end):\n return lst[start:end]",
},
],
max_tokens=512,
temperature=0.2,
)
print(response.choices[0].message.content)
print("Tokens used:", response.usage.total_tokens)
Para sessões longas de agente de codificação, defina max_tokens explicitamente. O Kimi K2.7 Code suporta até 262.144 tokens de saída, mas agentes em produção devem orçar o uso de tokens por turno e monitorar o custo acumulado em execuções de várias etapas.
Entrada de Imagem e Vídeo
A Novita lista texto, imagem e vídeo como modalidades de entrada para o Kimi K2.7 Code. Para entrada de visão, passe um array content na mensagem do usuário com uma parte text e uma parte image_url:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/openai",
api_key=os.environ["NOVITA_API_KEY"],
)
response = client.chat.completions.create(
model="moonshotai/kimi-k2.7-code",
messages=[
{"role": "system", "content": "You are a UI code review assistant."},
{
"role": "user",
"content": [
{
"type": "text",
"text": "Describe any accessibility issues visible in this UI screenshot and suggest CSS fixes.",
},
{
"type": "image_url",
"image_url": {"url": "https://example.com/screenshot.png"},
},
],
},
],
max_tokens=512,
)
print(response.choices[0].message.content)
Uma ordem prática para integração multimodal:
- Confirme primeiro que o teste somente de texto funciona.
- Adicione uma entrada de imagem com uma tarefa claramente verificável, como extrair rótulos de uma captura de tela de interface.
- Valide a qualidade e o formato da resposta para sua carga de trabalho real.
- Teste entradas de vídeo separadamente — comece com clipes curtos, verifique o formato da solicitação e meça latência e custos de tokens antes de adicionar vídeo a um caminho de produção.
Não presuma que todos os payloads multimodais compatíveis com OpenAI sejam aceitos de forma idêntica por todos os modelos hospedados na Novita. Verifique o formato exato do payload de imagem e vídeo na documentação atual da Novita AI ou nos exemplos do console para moonshotai/kimi-k2.7-code antes do lançamento.
Chamada de Função e Saídas Estruturadas
O Kimi K2.7 Code suporta chamada de função por meio do parâmetro tools e saídas estruturadas por meio de response_format. Ambos estão listados como recursos na página do modelo da Novita AI.
Use chamada de função quando o modelo deve selecionar uma ferramenta e retornar argumentos estruturados em vez de responder em prosa:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/openai",
api_key=os.environ["NOVITA_API_KEY"],
)
tools = [
{
"type": "function",
"function": {
"name": "file_search",
"description": "Search the repository for files matching a pattern.",
"parameters": {
"type": "object",
"properties": {
"pattern": {
"type": "string",
"description": "Glob pattern to match, e.g. '**/*.py'",
},
"directory": {
"type": "string",
"description": "Root directory to search within.",
},
},
"required": ["pattern"],
},
},
}
]
response = client.chat.completions.create(
model="moonshotai/kimi-k2.7-code",
messages=[
{"role": "system", "content": "You are a repository analysis assistant."},
{
"role": "user",
"content": "Find all Python files in the src directory that might contain database migration logic.",
},
],
tools=tools,
tool_choice="auto",
temperature=0.1,
)
message = response.choices[0].message
if message.tool_calls:
for call in message.tool_calls:
print(f"Tool: {call.function.name}")
print(f"Arguments: {call.function.arguments}")
else:
print(message.content)
Para saídas estruturadas, use response_format com json_schema quando precisar de uma resposta JSON validada sem chamada de ferramenta. Mantenha os primeiros schemas pequenos e teste seu parser com o formato exato de resposta retornado por moonshotai/kimi-k2.7-code antes de confiar no modo estrito em produção.
A arquitetura de raciocínio intercalado do Kimi K2.7 Code significa que ele raciocina por tarefas de várias etapas antes de retornar um resultado. Para fluxos de trabalho de codificação agênticos com várias chamadas de ferramenta por turno, teste como a escolha da ferramenta, a qualidade dos argumentos e a latência da resposta se comportam no seu conjunto real de tarefas antes de direcionar tráfego de produção.
Checklist de Testes em Produção
O Kimi K2.7 Code tem preços separados para tokens de entrada, saída e leitura de cache. Os perfis de custo variam significativamente por carga de trabalho:
- Revisão de código com contexto longo: grandes contagens de tokens de entrada dominam o custo.
- Agentes de geração de código: o uso de tokens de saída escala com o tamanho da resposta e o número de turnos.
- Fluxos de trabalho com contexto repetido: o preço de leitura de cache se aplica quando um prompt de sistema estável, schema de ferramenta ou resumo de repositório se repete em muitas chamadas.
Antes da produção, execute um conjunto de avaliação que inclua:
- Prompts curtos somente de texto (linha de base de latência e verificação de autenticação).
- Prompts de contexto longo próximos ao seu tamanho esperado de trabalho, não à janela máxima.
- Prompts de chamada de ferramenta em que o comportamento correto é chamar uma função com argumentos válidos.
- Entradas de imagem que correspondam à sua fonte real de upload e ao tratamento de arquivos.
- Casos de falha: entrada acima do limite, URL de mídia ausente, chave de API inválida e comportamento de timeout.
Listas de recursos descrevem o que está disponível. A avaliação na sua carga de trabalho real indica se latência, uso de tokens, qualidade dos argumentos da ferramenta e corretude da saída atendem ao seu padrão de produção.
Perguntas Frequentes
O Kimi K2.7 Code está disponível por meio da Novita AI?
Sim. A Novita AI lista o Kimi K2.7 Code como um LLM Serverless com o ID do modelo na API moonshotai/kimi-k2.7-code.
Qual é o ID correto do modelo?
Use moonshotai/kimi-k2.7-code em todas as chamadas de API.
Qual endpoint devo usar?
Use o endpoint de chat completions compatível com OpenAI: POST https://api.novita.ai/openai/v1/chat/completions. Defina a URL base como https://api.novita.ai/openai ao usar um cliente do SDK da OpenAI.
Quanto custa o Kimi K2.7 Code?
Em 16 de junho de 2026, a Novita AI lista US$ 0,95 por 1M de tokens de entrada, US$ 4,00 por 1M de tokens de saída e US$ 0,19 por 1M de tokens de entrada lidos do cache. Verifique os preços atuais na página do modelo Kimi K2.7 Code antes de qualquer decisão de compra.
Ele suporta entrada de imagem e vídeo?
A Novita lista texto, imagem e vídeo como modalidades de entrada. Para o formato exato do payload, verifique na documentação atual da Novita ou com uma chamada de teste antes de lançar recursos multimodais.
O Kimi K2.7 Code suporta chamada de função?
Sim. Use o parâmetro tools na solicitação de chat completions. A Novita lista chamada de função e saídas estruturadas como recursos suportados.
Qual é a janela de contexto?
Janela de contexto de 262.144 tokens e máximo de saída de 262.144 tokens, conforme listado na página do modelo da Novita AI.
