llama-server: API local de tipo OpenAI con llama.cpp

#¿Por qué llama-server?

Ollama, LM Studio y Jan se basan en el mismo motor subyacente: llama.cpp. Este motor incluye su propio servidor HTTP, llama-server, que no necesita ninguna de esas capas. Indicas un archivo GGUF y obtienes una API y una interfaz web. Nada más.

La ventaja no es meramente estética. Mientras que Ollama decide por ti el número de capas enviadas a la GPU, el tamaño del contexto y cómo dividir el modelo, llama-server expone cada parámetro en la línea de comandos. Puedes ver y ajustar lo que ocurre. Es el modo «manual» de la IA local: más verboso, pero sin caja negra.

API compatible con OpenAI

Endpoints /v1/chat/completions, /v1/completions, /v1/models, /v1/embeddings. Cualquier cliente OpenAI se conecta a ellos sin modificaciones.

Control del offloading

--n-gpu-layers fija precisamente cuántas capas van a la VRAM. Es indispensable cuando el modelo supera tu tarjeta.

Interfaz web integrada

Un chat servido directamente en la raíz del servidor, sin instalar Open WebUI ni Docker.

Sin dependencias pesadas

Un solo binario (algunas decenas de MB). Ni Python, ni contenedor, ni servicio del sistema obligatorio.

Batching y paralelismo

Batching continuo activado por defecto, varias solicitudes simultáneas a través de slots.

#Prerrequisitos

Un archivo GGUF

El formato de llama.cpp. Se puede obtener en Hugging Face o descargar directamente con llama-server mediante -hf (ver más abajo).

VRAM o RAM

En Q4_K_M, aprox. 2 GB para un 3B, aprox. 5 GB para un 7B, aprox. 9 GB para un 14B, aprox. 19 GB para un 32B, aprox. 40 GB para un 70B.

Una GPU (muy recomendable)

RTX 3060 de 12 GB para empezar, RTX 4070/4080 en la gama media, RTX 4090 de 24 GB o Mac M4 Pro para los modelos grandes. Usar solo la CPU funciona, pero lentamente.

Un terminal

llama-server se controla desde la línea de comandos. No es nada insuperable, pero no es una aplicación que se abra con un doble clic como LM Studio.

#1. Obtener llama-server

Tres opciones, de la más rápida a la que ofrece mayor rendimiento. En macOS, Homebrew instala el binario con un solo comando:

brew install llama.cpp

# le binaire s'appelle llama-server
llama-server --version

En Windows y Linux, lo más sencillo es descargar un binario precompilado desde las versiones oficiales de llama.cpp publicadas en GitHub (elige la variante correspondiente a tu hardware: CUDA para NVIDIA, Vulkan para una GPU genérica o CPU).

https://github.com/ggml-org/llama.cpp/releases

Para obtener el máximo de tokens por segundo, compila a partir del código fuente con el backend de tu GPU. Ejemplo para NVIDIA con CUDA:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j

# le binaire se trouve dans build/bin/
./build/bin/llama-server --version

#2. Ejecutar con un GGUF mediante un solo comando

El comando mínimo indica un modelo y arranca el servidor. Aquí, un Qwen 3.5 9B en Q4_K_M (la opción de 8 GB de referencia en 2026, 256k de contexto) con todas las capas enviadas al GPU:

llama-server -m ./qwen3.5-9b-instruct-q4_k_m.gguf -ngl 99 -c 8192

-m

Ruta al archivo GGUF que se va a servir.

-ngl 99

Número de capas transferidas a la GPU. 99 = «todas» (el modelo tiene menos; el exceso se ignora sin error).

-c 8192

Tamaño del contexto en tokens. Por defecto suele ser 4096; adáptalo según tus necesidades y tu VRAM.

No tienes el archivo a mano? llama-server puede descargarlo directamente desde Hugging Face y guardarlo en caché, como ollama pull mais integrado:

llama-server -hf bartowski/Qwen3.5-9B-Instruct-GGUF:Q4_K_M -ngl 99 -c 8192

Una vez iniciado, el servidor escucha por defecto en http://127.0.0.1:8080. Comprueba que esté activo:

curl http://localhost:8080/health
# {"status":"ok"}

#3. La API compatible con OpenAI: conectar cualquier aplicación

Es el gran argumento a favor de llama-server. Utiliza el protocolo de OpenAI, por lo que cualquier herramienta diseñada para la API de OpenAI funciona simplemente cambiando la URL base. Una llamada directa al chat con curl:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "local",
    "messages": [
      {"role": "system", "content": "Tu réponds en français, de façon concise."},
      {"role": "user", "content": "Explique le format GGUF en une phrase."}
    ],
    "temperature": 0.7
  }'

El campo model admite cualquier valor: llama-server solo sirve un modelo a la vez e ignora en gran medida este valor. En el SDK de Python de OpenAI, basta con redirigir base_url a tu servidor. La clave API puede ser cualquier cadena si no has establecido --api-key:

from openai import OpenAI

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

resp = client.chat.completions.create(
    model="local",
    messages=[
        {"role": "user", "content": "Donne-moi trois idées de noms pour un projet open source."}
    ],
)
print(resp.choices[0].message.content)

/v1/chat/completions

Modo de conversación, con aplicación automática de la plantilla de chat del modelo.

/v1/completions

Completado de texto sin procesar, sin formato de roles.

/v1/models

Lista el modelo cargado — útil para los clientes que consultan primero los modelos disponibles.

/v1/embeddings

Genera embeddings si el servidor se inicia con --embedding (útil para un RAG propio).

#4. n-gpu-layers: el offloading con control preciso que Ollama oculta

Un modelo es una pila de capas (layers). Cada capa enviada a la VRAM se calcula con el GPU, muy rápido; las que quedan en la RAM se calculan con el CPU, lentamente. --n-gpu-layers (o -ngl) determina cuántas capas van al GPU. Es el ajuste más importante para la velocidad.

-ngl 99

Todo en la GPU. Es la opción a la que conviene aspirar si el modelo cabe completamente en la VRAM. Velocidad máxima.

-ngl 20

Offloading parcial: 20 capas en la GPU y el resto en la CPU. Una solución de compromiso cuando el modelo supera la capacidad de la VRAM.

-ngl 0

Todo en la CPU. Lento, pero permite ejecutar un modelo mucho más grande de lo que admite tu tarjeta.

La estrategia: aumentar -ngl todo lo posible sin saturar la VRAM. Un 14B en Q4 (≈9 GB) cabe por completo en una RTX 3060 de 12 GB con -ngl 99. Un Qwen 3.8 27B en Q4 (≈18 GB) no cabe; en esa misma tarjeta, se transfiere solo una parte del modelo a la GPU —por ejemplo, con -ngl 40— y se acepta una ralentización.

# Qwen 3.8 27B Q4 (~18 Go) sur un GPU 12 Go : une partie sur GPU, le reste sur CPU
llama-server -m ./qwen3.8-27b-instruct-q4_k_m.gguf -ngl 40 -c 4096

Para vigilar qué cabe realmente en la VRAM durante la carga, observa nvidia-smi en otra ventana:

nvidia-smi -l 1

#5. Interfaz web incluida

No necesitas Open WebUI ni Docker para conversar: llama-server sirve una interfaz de chat directamente desde su raíz. Abre simplemente la dirección del servidor en un navegador.

http://localhost:8080

Allí encontrarás un chat completo: historial de conversación, ajuste de la temperatura y de los parámetros de muestreo, soporte para prompts de sistema y renderizado en Markdown. Es suficiente para un uso personal diario, sin instalar ninguna capa adicional.

#¿Cuándo preferir llama-server a Ollama (y cuándo no)?

llama-server y Ollama ejecutan el mismo motor. La elección es una cuestión de control frente a comodidad.

Elige llama-server

Cuando quieres ajustar finamente el offloading, probar un GGUF específico de un cuantizador dado, evitar un daemon permanente o desplegar un binario único sin dependencias en un servidor.

Elige llama-server

Cuando un modelo supera la capacidad de tu VRAM: el control directo de -ngl y de las opciones de memoria marca la diferencia entre «inutilizable» y «lento pero funcional».

Sigue usando Ollama

Cuando quieres alternar entre varios modelos sobre la marcha sin reiniciar procesos, gestionar una biblioteca con ollama pull/list o cargar y descargar modelos de la memoria automáticamente según la demanda.

Sigue usando Ollama

Cuando varias aplicaciones apuntan a modelos diferentes en el mismo puerto 11434: Ollama enruta las solicitudes e intercambia los modelos por ti, mientras que llama-server trabaja con un solo modelo por proceso.

#Solución de problemas

« CUDA out of memory » al cargar

El valor de -ngl es demasiado alto para tu VRAM. Bájalo (offloading parcial), reduce -c o pasa a una cuantización más ligera (Q4_K_M en lugar de Q5/Q8).

La tarjeta gráfica no se utiliza

El binario podría ser la variante CPU. Asegúrate de que estés usando un build CUDA/Metal/Vulkan y que -ngl sea mayor que 0. nvidia-smi debe mostrar VRAM ocupada.

Respuestas incoherentes o etiquetas visibles

El template de chat no se ha aplicado. Vuelve a iniciar con --jinja para usar el template incorporado en el GGUF.

La aplicación cliente no encuentra el modelo

Algunos clientes consultan primero /v1/models. Asigna un alias con -a e introduce ese nombre exacto en el campo model de tu aplicación.

Contexto truncado / respuestas cortadas

-c es demasiado pequeño. Aumenta el tamaño del contexto, teniendo en cuenta que un gran contexto consume más VRAM.

#Para ir más allá

llama-server ofrece todo su potencial con un llama.cpp bien compilado y un GGUF bien elegido. Estas guías del sitio complementan la puesta en marcha:

Compilar llama.cpp con CUDA

Para un binario optimizado para NVIDIA y el máximo de tokens por segundo en tu tarjeta.

Q4, Q5, Q8: ¿qué cuantización elegir?

Para encontrar el equilibrio entre calidad, velocidad y VRAM antes de descargar un GGUF.

llama.cpp vs vLLM vs Exllama

Para situar llama-server frente a otros motores de inferencia según tus necesidades de rendimiento en tokens por segundo.