Cómo Usar Kimi K2 con VSCode Copilot

En una era donde las herramientas para desarrolladores impulsadas por IA ya no son una novedad, sino una necesidad, Copilot de Visual Studio Code se ha establecido firmemente como un líder. Sin embargo, el verdadero poder de la IA reside en su diversidad y en las capacidades especializadas de los diferentes modelos. ¿Qué pasaría si pudieras cambiar el motor predeterminado de tu Copilot por algo más potente, más especializado o incluso algo que ejecutes tú mismo? Este artículo te guiará a través del proceso de integración del formidable modelo de lenguaje Kimi K2 de Moonshot AI en tu Copilot de VSCode, y lo haremos con una herramienta ingeniosa llamada Fake Ollama.

Esta guía completa te llevará a través de todo el proceso, desde la obtención de tus claves API hasta la configuración de tu entorno local y, finalmente, a presenciar el poder de un modelo de un billón de parámetros directamente dentro de tu editor favorito.

Antes de sumergirnos en los detalles técnicos, familiaricémonos con los componentes clave de esta configuración.

¿Qué es Kimi K2?

Kimi K2 es un modelo de lenguaje grande de última generación desarrollado por Moonshot AI. Es un modelo de Mezcla de Expertos (MoE) con la asombrosa cantidad de un billón de parámetros totales, con 32 mil millones activos durante cualquier inferencia dada.

Esta arquitectura permite que Kimi K2 sobresalga en una amplia gama de tareas, particularmente en:

• Codificación: Con puntuaciones impresionantes en puntos de referencia como LiveCodeBench y SWE-bench, Kimi K2 es una potencia de codificación.
• Razonamiento: El modelo demuestra sólidas capacidades lógicas y de razonamiento, lo que lo convierte en un excelente socio para la resolución de problemas complejos.
• Comprensión de contexto largo: Kimi K2 puede manejar una ventana de contexto masiva de hasta 128.000 tokens, lo que le permite comprender y trabajar con grandes bases de código, documentación extensa y conversaciones largas.

Kimi K2 está disponible en dos variantes principales:

• Kimi-K2-Base: El modelo fundamental, ideal para investigadores y desarrolladores que desean ajustar y construir soluciones personalizadas.
• Kimi-K2-Instruct: Una versión ajustada optimizada para tareas de chat y agénticas, lo que la convierte en un reemplazo perfecto para otros modelos que siguen instrucciones.

Para nuestros propósitos, utilizaremos el modelo Instruct a través de una API.

¿Qué es VSCode Copilot?

Si estás leyendo este artículo, es probable que ya estés familiarizado con VSCode Copilot. Es una herramienta de asistencia y finalización de código impulsada por IA desarrollada por GitHub y OpenAI. Proporciona sugerencias de código inteligentes, responde preguntas de codificación e incluso puede ayudarte a refactorizar y depurar tu código. Si bien es increíblemente potente de forma predeterminada, las actualizaciones recientes han abierto la puerta al uso de modelos personalizados, que es la característica que aprovecharemos.

¿Qué es Fake Ollama?

Esta es la salsa secreta que hace posible nuestra integración. Fake Ollama, como su nombre indica, es una herramienta que crea un servidor que imita la API de Ollama, una plataforma popular para ejecutar y administrar modelos de lenguaje locales.

Muchas aplicaciones, incluidas las últimas versiones de VSCode Copilot, tienen soporte integrado para la API de Ollama. Al ejecutar Fake Ollama, podemos engañar a VSCode Copilot para que piense que se está comunicando con una instancia estándar de Ollama, mientras que, en realidad, nuestro servidor Fake Ollama está reenviando las solicitudes a la API de Kimi K2. Esto lo convierte en un puente versátil, lo que nos permite conectar prácticamente cualquier API de modelo a cualquier herramienta que admita Ollama.

Requisitos previos

Antes de comenzar, asegúrate de tener lo siguiente instalado y listo:

• Visual Studio Code: Se recomienda la última versión para garantizar la compatibilidad con las características de Copilot que utilizaremos.
• Extensión VSCode Copilot: Necesitarás una suscripción activa a Copilot y la extensión instalada en VSCode.
• Python: Se requiere una versión reciente de Python (3.8 o superior) para ejecutar el servidor Fake Ollama.
• Git: Necesitarás Git para clonar el repositorio de Fake Ollama desde GitHub.
• Una clave API de Kimi K2: Cubriremos cómo obtenerla en el primer paso.

La integración: una guía paso a paso

Ahora, manos a la obra e integremos Kimi K2 en VSCode Copilot.

Paso 1: Obtén tu clave API de Kimi K2

Tienes dos opciones principales para obtener una clave API de Kimi K2:

1. Plataforma Moonshot AI: Puedes registrarte directamente en la plataforma Moonshot AI. Esto te dará acceso directo a la API de Kimi K2.
2. OpenRouter: Este es el enfoque recomendado por su flexibilidad. OpenRouter es un servicio que proporciona una API unificada para una amplia gama de modelos de IA, incluido Kimi K2. Al usar OpenRouter, puedes cambiar fácilmente entre diferentes modelos sin cambiar tu código o claves API.

Para esta guía, asumiremos que estás usando OpenRouter. Una vez que hayas creado una cuenta y obtenido tu clave API, puedes interactuar con el modelo Kimi K2 usando la biblioteca OpenAI de Python, de la siguiente manera:Python

from openai import OpenAI

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

response = client.chat.completions.create(
  model="moonshotai/kimi-k2",
  messages=[
    {"role": "user", "content": "Escribe una función simple en Python para calcular el factorial de un número."},
  ],
)
print(response.choices[0].message.content)

Mantén tu clave API de OpenRouter a mano; la necesitarás para la configuración de Fake Ollama.

Paso 2: Configura Fake Ollama

Primero, deberás clonar el repositorio de Fake Ollama desde GitHub. Abre tu terminal y ejecuta el siguiente comando:Bash

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

Luego, navega al directorio clonado e instala las dependencias de Python requeridas:Bash

cd fake-ollama
pip install -r requirements.txt

Paso 3: Configura Fake Ollama para Kimi K2

Este es el paso más crucial. Necesitamos configurar Fake Ollama para que use nuestra clave API de OpenRouter y apunte al modelo Kimi K2. La configuración probablemente estará en un archivo .env o directamente en el script principal de Python. Para esta guía, asumiremos un archivo .env para las mejores prácticas.

Crea un archivo llamado .env en el directorio fake-ollama y agrega las siguientes líneas:

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

Al establecer estas variables de entorno, el servidor Fake Ollama sabrá cómo reenviar las solicitudes al endpoint de OpenRouter, usar tu clave API para la autenticación y especificar moonshotai/kimi-k2 como el modelo deseado.

Paso 4: Ejecuta el servidor Fake Ollama

Ahora, es hora de iniciar el servidor Fake Ollama. En tu terminal, desde el directorio fake-ollama, ejecuta:Bash

python main.py

Si todo está configurado correctamente, deberías ver un mensaje que indica que el servidor se está ejecutando, típicamente en http://localhost:11434. Este es el endpoint local que usaremos en VSCode.

Paso 5: Configura VSCode Copilot

El paso final es indicarle a VSCode Copilot que use nuestro servidor Fake Ollama local en lugar de los modelos predeterminados de GitHub Copilot.

1. Abre VSCode y ve a la vista de Copilot Chat.
2. En la entrada del chat, escribe / y selecciona "Seleccionar un modelo".
3. Haz clic en "Administrar modelos...".
4. En el cuadro de diálogo que aparece, selecciona "Ollama" como proveedor de IA.
5. Se te pedirá que ingreses la URL del servidor Ollama. Ingresa la dirección de tu servidor Fake Ollama local: http://localhost:11434.
6. A continuación, se te pedirá que selecciones un modelo. Deberías ver el modelo que especificaste en tu configuración de Fake Ollama (moonshotai/kimi-k2) en la lista. Selecciónalo.

¡Y eso es todo! Tu VSCode Copilot ahora está impulsado por el modelo Kimi K2. Puedes iniciar una nueva sesión de chat y experimentar las capacidades mejoradas de codificación y razonamiento de este potente modelo.

Más allá de la API: Uso de modelos locales con vLLM, llama.cpp y ktransformers

La belleza de la configuración de Fake Ollama es que no se limita a los modelos basados en API. También puedes usarlo como interfaz para modelos que se ejecutan localmente en tu propio hardware utilizando potentes motores de inferencia como:

• vLLM: Una biblioteca de código abierto que acelera significativamente la inferencia y el servicio de LLM.
• llama.cpp: Una implementación en C++ de los modelos LLaMA, optimizada para ejecutarse en CPUs y una amplia gama de hardware.
• ktranformers: Un marco flexible para experimentar con optimizaciones de inferencia de LLM de vanguardia. En particular, ktranformers ha anunciado soporte para Kimi K2, lo que significa que puedes ejecutar una versión cuantificada del modelo localmente.

El proceso es similar: primero configurarías y ejecutarías tu modelo deseado utilizando uno de estos motores de inferencia, que expondrá un endpoint de API local. Luego, configurarías Fake Ollama para que apunte a ese endpoint del modelo local en lugar de la API de OpenRouter. Esto te da un control completo sobre tus modelos y datos, con la desventaja de requerir hardware más potente.

Conclusión

Al aprovechar la flexibilidad del soporte de modelos personalizados de VSCode Copilot y la ingeniosidad de la herramienta Fake Ollama, puedes desbloquear un nuevo nivel de desarrollo asistido por IA. La integración de Kimi K2 proporciona un impulso significativo en la codificación, el razonamiento y la comprensión de contextos largos, haciendo de tu Copilot un socio aún más valioso.

El mundo de los modelos de lenguaje grandes está en constante evolución, y la capacidad de intercambiar y experimentar fácilmente con diferentes modelos es un cambio de juego. Ya sea que estés utilizando una API de última generación como Kimi K2 o ejecutando tus propios modelos localmente, el poder de personalizar tus herramientas está en tus manos. ¡Feliz codificación!