llama.cpp 1.0.0: cambios de API, caché FP8 y seguridad

Actualiza llama.cpp y ggml a 1.0.0 sin interrumpir tus agentes de programación locales. Elimina las funciones C y opciones de desfragmentación retiradas, compara la memoria y precisión de la caché KV FP8, ajusta la caché de expertos MoE y comprueba las restricciones de herramientas y URL privadas de llama-server. También explica cómo fijar versiones y cuándo deben actuar los usuarios de Ollama y LM Studio.

Índice
llama.cpp 1.0.0: cambios de API, caché FP8 y seguridad

Antes de actualizar a llama.cpp 1.0.0, revisa tus bindings de C, los argumentos de inicio y la configuración de seguridad de llama-server. La versión publicada el 13 de noviembre de 2026 elimina API obsoletas, incorpora la caché KV FP8 y añade controles para la caché de expertos MoE. Si utilizas un modelo local como backend de un agente de programación, actualiza primero un servidor de pruebas y comprueba tanto las respuestas normales como las llamadas a herramientas.

La publicación también establece una política de versionado para libllama y libggml. A partir de ahora, los cambios incompatibles de la API pública de C requieren incrementar la versión principal.

Esto facilita planificar las actualizaciones de dependencias. No garantiza que permanezcan idénticos los resultados del modelo, el rendimiento, los backends de GPU o todos los endpoints HTTP.

¿Qué cambia en llama.cpp 1.0.0?

Los cambios afectan principalmente a quienes integran llama.cpp en sus aplicaciones, administran llama-server u optimizan la memoria de inferencia local.

ÁreaCambio en 1.0.0Acción recomendada
VersionadoLas incompatibilidades de la API pública de C y la ABI afectan a la versión principalFijar una versión o commit en producción
API de CSe eliminan 35 funciones obsoletas y llama_set_warmupActualizar los bindings y recompilar
Configuración del contextoSe eliminan defrag_thold y --defrag-tholdQuitar las opciones antiguas
Decodificación especulativaNextN API pasa a llama.h y se renombra una funciónActualizar inclusiones y llamadas
Caché KVSe admite f8_e4m3 para K y VMedir memoria, calidad y compatibilidad
Inferencia MoEUna caché de expertos en GPU permite procesar ciertos fallos de caché en CPURevisar la GPU y ajustar tamaño y proporción de CPU
Seguridad del servidorNuevas restricciones para herramientas y URL privadas de mediosRevisar la exposición de red y la autenticación
Compatibilidad de modelosKimi-K3.1-Pro, Ripple, xing4_0 y nuevas funciones multimodalesComprobar los requisitos de carga
API de vozEndpoint /v1/audio/speech compatible con OpenAIProbarlo con un modelo de voz admitido

Los detalles aparecen en las notas de lanzamiento de v1.0.0 y en el anuncio oficial sobre el versionado.

El proyecto declara compatibilidad con más de 150 variantes de arquitecturas de modelos. Esto no significa que todos los checkpoints y sus funciones sean compatibles con cualquier backend.

¿Qué implica el versionado semántico a partir de 1.0.0?

La política de compatibilidad cubre las interfaces públicas de C declaradas en ./include, incluidas las que exponen llama.cpp y ggml.

Los responsables establecen estas reglas:

ComponenteCuándo cambiaEjemplo
MAJORCambio incompatible en la API pública de C1.x.x a 2.0.0
MINORFunción compatible, nuevo backend, modelo o ampliación de API1.0.0 a 1.1.0
PATCHCorrección de errores sin cambios en la API1.0.0 a 1.0.1

Los ejemplos ilustran las reglas. No representan futuras versiones anunciadas.

Si compilas una aplicación con libllama, tendrás menos riesgo de encontrar cambios inesperados en las firmas de funciones públicas dentro de la misma versión principal.

Sin embargo, esta promesa no cubre automáticamente los encabezados internos, símbolos sin documentar, argumentos de CLI, detalles de las respuestas HTTP ni el comportamiento de los modelos.

¿Cómo fijar la versión de llama.cpp?

Al compilar llama.cpp como dependencia, utiliza una etiqueta de lanzamiento específica o un commit inmutable.

La guía oficial de compilación explica cómo obtener el código y utilizar CMake. Combina ese procedimiento con la etiqueta v1.0.0.

Ejemplo en Bash:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
git fetch --tags
git checkout v1.0.0

cmake -B build
cmake --build build --config Release

Son los comandos documentados para una compilación básica con CPU. Algunas plataformas pueden activar otros backends por defecto. Comprueba la configuración antes de asumir qué dispositivo ejecutará el modelo.

Para la compilación estándar, la documentación sitúa el ejecutable en ./build/bin/llama-server. Algunos generadores de CMake pueden producir una estructura diferente.

Añade las opciones de CMake documentadas si necesitas un backend de GPU concreto.

En producción, registra la etiqueta, el hash del commit, las opciones de compilación y el backend de ejecución. Prueba cada actualización antes de sustituir el binario operativo.

Si una aplicación incluye su propia versión de llama.cpp, fija también la versión del paquete o wrapper. Su número de versión puede ser distinto del motor incluido.

¿Qué funciones y argumentos se eliminaron?

La primera tarea de migración consiste en retirar las interfaces C obsoletas y el antiguo umbral de desfragmentación.

La limpieza de API del PR #30565 elimina 35 funciones obsoletas, llama_set_warmup y la configuración del umbral de desfragmentación.

Revisa estos cambios:

  • Elimina las llamadas a llama_set_warmup.
  • Elimina defrag_thold de la configuración del contexto.
  • Quita --defrag-thold de los scripts de inicio.
  • Sustituye llama_set_embd_state_src por llama_set_ctx_state_src cuando corresponda.
  • Actualiza las inclusiones y declaraciones de NextN API, ahora expuestas mediante llama.h.

Las 35 funciones eliminadas no tienen necesariamente un reemplazo individual. Compara los encabezados de v1.0.0 con los símbolos que utiliza realmente tu binding.

Cómo eliminar —defrag-thold de los scripts

Una configuración anterior podía iniciar el servidor así:

./build/bin/llama-server \
  -m /path/to/model.gguf \
  -c 32768 \
  --defrag-thold 0.1

En 1.0.0 elimina el argumento:

./build/bin/llama-server \
  -m /path/to/model.gguf \
  -c 32768

No necesitas elegir otro valor para el umbral. El parámetro completo ha desaparecido. No inventes una opción equivalente sin documentación.

Busca los nombres antiguos en scripts de shell, configuraciones de Docker, servicios y código fuente:

grep -RInE \
  'defrag[_-]thold|llama_set_warmup|llama_set_embd_state_src' \
  ./scripts ./config ./src

Ajusta los directorios a tu proyecto. Si alguna ruta no existe, elimínala del comando.

Comprueba también las variables de entorno y los wrappers que generan argumentos de inicio automáticamente.

Cómo actualizar bindings de C y Python

Si compilas directamente contra llama.h, compara las declaraciones de tu código con los encabezados de v1.0.0.

Después recompila la aplicación y comprueba los mensajes del compilador y del enlazador.

Para Python, verifica primero si la versión del wrapper declara compatibilidad con llama.cpp 1.0.0.

Cambiar el ejecutable de llama.cpp no actualiza por sí solo las definiciones compiladas de una extensión de Python.

Algunos wrappers incluyen una copia propia del código fuente de llama.cpp. En ese caso, sigue el proceso de actualización que admita el proyecto. No sustituyas manualmente la biblioteca compartida sin comprobar la compatibilidad.

Un import correcto solo confirma una parte del funcionamiento. Carga un modelo, genera tokens y prueba las operaciones de estado del contexto o decodificación especulativa que utilice tu aplicación.

¿Cómo activar la caché KV FP8 en llama.cpp 1.0.0?

Utiliza -ctk f8_e4m3 -ctv f8_e4m3 para solicitar almacenamiento FP8 para las claves y los valores de atención.

La caché KV conserva información de tokens anteriores. Así, el modelo puede continuar generando sin volver a calcular todo el contexto.

Cuanto más amplio sea el contexto, mayor suele ser la memoria necesaria para esta caché.

FP8 utiliza 8 bits por valor, frente a los 16 bits de FP16. Para tensores con dimensiones equivalentes, el almacenamiento bruto de K/V podría reducirse aproximadamente a la mitad.

Esta estimación no incluye los pesos del modelo, metadatos, factores de escala, alineación de memoria ni buffers de cálculo. No implica una reducción del 50% de toda la VRAM utilizada.

Establece primero una referencia con FP16

Utiliza el mismo modelo y tamaño de contexto en ambas pruebas.

Inicia el servidor con FP16:

./build/bin/llama-server \
  -m /path/to/model.gguf \
  -c 32768 \
  --host 127.0.0.1 \
  --port 8080 \
  -ctk f16 \
  -ctv f16

Anota la memoria asignada a la caché KV según los registros. Guarda también la memoria libre, la velocidad de procesamiento del prompt y la velocidad de generación.

Detén el servidor y ejecuta la variante FP8:

./build/bin/llama-server \
  -m /path/to/model.gguf \
  -c 32768 \
  --host 127.0.0.1 \
  --port 8080 \
  -ctk f8_e4m3 \
  -ctv f8_e4m3

La versión también incorpora escalas estáticas opcionales por tensor para la caché FP8.

Revisa los registros para confirmar los tipos de caché seleccionados y las asignaciones de memoria.

Que un argumento sea aceptado no demuestra que tu backend de GPU admita todas las rutas de ejecución optimizadas con ese formato.

¿FP8 permite duplicar la longitud del contexto?

No necesariamente. FP8 reduce el almacenamiento de los tensores KV, pero no elimina los límites del modelo ni los de la memoria disponible.

Supongamos una carga hipotética donde la caché KV FP16 consume 8 GiB. Una representación FP8 de las mismas dimensiones podría reducir los datos brutos a aproximadamente 4 GiB.

Es un cálculo teórico, no un resultado medido en llama.cpp.

La memoria liberada podría permitir un contexto mayor o más solicitudes simultáneas. No amplía la capacidad efectiva del modelo por encima de sus límites admitidos.

FP8 también utiliza menor precisión. La documentación del lanzamiento no establece una mejora ni una pérdida universal de calidad en programación o llamadas a herramientas.

Para un agente de código, compara FP16 y FP8 con las mismas tareas:

  1. Localiza un símbolo relevante en un archivo fuente largo.
  2. Prepara una modificación que abarque varios archivos.
  3. Genera una llamada estructurada a una herramienta.
  4. Continúa la tarea después de varios turnos largos de conversación.

Revisa la corrección del código y los argumentos de las herramientas. No te limites a comparar tokens por segundo.

¿Cómo funciona la nueva caché de expertos MoE?

La caché MoE puede ayudar cuando un modelo Mixture-of-Experts mantiene pesos de expertos en la RAM del sistema en lugar de guardarlos todos en la GPU.

Un modelo MoE selecciona ciertos expertos para procesar cada token. Transferir sus pesos desde la RAM hacia la GPU puede ralentizar la decodificación.

La caché mantiene en la memoria de GPU los expertos residentes en CPU que más se utilizan. Un control adicional permite procesar parte de los fallos de caché en la CPU.

No es lo mismo que la caché KV FP8. La caché MoE gestiona pesos de expertos; la caché KV conserva estados de atención.

La guía oficial de caché MoE documenta estas opciones:

OpciónFunciónValor predeterminado
-cmoeMantener todos los pesos de expertos MoE en la memoria de CPUDesactivado salvo que se indique
--moe-cache-mib NReservar N MiB de caché de GPU para expertos residentes en CPU0, desactivado
--moe-cache-cpu-share FProcesar en CPU una proporción F de los fallos cuando la caché esté llena0

El intervalo documentado de CPU share es de 0 a 1.

Estas son las reglas de funcionamiento:

  • Los aciertos de caché se procesan en GPU.
  • Antes de que se llene, los expertos que faltan se transfieren a GPU.
  • Una vez llena, la CPU procesa la proporción configurada de fallos.
  • Los demás fallos requieren transferir los pesos para ejecutarlos en GPU.
  • Los lotes grandes todavía pueden necesitar transferencias de expertos.

La ejecución en CPU puede ser ventajosa cuando leer los pesos desde la RAM resulta más rápido que transferirlos a la GPU.

La memoria de host fijada, o pinned memory, modifica esa comparación. Si las transferencias ya aprovechan bien el enlace disponible, aumentar CPU share puede aportar poco o incluso empeorar el rendimiento.

Ejemplo: caché de expertos MoE residentes en RAM

Necesitas un backend de GPU compatible y suficiente memoria de dispositivo libre para alojar la caché.

Una compilación que solo utiliza CPU no puede ofrecer esta caché de expertos en GPU.

Si usas NVIDIA y dispones del entorno de desarrollo CUDA necesario, las instrucciones oficiales para CUDA indican:

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

Para otras GPU compatibles, utiliza las opciones de compilación documentadas para su backend.

Ejemplo con un modelo MoE compatible y un binario con soporte GPU:

./build/bin/llama-server \
  -m /path/to/moe-model.gguf \
  -cmoe \
  -c 32768 \
  --host 127.0.0.1 \
  --port 8080 \
  --moe-cache-mib 2048 \
  --moe-cache-cpu-share 0.5

-cmoe mantiene los pesos de expertos en RAM. --moe-cache-mib 2048 solicita 2,048 MiB de memoria GPU para los expertos seleccionados.

El valor 0.5 asigna a la CPU el 50% de los fallos de caché después de que esta se llene.

Antes de llenarse, los fallos siguen provocando transferencias a GPU. Los aciertos también se ejecutan en GPU.

Es un ejemplo de configuración, no una recomendación universal para cualquier equipo.

La memoria de GPU también debe albergar capas del modelo, caché KV y buffers de cálculo. Reservar más espacio para expertos deja menos memoria para esos elementos.

Si la asignación no cabe, reduce la caché o revisa la distribución de pesos. La caché MoE no garantiza que un modelo demasiado grande pueda ejecutarse.

Utiliza el script de ajuste de caché

El proyecto proporciona una herramienta para buscar una configuración adecuada a tu hardware.

Desde el repositorio de llama.cpp, ejecuta:

python3 scripts/moe-cache-tune.py -- \
  ./build/bin/llama-server \
  -m /path/to/moe-model.gguf \
  -cmoe \
  -t 8 \
  -c 32768

El script de ajuste inicia el servidor con distintos tamaños de caché y proporciones de CPU.

La guía oficial describe seis mediciones: dos tamaños de caché combinados con proporciones 0, 0.5 y 0.95.

Con esos resultados, el script estima otras configuraciones. Muestra velocidades medidas, rendimiento previsto y argumentos recomendados.

Mantén los ajustes reales de modelo, hilos de CPU, tamaño del contexto y distribución de expertos. Todos afectan tanto a la velocidad como a la memoria disponible.

La caché documentada está dirigida principalmente a la decodificación de lotes pequeños. Los lotes grandes todavía pueden necesitar cargar expertos en GPU.

Si el modelo es denso o todos sus expertos ya caben en GPU, probablemente no obtendrás ventaja con esta caché. Empieza con su valor predeterminado desactivado.

¿Qué cambió en la seguridad de llama-server?

La versión 1.0.0 añade permisos explícitos para exponer herramientas sin autenticación y para acceder a URL de medios en redes privadas.

Estas opciones merecen especial atención cuando el servidor acepta conexiones desde otros equipos.

—allow-unauthenticated-tools

--allow-unauthenticated-tools permite utilizar herramientas del servidor, servidores MCP o un proxy MCP en una dirección distinta de loopback sin API key.

La referencia oficial de parámetros indica que este permiso está desactivado por defecto y recomienda utilizarlo solo en redes de confianza.

La dirección 127.0.0.1 limita las conexiones a la propia máquina. En cambio, escuchar en 0.0.0.0 puede permitir conexiones desde otras interfaces de red.

Por tanto, revisa cualquier combinación de acceso no local, herramientas del servidor o MCP activados y ausencia de API key.

El argumento que concede el permiso es:

--allow-unauthenticated-tools

No lo añadas automáticamente para resolver problemas tras actualizar. Permite acceso sin autenticación a capacidades sensibles del servidor.

Esta opción regula herramientas ejecutadas por el servidor y MCP. Que el modelo devuelva un objeto estructurado tool_calls es una parte distinta del flujo del agente.

Si desarrollas en la misma máquina, prefiere un servidor local:

./build/bin/llama-server \
  -m /path/to/model.gguf \
  --host 127.0.0.1 \
  --port 8080 \
  --jinja

Para clientes remotos, configura autenticación con la opción documentada --api-key y añade controles de red adecuados.

En Bash, introduce la clave sin mostrarla en pantalla:

read -rs LLAMA_SERVER_API_KEY && export LLAMA_SERVER_API_KEY

Inicia el servidor usando la variable de entorno:

./build/bin/llama-server \
  -m /path/to/model.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  --jinja \
  --api-key "$LLAMA_SERVER_API_KEY"

Mantén el servicio protegido mediante controles de red. Una API key no garantiza por sí sola la seguridad de cualquier implementación pública.

—media-allow-private-urls

El segundo cambio afecta a las URL HTTP(S) de medios recibidas por el servidor, como los enlaces a imágenes.

Por defecto, el servidor no permite cargar medios desde direcciones locales o privadas.

La opción para permitirlo es:

--media-allow-private-urls

Cuando está activada, el servidor puede acceder a recursos HTTP(S) alojados en direcciones locales o privadas.

Puede ser útil si una aplicación de confianza sirve imágenes desde un sistema interno.

Pero aumenta el riesgo de SSRF si un cliente no confiable controla las URL. Un atacante podría conseguir que el servidor solicite recursos internos que no debería consultar.

Siempre que sea posible, envía los datos de imagen directamente mediante un formato admitido o utiliza un alojamiento de medios controlado.

Si necesitas acceder a URL privadas, limita quién puede enviar solicitudes y qué destinos puede alcanzar el servidor. No habilites el argumento únicamente para procesar un enlace desconocido.

Otras correcciones de seguridad

El lanzamiento también incluye cambios relacionados con:

  • Validación de --cors-origins y comparación de orígenes.
  • Protección frente a DNS rebinding.
  • Correcciones de SSRF a través del proxy CORS.
  • Restricciones al acceso directo del navegador a instancias secundarias.
  • Limitación de los destinos que pueden recibir HF_TOKEN.
  • Cancelación de llamadas MCP al desconectarse el cliente o agotarse el tiempo de espera.

El envío de HF_TOKEN queda restringido a los hosts de huggingface.co.

En los agentes de programación, cancelar llamadas MCP puede evitar que sigan ejecutándose herramientas innecesarias después de que el cliente se desconecte.

Sin embargo, la notificación de cancelación no garantiza deshacer operaciones que una herramienta externa ya haya completado.

Consulta PR #32113, PR #32115 y las notas de v1.0.0 para revisar estos cambios.

¿Cómo comprobar el backend de un agente de programación local?

Prueba primero la generación de respuestas del servidor. Después conecta Claude Code, OpenCode u otro cliente.

Inicia llama-server en loopback con un modelo de instrucciones adecuado:

./build/bin/llama-server \
  -m /path/to/coding-model.gguf \
  --alias local-coder \
  -c 32768 \
  --host 127.0.0.1 \
  --port 8080 \
  --jinja

El modelo debe admitir el comportamiento de llamadas a herramientas que espera el cliente.

--jinja activa el procesamiento de plantillas de chat. No añade capacidades de uso de herramientas a un modelo que no las tenga.

Consulta el endpoint de modelos con curl:

curl --fail-with-body \
  http://127.0.0.1:8080/v1/models

La respuesta debería incluir el alias configurado para el modelo.

Después envía una solicitud de chat sencilla:

curl --fail-with-body \
  http://127.0.0.1:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "local-coder",
    "messages": [
      {
        "role": "user",
        "content": "Explain what a Git diff shows in one sentence."
      }
    ],
    "max_tokens": 100
  }'

Comprueba que recibes una respuesta dentro de choices.

Cuando funcione, configura el cliente mediante su mecanismo documentado de proveedor personalizado. La URL base de la API local compatible con OpenAI es:

http://127.0.0.1:8080/v1

La compatibilidad con OpenAI Chat Completions no implica compatibilidad completa con Anthropic Messages API ni OpenAI Responses API.

Claude Code puede necesitar un adaptador de protocolo u otra integración compatible para conectarse al servidor local.

OpenCode puede utilizar un proveedor personalizado compatible cuando la API y el modelo coinciden con su configuración.

Antes de usar el agente en un repositorio real, verifica que puede leer un archivo, proponer una edición y realizar una llamada a herramienta.

Una respuesta de texto correcta no demuestra que funcionen los argumentos estructurados, las ediciones de archivos o las sesiones largas.

Si estás evaluando Kimi, revisa la guía para configurar Kimi K3.1 Pro con Claude Code y Codex. La guía de pesos abiertos y licencia de Kimi K3.1 Pro ayuda a distinguir los requisitos de ejecución local y los de una API alojada.

¿Deben actualizar los usuarios de Ollama y LM Studio?

Si utilizas Ollama o LM Studio como aplicación terminada, no sustituyas manualmente las bibliotecas internas de llama.cpp.

Estas aplicaciones administran sus propias versiones del motor, distribuciones y pruebas de compatibilidad.

Que exista llama.cpp 1.0.0 no significa que todas las aplicaciones dependientes lo incluyan de inmediato.

Consulta las notas de versión y utiliza el mecanismo de actualización de cada aplicación para identificar el runtime que realmente incorpora.

Presta atención cuando ocurra alguno de estos cambios:

  • La nueva versión menciona explícitamente llama.cpp 1.0.0 o modificaciones relacionadas.
  • Aparecen nuevos formatos de caché KV u opciones de caché MoE.
  • Cambian los requisitos de autenticación para herramientas del servidor o MCP.
  • La carga del modelo o las llamadas a herramientas funcionan de otra manera tras actualizar.

Para un uso normal de chat en escritorio, puedes seguir con una versión compatible que funcione correctamente si no necesitas un arreglo o función nueva.

Si utilizas Ollama o LM Studio como backend de un agente, prueba toda la conexión entre cliente y servidor después de cada actualización.

¿Cuándo conviene pasar a una API alojada?

La inferencia local resulta útil mientras tu equipo pueda ejecutar el modelo elegido con el contexto y la velocidad que necesitas.

La caché KV FP8 puede reducir el consumo de memoria. La caché MoE puede ayudar en ciertas cargas con expertos en RAM. Ninguna resuelve todos los límites del hardware ni garantiza una mayor velocidad de programación.

Si los pesos, la caché de atención o las solicitudes concurrentes superan la memoria disponible, compara un modelo local más pequeño con uno alojado.

Una API alojada evita administrar directamente la memoria GPU de ese modelo. A cambio, introduces latencia de red, costes por uso y dependencia del proveedor.

BetterToken ofrece una opción de acceso a varios modelos mediante API con pago por uso. No sustituye la ejecución local de llama.cpp ni proporciona sus funciones de seguridad del servidor.

Antes de elegir un servicio alojado, revisa el coste del modelo y de tu carga en la página de precios actualizados.

Si necesitas alternar entre un modelo local y uno alojado, mantén dos configuraciones de proveedor probadas por separado.

No presupongas que el mismo ID de modelo, formato de herramientas o mecanismo de autenticación funcionará en ambos endpoints.

Lista de comprobación para actualizar con seguridad

Antes de trasladar un backend de programación a llama.cpp 1.0.0 en producción, verifica lo siguiente:

  1. Fija los fuentes de v1.0.0 o un artefacto de compilación exacto.
  2. Elimina --defrag-thold y las llamadas a API de C retiradas.
  3. Recompila los bindings nativos con los nuevos encabezados públicos.
  4. Empieza con la configuración anterior de caché KV FP16.
  5. Prueba FP8 KV por separado y compara memoria, velocidad, corrección del código y llamadas a herramientas.
  6. Ajusta la caché MoE solo con un backend GPU compatible y expertos residentes en CPU.
  7. Revisa la autenticación de herramientas y las restricciones de URL privadas.
  8. Comprueba /v1/models, chat, llamadas a herramientas y el cliente de programación.
  9. Conserva el binario y la configuración anterior para poder revertir la actualización.

llama.cpp 1.0.0 establece límites más claros para la compatibilidad de sus bibliotecas públicas de C. Aun así, una actualización segura requiere comprobar tus bindings, tu hardware, la exposición del servidor y el flujo real del agente.

¿Quieres optimizar tu flujo de trabajo con LLM?

Conecta modelos mediante una API, gestiona claves y controla el gasto en IA.

Empezar gratis