assistant IA local le texte fonctionne très bien, la voix est une autre histoire
Le point de départ
Comme beaucoup d’utilisateurs Jeedom, je pilotais ma maison via des routines Alexa classiques : je parlais, Amazon comprenait, et le résultat revenait déclencher une action chez moi. Ça fonctionne, mais toute l’intelligence — la compréhension de ma demande — passait par les serveurs d’Amazon.
Le point de départ
Comme beaucoup d’utilisateurs Jeedom, je pilotais ma maison via des routines Alexa classiques : je parlais, Amazon comprenait, et le résultat revenait déclencher une action chez moi. Ça fonctionne, mais toute l’intelligence — la compréhension de ma demande — passait par les serveurs d’Amazon.
L’objectif que je me suis fixé : construire un assistant qui comprend une phrase en langage naturel (« ferme un peu le volet du salon », « quelle température fait-il dans la cuisine ») et agit dessus, sans dépendre d’une IA cloud, tout en gardant le matériel Alexa que j’ai dans toute la maison comme simple façade vocale.
Spoiler : j’y suis arrivé. Voici le chemin complet, avec ses impasses et la solution finale qui fonctionne aujourd’hui de bout en bout.
Partie 1 : construire un assistant textuel rapide et fiable
L’IA locale complète, trop lente
Ma première tentative reposait sur le plugin ai_assistant, connecté à Ollama (IA locale) via le protocole MCP, en mode agentique complet : l’IA recevait ma question, décidait elle-même quels outils appeler, orchestrait tout.
Les réponses mettaient 2 à 4 minutes, parfois jusqu’au timeout de 120 secondes. En creusant : un modèle en mode *thinking* (raisonnement interne invisible), aucune de mes machines n’ayant de GPU exploitable (NAS, mini-PC, Raspberry Pi — aucune accélération CUDA/ROCm), et une architecture agentique ajoutant ses propres allers-retours.
Le découplage MCP / Ollama — la vraie percée
Plutôt que de tout confier à un agent IA autonome, j’ai découplé deux briques :
1. MCP en lecture ciblée : appel direct à l’outil find_command pour retrouver dynamiquement l’ID d’une commande Jeedom (température, lumière, volet) à partir de son type générique.
2. Ollama en appel minimal : un simple appel API avec un modèle léger (qwen2.5:1.5b, sans mode *thinking*), un contexte réduit et une réponse plafonnée.
Résultat : des réponses en 3 à 5 secondes au lieu de plusieurs minutes.
Un scénario fusionné qui gère toute la maison
J’ai étendu ce mécanisme aux lumières et aux volets, puis fusionné le tout en un seul scénario avec un système de routage par mots-clés. Il gère aujourd’hui :
- la lecture de n’importe quel capteur de température, avec réponse formulée naturellement,
- l’allumage/extinction de n’importe quelle lumière, individuellement ou toutes ensemble,
- le pilotage de volets proportionnels avec positions absolues (« ferme », « ouvre à moitié ») et relatives (« ouvre un peu » → ±20 % par rapport à la position réelle lue en direct), ainsi que l’arrêt en cours de mouvement.
C’est ce scénario qui reste le cœur du projet — rapide, fiable, sans dépendance cloud.
Partie 2 : la bataille pour le rendre pilotable à la voix
Avoir un assistant qui comprend le texte, c’est une chose. Lui faire recevoir ce texte depuis une phrase dite à voix haute, sans repasser par une IA cloud, en est une autre — et c’est là que ça s’est corsé.
Impasse 1 : le canal texte-libre officiel d’Alexa (VoiceQuery)
Le seul mécanisme du skill Alexa officiellement conçu pour du texte vraiment libre passe par le plugin ai_assistant. Même optimisé (modèle léger, sans *thinking*), les réponses ont mis de 2 à 47 secondes selon les cas, et le contexte automatiquement filtré excluait parfois la donnée recherchée — menant l’IA à inventer une réponse plutôt que lire la vraie valeur.
Impasse 2 : le mécanisme `ask` avec réponse libre
Jeedom propose une action de scénario ask qui accepte en théorie une réponse vocale totalement libre (* dans la liste des réponses possibles). Après des heures de débogage, la cause de l’échec systématique est apparue dans la documentation elle-même : Alexa ne fait pas partie des canaux compatibles avec cette fonctionnalité (seuls sms, Slack, Telegram, Snips et l’application mobile le sont).
Impasse 3 : la capture « libre » du moteur d’interactions natif
Une interaction Jeedom avec un tag générique censé capturer n’importe quel texte ne matche jamais rien en pratique. La cause : le moteur d’interactions ne fait pas de capture de texte réellement libre — un tag doit correspondre à une commande dont les valeurs possibles sont connues à l’avance (liste, plage de slider), pas à du langage naturel.
La contrainte structurelle de fond : les 8 secondes
Un skill Alexa hébergé a une limite dure et non modifiable de 8 secondes pour toute la chaîne de traitement d’une commande vocale. Entre la latence réseau vers Jeedom et le traitement lui-même, cette limite était régulièrement dépassée — peu importe le mécanisme utilisé côté skill.
La solution qui a tout débloqué : sortir Alexa du chemin d’écoute
Le vrai déblocage est venu d’un changement d’architecture complet : au lieu de faire transiter la reconnaissance vocale *par* le skill Alexa (bridé à 8 secondes), la reconnaissance se fait en dehors de ce cadre, via Home Assistant.
L’intégration officielle Alexa Devices de Home Assistant expose une entité qui reçoit, par événements poussés en temps réel (pas de sondage), le texte exact de chaque phrase dite à un appareil Alexa — sans jamais passer par le skill ni son plafond de temps.
Architecture finale :
| Voix → Alexa (reconnaissance uniquement) → Home Assistant (capteur « Last Called », push temps réel) → Automatisation HA (appel HTTP) → Commande virtuelle Jeedom → Scénario fusionné (MCP + IA locale) → Action + réponse vocale via « Faire parler Alexa » |
Aucune limite de temps de ce côté : Home Assistant peut prendre le temps qu’il faut pour traiter l’information et appeler Jeedom, puisque ce n’est plus Alexa qui attend une réponse synchrone.
Le détail qui manquait : la construction du virtuel côté Jeedom
Pour que Home Assistant ait un point d’entrée simple et fiable à appeler, tout repose sur un petit équipement virtuel avec deux commandes qui se relaient :
- une commande info (type texte), qui reçoit la phrase et déclenche le scénario fusionné dès que sa valeur change (avec l’option * »Répéter les valeurs identiques »* activée, sinon reposer deux fois la même question ne redéclenche rien) ;
- une commande action (type message), dont le champ * »Résultat dans »* pointe vers la commande info ci-dessus — c’est elle que Home Assistant appelle via l’API Jeedom (jeeApi.php), ce qui déclenche la commande info en cascade.

Ce petit détour (une action qui écrit dans une info) permet à n’importe quelle source — Home Assistant aujourd’hui, un autre mécanisme demain — d’alimenter le même point d’entrée sans dupliquer la logique de routage. C’est ce même virtuel qui avait servi, bien avant Home Assistant, à tester le scénario simplement en tapant du texte à la main.
Le cheminement complet, du son à l’action
| 1. Tu parles à un Echo, n’importe où dans la maison 2. Alexa fait la reconnaissance vocale (elle seule communique avec Amazon) 3. Home Assistant reçoit le texte par événement poussé (push, temps réel) 4. Une automatisation HA détecte le changement et appelle l’API Jeedom 5. La commande action du virtuel Jeedom écrit dans la commande info 6. Ce changement de valeur déclenche automatiquement le scénario fusionné 7. Le scénario route la demande (volet / lumière / température), interroge MCP pour trouver la bonne commande Jeedom, puis agit 8. La réponse est écrite dans le virtuel ET renvoyée à voix haute sur l’Echo via la commande « Faire parler Alexa » |
À aucun moment de cette chaîne le skill Alexa officiel n’intervient — il ne sert donc plus de goulot d’étranglement.
Les derniers obstacles avant que tout fonctionne
- Double authentification obligatoire : l’intégration Alexa Devices exige une 2FA par application (pas SMS) sur le compte Amazon — une contrainte qui, loin de gêner les autres plugins Alexa existants, améliore même la fiabilité de leur propre authentification.
- Réponse vocale parasite d’Alexa : Alexa continue de tenter une correspondance SmartHome native sur toute phrase entendue, même après avoir été correctement traitée côté Home Assistant. Une réponse vocale explicite renvoyée depuis le scénario Jeedom (via la commande « Faire parler Alexa ») permet de donner la vraie réponse malgré ce bruit de fond.
Le scénario final (version généralisée)
Voici le scénario complet, avec une section de configuration personnalisable en tête — à adapter à ta propre installation en modifiant uniquement le tableau $mesCommandesPerso.
$mcpUrl = 'http://127.0.0.1:8765/mcp';
// ============================================================
// === MES COMMANDES PERSO — modifie uniquement cette section ===
// ============================================================
$mesCommandesPerso = [
'volets' => [
'salon' => ['SALON', 'Volet salon'],
'cuisine' => ['CUISINE', 'Volet cuisine'],
// Ajoute ici tes autres volets
],
'lumieres' => [
'salon' => ['SALON', 'Lum_Salon'],
'cuisine' => ['CUISINE', 'Lum_Cuisine'],
'sdb' => ['SDB', 'Lum_Sdb'],
'salle de bain' => ['SDB', 'Lum_Sdb'],
'chambre1' => ['CHAMBRE1', 'Lum_Chambre1'],
'chambre2' => ['CHAMBRE2', 'Lum_Chambre2'],
'garage' => ['GARAGE', 'Lum_Garage'],
'entree' => ['ENTREE', 'Lumiere_Entree'],
'entrée' => ['ENTREE', 'Lumiere_Entree'],
// Ajoute ici tes autres lumières
],
'lumieres_toutes' => ['Lum_Salon', 'Lum_Cuisine', 'Lum_Sdb', 'Lum_Chambre1', 'Lum_Chambre2', 'Lum_Garage', 'Lumiere_Entree'],
'temperatures' => [
'salon' => 'Temp_Salon',
'cuisine' => 'Temp_Cuisine',
'sdb' => 'Temp_Sdb',
'salle de bain' => 'Temp_Sdb',
'exterieur' => 'Temp_Exterieur',
'extérieur' => 'Temp_Exterieur',
'dehors' => 'Temp_Exterieur',
// Ajoute ici tes autres capteurs
],
'cmd_reponse_id' => 0, // ID de ta commande de réponse (info)
'cmd_alexa_speak' => 0, // ID de la commande "Faire parler Alexa"
'ollama_url' => 'http://IP_SERVEUR_OLLAMA:PORT/api/generate',
'ollama_model' => 'qwen2.5:1.5b',
];
// ============================================================
// === FIN DE LA CONFIGURATION PERSO ===
// ============================================================
function parseMcpSse($raw) {
foreach (explode("\n", $raw) as $line) {
if (strpos($line, 'data: ') === 0) {
return json_decode(substr($line, 6), true);
}
}
return null;
}
function mcpFindCommand($mcpUrl, $genericType, $reqId) {
$ch = curl_init($mcpUrl);
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true,
CURLOPT_POSTFIELDS => json_encode([
'jsonrpc' => '2.0', 'id' => $reqId, 'method' => 'tools/call',
'params' => ['name' => 'find_command', 'arguments' => ['generic_type' => $genericType]]
]),
CURLOPT_HTTPHEADER => ['Content-Type: application/json'], CURLOPT_TIMEOUT => 8,
]);
$response = curl_exec($ch);
curl_close($ch);
$data = parseMcpSse($response);
return $data['result']['content'][0]['text'] ?? '';
}
function extractCmdId($text, $cmdName) {
foreach (explode("\n", $text) as $line) {
if (stripos($line, $cmdName . ' →') !== false && preg_match('/cmd_id=(\d+)/', $line, $m)) {
return (int)$m[1];
}
}
return null;
}
function trouverPiece($questionLower, $mapping) {
foreach ($mapping as $motCle => $valeur) {
if (mb_stripos($questionLower, $motCle) !== false) return $valeur;
}
return null;
}
function faireParlerAlexa($cmdId, $texte) {
if (!$cmdId) return;
$c = cmd::byId($cmdId);
if (is_object($c)) {
$c->execCmd(['message' => $texte]);
}
}
// --- Récupérer la commande vocale ---
$tags = $scenario->getTags();
$question = trim((string)($tags['#trigger_value#'] ?? ''));
$questionLower = mb_strtolower($question);
$scenario->setLog("Commande reçue : " . $question);
// --- Initialize MCP (une seule fois) ---
$ch = curl_init($mcpUrl);
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true,
CURLOPT_POSTFIELDS => json_encode([
'jsonrpc' => '2.0', 'id' => 1, 'method' => 'initialize',
'params' => ['protocolVersion' => '2025-03-26', 'capabilities' => new stdClass(),
'clientInfo' => ['name' => 'jeedom-assistant', 'version' => '1.0']]
]),
CURLOPT_HTTPHEADER => ['Content-Type: application/json'], CURLOPT_TIMEOUT => 8,
]);
curl_exec($ch);
curl_close($ch);
$cmdReponse = cmd::byId($mesCommandesPerso['cmd_reponse_id']);
$cmdAlexaSpeak = $mesCommandesPerso['cmd_alexa_speak'];
// --- Routage selon les mots-clés ---
$isVolet = mb_stripos($questionLower, 'volet') !== false;
$isLumiere = mb_stripos($questionLower, 'lumiere') !== false || mb_stripos($questionLower, 'lumière') !== false;
$isTemp = mb_stripos($questionLower, 'temperature') !== false || mb_stripos($questionLower, 'température') !== false
|| mb_stripos($questionLower, 'degr') !== false;
$scenario->setLog("Routage : volet=" . ($isVolet?'oui':'non') . " lumiere=" . ($isLumiere?'oui':'non') . " temp=" . ($isTemp?'oui':'non'));
// ============================================================
// BLOC VOLET
// ============================================================
if ($isVolet) {
$niveau = null;
$relatif = false;
$isFermer = false;
$isOuvrir = false;
if (mb_stripos($questionLower, 'peu') !== false) {
$relatif = true;
$isFermer = (bool) preg_match('/\b(ferm\w*|baiss\w*|descend\w*)\b/i', $question);
$isOuvrir = (bool) preg_match('/\b(ouvr\w*|mont\w*|l[eè]v\w*)\b/i', $question);
} elseif (preg_match('/\b(ferm\w*|baiss\w*|descend\w*)\b/i', $question)) {
$niveau = 0;
} elseif (mb_stripos($questionLower, 'quart') !== false || mb_stripos($questionLower, '25') !== false) {
$niveau = 25;
} elseif (mb_stripos($questionLower, 'moitié') !== false || mb_stripos($questionLower, 'moitie') !== false
|| mb_stripos($questionLower, 'demi') !== false || mb_stripos($questionLower, '50') !== false) {
$niveau = 50;
} elseif (preg_match('/\b(ouvr\w*|mont\w*|l[eè]v\w*|grand\w*)\b/i', $question)) {
$niveau = 100;
}
if ($niveau === null && !$relatif) {
$scenario->setLog("Aucun niveau d'ouverture reconnu.");
return;
}
$infoVolet = trouverPiece($questionLower, $mesCommandesPerso['volets']);
if (!$infoVolet) {
$scenario->setLog("Impossible de déterminer la pièce (volet).");
return;
}
[$piece, $cmdName] = $infoVolet;
$textSlider = mcpFindCommand($mcpUrl, 'FLAP_SLIDER', 2);
$cmdId = extractCmdId($textSlider, $cmdName);
if (!$cmdId) {
$scenario->setLog("Aucune commande volet trouvée.");
return;
}
if ($relatif) {
$textState = mcpFindCommand($mcpUrl, 'FLAP_STATE', 3);
$cmdIdState = extractCmdId($textState, $cmdName);
$cState = $cmdIdState ? cmd::byId($cmdIdState) : null;
$posActuelle = is_object($cState) ? (int) $cState->execCmd() : 50;
if ($isFermer) {
$niveau = max(0, $posActuelle - 20);
} elseif ($isOuvrir) {
$niveau = min(100, $posActuelle + 20);
} else {
$scenario->setLog("Direction relative non reconnue.");
return;
}
$scenario->setLog("Position actuelle : $posActuelle%, nouvelle : $niveau%");
}
$c = cmd::byId($cmdId);
if (is_object($c)) {
// Format ['slider' => valeur] — à adapter selon ton propre plugin volet
$c->execCmd(['slider' => $niveau]);
$msg = "J'ai réglé le volet du $piece à $niveau%.";
if (is_object($cmdReponse)) $cmdReponse->event($msg);
faireParlerAlexa($cmdAlexaSpeak, $msg);
}
return;
}
// ============================================================
// BLOC LUMIERE
// ============================================================
if ($isLumiere) {
$isOn = (bool) preg_match('/\b(allum\w*|ouvr\w*)\b/i', $question);
$isOff = (bool) preg_match('/\b(éte?ins?\w*|eteins?\w*|ferm\w*)\b/i', $question);
if (!$isOn && !$isOff) {
$scenario->setLog("Aucune action lumière reconnue.");
return;
}
$genericType = $isOn ? 'LIGHT_ON' : 'LIGHT_OFF';
$isToutesLesLumieres = preg_match('/\btoutes?\s+les?\s+lumi[eè]res?\b/i', $question)
|| mb_stripos($questionLower, 'toute la maison') !== false
|| preg_match('/\ballume\s+tout\b/i', $question)
|| preg_match('/\bétein[st]\s+tout\b/i', $question)
|| preg_match('/\beteins?\s+tout\b/i', $question);
if ($isToutesLesLumieres) {
$text = mcpFindCommand($mcpUrl, $genericType, 4);
$nbExecutees = 0;
foreach ($mesCommandesPerso['lumieres_toutes'] as $nom) {
$id = extractCmdId($text, $nom);
if ($id) {
$c = cmd::byId($id);
if (is_object($c)) { $c->execCmd(); $nbExecutees++; }
}
}
$scenario->setLog("$nbExecutees lumière(s) actionnée(s).");
$msg = $isOn ? "J'ai allumé toutes les lumières." : "J'ai éteint toutes les lumières.";
if (is_object($cmdReponse)) $cmdReponse->event($msg);
faireParlerAlexa($cmdAlexaSpeak, $msg);
return;
}
$infoLumiere = trouverPiece($questionLower, $mesCommandesPerso['lumieres']);
if (!$infoLumiere) {
$scenario->setLog("Impossible de déterminer la pièce (lumière).");
return;
}
[$piece, $cmdName] = $infoLumiere;
$text = mcpFindCommand($mcpUrl, $genericType, 5);
$cmdId = extractCmdId($text, $cmdName);
if ($cmdId) {
$c = cmd::byId($cmdId);
if (is_object($c)) {
$c->execCmd();
$scenario->setLog("Lumière $piece exécutée.");
$msg = $isOn ? "J'ai allumé la lumière du $piece." : "J'ai éteint la lumière du $piece.";
if (is_object($cmdReponse)) $cmdReponse->event($msg);
faireParlerAlexa($cmdAlexaSpeak, $msg);
}
} else {
$scenario->setLog("Aucune commande lumière trouvée.");
}
return;
}
// ============================================================
// BLOC TEMPERATURE
// ============================================================
if ($isTemp) {
$cmdName = trouverPiece($questionLower, $mesCommandesPerso['temperatures']);
if (!$cmdName) {
$scenario->setLog("Aucune pièce reconnue (température).");
return;
}
$text = mcpFindCommand($mcpUrl, 'TEMPERATURE', 6);
$cmdId = extractCmdId($text, $cmdName);
if (!$cmdId) {
$scenario->setLog("Commande température introuvable.");
return;
}
$c = cmd::byId($cmdId);
$valeur = is_object($c) ? $c->execCmd() : null;
$scenario->setLog("Valeur : " . $valeur);
if ($valeur === null) return;
$prompt = "Réponds de façon courte et naturelle à cette question sur la maison.\n";
$prompt .= "Valeur mesurée : {$valeur}°C\nQuestion : {$question}\nAssistant :";
$payload = [
'model' => $mesCommandesPerso['ollama_model'], 'prompt' => $prompt, 'stream' => false, 'keep_alive' => -1,
'options' => ['num_predict' => 45, 'temperature' => 0.1, 'num_ctx' => 512]
];
$ch = curl_init($mesCommandesPerso['ollama_url']);
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true,
CURLOPT_POSTFIELDS => json_encode($payload, JSON_UNESCAPED_UNICODE),
CURLOPT_HTTPHEADER => ['Content-Type: application/json'], CURLOPT_TIMEOUT => 15,
]);
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true);
$answer = trim((string)($data['response'] ?? ''));
if (mb_strlen($answer) > 240) $answer = mb_substr($answer, 0, 237) . '...';
$scenario->setLog("Réponse IA : " . $answer);
if ($answer !== '') {
if (is_object($cmdReponse)) $cmdReponse->event($answer);
faireParlerAlexa($cmdAlexaSpeak, $answer);
}
return;
}
// ============================================================
// AUCUN TYPE RECONNU
// ============================================================
$scenario->setLog("Type de demande non reconnu (ni volet, ni lumière, ni température).");
Le pont Home Assistant → Jeedom
Deux briques côté Home Assistant, à créer une fois pour toutes.
1. Un capteur qui expose la dernière phrase dite (configuration.yaml, doc officielle de l’intégration Alexa Devices) :
template:
- sensor:
- name: Alexa Devices Last Called
unique_id: alexa_devices_last_called
state: >
{{
integration_entities('alexa_devices')
| select('match', '^event\.')
| select('has_value')
| map('states')
| sort
| last
}}
attributes:
event_entity: >
{{
integration_entities('alexa_devices')
| select('match', '^event\.')
| select('has_value')
| select('is_state', this.state)
| first
| default(none)
}}
voice_command: >
{{ state_attr(this.attributes.event_entity, 'voice_command') }}
2. Une commande REST qui transmet le texte à Jeedom :
rest_command:
jeedom_alexa_texte:
url: "http://IP_JEEDOM/core/api/jeeApi.php?apikey=TA_CLE_API&type=cmd&id=ID_COMMANDE_ACTION&title=&message={{ texte | urlencode }}"
method: GET
Puis une automatisation simple : déclencheur sur changement d’état du capteur, action = appel de cette commande REST avec texte: « {{ trigger.to_state.attributes.voice_command }} ».
Ce que je retiens
- Construire un assistant qui comprend le langage naturel, en local, est largement accessible — à condition de découpler la recherche d’information (rapide, ciblée) de la génération de réponse, plutôt que de tout confier à un agent IA autonome.
- La vraie difficulté n’était pas de comprendre le langage, mais de capter la voix sans passer par un canal contraint. Trois mécanismes officiels d’Alexa se sont révélés inadaptés pour des raisons différentes (lenteur, incompatibilité non documentée, fausse promesse de capture libre) avant de trouver la bonne porte d’entrée.
- Sortir la reconnaissance vocale du skill Alexa lui-même a tout débloqué. En laissant Home Assistant écouter passivement (par push, sans plafond de temps) et en ne réutilisant Alexa que comme haut-parleur, la contrainte structurelle des 8 secondes disparaît complètement.
- La documentation officielle ne suffit pas toujours : plusieurs blocages (compatibilité * avec Alexa, comportement réel du moteur d’interactions, resynchronisation d’un token après rotation de clé) n’ont été résolus qu’en testant directement et en lisant les journaux bruts.
Le résultat aujourd’hui : je dis une phrase à un Echo, n’importe où dans la maison, et la maison comprend et agit — sans qu’aucune donnée ne transite par une IA cloud, et sans les limites qu’imposait le skill Alexa classique.

