O Kimi K2.7 Code está disponível na Novita AI com o ID de modelo moonshotai/kimi-k2.7-code, um endpoint chat/completions compatível com OpenAI, uma janela de contexto de 262.144 tokens e suporte para entradas de texto, imagem e vídeo. Este início rápido cobre a configuração do desenvolvedor: autentique-se, envie sua primeira requisição, use entrada de visão, adicione chamada de funções e entenda os preços antes de construir. Para uma visão mais ampla sobre posicionamento e casos de uso, veja a visão geral do Kimi K2.7 Code na Novita AI.
Configuração da API Kimi K2.7 Code
Comece com três itens de configuração:
| Item | Valor |
|---|---|
| Chave de 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 os campos completos de requisição e resposta.
Mantenha a chave de API fora do controle de versão. Exporte-a no seu shell para desenvolvimento local:
export NOVITA_API_KEY="sua_chave_api"
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 do 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 parâmetros no total, 32B ativados |
| Famílias de endpoint | chat/completions, anthropic |
| Modalidades de entrada | Texto, imagem, vídeo |
| Modalidade de saída | Texto |
| Janela de contexto | 262.144 tokens |
| Máx. tokens de saída | 262.144 tokens |
| Funcionalidades | Chamada de funções, saídas estruturadas, raciocínio |
A partir de 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 | $0,95 por 1M de tokens |
| Tokens de saída | $4,00 por 1M de tokens |
| Tokens de entrada lidos do cache | $0,19 por 1M de tokens |
Preços, disponibilidade e limites de taxa podem mudar. Verifique 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 qualquer compromisso de custo.
Exemplo com cURL do Kimi K2.7 Code
Comece com uma requisição apenas de texto para confirmar autenticação, roteamento do modelo e análise da resposta antes de adicionar chamadas de visão ou ferramentas.
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": "Você é um assistente de revisão de código conciso."
},
{
"role": "user",
"content": "Liste três erros comuns ao implementar lógica de retry em Python."
}
],
"max_tokens": 512,
"temperature": 0.2
}'
Uma resposta bem-sucedida retorna a estrutura padrão de chat completions: um array choices, uma mensagem com content, metadados de modelo/created, e um objeto usage com contagens de tokens de prompt, completion e total.
Use este teste inicial para verificar:
- A chave de 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 requisição.
Exemplo em Python do 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": "Você é um assistente de revisão de código conciso."},
{
"role": "user",
"content": "Revise esta função Python para erros de off-by-one e casos extremos ausentes:\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 usados:", response.usage.total_tokens)
Para sessões longas de agentes de código, defina max_tokens explicitamente. O Kimi K2.7 Code suporta até 262.144 tokens de saída, mas agentes de 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": "Você é um assistente de revisão de código de UI."},
{
"role": "user",
"content": [
{
"type": "text",
"text": "Descreva quaisquer problemas de acessibilidade visíveis neste screenshot de UI e sugira correções CSS.",
},
{
"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:
- Primeiro confirme que o teste apenas de texto funciona.
- Adicione uma entrada de imagem com uma tarefa claramente verificável, como extrair rótulos de um screenshot de UI.
- Valide tanto a qualidade da resposta quanto a estrutura da resposta para sua carga de trabalho real.
- Teste entradas de vídeo separadamente — comece com clipes curtos, verifique o formato da requisição e meça a latência e os custos de token antes de adicionar vídeo a um caminho de produção.
Não assuma que toda carga útil multimodal compatível com OpenAI é aceita de forma idêntica por todo modelo hospedado na Novita. Verifique a forma exata da carga útil de imagem e vídeo na documentação atual da Novita AI ou exemplos do console para moonshotai/kimi-k2.7-code antes de lançar.
Chamada de Funções e Saídas Estruturadas
O Kimi K2.7 Code suporta chamada de funções através do parâmetro tools e saídas estruturadas através de response_format. Ambos são listados como funcionalidades na página do modelo da Novita AI.
Use chamada de funções 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": "Pesquisar no repositório por arquivos que correspondem a um padrão.",
"parameters": {
"type": "object",
"properties": {
"pattern": {
"type": "string",
"description": "Padrão glob para correspondência, ex. '**/*.py'",
},
"directory": {
"type": "string",
"description": "Diretório raiz para pesquisar.",
},
},
"required": ["pattern"],
},
},
}
]
response = client.chat.completions.create(
model="moonshotai/kimi-k2.7-code",
messages=[
{"role": "system", "content": "Você é um assistente de análise de repositório."},
{
"role": "user",
"content": "Encontre todos os arquivos Python no diretório src que possam conter lógica de migração de banco de dados.",
},
],
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"Ferramenta: {call.function.name}")
print(f"Argumentos: {call.function.arguments}")
else:
print(message.content)
Para saídas estruturadas, use response_format com json_schema quando você precisar de uma resposta JSON validada sem uma chamada de ferramenta. Mantenha os primeiros esquemas pequenos e teste seu analisador em relação à forma exata da resposta que moonshotai/kimi-k2.7-code retorna antes de confiar no modo estrito em produção.
A arquitetura de raciocínio intercalado do Kimi K2.7 Code significa que ele raciocina através de 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 de resposta se comportam em seu conjunto de tarefas real antes de rotear tráfego de produção.
Checklist de Testes em Produção
O Kimi K2.7 Code é precificado separadamente 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 de 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 comprimento 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, esquema 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 apenas de texto (linha de base de latência e verificação de autenticação).
- Prompts de contexto longo próximos ao tamanho de trabalho esperado, não à janela máxima.
- Prompts de chamada de ferramenta onde o comportamento correto é chamar uma função com argumentos válidos.
- Entradas de imagem que correspondam à sua fonte de upload real e manipulação de arquivos.
- Casos de falha: entrada muito grande, URL de mídia ausente, chave de API inválida e comportamento de timeout.
Listas de funcionalidades descrevem o que está disponível. A avaliação em sua carga de trabalho real informa se latência, uso de tokens, qualidade dos argumentos da ferramenta e correção da saída atendem ao seu padrão de produção.
FAQ
O Kimi K2.7 Code está disponível através da Novita AI?
Sim. A Novita AI lista o Kimi K2.7 Code como um LLM Serverless com o ID de modelo na API moonshotai/kimi-k2.7-code.
Qual é o ID de modelo correto?
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 SDK da OpenAI.
Quanto custa o Kimi K2.7 Code?
A partir de 16 de junho de 2026, a Novita AI lista $0,95 por 1M de tokens de entrada, $4,00 por 1M de tokens de saída e $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 aquisição.
Ele suporta entrada de imagem e vídeo?
A Novita lista texto, imagem e vídeo como modalidades de entrada. Para a forma exata da carga útil, verifique com a documentação atual da Novita ou uma chamada de teste antes de lançar funcionalidades multimodais.
O Kimi K2.7 Code suporta chamada de funções?
Sim. Use o parâmetro tools na requisição de chat completions. A Novita lista chamada de funções e saídas estruturadas como funcionalidades suportadas.
Qual é a janela de contexto?
262.144 tokens de janela de contexto e 262.144 tokens de saída máxima, conforme listado na página do modelo da Novita AI.
