Blog

Como Usar a API Kimi K2.5

Ashley Innocent

Ashley Innocent

27 janeiro 2026

Como Usar a API Kimi K2.5

Desenvolvedores buscam cada vez mais APIs robustas que lidem com entradas multimodais complexas e entreguem saídas inteligentes. A API Kimi K2.5 se destaca como uma ferramenta versátil da Moonshot AI, permitindo que aplicativos processem texto, imagens e vídeos com capacidades avançadas de raciocínio. Esta API capacita você a construir soluções sofisticadas orientadas por IA, desde a depuração visual em código até a orquestração de enxames de agentes para execução de tarefas paralelas.

💡
Quer acompanhar? Baixe o Apidog para testar suas chamadas da API Kimi K2.5 visualmente. O Apidog permite configurar requisições, inspecionar respostas, depurar problemas de autenticação e gerar código pronto para produção — tudo sem escrever código repetitivo. É a maneira mais rápida de experimentar as capacidades do K2.5 antes de se comprometer com o código.
button

O que é Kimi K2.5?

Kimi K2.5 representa o modelo multimodal de código aberto mais avançado da Moonshot AI, construído através de um pré-treinamento contínuo em aproximadamente 15 trilhões de tokens visuais e de texto mistos sobre a arquitetura Kimi-K2-Base. Diferente de seu predecessor, o K2.5 integra perfeitamente a compreensão de visão e linguagem com capacidades agênticas avançadas, tornando-o particularmente poderoso para desenvolvedores que constroem aplicações baseadas em IA.

O modelo introduz diversas funcionalidades inovadoras que o diferenciam de outras APIs de IA. Sua multimodalidade nativa significa que ele foi pré-treinado em tokens de visão-linguagem desde o início, em vez de ter capacidades de visão adicionadas como um complemento. Essa abordagem resulta em desempenho superior em conhecimento visual, raciocínio intermodal e uso de ferramentas agênticas baseado em entradas visuais.

Por que Kimi K2.5 é importante para desenvolvedores:

Principais Funcionalidades e Capacidades

Inteligência Multimodal Nativa

O K2.5 se destaca no conhecimento visual, raciocínio intermodal e uso de ferramentas agênticas baseado em entradas visuais. Não se trata apenas de reconhecimento de imagem — é uma compreensão profunda do contexto visual que pode informar tomadas de decisão complexas.

Codificação com Visão

Uma das capacidades de destaque do K2.5 é a geração de código a partir de especificações visuais. Aponte-o para um mockup de design de interface de usuário, e ele pode produzir código front-end funcional. Mostre-lhe um fluxo de trabalho em vídeo, e ele pode orquestrar ferramentas para processamento de dados visuais. Isso o torna particularmente valioso para:

Arquitetura de Enxame de Agentes

O K2.5 transita do escalonamento de agente único para um esquema de execução coordenado e autodirigido, similar a um enxame. Quando confrontado com tarefas complexas, ele pode:

  1. Decompor o problema em subtarefas paralelas
  2. Instanciar dinamicamente agentes específicos de domínio
  3. Coordenar a execução entre múltiplos agentes
  4. Sintetizar resultados em saídas coerentes

Essa arquitetura permite que o K2.5 lide com tarefas que sobrecarregariam sistemas de agente único, como refatoração de código abrangente, geração de documentação multifilhas ou pipelines complexos de análise de dados.

Desempenho de Benchmark

Começando com a API Kimi K2.5

Passo 1: Crie sua Conta Moonshot AI

Visite platform.moonshot.ai e crie uma conta. O processo de registro é simples:

  1. Clique em "Sign Up" ou "Register" (Inscrever-se ou Registrar)
  2. Forneça seu e-mail e crie uma senha
  3. Verifique seu endereço de e-mail
  4. Preencha qualquer informação de perfil necessária

Passo 2: Gere sua Chave de API

Uma vez logado:

  1. Navegue até a seção de Chaves de API no seu painel
  2. Clique em "Create New API Key" (Criar Nova Chave de API)
  3. Dê à sua chave um nome descritivo (por exemplo, "kimi-k2-5-development")
  4. Copie e armazene sua chave de API com segurança — você não a verá novamente

Dica de segurança: Nunca publique chaves de API no controle de versão. Use variáveis de ambiente ou um gerenciador de segredos.

Passo 3: Configure seu Ambiente

Para Python:

pip install --upgrade 'openai>=1.0'

Para Node.js:

npm install openai@latest

Passo 4: Configure sua Chave de API

Defina sua chave de API como uma variável de ambiente:

macOS/Linux:

export MOONSHOT_API_KEY="sua-chave-api-aqui"

Windows (PowerShell):

[System.Environment]::SetEnvironmentVariable("MOONSHOT_API_KEY", "sua-chave-api-aqui", "User")

Windows (Prompt de Comando):

setx MOONSHOT_API_KEY "sua-chave-api-aqui"

Exemplos de Código Python

Conclusão Básica de Chat

Aqui está um exemplo simples para começar com Kimi K2.5:

import os
from openai import OpenAI

# Initialize the client with Moonshot AI endpoint
client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Create a chat completion
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "system",
            "content": "You are Kimi, an AI assistant developed by Moonshot AI. You are helpful, harmless, and honest."
        },
        {
            "role": "user",
            "content": "Explain the concept of mixture-of-experts architecture in neural networks."
        }
    ],
    temperature=0.6,
    max_tokens=2048,
)

print(response.choices[0].message.content)

Streaming de Respostas

Para aplicações em tempo real, use streaming para exibir respostas à medida que são geradas:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Stream the response
stream = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {"role": "user", "content": "Write a Python function to implement binary search."}
    ],
    stream=True,
    temperature=0.3,
)

# Process the stream
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Conversa Multi-Turno

Mantenha o contexto em múltiplas trocas:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

conversation_history = [
    {"role": "system", "content": "You are a helpful coding assistant."}
]

def chat(user_message):
    conversation_history.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="kimi-k2.5-preview",
        messages=conversation_history,
        temperature=0.6,
    )

    assistant_message = response.choices[0].message.content
    conversation_history.append({"role": "assistant", "content": assistant_message})

    return assistant_message

# Example conversation
print(chat("How do I create a REST API in Python?"))
print(chat("Can you show me how to add authentication to that?"))
print(chat("What about rate limiting?"))

Implementação Assíncrona

Para aplicações de alto desempenho, use async/await:

import os
import asyncio
from openai import AsyncOpenAI

async def main():
    client = AsyncOpenAI(
        api_key=os.environ.get("MOONSHOT_API_KEY"),
        base_url="https://api.moonshot.ai/v1",
    )

    # Run multiple requests concurrently
    tasks = [
        client.chat.completions.create(
            model="kimi-k2.5-preview",
            messages=[{"role": "user", "content": f"What is {topic}?"}],
        )
        for topic in ["REST API", "GraphQL", "gRPC"]
    ]

    responses = await asyncio.gather(*tasks)

    for response in responses:
        print(response.choices[0].message.content[:200])
        print("-" * 50)

asyncio.run(main())

Exemplos de JavaScript/Node.js

Conclusão Básica de Chat

import OpenAI from 'openai';

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

async function chat(userMessage) {
  const response = await client.chat.completions.create({
    model: 'kimi-k2.5-preview',
    messages: [
      {
        role: 'system',
        content: 'You are Kimi, a helpful AI assistant.',
      },
      {
        role: 'user',
        content: userMessage,
      },
    ],
    temperature: 0.6,
  });

  return response.choices[0].message.content;
}

// Usage
const answer = await chat('How do I implement a binary search tree in JavaScript?');
console.log(answer);

Streaming com Node.js

import OpenAI from 'openai';

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

async function streamChat(userMessage) {
  const stream = await client.chat.completions.create({
    model: 'kimi-k2.5-preview',
    messages: [{ role: 'user', content: userMessage }],
    stream: true,
  });

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

await streamChat('Explain microservices architecture');

Usando Fetch API (Navegador/Funções Edge)

async function callKimiAPI(prompt) {
  const response = await fetch('https://api.moonshot.ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.MOONSHOT_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'kimi-k2.5-preview',
      messages: [{ role: 'user', content: prompt }],
      temperature: 0.6,
    }),
  });

  const data = await response.json();
  return data.choices[0].message.content;
}

// Usage
const result = await callKimiAPI('What are the best practices for API design?');
console.log(result);

Testando a API Kimi K2.5 com Apidog

Testar APIs de IA de forma eficaz requer entender as estruturas de requisição/resposta, lidar com streaming, gerenciar autenticação e depurar problemas. O Apidog oferece uma solução abrangente para o desenvolvimento de APIs que torna o trabalho com Kimi K2.5 simples.

Configurando Kimi K2.5 no Apidog

Passo 1: Crie um Novo Projeto

  1. Abra o Apidog e crie um novo projeto chamado "Kimi K2.5 Integration"
  2. Isso organiza todos os seus endpoints relacionados ao Kimi em um só lugar

Passo 2: Configure Variáveis de Ambiente

  1. Navegue até as Configurações de Ambiente
  2. Adicione uma nova variável de ambiente:

Passo 3: Crie o Endpoint de Conclusões de Chat

  1. Adicione uma nova requisição POST
  2. URL: https://api.moonshot.ai/v1/chat/completions
  3. Cabeçalhos:

Passo 4: Configure o Corpo da Requisição

{
  "model": "kimi-k2.5-preview",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful AI assistant."
    },
    {
      "role": "user",
      "content": "Hello, how can you help me today?"
    }
  ],
  "temperature": 0.6,
  "max_tokens": 2048,
  "stream": false
}

Depurando com Apidog

A interface visual do Apidog ajuda você a:

Criando Testes Automatizados

Com o executor de testes do Apidog, você pode verificar sua integração com Kimi K2.5:

// Post-response test script in Apidog
pm.test("Response status is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response contains choices", function () {
    const response = pm.response.json();
    pm.expect(response.choices).to.be.an('array');
    pm.expect(response.choices.length).to.be.greaterThan(0);
});

pm.test("Response content is not empty", function () {
    const response = pm.response.json();
    pm.expect(response.choices[0].message.content).to.not.be.empty;
});

Chamada de Ferramentas e Capacidades de Agente

Uma das funcionalidades mais poderosas do Kimi K2.5 é sua capacidade de chamar ferramentas externas. Isso permite a construção de agentes de IA sofisticados que podem interagir com sistemas externos.

Definindo Ferramentas

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Define available tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and country, e.g., 'London, UK'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Search a database for information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search query"
                    },
                    "limit": {
                        "type": "integer",
                        "description": "Maximum number of results"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# Make a request with tools
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {"role": "user", "content": "What's the weather like in Tokyo?"}
    ],
    tools=tools,
    tool_choice="auto",
)

# Handle tool calls
if response.choices[0].message.tool_calls:
    for tool_call in response.choices[0].message.tool_calls:
        print(f"Tool: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")

Executando Chamadas de Ferramentas

import json

def execute_tool_call(tool_call):
    """Execute a tool call and return the result."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    if name == "get_weather":
        # Simulate weather API call
        return json.dumps({
            "location": args["location"],
            "temperature": 22,
            "unit": args.get("unit", "celsius"),
            "condition": "sunny"
        })
    elif name == "search_database":
        # Simulate database search
        return json.dumps({
            "results": [
                {"id": 1, "title": "Result 1"},
                {"id": 2, "title": "Result 2"}
            ]
        })

    return json.dumps({"error": "Unknown tool"})

# Complete the conversation with tool results
messages = [
    {"role": "user", "content": "What's the weather in Tokyo?"}
]

response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=messages,
    tools=tools,
)

if response.choices[0].message.tool_calls:
    # Add assistant message with tool calls
    messages.append(response.choices[0].message)

    # Execute each tool and add results
    for tool_call in response.choices[0].message.tool_calls:
        result = execute_tool_call(tool_call)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })

    # Get final response
    final_response = client.chat.completions.create(
        model="kimi-k2.5-preview",
        messages=messages,
        tools=tools,
    )

    print(final_response.choices[0].message.content)

Recursos de Visão e Multimodais

As capacidades multimodais nativas do K2.5 permitem o processamento de imagens juntamente com texto:

import os
import base64
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

def encode_image(image_path):
    """Encode image to base64."""
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Analyze an image
image_base64 = encode_image("screenshot.png")

response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Analyze this UI design and suggest improvements."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_base64}"
                    }
                }
            ]
        }
    ],
    max_tokens=2048,
)

print(response.choices[0].message.content)

Geração de Código a Partir de Entrada Visual

# Generate code from a wireframe
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "system",
            "content": "You are an expert frontend developer. Generate clean, production-ready code."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Convert this wireframe into a React component with Tailwind CSS styling."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{encode_image('wireframe.png')}"
                    }
                }
            ]
        }
    ],
    temperature=0.3,
)

print(response.choices[0].message.content)

Preços e Limites de Taxa

Pontos-chave:

Melhores Práticas e Dicas

Otimizar o Uso de Tokens

# Use system prompts efficiently
system_prompt = """You are a concise technical assistant.
Rules: 1) Be brief 2) Use code blocks 3) Skip pleasantries"""

# Enable caching for repeated contexts
# Moonshot automatically caches similar prompts

Configurações de Temperatura

Tratamento de Erros

from openai import OpenAI, APIError, RateLimitError

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

def safe_chat(message, retries=3):
    for attempt in range(retries):
        try:
            response = client.chat.completions.create(
                model="kimi-k2.5-preview",
                messages=[{"role": "user", "content": message}],
            )
            return response.choices[0].message.content
        except RateLimitError:
            if attempt < retries - 1:
                time.sleep(2 ** attempt)  # Exponential backoff
            else:
                raise
        except APIError as e:
            print(f"API Error: {e}")
            raise

result = safe_chat("Hello, Kimi!")

Solução de Problemas Comuns

Erros de Autenticação

Problema: Erro 401 Unauthorized

Soluções:

  1. Verifique se sua chave de API está correta
  2. Verifique se a chave não expirou
  3. Garanta que o formato do cabeçalho Authorization esteja correto: Bearer SUA_CHAVE

Limite de Taxa

Problema: 429 Too Many Requests (Muitas Requisições)

Soluções:

  1. Implemente backoff exponencial
  2. Atualize seu nível adicionando fundos
  3. Monitore os cabeçalhos X-RateLimit-Remaining

Comprimento do Contexto Excedido

Problema: A requisição excede o limite de 256K tokens

Soluções:

  1. Resuma conversas longas
  2. Use uma abordagem de janela deslizante
  3. Divida em múltiplas requisições

Problemas de Tempo Limite

Problema: Requisições com tempo limite esgotado

Soluções:

  1. Use streaming para respostas longas
  2. Aumente as configurações de tempo limite do cliente
  3. Divida prompts complexos em tarefas menores

Pronto para construir com Kimi K2.5? Baixe o Apidog para otimizar seu fluxo de trabalho de desenvolvimento de API com testes visuais, documentação automática e recursos de colaboração em equipe que tornam a integração de APIs de IA mais rápida e confiável.

button

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar