bots-garden/houlapublic Fork
⑂ v0.0.0
Commits
⬇ Clone ▾
git clone https://git.rickub.com/bots-garden/houla.git
git clone ssh://git@rickub.com/bots-garden/houla.git

Host key fingerprint (ed25519): SHA256:iycHnxEyq0Q7uyVpB7JlznP0G7JrTPXLYRcAU5CSLhc — verify it before your first connect.

Download ZIP
🛟 Updated. 1dfc968Unverified · on v0.0.0 · k33g · 4h ago
olala-sbx.fr.md · 123 lines · 5.6 KBmarkdown
Blame HistoryOpen raw

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 dans sbxenv.dev.yaml : sbx env run sbxenv.dev.yaml.

Le hook postCreate lance scripts/olala.sh up dans le sandbox :

  1. utilise le llama-server du kit (sans le kit, il compile le fork : quelques minutes) ;
  2. télécharge Olala-v1.0-mini-7A1B-q8_0-safe2.gguf (6,9 Go) dans ./models, dans le dépôt ;
  3. démarre llama-server sur 0.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 32768 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). En mmap (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
# 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`](../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](https://github.com/OVHai-LLM/llama.cpp) (voir la [fiche du modèle GGUF](https://huggingface.co/OVHaiLLM/Olala-v1.0-mini-7A1B-GGUF)).

## Créer le sandbox

Sur la machine hôte, à la racine du projet :

```bash
sbx env create sbxenv.yaml
```

> Le sandbox de développement (Claude Code + toolchains Go/Python/mini-me, `houla-houla`) est décrit à part dans `sbxenv.dev.yaml` : `sbx env run sbxenv.dev.yaml`.

Le hook `postCreate` lance [`scripts/olala.sh up`](../scripts/olala.sh) dans le sandbox :

1. utilise le `llama-server` du kit (sans le kit, il compile le fork : quelques minutes) ;
2. télécharge `Olala-v1.0-mini-7A1B-q8_0-safe2.gguf` (6,9 Go) dans `./models`, dans le dépôt ;
3. démarre `llama-server` sur `0.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` | `32768` | Taille du contexte (partagée par les 4 slots) |

```bash
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>'`) :

```bash
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 :

```bash
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`](../scripts/olala.sh)).

> **Chargement du modèle :** le script lance `llama-server --load-mode none` (le modèle est lu en RAM, ~7 Go). En `mmap` (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 :

```bash
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 :

```bash
sbx ports houla-houla --publish 8080:8080
```

## Tester avec curl

Depuis l'hôte (ou le sandbox) :

```bash
# 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`) :

```bash
sbx run claude --kit ./kits/llama-cpp-olala
```