Update app.py

app.py

@@ -731,11 +731,458 @@ async def api_ia_configurer(request: dict):
         }
     except Exception as e:
         return {"success": False, "error": str(e)}
+# =============================================================================
+# SYSTÈME AVANCÉ DE RECOMMANDATIONS PERSONNALISÉES
+# =============================================================================
+
+class SystemeRecommandations:
+    """Système intelligent de recommandations basé sur le comportement utilisateur"""
+    
+    def __init__(self):
+        self.historique_interactions = deque(maxlen=1000)
+        self.profil_utilisateur = {
+            "themes_frequents": defaultdict(int),
+            "horaires_activite": defaultdict(int),
+            "types_requetes": defaultdict(int),
+            "fonctionnalites_preferees": defaultdict(int),
+            "niveau_technique": "intermediaire"  # debutant, intermediaire, expert
+        }
+        
+        self.recommandations_actives = []
+        self.derniere_analyse = time.time()
+        self.score_personnalisation = 0.0
+        
+        logger.info("🎯 Système de recommandations personnalisées initialisé")
+    
+    def enregistrer_interaction(self, interaction: Dict[str, Any]):
+        """Enregistre une interaction utilisateur pour l'analyse"""
+        self.historique_interactions.append(interaction)
+        
+        # Mettre à jour le profil en temps réel
+        self._mettre_a_jour_profil(interaction)
+        
+        # Générer de nouvelles recommandations si nécessaire
+        if time.time() - self.derniere_analyse > 300:  # Toutes les 5 minutes
+            self.analyser_comportement()
+            self.derniere_analyse = time.time()
+    
+    def analyser_comportement(self) -> Dict[str, Any]:
+        """Analyse approfondie du comportement utilisateur"""
+        logger.info("🔍 Analyse du comportement utilisateur...")
+        
+        if not self.historique_interactions:
+            return {"statut": "donnees_insuffisantes"}
+        
+        # Analyse des thèmes fréquents
+        themes = self._analyser_themes_frequents()
+        
+        # Analyse des patterns temporels
+        patterns_temps = self._analyser_patterns_temporels()
+        
+        # Analyse du niveau technique
+        niveau_tech = self._evaluer_niveau_technique()
+        
+        # Détection des besoins implicites
+        besoins = self._detecter_besoins_implicites()
+        
+        # Générer les recommandations
+        self._generer_recommandations(themes, patterns_temps, niveau_tech, besoins)
+        
+        return {
+            "themes_principaux": dict(sorted(themes.items(), key=lambda x: x[1], reverse=True)[:5]),
+            "patterns_temporels": patterns_temps,
+            "niveau_technique": niveau_tech,
+            "besoins_detectes": besoins,
+            "score_personnalisation": self.score_personnalisation,
+            "recommandations_actives": len(self.recommandations_actives)
+        }
+    
+    def _analyser_themes_frequents(self) -> Dict[str, int]:
+        """Analyse les thèmes les plus fréquents dans les interactions"""
+        themes = defaultdict(int)
+        
+        for interaction in self.historique_interactions:
+            message = interaction.get("message", "").lower()
+            
+            # Détection de thèmes
+            if any(mot in message for mot in ['cortex', 'mémoire', 'optimisation', 'performance']):
+                themes["optimisation_technique"] += 1
+            if any(mot in message for mot in ['bonjour', 'salut', 'hello', 'merci']):
+                themes["communication"] += 1
+            if any(mot in message for mot in ['état', 'statut', 'santé', 'santé']):
+                themes["monitoring_systeme"] += 1
+            if any(mot in message for mot in ['aide', 'comment', 'quoi', 'pourquoi']):
+                themes["recherche_aide"] += 1
+            if any(mot in message for mot in ['ia', 'intelligence', 'apprentissage']):
+                themes["ia_avancee"] += 1
+            if any(mot in message for mot in ['projet', 'developpement', 'code', 'programmation']):
+                themes["developpement"] += 1
+        
+        # Mettre à jour le profil
+        for theme, count in themes.items():
+            self.profil_utilisateur["themes_frequents"][theme] += count
+        
+        return themes
+    
+    def _analyser_patterns_temporels(self) -> Dict[str, Any]:
+        """Analyse les patterns d'utilisation temporels"""
+        heures_activite = defaultdict(int)
+        jours_activite = defaultdict(int)
+        
+        for interaction in self.historique_interactions:
+            timestamp = interaction.get("timestamp", time.time())
+            heure = datetime.fromtimestamp(timestamp).hour
+            jour = datetime.fromtimestamp(timestamp).strftime("%A")
+            
+            heures_activite[heure] += 1
+            jours_activite[jour] += 1
+        
+        # Déterminer les pics d'activité
+        heure_pic = max(heures_activite.items(), key=lambda x: x[1])[0] if heures_activite else 12
+        jour_pic = max(jours_activite.items(), key=lambda x: x[1])[0] if jours_activite else "Lundi"
+        
+        return {
+            "heures_actives": dict(heures_activite),
+            "jours_actifs": dict(jours_activite),
+            "pic_activite": f"{heure_pic}h",
+            "jour_favori": jour_pic
+        }
+    
+    def _evaluer_niveau_technique(self) -> str:
+        """Évalue le niveau technique de l'utilisateur"""
+        termes_techniques = 0
+        termes_simples = 0
+        
+        for interaction in self.historique_interactions:
+            message = interaction.get("message", "").lower()
+            
+            # Termes techniques
+            if any(mot in message for mot in ['api', 'endpoint', 'docker', 'uvicorn', 'fastapi', 'websocket']):
+                termes_techniques += 1
+            # Termes simples
+            if any(mot in message for mot in ['comment', 'quoi', 'aide', 'simple']):
+                termes_simples += 1
+        
+        total_interactions = len(self.historique_interactions)
+        if total_interactions == 0:
+            return "debutant"
+        
+        ratio_technique = termes_techniques / total_interactions
+        
+        if ratio_technique > 0.3:
+            return "expert"
+        elif ratio_technique > 0.1:
+            return "intermediaire"
+        else:
+            return "debutant"
+    
+    def _detecter_besoins_implicites(self) -> List[str]:
+        """Détecte les besoins non exprimés directement"""
+        besoins = []
+        
+        # Analyser les patterns pour détecter les besoins
+        themes = self.profil_utilisateur["themes_frequents"]
+        
+        if themes.get("optimisation_technique", 0) > 5:
+            besoins.append("optimisation_avancee")
+        if themes.get("monitoring_systeme", 0) > 3:
+            besoins.append("dashboard_ameliore")
+        if themes.get("recherche_aide", 0) > 5:
+            besoins.append("assistant_intelligent")
+        if themes.get("ia_avancee", 0) > 2:
+            besoins.append("integrations_ia")
+        if themes.get("developpement", 0) > 3:
+            besoins.append("outils_developement")
+        
+        return besoins
+    
+    def _generer_recommandations(self, themes: Dict, patterns: Dict, niveau: str, besoins: List[str]):
+        """Génère des recommandations personnalisées"""
+        self.recommandations_actives = []
+        
+        # Recommandations basées sur les thèmes
+        for theme, count in themes.items():
+            if count > 3:  # Seuil d'activation
+                if theme == "optimisation_technique":
+                    self.recommandations_actives.append({
+                        "type": "fonctionnalite",
+                        "titre": "🔧 Mode Optimisation Avancée",
+                        "description": "Activez le mode haute performance pour l'optimisation mémoire",
+                        "priorite": "haute",
+                        "action": "/api/optimisation/activer",
+                        "score_confiance": min(1.0, count / 10)
+                    })
+                elif theme == "monitoring_systeme":
+                    self.recommandations_actives.append({
+                        "type": "interface",
+                        "titre": "📊 Dashboard Détaillé",
+                        "description": "Accédez à des métriques système avancées",
+                        "priorite": "moyenne",
+                        "action": "/dashboard/avance",
+                        "score_confiance": min(1.0, count / 8)
+                    })
+        
+        # Recommandations basées sur le niveau technique
+        if niveau == "debutant":
+            self.recommandations_actives.append({
+                "type": "guide",
+                "titre": "🎓 Guide de Démarrage",
+                "description": "Découvrez les fonctionnalités principales de Barouia-Cortex",
+                "priorite": "haute",
+                "action": "/guide/demarrage",
+                "score_confiance": 0.9
+            })
+        elif niveau == "expert":
+            self.recommandations_actives.append({
+                "type": "fonctionnalite",
+                "titre": "⚙️ API Avancée",
+                "description": "Accédez aux endpoints experts et à la documentation technique",
+                "priorite": "moyenne",
+                "action": "/api/docs",
+                "score_confiance": 0.8
+            })
+        
+        # Recommandations basées sur les besoins détectés
+        for besoin in besoins:
+            if besoin == "integrations_ia":
+                self.recommandations_actives.append({
+                    "type": "integration",
+                    "titre": "🤖 Intégrations IA",
+                    "description": "Connectez Barouia-Cortex à GPT-4, Claude et autres modèles",
+                    "priorite": "haute",
+                    "action": "/api/ia/configurer",
+                    "score_confiance": 0.85
+                })
+            elif besoin == "assistant_intelligent":
+                self.recommandations_actives.append({
+                    "type": "fonctionnalite",
+                    "titre": "💡 Assistant Contextuel",
+                    "description": "Activez l'assistant qui comprend le contexte de vos projets",
+                    "priorite": "moyenne",
+                    "action": "/api/assistant/activer",
+                    "score_confiance": 0.75
+                })
+        
+        # Calcul du score de personnalisation
+        self.score_personnalisation = min(1.0, len(self.historique_interactions) / 50)
+        
+        # Trier par priorité et score de confiance
+        self.recommandations_actives.sort(
+            key=lambda x: (1 if x["priorite"] == "haute" else 0.5, x["score_confiance"]), 
+            reverse=True
+        )
+    
+    def suggerer_fonctionnalites(self, limite: int = 5) -> List[Dict[str, Any]]:
+        """Suggère des fonctionnalités personnalisées"""
+        if not self.recommandations_actives:
+            self.analyser_comportement()
+        
+        # Retourner les recommandations les plus pertinentes
+        return self.recommandations_actives[:limite]
+    
+    def suggerer_themes(self, limite: int = 3) -> List[str]:
+        """Suggère des thèmes de discussion basés sur les intérêts"""
+        themes_tries = sorted(
+            self.profil_utilisateur["themes_frequents"].items(),
+            key=lambda x: x[1],
+            reverse=True
+        )
+        
+        themes_suggerees = []
+        correspondance_themes = {
+            "optimisation_technique": "Optimisation du système et performances",
+            "communication": "Communication et interaction naturelle",
+            "monitoring_systeme": "Surveillance et métriques avancées",
+            "ia_avancee": "Intelligence artificielle et apprentissage",
+            "developpement": "Développement et programmation"
+        }
+        
+        for theme, count in themes_tries[:limite]:
+            if count > 2:  # Seuil minimum
+                themes_suggerees.append(correspondance_themes.get(theme, theme))
+        
+        return themes_suggerees
+    
+    def get_statistiques(self) -> Dict[str, Any]:
+        """Retourne les statistiques du système de recommandations"""
+        return {
+            "total_interactions": len(self.historique_interactions),
+            "score_personnalisation": self.score_personnalisation,
+            "recommandations_actives": len(self.recommandations_actives),
+            "profil_utilisateur": {
+                "niveau_technique": self.profil_utilisateur["niveau_technique"],
+                "themes_principaux": dict(
+                    sorted(
+                        self.profil_utilisateur["themes_frequents"].items(),
+                        key=lambda x: x[1], 
+                        reverse=True
+                    )[:5]
+                )
+            },
+            "derniere_analyse": self.derniere_analyse
+        }
 
 # =============================================================================
 # INTÉGRATION AVEC LE SYSTÈME EXISTANT
 # =============================================================================
 
+# Ajoutez cette ligne APRÈS la création des autres systèmes
+systeme_recommandations = SystemeRecommandations()
+
+# Modifiez la fonction de traitement des messages pour enregistrer les interactions
+async def traiter_requete_avec_recommandations(self, requete: str) -> Dict[str, Any]:
+    """Version améliorée qui enregistre les interactions pour les recommandations"""
+    resultat = await self.traiter_requete_optimisee(requete)
+    
+    # Enregistrer l'interaction pour les recommandations
+    interaction = {
+        "timestamp": time.time(),
+        "message": requete,
+        "type": "chat",
+        "longueur": len(requete),
+        "themes_detectes": []  # Serait rempli par analyse NLP
+    }
+    
+    systeme_recommandations.enregistrer_interaction(interaction)
+    
+    return resultat
+
+# Remplacez la méthode originale
+CortexOptimise.traiter_requete_optimisee = traiter_requete_avec_recommandations
+
+# =============================================================================
+# ROUTES API POUR LES RECOMMANDATIONS
+# =============================================================================
+
+@app.get("/api/recommandations/obtenir")
+async def obtenir_recommandations(limite: int = 5):
+    """Endpoint pour obtenir les recommandations personnalisées"""
+    recommandations = systeme_recommandations.suggerer_fonctionnalites(limite)
+    
+    return {
+        "success": True,
+        "recommandations": recommandations,
+        "statistiques": systeme_recommandations.get_statistiques(),
+        "themes_suggerees": systeme_recommandations.suggerer_themes(3)
+    }
+
+@app.post("/api/recommandations/analyser")
+async def analyser_comportement():
+    """Déclenche une analyse manuelle du comportement"""
+    analyse = systeme_recommandations.analyser_comportement()
+    
+    return {
+        "success": True,
+        "analyse": analyse,
+        "message": "Analyse du comportement terminée"
+    }
+
+@app.get("/api/recommandations/statistiques")
+async def get_recommandations_statistiques():
+    """Statistiques détaillées du système de recommandations"""
+    return {
+        "success": True,
+        "statistiques": systeme_recommandations.get_statistiques()
+    }
+
+@app.post("/api/recommandations/feedback")
+async def donner_feedback_recommandation(request: dict):
+    """Donne un feedback sur une recommandation (utile pour l'apprentissage)"""
+    recommandation_id = request.get("recommandation_id")
+    note = request.get("note")  # 1-5
+    utile = request.get("utile", False)
+    
+    # Ici on pourrait enregistrer le feedback pour améliorer le système
+    logger.info(f"📝 Feedback reçu: {recommandation_id} - Note: {note} - Utile: {utile}")
+    
+    return {
+        "success": True,
+        "message": "Feedback enregistré pour amélioration du système"
+    }
+
+# =============================================================================
+# INTÉGRATION DANS L'INTERFACE
+# =============================================================================
+
+# Ajoutez cette route pour une interface dédiée aux recommandations
+@app.get("/recommandations", response_class=HTMLResponse)
+async def interface_recommandations():
+    """Interface dédiée aux recommandations personnalisées"""
+    return """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Recommandations Personnalisées - Barouia-Cortex</title>
+        <style>
+            body { 
+                font-family: Arial, sans-serif; 
+                margin: 40px;
+                background: #0f0f23;
+                color: white;
+            }
+            .container { max-width: 800px; margin: 0 auto; }
+            .header { text-align: center; margin-bottom: 2rem; }
+            .recommandation { 
+                background: rgba(255,255,255,0.1); 
+                padding: 1rem; 
+                margin: 1rem 0; 
+                border-radius: 10px;
+                border-left: 4px solid #667eea;
+            }
+            .priorite-haute { border-left-color: #ff6b6b; }
+            .priorite-moyenne { border-left-color: #ffd93d; }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="header">
+                <h1>🎯 Recommandations Personnalisées</h1>
+                <p>Découvrez les fonctionnalités adaptées à votre usage</p>
+            </div>
+            <div id="recommandations-container">
+                <p>Chargement des recommandations...</p>
+            </div>
+        </div>
+
+        <script>
+            async function chargerRecommandations() {
+                try {
+                    const response = await fetch('/api/recommandations/obtenir?limite=10');
+                    const data = await response.json();
+                    
+                    const container = document.getElementById('recommandations-container');
+                    container.innerHTML = '';
+                    
+                    if (data.recommandations.length === 0) {
+                        container.innerHTML = '<p>Aucune recommandation pour le moment. Continuez à utiliser le système !</p>';
+                        return;
+                    }
+                    
+                    data.recommandations.forEach(rec => {
+                        const div = document.createElement('div');
+                        div.className = `recommandation priorite-${rec.priorite}`;
+                        div.innerHTML = `
+                            <h3>${rec.titre}</h3>
+                            <p>${rec.description}</p>
+                            <small>Confiance: ${(rec.score_confiance * 100).toFixed(0)}%</small>
+                        `;
+                        container.appendChild(div);
+                    });
+                    
+                } catch (error) {
+                    console.error('Erreur:', error);
+                }
+            }
+            
+            document.addEventListener('DOMContentLoaded', chargerRecommandations);
+        </script>
+    </body>
+    </html>
+    """
+# =============================================================================
+# INTÉGRATION AVEC LE SYSTÈME EXISTANT
+# =============================================================================
+
 # Ajoutez cette ligne APRÈS la création de cortex_optimise (vers la ligne ~400)
 integration_apis = IntegrationAPIs()