moteur_ia.py — assemblage complet (moteur, personnalité, garde-fou)

[Mario Da Conceicao]

Nouveau composant du 01/08/2026 — le moteur principal qui assemble tout ce qu’on a construit ce soir : détection matérielle, spécialités avec garde-fou, personnalité de MIRA (précision avant vitesse, réponses courtes et justes, jamais de bluff, aucune action sans validation).

Ce que ce fichier fait

• Détecte la RAM et choisit le bon modèle (detecteur_materiel.py)
• Ne télécharge jamais rien automatiquement — si le modèle manque, il le dit et attend une validation
• Charge le modèle via llama.cpp une fois présent
• Applique une "carte d’identité" (prompt système) qui fixe le caractère de MIRA à chaque réponse
• Consulte les spécialités actives avant de répondre, plutôt que de deviner
• Limite volontairement la longueur des réponses (réglage max_tokens) pour rester court et direct

"""
MIRA - Moteur neuronal
Assemble : détection matérielle, chargement du modèle, personnalité,
recherche dans les spécialités, garde-fou.
"""

import sys
from pathlib import Path

sys.path.append(str(Path(__file__).resolve().parent))

from detecteur_materiel import choisir_palier_modele, modele_deja_present, obtenir_ram_disponible_go
from gestionnaire_specialites import GestionnaireSpecialites

BASE_DIR = Path(__file__).resolve().parent
MODELES_DIR = BASE_DIR / "modeles"

# --- Carte d'identité de MIRA (personnalité) ---
PROMPT_SYSTEME = """Tu es MIRA, une intelligence artificielle locale et autonome.

Tes principes, non négociables :
1. PRÉCISION avant vitesse. Tu prends le temps de vérifier avant de répondre.
   Tu ne devines jamais quand tu peux vérifier dans tes spécialités.
2. RÉPONSES COURTES ET JUSTES. Jamais de remplissage, jamais de blabla.
   Une réponse contient uniquement ce qui est nécessaire, rien de plus.
3. HONNÊTETÉ. Si tu ne sais pas, tu le dis clairement, tu ne bluffes jamais.
4. AUCUNE ACTION SANS VALIDATION. Tu ne modifies jamais de fichier système,
   ne télécharges rien, n'actives aucune spécialité sans l'accord explicite
   de l'utilisateur.
5. Tu restes toi-même : conçue et façonnée par Mario ANTARES, pas une copie
   d'un autre assistant.
"""

class MoteurMira:
    def __init__(self):
        self.ram_go = obtenir_ram_disponible_go()
        self.palier = choisir_palier_modele(self.ram_go)
        self.specialites = GestionnaireSpecialites()
        self.modele_charge = None

    def demarrer(self):
        """
        Prépare le moteur au démarrage : vérifie le modèle, le charge.
        Aucun téléchargement automatique (garde-fou).
        """
        if not modele_deja_present(self.palier):
            return {
                "statut": "attente_validation",
                "message": (
                    f"Le modèle recommandé pour cette machine ({self.palier['nom']}, "
                    f"{self.palier['parametres']}) n'est pas encore installé. "
                    f"Fichier attendu : modeles/{self.palier['fichier']}. "
                    "Aucun téléchargement automatique — validation nécessaire."
                )
            }

        self._charger_modele()
        return {"statut": "pret", "message": self.rapport_demarrage()}

    def _charger_modele(self):
        """
        Charge le modèle via llama-cpp-python. À brancher une fois llama.cpp
        installé sur OS-MIRE.
        """
        try:
            from llama_cpp import Llama
            self.modele_charge = Llama(
                model_path=str(MODELES_DIR / self.palier["fichier"]),
                n_ctx=4096,
                verbose=False,
            )
        except ImportError:
            self.modele_charge = None  # llama-cpp-python pas encore installé

    def rapport_demarrage(self):
        return (
            f"RAM détectée : {self.ram_go} Go\n"
            f"Modèle chargé : {self.palier['nom']} ({self.palier['parametres']})\n"
            f"Spécialités actives : {len(self.specialites.lister_actives())}"
        )

    def repondre(self, question):
        """
        Analyse la question, consulte les spécialités actives si pertinent,
        puis génère une réponse courte avec le modèle.
        """
        if self.modele_charge is None:
            return "Le moteur neuronal n'est pas encore chargé (llama.cpp manquant ou modèle absent)."

        contexte = self._rassembler_contexte(question)
        messages = [{"role": "system", "content": PROMPT_SYSTEME}]
        if contexte:
            messages.append({
                "role": "system",
                "content": f"Informations trouvées dans tes spécialités, utilise-les si pertinentes :\n{contexte}"
            })
        messages.append({"role": "user", "content": question})

        resultat = self.modele_charge.create_chat_completion(
            messages=messages,
            max_tokens=400,     # borne la longueur : cohérent avec "réponses courtes"
            temperature=0.3,    # privilégie la justesse à la créativité
        )
        return resultat["choices"][0]["message"]["content"].strip()

    def _rassembler_contexte(self, question):
        """Cherche un contexte pertinent dans les spécialités actives."""
        extraits = []
        for specialite in self.specialites.lister_actives():
            resultats = self.specialites.consulter_specialite(specialite["nom"], mot_cle=None)
            # À terme : brancher recherche_semantique.py ici pour une vraie
            # recherche par sens, une fois l'index construit sur chaque spécialité.
            if resultats:
                extraits.extend(r["extrait"] for r in resultats[:1])
        return "\n---\n".join(extraits) if extraits else None

if __name__ == "__main__":
    moteur = MoteurMira()
    etat = moteur.demarrer()
    print(etat["message"])

Ce qui reste à faire, clairement identifié dans le code (marqué "à brancher"/"à terme")

• Relier recherche_semantique.py à _rassembler_contexte() pour une vraie recherche par sens (actuellement, appel simple en attendant)
• Installer réellement llama-cpp-python et le modèle choisi sur OS-MIRE une fois le système prêt

Prochaine étape naturelle

Faire tourner ce moteur pour de vrai suppose maintenant d’avoir OS-MIRE installé (Tiny Core + Python), l’étape qu’on avait mise en pause pour se concentrer sur l’IA.

[Auteur]

Messages