Como Usar Kimi K2 no VSCode Copilot: Guia Completo

Numa era em que as ferramentas de desenvolvedor alimentadas por IA não são mais uma novidade, mas uma necessidade, o Copilot do Visual Studio Code estabeleceu-se firmemente como líder. No entanto, o verdadeiro poder da IA reside na sua diversidade e nas capacidades especializadas de diferentes modelos. E se você pudesse trocar o motor padrão do seu Copilot por algo mais poderoso, mais especializado, ou até mesmo algo que você executa localmente? Este artigo irá guiá-lo através do processo de integração do formidável modelo de linguagem Kimi K2 da Moonshot AI no seu VSCode Copilot, e faremos isso com uma ferramenta inteligente chamada Fake Ollama.

Este guia abrangente irá acompanhá-lo por todo o processo, desde a obtenção das suas chaves de API até a configuração do seu ambiente local e, finalmente, testemunhar o poder de um modelo de um trilhão de parâmetros diretamente no seu editor favorito.

Antes de mergulharmos nos detalhes técnicos, vamos nos familiarizar com os principais componentes desta configuração.

O que é Kimi K2?

Kimi K2 é um modelo de linguagem grande de última geração desenvolvido pela Moonshot AI. É um modelo de Mistura de Especialistas (MoE) com um impressionante total de um trilhão de parâmetros, com 32 bilhões ativos durante qualquer inferência.

Esta arquitetura permite que o Kimi K2 se destaque em uma ampla gama de tarefas, particularmente em:

• Codificação: Com pontuações impressionantes em benchmarks como LiveCodeBench e SWE-bench, o Kimi K2 é uma potência em codificação.
• Raciocínio: O modelo demonstra fortes capacidades lógicas e de raciocínio, tornando-o um excelente parceiro para a resolução de problemas complexos.
• Compreensão de Contexto Longo: O Kimi K2 pode lidar com uma janela de contexto massiva de até 128.000 tokens, permitindo-lhe entender e trabalhar com grandes bases de código, documentação extensa e conversas longas.

O Kimi K2 está disponível em duas variantes principais:

• Kimi-K2-Base: O modelo fundamental, ideal para pesquisadores e desenvolvedores que desejam ajustar e construir soluções personalizadas.
• Kimi-K2-Instruct: Uma versão ajustada otimizada para tarefas de chat e agência, tornando-o um substituto perfeito para outros modelos que seguem instruções.

Para os nossos propósitos, usaremos o modelo Instruct via API.

O que é VSCode Copilot?

Se você está lendo este artigo, provavelmente já está familiarizado com o VSCode Copilot. É uma ferramenta de assistência e conclusão de código alimentada por IA desenvolvida pelo GitHub e OpenAI. Ela fornece sugestões de código inteligentes, responde a perguntas de codificação e pode até ajudá-lo a refatorar e depurar seu código. Embora incrivelmente poderosa por padrão, atualizações recentes abriram a porta para o uso de modelos personalizados, que é o recurso que aproveitaremos.

O que é Fake Ollama?

Este é o ingrediente secreto que torna nossa integração possível. O Fake Ollama, como o nome sugere, é uma ferramenta que cria um servidor que imita a API do Ollama, uma plataforma popular para executar e gerenciar modelos de linguagem locais.

Muitos aplicativos, incluindo as versões mais recentes do VSCode Copilot, têm suporte integrado para a API do Ollama. Ao executar o Fake Ollama, podemos enganar o VSCode Copilot, fazendo-o pensar que está se comunicando com uma instância padrão do Ollama, enquanto na realidade, nosso servidor Fake Ollama está encaminhando as requisições para a API do Kimi K2. Isso o torna uma ponte versátil, permitindo-nos conectar praticamente qualquer API de modelo a qualquer ferramenta que suporte o Ollama.

Pré-requisitos

Antes de começarmos, certifique-se de ter o seguinte instalado e pronto:

• Visual Studio Code: A versão mais recente é recomendada para garantir a compatibilidade com os recursos do Copilot que usaremos.
• Extensão VSCode Copilot: Você precisará de uma assinatura ativa do Copilot e da extensão instalada no VSCode.
• Python: Uma versão recente do Python (3.8 ou superior) é necessária para executar o servidor Fake Ollama.
• Git: Você precisará do Git para clonar o repositório Fake Ollama do GitHub.
• Uma Chave de API Kimi K2: Abordaremos como obter isso na primeira etapa.

A Integração: Um Guia Passo a Passo

Agora, vamos colocar a mão na massa e integrar o Kimi K2 ao VSCode Copilot.

Passo 1: Obtenha Sua Chave de API Kimi K2

Você tem duas opções principais para obter uma chave de API Kimi K2:

1. Plataforma Moonshot AI: Você pode se inscrever diretamente na plataforma Moonshot AI. Isso lhe dará acesso direto à API do Kimi K2.
2. OpenRouter: Esta é a abordagem recomendada pela sua flexibilidade. O OpenRouter é um serviço que fornece uma API unificada para uma vasta gama de modelos de IA, incluindo o Kimi K2. Ao usar o OpenRouter, você pode alternar facilmente entre diferentes modelos sem alterar seu código ou chaves de API.

Para este guia, assumiremos que você está usando o OpenRouter. Depois de criar uma conta e obter sua chave de API, você pode interagir com o modelo Kimi K2 usando a biblioteca Python do OpenAI, da seguinte forma:Python

from openai import OpenAI

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

response = client.chat.completions.create(
  model="moonshotai/kimi-k2",
  messages=[
    {"role": "user", "content": "Write a simple Python function to calculate the factorial of a number."},
  ],
)
print(response.choices[0].message.content)

Mantenha sua chave de API do OpenRouter à mão; você precisará dela para a configuração do Fake Ollama.

Passo 2: Configure o Fake Ollama

Primeiro, você precisará clonar o repositório Fake Ollama do GitHub. Abra seu terminal e execute o seguinte comando:Bash

git clone https://github.com/spoonnotfound/fake-ollama.git

Em seguida, navegue até o diretório clonado e instale as dependências Python necessárias:Bash

cd fake-ollama
pip install -r requirements.txt

Passo 3: Configure o Fake Ollama para Kimi K2

Este é o passo mais crucial. Precisamos configurar o Fake Ollama para usar nossa chave de API do OpenRouter e apontar para o modelo Kimi K2. A configuração provavelmente estará em um arquivo .env ou diretamente no script Python principal. Para este guia, assumiremos um arquivo .env para as melhores práticas.

Crie um arquivo chamado .env no diretório fake-ollama e adicione as seguintes linhas:

OPENAI_API_BASE=https://openrouter.ai/api/v1
OPENAI_API_KEY=YOUR_OPENROUTER_API_KEY
MODEL_NAME=moonshotai/kimi-k2

Ao definir essas variáveis de ambiente, o servidor Fake Ollama saberá para onde encaminhar as requisições para o endpoint do OpenRouter, usar sua chave de API para autenticação e especificar moonshotai/kimi-k2 como o modelo desejado.

Passo 4: Execute o Servidor Fake Ollama

Agora, é hora de iniciar o servidor Fake Ollama. No seu terminal, dentro do diretório fake-ollama, execute:Bash

python main.py

Se tudo estiver configurado corretamente, você deverá ver uma mensagem indicando que o servidor está em execução, geralmente em http://localhost:11434. Este é o endpoint local que usaremos no VSCode.

Passo 5: Configure o VSCode Copilot

O passo final é dizer ao VSCode Copilot para usar nosso servidor Fake Ollama local em vez dos modelos padrão do GitHub Copilot.

1. Abra o VSCode e vá para a visualização do Copilot Chat.
2. Na entrada do chat, digite / e selecione "Selecionar um Modelo".
3. Clique em "Gerenciar Modelos...".
4. Na caixa de diálogo que aparece, selecione "Ollama" como o provedor de IA.
5. Você será solicitado a inserir a URL do servidor Ollama. Insira o endereço do seu servidor Fake Ollama local: http://localhost:11434.
6. Em seguida, você será solicitado a selecionar um modelo. Você deverá ver o modelo que especificou na sua configuração do Fake Ollama (moonshotai/kimi-k2) na lista. Selecione-o.

E é isso! Seu VSCode Copilot agora é alimentado pelo modelo Kimi K2. Você pode iniciar uma nova sessão de chat e experimentar as capacidades aprimoradas de codificação e raciocínio deste poderoso modelo.

Além da API: Usando Modelos Locais com vLLM, llama.cpp e ktransformers

A beleza da configuração do Fake Ollama é que ela não se limita a modelos baseados em API. Você também pode usá-lo como um front-end para modelos executados localmente em seu próprio hardware usando poderosos motores de inferência como:

• vLLM: Uma biblioteca de código aberto que acelera significativamente a inferência e o serviço de LLM.
• llama.cpp: Uma implementação em C++ dos modelos LLaMA, otimizada para execução em CPUs e uma ampla gama de hardware.
• ktranformers: Um framework flexível para experimentar otimizações de inferência de LLM de ponta. Notavelmente, o ktranformers anunciou suporte para Kimi K2, o que significa que você pode executar uma versão quantizada do modelo localmente.

O processo é semelhante: você primeiro configuraria e executaria o modelo desejado usando um desses motores de inferência, que exporia um endpoint de API local. Em seguida, você configuraria o Fake Ollama para apontar para o endpoint desse modelo local em vez da API do OpenRouter. Isso lhe dá controle total sobre seus modelos e dados, com a desvantagem de exigir hardware mais potente.

Conclusão

Ao aproveitar a flexibilidade do suporte a modelos personalizados do VSCode Copilot e a inteligência da ferramenta Fake Ollama, você pode desbloquear um novo nível de desenvolvimento assistido por IA. A integração do Kimi K2 proporciona um aumento significativo na codificação, raciocínio e compreensão de contexto longo, tornando seu Copilot um parceiro ainda mais valioso.

O mundo dos grandes modelos de linguagem está em constante evolução, e a capacidade de trocar e experimentar facilmente diferentes modelos é um divisor de águas. Seja você usando uma API de última geração como o Kimi K2 ou executando seus próprios modelos localmente, o poder de personalizar suas ferramentas está em suas mãos. Boa codificação!