Fusion de embeddings-token dans main (le jeton devant Ollama, avec le pompage des conversations)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
commit
e3c4a29e90
13 files changed
+315
-57
No files matched your search
@@ -6,7 +6,8 @@
|
||||
"Read(./.env)",
|
||||
"Read(./.env.*)",
|
||||
"Read(./instance-de-test/.env)",
|
||||
"Read(./acces/.env)"
|
||||
"Read(./acces/.env)",
|
||||
"Read(./ollama/.env)"
|
||||
]
|
||||
},
|
||||
"hooks": {}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
.env
|
||||
instance-de-test/.env
|
||||
acces/.env
|
||||
ollama/.env
|
||||
acces/database.db
|
||||
acces/utilisateurs.json
|
||||
instance-de-test/config.toml
|
||||
|
||||
@@ -4,7 +4,7 @@ Les demandes des clients AIMsight arrivent par mail dans LibreDesk (`helpdesk.se
|
||||
|
||||
Ce dépôt porte tout ce qu'il faut pour cela :
|
||||
- `snippets/` : les textes des snippets, relus (`textes/`, un fichier par snippet), les consignes de rédaction (`consignes_redaction.md`, à coller dans Admin → IA → Providers → Custom instructions) et l'import vers LibreDesk ;
|
||||
- `ollama/` : l'image Ollama avec le modèle d'embeddings `bge-m3:567m` embarqué, qui sert la recherche dans la base depuis le serveur de LibreDesk ;
|
||||
- `ollama/` : l'image `embeddings-bge-m3`, Ollama avec le modèle d'embeddings `bge-m3:567m` embarqué (API OpenAI, 1024 dimensions, hors ligne), qui sert la recherche dans la base depuis le serveur de LibreDesk. Caddy, devant Ollama, exige `Authorization: Bearer <EMBEDDINGS_JETON>` : le jeton est dans `ollama/.env` (hors de git), et c'est la « API key » des embeddings dans LibreDesk ;
|
||||
- `acces/` : le service d'accès, appelé par l'outil `get_customer_access` de LibreDesk au clic sur « Generate reply » : les stations que le client de la conversation peut voir sur le dashboard (export d'Auth0 `acces/utilisateurs.json` + ses UserGroup, en lecture seule) ; lancement dans `acces/compose.yml` ;
|
||||
- `conversations/` : le pompage des conversations, **en lecture seule**, vers `~/aimsight-labeling/auto/conversations/` (le fil, les images, les pièces jointes), pour le support et l'entraînement ; lancé par l'onglet Conversations d'aimsight-app (section ci-dessous) ;
|
||||
- `instance-de-test/` : un LibreDesk v2.9.0 local avec Mailpit (un piège SMTP : rien ne sort), pour tout essayer avant la production ;
|
||||
@@ -28,7 +28,11 @@ Sous WSL (Ubuntu), depuis `~/aimsight-libredesk` (ex-Support-LibreDesk, renommé
|
||||
python3 -m unittest discover -s tests -v
|
||||
```
|
||||
|
||||
Les secrets restent hors de git : `.env` (la clé Anthropic de l'instance de test, `export ANTHROPIC_API_KEY=…`, et les clés admin temporaires d'un import en production) et `instance-de-test/.env` (écrit par `2_creer_boite_et_cle.py`).
|
||||
Les secrets restent hors de git : `.env` (la clé Anthropic de l'instance de test, `export ANTHROPIC_API_KEY=…`, et les clés admin temporaires d'un import en production) , `instance-de-test/.env` (écrit par `2_creer_boite_et_cle.py`) et `ollama/.env` (`EMBEDDINGS_JETON=…`, le jeton d'embeddings-bge-m3 ; 32 caractères au moins, lettres, chiffres, `_` et `-`) :
|
||||
|
||||
```bash
|
||||
echo "EMBEDDINGS_JETON=$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')" >> ollama/.env && chmod 600 ollama/.env
|
||||
```
|
||||
|
||||
### L'instance de test
|
||||
|
||||
@@ -42,7 +46,7 @@ bash instance-de-test/1_demarrer.sh 'TestAdmin-2026!'
|
||||
python3 instance-de-test/2_creer_boite_et_cle.py 'TestAdmin-2026!'
|
||||
```
|
||||
|
||||
Puis Ollama sur son réseau (sur ce poste, un Ollama Windows occupe déjà le port 11434 : on publie sur 11435) :
|
||||
Puis embeddings-bge-m3 sur son réseau (sur ce poste, un Ollama Windows occupe déjà le port 11434 : on publie sur 11435 ; le jeton vient de `ollama/.env`, et `3_brancher_ia.py` le donne à LibreDesk comme clé) :
|
||||
|
||||
```bash
|
||||
docker compose -f ollama/compose.yml build
|
||||
|
||||
+16
-9
@@ -15,6 +15,12 @@ Rien de ce qui suit n'envoie de message : « Generate reply » pose un brouillon
|
||||
- [x] **0 ter. Rien d'automatique** (vérifié le 2026-11-11). Admin → Automations : aucune règle ; Admin → IA → Tools : aucun outil ; aucun webhook ; Admin → IA → Suggestions : « Learn from resolved conversations » désactivé.
|
||||
- [x] **1 provisoire. LM Studio sur le PC de Maxime** (2026-11-11). `text-embedding-bge-m3` (bge-m3 Q8_0) sur `http://10.0.2.140:1234/v1` (adresse Wi-Fi attribuée par DHCP). Le PC doit rester allumé, LM Studio lancé avec son serveur actif. **Remplacé par Ollama ci-dessous.**
|
||||
- [x] **1 bis provisoire. L'image Ollama sur le PC de Maxime** (2026-11-12), à la place de LM Studio, pour essayer le paquet comme le fera le serveur : dossier `~/essai-production/ollama` avec seulement les deux fichiers compose et `verifier_ollama.py`, `.env` = `OLLAMA_BIND=10.0.2.140` + `OLLAMA_PORT=11435`, `docker compose up -d --no-build` (image tirée de Gitea **sans login** : le paquet est public). Pare-feu de WSL (Hyper-V, bloque tout en entrée par défaut, sans interface graphique) ouvert par Maxime : règle `Ollama-LibreDesk`, TCP 11435, d'abord depuis `10.0.0.0/8`, puis resserrée au seul serveur LibreDesk `10.0.1.184` ; à retirer après l'essai (`Remove-NetFirewallHyperVRule -Name "Ollama-LibreDesk"`). Embeddings dans LibreDesk : `http://10.0.2.140:11435/v1`, `bge-m3:567m`, clé `ollama`, dimensions vides (0). Test réussi ; 118 appels `/v1/embeddings` depuis LibreDesk (`10.0.1.184`), tous en 200. Mêmes limites que LM Studio : PC allumé, adresse Wi-Fi qui peut changer.
|
||||
- [ ] **1 ter. Le jeton sur le PC de Maxime** (image `embeddings-bge-m3`, branche `embeddings-token`). L'image renommée exige `Authorization: Bearer <EMBEDDINGS_JETON>` ; Ollama n'écoute plus que dans le conteneur, Caddy devant lui. Elle est déjà construite sur le PC : pas besoin de l'avoir poussée sur Gitea pour cet essai. L'ancienne image accepte n'importe quelle clé : on change donc d'abord la clé dans LibreDesk, puis le conteneur, sans coupure.
|
||||
1. Tirer un jeton (Maxime, jamais montré à Claude) : `python3 -c 'import secrets; print(secrets.token_urlsafe(32))'`, et l'ajouter à `~/essai-production/ollama/.env` : `EMBEDDINGS_JETON=<jeton>`.
|
||||
2. LibreDesk, Admin → IA → Providers, Embedding : **API key** = le jeton ; URL, modèle et *dimensions* inchangés (*dimensions* vide ou 0 : bge-m3 rend 1024 nombres, pas 1536). *Test connection*, puis *Save*. La clé n'entre pas dans l'empreinte des extraits : pas de recalcul.
|
||||
3. Copier les nouveaux `compose.yml` et `verifier_ollama.py` dans `~/essai-production/ollama`, puis `cd ~/essai-production/ollama && docker compose up -d --no-build` (remplace `ollama-bge-m3` par `embeddings-bge-m3`, quelques secondes sans base).
|
||||
4. Vérification : `python3 ~/essai-production/ollama/verifier_ollama.py http://10.0.2.140:11435/v1` → `OK bge-m3:567m, 1024 dimensions, jeton exigé` (le jeton est lu dans le `.env` voisin) ; dans LibreDesk, *Test connection* réussit ; un « Generate reply » s'appuie sur la base.
|
||||
Retour en arrière : dans le `compose.yml` de `~/essai-production/ollama`, remettre l'image `ollama-bge-m3:0.40.16-567m` et `container_name: ollama-bge-m3`, `docker compose up -d --no-build` ; la clé de LibreDesk peut rester (l'ancienne image l'ignore).
|
||||
- [x] **2. Embeddings** (2026-11-11). Fournisseur OpenAI, URL `http://10.0.2.140:1234/v1`, modèle `text-embedding-bge-m3`, clé `lm-studio`, *embedding max tokens* 2048.
|
||||
- [x] **3. Complétion** (2026-11-11). *Max tokens* 4096 ; *Custom instructions* = `snippets/consignes_redaction.md` ; Claude Sonnet 5.5, `https://api.anthropic.com/v1`, effort `medium`.
|
||||
- [x] **4. Import de la base** (2026-11-11). 118 extraits actifs. Agent « Import base » (id 127) : clé révoquée, agent désactivé. Pour un réimport : regénérer une clé, réactiver l'agent, mettre la clé dans `.env` (`export LIBREDESK_ADMIN_KEY=…`, `export LIBREDESK_ADMIN_SECRET=…`), tâche « Snippets : envoyer en simulation (PRODUCTION) » puis « Snippets : ENVOYER (PRODUCTION) », puis tout révoquer.
|
||||
@@ -27,6 +33,7 @@ But : remplacer LM Studio par Ollama (`bge-m3:567m`) sur le serveur de LibreDesk
|
||||
- [x] **6. L'image.** Sur le poste, tâche « Ollama : construire » (ou `docker compose -f ollama/compose.yml build`), puis vérification hors ligne (`verifications.md`). Puis, avec l'accord de Maxime, la pousser au registre Gitea : jeton Gitea à portée `write:package`, `docker login exchange.sensima.ch`, `docker push exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m`, puis `docker logout exchange.sensima.ch` (le login garde le jeton en clair dans `~/.docker/config.json`).
|
||||
Vérification : l'image apparaît dans Packages du compte. Si le registre la refuse (taille), on la transportera par SSH au point 8.
|
||||
Construite et vérifiée hors ligne le 2026-11-12 (2,43 Go, sans clé privée : chaque conteneur crée la sienne au démarrage). Poussée le 2026-11-12, digest `sha256:332fbdec63583c8b2ac59a168cbd8c3e39624047662b912e58d9f3f7fff99530`. Pour le serveur (point 8) : un autre jeton, `package` en **lecture seule**.
|
||||
- [ ] **6 bis. L'image renommée, avec jeton.** `exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m`, construite et vérifiée hors ligne le 2026-11-18 (2,49 Go ; `verifications.md`). À pousser comme au point 6, avec l'accord de Maxime. Puis, dans Gitea, la rattacher au dépôt (paramètres du paquet → lier au dépôt `aimsight-libredesk`). L'ancien paquet `ollama-bge-m3` ne sera supprimé qu'une fois plus rien ne l'utilise (point 1 ter fait), avec l'accord de Maxime.
|
||||
|
||||
- [ ] **7. État des lieux du serveur, sans rien changer** (Maxime, en SSH).
|
||||
```bash
|
||||
@@ -44,8 +51,8 @@ But : remplacer LM Studio par Ollama (`bge-m3:567m`) sur le serveur de LibreDesk
|
||||
```bash
|
||||
ssh <serveur> mkdir -p ollama && scp ollama/compose.yml ollama/compose.reseau.yml ollama/verifier_ollama.py <serveur>:ollama/
|
||||
```
|
||||
Récupérer l'image : `docker login exchange.sensima.ch && docker pull exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m && docker logout exchange.sensima.ch` ; ou, si le registre l'a refusée, depuis le poste : `docker save exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m | gzip | ssh <serveur> 'gunzip | docker load'`. Vérifier : `docker image ls exchange.sensima.ch/maxime.pasquier/ollama-bge-m3` montre le tag `0.40.16-567m`.
|
||||
Puis écrire `~/ollama/.env` sur le serveur. Docker Compose le lit à chaque commande lancée depuis `~/ollama` : les réglages ne dépendent d'aucune option à retenir, et un simple `docker compose …` garde toujours Ollama au bon endroit. Selon l'état des lieux :
|
||||
Récupérer l'image : `docker pull exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m` (paquet public : sans login) ; ou, si le registre l'a refusée, depuis le poste : `docker save exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m | gzip | ssh <serveur> 'gunzip | docker load'`. Vérifier : `docker image ls exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3` montre le tag `0.40.16-567m`.
|
||||
Puis écrire `~/ollama/.env` sur le serveur (`chmod 600`), avec, dans tous les cas, un jeton **propre au serveur** (pas celui du PC) : `EMBEDDINGS_JETON=<jeton>`, tiré par `python3 -c 'import secrets; print(secrets.token_urlsafe(32))'`. Sans lui, le conteneur refuse de démarrer. Docker Compose le lit à chaque commande lancée depuis `~/ollama` : les réglages ne dépendent d'aucune option à retenir, et un simple `docker compose …` garde toujours Ollama au bon endroit. Selon l'état des lieux :
|
||||
- **LibreDesk dans Docker** (cas attendu) :
|
||||
```
|
||||
COMPOSE_FILE=compose.yml:compose.reseau.yml
|
||||
@@ -61,16 +68,16 @@ But : remplacer LM Studio par Ollama (`bge-m3:567m`) sur le serveur de LibreDesk
|
||||
```bash
|
||||
cd ~/ollama && docker compose up -d --no-build
|
||||
```
|
||||
Vérification : `docker ps --filter name=ollama-bge-m3` montre `Up … (healthy)` ; `docker inspect ollama-bge-m3 --format '{{.HostConfig.RestartPolicy.Name}}'` rend `unless-stopped` ; dans le cas Docker, `docker network inspect <réseau de LibreDesk> --format '{{range .Containers}}{{.Name}} {{end}}'` liste `ollama-bge-m3`.
|
||||
Vérification : `docker ps --filter name=embeddings-bge-m3` montre `Up … (healthy)` ; `docker inspect embeddings-bge-m3 --format '{{.HostConfig.RestartPolicy.Name}}'` rend `unless-stopped` ; dans le cas Docker, `docker network inspect <réseau de LibreDesk> --format '{{range .Containers}}{{.Name}} {{end}}'` liste `embeddings-bge-m3`.
|
||||
|
||||
- [ ] **9. Vérifier Ollama.**
|
||||
- Depuis le serveur : `python3 ~/ollama/verifier_ollama.py http://127.0.0.1:11434/v1` (ou l'adresse interne) → `OK bge-m3:567m, 1024 dimensions`.
|
||||
- Depuis le réseau de LibreDesk (cas Docker) : `docker run --rm --network <réseau> -v ~/ollama:/o:ro python:3.12-alpine python /o/verifier_ollama.py http://ollama:11434/v1` → même résultat (il faut que le serveur puisse tirer `python:3.12-alpine` ; sinon le test du point 10 depuis LibreDesk fait foi).
|
||||
- **De l'extérieur** : depuis un téléphone en 4G (Wi-Fi coupé), ouvrir `http://46.14.212.91:11434` : la page **ne doit pas répondre**. Si elle répond (« Ollama is running »), arrêter Ollama (`cd ~/ollama && docker compose down`) et revoir le point 7 avec la personne qui gère le serveur.
|
||||
- Si `python3` manque ou est trop ancien sur le serveur : `curl -s http://127.0.0.1:11434/v1/models` doit lister `bge-m3:567m`.
|
||||
- Depuis le serveur : `python3 ~/ollama/verifier_ollama.py http://127.0.0.1:11434/v1` (ou l'adresse interne) → `OK bge-m3:567m, 1024 dimensions, jeton exigé`. Le jeton est lu dans `~/ollama/.env`, à côté du script ; le script vérifie aussi qu'une requête **sans** jeton est refusée.
|
||||
- Depuis le réseau de LibreDesk (cas Docker) : `docker run --rm --network <réseau> -v ~/ollama:/o:ro python:3.12-alpine python /o/verifier_ollama.py http://ollama:11434/v1` → même résultat (le `.env` monté avec `/o` donne le jeton ; il faut que le serveur puisse tirer `python:3.12-alpine` ; sinon le test du point 10 depuis LibreDesk fait foi).
|
||||
- **De l'extérieur** : depuis un téléphone en 4G (Wi-Fi coupé), ouvrir `http://46.14.212.91:11434` : la page **ne doit pas répondre**. Si elle répond (« jeton manquant ou invalide »), le jeton protège encore, mais le port est exposé : arrêter le service (`cd ~/ollama && docker compose down`) et revoir le point 7 avec la personne qui gère le serveur.
|
||||
- Si `python3` manque ou est trop ancien sur le serveur : `curl -s http://127.0.0.1:11434/v1/models` doit rendre `jeton manquant ou invalide` ; avec le jeton (`set -a && . ~/ollama/.env && set +a && curl -s -H "Authorization: Bearer $EMBEDDINGS_JETON" http://127.0.0.1:11434/v1/models`), la liste avec `bge-m3:567m`.
|
||||
- **Ne pas redémarrer le service Docker pour essayer** : cela redémarrerait aussi LibreDesk. `systemctl is-enabled docker` (point 7) et la politique `unless-stopped` suffisent ; le prochain redémarrage planifié du serveur le confirmera (vérifier alors `docker ps`).
|
||||
|
||||
- [ ] **10. Brancher LibreDesk sur Ollama.** Admin → IA → Providers, Embeddings : fournisseur OpenAI, URL de l'étape 8, modèle `bge-m3:567m`, clé `ollama`, *dimensions* 0, *embedding max tokens* 2048. Bouton de test, puis enregistrer seulement s'il réussit.
|
||||
- [ ] **10. Brancher LibreDesk sur Ollama.** Admin → IA → Providers, Embeddings : fournisseur OpenAI, URL de l'étape 8, modèle `bge-m3:567m`, clé = le jeton du serveur (`EMBEDDINGS_JETON` de `~/ollama/.env`), *dimensions* 0, *embedding max tokens* 2048. Bouton de test, puis enregistrer seulement s'il réussit.
|
||||
Vérification : le test réussit ; la complétion n'a pas changé.
|
||||
|
||||
- [ ] **11. Le recalcul.** LibreDesk recalcule seul les 118 extraits (environ une minute). Dans ses journaux (`docker logs <conteneur LibreDesk> --since 10m 2>&1 | grep -E "embedding provider changed|reconciled embeddings|error generating embeddings"`) :
|
||||
@@ -102,7 +109,7 @@ Au clic sur « Generate reply », le LLM peut appeler l'outil `get_customer_acce
|
||||
|
||||
## Au quotidien
|
||||
|
||||
- **Si Ollama est arrêté**, « Generate reply » rend quand même un brouillon, mais **sans la base de connaissances**, et rien ne le signale à l'agent (journaux de LibreDesk : `AI provider unavailable`, `search_articles` en erreur). Si les brouillons deviennent vagues : `docker ps --filter name=ollama-bge-m3` et `python3 ~/ollama/verifier_ollama.py …` sur le serveur. Pour le relancer (un arrêt manuel n'est pas relancé seul), toujours `cd ~/ollama && docker compose up -d --no-build` plutôt que `docker start` : si LibreDesk a recréé son réseau entre-temps, seul Compose y rattache Ollama.
|
||||
- **Si Ollama est arrêté**, « Generate reply » rend quand même un brouillon, mais **sans la base de connaissances**, et rien ne le signale à l'agent (journaux de LibreDesk : `AI provider unavailable`, `search_articles` en erreur). Si les brouillons deviennent vagues : `docker ps --filter name=embeddings-bge-m3` et `python3 ~/ollama/verifier_ollama.py …` sur le serveur. Pour le relancer (un arrêt manuel n'est pas relancé seul), toujours `cd ~/ollama && docker compose up -d --no-build` plutôt que `docker start` : si LibreDesk a recréé son réseau entre-temps, seul Compose y rattache Ollama.
|
||||
- **Ollama est rattaché au réseau de LibreDesk** (cas Docker) : tant qu'il y est, un `docker compose down` de LibreDesk ne peut pas supprimer ce réseau (avertissement « Resource is still in use », ou erreur avec l'ancien `docker-compose`). Arrêter Ollama d'abord (`cd ~/ollama && docker compose down`), puis le relancer après LibreDesk.
|
||||
- **Retoucher la base** : modifier le fichier dans `snippets/textes/`, puis réimporter (point 4). Un extrait renommé ou retiré du corpus est signalé (« dans LibreDesk mais pas dans le corpus ») et **n'est pas supprimé** : le désactiver ou le supprimer à la main dans Admin → IA → Snippets.
|
||||
- **Changer de version d'Ollama** : modifier `ollama/Dockerfile`, reconstruire, revérifier hors ligne (`docker run --network none …`, puis `ollama/verifier_ollama.py`), puis refaire les points 6, 8 et 9. Même modèle, même adresse : pas de recalcul.
|
||||
|
||||
@@ -24,6 +24,17 @@ Repris de Support-AI (vérifications des 2026-11-09 et 2026-11-11), limité à c
|
||||
|
||||
**Le réseau du poste** : WSL est en mode `networkingMode=mirrored` ; WSL et Docker ne joignent Windows que par `127.0.0.1`. Pour qu'un conteneur joigne LM Studio sur Windows, il fallait un relais `socat` (voir l'historique de Support-AI) ; avec Ollama dans Docker, le réseau Docker de l'instance suffit.
|
||||
|
||||
## L'image renommée embeddings-bge-m3, avec jeton (2026-11-18) [code, test]
|
||||
|
||||
Image `exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m` (2,49 Go) : la précédente, plus Caddy 2.10.2 devant Ollama. Ollama n'écoute que sur `127.0.0.1:11435` dans le conteneur ; Caddy, sur 11434, ne transmet que les requêtes qui portent `Authorization: Bearer <EMBEDDINGS_JETON>`.
|
||||
- LibreDesk v2.9.0 envoie la clé des embeddings en `Authorization: Bearer <clé>` (`internal/ai/openai.go`, `post`), et lit un 401 comme « clé API invalide » (`ErrInvalidAPIKey`, sans nouvel essai). La clé n'entre pas dans l'empreinte des extraits (`itemFingerprint`) : la changer ne déclenche pas de recalcul.
|
||||
- Sans jeton, ou avec un jeton de moins de 32 caractères : le conteneur s'arrête aussitôt (code 1, message `EMBEDDINGS_JETON manquant ou invalide`).
|
||||
- Hors ligne (réseau Docker `--internal`, alias `ollama` comme sur le réseau de LibreDesk) : `healthy` ; `verifier_ollama.py` → `OK bge-m3:567m, 1024 dimensions, jeton exigé` ; sans en-tête, mauvais jeton, ancienne clé `ollama` : 401 ; bon jeton : 200 ; Ollama lui-même (11435) injoignable depuis un autre conteneur.
|
||||
- Ollama, lié à 127.0.0.1, refuse (403) un Host non local comme `ollama:11434` : Caddy réécrit `Host` (`header_up Host 127.0.0.1:11435`), et ne transmet pas le jeton à Ollama.
|
||||
- Le jeton n'apparaît pas dans `docker logs` ; il est dans l'environnement de Caddy seulement, pas dans celui d'Ollama. Il reste lisible par `docker inspect` (comme `ACCES_JETON`) : réservé à qui administre Docker.
|
||||
- `docker stop` : arrêt immédiat (les signaux sont transmis). Ollama tué dans le conteneur : le conteneur s'arrête, Docker le relance (`RestartCount` 1), de nouveau `healthy`.
|
||||
- Port publié sur `127.0.0.1:11436`, depuis WSL : même résultat que hors ligne.
|
||||
|
||||
## La simulation du passage à Ollama (2026-11-12) [test]
|
||||
|
||||
Instance de test neuve (LibreDesk v2.9.0, Mailpit), base importée (118 extraits), image `exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m` (Ollama 0.40.16, `bge-m3:567m`, **2,43 Go**) sur le réseau Docker de l'instance (`ollama/compose.reseau.yml`).
|
||||
|
||||
@@ -4,6 +4,8 @@ d'embeddings à un autre (LibreDesk recalcule alors seul les vecteurs). Ne crée
|
||||
|
||||
ANTHROPIC_API_KEY=… python3 instance-de-test/3_brancher_ia.py <mot de passe System> <url des embeddings> <modèle> [clé]
|
||||
ex. : … 'TestAdmin-2026!' http://ollama:11434/v1 bge-m3:567m
|
||||
Sans [clé] : le jeton d'embeddings-bge-m3 (EMBEDDINGS_JETON, dans l'environnement ou dans ollama/.env), pour ne pas
|
||||
le taper dans la commande.
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
@@ -11,7 +13,10 @@ from pathlib import Path
|
||||
|
||||
from connexion_admin import connexion, req
|
||||
|
||||
CONSIGNES = Path(__file__).resolve().parents[1] / "snippets" / "consignes_redaction.md"
|
||||
DEPOT = Path(__file__).resolve().parents[1]
|
||||
CONSIGNES = DEPOT / "snippets" / "consignes_redaction.md"
|
||||
sys.path.insert(0, str(DEPOT / "ollama"))
|
||||
from verifier_ollama import lire_jeton # noqa: E402
|
||||
|
||||
|
||||
def configurer(type_: str, config: dict) -> None:
|
||||
@@ -20,8 +25,9 @@ def configurer(type_: str, config: dict) -> None:
|
||||
print(f"{type_} : test réussi, configuration enregistrée")
|
||||
|
||||
|
||||
def main(mot_de_passe: str, url_embeddings: str, modele: str, cle: str = "ollama") -> None:
|
||||
def main(mot_de_passe: str, url_embeddings: str, modele: str, cle: str | None = None) -> None:
|
||||
cle_claude = os.environ.get("ANTHROPIC_API_KEY") or sys.exit("ANTHROPIC_API_KEY manque dans l'environnement")
|
||||
cle = cle or lire_jeton() or sys.exit("pas de clé d'embeddings : EMBEDDINGS_JETON manque (environnement ou ollama/.env)")
|
||||
connexion(mot_de_passe)
|
||||
configurer("completion", {"provider": "openai", "base_url": "https://api.anthropic.com/v1", "api_key": cle_claude,
|
||||
"model": "claude-sonnet-5-5", "max_tokens": 4096, "reasoning_effort": "medium",
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
# Le portier de l'image embeddings-bge-m3 : seul port publié (11434), il ne laisse passer vers Ollama
|
||||
# (127.0.0.1:11435, joignable seulement dans le conteneur) que les requêtes qui portent
|
||||
# « Authorization: Bearer <EMBEDDINGS_JETON> ». Le jeton est donné au lancement, jamais rangé dans l'image.
|
||||
# demarrer.sh vérifie le jeton avant de lancer Caddy : 32 caractères au moins, lettres, chiffres, « _ » et « - »
|
||||
# seulement (« * » serait un joker pour le filtre header, « } » casserait la substitution).
|
||||
{
|
||||
admin off
|
||||
auto_https off
|
||||
persist_config off
|
||||
}
|
||||
|
||||
:11434 {
|
||||
@autorise header Authorization "Bearer {$EMBEDDINGS_JETON}"
|
||||
|
||||
handle @autorise {
|
||||
reverse_proxy 127.0.0.1:11435 {
|
||||
# Ollama, lié à 127.0.0.1, refuse (403) un Host qui n'est pas local, comme « ollama:11434 ».
|
||||
header_up Host 127.0.0.1:11435
|
||||
header_up -Authorization
|
||||
}
|
||||
}
|
||||
|
||||
handle {
|
||||
header WWW-Authenticate "Bearer"
|
||||
respond "jeton manquant ou invalide" 401
|
||||
}
|
||||
}
|
||||
+20
-6
@@ -1,5 +1,8 @@
|
||||
# embeddings-bge-m3 : un service d'embeddings (bge-m3, 1024 dimensions, format OpenAI) protégé par un jeton.
|
||||
# Ollama avec bge-m3 embarqué : l'image démarre sans rien télécharger, et c'est le même modèle partout.
|
||||
# Versions figées (2026-11-12) ; les changer = reconstruire et revérifier (ollama/verifier_ollama.py).
|
||||
# Devant Ollama, Caddy exige « Authorization: Bearer <EMBEDDINGS_JETON> » (Caddyfile, demarrer.sh).
|
||||
# Versions figées (Ollama 2026-11-12, Caddy 2026-11-18) ; les changer = reconstruire et revérifier
|
||||
# (ollama/verifier_ollama.py).
|
||||
|
||||
# 1. Le modèle, téléchargé à la construction par l'image officielle (un serveur lancé le temps du pull) ;
|
||||
# puis les bibliothèques GPU retirées (4,4 Go de CUDA) : bge-m3 tourne sur processeur.
|
||||
@@ -11,21 +14,32 @@ RUN ollama serve >/tmp/serve.log 2>&1 & \
|
||||
rm -rf /usr/lib/ollama/cuda_v12 /usr/lib/ollama/cuda_v13 /usr/lib/ollama/mlx_cuda_v13 \
|
||||
/usr/lib/ollama/vulkan /usr/lib/ollama/include
|
||||
|
||||
# 2. L'image livrée : la même Ubuntu 24.04 que l'image officielle, Ollama, ses bibliothèques processeur, le modèle.
|
||||
# 2. Le portier : Caddy, un seul binaire statique, pris dans l'image officielle.
|
||||
FROM caddy:2.10.2-alpine AS portier
|
||||
|
||||
# 3. L'image livrée : la même Ubuntu 24.04 que l'image officielle d'Ollama, Ollama, ses bibliothèques processeur,
|
||||
# le modèle, et Caddy.
|
||||
FROM ubuntu:noble-20261024.1
|
||||
LABEL org.opencontainers.image.title="embeddings-bge-m3" \
|
||||
org.opencontainers.image.description="Service d'embeddings bge-m3:567m (1024 dimensions), API OpenAI /v1/embeddings, sur processeur, hors ligne, protégé par un jeton (EMBEDDINGS_JETON). Pour la recherche dans la base de connaissances de LibreDesk." \
|
||||
org.opencontainers.image.source="https://exchange.sensima.ch/maxime.pasquier/aimsight-libredesk" \
|
||||
org.opencontainers.image.version="0.40.16-567m"
|
||||
COPY --from=source /usr/bin/ollama /usr/bin/ollama
|
||||
COPY --from=source /usr/lib/ollama /usr/lib/ollama
|
||||
# Seulement les modèles : la clé d'identité (id_ed25519) créée par le serveur du pull reste dans l'étape 1 ;
|
||||
# chaque conteneur génère la sienne au premier démarrage.
|
||||
COPY --from=source /root/.ollama/models /root/.ollama/models
|
||||
COPY --from=portier /usr/bin/caddy /usr/bin/caddy
|
||||
COPY Caddyfile /etc/caddy/Caddyfile
|
||||
COPY demarrer.sh /usr/local/bin/demarrer.sh
|
||||
|
||||
# Écoute sur toutes les interfaces du conteneur ; c'est le compose qui choisit où le port est publié.
|
||||
# Ollama n'écoute que dans le conteneur (127.0.0.1:11435) ; seul Caddy (11434) est joignable de l'extérieur, et
|
||||
# c'est le compose qui choisit où ce port est publié.
|
||||
# KEEP_ALIVE=-1 : le modèle reste chargé, le premier brouillon de la journée ne paie pas le chargement.
|
||||
# NO_CLOUD=1 : aucun appel à ollama.com (recommandations, modèles en ligne) ; tout est local.
|
||||
ENV OLLAMA_HOST=0.0.0.0:11434 \
|
||||
ENV OLLAMA_HOST=127.0.0.1:11435 \
|
||||
OLLAMA_KEEP_ALIVE=-1 \
|
||||
OLLAMA_NO_CLOUD=1
|
||||
EXPOSE 11434
|
||||
HEALTHCHECK --interval=30s --timeout=10s --start-period=20s --retries=3 CMD ["ollama", "list"]
|
||||
ENTRYPOINT ["/usr/bin/ollama"]
|
||||
CMD ["serve"]
|
||||
ENTRYPOINT ["/bin/bash", "/usr/local/bin/demarrer.sh"]
|
||||
@@ -1,5 +1,5 @@
|
||||
# Surcharge : rattache Ollama au réseau Docker de LibreDesk, où il est joignable sous le nom « ollama »
|
||||
# (http://ollama:11434/v1). Localement RESEAU_LIBREDESK=ldtest_libredesk ; sur le serveur, le réseau de LibreDesk.
|
||||
# Surcharge : rattache embeddings-bge-m3 au réseau Docker de LibreDesk, où il est joignable sous le nom « ollama »
|
||||
# (http://ollama:11434/v1, avec le jeton comme pour une adresse publiée). Localement RESEAU_LIBREDESK=ldtest_libredesk ; sur le serveur, le réseau de LibreDesk.
|
||||
# RESEAU_LIBREDESK=<réseau> docker compose -f ollama/compose.yml -f ollama/compose.reseau.yml up -d
|
||||
services:
|
||||
ollama:
|
||||
|
||||
+12
-6
@@ -1,14 +1,20 @@
|
||||
# Ollama + bge-m3, pour LibreDesk. Ollama n'a pas d'authentification : son port n'est publié que sur 127.0.0.1,
|
||||
# sauf si OLLAMA_BIND donne une autre adresse (l'adresse INTERNE du serveur, jamais une adresse publique).
|
||||
# OLLAMA_PORT change seulement le port publié (11434 par défaut, celui du serveur) : utile sur un poste où un autre
|
||||
# Ollama occupe déjà 11434.
|
||||
# embeddings-bge-m3 (Ollama + bge-m3 derrière Caddy), pour LibreDesk. Chaque requête doit porter
|
||||
# « Authorization: Bearer <EMBEDDINGS_JETON> » (dans LibreDesk : le champ « API key » des embeddings).
|
||||
# - ollama/.env (hors de git, jamais lu par Claude) : EMBEDDINGS_JETON (32 caractères au moins, lettres, chiffres,
|
||||
# « _ » et « - ») ; sans lui, le conteneur refuse de démarrer. Et, s'il le faut, OLLAMA_BIND, OLLAMA_PORT.
|
||||
# - Le jeton ne dispense pas de garder le port à l'intérieur : il n'est publié que sur 127.0.0.1, sauf si OLLAMA_BIND
|
||||
# donne une autre adresse (l'adresse INTERNE du serveur, jamais une adresse publique ; HTTP en clair).
|
||||
# - OLLAMA_PORT change seulement le port publié (11434 par défaut, celui du serveur) : utile sur un poste où un autre
|
||||
# Ollama occupe déjà 11434.
|
||||
# docker compose -f ollama/compose.yml build
|
||||
# OLLAMA_BIND=<adresse interne> docker compose -f ollama/compose.yml up -d
|
||||
services:
|
||||
ollama:
|
||||
build: .
|
||||
image: exchange.sensima.ch/maxime.pasquier/ollama-bge-m3:0.40.16-567m
|
||||
container_name: ollama-bge-m3
|
||||
image: exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m
|
||||
container_name: embeddings-bge-m3
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
EMBEDDINGS_JETON: ${EMBEDDINGS_JETON:-}
|
||||
ports:
|
||||
- "${OLLAMA_BIND:-127.0.0.1}:${OLLAMA_PORT:-11434}:11434"
|
||||
@@ -0,0 +1,32 @@
|
||||
#!/bin/bash
|
||||
# Démarrage de l'image embeddings-bge-m3 : Ollama sur 127.0.0.1:11435 (seulement dans le conteneur), et devant lui
|
||||
# Caddy sur 11434, qui exige le jeton (Caddyfile). Sans jeton valable, rien ne démarre : on ne peut pas lancer le
|
||||
# service ouvert par oubli. Si l'un des deux s'arrête, le conteneur s'arrête, et Docker le relance (unless-stopped).
|
||||
set -uo pipefail
|
||||
|
||||
jeton="${EMBEDDINGS_JETON:-}"
|
||||
if [[ ! "$jeton" =~ ^[A-Za-z0-9_-]{32,}$ ]]; then
|
||||
echo "EMBEDDINGS_JETON manquant ou invalide : 32 caractères au moins, lettres, chiffres, « _ » et « - » seulement." >&2
|
||||
echo "Par exemple : python3 -c 'import secrets; print(secrets.token_urlsafe(32))'" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Ollama n'a pas besoin du jeton : il ne le reçoit pas.
|
||||
env -u EMBEDDINGS_JETON /usr/bin/ollama serve &
|
||||
ollama=$!
|
||||
/usr/bin/caddy run --config /etc/caddy/Caddyfile --adapter caddyfile &
|
||||
caddy=$!
|
||||
|
||||
arreter() {
|
||||
kill -TERM "$ollama" "$caddy" 2>/dev/null
|
||||
wait
|
||||
exit 0
|
||||
}
|
||||
trap arreter TERM INT
|
||||
|
||||
wait -n
|
||||
code=$?
|
||||
echo "Ollama ou Caddy s'est arrêté (code $code) : arrêt du conteneur." >&2
|
||||
kill -TERM "$ollama" "$caddy" 2>/dev/null
|
||||
wait
|
||||
exit 1
|
||||
+50
-11
@@ -1,49 +1,88 @@
|
||||
"""Vérifie qu'une adresse Ollama (format OpenAI) sert bge-m3:567m en dimension 1024, comme LibreDesk l'attend.
|
||||
"""Vérifie qu'une adresse embeddings-bge-m3 (format OpenAI) sert bge-m3:567m en dimension 1024, comme LibreDesk
|
||||
l'attend, avec le jeton, et qu'elle refuse une requête sans jeton.
|
||||
Bibliothèque standard seulement : tourne sur le poste, sur le serveur, ou dans un conteneur python.
|
||||
|
||||
python3 ollama/verifier_ollama.py http://127.0.0.1:11434/v1
|
||||
|
||||
Le jeton vient de la variable EMBEDDINGS_JETON, sinon du fichier .env posé à côté de ce script (ollama/.env, ou
|
||||
~/ollama/.env sur le serveur) : il n'apparaît ni dans la commande ni dans l'historique, et n'est jamais affiché.
|
||||
"""
|
||||
from __future__ import annotations # lisible par le Python du serveur, même ancien (3.8, 3.9)
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
MODELE = "bge-m3:567m"
|
||||
DIMENSION = 1024
|
||||
VARIABLE = "EMBEDDINGS_JETON"
|
||||
|
||||
|
||||
def _appel(url: str, corps: dict | None = None) -> dict:
|
||||
r = urllib.request.Request(url, data=json.dumps(corps).encode() if corps is not None else None,
|
||||
headers={"Content-Type": "application/json", "Authorization": "Bearer ollama"})
|
||||
class JetonRefuse(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
def lire_jeton(env: dict | None = None, fichier: Path | None = None) -> str | None:
|
||||
"""Le jeton de `env` (os.environ par défaut), sinon celui du .env à côté de ce script ; None s'il n'y en a pas."""
|
||||
env = os.environ if env is None else env
|
||||
fichier = Path(__file__).with_name(".env") if fichier is None else fichier
|
||||
if env.get(VARIABLE):
|
||||
return env[VARIABLE]
|
||||
if not fichier.is_file():
|
||||
return None
|
||||
for ligne in fichier.read_text(encoding="utf-8").splitlines():
|
||||
cle, egal, valeur = ligne.strip().partition("=")
|
||||
if egal and cle.strip() == VARIABLE:
|
||||
return valeur.strip().strip("'\"") or None
|
||||
return None
|
||||
|
||||
|
||||
def _appel(url: str, jeton: str | None, corps: dict | None = None) -> dict:
|
||||
entetes = {"Content-Type": "application/json"}
|
||||
if jeton is not None:
|
||||
entetes["Authorization"] = f"Bearer {jeton}"
|
||||
r = urllib.request.Request(url, data=json.dumps(corps).encode() if corps is not None else None, headers=entetes)
|
||||
try:
|
||||
with urllib.request.urlopen(r, timeout=120) as rep:
|
||||
return json.loads(rep.read())
|
||||
except urllib.error.HTTPError as e:
|
||||
with e:
|
||||
if e.code == 401:
|
||||
raise JetonRefuse(f"{url} : 401, jeton refusé") from e
|
||||
raise RuntimeError(f"{url} : {e.code} {e.read().decode(errors='replace')[:200]}") from e
|
||||
except (urllib.error.URLError, TimeoutError) as e:
|
||||
raise RuntimeError(f"Ollama injoignable à {url} : {getattr(e, 'reason', e)}") from e
|
||||
raise RuntimeError(f"service d'embeddings injoignable à {url} : {getattr(e, 'reason', e)}") from e
|
||||
|
||||
|
||||
def verifier(base_url: str) -> str:
|
||||
"""Rend « OK bge-m3:567m, 1024 dimensions » ; lève RuntimeError avec ce qui manque."""
|
||||
def verifier(base_url: str, jeton: str) -> str:
|
||||
"""Rend « OK bge-m3:567m, 1024 dimensions, jeton exigé » ; lève RuntimeError avec ce qui manque."""
|
||||
base = base_url.rstrip("/")
|
||||
modeles = [m.get("id") for m in _appel(f"{base}/models").get("data") or []]
|
||||
try:
|
||||
_appel(f"{base}/models", None)
|
||||
except JetonRefuse:
|
||||
pass
|
||||
else:
|
||||
raise RuntimeError(f"{base} répond sans jeton : la protection n'est pas active (ancienne image, ou Ollama nu ?)")
|
||||
modeles = [m.get("id") for m in _appel(f"{base}/models", jeton).get("data") or []]
|
||||
if MODELE not in modeles:
|
||||
raise RuntimeError(f"{MODELE} absent de {base}/models (servis : {modeles})")
|
||||
vecteur = _appel(f"{base}/embeddings", {"model": MODELE, "input": "Quelle est l'autonomie de la batterie ?"}
|
||||
vecteur = _appel(f"{base}/embeddings", jeton, {"model": MODELE, "input": "Quelle est l'autonomie de la batterie ?"}
|
||||
)["data"][0]["embedding"]
|
||||
if len(vecteur) != DIMENSION:
|
||||
raise RuntimeError(f"vecteur de {len(vecteur)} dimensions, {DIMENSION} attendues")
|
||||
return f"OK {MODELE}, {DIMENSION} dimensions"
|
||||
return f"OK {MODELE}, {DIMENSION} dimensions, jeton exigé"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) != 2:
|
||||
sys.exit(__doc__)
|
||||
jeton = lire_jeton()
|
||||
if not jeton:
|
||||
sys.exit(f"ÉCHEC : pas de jeton ({VARIABLE} dans l'environnement ou dans {Path(__file__).with_name('.env')})")
|
||||
try:
|
||||
print(verifier(sys.argv[1]))
|
||||
print(verifier(sys.argv[1], jeton))
|
||||
except RuntimeError as e:
|
||||
sys.exit(f"ÉCHEC : {e}")
|
||||
+127
-17
@@ -1,8 +1,12 @@
|
||||
"""L'image Ollama : le script de vérification (contre un faux serveur) et les garde-fous du lancement (design §2, §5)."""
|
||||
"""L'image embeddings-bge-m3 : le script de vérification (contre un faux serveur) et les garde-fous du lancement
|
||||
(design §2, §5) ; le jeton exigé par Caddy devant Ollama."""
|
||||
import ast
|
||||
import json
|
||||
import os
|
||||
import socket
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
@@ -11,34 +15,48 @@ from pathlib import Path
|
||||
OLLAMA = Path(__file__).resolve().parents[1] / "ollama"
|
||||
COMPOSE = OLLAMA / "compose.yml"
|
||||
DOCKERFILE = OLLAMA / "Dockerfile"
|
||||
CADDYFILE = OLLAMA / "Caddyfile"
|
||||
DEMARRER = OLLAMA / "demarrer.sh"
|
||||
IMAGE = "exchange.sensima.ch/maxime.pasquier/embeddings-bge-m3:0.40.16-567m"
|
||||
JETON = "j" * 40
|
||||
sys.path.insert(0, str(OLLAMA))
|
||||
from verifier_ollama import verifier # noqa: E402
|
||||
from verifier_ollama import lire_jeton, verifier # noqa: E402
|
||||
|
||||
|
||||
class FauxOllama:
|
||||
"""Rend `modeles` sur GET /v1/models et un vecteur de `dimension` nombres sur POST /v1/embeddings."""
|
||||
"""Rend `modeles` sur GET /v1/models et un vecteur de `dimension` nombres sur POST /v1/embeddings.
|
||||
Avec `jeton`, comme Caddy : 401 si l'en-tête n'est pas « Authorization: Bearer <jeton> »."""
|
||||
|
||||
def __init__(self, modeles: list[str], dimension: int):
|
||||
def __init__(self, modeles: list[str], dimension: int, jeton: str | None = JETON):
|
||||
faux = self
|
||||
self.corps_recus: list[dict] = []
|
||||
|
||||
class Gestion(BaseHTTPRequestHandler):
|
||||
def _json(self, data: dict):
|
||||
def _json(self, data: dict, code: int = 200):
|
||||
texte = json.dumps(data).encode()
|
||||
self.send_response(200)
|
||||
self.send_response(code)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("Content-Length", str(len(texte)))
|
||||
self.end_headers()
|
||||
self.wfile.write(texte)
|
||||
|
||||
def _autorise(self) -> bool:
|
||||
if jeton is None or self.headers.get("Authorization") == f"Bearer {jeton}":
|
||||
return True
|
||||
self._json({"erreur": "jeton manquant ou invalide"}, 401)
|
||||
return False
|
||||
|
||||
def do_GET(self):
|
||||
self._json({"object": "list", "data": [{"id": m, "object": "model"} for m in modeles]})
|
||||
if self._autorise():
|
||||
self._json({"object": "list", "data": [{"id": m, "object": "model"} for m in modeles]})
|
||||
|
||||
def do_POST(self):
|
||||
n = int(self.headers.get("Content-Length") or 0)
|
||||
faux.corps_recus.append(json.loads(self.rfile.read(n)))
|
||||
self._json({"object": "list", "data": [{"object": "embedding", "index": 0,
|
||||
"embedding": [0.01] * dimension}]})
|
||||
corps = json.loads(self.rfile.read(n))
|
||||
if self._autorise():
|
||||
faux.corps_recus.append(corps)
|
||||
self._json({"object": "list", "data": [{"object": "embedding", "index": 0,
|
||||
"embedding": [0.01] * dimension}]})
|
||||
|
||||
def log_message(self, *_):
|
||||
pass
|
||||
@@ -53,32 +71,64 @@ class FauxOllama:
|
||||
|
||||
|
||||
class TestVerifier(unittest.TestCase):
|
||||
def faux(self, modeles: list[str], dimension: int) -> FauxOllama:
|
||||
f = FauxOllama(modeles, dimension)
|
||||
def faux(self, modeles: list[str], dimension: int, jeton: str | None = JETON) -> FauxOllama:
|
||||
f = FauxOllama(modeles, dimension, jeton)
|
||||
self.addCleanup(f.arreter)
|
||||
return f
|
||||
|
||||
def test_modele_et_dimension_ok(self):
|
||||
f = self.faux(["bge-m3:567m"], 1024)
|
||||
self.assertIn("1024", verifier(f.url))
|
||||
self.assertIn("1024", verifier(f.url, JETON))
|
||||
self.assertEqual(f.corps_recus[0]["model"], "bge-m3:567m")
|
||||
|
||||
def test_modele_absent(self):
|
||||
f = self.faux(["nomic-embed-text:latest"], 1024)
|
||||
with self.assertRaisesRegex(RuntimeError, "bge-m3:567m"):
|
||||
verifier(f.url)
|
||||
verifier(f.url, JETON)
|
||||
|
||||
def test_mauvaise_dimension(self):
|
||||
f = self.faux(["bge-m3:567m"], 768)
|
||||
with self.assertRaisesRegex(RuntimeError, "768"):
|
||||
verifier(f.url)
|
||||
verifier(f.url, JETON)
|
||||
|
||||
def test_adresse_injoignable(self):
|
||||
with socket.socket() as s: # un port libre, que personne n'écoute une fois fermé (refus immédiat)
|
||||
s.bind(("127.0.0.1", 0))
|
||||
port = s.getsockname()[1]
|
||||
with self.assertRaisesRegex(RuntimeError, "injoignable"):
|
||||
verifier(f"http://127.0.0.1:{port}/v1")
|
||||
verifier(f"http://127.0.0.1:{port}/v1", JETON)
|
||||
|
||||
def test_mauvais_jeton(self):
|
||||
f = self.faux(["bge-m3:567m"], 1024)
|
||||
with self.assertRaisesRegex(RuntimeError, "jeton refusé"):
|
||||
verifier(f.url, "x" * 40)
|
||||
self.assertEqual(f.corps_recus, [])
|
||||
|
||||
def test_service_ouvert_sans_jeton_refuse(self): # l'ancienne image, ou un Ollama nu : à ne pas brancher
|
||||
f = self.faux(["bge-m3:567m"], 1024, jeton=None)
|
||||
with self.assertRaisesRegex(RuntimeError, "sans jeton"):
|
||||
verifier(f.url, JETON)
|
||||
|
||||
|
||||
class TestLireJeton(unittest.TestCase):
|
||||
def fichier(self, texte: str) -> Path:
|
||||
d = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(d.cleanup)
|
||||
p = Path(d.name) / ".env"
|
||||
p.write_text(texte, encoding="utf-8")
|
||||
return p
|
||||
|
||||
def test_variable_d_environnement_d_abord(self):
|
||||
p = self.fichier("EMBEDDINGS_JETON=du-fichier\n")
|
||||
self.assertEqual(lire_jeton({"EMBEDDINGS_JETON": "de-l-env"}, p), "de-l-env")
|
||||
|
||||
def test_sinon_le_env_a_cote_du_script(self):
|
||||
p = self.fichier("OLLAMA_BIND=10.0.0.1\n# commentaire\nEMBEDDINGS_JETON='abc_DEF-123'\n")
|
||||
self.assertEqual(lire_jeton({}, p), "abc_DEF-123")
|
||||
|
||||
def test_absent(self):
|
||||
self.assertIsNone(lire_jeton({}, self.fichier("OLLAMA_BIND=10.0.0.1\n")))
|
||||
self.assertIsNone(lire_jeton({}, Path(tempfile.gettempdir()) / "pas-de-fichier-ici" / ".env"))
|
||||
|
||||
|
||||
class TestCompatibilite(unittest.TestCase):
|
||||
@@ -94,19 +144,36 @@ class TestCompatibilite(unittest.TestCase):
|
||||
|
||||
|
||||
class TestLancement(unittest.TestCase):
|
||||
def test_port_lie_a_localhost_par_defaut(self): # Ollama n'a pas d'authentification
|
||||
def test_nom_de_l_image_et_du_conteneur(self):
|
||||
texte = COMPOSE.read_text()
|
||||
self.assertIn(f"image: {IMAGE}", texte)
|
||||
self.assertIn("container_name: embeddings-bge-m3", texte)
|
||||
self.assertNotIn("ollama-bge-m3", texte)
|
||||
|
||||
def test_port_lie_a_localhost_par_defaut(self): # le jeton ne dispense pas de garder le port à l'intérieur
|
||||
self.assertIn('"${OLLAMA_BIND:-127.0.0.1}:${OLLAMA_PORT:-11434}:11434"', COMPOSE.read_text())
|
||||
self.assertNotIn("0.0.0.0:11434:", COMPOSE.read_text())
|
||||
|
||||
def test_jeton_passe_au_lancement(self): # jamais dans l'image : le paquet est public
|
||||
self.assertIn("EMBEDDINGS_JETON: ${EMBEDDINGS_JETON:-}", COMPOSE.read_text())
|
||||
self.assertNotIn("EMBEDDINGS_JETON=", DOCKERFILE.read_text())
|
||||
|
||||
def test_redemarrage_automatique(self):
|
||||
self.assertIn("restart: unless-stopped", COMPOSE.read_text())
|
||||
|
||||
def test_version_figee(self):
|
||||
texte = DOCKERFILE.read_text()
|
||||
self.assertRegex(texte, r"FROM ollama/ollama:\d+\.\d+\.\d+\s")
|
||||
self.assertRegex(texte, r"FROM caddy:\d+\.\d+\.\d+-alpine\s")
|
||||
self.assertNotIn("latest", texte)
|
||||
self.assertIn("bge-m3:567m", texte)
|
||||
|
||||
def test_description_dans_l_image(self): # Gitea l'affiche sur la page du paquet
|
||||
texte = DOCKERFILE.read_text()
|
||||
for label in ("title", "description", "source"):
|
||||
self.assertIn(f"org.opencontainers.image.{label}=", texte)
|
||||
self.assertIn('org.opencontainers.image.title="embeddings-bge-m3"', texte)
|
||||
|
||||
def test_pas_d_appel_au_nuage(self): # sans ce réglage, Ollama interroge ollama.com au démarrage
|
||||
self.assertIn("OLLAMA_NO_CLOUD=1", DOCKERFILE.read_text())
|
||||
|
||||
@@ -122,5 +189,48 @@ class TestLancement(unittest.TestCase):
|
||||
self.assertFalse([c for c in copies if c.rstrip("/") in ("/root", "/root/.ollama")], copies)
|
||||
|
||||
|
||||
class TestPortier(unittest.TestCase):
|
||||
"""Ollama n'écoute que dans le conteneur ; seul Caddy est publié, et il exige le jeton."""
|
||||
|
||||
def test_ollama_n_ecoute_que_dans_le_conteneur(self):
|
||||
texte = DOCKERFILE.read_text()
|
||||
self.assertIn("OLLAMA_HOST=127.0.0.1:11435", texte)
|
||||
self.assertNotIn("OLLAMA_HOST=0.0.0.0", texte)
|
||||
|
||||
def test_caddy_exige_le_jeton(self):
|
||||
texte = CADDYFILE.read_text()
|
||||
self.assertIn('header Authorization "Bearer {$EMBEDDINGS_JETON}"', texte)
|
||||
self.assertIn("reverse_proxy 127.0.0.1:11435", texte)
|
||||
self.assertIn("respond", texte)
|
||||
self.assertIn("401", texte)
|
||||
|
||||
def test_caddy_sans_administration_ni_https_automatique(self):
|
||||
texte = CADDYFILE.read_text()
|
||||
self.assertIn("admin off", texte)
|
||||
self.assertIn("auto_https off", texte)
|
||||
|
||||
def test_hote_reecrit_pour_ollama(self): # Ollama, lié à 127.0.0.1, refuse (403) un Host comme « ollama:11434 »
|
||||
self.assertIn("header_up Host 127.0.0.1:11435", CADDYFILE.read_text())
|
||||
|
||||
def lancer(self, jeton: str | None) -> subprocess.CompletedProcess:
|
||||
env = {k: v for k, v in os.environ.items() if k != "EMBEDDINGS_JETON"}
|
||||
if jeton is not None:
|
||||
env["EMBEDDINGS_JETON"] = jeton
|
||||
# Les jetons refusés arrêtent le script avant tout lancement : rien d'Ollama ni de Caddy n'est appelé ici.
|
||||
return subprocess.run(["bash", str(DEMARRER)], env=env, capture_output=True, text=True, timeout=10)
|
||||
|
||||
def test_refuse_de_demarrer_sans_jeton(self):
|
||||
r = self.lancer(None)
|
||||
self.assertNotEqual(r.returncode, 0)
|
||||
self.assertIn("EMBEDDINGS_JETON", r.stderr)
|
||||
|
||||
def test_refuse_un_jeton_court(self):
|
||||
self.assertNotEqual(self.lancer("a" * 31).returncode, 0)
|
||||
|
||||
def test_refuse_les_caracteres_speciaux(self): # « * » serait un joker pour Caddy, « } » casserait le Caddyfile
|
||||
for jeton in ("a" * 32 + "*", "a" * 32 + "}", "a" * 32 + " b", "a" * 32 + '"'):
|
||||
self.assertNotEqual(self.lancer(jeton).returncode, 0, jeton)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user