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

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.
| Área | Cambio en 1.0.0 | Acción recomendada |
|---|---|---|
| Versionado | Las incompatibilidades de la API pública de C y la ABI afectan a la versión principal | Fijar una versión o commit en producción |
| API de C | Se eliminan 35 funciones obsoletas y llama_set_warmup | Actualizar los bindings y recompilar |
| Configuración del contexto | Se eliminan defrag_thold y --defrag-thold | Quitar las opciones antiguas |
| Decodificación especulativa | NextN API pasa a llama.h y se renombra una función | Actualizar inclusiones y llamadas |
| Caché KV | Se admite f8_e4m3 para K y V | Medir memoria, calidad y compatibilidad |
| Inferencia MoE | Una caché de expertos en GPU permite procesar ciertos fallos de caché en CPU | Revisar la GPU y ajustar tamaño y proporción de CPU |
| Seguridad del servidor | Nuevas restricciones para herramientas y URL privadas de medios | Revisar la exposición de red y la autenticación |
| Compatibilidad de modelos | Kimi-K3.1-Pro, Ripple, xing4_0 y nuevas funciones multimodales | Comprobar los requisitos de carga |
| API de voz | Endpoint /v1/audio/speech compatible con OpenAI | Probarlo 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:
| Componente | Cuándo cambia | Ejemplo |
|---|---|---|
| MAJOR | Cambio incompatible en la API pública de C | 1.x.x a 2.0.0 |
| MINOR | Función compatible, nuevo backend, modelo o ampliación de API | 1.0.0 a 1.1.0 |
| PATCH | Corrección de errores sin cambios en la API | 1.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_tholdde la configuración del contexto. - Quita
--defrag-tholdde los scripts de inicio. - Sustituye
llama_set_embd_state_srcporllama_set_ctx_state_srccuando 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:
- Localiza un símbolo relevante en un archivo fuente largo.
- Prepara una modificación que abarque varios archivos.
- Genera una llamada estructurada a una herramienta.
- 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ón | Función | Valor predeterminado |
|---|---|---|
-cmoe | Mantener todos los pesos de expertos MoE en la memoria de CPU | Desactivado salvo que se indique |
--moe-cache-mib N | Reservar N MiB de caché de GPU para expertos residentes en CPU | 0, desactivado |
--moe-cache-cpu-share F | Procesar en CPU una proporción F de los fallos cuando la caché esté llena | 0 |
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-originsy 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:
- Fija los fuentes de
v1.0.0o un artefacto de compilación exacto. - Elimina
--defrag-tholdy las llamadas a API de C retiradas. - Recompila los bindings nativos con los nuevos encabezados públicos.
- Empieza con la configuración anterior de caché KV FP16.
- Prueba FP8 KV por separado y compara memoria, velocidad, corrección del código y llamadas a herramientas.
- Ajusta la caché MoE solo con un backend GPU compatible y expertos residentes en CPU.
- Revisa la autenticación de herramientas y las restricciones de URL privadas.
- Comprueba
/v1/models, chat, llamadas a herramientas y el cliente de programación. - 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.