Was ist AirLLM?

AirLLM ist eine Open-Source-Python-Bibliothek, die eine scheinbar unmögliche Aufgabe löst: ein 70B-Parameter-LLM auf einer GPU mit nur 4GB VRAM auszuführen.

Normalerweise braucht ein 70B-Modell in FP16-Präzision etwa 140GB VRAM – mindestens zwei A100-GPUs (je 80GB) sind nötig, um es zu laden. AirLLM nutzt schichtweise Inferenz (Layer-wise Inference): Es lädt immer nur eine Schicht des Modells in die GPU, berechnet sie, entlädt sie und lädt dann die nächste. Dadurch sinkt der VRAM-Bedarf von 140GB auf unter 4GB.

Stand Juli 2026 hat AirLLM über 23.000 Stars auf GitHub und die PyPI-Downloads steigen stetig. Es ist eines der beliebtesten Tools für lokales LLM-Inferenz.

Die wichtigsten Vorteile

Merkmal Traditioneller Ansatz AirLLM
VRAM für 70B ~140GB (2× A100 80GB) ~4GB
671B (DeepSeek-V3) ~1,3TB (Multi-GPU-Cluster) ~12GB
Quantisierung/Destillation Erforderlich, Genauigkeitsverlust Nicht nötig (optional)
Hardware-Anforderungen Rechenzentrum-GPUs Consumer-Grafikkarte reicht
Installationsaufwand Komplex (CUDA, Multi-GPU) pip install airllm – eine Zeile

So funktioniert es: Schichtweise Inferenz

Traditionelle Inferenz:  [Schicht 1] → [Schicht 2] → ... → [Schicht 80]   ← alles gleichzeitig in der GPU
                         benötigt ~140GB VRAM

AirLLM:                  [Schicht 1] ← in GPU laden → berechnen → auf CPU speichern → freigeben
                         [Schicht 2] ← in GPU laden → berechnen → auf CPU speichern → freigeben
                         ...
                         [Schicht 80] ← in GPU laden → berechnen → Ergebnis ausgeben
                         benötigt nur ~4GB VRAM (Größe einer Schicht)

Der Kniff: Die Inferenz großer Modelle ist sequenziell. Die Ausgabe der N-ten Schicht ist die Eingabe der (N+1)-ten. AirLLM nutzt das aus und hält immer nur eine Schicht im GPU-Speicher. Die Zwischenergebnisse werden zurück in den CPU-RAM geschrieben, dann wird der VRAM freigegeben und die nächste Schicht geladen.

💡 Was ist der Preis? Geschwindigkeit. Weil jede Schicht zwischen GPU und CPU hin- und herkopiert wird, ist die Inferenz langsamer als beim vollständigen Laden. Aber für einzelne Entwickler gilt: Hauptsache es läuft, nicht wie schnell.

Installation und Vorbereitung

Grundinstallation

BASH 
# Virtuelle Umgebung erstellen (empfohlen)
python -m venv airllm-env
source airllm-env/bin/activate

# AirLLM installieren
pip install airllm

# Für Quantisierungs-Beschleunigung: bitsandbytes nachinstallieren
pip install -U bitsandbytes

Systemanforderungen

  • GPU-Inferenz: NVIDIA-GPU, 4GB+ VRAM, CUDA-Unterstützung
  • CPU-Inferenz: Beliebiger x86_64-CPU (seit August 2024 unterstützt)
  • macOS: Apple Silicon (M1/M2/M3), mlx-Framework erforderlich
  • Festplattenspeicher: Beim ersten Start wird das Modell heruntergeladen (70B ≈ 130GB) – also genug Platz einplanen
  • Arbeitsspeicher: Mindestens 16GB System-RAM empfohlen (zum Zwischenspeichern der Zwischenergebnisse)

Installation prüfen

PYTHON 
from airllm import AutoModel
print("AirLLM erfolgreich installiert!")

Schnellstart: In 5 Minuten loslegen

Hello World

PYTHON 
from airllm import AutoModel

MAX_LENGTH = 128

# Eine Zeile zum Modellladen (automatischer Download + schichtweise Verarbeitung)
model = AutoModel.from_pretrained("Qwen/Qwen3-32B")

# Eingabe vorbereiten
input_text = ["What is the capital of France?"]
input_tokens = model.tokenizer(
    input_text,
    return_tensors="pt",
    return_attention_mask=False,
    truncation=True,
    max_length=MAX_LENGTH,
    padding=False
)

# Inferenz ausführen
generation_output = model.generate(
    input_tokens['input_ids'].cuda(),
    max_new_tokens=50,
    use_cache=True,
    return_dict_in_generate=True
)

# Ausgabe decodieren
output = model.tokenizer.decode(generation_output.sequences[0])
print(output)

Beispielausgabe:

What is the capital of France? The capital of France is Paris.

Das war's. Kein manuelles Multi-GPU-Setup, kein VRAM-Optimierungs-Code, keine Quantisierung. AirLLMs AutoModel übernimmt alles automatisch.

Unterstützte Modelle

Über AutoModel erkennt AirLLM den Modelltyp automatisch und deckt praktisch alle gängigen Open-Source-LLMs ab:

Modellreihe Beispiel Min. VRAM
Qwen3 Qwen3-32B / Qwen3-235B ~3GB
DeepSeek DeepSeek-V3 (671B) ~12GB
Llama Llama 3.1 405B / Llama 3 70B ~8GB / ~4GB
Mistral Mixtral 8x7B ~4GB
ChatGLM ChatGLM3-6B ~4GB
Phi Phi-4 ~4GB
Gemma Gemma 2B/7B ~4GB
Baichuan Baichuan2-7B ~4GB

Fortgeschrittene Funktionen

1. 4-Bit / 8-Bit Quantisierung für mehr Speed

AirLLM hat eine blockweise Quantisierung (block-wise quantization) eingebaut, die die Inferenzgeschwindigkeit bis zu 3× beschleunigen kann – bei minimalem Genauigkeitsverlust.

PYTHON 
from airllm import AutoModel

# 4-Bit-Quantisierung (schnellste Option, kleinster VRAM)
model = AutoModel.from_pretrained(
    "Qwen/Qwen3-32B",
    compression='4bit'  # oder '8bit'
)

Warum ist der Genauigkeitsverlust so gering? Herkömmliche Quantisierung muss sowohl Gewichte als auch Aktivierungen quantisieren, um die Berechnung zu beschleunigen. Bei AirLLM liegt der Engpass aber im Festplatten-I/O (Modellschichten von der Platte laden). Deswegen müssen nur die Gewichte quantisiert werden – das ist deutlich einfacher und genauer.

2. Prefetching

Beim Prefetching wird die nächste Modellschicht schon von der Platte geladen, während die GPU noch die aktuelle berechnet. So überlappen sich Berechnung und I/O, was etwa 10% mehr Speed bringt.

PYTHON 
from airllm import AutoModel

# Prefetching ist standardmäßig aktiviert (bei AirLLMLlama2)
model = AutoModel.from_pretrained(
    "meta-llama/Llama-2-70b-hf",
    hf_token="dein_huggingface_token",  # HuggingFace-Token für gated models nötig
)

3. Alle Konfigurationsoptionen

PYTHON 
model = AutoModel.from_pretrained(
    "modell_name_oder_pfad",

    # Quantisierung: '4bit' / '8bit' / None
    compression='4bit',

    # Profiling: gibt Zeitbedarf pro Phase aus
    profiling_mode=True,

    # Pfad zum Speichern der schichtweisen Fragmente (optional)
    layer_shards_saving_path='/data/airllm_cache/',

    # HuggingFace-Token (für geschützte Modelle erforderlich)
    hf_token="hf_xxxx",

    # Prefetching (standardmäßig an)
    prefetching=True,

    # Original-Modelldateien nach der Konvertierung löschen (Platz sparen)
    delete_original=True,
)

4. Multi-Turn-Dialog

PYTHON 
from airllm import AutoModel

model = AutoModel.from_pretrained("Qwen/Qwen3-32B")

def chat_with_model(prompt, history=None):
    """Einfacher Single-Turn-Dialog"""
    if history:
        full_prompt = history + "\nUser: " + prompt + "\nAssistant: "
    else:
        full_prompt = f"User: {prompt}\nAssistant: "

    input_tokens = model.tokenizer(
        [full_prompt],
        return_tensors="pt",
        return_attention_mask=False,
        truncation=True,
        max_length=512,
        padding=False
    )

    generation_output = model.generate(
        input_tokens['input_ids'].cuda(),
        max_new_tokens=256,
        use_cache=True,
        return_dict_in_generate=True,
        temperature=0.7,
        top_p=0.9,
    )

    response = model.tokenizer.decode(generation_output.sequences[0])
    # Nur die Assistant-Antwort extrahieren
    if "Assistant:" in response:
        response = response.split("Assistant:")[-1].strip()

    return response

# Test
print(chat_with_model("Erkläre Quantencomputing in drei Sätzen"))
print(chat_with_model("Was ist der eleganteste Sortieralgorithmus in Python?"))

Praxis-Szenarien

Szenario 1: Lokale Wissensdatenbank mit Q&A

Combine AirLLM mit einem Embedding-Modell für ein komplettes RAG-System (Retrieval-Augmented Generation) – komplett offline:

PYTHON 
from airllm import AutoModel
# Zusammen mit LangChain
from langchain.llms import HuggingFacePipeline
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.chains import RetrievalQA

# AirLLM-Modell als LLM-Backend laden
model = AutoModel.from_pretrained("Qwen/Qwen3-32B", compression='4bit')

# Mit lokaler Vektor-Datenbank kombinieren (z. B. FAISS)
# Für Offline-Dokumenten-Q&A, Code-Suche etc.

Szenario 2: Deployment auf Embedded-Geräten

Raspberry Pi 5 + USB-AI-Beschleuniger oder Jetson Nano – Edge-Geräte gehen auch:

BASH 
# Auf dem Edge-Gerät
pip install airllm
# CPU-Inferenz-Modus, keine GPU nötig
PYTHON 
from airllm import AutoModel

# Kleines Modell auf CPU ausführen
model = AutoModel.from_pretrained("microsoft/Phi-3-mini-4k-instruct")

# Für lokale KI-Inferenz auf IoT-Geräten
# Smart-Home-Sprachsteuerung, Industrie-Inspektion etc.

Szenario 3: Lokale Inferenz auf dem MacBook

Apple-Silicon-Nutzer können große Modelle direkt laufen lassen:

PYTHON 
# Auf macOS muss mlx installiert sein
# pip install mlx

from airllm import AutoModel

# Auf M1/M2/M3 MacBook ausführen
model = AutoModel.from_pretrained("Qwen/Qwen3-32B")

# Dank Unified Memory Architecture fast native Inferenz-Geschwindigkeit

AirLLM vs. andere lokale Inferenz-Lösungen

Lösung Prinzip Min. VRAM Speed Genauigkeit Bedienung
AirLLM Schichtweises Laden 4GB Langsamer ✅ Verlustfrei ⭐⭐⭐⭐⭐
llama.cpp GGUF-Quantisierung 4GB Schnell Quantisierungsverlust ⭐⭐⭐⭐
vLLM PagedAttention 80GB+ Extrem schnell ✅ Verlustfrei ⭐⭐⭐
Ollama GGUF-Wrapper 4GB Schnell Quantisierungsverlust ⭐⭐⭐⭐⭐
ExLlamaV2 4-Bit GPTQ 24GB+ Extrem schnell Quantisierungsverlust ⭐⭐⭐

Empfehlung zur Auswahl: - VRAM < 8GB: AirLLM (verlustfrei) oder llama.cpp/Ollama (mit Quantisierungsverlust) - VRAM 8-24GB: AirLLM + 4-Bit-Quantisierung oder ExLlamaV2 - Multi-GPU / Rechenzentrum: vLLM (Produktions-Level) - Einfachheit zuerst: Ollama (One-Click-Start) oder AirLLM (ein pip-Befehl)

Benchmarks aus der Community

Folgende Werte kommen aus Community-Tests (abhängig von Hardware und Modellversion – nur als Richtwert):

Modell Hardware Tokens/Sek. Hinweis
Llama-3-8B RTX 3060 12GB ~8-12 4-Bit-Quantisierung
Llama-3-70B RTX 3060 12GB ~1-2 4-Bit-Quantisierung
Qwen3-32B GTX 1650 4GB ~1-2 Ohne Quantisierung
DeepSeek-V3 671B RTX 4090 24GB ~0,3 ~12GB VRAM

⚠️ Hinweis: AirLLM ist tatsächlich langsamer als vollständiges GPU-Laden (meist 1-3 Tokens/Sek.). Aber der Wert liegt darin, dass große Modelle auf normaler Hardware überhaupt laufen – ideal für Entwicklung, lokale Experimente und Offline-Inferenz.

Häufig gestellte Fragen

F: Kann ich mit AirLLM Modelle trainieren?

Nein. AirLLM ist ausschließlich für Inferenz gedacht – Training oder Fine-Tuning werden nicht unterstützt. Für Fine-Tuning empfehlen sich LoRA/QLoRA.

F: Warum ist mein Modell so langsam?

Das ist normal bei AirLLMs schichtweisem Laden. So wird es schneller: 1. 4-Bit-Quantisierung nutzen (compression='4bit') 2. Prefetching aktivieren (prefetching=True, standardmäßig schon an) 3. Modell auf einer SSD speichern (weniger Festplatten-Latenz)

F: Warum dauert der erste Start so lange?

Beim ersten Run lädt AirLLM das Modell herunter und teilt es schichtweise in den Cache auf. Ein 70B-Modell herunterzuladen (~130GB) und aufzuteilen braucht Zeit. Beim zweiten Start wird direkt der Cache genutzt – dann ist es deutlich schneller.

F: Mein Festplattenspeicher ist zu klein – was tun?

PYTHON 
# delete_original=True löscht das originale HuggingFace-Modell nach der Aufteilung
model = AutoModel.from_pretrained(
    "Qwen/Qwen3-32B",
    delete_original=True  # Spart ca. 50% Festplattenspeicher
)

Fazit

AirLLM lässt sich in einem Satz zusammenfassen: Jeder Entwickler kann große Modelle auf seinem eigenen Rechner laufen lassen.

Dimension Bewertung
🎯 Kernvorteil 70B auf 4GB VRAM, ohne Quantisierung
📦 Installation pip install, Null-Konfiguration
🧪 Modellunterstützung Alle gängigen Open-Source-Modelle
⚡ Inferenz-Geschwindigkeit Langsam (1-3 Tok/s), aber es läuft
🔧 Einsatzszenarien Entwicklung, lokale Experimente, Edge-Deployment
📄 Lizenz Apache 2.0 / BELLE License

Nächste Schritte: - GitHub-Repo — 23K+ Stars, aktiv gepflegt - HuggingFace-Blog — Technische Deep Dive - Colab-Demo — Kostenlos im Browser testen

Hat dir dieser Artikel geholfen? Dann teile ihn gerne mit anderen Entwicklern!