# Kazeia-Engine — vue d'ensemble du moteur unifié

**Mai 2026**. Moteur d'inférence local-first pour la tablette Snapdragon 8 Elite (Pad3). Couvre LLM, TTS (avec clonage vocal embarqué) et STT dans une stack cohérente.

```
┌─────────────────────── Kazeia-Engine ───────────────────────┐
│                                                              │
│  STT (Whisper-Small NPU)        TTS (Qwen3-TTS in-process)   │
│  ┌──────────────────────┐       ┌────────────────────────┐  │
│  │ libkazeia_stt.so     │       │ libkazeia_tts.so       │  │
│  │  168 KB              │       │  ~5 MB                 │  │
│  │  ↳ stt_engine        │       │  ↳ tts_engine          │  │
│  │  ↳ kazeia_mel        │ ────► │  ↳ kazeia_mel          │  │ partage
│  │  ↳ VAD RMS C++       │       │  ↳ speaker_encoder     │  │ mel + VAD
│  │  ↳ BPE byte-level    │       │  ↳ cp_inference        │  │
│  │  ↳ JSON parser       │       │  ↳ decoder ggml chraac │  │
│  │                      │       │  ↳ sampler             │  │
│  │  runtime :           │       │                        │  │
│  │  libonnxruntime.so + │       │  runtime :             │  │
│  │  libQnnHtp*.so       │       │  libllama + libggml*   │  │
│  └──────────────────────┘       └────────────────────────┘  │
│                                                              │
│  LLM (Qwen3.5-4B GGUF)                                      │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ libllama.so + libggml-htp-v79.so + chraac codec      │   │
│  │  ↳ prefill HTP / decode CPU NEON                     │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                              │
└──────────────────────────────────────────────────────────────┘
```

## API Kotlin unifiée (côté app)

```kotlin
// 1) STT in-process (Whisper-Small NPU)
val stt = SttEngine("/data/.../whisper-small-sm8750", useHtp = true)
val transcript = stt.transcribe(pcm16, language = "fr")

// 2) VAD (drop-in replacement de VadStage.kt)
val vad = SttVad()
when (vad.push(chunk)) { SttVad.SPEECH -> ... ; SttVad.END_OF_SPEECH -> ... }

// 3) TTS in-process (Qwen3-TTS + clonage vocal embarqué)
val tts = TtsEngine(
    talkerGguf  = "/data/.../talker_f32.gguf",
    vocabGguf   = "/data/.../Qwen3-4B-Q4_0.gguf",
    dumpDir     = "/data/.../tts_dump",
    useHtp      = false,
    nThreads    = 6
)
val r = tts.synthesize("Bonjour, comment ça va ?", "/sdcard/out.wav")

// 4) LLM via libllama (Qwen3.5-4B Q4_0 cascade Speaker+Thinker)
//    -- intégration via lib séparée libkazeia_engine.so + façade existante.
```

## Composants livrés à ce jour

| Composant | État | Lib | Doc |
|---|---|---|---|
| LLM Qwen3.5-4B / Qwen3.5-9B GGUF | prod | `libllama.so` + Hexagon backend | `CLAUDE.md` |
| TTS Talker + CP + decoder ggml | prod | `libkazeia_tts.so` | `tts_engine.h` |
| Clonage vocal speaker encoder ECAPA-TDNN | **livré 31/05** | `libkazeia_tts.so` | mémoire `project_tts_voice_cloning` |
| STT Whisper-Small NPU C++ | **livré 31/05** | `libkazeia_stt.so` | **`STT_INTEGRATION.md`** |
| VAD RMS C++ | **livré 31/05** | `libkazeia_stt.so` | idem |
| Mel extractor partagé (FFT) | **livré 31/05** | `kazeia_mel.{h,cpp}` | header |

## Empreinte mémoire (Snapdragon 8 Elite, 16 GB RAM)

| Composant chargé | RAM peak |
|---|---:|
| LLM Qwen3.5-4B Q4_0 | 2.4 GB |
| LLM Qwen3.5-9B Q4_0 | 5.0 GB |
| TTS (talker + CP + decoder + vocab + xvector fixture) | 3.5 GB |
| TTS clonage vocal (speaker encoder, en plus du fixture) | +34 MB |
| STT Whisper-Small NPU (encoder + decoder QAIRT) | 378 MB |
| **Total cascade Speaker 4B + STT + TTS** | **~6.3 GB** (sur 16 GB dispo) |

## Pipeline vocal de bout en bout (latence typique)

```
mic 16 kHz PCM16
  ↓ AudioRecord
SttVad (RMS énergie)           → ~830 ms après fin de parole (silence 800 ms + overhead)
  ↓ end_of_speech
SttEngine.transcribe(pcm)      → ~0.4-2.0 s selon longueur audio (RTF 0.4)
  ↓ texte FR
LLM Qwen3.5-4B cascade         → ~5-10 s (Guard + Speaker, 4-9 GB total)
  ↓ réponse FR
TtsEngine.synthesize(text)     → ~3-10 s (RTF 2.5-3.0 selon longueur)
  ↓
audio playback
```

Total latence voix→audio : ~10-25 s selon longueur du tour, dominée par LLM + TTS.

## Documentation par sous-système

- **LLM** : `/opt/Kazeia-engine/CLAUDE.md` (état complet)
- **TTS** : `tts_engine.h` (API publique) + clonage vocal section §1 du STT_INTEGRATION.md
- **STT** : **`STT_INTEGRATION.md`** (guide intégration complet)
- **Mémoire interne assistant** : `/home/alf/.claude/projects/-opt-Kazeia-engine/memory/`

## Pour intégrer côté app Android

Lire `STT_INTEGRATION.md` — guide complet de migration depuis `WhisperHybridEngine.kt`. Les libs `libkazeia_tts.so` et `libkazeia_stt.so` partagent le même runtime (NDK r27d, arm64-v8a, API 31+, `-march=armv8.6-a+i8mm+bf16+dotprod+fp16`).