Cómo ejecutar Qwen3.5-27B en local para coding agentico

En este tutorial, vas a configurar una instancia remota H100 SXM en Vast.ai, servir Qwen3.5-27B con vLLM, conectarlo a OpenCode y poner a prueba su capacidad de coding agentico en un proyecto real con FastAPI.

Aquí no usamos llama.cpp a propósito. Aunque llama.cpp es excelente para muchos montajes de inferencia local, ejecutar un modelo de 27B cuantizado suele implicar sacrificios: menor calidad de salida, peor desempeño en código y más fricción en la configuración. 

En modelos grandes como Qwen3.5-27B, la cuantización puede afectar de forma notable a la fiabilidad, y los despliegues locales con llama.cpp pueden volverse difíciles de gestionar si buscas un comportamiento de agente estable y cercano a producción.

En su lugar, este tutorial utiliza vLLM en una GPU H100 SXM alquilada. Así obtienes un endpoint compatible con OpenAI más estable, mejor rendimiento del modelo completo y una configuración mucho más limpia para flujos de trabajo de coding agentico.

También puedes ver nuestra guía aparte para ejecutar Qwen3.5-397B-A17B en local. 

Requisitos previos

Antes de empezar, asegúrate de tener:

• una cuenta en Vast.ai
• al menos 5 $ en créditos para alquilar una instancia con GPU
• nociones básicas de terminal Linux

Una H100 SXM es una gran elección para este montaje porque Qwen3.5-27B necesita mucha memoria y alto throughput, especialmente para ventanas de contexto largas y una inferencia fluida centrada en código.

Paso 1: lanza y accede a tu instancia de Vast.ai

Usamos Vast.ai porque es un marketplace de GPUs que suele darte mucha más flexibilidad en precio y hardware que una nube tradicional de un único proveedor. 

Puedes alquilar desde máquinas alojadas por la comunidad hasta ofertas de Secure Cloud / datacenter, que Vast marca con una etiqueta azul de datacenter. Para un montaje como este, te recomiendo elegir una de esas máquinas con etiqueta azul por su mayor fiabilidad y una experiencia más fluida.

Empieza creando una cuenta en Vast.ai y añade crédito suficiente para tu sesión. Luego abre la página de búsqueda, elige la plantilla de PyTorch con Jupyter activado, y busca una oferta de 1x H100 SXM. 

El precio cambia constantemente en Vast.ai porque es un mercado en tiempo real, así que toma cualquier tarifa por hora como aproximada, no fija.

Cuando alquiles la máquina, ve a la pestaña Instances. Cuando el estado cambie a Open, haz clic en el botón Open para abrir el portal de la instancia en tu navegador. 

Desde ahí, puedes abrir Jupyter e iniciar una sesión de terminal directamente en la máquina remota.

Para este tutorial, mantén dos terminales abiertas:

• Una terminal para servir Qwen3.5-27B con vLLM
• Otra terminal para instalar y ejecutar OpenCode

Mantener estas tareas separadas hace que el flujo sea mucho más fácil de gestionar cuando el servidor del modelo esté en marcha.

Paso 2: instala vLLM y sirve Qwen3.5

En este paso, crearás un entorno aislado de Python, instalarás vLLM y lanzarás Qwen3.5-27B como una API compatible con OpenAI con la que OpenCode pueda comunicarse. 

vLLM es un motor de inferencia de alto rendimiento para modelos de lenguaje grandes, diseñado para servir modelos de forma eficiente a través de una API.

Crea un espacio de trabajo y un entorno virtual

En tu primera terminal, crea un espacio limpio para el servidor del modelo:

mkdir qwen-servercd qwen-server/uv venv --python 3.12source .venv/bin/activate

Esto te da un entorno dedicado de Python 3.12 para que las dependencias del servidor del modelo queden aisladas del resto de la máquina.

Instala vLLM

Ahora instala vLLM:

uv pip install vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly

Con esto instalas el motor de inferencia que expondrá Qwen3.5 mediante una API compatible con OpenAI.

Nota: puede que no necesites los wheels nightly para este montaje, ya que el soporte actual de vLLM para Qwen3.5 a menudo funciona también con la instalación estándar.

Inicia el servidor de Qwen3.5

Una vez instalado vLLM, arranca el servidor del modelo con:

vllm serve Qwen/Qwen3.5-27B \
 --host 127.0.0.1 \
 --port 8000 \
 --api-key local-dev-key \
 --served-model-name qwen3.5-27b-local \
 --tensor-parallel-size 1 \
 --max-model-len 64000 \
 --enable-auto-tool-choice \
 --tool-call-parser qwen3_coder \
 --reasoning-parser qwen3

La primera vez que ejecutes este comando, vLLM descargará los archivos del modelo y el tokenizador.

Después lo cargará en la memoria de la GPU. Cuando todo esté listo, verás un mensaje indicando que el servidor se ha iniciado por completo.

Esto lanza Qwen3.5-27B en local en el puerto 8000 y protege el endpoint con la clave de API local-dev-key.

Hay algunos detalles importantes:

• --served-model-name asigna un nombre al modelo para que OpenCode lo referencie
• --enable-auto-tool-choice habilita el comportamiento tipo agente
• --tool-call-parser qwen3_coder se adapta a flujos de trabajo de Qwen orientados a código
• --reasoning-parser qwen3 ayuda a manejar correctamente la salida de razonamiento de Qwen

Deja esta terminal ejecutándose cuando el servidor esté listo.

Paso 3: instala y configura OpenCode

En este paso, abrirás una segunda terminal, instalarás OpenCode y lo conectarás al endpoint local de vLLM que iniciaste en el paso 2. 

OpenCode es un agente de coding de código abierto que puede ejecutarse en la terminal y conectarse a modelos locales mediante su configuración de proveedor.

Vuelve al portal de la instancia y abre una segunda terminal de Jupyter. Mantén la primera ejecutándose, ya que es la que sirve Qwen3.5 a través de vLLM. 

Si al hacer clic en el botón de Jupyter Terminal se abre la misma terminal, normalmente puedes abrir otra cambiando el número al final de la URL de la terminal. Por ejemplo, si tu terminal actual termina en /terminals/1, cámbialo a /terminals/2.

Esta segunda terminal será tu terminal de OpenCode, mientras la primera sigue ejecutando el servidor del modelo.

Instala OpenCode

Ejecuta el siguiente comando para instalar OpenCode:

curl -fsSL https://opencode.ai/install | bash

Luego refresca tu shell:

exec bash

Esto recarga tu shell, para que el comando opencode esté disponible al instante.

Apunta OpenCode a tu servidor local de vLLM

OpenCode busca su configuración global en ~/.config/opencode/opencode.json, y sus ajustes de proveedor admiten valores personalizados de baseURL y apiKey. Esto encaja bien con un servidor local compatible con OpenAI como el que lanzaste con vLLM.

Crea el archivo de configuración con:

mkdir -p ~/.config/opencode && cat > ~/.config/opencode/opencode.json <<'EOF'
{
 "$schema": "https://opencode.ai/config.json",
 "provider": {
   "vllm": {
     "npm": "@ai-sdk/openai-compatible",
     "name": "Local vLLM",
     "options": {
       "baseURL": "http://127.0.0.1:8000/v1",
       "apiKey": "local-dev-key"
     },
     "models": {
       "qwen3.5-27b-local": {
         "name": "Qwen3.5-27B Local"
       }
     }
   }
 },
 "model": "vllm/qwen3.5-27b-local",
 "small_model": "vllm/qwen3.5-27b-local"
}
EOF

Esto le indica a OpenCode que use tu endpoint local de vLLM en http://127.0.0.1:8000/v1 en lugar de una API alojada. También usa la misma clave de API que estableciste al lanzar el servidor de vLLM en el paso 2, para que OpenCode pueda autenticarse correctamente.

Paso 4: conecta OpenCode al modelo local

Ahora crea un directorio de proyecto para probar el agente de coding:

mkdir investment-apicd investment-apiopencode

Esto lanza OpenCode dentro de la carpeta investment-api y utiliza tu modelo local de Qwen3.5 como backend. 

Desde aquí puedes pedirle que inspeccione archivos, explique código o genere nuevos componentes del proyecto usando el modelo que corre en tu GPU alquilada.

Paso 5: prueba Qwen3.5 en una tarea real de código

Ha llegado el momento de poner a prueba todo el montaje en una tarea real.

Empecé con un prompt muy simple para comprobar que todo funcionaba. En un segundo obtuve respuesta, una buena señal de que el modelo estaba bien conectado.

Después le di una tarea de coding agentico más realista:

"Build a FastAPI backend for investment market data that 
collects the latest public data every few minutes for S&P 500, 
gold, silver, Brent, major indices, and selected stocks."

Tras alrededor de un minuto razonando, el modelo empezó a hacer preguntas de seguimiento útiles. Preguntó qué fuente de datos usar, qué tipo de almacenamiento o base de datos prefería y qué tickers incluir. 

Buena señal, porque mostraba que no se lanzaba a escribir código a ciegas: primero buscaba aclarar requisitos.

Con eso, creó un plan y empezó a trabajar paso a paso. Dividió el problema en tareas pequeñas, las añadió a su lista de pendientes y fue completándolas una a una.

En menos de cinco minutos, ya había creado la estructura completa del proyecto y generado un backend con FastAPI que funcionaba casi al completo. Muy rápido para una tarea así.

Después le pedí probar la API y ejecutar un smoke test. El resultado fue una API financiera casi operativa. Quedaban algunos flecos por pulir, pero para una sesión tan corta, el rendimiento fue muy convincente.

Reflexiones finales

Ya tenemos un entorno completo de coding en local ejecutándose en una instancia H100 SXM de Vast.ai alquilada. En este tutorial hemos usado vLLM para servir Qwen3.5-27B mediante una API compatible con OpenAI y hemos conectado ese endpoint con OpenCode para usar el modelo en un flujo de trabajo agentico.

Este enfoque nos da una forma práctica de ejecutar un modelo open-weight potente para programar en tareas reales sin depender de un proveedor alojado. Además, nos da más control sobre todo el stack, desde el servidor del modelo hasta la interfaz de coding.

Comparado con intentar correr un modelo de 27B muy cuantizado en local con llama.cpp, este montaje suele ser más estable y más adecuado para trabajo serio con código. Evitamos muchos de los sacrificios de rendimiento, limitaciones de memoria y problemas de configuración que aparecen al forzar modelos grandes en un entorno puramente local.

Otra gran ventaja es el rendimiento. Con este montaje logramos un throughput muy alto de tokens por segundo, una longitud de contexto amplia y una experiencia de programación mucho más fluida. Esto lo hace mucho más práctico para prompts largos, tareas multiarchivo y flujos de trabajo tipo agente, donde el modelo necesita espacio para razonar y seguir más contexto.