Usa cualquier modelo open source sin tener una GPU

¿Quieres probar un modelo open source pero no tienes una GPU?

Hasta hace no mucho, la respuesta era bastante incómoda.

Tenías que descargar los pesos, encontrar una GPU con suficiente VRAM, configurar CUDA, levantar un servidor de inference y encargarte de que todo funcionase.

Hoy puedes hacer algo mucho más sencillo:

elegir un modelo y llamarlo mediante una API.

En este artículo vamos a utilizar Kimi K3 como ejemplo y veremos cómo podemos utilizarlo mediante Serverless Inference con Novita.

Cuando hablamos de modelos open source, solemos pensar en todo lo que hay que montar alrededor del modelo: GPU, memoria, entorno de ejecución, servidor de inference, API y escalado.

Todo esto tiene sentido si quieres operar el modelo tú mismo.

Pero muchas veces nuestro objetivo es bastante más sencillo:

Quiero utilizar el modelo dentro de mi aplicación.

No necesito necesariamente saber qué GPU lo está ejecutando, cómo está configurado el servidor o cómo se distribuye el modelo.

Aquí es donde aparece Serverless Inference.

Serverless no significa que no existan servidores.

Significa que tú no tienes que gestionarlos.

El proveedor se encarga de la infraestructura necesaria para ejecutar el modelo y tú consumes esa capacidad mediante una API.

En el caso de Novita, puedes acceder a modelos mediante una API Serverless sin tener que desplegar tú mismo la infraestructura de inference. Kimi K3 en Novita

Y esto cambia bastante la barrera de entrada para experimentar con modelos grandes.

Para verlo en la práctica vamos a utilizar Kimi K3.

Kimi K3 es un modelo MoE con 2,8 billones de parámetros totales y 104.000 millones de parámetros activos, además de una ventana de contexto de hasta 1 millón de tokens.

Es un modelo orientado especialmente a tareas de razonamiento, programación y agentes.

Lo interesante para nosotros es que podemos acceder a él mediante la API Serverless de Novita.

No necesitamos ejecutar nosotros mismos toda esa infraestructura.

Entramos en Novita y creamos una API key.

Una vez tenemos nuestra clave, podemos utilizar el modelo desde código.

Y aquí hay algo especialmente interesante:

la API es compatible con OpenAI.

Por tanto, si ya has utilizado el SDK de OpenAI, la integración resulta muy sencilla.

En Python:

pip install openai

Después creamos nuestro cliente:

from openai import OpenAI
client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.novita.ai/openai"
)

Ahora simplemente hacemos una petición:

response = client.chat.completions.create(
    model="moonshotai/kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Explain speculative decoding in simple terms"
        }
    ],
    max_tokens=1000
)
print(response.choices[0].message.content)

Y ya está.

No hemos descargado Kimi K3.

No hemos configurado CUDA.

No hemos seleccionado una GPU.

No hemos instalado un inference server.

No hemos desplegado un contenedor.

Hemos hecho una petición y hemos recibido una respuesta.

Ese es precisamente el valor de esta abstracción.

Kimi K3 se ofrece actualmente en Novita con pricing basado en tokens.

El precio que muestra actualmente Novita es de $3 por millón de tokens de entrada, $0,30 por millón de tokens leídos desde caché y $15 por millón de tokens de salida. Pricing de Kimi K3 en Novita

Esto significa que no necesitas mantener una GPU dedicada funcionando mientras no estás utilizando el modelo.

Pagas por el uso de inference.

Aquí está la parte que me parece más interesante.

La idea no es realmente Kimi K3.

Kimi K3 es simplemente nuestro ejemplo.

La idea es poder elegir un modelo open source y consumirlo mediante una API sin preocuparnos inicialmente por la infraestructura que hay detrás.

Novita ofrece un catálogo amplio de modelos y diferentes modalidades de inference.

Esto cambia la pregunta que nos hacemos como desarrolladores.

En lugar de empezar pensando:

¿Qué GPU necesito para ejecutar este modelo?

Podemos empezar pensando:

¿Qué modelo quiero utilizar?

Y después decidir cómo queremos consumirlo.

No.

Y esta distinción es importante.

Hay una diferencia entre utilizar un modelo y operar un modelo.

Si quiero consumir un modelo rápidamente y abstraer la infraestructura, una plataforma como Novita tiene mucho sentido.

Si quiero controlar directamente la GPU, el container, el runtime o el deployment del modelo, probablemente quiera una solución como RunPod.

No se trata de que una opción sea mejor que la otra.

Se trata de elegir el nivel de control que necesitas.

Creo que esta es una de las abstracciones más interesantes que estamos viendo en infraestructura de IA:

usar un modelo y operar un modelo son problemas diferentes.

Durante mucho tiempo, para utilizar un modelo open source teníamos que ocuparnos también de ejecutarlo.

Ahora podemos separar ambas cosas.

La infraestructura sigue existiendo.

Simplemente deja de ser nuestro problema.

Y eso permite que un developer pueda experimentar con modelos que, de otra forma, serían bastante difíciles de ejecutar localmente.

Si quieres probar Kimi K3 sin montar tu propia infraestructura de inference, puedes hacerlo directamente desde Novita.

Probar Kimi K3 con Novita

Y si quieres verlo paso a paso, en el vídeo de esta semana lo hago desde cero:

Cómo usar un modelo de 2,8T de parámetros sin tener una GPU.

La idea que quiero que te lleves es sencilla:

Cuando quieras probar un modelo open source, quizá la primera pregunta ya no sea “¿qué GPU necesito?”, sino “¿dónde puedo consumirlo?”

Y esa diferencia está cambiando la forma en la que construimos con IA.

Probar Kimi K3