Kolibri lokal einrichten: Schritt für Schritt

1. Hardware prüfen

Für den hier beschriebenen Kolibri-Betrieb brauchst du einen passenden GPU-Rechner: Schon die FP8-Gewichte belegen rund 78 GB, die BF16-Gewichte rund 156 GB. Speicher für Kontext und Laufzeit kommt noch dazu. Prüfe das vor dem Download. Kolibri-1 ist ein großes Textmodell von Aleph Alpha.

Kolibri-1 steht unter Apache 2.0. Als Mindestkonfiguration nennt Aleph Alpha für FP8 eine H200, B200 oder B300, zwei A100 mit je 80 GB oder zwei H100 SXM5. Die rund 78 GB betreffen nur die FP8-Gewichte; Kontext und Laufzeit brauchen zusätzlichen Speicher. Kosten für Hardware, Strom oder GPU-Miete hängen von deinem Aufbau ab.

FP8 und BF16 sind zwei Varianten mit unterschiedlichen Speicheranforderungen. Die Modellangaben und Herstellerquellen stehen im Kolibri-1-Profil.

Die Tabelle nennt Beispiele aus den Modellkarten. Entscheidend sind auch Treiber, unterstützte Rechenoperationen, Kontext und gleichzeitige Anfragen. Zwei beliebige Grafikkarten genügen deshalb nicht. Mehr dazu erklärt der Guide zum Speicherbedarf lokaler KI.

Schau nach, was auf deinem GPU-Rechner verfügbar ist

Öffne dort ein Terminal und führe diese drei Abfragen aus:

nvidia-smi
python3 --version
df -h .

Notiere GPU-Typ, freien Speicher, Treiber und Python-Version. Die Befehle zeigen den Bestand; ob die Laufzeit deine Kombination unterstützt, prüfst du zusätzlich anhand ihrer Anforderungen.

Für diese Anleitung: FP8 und vLLM

Wir verwenden im Hauptweg vLLM mit dem Aleph-Alpha-Plugin. Damit läuft Kolibri als Modellserver: Eine Anwendung schickt eine Anfrage an seine API und erhält die Antwort zurück. Eine Chatoberfläche richtest du damit noch nicht ein.

Das Startbeispiel nutzt die FP8-Variante und zwei dafür geeignete GPUs. Hast du die passende Hardware, kannst du mit Schritt 2 weitermachen.

Du möchtest Kolibri direkt aus einem Python-Skript aufrufen? Nutze stattdessen die Python-Anleitung mit Transformers. Für GGUF-Dateien und Desktop-Apps gibt es weiter unten die Hinweise zu Ollama, LM Studio und Mac.

2. Kolibri als Server einrichten

Ab jetzt arbeitest du auf dem geeigneten Linux-GPU-Rechner. Lege für den Server eine eigene Python-Umgebung an. So bleiben seine Pakete von anderen Projekten getrennt.

Die Pakete installieren

Das Paket aleph-alpha-inference enthält die Kolibri-Erweiterung und die dazu passende vLLM-Version. Der geprüfte Paketstand verwendet vLLM 0.29 und setzt Python ab 3.10 voraus. GPU, Treiber und weitere Abhängigkeiten müssen ebenfalls passen.

python3 -m venv .venv-kolibri-server
source .venv-kolibri-server/bin/activate
python -m pip install 'aleph-alpha-inference>=1'
python -m pip show aleph-alpha-inference vllm transformers

Der Download beginnt mit dem Installationsbefehl. Hebe die Ausgabe von pip show auf, damit du deine Paketversionen später wiederfindest. Installiere nicht nachträglich eine andere vLLM-Hauptversion darüber: Plugin und Laufzeit müssen zusammenpassen.

Den Modellserver starten

Bleibe in der aktivierten Serverumgebung. Der folgende Befehl gehört zum FP8-Beispiel mit zwei passenden GPUs. Er bindet den Server an 127.0.0.1:8000, erlaubt zunächst eine gleichzeitige Anfrage und verwendet 32.768 Tokens Kontext.

vllm serve Aleph-Alpha/Kolibri-1 \
  --host 127.0.0.1 --port 8000 \
  --tensor-parallel-size 2 \
  --max-model-len 32768 --max-num-seqs 1 \
  --kv-cache-dtype fp8 \
  --reasoning-parser kolibri1 \
  --tool-call-parser kolibri1 \
  --enable-auto-tool-choice

Beim ersten Start können die Modellgewichte heruntergeladen werden. Warte, bis Laden und Initialisieren abgeschlossen sind. Lass dieses Terminal anschließend geöffnet.

Prüfen, ob der Server erreichbar ist

Öffne ein zweites Terminal auf demselben GPU-Rechner:

curl --fail-with-body http://127.0.0.1:8000/v1/models

Die Antwort soll eine Modellliste mit der angebotenen Modell-ID enthalten. Für diesen Start erwarten wir Aleph-Alpha/Kolibri-1. Übernimm immer die ID, die dein Server tatsächlich anbietet.

3. Eine erste Antwort testen

Nimm für den ersten Versuch eine Aufgabe, deren Antwort du kennst. In unserem fiktiven Beispiel steht der Termin um 9 Uhr. Du prüfst, ob der Server Text zurückgibt und ob die Antwort diese Angabe übernimmt.

Die Anfrage speichern und senden

Speichere diesen Inhalt auf dem GPU-Rechner als anfrage.json:

{
  "model": "Aleph-Alpha/Kolibri-1",
  "messages": [
    {
      "role": "user",
      "content": "Quelle A: Der Termin ist um 9 Uhr. Nenne nur die Uhrzeit aus Quelle A."
    }
  ],
  "max_tokens": 128,
  "chat_template_kwargs": {
    "enable_thinking": false
  }
}

Sende die gespeicherte Datei aus demselben Ordner an den Server:

curl --fail-with-body http://127.0.0.1:8000/v1/chat/completions \
  -H 'Content-Type: application/json' \
  --data-binary @anfrage.json

1. Kommt eine Antwort zurück? Prüfe den HTTP-Status und das Feld choices[0].message.content.
2. Steht dort 9 Uhr? Das ist die erwartete Antwort aus der erfundenen Quelle, kein hier gemessenes Modellergebnis.
3. Ist die Ausgabe vollständig? Bei finish_reason: length wurde das Ausgabelimit erreicht.

python3 erster_test.py

4. Deine Anwendung verbinden

Jetzt kannst du eine Anwendung anschließen, die eine eigene OpenAI-kompatible API-Adresse unterstützt. Läuft sie direkt auf dem GPU-Rechner, lautet die Basisadresse in diesem Beispiel http://127.0.0.1:8000/v1.

Wenn die Anwendung auf deinem Laptop läuft

127.0.0.1 meint immer das Gerät der jeweiligen Anwendung. Auf deinem Laptop zeigt die Adresse also auf den Laptop. Ein SSH-Tunnel kann diesen lokalen Anschluss mit dem GPU-Server verbinden.

Voraussetzung ist ein funktionierender SSH-Zugang zum GPU-Server mit erlaubter Portweiterleitung. Öffne auf deinem Laptop ein Terminal. Ersetze BENUTZER@GPU-SERVER durch deinen Zugang; der lokale Port 8000 muss frei sein.

ssh -N -L 127.0.0.1:8000:127.0.0.1:8000 BENUTZER@GPU-SERVER

Prüfe den Host-Schlüssel wie bei deinem üblichen SSH-Zugang und lass den Tunnel geöffnet. Rufe anschließend http://127.0.0.1:8000/v1/models vom Laptop aus ab. Wenn die Modellliste erscheint, trägst du die Verbindung in deiner Anwendung ein:

Dein Setup festhalten

Notiere zum Schluss die Versionen und Einstellungen, mit denen der Test funktioniert hat. Das hilft bei einem späteren Update oder Fehler. Halte getrennt fest, ob der Server erreichbar war, ob die kleine Aufgabe stimmte und welche weiteren Aufgaben du noch prüfen möchtest.

Datum / GPU / Treiber / Python:
Modell-ID / Revision / Format:
Laufzeit / Paketversionen:
Kontext / Parallelisierung / Output / Thinking:
Modellliste erreichbar?
Kleine Aufgabe / erwartete Antwort:
Tatsächliche Antwort / finish_reason:
Fehler / nächster Prüfschritt:
Entscheidung: weiter testen / nacharbeiten / stoppen

Wenn etwas nicht funktioniert

Gehe vom beobachteten Fehler aus und ändere jeweils nur eine Sache. Wiederhole danach dieselbe kleine Anfrage. So siehst du, welche Änderung geholfen hat.

Bei Speicherproblemen ist BF16 kein leichterer Ersatz für FP8. Prüfe zuerst Variante, freien Speicher, Kontext und Parallelisierung. Die Einordnung von Kolibri erklärt, wofür das Modell gedacht ist.

Alternative: Kolibri direkt mit Python nutzen

Du brauchst keinen API-Server, wenn du Kolibri direkt aus einem Python-Skript aufrufen möchtest. Dafür beschreibt Aleph Alpha Transformers ab Version 5.20. Die Modellgewichte und Hardwareanforderungen bleiben dieselben.

Eine eigene Python-Umgebung anlegen

Verwende dafür eine getrennte Umgebung auf dem geeigneten GPU-Rechner:

python3 -m venv .venv-kolibri-python
source .venv-kolibri-python/bin/activate
python -m pip install "transformers[kernels,torch]>=5.20"
python -m pip show transformers torch

Das Beispiel speichern und ausführen

Speichere den folgenden Code als kolibri_beispiel.py. Er verwendet die Hersteller-Auto-Klassen, schaltet Thinking für die kleine Aufgabe aus und begrenzt die neue Ausgabe auf 128 Tokens. Beim ersten Laden können die vollständigen Gewichte heruntergeladen werden.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "Aleph-Alpha/Kolibri-1"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

messages = [{"role": "user", "content":
    "Quelle A: Der Termin ist um 9 Uhr. Nenne nur die Uhrzeit aus Quelle A."}]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, enable_thinking=False,
    return_tensors="pt", return_dict=True,
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=128)
prompt_length = inputs["input_ids"].shape[1]
answer = tokenizer.parse_response(
    outputs[0, prompt_length:], prefix=outputs[0, :prompt_length]
)
print(answer["content"])

device_map="auto" lässt die Bibliothek die Platzierung wählen. Deine Hardware muss das Modell trotzdem unterstützen und genug Speicher bieten. Python-Beispiel herunterladen.

python kolibri_beispiel.py

Prüfe die Ausgabe wie in Schritt 3: Kommt Text zurück, nennt er die Uhrzeit aus der fiktiven Quelle und ist er vollständig?

Kolibri mit Ollama, LM Studio oder auf dem Mac

llama.cpp b11709 enthält Unterstützung für die Kolibri-1-Architektur. Prüfe trotzdem die konkrete Kombination aus Modelldatei, Laufzeit, App-Version und Hardware, bevor du eine Datei herunterlädst.

Die öffentliche Ollama-Suche enthält einen Community-Eintrag. Ob dieser mit deiner App-Version und deinem Gerät läuft, wurde hier nicht getestet. Für einen ersten Versuch ohne passende GPU-Umgebung kann ein kleineres Modell, dessen Betrieb für dein Gerät dokumentiert ist, geeigneter sein.