Cómo ejecutar Qwen 3.5 en local con una sola GPU: guía paso a paso

Qwen3.5 es la última serie de modelos de Alibaba y mejora el sólido rendimiento de versiones anteriores de Qwen en tareas de razonamiento, programación y multimodales. 

Evaluaciones independientes muestran que el modelo Qwen3.5-397B-A17B obtiene puntuaciones muy altas en pruebas ampliamente utilizadas como LiveCodeBench y AIME26, superando a menudo a modelos líderes como GPT-5.2 y Claude Opus 4.5 en la mayoría de categorías evaluadas, y ofreciendo un rendimiento por segundo significativamente mayor que generaciones previas de Qwen.

Fuente: Qwen/Qwen3.5-397B-A17B · Hugging Face

En este tutorial, vamos a:

1. Revisar los requisitos para ejecutar Qwen3.5 en local
2. Configurar una máquina virtual con GPU en Hyperbolic AI
3. Instalar llama.cpp con soporte CUDA
4. Descargar el modelo Qwen3.5 desde Hugging Face
5. Arrancar un servidor de inferencia de Qwen3.5 compatible con OpenAI
6. Probar el servidor usando el SDK de OpenAI
7. Usar la WebUI de llama.cpp para crear una app sencilla de trading

Requisitos de hardware y software de Qwen3.5

Antes de ejecutar Qwen3.5 en local, asegúrate de que tu entorno cumple los requisitos de hardware y software para una inferencia fluida. En este tutorial usamos una GPU NVIDIA H200 con 141 GB de VRAM junto con 240 GB de RAM del sistema, más que suficiente para ejecutar la versión MXFP4_MOE de Qwen3.5 con offloading de MoE de forma eficiente.

Como referencia, la cuantización dinámica Unsloth de 4 bits UD-Q4_K_XL ocupa en torno a 214 GB de disco. Cabe directamente en un M3 Ultra de 256 GB, y también funciona bien con una única GPU de 24 GB y 256 GB de RAM, logrando más de 25 tokens por segundo con offloading de MoE. Cuantizaciones más pequeñas de 3 bits pueden ajustarse a 192 GB de RAM, mientras que versiones de mayor precisión (8 bits) pueden requerir hasta 512 GB entre RAM y VRAM combinadas.

En general, para un mejor rendimiento, la VRAM + RAM combinadas deberían aproximarse al tamaño del modelo cuantizado que descargues. Si no, llama.cpp puede descargar a un SSD, pero la inferencia será más lenta.

En la parte de software, deberías tener los controladores más recientes de NVIDIA instalados, junto con un CUDA Toolkit reciente, para asegurar la compatibilidad con llama.cpp y la inferencia acelerada por CUDA.

Cómo ejecutar Qwen 3.5 en local

Con los requisitos listos, veamos paso a paso cómo usar Qwen 3.5 en local: 

1. Configura tu entorno local

Para ejecutar Qwen3.5 en local, necesitas acceder a una máquina con una GPU potente. Dado que la mayoría de portátiles y PCs de sobremesa no tienen suficiente VRAM o memoria para modelos de este tamaño, usaremos una máquina virtual con GPU en la nube.

En este tutorial usamos Hyperbolic para ejecutar el modelo en privado. También puedes usar otros proveedores como RunPod, Vast.ai o cualquier plataforma de VMs con GPU que prefieras. Elegimos Hyperbolic porque actualmente ofrece instancias con GPU muy competitivas en coste.

Empieza lanzando una nueva instancia con una sola GPU H200. 

Cuando la máquina arranque, verás la IP pública y el comando SSH necesario para conectar desde tu terminal local.

Antes de conectar, asegúrate de tener SSH configurado en local y de haber añadido tu clave pública SSH al crear la máquina virtual.

Cuando la instancia esté lista, conéctate por SSH con reenvío de puertos. Es importante porque queremos acceder al servidor de inferencia de llama.cpp en local a través del puerto 8080:

ssh -L 8080:localhost:8080 root@129.212.191.53

La primera vez, escribe yes para confirmar y autentícate con tu clave SSH.

Tras iniciar sesión, verifica que la GPU se detecta correctamente:

nvidia-smi 

Deberías ver la NVIDIA H200 listada en la salida.

Por último, instala los paquetes de Linux necesarios para descargar, compilar y ejecutar llama.cpp:

sudo apt update
sudo apt install pciutils build-essential cmake curl libcurl4-openssl-dev -y

Con esto, tu entorno estará listo para instalar llama.cpp y ejecutar Qwen3.5 en local.

2. Instalar llama.cpp con soporte CUDA

llama.cpp es un motor de inferencia open source en C y C++ que permite ejecutar modelos de lenguaje grandes en local con una configuración mínima y soporta aceleración por CPU y GPU.

Primero, clona el repositorio de llama.cpp:

git clone https://github.com/ggml-org/llama.cpp

Después, configura una build con CUDA usando CMake. Activamos CUDA con -DGGML_CUDA=ON y establecemos la arquitectura CUDA en 90a porque usamos una NVIDIA H200 (clase Hopper). Así el binario aprovecha las características de Hopper.

cmake llama.cpp -B llama.cpp/build \
  -DGGML_CUDA=ON \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_CUDA_ARCHITECTURES="90a"

Ahora compila el binario del servidor. llama-server es el servidor REST integrado que te permite exponer llama.cpp como un endpoint de API:

cmake --build llama.cpp/build --config Release -j --clean-first --target llama-server

Por último, copia los binarios compilados a la carpeta principal para ejecutarlos más fácilmente:

cp llama.cpp/build/bin/llama-* llama.cpp

3. Descargar el modelo Qwen3.5

Con llama.cpp instalado, el siguiente paso es descargar los pesos del modelo Qwen3.5 en formato GGUF. Estos ficheros son grandes, por lo que usar la CLI de Hugging Face es la forma más fiable de traerlos directamente a tu máquina con GPU.

Instalamos primero Python porque las herramientas de descarga y autenticación de Hugging Face se distribuyen como paquetes de Python. Aunque llama.cpp está escrito en C++, Python facilita mucho la gestión de descargas y transferencias.

Empieza instalando pip:

sudo apt install python3-pip

Luego instala el cliente de Hugging Face Hub junto con utilidades de rendimiento. hf_transfer y hf-xet aceleran notablemente las descargas, algo clave cuando bajas cientos de gigas de ficheros de modelo:

pip -q install -U huggingface_hub hf-xet
pip -q install -U hf_transfer

Ahora descarga el modelo Qwen3.5 desde Hugging Face. En este tutorial solo traemos la variante MXFP4_MOE, optimizada para una inferencia MoE eficiente:

hf download unsloth/Qwen3.5-397B-A17B-GGUF \
   --local-dir models/Qwen3.5 \
   --include "*MXFP4_MOE*"

Cuando termine, los ficheros quedarán en models/Qwen3.5, listos para cargarlos en llama.cpp y hacer inferencia en local.

4. Arrancar el modelo Qwen3.5 en la GPU única

Ya podemos iniciar Qwen3.5 con llama-server. Esto nos da un endpoint de API compatible con OpenAI al que llamar desde herramientas y apps locales.

Hemos optimizado el servidor para una configuración de una sola GPU con tres ajustes clave. Primero, activamos --fit on para que llama.cpp equilibre automáticamente el modelo entre VRAM de GPU y RAM del sistema, en lugar de fallar cuando el modelo no cabe íntegramente en VRAM. 

Segundo, usamos una ventana de contexto mayor con --ctx-size 16384 para manejar prompts largos. Tercero, activamos --jinja y pasamos --chat-template-kwargs para controlar el formato del chat y desactivar el modo thinking, logrando respuestas más rápidas y directas.

Ejecuta el servidor con:

./llama.cpp/llama-server \
    --model models/Qwen3.5/MXFP4_MOE/Qwen3.5-397B-A17B-MXFP4_MOE-00001-of-00006.gguf \
    --alias "Qwen3.5" \
  --host 0.0.0.0 \
  --port 8080 \
  --fit on \
  --jinja \
   --ctx-size 16384 \
   --temp 0.7 \
   --top-p 0.8 \
   --top-k 20 \
   --min-p 0.00 \
   --chat-template-kwargs "{\"enable_thinking\": false}"

Mientras el modelo carga, verás que usa tanto VRAM de GPU como memoria del sistema, lo esperado para un modelo MoE grande. 

Cuando termine, el servidor quedará disponible en:

• 0.0.0.0:8080 en la VM
• http://127.0.0.1:8080 en tu máquina local tras el reenvío por SSH

Deja el servidor ejecutándose. En tu PC local, abre una nueva terminal y reconecta con reenvío de puertos por SSH:

ssh -L 8080:localhost:8080 root@129.212.191.53

Luego prueba el servidor listando los modelos disponibles:

curl -s http://127.0.0.1:8080/v1/models

Si ves Qwen3.5 en la respuesta, tu servidor funciona correctamente y ya puedes llamarlo desde el SDK de OpenAI y tus apps locales.

5. Probar el modelo Qwen3.5 con el SDK de OpenAI

Con el servidor de inferencia de Qwen3.5 en marcha, toca verificar que funciona bien con aplicaciones cliente reales. Una de las mayores ventajas de llama.cpp es que llama-server expone una API compatible con OpenAI, por lo que puedes usar el SDK oficial de OpenAI sin cambiar la estructura de tu código.

Primero, instala el paquete de OpenAI para Python en tu máquina local (o dentro de la VM si lo prefieres):

pip install openai 

Ahora ejecuta un script de prueba. Conecta con tu endpoint reenviado en local http://127.0.0.1:8080/v1 en lugar de los servidores en la nube de OpenAI.

python3 - <<'PY'
from openai import OpenAI

client = OpenAI(
    base_url="http://127.0.0.1:8080/v1",
    api_key="sk-no-key-required"
)

response = client.chat.completions.create(
    model="Qwen3.5",
    messages=[
        {"role": "user", "content": "Write one sentence about AI agents."}
    ]
)

print(response.choices[0].message.content)
PY

Algunos puntos importantes:

• base_url apunta a tu servidor local de Qwen3.5, no a la API de OpenAI.
• api_key sigue siendo requerida por el SDK, pero llama.cpp no aplica autenticación, así que cualquier valor de relleno sirve.
• El nombre model="Qwen3.5" coincide con el alias que definimos al arrancar el servidor.

Si todo está bien configurado, obtendrás una respuesta rápida y limpia del modelo.

Esto confirma que:

• El modelo Qwen3.5 se ha cargado correctamente
• El servidor de llama.cpp está funcionando
• Tu reenvío de puertos por SSH funciona
• El endpoint es totalmente compatible con aplicaciones estilo OpenAI

A partir de aquí, puedes integrar Qwen3.5 en cualquier herramienta local, flujo de agentes o aplicación que ya soporte el formato de la API de OpenAI.

6. Crear una TUI de trading con Llama.cpp WebUI

llama.cpp incluye una WebUI integrada, al estilo ChatGPT, para chatear con el modelo directamente desde tu navegador. Es útil para pruebas rápidas, iterar prompts y generar código sin escribir clientes primero. 

Como ya configuramos el reenvío de puertos por SSH, puedes abrir la WebUI en tu máquina local y se comportará como si el servidor estuviera en tu portátil.

Por defecto, la WebUI está disponible en:

http://127.0.0.1:8080

Si la página carga, confirma dos cosas: tu túnel SSH funciona y el servidor Qwen3.5 es accesible en local mientras sigue ejecutándose en privado en la VM con GPU.

Una vez en la WebUI, pega este prompt. El objetivo es que el modelo genere tanto el código en Python como una breve guía de uso.

En unos segundos, Qwen3.5 debería generar un fichero app.py y normalmente una breve explicación de cómo ejecutarlo.

Ahora cambia a tu terminal local (tu portátil). Instala las dependencias que necesita la app generada:

pip install rich yfinance

Esto instala:

• rich para el layout de la TUI, tablas, prompts e indicadores de progreso
• yfinance para obtener métricas bursátiles públicas y gratuitas

Crea un archivo llamado app.py, pega el código generado por el modelo y ejecuta:

python3 app.py

Al ejecutarlo, la TUI debería iniciarse correctamente en tu terminal. La app te pedirá los tickers que quieras analizar, el modo de filtrado y el nivel de riesgo. 

Por ejemplo, lo probamos con tres acciones populares.

Tras una breve carga, la herramienta devuelve una tabla completa de métricas, resalta los resultados según las reglas de scoring y guarda todo en el fichero results.csv.

Este es un gran ejemplo de cómo Qwen3.5 puede generar una aplicación funcional en un solo intento, usando solo un endpoint cuantizado de 4 bits y un prompt sencillo.

Reflexiones finales

Ejecutar Qwen3.5 en local es una forma potente de acceder a un modelo de vanguardia manteniendo todo en privado y bajo tu control. En este tutorial, el modelo se alojó en una única VM con GPU H200, se accedió de forma segura desde una máquina local mediante reenvío de puertos por SSH y se sirvió a través de un endpoint optimizado de llama.cpp compatible con OpenAI.

Dicho esto, conviene tener en cuenta algunas limitaciones prácticas. Como todo depende de un túnel SSH activo, la conexión debe ser estable. Si tu internet cae o la sesión se desconecta, pierdes el acceso al puerto local y a menudo tendrás que reconectar y reiniciar parte del flujo.

Otro problema habitual es compilar correctamente llama.cpp. Si no indicas la arquitectura CUDA adecuada para tu GPU, la compilación puede tardar mucho más y no optimizar del todo el hardware. Establecer la arquitectura correcta desde el principio marca una diferencia notable en tiempo de build y rendimiento.

Por último, aunque la cuantización de 4 bits MXFP4_MOE es excelente para ejecutar modelos grandes de forma eficiente, no siempre es ideal para flujos de programación con agentes. En pruebas con herramientas como Qwen Code CLI, Kilo Code CLI y OpenCode, el modelo tuvo dificultades con razonamientos más profundos y a menudo falló en bucles de generación largos, provocando incluso inestabilidad en la GPU. 

Cuantizaciones de mayor precisión o modelos más pequeños centrados en razonamiento pueden funcionar mejor para agentes de programación fiables.

Si quieres profundizar en programación con agentes, echa un vistazo a nuestro curso AI-Assisted Coding for Developers. También te recomiendo nuestra guía sobre ejecutar GLM-5 en local para programación con agentes.