Qwen3.8-27B en tu PC: IA local con una RTX 5070 Ti de 16 GB

Qwen3.8-27B es un modelo de IA de Qwen que puedes ejecutar en tu propio PC, sin mandar nada a ningún servidor. Esta guía lo pone en marcha en una NVIDIA RTX 5070 Ti de 16 GB, en Windows y en CachyOS. El método: primero que funcione de forma estable y comprobable, después más contexto y, al final, extras.

El modelo admite hasta 262.144 tokens de contexto, pero eso no es lo que cabe en 16 GB de memoria de vídeo. Aquí empezaremos con 8.192 y subiremos poco a poco.

Las versiones de los programas, los tamaños de los archivos y las opciones cambian muy deprisa. Comprueba siempre las fuentes oficiales y la ayuda de tu versión.

Cuatro conceptos

• GGUF: el formato de los modelos «comprimidos» (cuantizados) que usan llama.cpp y Ollama.
• Cuantización: cuantos menos bits, menos memoria ocupa el modelo, pero puede perder algo de calidad.
• Contexto: cuánto texto «recuerda» en una conversación (8K son 8.192 tokens). Más contexto, más memoria.
• Caché KV: la memoria que usa el contexto. La guardaremos en q8_0, que ahorra memoria con poca pérdida.

Qué versión del modelo cabe en 16 GB

El punto de partida prudente es UD-Q3_K_XL, de Unsloth en Hugging Face: pesa unos 13,1 GB. La siguiente, UD-Q4_K_M, ya pesa unos 16,5 GB y no cabe en la tarjeta antes siquiera de sumar el contexto.

Deja además unos 35 o 40 GB libres de disco para el modelo y los programas.

Comprueba tu gráfica

nvidia-smi

Tiene que aparecer la RTX 5070 Ti. Si aparece, no reinstales el driver. En Windows, si falla, actualízalo con la NVIDIA App. En CachyOS, las RTX 50 funcionan con los drivers nvidia-open que instala el propio sistema; no instales nunca el .run de NVIDIA encima.

En Windows: llama.cpp oficial

Usamos los programas ya compilados de llama.cpp, sin compilar nada. Descarga de la misma publicación los dos ZIP de CUDA para Windows x64:

1. llama-…-bin-win-cuda-…-x64.zip (el programa).
2. cudart-llama-…-win-cuda-…-x64.zip (las librerías de CUDA).

Extrae los dos en la misma carpeta, por ejemplo %USERPROFILE%\AI\llama.cpp. Si la publicación incluye hashes, compáralos con Get-FileHash archivo.zip -Algorithm SHA256.

No mezcles el programa de una publicación con las librerías de otra.

Comprueba que ve la tarjeta:

cd $HOME\AI\llama.cpp
            .\llama-server.exe --version
            .\llama-server.exe --list-devices

Tiene que salir CUDA con la RTX 5070 Ti.

En Windows: primera prueba a 8K

llama.cpp puede descargar el modelo directamente de Hugging Face:

.\llama-server.exe `
              -hf "unsloth/Qwen3.8-27B-GGUF:UD-Q3_K_XL" `
              --no-mmproj `
              --n-gpu-layers all `
              --fit off `
              --ctx-size 8192 `
              --cache-type-k q8_0 `
              --cache-type-v q8_0 `
              --flash-attn on `
              --parallel 1 `
              --host 127.0.0.1 `
              --port 8080

Abre http://127.0.0.1:8080 y prueba. En otra ventana, nvidia-smi -l 1 te enseña cuánta memoria usa.

• --n-gpu-layers all: todo el modelo en la gráfica.
• --fit off: durante las pruebas, que falle a la vista si no cabe, en vez de ajustarse sin avisar. Cuando todo funcione puedes quitarlo.
• --no-mmproj: sin la parte de visión, que consume memoria.

En Windows: más contexto y MTP

Sube paso a paso, cambiando una sola cosa cada vez:

1. 16K: --ctx-size 16384.
2. MTP, que acelera la generación usando el propio modelo para adelantar palabras: añade --spec-type draft-mtp --spec-draft-n-max 3. Compara con y sin, con la misma pregunta.
3. 24K (--ctx-size 24576), solo si 16K con MTP va estable.

MTP tiene fallos abiertos en llama.cpp. Si ves repeticiones raras o respuestas que se mezclan, vuelve a probar con --spec-type none.

Windows puede usar la RAM del sistema cuando se acaba la memoria de vídeo. Evita que falle, pero va muchísimo más lento. La RAM te da margen, no una segunda gráfica.

En CachyOS: Ollama desde el repositorio oficial

En CachyOS usamos Ollama con CUDA, del repositorio oficial, sin compilar nada:

sudo pacman -Syu
            sudo pacman -S ollama-cuda
            sudo systemctl enable --now ollama

Para que el contexto use la caché q8_0 y empiece en 8K, configura el servicio con sudo systemctl edit ollama y añade:

[Service]
            Environment="OLLAMA_FLASH_ATTENTION=1"
            Environment="OLLAMA_KV_CACHE_TYPE=q8_0"
            Environment="OLLAMA_CONTEXT_LENGTH=8192"

Reinicia el servicio con sudo systemctl restart ollama y carga la versión Q3_K_XL directamente desde Hugging Face:

ollama run hf.co/unsloth/Qwen3.8-27B-GGUF:UD-Q3_K_XL

No uses la versión por defecto de Ollama (qwen3.8:27b): pesa unos 17 GB y no cabe entera en la tarjeta. Ollama la repartiría con el procesador y sería mucho más lenta.

Comprueba con ollama ps que el modelo está 100 % en GPU, y vigila la memoria con nvidia-smi -l 1 o nvtop (sudo pacman -S nvtop).

Para subir a 16K, cambia OLLAMA_CONTEXT_LENGTH a 16384 y reinicia el servicio. Si deja de estar al 100 % en GPU, vuelve a 8K.

Con Ollama no hay MTP ni algunos ajustes finos de llama.cpp. Es el precio de usar solo paquetes del repositorio oficial: a cambio, se instala y se actualiza con el sistema.

Ajustes de respuesta recomendados por Qwen

Con razonamiento (thinking): temperature 1.0, top_p 0.95, top_k 20, min_p 0, presence_penalty 0 y repetition_penalty 1.0.

Sin razonamiento (instruct): temperature 0.7, top_p 0.80, top_k 20, min_p 0, presence_penalty 1.5 y repetition_penalty 1.0.

Para comparar dos configuraciones, deja estos valores iguales y cambia solo lo que quieras medir.

Visión, al final

El modelo entiende imágenes con un archivo extra (el proyector, mmproj-F16.gguf, de unos 0,9 GB). En Windows, pruébalo a 8K y sin MTP, con --mmproj RUTA_AL_ARCHIVO --no-mmproj-offload: esa última opción deja la memoria de vídeo para el modelo, a cambio de procesar las imágenes más despacio.

Usarlo desde otros programas

Los dos ofrecen una API compatible con la de OpenAI, solo en tu equipo:

• llama.cpp (Windows): http://127.0.0.1:8080/v1
• Ollama (CachyOS): http://127.0.0.1:11434/v1

Déjalo escuchando solo en tu equipo (127.0.0.1). No uses --host 0.0.0.0 ni abras puertos en el router sin autenticación y cortafuegos: cualquiera de tu red, o de Internet, podría usarlo.

Un script para el día a día en Windows

Guarda esto en %USERPROFILE%\AI\qwen38-27b.ps1, con el modelo ya descargado en %USERPROFILE%\AI\models\Qwen3.8-27B\:

$ErrorActionPreference = "Stop"
            $Server = "$HOME\AI\llama.cpp\llama-server.exe"
            $Model  = "$HOME\AI\models\Qwen3.8-27B\Qwen3.8-27B-UD-Q3_K_XL.gguf"
            if (-not (Test-Path $Server)) { throw "No existe llama-server: $Server" }
            if (-not (Test-Path $Model))  { throw "No existe el modelo: $Model" }
            & $Server --model $Model --n-gpu-layers all --ctx-size 16384 `
              --cache-type-k q8_0 --cache-type-v q8_0 --flash-attn on `
              --parallel 1 --no-mmproj --host 127.0.0.1 --port 8080

MTP queda fuera hasta que lo hayas probado y compruebes que te compensa.

Si no cabe en 16 GB

Por este orden, de menos a más pérdida:

1. Cierra los programas que usen la gráfica.
2. Baja el contexto: de 24K a 16K, y de 16K a 8K.
3. Desactiva MTP.
4. Caché KV en q4_0 (ahorra memoria, pero pierde precisión).
5. Solo al final, una versión del modelo con menos bits.

Si algo falla

• Windows dice que falta una DLL: el programa y las librerías de CUDA tienen que ser de la misma publicación y estar en la misma carpeta.
• --list-devices no muestra CUDA: revisa el driver y que descargaste la versión CUDA.
• CUDA va anormalmente lento: hay un fallo abierto con algunas RTX 50 y ciertas versiones del driver y de CUDA. Apunta tus versiones y prueba una publicación anterior de llama.cpp, o la versión Vulkan solo para comparar.
• La web no abre: comprueba que el servidor sigue en marcha y responde en http://127.0.0.1:8080/health.
• Ollama va lento: mira ollama ps; si no está al 100 % en GPU, baja el contexto.

Para quitarlo todo: en Windows, detén el servidor con Ctrl+C y borra la carpeta de llama.cpp y el modelo. En CachyOS, ollama rm seguido del nombre del modelo, y sudo pacman -Rns ollama-cuda. No desinstales el driver de NVIDIA para esto.

Fuentes: Qwen3.8-27B, llama.cpp, decodificación especulativa y MTP y preguntas frecuentes de Ollama.