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/01-architecture/infrastructure.md
+185
View File
@@ -0,0 +1,185 @@
# 🏗️ Architecture Infrastructure
## Vue d'ensemble
Effi fonctionne sur une architecture **multi-machines** avec une séparation claire entre le serveur principal (services Docker) et la station de travail puissante (calcul GPU).
---
## Machines
### effi-server (192.168.1.27)
**Rôle** : Serveur Docker principal, héberge tous les services de l'interface et de la logique
| Caractéristique | Valeur |
|-----------------|--------|
| **OS** | Ubuntu Server 22.04 LTS |
| **CPU** | Intel J5040 (4 cœurs) |
| **RAM** | ~7.6 GB |
| **Stockage** | SSD |
| **GPU** | Aucun (tout est fait en CPU) |
**Services hébergés :**
- Open WebUI (interface utilisateur)
- Qdrant (base vectorielle)
- CouchDB (synchronisation Obsidian)
- n8n (automatisation)
- mcpo (proxy MCP)
- wol-proxy (Wake-on-LAN)
- pipelines (middleware mémoire)
- Watchtower (mises à jour auto)
- Obsidian Server (interface web)
---
### folzo-Corp (192.168.1.11)
**Rôle** : Station de calcul GPU pour LLM et traitement audio
| Caractéristique | Valeur |
|-----------------|--------|
| **OS** | Bazzite (Fedora-based) |
| **CPU** | AMD Ryzen 5800X3D |
| **RAM** | 32 GB+ |
| **GPU** | AMD RX 7800 XT 16 GB VRAM |
| **ROCm** | Version 6.3.4 |
| **Architecture GPU** | gfx1100 |
**Services hébergés :**
- Ollama (LLM qwen2.5:14b)
- speaches (STT Whisper)
- openedai-speech (TTS Piper/XTTS)
---
## Schéma Réseau
```
Internet
│
▼
┌────────────────────────────────────────────────────────────┐
│ Routeur (Box) │
│ DHCP 192.168.1.0/24 │
└────────────────────────────────────────────────────────────┘
│ │
│ │
▼ ▼
┌──────────────┐ ┌──────────────────┐
│ effi-server │◄────────►│ folzo-Corp │
│ 192.168.1.27 │ LAN │ 192.168.1.11 │
│ │ │ │
│ • Docker │ │ • Ollama │
│ • WebUI │ WoL │ • Whisper │
│ • Qdrant │◄─────────│ • TTS │
│ • n8n │ │ • ROCm/GPU │
└──────────────┘ └──────────────────┘
```
---
## Flux de Données
### Pipeline Conversationnelle
```
┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Micro │────►│ speaches │────►│ Open WebUI │────►│ Ollama │
│ (Client) │ STT │ (folzo-Corp) │ │(effi-server) │ │ (folzo-Corp) │
└──────────────┘ └──────────────┘ └──────┬───────┘ └──────┬───────┘
│ │
│◄───────────────────┘
│ Réponse LLM
│
▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Haut- │◄────│ openedai- │◄────│ Open WebUI │
│ parleurs │ TTS │ speech │ │(traite la │
│ │ │(folzo-Corp) │ │ réponse) │
└──────────────┘ └──────────────┘ └──────────────┘
```
### Wake-on-LAN
Quand OpenWebUI sur effi-server veut appeler Ollama sur folzo-Corp :
1. Requête vers `192.168.1.27:3011` (wol-proxy)
2. wol-proxy vérifie si Ollama répond sur `192.168.1.11:11434`
3. Si non → envoie un Magic Packet WoL à l'adresse MAC configurée
4. Attend que le PC démarre (timeout configurable)
5. Une fois démarré, fait le proxy vers Ollama
---
## Sécurité Réseau
### Ports ouverts sur effi-server
| Port | Service | Exposition |
|------|---------|------------|
| 3000 | Open WebUI | LAN uniquement |
| 5678 | n8n | LAN uniquement |
| 5984 | CouchDB | LAN uniquement |
| 6333 | Qdrant | LAN uniquement |
| 8000 | mcpo | LAN uniquement |
### Ports ouverts sur folzo-Corp
| Port | Service | Exposition |
|------|---------|------------|
| 8100 | openedai-speech | LAN uniquement |
| 8200 | speaches | LAN uniquement |
| 11434 | Ollama | LAN uniquement |
### Recommandations
- Utiliser un VPN (WireGuard, Tailscale) pour l'accès externe
- Jamais exposer les ports directement sur Internet
- Configurer le pare-feu UFW (Ubuntu) ou firewall-cmd (Fedora)
---
## Sauvegardes
### Données critiques à sauvegarder
**Sur effi-server :**
```
~/effi/
├── docker-compose.yml # Configuration
├── .env # Variables (chiffrer)
├── open-webui-data/ # Mémoire, config
├── qdrant-storage/ # Vecteurs RAG
├── couchdb-data/ # Sync Obsidian
└── n8n-data/ # Workflows
```
**Sur folzo-Corp :**
```
~/ollama/ # Modèles téléchargés
~/speaches/models/ # Modèles Whisper
~/openedai-speech/tts-voices/ # Voix TTS
```
### Commande de backup
```bash
# Sur effi-server
tar -czvf effi-backup-$(date +%Y%m%d).tar.gz \
~/effi/docker-compose.yml \
~/effi/.env \
~/effi/open-webui-data/ \
~/effi/qdrant-storage/ \
~/effi/couchdb-data/ \
~/effi/n8n-data/
```
---
## Évolution Future
- **Réservation DHCP** : Fixer les IPs via le routeur
- **DNS local** : Utiliser des noms comme `effi.local` et `folzo-corp.local`
- **Reverse Proxy** : Traefik ou Nginx Proxy Manager pour HTTPS
- **Monitoring** : Prometheus + Grafana pour les métriques
docs/01-architecture/services.md
+230
View File
@@ -0,0 +1,230 @@
# 🐳 Services et Ports
## Tableau récapitulatif
| Service | Hôte | Port | Image | Description |
|---------|------|------|-------|-------------|
| **Open WebUI** | effi-server | 3000 | `ghcr.io/open-webui/open-webui:main` | Interface IA principale |
| **Qdrant** | effi-server | 6333 | `qdrant/qdrant:latest` | Base de données vectorielle |
| **CouchDB** | effi-server | 5984 | `couchdb:3.3` | Backend Obsidian LiveSync |
| **n8n** | effi-server | 5678 | `docker.n8n.io/n8nio/n8n:latest` | Automatisation workflows |
| **mcpo** | effi-server | 8000 | `ghcr.io/open-webui/mcpo:main` | Proxy MCP pour outils |
| **wol-proxy** | effi-server | 3011 | Build local | Wake-on-LAN + Proxy Ollama |
| **pipelines** | effi-server | 9099 | `ghcr.io/open-webui/pipelines:main` | Middleware mémoire mem0 |
| **speaches** | folzo-Corp | 8200 | `speaches:rocm-ct2` (build local) | STT Whisper avec ROCm |
| **openedai-speech** | folzo-Corp | 8100 | `ghcr.io/matatonic/openedai-speech` | TTS Piper/XTTS |
| **Ollama** | folzo-Corp | 11434 | Installation native | LLM (qwen2.5:14b) |
| **Obsidian** | effi-server | 3100 | `lscr.io/linuxserver/obsidian:latest` | Interface Obsidian web |
---
## Description détaillée
### Open WebUI (Port 3000)
**Rôle** : Interface utilisateur principale pour interagir avec l'IA
**Fonctionnalités :**
- Chat textuel avec le LLM
- Support vocal (STT/TTS)
- Gestion des conversations
- Upload de documents (RAG)
- Administration système
**Configuration clé :**
```yaml
environment:
- OLLAMA_BASE_URL=http://host.docker.internal:3011
- VECTOR_DB=qdrant
- QDRANT_URI=http://qdrant:6333
- ENABLE_MEMORIES=true
```
---
### Qdrant (Port 6333)
**Rôle** : Stockage vectoriel pour le RAG (Retrieval Augmented Generation)
**Utilisation :**
- Indexation des documents uploadés
- Recherche sémantique
- Embeddings via `bge-m3:latest`
**Endpoints :**
- API REST : `http://192.168.1.27:6333`
- gRPC : `http://192.168.1.27:6334`
---
### CouchDB (Port 5984)
**Rôle** : Base de données NoSQL pour Obsidian LiveSync
**Fonctionnalités :**
- Synchronisation temps réel des notes Obsidian
- Multi-device (mobile, desktop, web)
- Résolution de conflits intégrée
**Initialisation (premier démarrage) :**
```bash
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/_users
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/_replicator
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/obsidian-livesync
```
---
### n8n (Port 5678)
**Rôle** : Plateforme d'automatisation de workflows
**Cas d'usage :**
- Workflows d'intégration avec Home Assistant
- Automatisations basées sur le calendrier
- Webhooks pour notifications
- Traitement de données
**Authentification :** Basic Auth configurée via variables d'environnement
---
### mcpo (Port 8000)
**Rôle** : Proxy pour le protocole MCP (Model Context Protocol)
**Fonctionnalités :**
- Interface entre OpenWebUI et outils externes
- Exécution de commandes système
- Intégration avec Obsidian MCP
**Configuration :**
Fichier `~/effi/mcpo-config/config.json` :
```json
{
"mcpServers": {}
}
```
---
### wol-proxy (Port 3011)
**Rôle** : Wake-on-LAN + Proxy vers Ollama
**Fonctionnement :**
1. Intercepte les requêtes vers Ollama
2. Envoie un Magic Packet si le PC est éteint
3. Attend le démarrage (timeout: 60s)
4. Proxy la requête vers Ollama
**Variables d'environnement :**
- `TARGET_HOST` : IP du PC Gaming
- `TARGET_MAC` : Adresse MAC pour WoL
- `BROADCAST_IP` : IP de broadcast
---
### pipelines (Port 9099)
**Rôle** : Middleware pour les filtres OpenWebUI
**Utilisation actuelle :**
- Intégration mem0 pour mémoire avancée
- Traitement des messages entrants/sortants
---
### speaches (Port 8200)
**Rôle** : Service STT (Speech-to-Text)
**Caractéristiques :**
- Modèle : `deepdml/faster-whisper-large-v3-turbo-ct2`
- Accélération : ROCm (GPU AMD)
- Langue : Français forcé
- Format : Compatible API OpenAI
**Build personnalisé :**
- Nécessite CTranslate2 compilé pour gfx1100
- Voir guide dépannage ROCm
---
### openedai-speech (Port 8100)
**Rôle** : Service TTS (Text-to-Speech)
**Voix disponibles :**
- `tts-1` : Piper (CPU, rapide) - Voix FR : `fr_FR-upmc-medium`
- `tts-1-hd` : XTTS (GPU, qualité) - Voix clones
**Configuration :**
Fichier `~/openedai-speech/tts-config/config.yaml`
---
### Ollama (Port 11434)
**Rôle** : Serveur LLM
**Modèles installés :**
- `qwen2.5:14b` : LLM principal d'Effi
- `bge-m3:latest` : Modèle d'embeddings pour RAG
- `qwen2.5:3b` : LLM léger pour filtres mémoire
**Commandes utiles :**
```bash
# Lister les modèols
ollama list
# Télécharger un modèle
ollama pull qwen2.5:14b
# Vérifier le statut
curl http://localhost:11434/api/tags
```
---
### Obsidian Server (Port 3100)
**Rôle** : Interface web Obsidian 24/7
**Utilisation :**
- Accès aux notes depuis n'importe où
- Intégration MCP pour modification automatique
- Interface graphique complète
**Note :** Nécessite `shm_size: 1gb` pour la stabilité
---
## Dépendances entre services
```
open-webui
├──► qdrant (pour RAG)
├──► wol-proxy (pour Ollama)
└──► mcpo (pour outils externes)
n8n
└──► Peut appeler tous les services via API
Obsidian (mobile/desktop)
└──► CouchDB (synchronisation)
```
---
## Ressources système
| Service | CPU | RAM | Stockage |
|---------|-----|-----|----------|
| Open WebUI | Faible | ~500 MB | ~1 GB (DB SQLite) |
| Qdrant | Moyen | ~1 GB | Variable (vecteurs) |
| CouchDB | Faible | ~200 MB | Taille des notes |
| n8n | Variable | ~500 MB | Workflows |
| speaches | Élevé (GPU) | ~4 GB VRAM | ~3 GB (modèles) |
| openedai-speech | Moyen | ~2 GB VRAM | ~2 GB (voix) |
| Ollama | Élevé (GPU) | ~10 GB VRAM | ~9 GB (qwen2.5:14b) |
docs/02-configuration/audio-stt-tts.md
+230
View File
@@ -0,0 +1,230 @@
# 🎤 Configuration Audio (STT + TTS)
## Vue d'ensemble
Effi dispose d'un pipeline vocal complet fonctionnant sur **folzo-Corp** (PC Gaming avec RX 7800 XT) :
- **STT** (Speech-to-Text) : Whisper via speaches avec ROCm
- **TTS** (Text-to-Speech) : Piper/XTTS via openedai-speech
---
## STT - Speaches (Whisper)
### Configuration Docker Compose
Fichier : `~/speaches/docker-compose.yml` (sur folzo-Corp)
```yaml
services:
speaches:
image: speaches:rocm-ct2
container_name: speaches-stt
restart: unless-stopped
ports:
- "8200:8000"
devices:
- /dev/kfd
- /dev/dri
group_add:
- "44"
- "991"
security_opt:
- seccomp=unconfined
environment:
- HSA_OVERRIDE_GFX_VERSION=11.0.0
- WHISPER__MODEL=deepdml/faster-whisper-large-v3-turbo-ct2
- WHISPER__LANGUAGE=fr
- WHISPER__COMPUTE_TYPE=float32
- WHISPER__DEVICE=auto
volumes:
- speaches-models:/root/.cache/huggingface
speaches-init:
image: curlimages/curl:latest
container_name: speaches-init
restart: "no"
depends_on:
- speaches
entrypoint: >
sh -c "sleep 5 &&
curl -sf -X POST http://speaches:8000/v1/models/deepdml%2Ffaster-whisper-large-v3-turbo-ct2 &&
echo 'Modèle enregistré'"
volumes:
speaches-models:
```
### Modèle utilisé
**`deepdml/faster-whisper-large-v3-turbo-ct2`**
- Version optimisée CTranslate2
- Support ROCm (GPU AMD)
- Turbo = version rapide du large-v3
- Langue : Français forcé (`fr`)
### Points importants
1. **Build personnalisé** : L'image `speaches:rocm-ct2` doit être construite localement
2. **Architecture GPU** : gfx1100 (RX 7800 XT)
3. **Compute type** : `float32` en CPU, `float16` en GPU
4. **Initialisation** : Le service `speaches-init` enregistre le modèle au démarrage
---
## TTS - OpenedAI-Speech (Piper)
### Configuration Docker Compose
Fichier : `~/openedai-speech/docker-compose.yml` (sur folzo-Corp)
```yaml
services:
openedai-speech:
image: ghcr.io/matatonic/openedai-speech
container_name: openedai-speech
restart: unless-stopped
ports:
- "8100:8000"
volumes:
- ./tts-voices:/app/voices
- ./tts-config:/app/config
devices:
- /dev/kfd
- /dev/dri
group_add:
- "44"
- "991"
environment:
- HSA_OVERRIDE_GFX_VERSION=11.0.0
- HIP_VISIBLE_DEVICES=0
```
### Voix disponibles
#### Piper (CPU - Recommandé pour usage standard)
**Voix française** : `fr_FR-upmc-medium`
```bash
# Téléchargement
cd ~/openedai-speech/tts-voices
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/fr/fr_FR/upmc/medium/fr_FR-upmc-medium.onnx
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/fr/fr_FR/upmc/medium/fr_FR-upmc-medium.onnx.json
```
Configuration (`tts-config/config.yaml`) :
```yaml
tts-1:
alloy:
model: voices/fr_FR-upmc-medium.onnx
speaker: 0 # 0 = voix féminine
```
### Points importants
1. **group_add numériques** : Utiliser `"44"` et `"991"` (pas les noms)
2. **ROCm activé** : `HSA_OVERRIDE_GFX_VERSION=11.0.0`
3. **Fallback CPU** : Piper fonctionne aussi en CPU si GPU indisponible
---
## Configuration Open WebUI
**Admin Panel → Settings → Audio**
### Paramètres STT
| Paramètre | Valeur |
|-----------|--------|
| Engine | `OpenAI` |
| URL | `http://192.168.1.11:8200/v1` |
| Model | `deepdml/faster-whisper-large-v3-turbo-ct2` |
| API Key | `anything` (valeur quelconque) |
### Paramètres TTS
| Paramètre | Valeur |
|-----------|--------|
| Engine | `OpenAI` |
| URL | `http://192.168.1.11:8100/v1` |
| Model | `tts-1` (Piper) ou `tts-1-hd` (XTTS) |
| Voice | `alloy` |
---
## Build CTranslate2 ROCm (speaches)
### Pourquoi un build personnalisé ?
L'image officielle speaches ne publie pas d'image ROCm. Il faut builder CTranslate2 depuis les sources avec :
- Support MIOpen (équivalent ROCm de cuDNN)
- Architecture gfx1100 (RX 7800 XT)
### Procédure de build
```bash
# 1. Cloner le repo
cd ~
git clone https://github.com/speaches-ai/speaches.git
cd speaches
# 2. Modifier le Dockerfile pour gfx1100
cd src
sed -i 's/gfx1101/gfx1100/g' Dockerfile.rocm-ct2
# 3. Build (~50 min la première fois)
docker build -f Dockerfile.rocm-ct2 -t speaches:rocm-ct2 .
```
### Architecture GPU
Vérifier votre architecture :
```bash
docker run --device /dev/kfd --device /dev/dri \
-e HSA_OVERRIDE_GFX_VERSION=11.0.0 speaches:rocm-ct2 \
/opt/rocm-6.3.4/bin/rocminfo | grep -E "gfx|Name"
```
Cartes courantes :
- RX 7800 XT : `gfx1100`
- RX 7900 XTX : `gfx1100`
- RX 7700 XT : `gfx1101`
---
## Dépannage audio
### Erreur : "float16 not supported on CPU backend"
**Solution** : Changer `WHISPER__COMPUTE_TYPE` :
```yaml
environment:
- WHISPER__COMPUTE_TYPE=int8 # ou float32
```
### Erreur : "Unable to find group render"
**Solution** : Utiliser les GID numériques :
```yaml
group_add:
- "44" # video
- "991" # render
```
### Erreur : "hipErrorInvalidDeviceFunction"
**Cause** : Mauvaise architecture GPU dans le build
**Solution** : Rebuilder avec la bonne valeur gfx (voir section Build)
---
## Performance attendue
| Composant | Mode | Latence | Notes |
|-----------|------|---------|-------|
| STT | CPU (int8) | ~10s pour 5s audio | Utilisation 100% CPU |
| STT | GPU (ROCm) | ~1s pour 5s audio | Objectif après rebuild |
| TTS Piper | CPU | ~300ms | Léger, utilisable |
| TTS XTTS | GPU | ~500ms-2s | Qualité supérieure |
docs/02-configuration/environnement.md
+192
View File
@@ -0,0 +1,192 @@
# ⚙️ Variables d'Environnement
## Fichier `.env`
Ce fichier contient toutes les variables sensibles et de configuration. **Ne jamais le commiter !**
### Template
```bash
# ═══════════════════════════════════════════════════════════
# EFFI SERVER - Variables d'environnement
# ═══════════════════════════════════════════════════════════
# ═══════════════════════════════════════════════════════════
# 1. OPEN WEBUI
# ═══════════════════════════════════════════════════════════
WEBUI_SECRET_KEY=votre_cle_secrete_longue_et_aleatoire
# ═══════════════════════════════════════════════════════════
# 2. OLLAMA / PC GAMING
# ═══════════════════════════════════════════════════════════
OLLAMA_HOST=192.168.1.11
PC_GAMING_MAC=XX:XX:XX:XX:XX:XX
BROADCAST_IP=192.168.1.255
# ═══════════════════════════════════════════════════════════
# 3. COUCHDB (Obsidian LiveSync)
# ═══════════════════════════════════════════════════════════
COUCHDB_USER=master
COUCHDB_PASSWORD=votre_mot_de_passe_securise
# ═══════════════════════════════════════════════════════════
# 4. N8N (Automatisation)
# ═══════════════════════════════════════════════════════════
N8N_USER=master
N8N_PASSWORD=votre_mot_de_passe_securise
```
---
## Description des variables
### WEBUI_SECRET_KEY
**Utilisé par** : Open WebUI
**Description** : Clé secrète pour la gestion des sessions et le chiffrement.
**Génération** :
```bash
# Linux
openssl rand -hex 32
# ou
python3 -c "import secrets; print(secrets.token_hex(32))"
```
### OLLAMA_HOST
**Utilisé par** : wol-proxy
**Description** : IP du PC Gaming où tourne Ollama.
**Exemple** : `192.168.1.11`
### PC_GAMING_MAC
**Utilisé par** : wol-proxy
**Description** : Adresse MAC du PC Gaming pour le Wake-on-LAN.
**Format** : `XX:XX:XX:XX:XX:XX`
**Trouver l'adresse MAC** :
```bash
# Sur le PC Gaming
ip link show
# ou
ifconfig | grep ether
```
### BROADCAST_IP
**Utilisé par** : wol-proxy
**Description** : Adresse de broadcast du réseau local.
**Standard** : `192.168.1.255` (pour un réseau 192.168.1.0/24)
### COUCHDB_USER / COUCHDB_PASSWORD
**Utilisés par** : CouchDB
**Description** : Identifiants administrateur pour CouchDB.
**Note** : L'utilisateur par défaut dans les exemples est `master`.
### N8N_USER / N8N_PASSWORD
**Utilisés par** : n8n
**Description** : Identifiants pour l'accès à l'interface n8n (Basic Auth).
---
## Variables système
### TZ (TimeZone)
**Valeur par défaut** : `Europe/Paris`
**Utilisée par** : Tous les services
### HSA_OVERRIDE_GFX_VERSION
**Valeur** : `11.0.0`
**Utilisée par** : Services ROCm (speaches, openedai-speech)
**Description** : Force la version GFX pour la compatibilité ROCm.
---
## Configuration réseau
### Ports utilisés
| Service | Port | Protocole | Description |
|---------|------|-----------|-------------|
| Open WebUI | 3000 | TCP | Interface web |
| wol-proxy | 3011 | TCP | Proxy Ollama |
| Obsidian | 3100 | TCP | Interface Obsidian web |
| Qdrant HTTP | 6333 | TCP | API REST |
| Qdrant gRPC | 6334 | TCP | API gRPC |
| n8n | 5678 | TCP | Interface workflow |
| CouchDB | 5984 | TCP | Base de données |
| mcpo | 8000 | TCP | Proxy MCP |
| speaches | 8200 | TCP | STT API |
| openedai-speech | 8100 | TCP | TTS API |
| pipelines | 9099 | TCP | Middleware |
---
## Sécurité
### Bonnes pratiques
1. **Mots de passe** : Utiliser des mots de passe forts (>16 caractères, variété)
2. **Réseau** : Ne jamais exposer les ports directement sur Internet
3. **VPN** : Utiliser WireGuard ou Tailscale pour l'accès externe
4. **Backup** : Sauvegarder régulièrement le fichier `.env`
5. **Permissions** : Limiter l'accès au fichier `.env` (chmod 600)
### Commandes de sécurité
```bash
# Permissions restrictives
chmod 600 ~/effi/.env
# Vérifier les permissions
ls -la ~/effi/.env
# Backup chiffré
gpg -c ~/effi/.env
cp ~/effi/.env.gpg ~/backups/
```
---
## Dépannage environnement
### Variable non prise en compte
**Cause** : Le conteneur doit être recréé (pas juste redémarré)
**Solution** :
```bash
docker compose down
docker compose up -d
```
### Erreur "variable is not set"
**Cause** : Variable manquante dans le `.env`
**Solution** : Vérifier que toutes les variables requises sont définies
### Caractères spéciaux dans les mots de passe
**Attention** : Certains caractères peuvent poser problème dans les URLs (%, @, #, etc.)
**Solution** : Utiliser des mots de passe avec caractères alphanumériques uniquement, ou encoder les caractères spéciaux.
docs/02-configuration/mcp-et-n8n.md
+169
View File
@@ -0,0 +1,169 @@
# 🔗 Intégration MCP et n8n
## Vue d'ensemble
Effi s'intègre avec plusieurs outils externes via :
- **MCP** (Model Context Protocol) : Protocole d'outils pour l'IA
- **n8n** : Plateforme d'automatisation de workflows
- **CouchDB** : Synchronisation Obsidian LiveSync
---
## MCPO - Proxy MCP
### Rôle
MCPO fait le pont entre OpenWebUI et les outils MCP (Obsidian, système de fichiers, etc.).
### Configuration
**Fichier : `~/effi/mcpo-config/config.json`**
```json
{
"mcpServers": {}
}
```
Au démarrage, créer ce fichier s'il n'existe pas :
```bash
cat > ~/effi/mcpo-config/config.json << 'EOF'
{"mcpServers": {}}
EOF
```
### Accès
- URL : `http://192.168.1.27:8000`
- Port : 8000
### Dépannage
**Problème : mcpo redémarre en boucle**
**Cause** : Config `mcpo-config/config.json` vide ou inexistant
**Solution** :
```bash
cat > ~/effi/mcpo-config/config.json << 'EOF'
{"mcpServers": {}}
EOF
docker compose restart mcpo
```
**Problème : Processus zombies**
**Symptômes** : `[mcpo] <defunct>` dans `ps aux`
**Solution** :
```bash
docker restart mcpo
```
---
## n8n - Automatisation
### Rôle
n8n permet de créer des workflows d'automatisation déclenchés par Effi ou des événements externes.
### Configuration
**Variables d'environnement (dans `.env`) :**
```bash
N8N_USER=master
N8N_PASSWORD=mot_de_passe_securise
```
### Accès
- URL : `http://192.168.1.27:5678`
- Authentification : Basic Auth
### Cas d'usage
#### Exemple 1 : Webhook depuis Effi
1. Créer un workflow dans n8n avec un nœud **Webhook**
2. Configurer l'URL du webhook dans OpenWebUI
3. Effi peut déclencher des actions via ce webhook
#### Exemple 2 : Intégration Home Assistant (futur)
```
[Commande vocale Effi]
→ OpenWebUI
→ n8n (webhook)
→ API Home Assistant
→ Action domotique
```
### Sauvegarde des workflows
Les workflows sont stockés dans `~/effi/n8n-data/`
---
## CouchDB - Obsidian LiveSync
### Rôle
CouchDB sert de backend de synchronisation pour Obsidian LiveSync, permettant d'accéder aux notes depuis plusieurs appareils.
### Initialisation (premier démarrage)
```bash
# Créer les bases système
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/_users
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/_replicator
# Créer la base pour Obsidian
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/obsidian-livesync
```
### Configuration Obsidian
Dans Obsidian (desktop ou mobile) :
1. Installer le plugin **Self-hosted LiveSync**
2. Configuration :
- **URL** : `http://192.168.1.27:5984`
- **Database** : `obsidian-livesync`
- **Username** : `master`
- **Password** : [mot de passe CouchDB]
3. Activer la synchronisation
### Accès
- URL : `http://192.168.1.27:5984`
- Interface Fauxton : `http://192.168.1.27:5984/_utils`
---
## Pipelines - Middleware mem0
### Rôle
Le service pipelines est un middleware pour OpenWebUI permettant d'utiliser des pipelines personnalisés, notamment mem0 pour la mémoire avancée.
### Accès
- URL : `http://192.168.1.27:9099`
---
## Intégrations futures
### Home Assistant
Voir le document dans les notes d'archive pour les idées d'intégration complète avec Home Assistant.
### Nextcloud
Intégration possible pour :
- Sauvegarde automatique des conversations
- Accès aux fichiers pour le RAG
- Synchronisation des tâches
docs/02-configuration/memoire.md
+262
View File
@@ -0,0 +1,262 @@
# 🧠 Configuration Mémoire Persistante
## Vue d'ensemble
Effi utilise deux mécanismes de mémoire complémentaires :
1. **Auto Memory** : Extraction automatique des faits importants des conversations
2. **Memory Injection Filter** : Injection des souvenirs dans le contexte des conversations
---
## Architecture de la mémoire
```
Conversation utilisateur
↓
[Auto Memory] → Analyse avec qwen2.5:3b → Extraction de faits
↓
Stockage SQLite (webui.db)
↓
[Memory Injection] ← Récupération des souvenirs pertinents
↓
Injection dans le contexte LLM
```
---
## 1. Auto Memory (Extraction)
### Installation
1. **Admin Panel → Functions → Discover**
2. Rechercher **"Auto Memory"** par **nokodo**
3. Cliquer sur **Install**
### Configuration des Valves
**Admin Panel → Functions → Auto Memory → ⚙️ (Settings)**
| Paramètre | Valeur | Description |
|-----------|--------|-------------|
| OpenAI API URL | `http://192.168.1.11:3011/v1` | URL Ollama via wol-proxy |
| Model | `qwen2.5:3b` | LLM léger pour analyse |
| API Key | `toto` | Valeur quelconque |
| Messages To Consider | `10` | Nombre de messages analysés |
| Related Memories N | `5` | Souvenirs liés à considérer |
| Minimum Memory Similarity | `0.7` | Seuil de similarité |
| Override Memory Context | `OFF` | Ne pas écraser le contexte |
| Debug Mode | `OFF` | Mettre ON pour diagnostic |
### Activation globale
**Admin Panel → Functions → Auto Memory → ⋯ → Toggle Global** → **ON**
### Patch du code (JSON markdown)
Le filtre original a un problème avec les réponses JSON formatées en markdown. Appliquer ce patch :
**Admin Panel → Functions → Auto Memory → ⋯ → Edit**
Chercher : `text_response = response.choices[0].message.content`
Remplacer le bloc `if response_model:` par :
```python
if response_model:
try:
cleaned = re.sub(r'```(?:json)?\s*', '', text_response)
cleaned = re.sub(r'```\s*', '', cleaned).strip()
match = re.search(r'\{.*\}', cleaned, re.DOTALL)
if match:
cleaned = match.group(0)
return response_model.model_validate_json(cleaned)
except ValidationError as e:
self.log(f"response model validation error: {e}", level="warning")
raise
return text_response
```
Chercher aussi `UNIFIED_SYSTEM_PROMPT` et ajouter au début :
```python
UNIFIED_SYSTEM_PROMPT = """IMPORTANT: Respond with ONLY valid JSON. No markdown formatting, no code blocks, no explanation text. Start your response directly with { and end with }. """ + UNIFIED_SYSTEM_PROMPT
```
---
## 2. Memory Injection Filter (Restitution)
### Installation
1. **Admin Panel → Functions → Discover**
2. Rechercher **"Memory Injection Filter"** par **Raphael**
3. Cliquer sur **Install**
### Configuration
**Admin Panel → Functions → Memory Injection Filter → ⚙️**
| Paramètre | Valeur |
|-----------|--------|
| PREPENDING_TEXT | `Voici les souvenirs à long terme de l'utilisateur :` |
| SHOW_MEMORY_COUNT_EMITTER | `ON` |
### Activation globale
**Admin Panel → Functions → Memory Injection Filter → ⋯ → Toggle Global** → **ON**
---
## 3. Vérification du fonctionnement
### Test d'enregistrement
Dans un chat avec Effi :
```
Je collectionne les vinyles des années 80
```
Dans le terminal (vérification SQLite) :
```bash
sudo docker cp open-webui:/app/backend/data/webui.db /tmp/webui.db
sqlite3 /tmp/webui.db "SELECT content, datetime(created_at, 'unixepoch') FROM memory ORDER BY created_at DESC LIMIT 5;"
```
→ Le souvenir doit apparaître dans la base.
### Test de restitution entre sessions
Ouvrir un **nouveau chat** :
```
Qu'est-ce que tu sais sur mes hobbies ?
```
→ Effi doit mentionner les vinyles sans que tu l'aies redit.
### Vérification des logs
```bash
docker logs open-webui --tail 50 | grep -iE "memory|saved|added"
```
---
## 4. Gestion des souvenirs
### Via l'interface
**Profil → Settings → Personalization → Memory**
- Voir tous les souvenirs
- Supprimer individuellement (icône 🗑️)
- Rechercher dans les souvenirs
### Via SQLite (avancé)
**Lister les souvenirs :**
```bash
sudo docker cp open-webui:/app/backend/data/webui.db /tmp/webui.db
sqlite3 /tmp/webui.db "SELECT id, content, datetime(created_at, 'unixepoch') as date FROM memory ORDER BY created_at DESC;"
```
**Supprimer un souvenir :**
```bash
sqlite3 /tmp/webui.db "DELETE FROM memory WHERE id = 123;"
sudo docker cp /tmp/webui.db open-webui:/app/backend/data/webui.db
```
**Rechercher par mot-clé :**
```bash
sqlite3 /tmp/webui.db "SELECT * FROM memory WHERE content LIKE '%vinyle%';"
```
---
## 5. Bonnes pratiques
### Qualité des souvenirs
- **Courts et factuels** : Moins de 15 mots par souvenir
- **Spécifiques** : "Aime le rock" ❌ → "Collectionne vinyles années 80" ✅
- **Quantité** : Viser 30-50 souvenirs max pour ne pas surcharger le contexte
### Maintenance
- **Nettoyage trimestriel** : Supprimer les souvenirs obsolètes
- **Vérification** : Tester la restitution régulièrement
- **Backup** : Sauvegarder `webui.db` avant toute modification manuelle
---
## 6. Dépannage
### Les souvenirs ne s'enregistrent pas
**Vérifications :**
1. Auto Memory est-il activé globalement ?
2. La valve Debug Mode est-elle ON ? (voir les logs)
3. Le modèle qwen2.5:3b est-il bien téléchargé sur Ollama ?
4. L'URL Ollama dans les valves est-elle correcte ?
**Commandes diagnostic :**
```bash
# Vérifier qu'Ollama répond
curl http://192.168.1.11:3011/v1/models
# Voir les logs détaillés
docker logs open-webui --tail 100 | grep -i auto.memory
```
### Les souvenirs ne sont pas injectés
**Vérifications :**
1. Memory Injection Filter est-il activé globalement ?
2. La variable PREPENDING_TEXT est-elle configurée ?
3. Y a-t-il des souvenirs dans la base ? (vérifier avec SQLite)
### Doublons de souvenirs
**Cause** : L'extraction n'est pas dédupliquée automatiquement.
**Solution** : Nettoyage manuel périodique via l'interface.
### Performance lente
**Cause** : Trop de souvenirs (>100) ralentissent la recherche.
**Solution** :
- Augmenter `Minimum Memory Similarity` (ex: 0.8)
- Réduire `Related Memories N` (ex: 3)
- Nettoyer les souvenirs anciens
---
## 7. Stockage technique
### Emplacement
```
Conteneur : open-webui
Chemin : /app/backend/data/webui.db
Host : volume Docker open-webui-data
```
### Structure de la table `memory`
| Colonne | Type | Description |
|---------|------|-------------|
| id | INTEGER | ID auto-incrémenté |
| content | TEXT | Texte du souvenir |
| created_at | INTEGER | Timestamp Unix |
| updated_at | INTEGER | Timestamp Unix |
| user_id | TEXT | ID utilisateur |
### Backup de la mémoire
```bash
# Sauvegarde
docker cp open-webui:/app/backend/data/webui.db ~/backups/webui-$(date +%Y%m%d).db
# Restauration
docker cp ~/backups/webui-20260101.db open-webui:/app/backend/data/webui.db
docker restart open-webui
```
docs/03-guides/installation.md
+335
View File
@@ -0,0 +1,335 @@
# 📦 Guide d'Installation
## Vue d'ensemble
Ce guide décrit l'installation complète de l'infrastructure Effi, du serveur Ubuntu au premier démarrage des services.
**Temps estimé** : 2-3 heures
**Difficulté** : Intermédiaire
---
## Prérequis
### Matériel
**effi-server (serveur principal)** :
- CPU : Intel J5040 ou équivalent (4 cœurs)
- RAM : 8 GB minimum
- Stockage : 50 GB SSD minimum
- OS : Ubuntu Server 22.04 LTS
**folzo-Corp (PC Gaming)** :
- CPU : AMD Ryzen 5 ou supérieur
- RAM : 32 GB recommandé
- GPU : AMD RX 7800 XT (16 GB VRAM)
- OS : Bazzite (Fedora) ou Ubuntu 22.04
### Logiciels requis
**Sur effi-server** :
- Docker Engine 24.x+
- Docker Compose v2+
- curl, git
**Sur folzo-Corp** :
- Ollama
- ROCm 6.3.4 (pour AMD GPU)
- Docker Engine
---
## Étape 1 : Préparation du serveur (effi-server)
### 1.1 Installation de Docker
```bash
# Mettre à jour le système
sudo apt update && sudo apt upgrade -y
# Installer les dépendances
sudo apt install -y ca-certificates curl gnupg lsb-release
# Ajouter la clé GPG officielle de Docker
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
# Ajouter le repository Docker
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
# Installer Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
# Vérifier l'installation
sudo docker --version
sudo docker compose version
# Ajouter l'utilisateur au groupe docker (déconnexion/reconnexion nécessaire)
sudo usermod -aG docker $USER
```
### 1.2 Création de la structure de dossiers
```bash
# Créer le dossier principal
mkdir -p ~/effi
cd ~/effi
# Créer les sous-dossiers
mkdir -p mcpo-config
mkdir -p qdrant-storage
mkdir -p couchdb-data
mkdir -p n8n-data
mkdir -p wol-proxy
mkdir -p tts-voices
mkdir -p tts-config
mkdir -p obsidian-vault
```
---
## Étape 2 : Configuration du PC Gaming (folzo-Corp)
### 2.1 Installation d'Ollama
```bash
# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh
# Vérifier l'installation
ollama --version
# Télécharger les modèles nécessaires
ollama pull qwen2.5:14b
ollama pull qwen2.5:3b
ollama pull bge-m3
# Vérifier les modèles installés
ollama list
```
### 2.2 Configuration de Ollama pour le réseau
```bash
# Créer le fichier de service systemd
sudo systemctl edit ollama.service
```
Ajouter :
```ini
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
```
```bash
# Redémarrer Ollama
sudo systemctl daemon-reload
sudo systemctl restart ollama
# Vérifier que Ollama écoute sur toutes les interfaces
sudo ss -tlnp | grep 11434
```
### 2.3 Installation de ROCm (pour AMD GPU)
```bash
# Sur Bazzite/Fedora
sudo dnf install -y rocm-dev rocm-smi
# Vérifier l'installation
rocm-smi --showproductname
rocminfo | grep gfx
```
### 2.4 Configuration des services Docker sur folzo-Corp
Créer les dossiers :
```bash
mkdir -p ~/speaches
mkdir -p ~/openedai-speech/tts-voices
mkdir -p ~/openedai-speech/tts-config
```
---
## Étape 3 : Configuration de la mémoire persistante
Voir le guide détaillé dans [Configuration Mémoire](./memoire.md).
---
## Étape 4 : Premier démarrage
### 4.1 Configuration du fichier .env
```bash
cd ~/effi
cp .env.example .env
nano .env
```
Remplir toutes les variables :
- `WEBUI_SECRET_KEY` : Générer une clé aléatoire
- `OLLAMA_HOST` : IP de folzo-Corp
- `PC_GAMING_MAC` : Adresse MAC de folzo-Corp
- `COUCHDB_USER/PASSWORD` : Identifiants CouchDB
- `N8N_USER/PASSWORD` : Identifiants n8n
### 4.2 Initialisation de CouchDB
```bash
# Démarrer uniquement CouchDB
docker compose up -d couchdb
# Attendre 10 secondes
sleep 10
# Créer les bases nécessaires
curl -X PUT http://master:VOTRE_MOT_DE_PASSE@192.168.1.27:5984/_users
curl -X PUT http://master:VOTRE_MOT_DE_PASSE@192.168.1.27:5984/_replicator
curl -X PUT http://master:VOTRE_MOT_DE_PASSE@192.168.1.27:5984/obsidian-livesync
```
### 4.3 Démarrage complet
```bash
# Démarrer tous les services
docker compose up -d
# Vérifier l'état
docker compose ps
# Voir les logs
docker compose logs -f
```
---
## Étape 5 : Configuration STT/TTS sur folzo-Corp
### 5.1 Build de speaches (ROCm)
```bash
cd ~
git clone https://github.com/speaches-ai/speaches.git
cd speaches/src
# Modifier pour gfx1100
sed -i 's/gfx1101/gfx1100/g' Dockerfile.rocm-ct2
# Build (prend ~50 min)
docker build -f Dockerfile.rocm-ct2 -t speaches:rocm-ct2 .
```
### 5.2 Téléchargement des voix TTS
```bash
cd ~/openedai-speech/tts-voices
# Voix française Piper
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/fr/fr_FR/upmc/medium/fr_FR-upmc-medium.onnx
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/fr/fr_FR/upmc/medium/fr_FR-upmc-medium.onnx.json
# Configuration
mkdir -p ../tts-config
cat > ../tts-config/config.yaml << 'EOF'
tts-1:
alloy:
model: voices/fr_FR-upmc-medium.onnx
speaker: 0
EOF
```
### 5.3 Démarrage des services audio
```bash
cd ~/speaches
docker compose up -d
cd ~/openedai-speech
docker compose up -d
```
---
## Étape 6 : Vérification finale
### 6.1 Test des services
```bash
# Test OpenWebUI
curl http://192.168.1.27:3000
# Test Ollama
curl http://192.168.1.11:11434/api/tags
# Test STT
curl http://192.168.1.11:8200/v1/models
# Test TTS
curl http://192.168.1.11:8100/v1/models
# Test CouchDB
curl http://192.168.1.27:5984
# Test n8n
curl http://192.168.1.27:5678
```
### 6.2 Accès aux interfaces
| Service | URL |
|---------|-----|
| Open WebUI | http://192.168.1.27:3000 |
| n8n | http://192.168.1.27:5678 |
| CouchDB | http://192.168.1.27:5984/_utils |
| Qdrant | http://192.168.1.27:6333 |
---
## Prochaines étapes
Après l'installation, suivre le guide de [Première Configuration](./premiere-config.md) pour :
- Créer le compte admin
- Configurer les connexions
- Installer les filtres de mémoire
- Tester le pipeline vocal
---
## Dépannage initial
### Les conteneurs ne démarrent pas
```bash
# Voir les logs d'erreur
docker compose logs [nom-du-service]
# Vérifier les ports utilisés
sudo ss -tlnp
# Vérifier les variables d'environnement
docker compose config
```
### Erreur de permissions
```bash
# Fixer les permissions des volumes
sudo chown -R $USER:$USER ~/effi/*-data
sudo chown -R $USER:$USER ~/effi/*-storage
```
### Wake-on-LAN ne fonctionne pas
```bash
# Vérifier que wol-proxy est configuré
docker logs wol-proxy
# Tester le WoL manuellement
sudo apt install wakeonlan
wakeonlan XX:XX:XX:XX:XX:XX # MAC de folzo-Corp
```
docs/03-guides/premiere-config.md
+323
View File
@@ -0,0 +1,323 @@
# ⚙️ Guide de Première Configuration
## Vue d'ensemble
Ce guide couvre la configuration initiale d'OpenWebUI après l'installation, de la création du compte à la mise en place de la mémoire persistante.
---
## Étape 1 : Premier accès à OpenWebUI
### 1.1 Créer le compte administrateur
1. Ouvrir `http://192.168.1.27:3000` dans un navigateur
2. Cliquer sur "Sign up"
3. Créer un compte avec :
- **Nom** : Folzo (ou votre nom)
- **Email** : votre email
- **Mot de passe** : mot de passe fort
**Note** : Le premier compte créé devient automatiquement administrateur.
---
## Étape 2 : Configuration des connexions
### 2.1 Connexion Ollama
**Admin Panel → Settings → Connections**
| Paramètre | Valeur |
|-----------|--------|
| Ollama API URL | `http://192.168.1.27:3011` |
| Verify Ollama API | ✅ Cocher |
Cliquer sur **Save** puis **Verify**.
### 2.2 Configuration Audio
**Admin Panel → Settings → Audio**
#### Paramètres STT (Speech-to-Text)
| Paramètre | Valeur |
|-----------|--------|
| STT Engine | `OpenAI` |
| STT OpenAI API URL | `http://192.168.1.11:8200/v1` |
| STT Model | `deepdml/faster-whisper-large-v3-turbo-ct2` |
| STT API Key | `anything` |
#### Paramètres TTS (Text-to-Speech)
| Paramètre | Valeur |
|-----------|--------|
| TTS Engine | `OpenAI` |
| TTS OpenAI API URL | `http://192.168.1.11:8100/v1` |
| TTS Model | `tts-1` (Piper) ou `tts-1-hd` (XTTS) |
| TTS Voice | `alloy` |
Cliquer sur **Save**.
### 2.3 Configuration RAG (Documents)
**Admin Panel → Settings → Documents**
| Paramètre | Valeur |
|-----------|--------|
| Embedding Model Engine | `Ollama` |
| Ollama Base URL | `http://192.168.1.27:3011` |
| Embedding Model | `bge-m3:latest` |
| Vector Database | `qdrant` |
| Qdrant URL | `http://qdrant:6333` |
Cliquer sur **Save**.
---
## Étape 3 : Création du modèle Effi
### 3.1 Créer le modèle personnalisé
**Admin Panel → Models → + New Model**
| Paramètre | Valeur |
|-----------|--------|
| Model Name | `Effi` |
| Base Model | `qwen2.5:14b` |
Dans le champ **System Prompt**, coller :
```
Tu es Effi, l'assistante IA locale de Folzo (Open WebUI + Ollama).
## Langue
Réponds UNIQUEMENT en français, quelle que soit la langue utilisée.
## Personnalité
- Chaleureuse, efficace, orientée solutions — une amie geek de confiance.
- Humour fin : 0 à 1 vanne max par réponse, jamais forcée.
- Ton conversationnel IRL, phrases courtes, pas de pavés.
## Priorités
1. Répondre à la demande directement et clairement.
2. Ajouter un conseil ou alternative si pertinent.
3. Si ambigu → 1 à 3 questions courtes avant de proposer une solution.
## Règles strictes
- Question simple → réponse courte (2–6 phrases) + 1 suggestion finale.
- Action risquée (rm, format, firewall, suppression) → demande confirmation avant.
- Ne sur-parle pas, pas de répétitions inutiles.
## Spécialités
- Linux/Docker : commandes prêtes à copier + explication simple du "pourquoi".
- Débogage : étape par étape, checks rapides d'abord.
- Écriture : corrige en gardant le style de Folzo.
## Prise de notes
Folzo utilise Obsidian. Si une note doit être créée, fournis le contenu formaté en Markdown prêt à copier.
## Mémoire
N'invente pas de souvenirs. Les infos sur Folzo sont injectées automatiquement ci-dessous.
<memory_user_context></memory_user_context>
```
Cliquer sur **Save**.
---
## Étape 4 : Installation des filtres de mémoire
### 4.1 Installation d'Auto Memory
**Admin Panel → Functions → Discover**
1. Rechercher **"Auto Memory"** par **nokodo**
2. Cliquer sur **Install**
### 4.2 Configuration d'Auto Memory
**Admin Panel → Functions → Auto Memory → ⚙️ (Settings)**
| Paramètre | Valeur |
|-----------|--------|
| OpenAI API URL | `http://192.168.1.27:3011/v1` |
| Model | `qwen2.5:3b` |
| API Key | `toto` |
| Messages To Consider | `10` |
| Related Memories N | `5` |
| Minimum Memory Similarity | `0.7` |
| Override Memory Context | `OFF` |
| Debug Mode | `OFF` |
**Activation** : Admin Panel → Functions → Auto Memory → ⋯ → Toggle Global → **ON**
### 4.3 Patch du code Auto Memory
Le filtre a besoin d'un patch pour gérer correctement les réponses JSON.
**Admin Panel → Functions → Auto Memory → ⋯ → Edit**
1. Chercher : `text_response = response.choices[0].message.content`
2. Remplacer le bloc `if response_model:` par :
```python
if response_model:
try:
cleaned = re.sub(r'```(?:json)?\s*', '', text_response)
cleaned = re.sub(r'```\s*', '', cleaned).strip()
match = re.search(r'\{.*\}', cleaned, re.DOTALL)
if match:
cleaned = match.group(0)
return response_model.model_validate_json(cleaned)
except ValidationError as e:
self.log(f"response model validation error: {e}", level="warning")
raise
return text_response
```
3. Chercher `UNIFIED_SYSTEM_PROMPT` et ajouter au début :
```python
UNIFIED_SYSTEM_PROMPT = """IMPORTANT: Respond with ONLY valid JSON. No markdown formatting, no code blocks, no explanation text. Start your response directly with { and end with }. """ + UNIFIED_SYSTEM_PROMPT
```
4. Cliquer sur **Save**
### 4.4 Installation de Memory Injection Filter
**Admin Panel → Functions → Discover**
1. Rechercher **"Memory Injection Filter"** par **Raphael**
2. Cliquer sur **Install**
### 4.5 Configuration de Memory Injection
**Admin Panel → Functions → Memory Injection Filter → ⚙️**
| Paramètre | Valeur |
|-----------|--------|
| PREPENDING_TEXT | `Voici les souvenirs à long terme de l'utilisateur :` |
| SHOW_MEMORY_COUNT_EMITTER | `ON` |
**Activation** : Admin Panel → Functions → Memory Injection Filter → ⋯ → Toggle Global → **ON**
---
## Étape 5 : Tests de fonctionnement
### 5.1 Test de conversation basique
1. Créer un nouveau chat
2. Sélectionner le modèle **Effi**
3. Envoyer : `Bonjour Effi, comment vas-tu ?`
→ Effi devrait répondre en français avec sa personnalité configurée.
### 5.2 Test de mémoire
**Test d'enregistrement :**
```
Je collectionne les vinyles des années 80
```
Vérifier dans la base SQLite :
```bash
docker cp open-webui:/app/backend/data/webui.db /tmp/webui.db
sqlite3 /tmp/webui.db "SELECT content FROM memory ORDER BY created_at DESC LIMIT 3;"
```
→ Le souvenir devrait apparaître.
**Test de restitution :**
1. Créer un **nouveau chat** (important !)
2. Demander : `Qu'est-ce que tu sais sur mes hobbies ?`
→ Effi devrait mentionner les vinyles sans que vous l'ayez redit.
### 5.3 Test audio (si configuré)
**Test STT :**
- Cliquer sur l'icône micro dans OpenWebUI
- Parler : "Bonjour Effi"
- Vérifier que le texte est transcrit
**Test TTS :**
- Activer la lecture vocale dans les paramètres du chat
- Envoyer un message
- Vérifier que la réponse est lue à voix haute
---
## Étape 6 : Configuration Obsidian LiveSync
### 6.1 Préparer CouchDB
```bash
# Vérifier que CouchDB fonctionne
curl http://192.168.1.27:5984
# Les bases devraient déjà être créées lors de l'installation
# Si ce n'est pas le cas :
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/_users
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/_replicator
curl -X PUT http://master:MOT_DE_PASSE@192.168.1.27:5984/obsidian-livesync
```
### 6.2 Configurer Obsidian
Dans l'application Obsidian :
1. **Paramètres → Communauté → Parcourir**
2. Installer le plugin **Self-hosted LiveSync**
3. Ouvrir les paramètres du plugin
4. Configurer :
- **URI** : `http://192.168.1.27:5984`
- **Database** : `obsidian-livesync`
- **Username** : `master`
- **Password** : [votre mot de passe CouchDB]
5. Cliquer sur **Test**
6. Si OK, cliquer sur **Apply**
7. Activer la synchronisation
---
## Étape 7 : Optimisations
### 7.1 Activer les mémoires globales
**Admin Panel → Settings → General**
- **Memories** : ✅ ON
- **Memory Mode** : `User` ou `Global`
### 7.2 Configuration des modèles par défaut
**Admin Panel → Settings → Interface**
- **Default Model** : `Effi`
- **Default Language** : `fr-FR`
### 7.3 Personnalisation de l'interface
**Admin Panel → Settings → Interface**
- Changer le thème (clair/sombre)
- Configurer les raccourcis
- Personnaliser le logo et les couleurs
---
## Félicitations !
Effi est maintenant complètement configuré et prêt à l'emploi !
### Prochaines étapes suggérées :
1. **Explorer n8n** : Créer des workflows d'automatisation
2. **Configurer le RAG** : Uploader des documents pour enrichir les réponses
3. **Personnaliser davantage** : Ajuster le system prompt selon vos préférences
4. **Documentation** : Noter vos configurations dans Obsidian
### En cas de problème :
Consulter la section [Dépannage](../04-depannage/) pour les erreurs courantes et leurs solutions.
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)
docs/05-journal/historique.md
+185
View File
@@ -0,0 +1,185 @@
# 📓 Journal Historique
## Chronologie du projet Effi
---
## 2026-02-19 : Installation de la stack initiale
**Machine :** effi-server (192.168.1.27)
**Services installés :**
- ✅ Open WebUI (port 3000)
- ✅ WOL Proxy (port 3011)
- ✅ Qdrant (port 6333)
- ✅ CouchDB (port 5984)
- ✅ n8n (port 5678)
- ✅ mcpo (port 8000)
**Statut :** Infrastructure opérationnelle
---
## 2026-02-21 : Configuration ROCm et Whisper
**Machine :** folzo-Corp (192.168.1.11)
**Réalisations :**
- Installation ROCm sur Bazzite
- Recherche d'images Docker AMD
- Choix du modèle `bofenghuang/whisper-large-v3-french`
- Configuration OpenWebUI pour pointer vers STT
**Notes :** Projet de faire tourner Whisper sur GPU AMD
---
## 2026-02-23 : Intégration MCP Obsidian
**Réalisations :**
- Intégration MCP Obsidian fonctionnelle
- Tests de synchronisation
- Configuration des outils MCP
**Projets futurs identifiés :**
- Intégration Home Assistant
- Workflows n8n pour domotique
- Commandes vocales
---
## Mars 2026 : Migration et optimisations
### Migration STT/TTS vers folzo-Corp
**Motivation :** Réduire la charge CPU sur effi-server
**Actions :**
- Migration de openedai-speech vers folzo-Corp
- Build CTranslate2 ROCm pour speaches
- Configuration group_add avec GID numériques (44, 991)
- Firewall ports ouverts sur folzo-Corp
### Build CTranslate2 ROCm
**Problème rencontré :**
- `gfx1101` (dans Dockerfile) incompatible avec RX 7800 XT (`gfx1100`)
- `hipErrorInvalidDeviceFunction`
**Solution :**
```bash
sed -i 's/gfx1101/gfx1100/g' Dockerfile.rocm-ct2
docker build -f Dockerfile.rocm-ct2 -t speaches:rocm-ct2 .
```
**Statut :** Rebuild ROCm en cours, fonctionnement en CPU (int8) temporairement
### Configuration mémoire persistante
**Installation :**
- Filtre "Auto Memory" par nokodo
- Filtre "Memory Injection Filter" par Raphael
- Patch du code pour gestion JSON markdown
- Tests d'enregistrement et restitution réussis
### Problèmes résolus
1. **wol-proxy** : Build local depuis code Python maison
2. **Interface réseau** : Fix NetworkManager + udev rules
3. **Whisper** : Correction repo HuggingFace
4. **speaches** : Suppression PRELOAD_MODELS, utilisation speaches-init
5. **openedai-speech** : group_add avec GID numériques
6. **CTranslate2** : WHISPER__COMPUTE_TYPE=int8 en CPU
7. **mcpo** : Création config.json vide
8. **Open WebUI** : Ajout restart: unless-stopped à tous les services
---
## Avril 2026 : Documentation et organisation
**Actions :**
- Réorganisation complète de la documentation
- Création dépôt Git sur Gitea
- Structuration en sections logiques
- Fusion et nettoyage des notes dispersées
**Structure créée :**
```
effi/
├── README.md
├── docker-compose.yml
├── .env.example
├── .gitignore
└── docs/
├── 01-architecture/
├── 02-configuration/
├── 03-guides/
├── 04-depannage/
└── 05-journal/
```
---
## État actuel (Avril 2026)
### Services opérationnels
| Service | Hôte | État |
|---------|------|------|
| Open WebUI | effi-server | ✅ Fonctionnel |
| Ollama | folzo-Corp | ✅ qwen2.5:14b |
| Qdrant | effi-server | ✅ Running |
| CouchDB | effi-server | ✅ Running |
| n8n | effi-server | ✅ Running |
| speaches | folzo-Corp | ✅ CPU (GPU pending) |
| openedai-speech | folzo-Corp | ✅ ROCm gfx1100 |
| wol-proxy | effi-server | ✅ Fonctionnel |
| mcpo | effi-server | ✅ Running |
| pipelines | effi-server | ✅ Running |
### Fonctionnalités actives
- ✅ Chat textuel avec mémoire persistante
- ✅ RAG avec Qdrant
- ✅ STT (Whisper CPU, ~10s/phrase)
- ✅ TTS (Piper FR, ~300ms)
- ✅ Sync Obsidian LiveSync
- ✅ Wake-on-LAN automatique
### En cours / À venir
- 🔧 Finaliser build speaches ROCm gfx1100
- 🔧 Configurer RAG avec fichiers Nextcloud
- 🔧 Workflows n8n avancés
- 🔧 Intégration Home Assistant
- 🔧 Voice control complet
---
## Leçons apprises
### Ce qui a bien fonctionné
1. **Architecture multi-machines** : Séparation logique CPU/GPU
2. **Docker Compose** : Gestion simplifiée des services
3. **Mémoire persistante** : Filtres OpenWebUI efficaces
4. **Wake-on-LAN** : Solution élégante pour économie d'énergie
### Difficultés rencontrées
1. **ROCm AMD** : Complexité du build, documentation dispersée
2. **Groupes Docker** : Nécessité d'utiliser GID vs noms
3. **Networking** : Conflits DHCP, interfaces qui tombent
4. **Documentation** : Notes dispersées, doublons
### Bonnes pratiques identifiées
1. Toujours utiliser `restart: unless-stopped`
2. Documenter les erreurs ET les solutions
3. Versionner les configurations
4. Sauvegarder avant toute modification majeure
5. Utiliser des IPs fixes ou réservations DHCP
---
*Dernière mise à jour : Avril 2026*