Como Usar a API Kimi VL Thinking Gratuitamente

Modelos de linguagem visual (VLMs) revolucionaram a capacidade da IA de entender e raciocinar sobre conteúdo visual. Entre essas inovações, o modelo Kimi VL Thinking da Moonshot AI se destaca como particularmente impressionante - combinando capacidades de raciocínio avançadas com notável eficiência. Este tutorial irá guiá-lo para entender as capacidades do Kimi VL Thinking e como usá-lo gratuitamente pela plataforma OpenRouter.

Referências do Kimi VL Thinking

O Kimi VL Thinking (oficialmente chamado de Kimi-VL-A3B-Thinking) é um modelo avançado de linguagem visual desenvolvido pela Moonshot AI. O que torna este modelo especial é sua arquitetura de Mistura de Especialistas (MoE) que ativa apenas 2,8 bilhões de parâmetros por passo de inferência, enquanto contém aproximadamente 16 bilhões de parâmetros no total. Isso permite que ele forneça raciocínio sofisticado com computação relativamente eficiente.

O Kimi VL Thinking é especificamente projetado para tarefas de raciocínio avançadas, particularmente aquelas que requerem raciocínio passo a passo e análise matemática de entradas visuais. Ele foi criado ajustando o modelo base Kimi VL com técnicas de aprendizado supervisionado e aprendizado por reforço de cadeia de pensamento (CoT).

Principais Destaques do Modelo Kimi VL Thinking

Janela de Contexto Longa: Suporta até 128K tokens, permitindo conversas extensas de múltiplas interações e processamento de documentos longos.
Visão de Resolução Nativa: Usa o codificador MoonViT para processar entradas visuais de alta resolução com excelente reconhecimento de detalhes.
Raciocínio Avançado: Especialmente forte em raciocínio visual matemático e resolução de problemas passo a passo.
Computação Eficiente: Apesar de suas poderosas capacidades, o modelo ativa apenas 2,8 bilhões de parâmetros, tornando-o mais acessível do que alternativas maiores.
Código Aberto: Disponível sob licença MIT, permitindo amplas aplicações acadêmicas e comerciais.

Desempenho do Kimi VL Thinking em Referências

O Kimi VL Thinking demonstra desempenho impressionante em várias referências desafiadoras, muitas vezes rivalizando ou superando modelos muito maiores:

MathVision: Alcança uma pontuação de 36,8 (Pass@1), comparável a modelos como Gemma-3-27B (35,5) e se aproximando do Qwen2.5-VL-72B (38,1).
MathVista: Marca 71,3 no mini benchmark, superando modelos como GPT-4o-mini (56,7) e Gemma-3-12B (56,4).
MMMU (Compreensão Multimodal Massiva e Multitarefa): Alcança 61,7 no conjunto de validação, demonstrando fortes capacidades em tarefas multimodais complexas.

Para colocar esses resultados em perspectiva, o desempenho do Kimi VL Thinking é notável, considerando que ativa apenas 2,8 bilhões de parâmetros, enquanto compete contra modelos que usam 7 bilhões, 12 bilhões ou até 70 bilhões de parâmetros. Isso o posiciona como um dos VLMs mais eficientes com capacidade de raciocínio disponíveis.

Como Usar o Kimi VL Thinking Gratuitamente Através do OpenRouter

O OpenRouter oferece uma maneira conveniente de acessar o Kimi VL Thinking sem precisar implantar o modelo por conta própria. O nível gratuito permite que você experimente o modelo sem nenhum custo. Veja como começar:

Passo 1: Crie uma Conta no OpenRouter

Acesse o site do OpenRouter e inscreva-se para uma conta se você ainda não tiver uma.
Após o registro, navegue até as configurações da sua conta para gerar uma chave de API.
Armazene esta chave de API de forma segura, pois você precisará dela para todas as chamadas de API.

Passo 2: Entendendo a Estrutura da API do OpenRouter

A API do OpenRouter foi projetada para ser compatível com o formato da API do OpenAI, facilitando a integração se você já estiver familiarizado com os serviços do OpenAI. As principais diferenças são:

A URL base: https://openrouter.ai/api/v1
O nome do modelo: moonshotai/kimi-vl-a3b-thinking:free
Cabeçalhos adicionais opcionais para análises

Passo 3: Fazendo sua Primeira Chamada de API

Para usuários de Python, configure seu ambiente com estas dependências:

pip install openai requests pillow

Vamos começar com um exemplo básico usando o SDK do OpenAI, que é a abordagem mais direta:

from openai import OpenAI
from base64 import b64encode
from PIL import Image
import io

# Inicialize o cliente com a URL base do OpenRouter
client = OpenAI(
    base_url="<https://openrouter.ai/api/v1>",
    api_key="sua_chave_de_api_do_openrouter_aqui",
)

# Função para codificar imagens
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return b64encode(image_file.read()).decode('utf-8')

# Carregue e encode sua imagem
image_path = "caminho_para_sua_imagem.jpg"
base64_image = encode_image(image_path)

# Crie a solicitação da API
completion = client.chat.completions.create(
    extra_headers={
        "HTTP-Referer": "sua_url_do_site",  # Opcional para análises
        "X-Title": "nome_do_seu_app",       # Opcional para análises
    },
    model="moonshotai/kimi-vl-a3b-thinking:free",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                },
                {
                    "type": "text",
                    "text": "Por favor, examine este problema matemático e resolva-o passo a passo."
                }
            ]
        }
    ],
    max_tokens=1024
)

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

Se você preferir usar chamadas diretas de API sem o SDK:

import requests
import json
from base64 import b64encode

# Função para codificar imagens
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return b64encode(image_file.read()).decode('utf-8')

# Carregue e codifique sua imagem
image_path = "caminho_para_sua_imagem.jpg"
base64_image = encode_image(image_path)

# Crie a solicitação da API
response = requests.post(
    url="<https://openrouter.ai/api/v1/chat/completions>",
    headers={
        "Authorization": "Bearer sua_chave_de_api_do_openrouter_aqui",
        "Content-Type": "application/json",
        "HTTP-Referer": "sua_url_do_site",  # Opcional para análises
        "X-Title": "nome_do_seu_app",       # Opcional para análises
    },
    data=json.dumps({
        "model": "moonshotai/kimi-vl-a3b-thinking:free",
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}"
                        }
                    },
                    {
                        "type": "text",
                        "text": "Por favor, examine este problema matemático e resolva-o passo a passo."
                    }
                ]
            }
        ],
        "max_tokens": 1024
    })
)

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

Para respostas longas ou melhor experiência do usuário, você pode querer transmitir a saída do modelo:

from openai import OpenAI
from base64 import b64encode

client = OpenAI(
    base_url="<https://openrouter.ai/api/v1>",
    api_key="sua_chave_de_api_do_openrouter_aqui",
)

# Função para codificar imagens
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return b64encode(image_file.read()).decode('utf-8')

# Carregue e codifique sua imagem
image_path = "caminho_para_sua_imagem.jpg"
base64_image = encode_image(image_path)

# Crie uma solicitação em streaming
stream = client.chat.completions.create(
    model="moonshotai/kimi-vl-a3b-thinking:free",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{base64_image}"
                    }
                },
                {
                    "type": "text",
                    "text": "Por favor, examine este problema matemático e resolva-o passo a passo."
                }
            ]
        }
    ],
    stream=True,
    max_tokens=1024
)

# Processar a resposta streaming
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Testando a API do Kimi VL Thinking com Apidog

Apidog é uma ferramenta abrangente de teste de API que simplifica o processo de interação com APIs como o Kimi VL Thinking. Suas características, como gerenciamento de ambiente e simulação de cenários, a tornam ideal para desenvolvedores. Vamos ver como usar o Apidog para testar a API do Kimi VL Thinking.

botão

Configure o Apidog

Primeiro, baixe e instale o Apidog a partir de apidog.com. Após a instalação, crie um novo projeto e adicione o endpoint da API Kimi VL Thinking: https://openrouter.ai/api/v1/chat/completions.

Configure Seu Ambiente

Em seguida, configure diferentes ambientes (por exemplo, desenvolvimento e produção) no Apidog. Defina variáveis como sua chave de API e URL base para alternar facilmente entre configurações. No Apidog, vá até a aba “Ambientes” e adicione:

api_key: Sua chave de API do OpenRouter
base_url: https://openrouter.ai/api/v1

Crie uma Solicitação de Teste

Agora, crie uma nova solicitação POST no Apidog.

Defina a URL como {{base_url}}/chat/completions, adicione seus cabeçalhos e insira o corpo JSON:

{
    "model": "quasar-alpha",
    "messages": [
        {"role": "user", "content": "Explique a diferença entre let e const em JavaScript."}
    ],
    "max_tokens": 300
}

Na seção de cabeçalhos, adicione:

Authorization: Bearer {{api_key}}
Content-Type: application/json

Execute e Analise o Teste

Por fim, envie a solicitação e analise a resposta na interface visual do Apidog. O Apidog fornece relatórios detalhados, incluindo tempo de resposta, código de status e uso de tokens. Você também pode salvar esta solicitação como um cenário reutilizável para testes futuros.

A capacidade do Apidog de simular cenários do mundo real e gerar relatórios exportáveis o torna uma ferramenta poderosa para depuração e otimização de suas interações com a API do Kimi VL Thinking. Vamos concluir com algumas melhores práticas.

botão

Otimizando Prompts para o Kimi VL Thinking

O Kimi VL Thinking se destaca em raciocínio passo a passo, então estruture seus prompts para aproveitar essa capacidade:

Seja Explícito Sobre o Raciocínio: Peça ao modelo para "pensar passo a passo" ou "raciocinar cuidadosamente sobre este problema".
Uma Tarefa de Cada Vez: Para problemas complexos, divida-os em etapas gerenciáveis, em vez de pedir tudo de uma vez.
Forneça Contexto: Quando relevante, forneça informações de fundo que possam ajudar o modelo a entender melhor o problema.
Use Instruções Claras: Especifique exatamente o que você deseja que o modelo analise na imagem.

Conclusão

O Kimi VL Thinking representa uma conquista impressionante em modelos de linguagem visual eficientes, mas poderosos. Sua capacidade de realizar raciocínio avançado enquanto ativa apenas 2,8 bilhões de parâmetros o torna acessível a uma gama mais ampla de usuários do que modelos grandes tradicionais.

Aproveitando o nível gratuito do OpenRouter, você pode experimentar esta tecnologia de ponta sem barreiras de custo. Seja você um desenvolvedor trabalhando em aplicações educacionais, análise de dados ou documentação técnica, o Kimi VL Thinking oferece uma ferramenta poderosa para entender e raciocinar sobre conteúdo visual.

À medida que você se familiariza mais com o modelo, poderá explorar casos de uso mais complexos e, potencialmente, integrá-lo em aplicações de produção. Lembre-se de que o nível gratuito é perfeito para experimentação, mas para casos de uso em produção com altos volumes, você pode considerar a atualização para um nível pago para melhor confiabilidade e garantias de desempenho.

Comece a explorar o Kimi VL Thinking hoje e descubra como capacidades avançadas de raciocínio visual podem aprimorar seus projetos!