Guía de Llama.CPP | AI.MANZ.DEV

1. Introducción

Para comenzar a usar modelos de IA local necesitamos un motor de inferencia que cargue los modelos. Para ello vamos a utilizar llama.cpp. Sin embargo, este motor debe comunicarse con nuestra GPU (tarjeta gráfica) a través de un backend que depende, entre otras cosas, del sistema operativo que usemos y la marca de nuestra tarjeta gráfica:

GPU

BACKEND

LLAMA.CPP

Necesitaremos seguir los siguientes pasos:

Instalar los drivers actualizados de la GPU
Elegir e instalar un backend apropiado
Instalar Llama.CPP para su uso posterior

2. Instalación de drivers (GPU)

Antes de continuar, selecciona tu tarjeta gráfica:

Asegúrate de tener los últimos drivers de nVIDIA instalados.

Una vez instalados puedes testear desde una terminal si tu sistema detecta correctamente la GPU:

nvidia-smi

Asegúrate de tener los últimos drivers de AMD instalados.

3. Elegir el backend apropiado

Ahora necesitamos instalar y configurar el backend para comunicar la gráfica con nuestro motor de inferencia. Para ello tenemos que elegir uno de los siguientes. Observa que depende del sistema operativo y de nuestra tarjeta gráfica (y no todos los backends ofrecen el mismo rendimiento):

Backend	Rendimiento	Nvidia	AMD	Observaciones
CUDA (Nvidia)	🟩🟩🟩🟩🟩	✅	❌
ROCm/HIP (AMD)	🟩🟩🟩🟩🟩	❌	✅
Vulkan	🟩🟩🟩🟩⬛	✅	✅
CPU/RAM	🟨🟨⬛⬛⬛	❌	❌	Opción ideal para sistemas sin GPU (o poco potentes).

Accede a la sección releases de llama.cpp y descarga la versión adecuada para tu sistema operativo.

Selecciona tu sistema operativo:

Descarga el fichero Windows x64 (CUDA13) y el fichero CUDA 13.3 DLLs. Descomprime ambos ficheros en una carpeta, por ejemplo, en C:\llama.cpp. Si experimentas problemas, baja y prueba con las versiones de CUDA 12.

Si utilizas Linux (o quieres usar llama.cpp desde Windows con WSL), para usar CUDA debes compilar llama.cpp, adaptándolo a tu hardware específico. Los pasos que deberías dar son los siguientes:

# Preparamos compilación
sudo apt update
sudo apt install -y git build-essential cmake libopenblas-dev
sudo apt install -y ccache libssl-dev # opcional, recomendable

# Descargamos llama.cpp
cd ~
git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp

# Instalamos CUDA Toolkit
wget https://developer.download.nvidia.com/compute/cuda/13.3.0/local_installers/cuda_13.3.0_610.43.02_linux.run
sudo sh cuda_13.3.0_610.43.02_linux.run

# Compilamos llama.cpp
cmake -B build -DGGML_CUDA=ON -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS
cmake --build build --config Release -j$(nproc)

Una vez hecho esto, comprobamos que todo ha compilado correctamente:

./build/bin/llama-cli --version
version: 9518 (7c158fbb4)
built with GNU 13.3.0 for Linux x86_64

# Si nos da la versión correctamente, instalamos en el sistema
sudo cmake --install build
sudo ldconfig

# Ahora podremos llamarla desde cualquier ruta
llama-server --version

Si experimentas problemas con CUDA o compilarlo te parece muy complicado, tu opción ideal es utilizar Vulkan.

En el caso de Windows, descarga Windows x64 (HIP) y descomprimes en una carpeta, por ejemplo, en C:\llama.cpp.
En el caso de Linux, descarga Ubuntu x64 (ROCm 7.2) y descomprimes en una carpeta, por ejemplo, en /opt/llama.cpp.

Si experimentas problemas con CUDA, tu opción alternativa es probar Vulkan.

Vulkan ofrece algo menos de rendimiento que CUDA o ROCm, pero es la opción multiplataforma ya que está disponible tanto para Windows como para Linux, soportando tanto Nvidia como AMD.

En el caso de Windows, descarga Windows x64 (Vulkan) y descomprimes en una carpeta, por ejemplo, en C:\llama.cpp.
En el caso de Linux, descarga Ubuntu x64 (Vulkan) y descomprimes en una carpeta, por ejemplo, en /opt/llama.cpp.

Si no tienes una tarjeta gráfica potente, puedes hacer inferencia mediante CPU. Ofrece un rendimiento muy bajo, pero en sistemas potentes con mucha RAM puede ser una opción.

En el caso de Windows, descarga Windows x64 (CPU) y descomprimes en una carpeta, por ejemplo, en C:\llama.cpp.
En el caso de Linux, descarga Ubuntu x64 (CPU) y descomprimes en una carpeta, por ejemplo, en /opt/llama.cpp.

4. Uso

Llama.cpp tiene ficheros binarios ejecutables para múltiples casos de usos, pero el principal que vamos a utilizar es llama-server. Mi recomendación es bajar un modelo pequeño que, aunque será algo tonto, será lo suficientemente rápido para testear y probar si funciona todo bien.

Para la prueba, vamos a utilizar el modelo Qwen 3.5 0.8B sin cuantizar. Vamos a descargarlo y guardarlo en nuestra carpeta de llama.cpp.

Una vez descargado, vamos a activarlo con llama-server. Desde una terminal en la carpeta de llama.cpp escribimos el siguiente comando:

llama-server -m Qwen3.5-0.8B-BF16.gguf

Nos aparecerá mucha información, hasta que se detenga y aparezca un mensaje similar al siguiente:

llama_server: server is listening on http://127.0.0.1:8080

¡Felicidades! Ya lo tenemos listo. Esto significa que ahora podemos acceder a la página http://127.0.0.1:8080 donde encontrarás una interfaz de chat similar a ChatGPT para probar el modelo. Al escribir un mensaje, verás debajo una barra con la cantidad de tokens procesados, el tiempo que tardó en generarse y la velocidad en tokens/seg. Esta métrica es una de las más importantes, y el objetivo es que sea lo más alta posible.

Además de esto, llama-server expone una API añadiendo los parámetros --host 0.0.0.0 --port 8080 (el puerto es personalizable). Esto significa que cualquier sistema que pueda acceder a nuestra IP, puede utilizar llama-server e incluso conectarlo a agentes u otros programas.

Recuerda que Qwen es un modelo muy pequeño, orientado a dispositivos móviles y tareas de automatización muy sencillas. Nosotros lo usamos sólo para asegurarnos de que funciona todo bien antes de continuar. Te recomiendo visitar la sección Modelos Qwen para encontrar un modelo más potente (y con mayor cuantización para reducir su tamaño) y que se ajuste a tu hardware.

5. Optimización

Imaginemos que vamos a cargar un modelo en un equipo con 16GB de VRAM (GPU). Si quieres afinar al máximo el rendimiento de un modelo local, puedes utilizar los siguientes parámetros en llama-server:

#!/bin/bash

llama-server \
  -m qwen3.6-35b-a3b-iq2_xxs.gguf \
  --n-gpu-layers 999 \
  --ctx-size 64000 -ctk q4_0 -ctv q4_0 \
  --flash-attn on \
  --reasoning-budget 1024 \
  --poll 100 \
  --batch-size 256 --ubatch-size 256 --cont-batching \
  --threads 8 --threads-batch 8 \
  --mlock \
  --no-warmup \
  --fit off \
  --cache-reuse 256 \
  --jinja \
  --parallel 1 \
  --temp 0.6 --top-k 20 --top-p 0.95 --min-p 0.0 \
  --port 8999

More info for parameters

Parameter	Description
-m	Ruta del modelo a usar. Unsloth Qwen3.6 35B A3B cuantizado a IQ2_XXS (~11GB)
--n-gpu-layers	El modelo cabe entero en la GPU. Intenta pasar a GPU todo lo que pueda.
--ctx-size	Ventana de contexto (~64K tokens) KV cuantizados a 4 bits.
--flash-attn	Activado reduce el uso de VRAM en contextos grandes (> 16K)
--reasoning-budget	Límite de tokens para el razonamiento (-1 = sin limite)
--poll	Reduce latencia entre tokens manteniendo un hilo de CPU constante al 100%.
--batch-size	Flujo de procesamiento (tamaño de colas)
--ubatch-size
--cont-batching
--threads	CPU/Threads: En caso de usar CPU, uso de CPU y threads.
--threads-batch
--mlock	Bloquea el contenido alojado en RAM, evitando que se mueva a disco
--no-warmup	Salta calentamiento. Primera petición tarda algo más pero server arranca rápido.
--fit	Desactiva ajuste automatico cuando no cabe en VRAM.
--cache-reuse	Reutiliza hasta 256 tokens del KV cache.
--jinja	Activa el motor de plantillas. Necesario en Qwen3 y su formato de thinking.
--parallel	Solo un usuario/agente. Subir solo si se usan subagentes.
--temp	Temperatura: Aleatoriedad, más bajo = más determinista
--top-k	Filtra tokens muy improbables (solo 20 más probables)
--top-p	Considera tokens por encima de 95% de probabilidad
--min-p	Tercer filtro. Desactivado.
--port	Puerto del servidor