AirLLM: ejecutar LLM de 70B con solo 4 GB de VRAM

AirLLM es una biblioteca de inferencia en Python que carga un modelo grande capa por capa desde disco, de modo que puedes ejecutar un LLM de 70B en una sola GPU de 4 GB sin cuantización, destilación ni poda. El repositorio lyogavin/airllm en GitHub supera las 21.000 estrellas y afirma soportar incluso Llama 3.1 405B en 8 GB de VRAM con las optimizaciones adecuadas. No sustituye a LM Studio ni a Ollama para el día a día: es la herramienta que abre la puerta cuando tu tarjeta gráfica es demasiado pequeña para cargar el modelo entero en memoria.

Si ya has leído nuestra guía de mejores PCs para IA local, sabes que la VRAM suele ser el cuello de botella. AirLLM ataca ese cuello de otra forma: en lugar de meter todo el modelo en la GPU, solo mantiene en VRAM la capa que está calculando en ese instante y el resto vive en disco (o en RAM del sistema, según la configuración). El precio es velocidad. La recompensa es acceso a modelos que, de otro modo, serían imposibles en tu hardware.

Navegación rápida

Salta directamente a lo que buscas:

Qué es AirLLM | Cómo funciona | AirLLM vs LM Studio y Ollama | Requisitos | Instalación | Compresión 4/8 bits | Modelos soportados | macOS | Cuándo usarlo | FAQ

Qué es AirLLM

AirLLM es software open source (licencia Apache-2.0) creado por Gavin Li. Su propuesta es simple y llamativa: reducir el uso de memoria de inferencia para que modelos que normalmente exigen decenas de gigabytes de VRAM puedan ejecutarse en hardware modesto.

La API se parece a la de Hugging Face Transformers: instalas el paquete, cargas un modelo con AutoModel.from_pretrained() y llamas a generate(). La diferencia está debajo del capó: en la primera ejecución, AirLLM descompone el modelo en fragmentos por capa y los guarda en disco. En cada paso de inferencia carga solo la capa activa en la GPU.

Según el README del proyecto (actualizado a agosto de 2024 con soporte para Qwen 2.5 y Llama 3.1), las cifras de referencia son:

Estas cifras son aspiracionales del repositorio, no benchmarks independientes de Converly. Pero encajan con la lógica del enfoque: si no cargas el modelo entero, la VRAM deja de ser el límite duro y el disco (o la RAM) pasa a serlo.

Cómo funciona la inferencia por capas

La mayoría de motores de inferencia local —LM Studio, Ollama, llama.cpp con GPU offload completo— intentan mantener todo el modelo (o la mayor parte) en VRAM para maximizar tokens por segundo. Eso explica por qué una RTX 3060 de 12 GB ejecuta Llama 8B holgadamente pero se ahoga con un 70B, como detallamos en la guía de GPUs para LLM locales.

AirLLM invierte la prioridad:

1. Primera ejecución: descarga el modelo de Hugging Face, lo parte en capas y escribe los fragmentos en la caché (por defecto, la carpeta de caché de Hugging Face).
2. Inferencia: para cada capa del forward pass, carga los pesos desde disco → GPU → calcula → descarga.
3. Resultado: VRAM mínima, pero mucho más tiempo esperando lecturas de disco.

Piénsalo como leer un libro enciclopédico página a página en lugar de tenerlo entero sobre el escritorio. Puedes «leer» un volumen enorme con una mesa pequeña; solo que tardas más en pasar de una página a la siguiente.

El proyecto añade prefetching (v2.5+) para solapar carga y cómputo, y compresión por bloques (v2.0+) que reduce el tamaño de cada fragmento en disco sin cuantizar activaciones, solo pesos. Eso importa porque el cuello de botella real suele ser el ancho de banda de lectura, no el cómputo en sí.

AirLLM frente a LM Studio, Ollama y cuantización

No compiten en la misma categoría. Compiten por el mismo problema: «quiero un modelo grande en hardware pequeño».

Regla práctica: si tu objetivo es programar con IA todos los días, quédate con LM Studio u Ollama y un modelo que quepa en tu VRAM. Si tu objetivo es probar un 70B o un 405B en el portátil de 4 GB que tienes en el cajón, AirLLM es la herramienta interesante.

La cuantización y AirLLM no son excluyentes: el proyecto permite compression='4bit' o '8bit' con bitsandbytes para acelerar la lectura de pesos comprimidos.

Requisitos de hardware y disco

GPU y sistema

• NVIDIA con CUDA es el camino documentado para Linux y Windows.
• macOS en Apple Silicon está soportado desde la v2.8.2 (necesitas mlx, torch y Python nativo según el README).
• CPU inference llegó en la v2.10.1 para modelos no fragmentados.

La VRAM puede ser pequeña; el disco no. El README advierte explícitamente: en la primera ejecución, AirLLM descompone y guarda el modelo capa a capa. Un Llama 70B en FP16 son del orden de 140 GB en disco antes de cualquier compresión. Si te quedas sin espacio, verás errores del tipo MetadataIncompleteBuffer en safetensors —el FAQ del repo lo atribuye casi siempre a disco lleno.

Espacio en disco orientativo

Planifica el doble del tamaño del modelo original si quieres conservar la copia de Hugging Face y los fragmentos transformados. El parámetro delete_original=True borra la copia original tras la transformación y ahorra espacio a cambio de no poder volver atrás sin redescargar.

Instalación y primera inferencia

Paso 1: instalar

pip install airllm

Para compresión, añade bitsandbytes y asegúrate de tener una versión reciente:

pip install -U airllm bitsandbytes

Paso 2: script mínimo

from airllm import AutoModel

MAX_LENGTH = 128
model = AutoModel.from_pretrained("garage-bAInd/Platypus2-70B-instruct")

input_text = ["¿Cuál es la capital de España?"]

input_tokens = model.tokenizer(
    input_text,
    return_tensors="pt",
    return_attention_mask=False,
    truncation=True,
    max_length=MAX_LENGTH,
    padding=False,
)

generation_output = model.generate(
    input_tokens["input_ids"].cuda(),
    max_new_tokens=20,
    use_cache=True,
    return_dict_in_generate=True,
)

print(model.tokenizer.decode(generation_output.sequences[0]))

La primera llamada tardará mucho: está partiendo y guardando el modelo. Las siguientes serán más predecibles, aunque siguen limitadas por disco.

Paso 3: modelos con acceso restringido

Algunos modelos en Hugging Face requieren token:

model = AutoModel.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    hf_token="TU_TOKEN_DE_HUGGINGFACE",
)

Configuraciones útiles

Compresión 4bit y 8bit

Desde AirLLM 2.0, puedes activar compresión por bloques sin pasar por un pipeline de cuantización clásico de activaciones:

model = AutoModel.from_pretrained(
    "garage-bAInd/Platypus2-70B-instruct",
    compression="4bit",  # o "8bit"
)

El autor describe hasta 3× de mejora de velocidad con pérdida de precisión «casi ignorable», porque el cuello de botella es la lectura de disco, no la aritmética en GPU. Es un matiz importante frente a la cuantización agresiva de GGUF: aquí comprimes pesos para que viajen más rápido del SSD a la GPU, no para encajar un modelo en 8 GB de VRAM con calidad degradada.

Si ya dominas Q4_K_M en LM Studio, piensa en la compresión de AirLLM como optimización de almacenamiento y transferencia, no como sustituto de una GPU con VRAM suficiente para inferencia fluida.

Modelos soportados

AirLLM mantiene AutoModel para detectar la arquitectura automáticamente. Según el README, la lista incluye:

• Llama 2 / Llama 3 / Llama 3.1 (incluido 405B en configuraciones recientes)
• Mixtral (AirLLMMixtral)
• Qwen / Qwen 2.5
• ChatGLM
• Baichuan
• Mistral
• InternLM
• Formatos safetensors (top modelos del open LLM leaderboard a fecha de 2023/2024 según el autor)

Error frecuente del FAQ: cargar Qwen o ChatGLM con la clase equivocada (AirLLMLlama2). Usa siempre AutoModel.from_pretrained(...).

AirLLM en macOS

Desde la v2.8.2, el proyecto documenta ejecución en Apple Silicon. Necesitas MLX y PyTorch instalados; solo chips Apple M están soportados, no Intel.

Para muchos usuarios de Mac, la ruta más cómoda sigue siendo LM Studio con memoria unificada —lo cubrimos en la guía de mini PCs y DGX Spark—. AirLLM en Mac tiene sentido si quieres reproducir notebooks del repositorio o experimentar con el mismo código Python que en Linux.

Cuándo tiene sentido (y cuándo no)

Sí usa AirLLM si…

• Tienes poca VRAM pero SSD rápido y espacio de sobra.
• Quieres evaluar un modelo enorme antes de invertir en hardware.
• Trabajas en notebooks de investigación o pipelines Python batch, no chat interactivo.
• Necesitas reproducir resultados del repositorio para un paper o una PoC.

No uses AirLLM si…

• Buscas tokens por segundo para programar o escribir con IA. Usa LM Studio + un modelo que quepa en VRAM, o enruta tareas rutinarias a local con Converly LM mientras Claude se queda con el razonamiento pesado.
• Tu disco es lento o casi lleno. El proyecto fallará de formas crípticas.
• Necesitas API OpenAI-compatible para herramientas como Claude Code sin trabajo extra. Ese camino pasa por cambiar el motor a silicio local, no por AirLLM directamente.

En Converly vemos AirLLM como puente de acceso, no como stack de producción. Para clientes que despliegan agentes en producción, el diseño habitual sigue siendo: modelo acotado en VRAM suficiente, servidor estable (LM Studio, vLLM, Ollama) y orquestación en la capa de aplicación. AirLLM encaja en la fase de «¿merece la pena este modelo en nuestro caso?» antes de comprar otra GPU.

Preguntas frecuentes

¿AirLLM sustituye a la cuantización GGUF?

No exactamente. GGUF/Q4 reduce el tamaño del modelo para que quepa en VRAM y corra rápido. AirLLM reduce la VRAM en uso cargando capas desde disco; puede ir más lento. Son complementarios si activas compression='4bit' en AirLLM.

¿Puedo usar AirLLM con Claude Desktop o Claude Code?

No de forma nativa. AirLLM expone una API Python, no un servidor OpenAI/Anthropic listo para conectar. Para Claude, monta LM Studio u Ollama como servidor y, si quieres ahorrar tokens, añade Converly LM en el medio.

¿Por qué falla con MetadataIncompleteBuffer?

Casi siempre disco lleno durante la primera descomposición del modelo. Libera espacio en la caché de Hugging Face, borra descargas a medias y vuelve a ejecutar.

¿Cuánta VRAM necesito de verdad?

El README cita 4 GB para 70B y 8 GB para 405B con su enfoque por capas. En la práctica, deja margen para el framework y la capa activa. Si tienes 8–12 GB, la experiencia sigue siendo lenta pero más estable que intentar cargar el modelo entero.

¿Es apto para producción?

Para inferencia interactiva de baja latencia, no. Para experimentación, benchmarking offline o validar si un modelo grande aporta calidad suficiente en tu dominio, sí.

---

Lecturas relacionadas

• LM Studio 2026: instalación y primer modelo
• Mejores GPUs para LLM locales
• Mejores PCs para IA local
• Recortar tu factura de Claude Code con Converly LM

Última actualización: junio de 2026. Cifras de hardware y versiones según el repositorio AirLLM en GitHub.