881 lines
29 KiB
Markdown
881 lines
29 KiB
Markdown
# WeChat Homework Bot - Auto-Correction System
|
||
|
||
**Status**: CONCEPT
|
||
**Created**: 2025-11-29
|
||
**Use Case**: Bot WeChat pour récolter automatiquement les devoirs (mp3/mp4/audio) et les corriger automatiquement
|
||
**Target**: Cours particuliers d'Alexis (2 classes, usage non-officiel)
|
||
|
||
---
|
||
|
||
## 📋 Table des matières
|
||
|
||
1. [Vue d'ensemble](#vue-densemble)
|
||
2. [Faisabilité technique](#faisabilité-technique)
|
||
3. [Architecture système](#architecture-système)
|
||
4. [Stack technique](#stack-technique)
|
||
5. [Workflow détaillé](#workflow-détaillé)
|
||
6. [Risques et mitigations](#risques-et-mitigations)
|
||
7. [Plan d'implémentation](#plan-dimplémentation)
|
||
8. [Coûts](#coûts)
|
||
9. [Alternatives](#alternatives)
|
||
10. [Ressources](#ressources)
|
||
|
||
---
|
||
|
||
## 🎯 Vue d'ensemble
|
||
|
||
### Problème
|
||
- Étudiants envoient devoirs audio/vidéo (mp3, mp4, messages vocaux WeChat)
|
||
- Collecte manuelle chronophage
|
||
- Correction manuelle répétitive
|
||
- Pas de tracking automatique qui a rendu/pas rendu
|
||
|
||
### Solution proposée
|
||
Bot WeChat automatisé qui :
|
||
1. **Écoute** messages entrants (audio/vidéo)
|
||
2. **Télécharge** fichiers média automatiquement
|
||
3. **Transcrit** audio → texte (Speech-to-Text)
|
||
4. **Corrige** selon critères définis (GPT-4 ou règles custom)
|
||
5. **Renvoie** feedback automatique à l'étudiant
|
||
6. **Track** statistiques (taux de rendu, progression, etc.)
|
||
|
||
### Bénéfices
|
||
- ⏱️ Gain de temps : ~70-80% du temps de correction
|
||
- 📊 Tracking automatique
|
||
- ⚡ Feedback instantané aux étudiants
|
||
- 🔄 Process reproductible et scalable
|
||
|
||
---
|
||
|
||
## ✅ Faisabilité technique
|
||
|
||
### Verdict : **100% FAISABLE**
|
||
|
||
### Capacités Wechaty confirmées
|
||
|
||
**Wechaty** (framework open-source bot WeChat) supporte :
|
||
- ✅ **Audio** : mp3, messages vocaux WeChat (.silk)
|
||
- ✅ **Video** : mp4, fichiers vidéo WeChat
|
||
- ✅ **Images** : jpg, png
|
||
- ⚠️ **Autres attachments** : .zip, .docx (bug connu - 0 bytes)
|
||
|
||
**Source** : [Wechaty Media File Bot Documentation](https://wechaty.js.org/docs/examples/advanced/media-file-bot/)
|
||
|
||
### Pattern de base
|
||
|
||
```javascript
|
||
import { WechatyBuilder } from 'wechaty'
|
||
|
||
const bot = WechatyBuilder.build()
|
||
|
||
bot.on('message', async (message) => {
|
||
const type = message.type()
|
||
const contact = message.talker()
|
||
|
||
// Détection média
|
||
if (type === bot.Message.Type.Audio ||
|
||
type === bot.Message.Type.Video) {
|
||
|
||
console.log(`📥 Média reçu de ${contact.name()}`)
|
||
|
||
// Téléchargement
|
||
const fileBox = await message.toFileBox()
|
||
const filename = `${Date.now()}_${contact.id()}_${fileBox.name}`
|
||
await fileBox.toFile(`./uploads/${filename}`)
|
||
|
||
// Traitement (STT + Correction)
|
||
await processHomework(filename, contact)
|
||
}
|
||
})
|
||
|
||
bot.start()
|
||
```
|
||
|
||
---
|
||
|
||
## 🏗️ Architecture système
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ ÉTUDIANT (WeChat) │
|
||
│ Envoie mp3/mp4/message vocal │
|
||
└────────────────────────┬────────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ BOT WECHAT (Wechaty) │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ 1. Écoute messages (event listener) │ │
|
||
│ │ 2. Détecte type (Audio/Video) │ │
|
||
│ │ 3. Télécharge fichier (message.toFileBox()) │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
└────────────────────────┬────────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ STOCKAGE LOCAL (./uploads/) │
|
||
│ Format: timestamp_userId_filename.mp3/mp4 │
|
||
└────────────────────────┬────────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ TRANSCRIPTION (Speech-to-Text) │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ Option 1: OpenAI Whisper API (multi-langue) │ │
|
||
│ │ Option 2: Baidu STT (optimisé Chine) │ │
|
||
│ │ Option 3: Tencent Cloud ASR (local Chine) │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
│ Output: Texte transcrit │
|
||
└────────────────────────┬────────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ CORRECTION AUTOMATIQUE │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ GPT-4 API avec prompt de correction │ │
|
||
│ │ - Grammaire │ │
|
||
│ │ - Prononciation (via transcription) │ │
|
||
│ │ - Vocabulaire │ │
|
||
│ │ - Score /10 + feedback détaillé │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
└────────────────────────┬────────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ BASE DE DONNÉES (SQLite) │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ Tables: │ │
|
||
│ │ - students (id, name, wechat_id) │ │
|
||
│ │ - submissions (id, student_id, file, timestamp) │ │
|
||
│ │ - corrections (id, submission_id, score, feedback) │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
└────────────────────────┬────────────────────────────────────┘
|
||
│
|
||
▼
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ FEEDBACK AUTOMATIQUE │
|
||
│ Bot renvoie message WeChat avec: │
|
||
│ - Score │
|
||
│ - Points positifs │
|
||
│ - Points à améliorer │
|
||
│ - Recommandations │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
---
|
||
|
||
## 🛠️ Stack technique
|
||
|
||
### 1. Bot WeChat
|
||
- **Framework** : [Wechaty](https://github.com/wechaty/wechaty) (Node.js/TypeScript)
|
||
- **Puppet** (protocole WeChat) :
|
||
- **padlocal** : Payant (~8$/mois), stable, maintenu
|
||
- **wechat4u** : Gratuit, moins stable, peut casser avec updates WeChat
|
||
- **Recommandation** : padlocal pour production
|
||
|
||
### 2. Speech-to-Text (STT)
|
||
|
||
#### Option 1 : OpenAI Whisper API ⭐ (Recommandé)
|
||
```javascript
|
||
import OpenAI from 'openai'
|
||
import fs from 'fs'
|
||
|
||
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })
|
||
|
||
async function transcribe(audioPath) {
|
||
const transcription = await openai.audio.transcriptions.create({
|
||
file: fs.createReadStream(audioPath),
|
||
model: "whisper-1",
|
||
language: "zh", // ou "fr", "en"
|
||
})
|
||
return transcription.text
|
||
}
|
||
```
|
||
|
||
**Avantages** :
|
||
- Multi-langue (FR/EN/CN/JP)
|
||
- Précision excellente (~95%+)
|
||
- Simple à intégrer
|
||
- Gère mp3, mp4, mpeg, mpga, m4a, wav, webm
|
||
|
||
**Inconvénients** :
|
||
- Nécessite accès internet stable
|
||
- Coût : $0.006/minute (~¥0.04/minute)
|
||
- Peut être lent depuis Chine (VPN recommandé)
|
||
|
||
#### Option 2 : Baidu ASR (Speech Recognition)
|
||
```javascript
|
||
const AipSpeechClient = require("baidu-aip-sdk").speech
|
||
|
||
const client = new AipSpeechClient(APP_ID, API_KEY, SECRET_KEY)
|
||
|
||
async function transcribe(audioPath) {
|
||
const voiceBuffer = fs.readFileSync(audioPath)
|
||
const voiceBase64 = voiceBuffer.toString('base64')
|
||
|
||
const result = await client.recognize(voiceBase64, 'pcm', 16000)
|
||
return result.result[0]
|
||
}
|
||
```
|
||
|
||
**Avantages** :
|
||
- Optimisé pour chinois
|
||
- Rapide depuis Chine
|
||
- Gratuit jusqu'à 50k appels/jour
|
||
|
||
**Inconvénients** :
|
||
- Moins précis que Whisper
|
||
- Nécessite conversion format audio
|
||
- Documentation en chinois
|
||
|
||
#### Option 3 : Tencent Cloud ASR
|
||
**Avantages** :
|
||
- Infrastructure en Chine (rapide)
|
||
- Intégration WeChat native
|
||
- Prix compétitifs
|
||
|
||
**Inconvénients** :
|
||
- Setup complexe
|
||
- Documentation chinoise
|
||
|
||
### 3. Correction automatique
|
||
|
||
#### GPT-4 API (Recommandé)
|
||
```javascript
|
||
async function correctHomework(transcription, criteria) {
|
||
const response = await openai.chat.completions.create({
|
||
model: "gpt-4",
|
||
messages: [
|
||
{
|
||
role: "system",
|
||
content: `Tu es un professeur de français. Corrige ce devoir oral selon ces critères:
|
||
- Grammaire
|
||
- Vocabulaire
|
||
- Fluidité
|
||
- Prononciation (basée sur la transcription)
|
||
|
||
Donne un score /10 et un feedback constructif en 3-4 phrases.`
|
||
},
|
||
{
|
||
role: "user",
|
||
content: `Transcription de l'audio de l'étudiant:\n\n${transcription}`
|
||
}
|
||
]
|
||
})
|
||
|
||
return response.choices[0].message.content
|
||
}
|
||
```
|
||
|
||
**Prompt engineering tips** :
|
||
- Définir critères précis
|
||
- Demander format structuré (JSON pour parsing)
|
||
- Inclure exemples (few-shot learning)
|
||
|
||
### 4. Base de données
|
||
|
||
**SQLite** (recommandé pour POC/petit volume)
|
||
```sql
|
||
-- Schema SQL
|
||
CREATE TABLE students (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
name TEXT NOT NULL,
|
||
wechat_id TEXT UNIQUE NOT NULL,
|
||
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
||
);
|
||
|
||
CREATE TABLE submissions (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
student_id INTEGER NOT NULL,
|
||
filename TEXT NOT NULL,
|
||
file_path TEXT NOT NULL,
|
||
submitted_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
FOREIGN KEY (student_id) REFERENCES students(id)
|
||
);
|
||
|
||
CREATE TABLE corrections (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
submission_id INTEGER NOT NULL,
|
||
transcription TEXT,
|
||
score INTEGER,
|
||
feedback TEXT,
|
||
corrected_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
FOREIGN KEY (submission_id) REFERENCES submissions(id)
|
||
);
|
||
|
||
CREATE TABLE stats (
|
||
student_id INTEGER PRIMARY KEY,
|
||
total_submissions INTEGER DEFAULT 0,
|
||
average_score REAL,
|
||
last_submission DATETIME,
|
||
FOREIGN KEY (student_id) REFERENCES students(id)
|
||
);
|
||
```
|
||
|
||
**Alternative** : PostgreSQL (si scale > 100 étudiants)
|
||
|
||
### 5. Infrastructure
|
||
|
||
**Hébergement** :
|
||
- VPS Chine (Aliyun, Tencent Cloud) pour latence faible
|
||
- Alternative : VPS étranger + VPN
|
||
- Minimum : 2GB RAM, 20GB storage
|
||
|
||
**OS** : Ubuntu 22.04 LTS
|
||
|
||
**Node.js** : v18+ (LTS)
|
||
|
||
---
|
||
|
||
## 🔄 Workflow détaillé
|
||
|
||
### 1. Initialisation bot
|
||
|
||
```javascript
|
||
// bot.js
|
||
import { WechatyBuilder } from 'wechaty'
|
||
import { PuppetPadlocal } from 'wechaty-puppet-padlocal'
|
||
import Database from './database.js'
|
||
import { transcribeAudio, correctHomework } from './ai.js'
|
||
|
||
const TOKEN = process.env.PADLOCAL_TOKEN
|
||
|
||
const bot = WechatyBuilder.build({
|
||
puppet: new PuppetPadlocal({ token: TOKEN })
|
||
})
|
||
|
||
const db = new Database('./homework.db')
|
||
|
||
bot.on('login', user => {
|
||
console.log(`✅ Bot logged in: ${user}`)
|
||
})
|
||
|
||
bot.on('message', handleMessage)
|
||
|
||
await bot.start()
|
||
```
|
||
|
||
### 2. Gestion messages
|
||
|
||
```javascript
|
||
// handlers.js
|
||
async function handleMessage(message) {
|
||
// Ignorer messages du bot lui-même
|
||
if (message.self()) return
|
||
|
||
const contact = message.talker()
|
||
const type = message.type()
|
||
const room = message.room()
|
||
|
||
// Ignorer messages de groupe (optionnel)
|
||
if (room) return
|
||
|
||
// Traiter audio/vidéo
|
||
if (type === bot.Message.Type.Audio ||
|
||
type === bot.Message.Type.Video) {
|
||
await handleMediaSubmission(message, contact)
|
||
}
|
||
|
||
// Commandes texte (optionnel)
|
||
if (type === bot.Message.Type.Text) {
|
||
const text = message.text()
|
||
if (text === '/stats') {
|
||
await sendStats(contact)
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### 3. Traitement soumission
|
||
|
||
```javascript
|
||
async function handleMediaSubmission(message, contact) {
|
||
try {
|
||
// 1. Accusé réception
|
||
await message.say('📥 Devoir reçu ! Traitement en cours...')
|
||
|
||
// 2. Téléchargement
|
||
const fileBox = await message.toFileBox()
|
||
const filename = `${Date.now()}_${contact.id()}_${fileBox.name}`
|
||
const filepath = `./uploads/${filename}`
|
||
await fileBox.toFile(filepath)
|
||
|
||
// 3. Enregistrement DB
|
||
const student = await db.getOrCreateStudent(contact.id(), contact.name())
|
||
const submission = await db.createSubmission(student.id, filename, filepath)
|
||
|
||
// 4. Transcription
|
||
const transcription = await transcribeAudio(filepath)
|
||
|
||
// 5. Correction
|
||
const correction = await correctHomework(transcription)
|
||
|
||
// 6. Enregistrement résultat
|
||
await db.saveCorrection(submission.id, transcription, correction.score, correction.feedback)
|
||
|
||
// 7. Envoi feedback
|
||
const feedbackMessage = `
|
||
✅ Devoir corrigé !
|
||
|
||
📊 Score: ${correction.score}/10
|
||
|
||
💬 Feedback:
|
||
${correction.feedback}
|
||
|
||
Bon courage ! 💪
|
||
`.trim()
|
||
|
||
await contact.say(feedbackMessage)
|
||
|
||
// 8. Update stats
|
||
await db.updateStats(student.id)
|
||
|
||
} catch (error) {
|
||
console.error('❌ Erreur traitement:', error)
|
||
await contact.say('⚠️ Erreur lors du traitement. Réessaye ou contacte le prof.')
|
||
}
|
||
}
|
||
```
|
||
|
||
### 4. Gestion vidéo (extraction audio)
|
||
|
||
```javascript
|
||
import ffmpeg from 'fluent-ffmpeg'
|
||
|
||
async function extractAudioFromVideo(videoPath) {
|
||
const audioPath = videoPath.replace(/\.(mp4|mov|avi)$/, '.mp3')
|
||
|
||
return new Promise((resolve, reject) => {
|
||
ffmpeg(videoPath)
|
||
.toFormat('mp3')
|
||
.on('end', () => resolve(audioPath))
|
||
.on('error', reject)
|
||
.save(audioPath)
|
||
})
|
||
}
|
||
```
|
||
|
||
### 5. Statistiques étudiant
|
||
|
||
```javascript
|
||
async function sendStats(contact) {
|
||
const student = await db.getStudent(contact.id())
|
||
if (!student) {
|
||
await contact.say('Aucun devoir rendu pour le moment.')
|
||
return
|
||
}
|
||
|
||
const stats = await db.getStats(student.id)
|
||
|
||
const message = `
|
||
📊 Tes statistiques:
|
||
|
||
📝 Devoirs rendus: ${stats.total_submissions}
|
||
⭐ Moyenne: ${stats.average_score.toFixed(1)}/10
|
||
📅 Dernier devoir: ${stats.last_submission}
|
||
|
||
Continue comme ça ! 🚀
|
||
`.trim()
|
||
|
||
await contact.say(message)
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## ⚠️ Risques et mitigations
|
||
|
||
### 1. Ban compte WeChat
|
||
|
||
**Risque** : WeChat détecte comportement automatisé → ban temporaire/permanent
|
||
|
||
**Probabilité** :
|
||
- Compte principal : ~40%
|
||
- Compte secondaire dédié : ~15%
|
||
- Avec padlocal (payant) : ~5%
|
||
|
||
**Mitigations** :
|
||
- ✅ **Utiliser compte WeChat dédié** (pas compte perso)
|
||
- ✅ **Puppet stable** (padlocal > wechat4u)
|
||
- ✅ **Rate limiting** : Ne pas répondre instantanément (delay 2-5s)
|
||
- ✅ **Humanisation** : Varier temps de réponse
|
||
- ✅ **Éviter spam** : Max 50 messages/heure
|
||
- ✅ **Warmup** : Utiliser compte manuellement 1-2 semaines avant automation
|
||
|
||
**Plan B si ban** :
|
||
- Compte backup prêt
|
||
- Export données régulier
|
||
- Alternative : WeChat Official Account (route officielle)
|
||
|
||
### 2. Instabilité Wechaty/Puppet
|
||
|
||
**Risque** : Updates WeChat cassent le protocole → bot offline
|
||
|
||
**Probabilité** : ~10-20% sur 6 mois (wechat4u), ~2-5% (padlocal)
|
||
|
||
**Mitigations** :
|
||
- ✅ **Monitoring** : Alertes si bot offline >30min
|
||
- ✅ **Auto-restart** : PM2 ou systemd
|
||
- ✅ **Logs** : Debugging rapide
|
||
- ✅ **Puppet payant** (padlocal) pour stabilité
|
||
|
||
### 3. Qualité transcription
|
||
|
||
**Risque** : Mauvaise qualité audio → transcription incorrecte → correction biaisée
|
||
|
||
**Probabilité** : 15-25% des submissions
|
||
|
||
**Mitigations** :
|
||
- ✅ **Consignes claires** aux étudiants (environnement calme, micro proche)
|
||
- ✅ **Validation manuelle** échantillon aléatoire (10%)
|
||
- ✅ **Flag low confidence** : Whisper donne confidence score
|
||
- ✅ **Fallback** : Si score <0.7, demander humain
|
||
|
||
### 4. Coûts API
|
||
|
||
**Risque** : Coûts explosent si volume important
|
||
|
||
**Estimation mensuelle** (20 étudiants, 3 devoirs/semaine, 2min audio moyenne) :
|
||
- Transcription (Whisper) : 20 × 3 × 4 × 2min × $0.006 = **$2.88/mois**
|
||
- Correction (GPT-4) : 60 corrections × $0.03 = **$1.80/mois**
|
||
- **Total API** : ~$5/mois
|
||
- **Padlocal** : $8/mois
|
||
- **VPS** : $5-10/mois
|
||
|
||
**Total estimé** : **$18-23/mois**
|
||
|
||
**Mitigations** :
|
||
- ✅ **Quotas** : Limite devoirs/étudiant/semaine
|
||
- ✅ **Caching** : Ne pas retraiter si déjà fait
|
||
- ✅ **Alternative gratuite** : Baidu STT (50k/jour gratuit)
|
||
|
||
### 5. Privacy/RGPD
|
||
|
||
**Risque** : Stockage données sensibles (voix étudiants)
|
||
|
||
**Mitigations** :
|
||
- ✅ **Consentement** explicite étudiants
|
||
- ✅ **Encryption** fichiers sensibles
|
||
- ✅ **Rétention** : Auto-delete après 3 mois
|
||
- ✅ **Anonymisation** : Hash WeChat IDs
|
||
|
||
### 6. Dépendance internet
|
||
|
||
**Risque** : API externes down → bot inutilisable
|
||
|
||
**Mitigations** :
|
||
- ✅ **Queue system** : Redis/Bull pour retry automatique
|
||
- ✅ **Fallback** : Mode dégradé (just download, manual correction)
|
||
- ✅ **Monitoring** : Uptime alerts
|
||
|
||
---
|
||
|
||
## 🚀 Plan d'implémentation
|
||
|
||
### Phase 1 : POC (Proof of Concept) - 2 jours
|
||
|
||
**Objectif** : Valider faisabilité technique end-to-end
|
||
|
||
**Livrables** :
|
||
- [ ] Bot Wechaty qui se connecte
|
||
- [ ] Réception 1 audio/vidéo
|
||
- [ ] Download fichier localement
|
||
- [ ] Envoi à Whisper API
|
||
- [ ] Retour transcription au user
|
||
|
||
**Stack minimal** :
|
||
- Wechaty + wechat4u (gratuit pour tester)
|
||
- OpenAI Whisper API
|
||
- Pas de DB (juste logs)
|
||
|
||
**Critère succès** : 1 cycle complet fonctionnel
|
||
|
||
### Phase 2 : MVP (Minimum Viable Product) - 1 semaine
|
||
|
||
**Objectif** : Version utilisable avec 1 classe test
|
||
|
||
**Livrables** :
|
||
- [ ] Database SQLite (students, submissions, corrections)
|
||
- [ ] Correction automatique GPT-4
|
||
- [ ] Feedback formaté
|
||
- [ ] Gestion erreurs basique
|
||
- [ ] Commande `/stats`
|
||
|
||
**Stack** :
|
||
- Upgrade vers padlocal (stable)
|
||
- SQLite + better-sqlite3
|
||
- GPT-4 API integration
|
||
- Error handling + logging
|
||
|
||
**Critère succès** : 5 étudiants tests pendant 1 semaine
|
||
|
||
### Phase 3 : Production - 2 semaines
|
||
|
||
**Objectif** : Déploiement avec 2 classes complètes
|
||
|
||
**Livrables** :
|
||
- [ ] VPS déployé (Chine ou VPN)
|
||
- [ ] PM2 auto-restart
|
||
- [ ] Monitoring (Uptime Kuma ou similaire)
|
||
- [ ] Dashboard stats (optionnel)
|
||
- [ ] Documentation utilisateur
|
||
- [ ] Backup automatique DB
|
||
|
||
**Infrastructure** :
|
||
- VPS (Aliyun/Tencent Cloud ou Hetzner+VPN)
|
||
- Nginx reverse proxy
|
||
- Let's Encrypt SSL
|
||
- Daily backup S3/OSS
|
||
|
||
**Critère succès** : 95% uptime sur 2 semaines
|
||
|
||
### Phase 4 : Optimisation - Ongoing
|
||
|
||
**Features additionnelles** :
|
||
- [ ] Dashboard web (stats agrégées)
|
||
- [ ] Export Excel statistiques
|
||
- [ ] Correction par niveaux (débutant/intermédiaire/avancé)
|
||
- [ ] Multi-langue (FR/EN switch auto)
|
||
- [ ] Voice feedback (TTS pour audio response)
|
||
- [ ] Plagiarism detection
|
||
- [ ] Progress tracking over time
|
||
|
||
---
|
||
|
||
## 💰 Coûts
|
||
|
||
### Setup initial (one-time)
|
||
- **Développement** : DIY (0€) ou freelance (500-1500€)
|
||
- **VPS setup** : 0€ (si DIY)
|
||
- **Compte WeChat dédié** : 0€ (création gratuite)
|
||
|
||
### Récurrent mensuel
|
||
|
||
| Poste | Coût mensuel | Note |
|
||
|-------|--------------|------|
|
||
| **Padlocal token** | $8 (~7€) | Puppet stable, recommandé production |
|
||
| **VPS** | $5-15 | Aliyun/Hetzner selon localisation |
|
||
| **Whisper API** | $3-10 | Dépend volume (20-50 étudiants) |
|
||
| **GPT-4 API** | $5-15 | Dépend longueur feedbacks |
|
||
| **Domain** (optionnel) | $1 | Si dashboard web |
|
||
| **Backup storage** | $1-2 | S3/OSS pour backups DB |
|
||
| **TOTAL** | **$23-51/mois** | **~20-45€/mois** |
|
||
|
||
### Scaling costs
|
||
|
||
**50 étudiants** :
|
||
- Whisper : ~$10/mois
|
||
- GPT-4 : ~$20/mois
|
||
- **Total** : ~$40-55/mois
|
||
|
||
**100 étudiants** :
|
||
- Whisper : ~$20/mois
|
||
- GPT-4 : ~$40/mois
|
||
- VPS upgrade : $20/mois
|
||
- **Total** : ~$90-110/mois
|
||
|
||
### ROI (Return on Investment)
|
||
|
||
**Temps gagné** (estimation) :
|
||
- Correction manuelle : ~5min/devoir
|
||
- Correction auto : ~30s/devoir (juste validation)
|
||
- **Gain** : 4.5min/devoir
|
||
|
||
**Pour 20 étudiants, 3 devoirs/semaine** :
|
||
- 60 devoirs/semaine × 4.5min = **270 min/semaine = 4.5h/semaine**
|
||
- **18h/mois gagnées**
|
||
|
||
**Coût horaire** : $25/mois ÷ 18h = **$1.40/h**
|
||
|
||
→ **Rentable si ton temps vaut >$2/h** (spoiler: oui)
|
||
|
||
---
|
||
|
||
## 🔀 Alternatives
|
||
|
||
### Alternative 1 : WeChat Official Account (route officielle)
|
||
|
||
**Description** : Créer un Official Account WeChat et utiliser l'API officielle
|
||
|
||
**Avantages** :
|
||
- ✅ Légal, supporté par WeChat
|
||
- ✅ Stable (pas de risque ban)
|
||
- ✅ Features avancées (menus, paiements, etc.)
|
||
|
||
**Inconvénients** :
|
||
- ❌ Nécessite vérification (entreprise chinoise)
|
||
- ❌ Process bureaucratique (2-4 semaines)
|
||
- ❌ Coûts annuels (300 RMB/an ~40€)
|
||
- ❌ Limitations API (quotas stricts)
|
||
|
||
**Recommandation** : Pour usage éducatif personnel → **Overkill**
|
||
|
||
### Alternative 2 : Workflow semi-automatique
|
||
|
||
**Description** : Étudiants uploadent sur plateforme (Google Drive, WeTransfer) → traitement batch
|
||
|
||
**Avantages** :
|
||
- ✅ Pas de risque ban WeChat
|
||
- ✅ Plus simple techniquement
|
||
- ✅ Meilleur contrôle qualité fichiers
|
||
|
||
**Inconvénients** :
|
||
- ❌ Friction étudiants (changer habitudes)
|
||
- ❌ Pas de feedback instantané
|
||
- ❌ Nécessite discipline upload
|
||
|
||
**Recommandation** : **Backup plan** si Wechaty trop instable
|
||
|
||
### Alternative 3 : Telegram Bot
|
||
|
||
**Description** : Utiliser Telegram au lieu de WeChat
|
||
|
||
**Avantages** :
|
||
- ✅ API officielle gratuite et stable
|
||
- ✅ Excellente documentation
|
||
- ✅ Pas de risque ban
|
||
- ✅ Features riches (keyboards, inline, etc.)
|
||
|
||
**Inconvénients** :
|
||
- ❌ Étudiants chinois utilisent peu Telegram
|
||
- ❌ VPN nécessaire en Chine (Telegram bloqué)
|
||
- ❌ Friction adoption
|
||
|
||
**Recommandation** : **Si étudiants non-Chinois** ou tech-savvy
|
||
|
||
### Alternative 4 : DingTalk Bot
|
||
|
||
**Description** : Utiliser DingTalk (钉钉), plateforme pro chinoise
|
||
|
||
**Avantages** :
|
||
- ✅ API officielle pour éducation
|
||
- ✅ Utilisé dans écoles chinoises
|
||
- ✅ Stable, pas de risque ban
|
||
- ✅ Features éducation intégrées
|
||
|
||
**Inconvénients** :
|
||
- ❌ Moins personnel que WeChat
|
||
- ❌ Setup groupe de travail nécessaire
|
||
- ❌ Documentation chinoise
|
||
|
||
**Recommandation** : **Si contexte semi-officiel** (collaboration école)
|
||
|
||
### Comparaison rapide
|
||
|
||
| Critère | Wechaty | Official Account | Telegram | DingTalk |
|
||
|---------|---------|------------------|----------|----------|
|
||
| **Facilité adoption** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐ |
|
||
| **Stabilité technique** | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
|
||
| **Setup rapidité** | ⭐⭐⭐⭐ | ⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ |
|
||
| **Coût** | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
|
||
| **Risque légal** | ⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
|
||
|
||
**Recommandation finale** : **Wechaty pour POC/MVP**, migrer vers Official Account si scale
|
||
|
||
---
|
||
|
||
## 📚 Ressources
|
||
|
||
### Documentation officielle
|
||
|
||
- **Wechaty** : https://wechaty.js.org/docs/
|
||
- **Wechaty GitHub** : https://github.com/wechaty/wechaty
|
||
- **Wechaty Media File Bot Example** : https://wechaty.js.org/docs/examples/advanced/media-file-bot/
|
||
- **FileBox (file handling)** : https://wechaty.js.org/docs/howto/file-box
|
||
- **OpenAI Whisper API** : https://platform.openai.com/docs/guides/speech-to-text
|
||
- **OpenAI GPT-4 API** : https://platform.openai.com/docs/guides/chat
|
||
|
||
### Puppets (protocoles WeChat)
|
||
|
||
- **Padlocal** : http://pad-local.com/ (payant, stable)
|
||
- **wechat4u** : https://github.com/nodeWechat/wechat4u (gratuit, moins stable)
|
||
- **Puppet comparison** : https://wechaty.js.org/docs/puppet-providers/
|
||
|
||
### Alternatives STT (Speech-to-Text)
|
||
|
||
- **Baidu ASR** : https://ai.baidu.com/tech/speech/asr
|
||
- **Tencent Cloud ASR** : https://cloud.tencent.com/product/asr
|
||
- **Azure Speech** : https://azure.microsoft.com/en-us/products/ai-services/speech-to-text
|
||
|
||
### Tutoriels et articles
|
||
|
||
- **Building Chatbots For WeChat** : https://chatbotsmagazine.com/building-chatbots-for-wechat-part-1-dba8f160349
|
||
- **WeChat API Guide (Medium)** : https://medium.com/le-wagon/a-video-to-help-new-developers-get-started-on-wechat-advanced-mode-apis-54638debbcfc
|
||
- **Wechaty Getting Started (Chinese)** : https://wechaty.js.org/docs/getting-started/
|
||
|
||
### Code examples
|
||
|
||
- **Wechaty Examples** : https://github.com/wechaty/wechaty-getting-started
|
||
- **Wechaty + GPT** : https://github.com/wechaty/bot5-assistant
|
||
- **File handling issue** : https://github.com/wechaty/wechaty/issues/2596
|
||
|
||
### Infrastructure
|
||
|
||
- **PM2 (process manager)** : https://pm2.keymetrics.io/
|
||
- **Uptime Kuma (monitoring)** : https://github.com/louislam/uptime-kuma
|
||
- **Better-sqlite3** : https://github.com/WiseLibs/better-sqlite3
|
||
|
||
### VPS providers Chine
|
||
|
||
- **Aliyun (Alibaba Cloud)** : https://www.alibabacloud.com/
|
||
- **Tencent Cloud** : https://intl.cloud.tencent.com/
|
||
- **Hetzner** (Europe, bon pour VPN) : https://www.hetzner.com/
|
||
|
||
---
|
||
|
||
## 🎯 Next Steps
|
||
|
||
### Actions immédiates
|
||
|
||
1. **Décision** : Valider concept et approuver développement
|
||
2. **Setup** :
|
||
- [ ] Créer compte WeChat dédié (si pas déjà fait)
|
||
- [ ] Acheter token Padlocal (ou tester wechat4u gratuit)
|
||
- [ ] Créer compte OpenAI + ajouter crédits ($10 pour commencer)
|
||
3. **Dev POC** : 1 weekend pour prototype fonctionnel
|
||
4. **Test** : 1 semaine avec 3-5 étudiants pilotes
|
||
5. **Itération** : Ajuster selon feedbacks
|
||
6. **Deployment** : VPS + production avec toutes les classes
|
||
|
||
### Questions ouvertes
|
||
|
||
- **Quel type de cours** ? (FR/EN/CN/autre) → Impact prompts correction
|
||
- **Critères de correction** ? (grammaire, vocabulaire, prononciation, fluidité)
|
||
- **Format feedback** ? (score seul, détaillé, recommandations)
|
||
- **Fréquence devoirs** ? (quotidien, hebdo) → Impact coûts
|
||
- **Deadline rendu** ? (système de rappels automatiques ?)
|
||
|
||
### Mesures de succès
|
||
|
||
**POC** :
|
||
- ✅ 1 cycle complet fonctionnel
|
||
- ✅ Temps traitement <2min
|
||
- ✅ Précision transcription >85%
|
||
|
||
**MVP** :
|
||
- ✅ 5 étudiants utilisent pendant 1 semaine
|
||
- ✅ 0 crash critique
|
||
- ✅ Feedback étudiants positif (>7/10)
|
||
|
||
**Production** :
|
||
- ✅ 95% uptime
|
||
- ✅ Temps gagné >15h/mois
|
||
- ✅ Satisfaction étudiants >8/10
|
||
- ✅ ROI <3 mois
|
||
|
||
---
|
||
|
||
## 📝 Notes
|
||
|
||
**Créé** : 2025-11-29
|
||
**Auteur** : Alexis Trouvé
|
||
**Status** : CONCEPT → À valider avant passage WIP
|
||
**Prochaine review** : TBD
|
||
|
||
**Changements majeurs** :
|
||
- 2025-11-29 : Création document initial
|
||
|
||
---
|
||
|
||
**Tags** : `#wechat` `#bot` `#automation` `#education` `#ai` `#stt` `#gpt4` `#wechaty`
|