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:
maximeandClaude Opus 5.5 committed 2026-11-18 15:31:12 +01:00
commit e3c4a29e90
13 files changed
+315 -57

No files matched your search

+2 -1
View File
@@ -6,7 +6,8 @@
"Read(./.env)",
"Read(./.env.*)",
"Read(./instance-de-test/.env)",
"Read(./acces/.env)"
"Read(./acces/.env)",
"Read(./ollama/.env)"
]
},
"hooks": {}
+1
View File
@@ -1,6 +1,7 @@
.env
instance-de-test/.env
acces/.env
ollama/.env
acces/database.db
acces/utilisateurs.json
instance-de-test/config.toml
+7 -3
View File
@@ -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
View File
@@ -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.
+11
View File
@@ -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`).
+8 -2
View File
@@ -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",
+27
View File
@@ -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
View File
@@ -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"]
+2 -2
View File
@@ -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
View File
@@ -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"
+32
View File
@@ -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
View File
@@ -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
View File
@@ -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()