Router de modelos locales

Por defecto, llama-server carga un solo modelo con el parámetro -m. Cada vez que quieres usar otro modelo tienes que parar el servidor y arrancarlo de nuevo con el fichero del otro modelo. Esto es incómodo cuando trabajas con un agente y quieres alternar entre un modelo potente, uno rápido u otro de razonamiento.

El modo router soluciona esto: en lugar de un modelo, le indicas una carpeta con varios modelos y llama-server los expone todos a través de la misma URL y el mismo puerto, con una API compatible con OpenAI. Tu agente pide el modelo que quiere por su id y el router lo carga (descargando el anterior si es necesario) sin que tengas que reiniciar nada.

A grandes rasgos, antes de continuar necesitas dos cosas:

1. Conocer llama.cpp: Si aún no lo tienes, primero deberías mirar la Guía de llama.cpp, que te ayuda a instalarlo. Si ya lo tienes, aunque no es obligatorio, te recomiendo pasar por la guía de Optimizar llama.cpp.

2. Un agente que hable con el router vía API compatible con OpenAI. Por ejemplo:

   • OpenCode: agente de código intuitivo y con filosofía abierta.
   • Pi: agente minimalista, ideal si te gusta configurarlo todo al máximo.

Además, ten presente tu hardware: en modo router sueles tener modelos grandes en disco, pero sólo se cargan en VRAM los que se estén usando (veremos cómo limitarlo). Tenemos disco de sobra, VRAM no.

El primer paso, antes de configurar nada, debe ser descargar los modelos en formato .gguf y guárdalos todos en la misma carpeta. Por ejemplo, puedes usar una carpeta del sistema ~/models.

Los modelos se pueden descargar desde Hugging Face. Tienes una buena lista de los mejores modelos en nuestra sección de Modelos locales. Recuerda elegir la cuantización adecuada según tu hardware: Q2 o Q3 para modelos grandes en gráficas justas, Q4 como equilibrio general, BF16 sólo para modelos muy pequeños de prueba.

Varios detalles a tener en cuenta:

• 1️⃣ El nombre del fichero importa: será el id con el que el agente pedirá ese modelo. Usa nombres descriptivos, sin espacios. Ej: Qwen3.6-35B-A3B-UD-IQ2_XXS.gguf.
• 2️⃣ Los modelos de visión (VL) necesitan su fichero mmproj-*.gguf en la misma carpeta.
• 3️⃣ No hace falta que todos los modelos quepan en VRAM a la vez: en disco pueden ocupar lo que quieras, ya limitaremos cuántos se cargan simultáneamente.

mkdir -p ~/models
ls ~/models
# Qwen3.6-35B-A3B-UD-IQ2_XXS.gguf
# Qwen3.5-9B-IQ4_NL.gguf
# Qwen3.5-0.8B-BF16.gguf
# ...

📌 Aquí puedes ver una lista curada de modelos locales para descargar.

Para utilizar llama-server en modo router, en lugar de usar -m para cargar un modelo, se usan estos tres parámetros conjuntamente:

llama-server \
  --models-dir ~/models \
  --models-max 1 \
  --no-models-autoload \
  --host 0.0.0.0 \
  --port 9931 \
  # Resto de parámetros

La explicación de estos parámetros:

Recuerda que la primera petición a un modelo tardará un poco (es el tiempo en el que carga el modelo de disco a VRAM). Las siguientes serán inmediatas hasta que cambies de modelo.

Una vez tengas el servidor llama-server arrancado, comprueba qué modelos expone ejecutando este comando. Si está funcionando correctamente el modo router, debería darte una lista con los nombres de los modelos:

curl -sL http://localhost:9931/v1/models | jq .data.[].id

También puedes abrir http://localhost:9931 en el navegador. En la interfaz web de llama.cpp hay un selector que te deja elegir qué modelo cargar, y ahí deberían aparecer todos.

Una vez superados los pasos anteriores, sólo necesitamos configurar nuestro agente para que sepa dos cosas: donde está el router y que modelos tiene disponibles:

Si utilizas el agente pi, la configuración se suele guardar en ~/.pi/agent/models.json y sólo hay que indicar una simple lista de id:

{
  "$schema": "https://pi.dev/schemas/models.schema.json",
  "providers": {
    "llamacpp": {
      "baseUrl": "http://localhost:9931/v1",
      "api": "openai-completions",
      "apiKey": "llama.cpp",
      "models": [
        { "id": "Qwen3.6-35B-A3B-UD-IQ2_XXS" },
        { "id": "Qwen3.8-27B-UD-IQ2_XXS" },
        { "id": "LFM2.5-24B-A2B-Preview-UD-Q3_K_XL" },
        { "id": "Muse-Glimmer-30B-UD-IQ2_XXS" },
        { "id": "Ornith-1.5-35B-A3B-AD-IQ3_XXS-IQ2_S" },
        { "id": "Ornith-1.5-9B-Q4_K_M" },
        { "id": "LFM2.5-8B-A1B-UD-Q4_K_M" },
        { "id": "Qwen3.5-9B-IQ4_NL" },
        { "id": "Qwen3.5-4B-UD-Q4_K_XL" },
        { "id": "Qwen3-VL-30B-A3B-Thinking-UD-IQ2_M" },
        { "id": "Qwen3.5-0.8B-BF16" }
      ]
    }
  }
}

Reorganízalos por rol para encontrarlos rápido: arriba los potentes de uso general (Qwen3.6-35B, Qwen3.8-27B), luego alternativas (LFM, Ornith, Glimmer), después los equilibrados/rápidos (9B, 4B), el de visión/thinking (VL-Thinking) y al final el diminuto de pruebas (0.8B). Los id deben coincidir con lo que devolvió /v1/models en el paso anterior (nombre del fichero, sin extensión).

Más cosas sobre el agente pi en Guía de pi.dev.

En opencode, el fichero de configuración es ~/.config/opencode/opencode.jsonc, pero el formato es distinto. Cada entrada tiene una clave local (el alias que verás en el selector, ej. qwen-35b) y dentro un modelID (el id real en el router).

Además, permite declarar capacidades y límites, que son importantes para que el agente use herramientas (tools) correctamente. Veamos el ejemplo con 3 modelos:

{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "llamacpp": {
      "name": "llama.cpp (router)",
      "package": "@opencode/ai/providers/openai-compatible",
      "settings": {
        "baseURL": "http://localhost:9931/v1",
        "apiKey": "llamacpp"
      },
      "models": {
        "qwen-36-35b": {
          "modelID": "Qwen3.6-35B-A3B-UD-IQ2_XXS",
          "name": "Qwen 3.6 35B (potente, uso general)",
          "capabilities": { "tools": true, "input": ["text"], "output": ["text"] },
          "limit": { "context": 32768, "output": 8192 }
        },
        "qwen-9b": {
          "modelID": "Qwen3.5-9B-IQ4_NL",
          "name": "Qwen 3.5 9B (equilibrado / rápido)",
          "capabilities": { "tools": true, "input": ["text"], "output": ["text"] },
          "limit": { "context": 32768, "output": 8192 }
        },
        "qwen-tiny": {
          "modelID": "Qwen3.5-0.8B-BF16",
          "name": "Qwen 3.5 0.8B (pruebas)",
          "capabilities": { "tools": false, "input": ["text"], "output": ["text"] },
          "limit": { "context": 8192, "output": 2048 }
        }
      }
    }
  }
}

Añade el resto de modelos siguiendo el mismo patrón.

Puedes encontrar aquí una Guía desde cero de OpenCode.

Una vez configurado, el flujo de trabajo es siempre el mismo:

• 1️⃣ Arranca llama-server (si usaste --no-models-autoload, arrancará sin consumir VRAM).
• 2️⃣ Abre tu agente en la carpeta del proyecto (opencode o pi).
• 3️⃣ Elige el modelo en el selector de modelos, normalmente con /models o /model.
• 4️⃣ Haz tu primera petición. La primera vez siempre tarda porque carga a VRAM.
• 5️⃣ Con --models-max 1 el router descarga el modelo anterior y carga el nuevo.

Algunos consejos que te pueden venir bien para el modo router:

• ✅ Empieza con 2-3 modelos: Uno potente, uno rápido y uno de pruebas.
• ✅ Usa siempre --models-max 1: Evitalo sólo si vas sobrado de VRAM.
• ✅ Contexto: Pon un --ctx-size que todos soporten. Mejor 64K estables que 128K inestables.
• ✅ Ajusta la temperatura a la tarea: ~0.6 para código (determinista), ~0.8-1.0 para ideas/creativo.
• ✅ Limita el thinking: El --reasoning-budget 1024 ayuda para respuestas más rápidas.
• ✅ Visión = modelo + mmproj. Sin el fichero mmproj al lado, el modelo VL funcionará sin visión.