Ejecuta un modelo de código local con llama.cpp y conéctalo a VS Code

Los agentes de programación con IA pueden leer un repositorio, redactar parches, ejecutar la batería de tests y explicar código que nunca has visto, y los equipos van notablemente más rápido gracias a ellos. Lo que sigue en discusión es la factura. Los agentes autónomos devoran tokens: una sola petición como «refactoriza este módulo y arregla los tests que fallan» puede consumir cien mil tokens de entrada antes de producir una sola línea de código.

Entre pagar por token y renunciar a la IA hay un camino intermedio: alojar el modelo tú mismo. Un portátil con GPU dedicada puede ejecutar un modelo de código competente mediante llama.cpp, exponerlo como una API HTTP compatible con OpenAI y conectarlo a VS Code con las extensiones Cline o Kilo Code. Cada token extra no cuesta nada y ningún dato sale de tu red. Esta es una configuración que funcionó.

Qué necesitas antes

Hardware: se recomienda mucho una GPU NVIDIA dedicada, y cuanta más VRAM, mejor. Los portátiles corporativos típicos traen unos 8 GB, suficiente si eliges con cuidado el modelo y la cuantización. La RAM del sistema también cuenta, porque vas a mandar a propósito parte del modelo allí.

Software: instala el CUDA Toolkit, versión 13.3 o posterior, desde la página de descargas de NVIDIA, con el instalador exe local para tu plataforma. Aporta las bibliotecas y APIs que reservan VRAM y ejecutan el modelo en la tarjeta gráfica, y también lo necesitarías si algún día compilas llama.cpp por tu cuenta. Además querrás un navegador y una cuenta de Hugging Face para descargar los pesos.

Conseguir llama.cpp

llama.cpp es aquí el motor de inferencia. Está escrito en C y C++, ejecuta modelos GGUF con eficiencia en hardware normal, aprovecha CUDA e incluye un servidor HTTP que imita la API de OpenAI, que es la función en la que se apoya toda esta configuración.

Coge el código fuente del repositorio de llama.cpp, y ten en cuenta que hay binarios precompilados para Windows y Linux en su página de releases. Descarga la build que corresponda a tu versión de CUDA, por ejemplo un paquete win-cuda-13.3-x64. No hace falta compilar nada. Descomprímelo en algún sitio sencillo, como D:\ai\.

Importan dos ejecutables:

• llama-cli.exe ofrece un chat interactivo en la terminal, útil para comprobar la instalación.
• llama-server.exe levanta un servidor HTTP con un endpoint /v1 al estilo de OpenAI y una interfaz de chat en el navegador.

Elegir el modelo

Todo lo demás es mecánico. Es en la elección del modelo donde ganas o pierdes. Descarga el formato .gguf desde Hugging Face, porque es el que lee llama.cpp.

Ajusta el modelo a la tarea en lugar de esperar que uno lo haga todo:

• Programar y trabajar con agentes en el IDE es el caso exigente. El agente necesita seguir bien las instrucciones, llamar a herramientas de forma fiable y tener una ventana de contexto grande para sostener varios archivos a la vez. Qwen3.6 35B A3B rinde bien aquí y es la opción por defecto para el trabajo con agentes en el IDE. Sus builds GGUF se pueden descargar del repositorio de unsloth, y los modelos densos pequeños cubren el resto.
• Las preguntas rápidas, los resúmenes y los mensajes de commit van perfectamente con un modelo denso mucho más pequeño, que se notará más ágil. Tanto Cline como Kilo Code permiten asignar un modelo pequeño y ligero a estas tareas secundarias, aparte del modelo principal de código.
• Razonar sobre documentos largos exige longitud de contexto más que número de parámetros, y conviene dejar VRAM para la caché KV.

Prefiere los modelos Mixture-of-Experts. El «A3B» del nombre significa 35 mil millones de parámetros en total y solo unos 3 mil millones activos por token. Obtienes el conocimiento de un modelo grande casi a la velocidad de uno pequeño, así que en hardware limitado un MoE supera con holgura a un modelo denso de calidad comparable.

Elige la cuantización con honestidad. La cuantización es el nivel de compresión de los pesos: cuanto más bajo el número Q, más pequeño el archivo y peor la calidad de salida. El tamaño del archivo es una buena aproximación de cuánta VRAM y RAM ocupará el modelo. Con 4 a 8 GB de VRAM, empieza a buscar en el rango de Q4 a Q2, como UD-IQ4_XS o UD-IQ2_M. Si dudas, dale a cualquier asistente de IA tus especificaciones, primero la VRAM y luego la RAM, y pregúntale qué cuantización usar. Son dos minutos y compensan.

Primero, una prueba de humo

Comprueba que todo funciona antes de tocar VS Code. Abre una consola en la carpeta de llama.cpp y ejecuta:

"D:\ai\llama-b9590-bin-win-cuda-13.3-x64\llama-cli.exe" -m "D:\ai\llms\Qwen3.6-35B-A3B-UD-IQ2_M.gguf"

Comprueba dos cosas. Primero, que aparece el banner, el modelo carga y puedes chatear en la terminal, con una velocidad en tokens indicada. En una GPU de portátil RTX PRO 2000 el resultado fue de unos 18 tokens por segundo para el prompt y 30 para la generación. Segundo, abre el Administrador de tareas, luego Rendimiento y luego GPU, y confirma que la memoria dedicada de la GPU sube. Si no se mueve, el modelo se está ejecutando en la CPU y tienes un problema de CUDA o de drivers. Arregla eso primero, porque si no todo lo demás será inservible de lento.

Arrancar el servidor

Ahora va en serio. llama-server ofrece tanto la interfaz en el navegador como la API con la que hablará tu IDE:

"D:\ai\llama-b9590-bin-win-cuda-13.3-x64\llama-server.exe" ^
  -m "D:\ai\llms\Qwen3.6-35B-A3B-UD-IQ2_M.gguf" ^
  --host 0.0.0.0 ^
  --port 8080 ^
  -ngl all ^
  -c 64000 ^
  -fa on ^
  --cache-type-k q4_0 ^
  --cache-type-v q4_0 ^
  --n-cpu-moe 22 ^
  -b 2048 ^
  -ub 2048 ^
  --no-mmap ^
  --reasoning off ^
  --reasoning-format none ^
  --reasoning-budget 0

Espera al mensaje de que el servidor escucha en el puerto 8080 y todos los slots están libres, luego abre http://localhost:8080 en un navegador y saluda.

Qué hacen los flags

No copies ese comando a ciegas. Estos son los ajustes que tocarás cuando un modelo no quepa.

• Lo básico: -m es el archivo de pesos, --port fija el puerto HTTP de la interfaz y la API, y --host 0.0.0.0 escucha en todas las interfaces para que se conecten otras máquinas de la LAN, mientras tú sigues usando localhost en local.
• Ubicación en la GPU: -ngl all lleva las capas estándar, es decir, los bloques de atención y los pesos no MoE, a la VRAM. --n-cpu-moe 22 deja en la RAM del sistema los pesos de expertos de ese número de capas para no desbordar la VRAM, y es tu principal mando de ajuste en una GPU pequeña.
• Memoria y contexto: -c 64000 limita la ventana de contexto en tokens, y más contexto cuesta más memoria. -fa on activa los kernels de FlashAttention, que aceleran el procesamiento del prompt y recortan el consumo de VRAM. --cache-type-k y --cache-type-v con q4_0 guardan las cachés de claves y valores en 4 bits, un gran ahorro con contexto largo.
• Rendimiento: -b y -ub fijan el tamaño de lote para el prefill del prompt y el microlote de la GPU. Mantenlos iguales para el mejor rendimiento. --no-mmap carga todo el modelo en memoria física de entrada en lugar de paginarlo.
• Salida de razonamiento: --reasoning off, --reasoning-format none y --reasoning-budget 0 desactivan el manejo integrado de la cadena de pensamiento, evitan que aparezcan etiquetas think en el stream y dan al razonamiento explícito un presupuesto de cero tokens.

Ese último grupo importa más de lo que parece. Las extensiones de agentes esperan una salida de llamadas a herramientas limpia y analizable, y dejar trazas de razonamiento en el stream es un motivo frecuente de que un modelo local «simplemente no funcione» con un agente.

Cuando el modelo no quepa, no saltes enseguida a una cuantización menor. Hazlo en este orden: reduce -c, luego sube --n-cpu-moe y después cuantiza la caché KV. Normalmente encontrarás sitio.

Ejecutarlo como servicio

Dejar una ventana de consola abierta indefinidamente es frágil. Windows permite registrar llama-server.exe como servicio para que el endpoint vuelva tras un reinicio. En una máquina compartida del equipo, en vez de portátiles individuales, esto es prácticamente obligatorio, y conviene poner TLS delante con --ssl-cert-file y --ssl-key-file, para que los prompts y el código nunca crucen la red sin cifrar.

Conectar VS Code

El valor de un endpoint compatible con OpenAI es que las extensiones de agentes ya saben usarlo. Instala Cline desde el marketplace de VS Code. En el primer arranque te pregunta cómo quieres usarlo. Elige la opción de traer tu propia clave de API, luego abre Settings y API Configuration y rellena:

• Provider: la entrada OpenAI Compatible.
• Dirección: http://0.0.0.0:8080/v1, ajustada si tu servidor usa otro host o puerto.
• API Key: ninguna.
• Model ID: el nombre exacto que indica el servidor, como Qwen3.6-35B-A3B-UD-IQ2_M.
• Context Window Size: 64000.

Haz coincidir la ventana de contexto con el valor de -c con el que arrancaste. Si Cline cree que tiene 128K mientras el servidor solo reservó 64K, tendrás errores de truncado a mitad de tarea y un agente desorientado.

En Advanced, plantéate activar modelos separados para los modos Plan y Act. Un modelo de razonamiento más potente redacta el plan y uno más rápido lo ejecuta, algo igual de útil en local que con APIs alojadas.

Kilo Code funciona casi igual. Añade un proveedor personalizado, dale un ID como llamacpp, apunta la Base URL al /v1 de tu servidor y descubrirá el modelo servido. Una lección aprendida a las malas: elige el modelo explícitamente en vez de fiarte del predeterminado, y repite esa elección para cada modo (Code, Ask, Debug, Orchestrator y Plan) en la configuración global.

La seguridad, lo primero

Un solo ajuste erróneo en una extensión de agentes puede mandar el código fuente de tu empresa a internet. Ejecutar en local sirve precisamente para evitarlo, así que protégelo con cuidado.

• Revisa la Base URL cada vez. Debe apuntar a tu propio host. Si apunta a otro sitio, tu código va allí.
• Desactiva la telemetría. En Cline, desmarca los informes de errores y de uso en los ajustes generales.
• Desactiva herramientas web como la navegación y la búsqueda salvo que tengas un motivo aprobado.
• Desactiva los servidores MCP que no controles, y deja la ejecución de shell en preguntar en lugar de permitir.
• No actives nunca el modo YOLO en una base de código corporativa. Ejecutar tareas generadas por un agente sin confirmación es tan temerario como suena.
• Usa TLS siempre que el servidor no esté en localhost. Para un escritorio compartido del equipo, sirve HTTPS e instala el certificado del servidor en cada máquina cliente, en Windows mediante certutil.
• No subas código ni diseños a servidores externos. La inferencia local existe para que no tengas que hacerlo.

¿Merece la pena?

Haz las cuentas y lo local gana con facilidad. Una licencia de programación de pago supone una cuota fija por persona y un límite mensual de tokens. Las APIs de pago por uso crecen al ritmo del uso, y con buenas herramientas el uso se dispara. Un servidor llama.cpp en tu propia máquina solo cuesta electricidad y una GPU que ya tienes.

Las contrapartidas son honestas. Los modelos locales son más lentos que los alojados de primera línea y más flojos en razonamiento realmente difícil, y los propios ajustes de Cline advierten que funciona mejor con modelos punteros. No esperes sustituir a tu mejor modelo alojado en decisiones de arquitectura.

Pero la arquitectura no es donde se va la mayoría de los tokens. El grueso se va en código repetitivo, refactorizaciones, andamiaje de tests, explicaciones de código, mensajes de commit y ediciones repetitivas, y un modelo de código MoE bien elegido se encarga de todo eso en tu propio hardware con coste marginal cero, mientras tu propiedad intelectual se queda en casa. Usa primero tu propia GPU y reserva las licencias de pago para el trabajo que de verdad las necesita.