Folzo/Effi
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: Documentation Effi v1.0

Browse Source 
- Structure complète du projet
- Docker compose de production
- Documentation organisée par thèmes
- Guides d'installation et configuration
- Section dépannage détaillée
- Journal historique
This commit is contained in:
Folzo
2026-04-04 08:45:59 +02:00
commit d1e12cff60
35 changed files with 4656 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/04-depannage/README.md
+119
View File
@@ -0,0 +1,119 @@
# 🔧 Dépannage - Index
## Vue d'ensemble
Cette section regroupe les problèmes courants rencontrés avec Effi et leurs solutions.
---
## Problèmes par catégorie
### 🖥️ [GPU AMD ROCm](./rocm-amd-gpu.md)
- `hipErrorInvalidDeviceFunction`
- `float16 not supported on CPU backend`
- Build CTranslate2 pour gfx1100
- ROCm non détecté
### 🌐 [Réseau et Ports](./reseau-et-ports.md)
- Conflits de ports
- Wake-on-LAN non fonctionnel
- Interface réseau qui tombe
- Erreurs de connexion entre machines
### 💾 Mémoire et Stockage
- Souvenirs qui ne s'enregistrent pas
- Souvenirs non injectés
- Erreurs SQLite
- Base CouchDB inaccessible
### 🐳 Docker
- Conteneurs qui redémarrent en boucle
- Erreurs de permissions
- Volumes non persistants
- Images qui ne buildent pas
### 🎤 Audio
- STT qui ne répond pas
- TTS silencieux
- Latence excessive
- Erreurs de transcription
---
## Diagnostic rapide
### Commandes de base
```bash
# Vérifier l'état des conteneurs
docker compose ps
# Voir les logs d'un service
docker compose logs [service]
# Vérifier l'utilisation des ressources
docker stats
# Tester les connexions réseau
curl http://192.168.1.27:3000 # OpenWebUI
curl http://192.168.1.11:11434/api/tags # Ollama
curl http://192.168.1.11:8200/v1/models # STT
curl http://192.168.1.11:8100/v1/models # TTS
```
### Logs importants
```bash
# Logs OpenWebUI (problèmes généraux)
docker logs open-webui --tail 100
# Logs avec filtre mémoire
docker logs open-webui --tail 50 | grep -iE "memory|saved|added"
# Logs speaches (STT)
docker logs speaches-stt
# Logs wol-proxy
docker logs wol-proxy
```
---
## Checklist de diagnostic
### Problème : Effi ne répond pas
- [ ] OpenWebUI est-il démarré ? `docker ps | grep open-webui`
- [ ] Ollama est-il accessible ? `curl http://192.168.1.11:11434/api/tags`
- [ ] Le PC Gaming est-il allumé ?
- [ ] Le wol-proxy fonctionne-t-il ? `docker logs wol-proxy`
### Problème : La mémoire ne fonctionne pas
- [ ] Auto Memory est-il activé globalement ?
- [ ] Memory Injection est-il activé globalement ?
- [ ] Le modèle qwen2.5:3b est-il disponible ?
- [ ] Y a-t-il des erreurs dans les logs ? `docker logs open-webui | grep -i memory`
### Problème : L'audio ne fonctionne pas
- [ ] speaches est-il démarré ? `docker ps | grep speaches`
- [ ] openedai-speech est-il démarré ?
- [ ] Les URLs dans OpenWebUI sont-elles correctes ?
- [ ] Test manuel : `curl http://192.168.1.11:8200/v1/models`
### Problème : ROCm/GPU
- [ ] ROCm est-il installé ? `rocm-smi --showproductname`
- [ ] La carte est-elle détectée ? `rocminfo | grep gfx`
- [ ] Les conteneurs utilisent-ils les bons devices ?
- [ ] L'architecture gfx est-elle correcte ?
---
## Ressources externes
- [Documentation OpenWebUI](https://docs.openwebui.com/)
- [Documentation Ollama](https://github.com/ollama/ollama/blob/main/docs/README.md)
- [Documentation ROCm AMD](https://docs.amd.com)
- [Documentation Qdrant](https://qdrant.tech/documentation/)
docs/04-depannage/reseau-et-ports.md
+256
View File
@@ -0,0 +1,256 @@
# 🌐 Dépannage Réseau et Ports
## Conflits de ports
### Symptôme : `bind: address already in use`
**Erreur :**
```
Error starting userland proxy: listen tcp 0.0.0.0:8200: bind: address already in use
```
**Diagnostic :**
```bash
# Trouver quel processus utilise le port
sudo ss -tlnp | grep 8200
# ou
sudo lsof -i :8200
# Voir tous les ports utilisés
sudo ss -tlnp
```
**Solutions :**
1. **Changer le port dans docker-compose.yml :**
```yaml
ports:
- "8201:8000" # Au lieu de 8200:8000
```
2. **Ou arrêter le processus existant :**
```bash
sudo kill -9 <PID>
```
---
## Wake-on-LAN (WOL) non fonctionnel
### Diagnostic
```bash
# Vérifier que wol-proxy est configuré
docker logs wol-proxy | tail -20
# Tester le WoL manuellement
sudo apt install wakeonlan
wakeonlan XX:XX:XX:XX:XX:XX # MAC de folzo-Corp
# Vérifier que la carte réseau supporte WoL
ethtool enp3s0 | grep -i wake
```
### Configuration wol-proxy
**Vérifier les variables dans `.env` :**
```bash
OLLAMA_HOST=192.168.1.11
PC_GAMING_MAC=XX:XX:XX:XX:XX:XX
BROADCAST_IP=192.168.1.255
```
### Activer WoL sur le PC Gaming (folzo-Corp)
```bash
# Sur Bazzite/Fedora
sudo ethtool -s enp3s0 wol g
# Rendre permanent
echo 'ACTION=="add", SUBSYSTEM=="net", NAME=="enp3s0", RUN+="/usr/sbin/ethtool -s enp3s0 wol g"' | \
sudo tee /etc/udev/rules.d/99-wol.rules
```
---
## Interface réseau qui tombe (effi-server)
### Symptôme : effi-server inaccessible après reboot
**Cause :** Problème de carte réseau Intel i225/i226 avec power saving
**Solution immédiate :**
```bash
sudo systemctl restart NetworkManager
```
**Solution permanente :**
```bash
# Désactiver le power saving
echo 'ACTION=="add", SUBSYSTEM=="net", NAME=="enp3s0", RUN+="/usr/sbin/ethtool -s enp3s0 wol g"' | \
sudo tee /etc/udev/rules.d/99-disable-net-powersave.rules
# Recharger les règles
sudo udevadm control --reload-rules
sudo udevadm trigger
```
---
## Conflit DHCP - Deux machines avec même IP
### Symptôme : `conflict detected for IP address`
**Diagnostic :**
```bash
# Sur effi-server
ip addr show
# Vérifier si l'IP est correcte
```
**Solution temporaire :**
```bash
# Renouveler le bail DHCP
sudo nmcli device disconnect enp6s0
sudo nmcli device connect enp6s0
```
**Solution permanente :**
- Configurer des réservations DHCP par MAC sur le routeur
- Ou configurer des IPs statiques
---
## Erreurs de connexion entre machines
### Ollama inaccessible depuis effi-server
**Diagnostic :**
```bash
# Depuis effi-server
curl http://192.168.1.11:11434/api/tags
# Vérifier que Ollama écoute sur 0.0.0.0
# Sur folzo-Corp :
sudo ss -tlnp | grep 11434
# Devrait afficher 0.0.0.0:11434, pas 127.0.0.1:11434
```
**Solution :** Configurer Ollama pour écouter sur toutes les interfaces :
```bash
# Sur folzo-Corp
sudo systemctl edit ollama.service
```
Ajouter :
```ini
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
```
```bash
sudo systemctl daemon-reload
sudo systemctl restart ollama
```
---
## Firewall et pare-feu
### Ouvrir les ports sur folzo-Corp (Fedora/Bazzite)
```bash
# Ouvrir les ports pour STT et TTS
sudo firewall-cmd --add-port=8200/tcp --permanent # speaches
sudo firewall-cmd --add-port=8100/tcp --permanent # openedai-speech
sudo firewall-cmd --add-port=11434/tcp --permanent # Ollama
sudo firewall-cmd --reload
```
### Ouvrir les ports sur effi-server (Ubuntu)
```bash
# Avec UFW
sudo ufw allow 3000/tcp # OpenWebUI
sudo ufw allow 5678/tcp # n8n
sudo ufw allow 5984/tcp # CouchDB
sudo ufw allow 6333/tcp # Qdrant
sudo ufw allow 8000/tcp # mcpo
sudo ufw reload
```
---
## Erreur 500 / Connection refused
### OpenWebUI : "Server Connection Error"
**Diagnostic :**
```bash
# Voir les logs
docker logs open-webui | grep -i "error\|connection"
# Vérifier si Ollama répond
curl http://192.168.1.27:3011/v1/models
```
**Causes possibles :**
1. PC Gaming éteint → WoL devrait le réveiller
2. wol-proxy mal configuré
3. Ollama planté sur folzo-Corp
**Solutions :**
```bash
# Redémarrer wol-proxy
docker restart wol-proxy
# Sur folzo-Corp, vérifier Ollama
sudo systemctl status ollama
sudo systemctl restart ollama
```
---
## Latence réseau élevée
### Test de connectivité
```bash
# Ping entre les machines
ping 192.168.1.11
# Test de bande passante
iperf3 -s # Sur serveur
iperf3 -c 192.168.1.27 # Sur client
# Vérifier les erreurs réseau
ifconfig | grep -i error
```
### Optimisations
1. **Utiliser des IPs fixes** : Éviter les délais DHCP
2. **Câblage Ethernet** : Préférer le filaire au WiFi
3. **MTU** : Vérifier la taille des paquets
```bash
ping -M do -s 1472 192.168.1.11
```
---
## Tableau des ports utilisés
| Port | Service | Machine | Protocole |
|------|---------|---------|-----------|
| 3000 | Open WebUI | effi-server | TCP |
| 3011 | wol-proxy | effi-server | TCP |
| 3100 | Obsidian | effi-server | TCP |
| 5678 | n8n | effi-server | TCP |
| 5984 | CouchDB | effi-server | TCP |
| 6333 | Qdrant HTTP | effi-server | TCP |
| 6334 | Qdrant gRPC | effi-server | TCP |
| 8000 | mcpo | effi-server | TCP |
| 8100 | openedai-speech | folzo-Corp | TCP |
| 8200 | speaches | folzo-Corp | TCP |
| 9099 | pipelines | effi-server | TCP |
| 11434 | Ollama | folzo-Corp | TCP |
docs/04-depannage/rocm-amd-gpu.md
+213
View File
@@ -0,0 +1,213 @@
# 🎮 Dépannage GPU AMD ROCm
## Erreurs courantes
### `hipErrorInvalidDeviceFunction`
**Symptôme :**
```
RuntimeError: parallel_for failed: hipErrorInvalidDeviceFunction: invalid device function
```
**Cause :** Le build ROCm a été compilé pour une mauvaise architecture GPU.
**Solution :**
1. Vérifier l'architecture de votre GPU :
```bash
rocminfo | grep gfx
# ou
docker run --device /dev/kfd --device /dev/dri \
-e HSA_OVERRIDE_GFX_VERSION=11.0.0 rocm/dev-ubuntu-24.04:6.3.4-complete \
/opt/rocm-6.3.4/bin/rocminfo | grep -E "gfx|Name"
```
2. Modifier le Dockerfile pour votre architecture :
```bash
cd ~/speaches/src
sed -i 's/gfx1101/gfx1100/g' Dockerfile.rocm-ct2
```
3. Rebuilder l'image :
```bash
docker build -f Dockerfile.rocm-ct2 -t speaches:rocm-ct2 .
```
**Architectures courantes :**
- RX 7800 XT / 7900 XTX : `gfx1100`
- RX 7700 XT : `gfx1101`
- RX 6000 series : `gfx1030`
---
### `float16 not supported on CPU backend`
**Symptôme :**
```
ValueError: float16 not supported on CPU backend
```
**Cause :** Whisper essaie d'utiliser float16 sur CPU (mode fallback).
**Solution :** Changer le compute type :
```yaml
environment:
- WHISPER__COMPUTE_TYPE=int8 # ou float32
```
---
### `Conv1D on GPU currently requires the cuDNN library`
**Symptôme :**
```
RuntimeError: Conv1D on GPU currently requires the cuDNN library which is not integrated in this build
```
**Cause :** CTranslate2 ROCm compilé sans support MIOpen (équivalent cuDNN).
**Solution :** Ajouter MIOpen dans le Dockerfile :
```dockerfile
# Dans Dockerfile.rocm-ct2
RUN cmake ... \
-DWITH_CUDNN=ON \
-DCUDnn_LIBRARY=/opt/rocm-6.3.4/lib/libMIOpen.so
```
---
### `Unable to find group render`
**Symptôme :**
```
Unable to find group render: no matching entries in group file
```
**Cause :** Les noms de groupes ne sont pas reconnus dans le conteneur.
**Solution :** Utiliser les GID numériques :
```yaml
group_add:
- "44" # GID video
- "991" # GID render
```
**Trouver les GID :**
```bash
cat /etc/group | grep -E "video|render"
```
---
### ROCm non détecté
**Symptôme :** `rocm-smi` ne trouve pas de GPU
**Diagnostic :**
```bash
# Vérifier que le kernel voit le GPU
lspci | grep -i vga
# Vérifier les modules kernel
lsmod | grep amdgpu
# Vérifier les devices
ls -la /dev/kfd /dev/dri
```
**Solutions :**
1. **Installer ROCm :**
```bash
# Sur Fedora/Bazzite
sudo dnf install -y rocm-dev rocm-smi
# Sur Ubuntu
sudo apt install -y rocm-dev
```
2. **Ajouter l'utilisateur au groupe video :**
```bash
sudo usermod -aG video $USER
sudo usermod -aG render $USER
# Déconnexion/reconnexion nécessaire
```
3. **Vérifier les permissions :**
```bash
ls -la /dev/kfd
# Doit être accessible au groupe video
```
---
### Faible performance GPU
**Symptôme :** La transcription prend toujours 10s+ malgré ROCm
**Diagnostic :**
```bash
# Vérifier l'utilisation GPU
rocm-smi
# Voir si ROCm est vraiment utilisé
docker logs speaches-stt | grep -i "rocm\|cuda\|gpu"
# Vérifier les variables d'environnement
docker inspect speaches-stt | grep -i env
```
**Causes possibles :**
1. Mode CPU activé malgré ROCm
2. Conflit avec Ollama qui utilise tout le GPU
3. Modèle trop gros
**Solutions :**
```yaml
# Forcer le device GPU
environment:
- WHISPER__DEVICE=cuda # ou auto
# Réduire la charge GPU d'Ollama
# Dans Ollama, utiliser moins de couches GPU
```
---
## Build CTranslate2 ROCm complet
### Procédure détaillée
```bash
# 1. Cloner le repo speaches
cd ~
git clone https://github.com/speaches-ai/speaches.git
cd speaches/src
# 2. Vérifier l'architecture GPU
rocminfo | grep gfx
# 3. Modifier le Dockerfile pour votre architecture
# Remplacer gfx1101 par votre architecture (ex: gfx1100)
sed -i 's/gfx1101/gfx1100/g' Dockerfile.rocm-ct2
# 4. Vérifier que MIOpen est activé
grep -i miopen Dockerfile.rocm-ct2
# Devrait contenir : -DWITH_CUDNN=ON
# 5. Build (prend 30-60 min)
docker build -f Dockerfile.rocm-ct2 -t speaches:rocm-ct2 .
# 6. Tester
docker run --rm --device /dev/kfd --device /dev/dri \
-e HSA_OVERRIDE_GFX_VERSION=11.0.0 \
speaches:rocm-ct2 \
python3 -c "import torch; print(torch.cuda.is_available())"
```
---
## Ressources
- [CTranslate2 ROCm Fork](https://github.com/arlo-phoenix/CTranslate2-rocm)
- [AMD ROCm Documentation](https://docs.amd.com)
- [ROCm GPU Support List](https://rocm.docs.amd.com/en/latest/release/gpu_os_support.html)