Servir Olala-v1.0-mini-7A1B dans un sandbox sbx
Ce guide crée un sandbox qui sert un modèle GGUF Olala avec llama-server (API compatible OpenAI), accessible depuis la machine hôte. llama-server vient du fork llama.cpp d'OVHai (CPU uniquement), fourni par le kit kits/llama-cpp-olala.
Upstream llama.cpp, Ollama et LM Studio ne connaissent pas encore l'architecture
olala: il faut le fork OVHai-LLM/llama.cpp (voir la fiche du modèle GGUF).
Créer le sandbox
Sur la machine hôte, à la racine du projet :
sbx env create sbxenv.yaml
Le sandbox de développement (Claude Code + toolchains Go/Python/mini-me,
houla-houla) est décrit à part danssbxenv.dev.yaml:sbx env run sbxenv.dev.yaml.
Le hook postCreate lance scripts/olala.sh up dans le sandbox :
- utilise le
llama-serverdu kit (sans le kit, il compile le fork : quelques minutes) ; - télécharge
Olala-v1.0-mini-7A1B-q8_0-safe2.gguf(6,9 Go) dans./models, dans le dépôt ; - démarre
llama-serversur0.0.0.0:8080, publié sur le port 8080 de l'hôte.
Chaque étape est sautée si elle est déjà faite (llama-server trouvé, modèle présent, serveur lancé). Les modèles restent dans ./models (ignoré par git) quand le sandbox est supprimé : un nouveau sandbox ne les retélécharge pas.
Le dossier du dépôt est sur kDrive : les modèles y sont donc aussi synchronisés. Exclus
models/de la synchronisation kDrive si tu ne le veux pas.
Options (à repasser à chaque commande sbx env de ce sandbox) :
| Argument | Défaut | Rôle |
|---|---|---|
model_repo |
OVHaiLLM/Olala-v1.0-mini-7A1B-GGUF |
Dépôt Hugging Face |
model_file |
Olala-v1.0-mini-7A1B-q8_0-safe2.gguf |
Fichier GGUF |
models_dir |
./models |
Dossier des modèles (relatif à la racine du dépôt, ou absolu) |
host_port |
8080 |
Port de l'hôte |
threads |
16 |
Threads CPU (garde 2 CPU libres : tous les utiliser est ~30 % plus lent) |
ctx |
16384 |
Taille du contexte (partagée par les 4 slots) |
sbx env create sbxenv.yaml --env-arg model_file=Olala-v1.0-mini-7A1B-q5_k_m.gguf --env-arg host_port=9090
Dans un sandbox existant
Dans le sandbox (ou via sbx env exec sbxenv.yaml -- bash -lc '$SBX_WS/scripts/olala.sh <commande>') :
scripts/olala.sh up # compile + télécharge + sert
scripts/olala.sh status # état et /health
scripts/olala.sh restart # après un changement de modèle
scripts/olala.sh stop
scripts/olala.sh logs
Changer de modèle :
OLALA_MODEL_FILE=Olala-v1.0-mini-7A1B-q6_k.gguf scripts/olala.sh download
scripts/olala.sh stop
OLALA_MODEL_FILE=Olala-v1.0-mini-7A1B-q6_k.gguf scripts/olala.sh serve
Les mêmes réglages existent en variables d'environnement : OLALA_MODELS_DIR, OLALA_THREADS, OLALA_CTX, OLALA_PORT, OLALA_LOAD_MODE, OLALA_EXTRA_ARGS… (liste en tête de scripts/olala.sh).
Chargement du modèle : le script lance
llama-server --load-mode none(le modèle est lu en RAM, ~7 Go). Enmmap(défaut de llama.cpp), le fichier reste sur le montage du dépôt et la génération tombe à ~2 tokens/s.
Un sandbox local s'arrête dès qu'aucune session ne le garde en vie, et llama-server avec lui. Le hook postCreate passe donc le sandbox en mode détaché (sbx run -d --name houla-olala, permanent pour ce sandbox) : il tourne jusqu'à sbx stop. Après un sbx stop ou un redémarrage de la machine, relance-le puis relance le serveur :
sbx run -d --name houla-olala
sbx env exec --no-input sbxenv.yaml -- bash -lc "$PWD/scripts/olala.sh serve"
Pour un sandbox créé sans sbxenv.yaml (par ex. houla-houla, le sandbox de dev de sbxenv.dev.yaml), publie le port depuis l'hôte :
sbx ports houla-houla --publish 8080:8080
Tester avec curl
Depuis l'hôte (ou le sandbox) :
# Santé
curl -s http://localhost:8080/health
# Modèles servis (le nom = fichier sans .gguf)
curl -s http://localhost:8080/v1/models
# Chat
curl -s http://localhost:8080/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{
"model": "Olala-v1.0-mini-7A1B-q8_0-safe2",
"messages": [{"role": "user", "content": "Explique en deux phrases ce qu est une pompe à chaleur."}],
"temperature": 0.8, "top_p": 0.9, "top_k": 40,
"reasoning_effort": "low"
}' | jq -r '.choices[0].message.content'
# Streaming, sans raisonnement
curl -sN http://localhost:8080/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{
"model": "Olala-v1.0-mini-7A1B-q8_0-safe2",
"stream": true,
"reasoning_effort": "disabled",
"messages": [{"role": "user", "content": "Dis bonjour"}]
}'
reasoning_effort vaut disabled, low, medium (défaut) ou high. Le raisonnement est renvoyé dans choices[0].message.reasoning_content.
Mesuré dans un sandbox aarch64 (18 CPU, 31 Go) avec q8_0-safe2, llama-server du kit, 16 threads : 35 à 44 tokens/s en génération.
Le kit llama-cpp-olala
Mixin sbx (kits v3) qui compile le fork une fois, au build du kit, et pose llama-server et llama-cli dans /opt/llama-cpp-olala (liens dans /usr/local/bin). Build portable (GGML_NATIVE=OFF, toutes les variantes CPU chargées à l'exécution), arm64 (testé) et amd64 (pas encore testé). L'argument ref fixe le commit du fork.
Pour l'utiliser dans un autre sandbox (syntaxe pas encore testée avec sbx) :
sbx run claude --kit ./kits/llama-cpp-olala
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 |
|