Curso
Building AI Agents with Google ADK
1 h
3.3K
A IA de código aberto tá de volta com tudo: A Moonshot AI lançou recentementeo Kimi K2, um modelo de linguagem Mixture-of-Experts (MoE) com 32 bilhões de parâmetros ativados e um trilhão de parâmetros no total.
Neste blog, vou explicar o que é o Kimi K2, como acessá-lo e vou te mostrar alguns casos práticos de uso do Kimi K2. Vamos ver como o Kimi K2 pode:
- Crie conteúdo web estruturado e responsivo
- Crie saídas gráficas como SVGs
- Facilitar a visualização interativa de dados e a análise estatística
- Simule fenômenos científicos complexos
- Crie jogos que prendem a atenção
- Planeje itinerários detalhados com recursos interativos
A gente mantém nossos leitores por dentro das últimas novidades em IA com o The Median, nosso boletim informativo gratuito que sai toda sexta-feira e traz as principais notícias da semana. Inscreva-se e fique por dentro em só alguns minutos por semana:
O que é Kimi K2?
O Kimi K2 é um modelo de linguagem criado pela Moonshot AI, com 32 bilhões de parâmetros ativados dentro de uma estrutura enorme de 1 trilhão de parâmetros no total. O Kimi K2 é feito pra tarefas de agente. Ele foi feito pra agir, executar e pensar em tarefas complexas que usam ferramentas.
O Kimi K2 vem em duas versões:
- Kimi-K2-Base, um modelo básico para ajustes personalizados; e
- Kimi-K2-Instruct, feito pra bate-papo geral e tarefas autônomas.
O Kimi K2 mostra resultados promissores em testes de benchmark, especialmente em codificação agênica e uso de ferramentas:
Fonte: Kimi K2
Comparado com os outros de código aberto, tipo o DeepSeek V3e Qwen 2.5e LLaMA 4, o Kimi K2 costuma ter um desempenho melhor em benchmarks, mas pode precisar de uma engenharia cuidadosa para conseguir os melhores resultados na prática, geralmente por meio de refinamentos iterativos. Ele até foi chamado informalmente de “DeepSeek V3 com menos cabeças e mais especialistas”, por causa da sua arquitetura MoE de roteamento especializado.
Embora a infraestrutura da API ainda esteja amadurecendo e a documentação pudesse ser mais clara, o Kimi K2 se destaca como uma das opções mais acessíveis disponíveis no momento. É ideal para desenvolvedores experientes que já conhecem fluxos de trabalho baseados em LLM, mas quem tá começando pode achar a curva de aprendizado mais íngreme.
Como acessar o Kimi K2?
Você pode acessar o Kimi K2 pela interface de chat e pela API.
Bate-papo com Kimi
Você pode acessar o Kimi K2 pelo interface do Kimi Chat:
A seguir, vou explicar como configurar o Kimi K2 via API passo a passo, então fique à vontade para pular direto para a seção de exemplos.
Kimi K2 API
Você também pode acessar o Kimi K2 por meio de um endpoint de API. No momento, é grátis pra consultas gerais no plano gratuito, com um certo número de consultas antes de passar pro plano pago.
Você vai precisar de uma chave API, que pode ser gerada no Console do desenvolvedor do Moonshot. Vamos ver esse processo passo a passo.
Passo 1: Gerando uma chave API
Veja como acessar a API Moonshot para acessar o modelo Kimi K2:
- Entra no console do Moonshot com com sua conta do Gmail.
- Clique em “Recarregar” na aba “Faturamento” e adicione os dados do seu cartão. Pra esse tutorial, uns R$ 20 já dá pra fazer tudo. Você ganha um voucher de R$ 5 na conta.
- Vá até a aba Chaves API e clique em Criar chave API. Preencha o nome da chave API e o projeto (deixe como padrão inicialmente) e salve a chave API para usar depois.
Passo 2: Configurando um ambiente Python
Agora, vamos preparar um ambiente para todos os nossos experimentos locais:
conda create -n kimi python=3.10
conda activate kimiEsse código cria e ativa um ambiente Python chamado kimi.
Passo 3: Configurando uma variável global
É melhor exportar a chave API como uma variável de ambiente. variável de ambiente no seu terminal ou salvá-la em um arquivo .env. Veja como salvar no seu ambiente Python (kimi, neste caso):
export MOONSHOT_API_KEY="your_api_key"Para ver se a API Moonshot tá configurada direitinho como uma variável global no seu ambiente, dá uma olhada nisso:
echo $MOONSHOT_API_KEYSe você vir o valor da chave ao executar o comando acima, pode continuar; caso contrário, primeiro configure a chave como uma variável global. Se você estiver configurando a chave API em um arquivo .env, salve-a assim:
MOONSHOT_API_KEY=your_api_keyAgora, estamos prontos para ver o que o Kimi K2 pode fazer.
Passo 4: Fazendo uma chamada API
Agora que a nossa chave API está configurada, vamos tentar uma tarefa básica de conclusão de chat com o modelo Kimi K2.
from openai import OpenAI
import os
MOONSHOT_API_KEY = os.getenv("MOONSHOT_API_KEY", "your-moonshot-api-key")
client = OpenAI(
api_key=MOONSHOT_API_KEY,
base_url="https://api.moonshot.ai/v1"
)
def simple_chat(model_name: str):
messages = [
{"role": "system", "content": "You are Kimi, an AI assistant created by Moonshot AI."},
{"role": "user", "content": "Explain LLM to a 5-year-old."}
]
response = client.chat.completions.create(
model=model_name,
messages=messages,
stream=False,
temperature=0.6,
max_tokens=256
)
print(response.choices[0].message.content)
simple_chat("kimi-k2-0711-preview")O script Python acima configura o cliente API usando a chave API e o endpoint fornecidos. A função “ simple_chat() ” manda um prompt pré-definido pro modelo Kimi (kimi-k2-0711-preview) usando um formato tipo chat com mensagens do sistema e do usuário, que depois mostra a resposta do assistente.
O Kimi K2 demorou bem mais tempo (cerca de 5 minutos) pra gerar o código em comparação com outros modelos que eu tentei recentemente (como o Grok 4 ou Gemini Diffusion). Mas, mesmo com esse atraso no começo, os gráficos e os elementos interativos do aplicativo que rolou foram super precisos. Além disso, o Kimi K2 usou bem suas funções de agente pra pegar uma imagem legal e sem royalties no Unsplash pra página HTML.
Exemplo 2: Gerando representações SVG
Depois, tentei criar algumas representações SVG (Scalable Vector Graphics). Embora tenha demorado um pouco para o modelo gerar uma boa imagem SVG, ele acabou fazendo um bom trabalho.
Prompt: Crie uma representação SVG de uma borboleta
No começo, pedi pra modelo criar uma representação de um dragão, e o resultado foi só umas sombras e cores. Mas, depois de algumas tentativas, o modelo conseguiu fazer uma boa representação de uma borboleta.
Exemplo 3: Analisando um conjunto de dados com simulação
Neste exemplo, pedi ao Kimi K2 para analisar um conjunto de dados simples e mostrar o que descobriu num painel HTML. Aqui tá o prompt que usei:
Prompt: Crie um painel HTML interativo com uma interface de usuário suave e moderna que permite aos usuários simular e visualizar os efeitos do trabalho remoto nos salários em várias funções, com base no conjunto de dados ds_salaries.csv fornecido.
O painel deve incluir os seguintes componentes aprimorados:
1. Controles de simulação dinâmica (simulador do usuário):
Entradas responsivas do controle deslizante e campos numéricos para ajustar:
Prêmio remoto (%)
Multiplicadores específicos para o perfil do cargo
Inflação ou deflação do salário base
Feedback em tempo real sobre como as mudanças nas entradas afetam o conjunto de dados
Dicas explicando o impacto de cada parâmetro
2. Gráficos de interação e mapas de calor:
Salário vs perfil do cargo × gráfico de interação da proporção de trabalho remoto
Opções para alternar entre as visualizações em barra, linha ou mapa de calor
Destacar valores atípicos ou interações estatisticamente significativas
3. Informações estatísticas em tempo real:
Resultados da regressão ao vivo (OLS, ANOVA)
Destaque os valores p e os limites de significância
Gráficos visuais residuais ou diagnósticos do modelo (se possível)
4. Design de interface moderna:
Design otimizado para dispositivos móveis e sem dependências, usando HTML/CSS/JS básicos
Layout tipo cartão, com seções que podem ser recolhidas para facilitar a visualização
Animações suaves, transições e alternância entre escuro/claro
Garanta que toda a saída esteja pronta para copiar e colar em um único arquivo index.html, sem dependências externas. Inclua uma lógica de espaço reservado para carregar o CSV por meio de um elemento <input type="file">. Bônus: adicionamos uma tabela de pré-visualização CSV e opções de download e exportação para dados simulados.
Em , essa experiência com o Kimi K2, o modelo aceitou e processou com sucesso o conjunto de dados carregado, atualizando corretamente os controles de simulação com base nas variáveis derivadas dos dados. A interface do usuário tinha recursos como alternar entre os modos escuro e claro, oferecendo uma experiência visual tranquila.
Mas, faltaram algumas coisas importantes na análise. Não tinha nenhum gráfico de interação, visualizações de mapa de calor nem insights estatísticos em tempo real, como resumos de regressão ou resultados de ANOVA. Embora o Kimi K2 tenha lidado bem com a geração estrutural e a lógica da interface do usuário, suas limitações em raciocínio estatístico e visualização interativa ficaram bem claras nesse caso de uso.
Exemplo 4: Simulação científica
A galera por trás do Kimi mostrou como usar a interface de chat deles pra explorar simulações científicas e dar uma olhada no código HTML dentro da interface de chat. Aqui estão as instruções que tentei:
Prompt: Crie uma simulação de galáxia com partículas em 3D
Tentei fazer algumas edições na simulação pra ver como o modelo se adapta a qualquer modificação, tipo uma vista de cima com rotação correta das partículas e tamanho variável das partículas.
Prompt revisado: Muda a Simulação de Galáxia de Partículas 3D atual pra renderizar a galáxia de cima pra baixo (como se estivéssemos olhando de cima do plano galáctico). As estrelas e os braços devem aparecer como um padrão espiral irradiando para fora, com rotação em torno do eixo Z (perpendicular à tela). Certifique-se de que:
As posições das estrelas estão distribuídas numa espiral plana, vista de cima.
A velocidade de rotação afeta a rotação angular dentro do plano XY.
Não tem inclinação vertical nem espessura no eixo Y — deixa a dimensão Z plana.
A câmera/ponto de vista está fixa acima da galáxia (perspectiva ortográfica ou de cima para baixo).
Se quiser, dá pra adicionar uma protuberância brilhante no meio pra simular o centro da galáxia.
Mantenha todos os controles existentes (contagem de estrelas, contagem de braços, zoom, velocidade de rotação) e certifique-se de que a regeneração reflete o layout da vista superior.
