Loki
2fbf86cdde
L'amont ne connaît qu'un fil unique (bkChat/conversation) que « clear chat »
effaçait définitivement. On garde toute la machinerie (un seul conv en
mémoire, mêmes flux SSE, même compactage) mais rangée par discussion :
bkChat/index liste des discussions (métadonnées seules)
bkChat/active discussion ouverte, partagée par tous les appareils
bkChat/conv:<id> état complet d'une discussion
Basculer réutilise le mécanisme d'epoch du reset : les abonnés SSE reçoivent
{reset:true} et rejouent le nouveau fil — aucun code de rendu à toucher. Le
fil unique existant est repris comme première discussion au premier
démarrage, et sa clé d'origine est laissée intacte.
- routes /api/conversations (liste, new, switch, rename, delete)
- barre latérale : liste (titre déduit du 1er message, date, nb d'échanges),
bouton +, renommer, supprimer ; lignes construites en DOM et non en
innerHTML, les titres venant de messages utilisateur
- suppression de la dernière discussion : convCreate et non convNew, qui
aurait réenregistré celle qu'on vient d'effacer
Le bouton « Vérifier les mises à jour » répondait « GitHub a répondu 404 » :
il interrogeait les releases du dépôt du fork, qui n'en publie aucune. En
conteneur, remplacer le binaire n'a de toute façon pas de sens — l'UI, l'API
et la CLI renvoient désormais « docker compose pull ».
Vérifié en conteneur : création, bascule, renommage (titre accentué avec
< > &), suppression de l'active puis de la dernière ; /api/update et
loki update renvoient la note Docker.
Loki — assistant IA local en conteneur (fork d'AJEAN)
Loki est un fork de AJEAN de nathaninline, sous licence MIT — voir
NOTICE.mdetLICENSE. L'essentiel du code et des fonctionnalités vient d'AJEAN ; ce fork le rebaptise et le fait tourner dans un conteneur Docker GPU autonome, là où l'amont s'installe en binaire + systemd sur la machine hôte.
Loki fait tourner un modèle de langage 100 % en local : tchat, mémoire persistante, accès internet, outils MCP, agent (shell, fichiers), accès distant chiffré — serveur d'inférence llama.cpp compris, dans une seule image.
Architecture
┌────────────────── conteneur loki ──────────────────┐
│ loki web (UI + API, port 8090, premier plan) │
│ │ pilote (fichier PID — pas de systemd) │
│ loki serve ──exec──► llama-server (CUDA, :8080) │
│ ▲ modèles .gguf │
│ /data (config, bbolt, mémoire, workspace) │
│ /models (GGUF déposés à la main) │
└────────────────────────────────────────────────────┘
- Un seul conteneur : l'UI joint le moteur sur
localhost(contrainte héritée de l'amont), les deux partagent donc le même conteneur. - Sans systemd : l'amont pilote le moteur via systemctl ; en conteneur,
Loki bascule automatiquement sur une supervision par fichier PID
(
internal/loki/sys_service_container.go). Changer de modèle depuis l'UI redémarre le moteur normalement. - Le moteur (port 8080, non authentifié par défaut) n'est pas exposé ; seule l'UI (8090) l'est.
Démarrage rapide (Docker, GPU NVIDIA)
Pré-requis : pilote NVIDIA + NVIDIA Container Toolkit.
cp .env.example .env
docker compose up --build # quelques minutes : llama-server vient précompilé
# de l'image officielle llama.cpp (server-cuda)
Interface : http://localhost:8090 — télécharge un modèle depuis le catalogue intégré (onglet modèles), il démarre tout seul.
Installation sur Unraid
L'image est construite et publiée par GitHub Actions sur GHCR
(ghcr.io/r0m1k3/loki:latest) à chaque push sur main — aucun build sur
Unraid. Compose prêt à l'emploi : docker-compose.unraid.yml.
- Installe le plugin Nvidia Driver (Apps) et vérifie
nvidia-smi. - Crée les dossiers :
mkdir -p /mnt/user/appdata/loki/data /mnt/user/appdata/loki/models - Plugin Compose Manager → nouvelle stack → colle
docker-compose.unraid.yml→ Compose Up. - Interface :
http://<ip-unraid>:8090.
Configuration
Tout se règle dans l'UI (modèle, contexte, presets…) et survit aux
redémarrages (volume /data). Variables d'environnement du conteneur :
| Variable | Rôle | Défaut |
|---|---|---|
LOKI_WEB_PORT |
port de l'UI | 8090 |
LOKI_MODEL |
modèle initial (semé au 1er boot seulement) | — |
LOKI_CTX |
taille de contexte initiale | 32768 |
LOKI_NGL |
couches GPU initiales | 999 (tout) |
LOKI_HOME |
données (volume) | /data |
LOKI_MODEL_DIRS |
dossiers .gguf additionnels | /models |
En CLI dans le conteneur : docker exec -it loki loki status (aussi :
logs, restart, config, bench, test…).
Fonctionnalités (héritées d'AJEAN)
- Tchat avec streaming, raisonnement visible, pièces jointes, vision (selon modèle), export de conversations.
- Mémoire persistante (
memory off|ondemand|always). - Accès internet : recherche + lecture de pages, moteur Go intégré ou Crawl4AI pour les pages JS.
- Agent : shell, fichiers, workspace (
agent on). - Serveurs MCP : Node.js est inclus dans l'image pour les serveurs
npx. - Presets de configuration par modèle, bench, auto-détection GPU.
- Accès distant chiffré via le relais ajean.link (service opéré par l'auteur de l'amont).
- API OpenAI-compatible exposable (
network on, protégée par clé).
Différences avec l'amont
| AJEAN (amont) | Loki (ce fork) | |
|---|---|---|
| Installation | binaire + sudo ajean install (systemd) |
docker compose up |
| Moteur llama.cpp | compilé sur la machine (ajean llamacpp install) |
image officielle llama.cpp (server-cuda), précompilée |
| Supervision moteur | systemd / launchd / PID (Windows) | fichier PID (LOKI_CONTAINER=1) |
| Configuration initiale | ajean edit ($EDITOR) |
entrypoint + loki config set |
| Mise à jour | ajean update (binaire GitHub) |
docker compose pull |
Le reste — UI, mémoire, outils, protocole — est celui d'AJEAN. Pour récupérer les évolutions de l'amont :
git fetch upstream && git merge upstream/main # conflits de renommage à arbitrer
Build sans GPU / autres accélérateurs / version épinglée
L'image Loki se construit au-dessus de l'image serveur officielle de
llama.cpp, choisie par le build-arg LLAMACPP_IMAGE :
# CPU seul (test sans GPU)
docker build --build-arg LLAMACPP_IMAGE=ghcr.io/ggml-org/llama.cpp:server .
# Vulkan (GPU AMD/Intel/NVIDIA sans CUDA)
docker build --build-arg LLAMACPP_IMAGE=ghcr.io/ggml-org/llama.cpp:server-vulkan .
# Version de llama.cpp épinglée (reproductible)
docker build --build-arg LLAMACPP_IMAGE=ghcr.io/ggml-org/llama.cpp:server-cuda-b10423 .
Aucune compilation de llama.cpp n'a lieu : le moteur est maintenu et précompilé par l'équipe amont (toutes architectures GPU courantes).
Licence
MIT — © les contributeurs d'AJEAN (« Jean contributors ») pour le code amont,
voir LICENSE et NOTICE.md.