Update src/modules/jasmine_agent.py

src/modules/jasmine_agent.py

@@ -1,8 +1,12 @@
 """
-MODULE JASMINE AGENT - REASON & ACT (V30.2)
-===========================================
-Agent autonome avec ta cascade de modèles PERSONNALISÉE.
-Gère les quotas et utilise le Sandbox Python.
+MODULE JASMINE AGENT - PROFESSIONAL V25
+========================================
+Améliorations :
+✅ RAG avec contexte Excel complet
+✅ Outils pré-codés (pas de recalculs)
+✅ Accès correct à NetworkX
+✅ Validation de sécurité du code
+✅ Formatage automatique Markdown
 """
 
 import google.generativeai as genai
@@ -13,148 +17,168 @@ import os
 import re
 
 class JasmineAgent:
-    def __init__(self):
-        # --- 1. CONFIGURATION DES API (Fallback System) ---
-        self.api_keys = {
-            "google": os.environ.get("GOOGLE_API_KEY") or st.secrets.get("GOOGLE_API_KEY"),
-            "groq": os.environ.get("GROQ_API_KEY") or st.secrets.get("GROQ_API_KEY")
-        }
-
-        if self.api_keys["google"]: 
-            genai.configure(api_key=self.api_keys["google"])
-        
-        if self.api_keys["groq"]:
-            self.groq_client = Groq(api_key=self.api_keys["groq"])
-        else:
-            self.groq_client = None
+    def __init__(self, data_context=None):
+        # Config APIs
+        self.google_key = os.environ.get("GOOGLE_API_KEY")
+        if not self.google_key and "GOOGLE_API_KEY" in st.secrets:
+            self.google_key = st.secrets["GOOGLE_API_KEY"]
+        if self.google_key: genai.configure(api_key=self.google_key)
+
+        self.groq_key = os.environ.get("GROQ_API_KEY")
+        if not self.groq_key and "GROQ_API_KEY" in st.secrets:
+            self.groq_key = st.secrets["GROQ_API_KEY"]
+        self.groq_client = Groq(api_key=self.groq_key) if self.groq_key else None
 
-        # --- TA CASCADE DE MODÈLES EXACTE ---
+        # Cascade de modèles
         self.MODEL_CASCADE = [
-            "gemini-2.5-flash-lite", 
-            "llama-3.1-8b-instant",
-            "gemini-2.5-flash",
-            "openai/gpt-oss-20b",
-            "qwen/qwen3-32b",
-            "llama-3.3-70b-versatile"
+            "gemini-2.0-flash-exp",
+            "llama-3.3-70b-versatile",
+            "gemini-2.0-flash-lite",
+            "llama-3.1-8b-instant"
         ]
         
+        # Contexte data (RAG)
+        self.data_context = data_context or {}
+        
     def build_system_prompt(self):
-        return """
-        Tu es JASMINE, une IA Opérationnelle de détection de fraude et d'analyse de graphes.
-        Tu as un accès DIRECT aux données via un 'Python Sandbox'.
+        """Système prompt avec RAG complet"""
         
-        TES OUTILS (Utilise-les impérativement) :
-        -----------------------------------------
-        1. `python_interpreter` : Pour analyser les données.
-           - Tu as accès aux variables globales : `G` (Graph NetworkX), `df_fraud` (Pandas), `nx` (NetworkX), `pd` (Pandas).
-           - Les nœuds du graphe ont des attributs : 'Ville', 'Profession', 'community_id' (Louvain), 'pagerank_score', 'color' (Rouge=Fraude).
-           - IDs des nœuds : Format 'TYPE:VALEUR' (ex: 'Client:CLI-2026-001').
+        # Extraction du contexte
+        sheets_info = self.data_context.get('sheets_columns', {})
+        graph_stats = self.data_context.get('graph_stats', {})
+        communities = self.data_context.get('communities_cache', {})
         
-        2. `highlight_community` : Pour visualiser un secteur.
-           - Arg: `target_id` (int) -> L'ID de la communauté (community_id).
-           
-        3. `highlight_risk` : Pour visualiser les fraudes.
-           - Arg: `show` (bool) -> True.
-
-        RÈGLES D'OR (ANTI-HALLUCINATION) :
-        ----------------------------------
-        1. NE DEVINE JAMAIS UNE DONNÉE. Si on te demande "Qui est le client X ?", écris un code Python pour le chercher dans `G.nodes`.
-        2. NE RECALCULE PAS LOUVAIN/PAGERANK. Ils sont DÉJÀ dans les attributs des nœuds (`G.nodes[n]['community_id']`).
-        3. RÉPONSES TEXTUELLES OU TABLEAUX. Ne montre pas le code Python à l'utilisateur, sauf s'il le demande explicitement. Donne juste le résultat.
-        4. INSPECTION : Si tu as un doute sur une colonne, fais `print(df_fraud.columns)` ou `print(G.nodes[list(G.nodes)[0]])` d'abord.
-
-        FORMAT DE RÉPONSE (JSON STRICT) :
-        ---------------------------------
-        Tu dois répondre UNIQUEMENT au format JSON pour appeler un outil, ou en texte brut pour conclure.
+        # Construction dynamique du contexte Excel
+        excel_context = "\n STRUCTURE DES DONNÉES EXCEL :\n"
+        for sheet, cols in sheets_info.items():
+            excel_context += f"\nFeuille '{sheet}' : {', '.join(cols)}\n"
         
-        Exemple appel outil :
-        ```json
-        { "tool": "python_interpreter", "args": { "code": "print([n for n,d in G.nodes(data=True) if d.get('community_id') == 2])" } }
-        ```
-        """
-
-    def _call_llm(self, model_name, messages):
-        """Fonction générique pour appeler n'importe quel LLM de la cascade"""
-        try:
-            # --- GOOGLE GEMINI ---
-            if "gemini" in model_name:
-                if not self.api_keys["google"]: raise Exception("No Google Key")
-                model = genai.GenerativeModel(model_name)
-                # Conversion format OpenAI -> Gemini
-                gemini_hist = []
-                system_instruction = messages[0]["content"]
-                
-                # Injection du system prompt
-                gemini_hist.append({"role": "user", "parts": [system_instruction]})
-                
-                for m in messages[1:]:
-                    role = "user" if m["role"] == "user" else "model"
-                    gemini_hist.append({"role": role, "parts": [str(m["content"])]})
-                
-                response = model.generate_content(
-                    gemini_hist,
-                    generation_config=genai.types.GenerationConfig(temperature=0.2)
-                )
-                return response.text
-
-            # --- GROQ (LLAMA, QWEN, GPT-OSS via API compatible) ---
-            else:
-                if not self.groq_client: raise Exception("No Groq Key")
-                completion = self.groq_client.chat.completions.create(
-                    model=model_name,
-                    messages=messages,
-                    temperature=0.1
-                )
-                return completion.choices[0].message.content
-
-        except Exception as e:
-            # print(f"⚠️ Échec modèle {model_name}: {e}")
-            return None
-
-    def ask(self, user_message, chat_history, context_result=None):
-        """
-        Boucle principale de décision.
-        """
-        system_prompt = self.build_system_prompt()
-        
-        # Construction de l'historique
-        messages = [{"role": "system", "content": system_prompt}]
+        # Stats du graphe
+        graph_context = f"""
+ STATISTIQUES DU GRAPHE :
+- Nœuds totaux : {graph_stats.get('total_nodes', 0)}
+- Relations : {graph_stats.get('total_edges', 0)}
+- Communautés détectées : {graph_stats.get('num_communities', 0)}
+- Nœuds à risque : {graph_stats.get('fraud_nodes', 0)}
+"""
         
-        # On garde les 10 derniers échanges pour le contexte
-        for m in chat_history[-10:]:
-            if m.get("type") == "tool_result" and m != chat_history[-1]: 
-                continue 
+        return f"""
+Tu es JASMINE, Analyste de Données Expert spécialisée en Graphes RDF.
+
+{excel_context}
+{graph_context}
+
+🔧 TES OUTILS DISPONIBLES :
+
+1️⃣ RECHERCHE PAR ID (Optimisé - Utilise-le systématiquement)
+{{"tool": "search_by_id", "args": {{"entity_id": "CLI-2026-0001"}}}}
+→ Retourne TOUTES les propriétés (Ville, Profession, etc.) + Relations
+
+2️⃣ RECHERCHE PAR ATTRIBUT
+{{"tool": "search_by_attribute", "args": {{"attr_name": "Ville", "value": "Paris"}}}}
+→ Trouve toutes les entités avec cet attribut
+
+3️⃣ STATISTIQUES COMMUNAUTÉS (Pré-calculées)
+{{"tool": "get_community_stats", "args": {{}}}}
+→ Liste des secteurs avec tailles et leaders (DÉJÀ CALCULÉ, pas de variation)
+
+4️⃣ DÉTAILS D'UNE COMMUNAUTÉ
+{{"tool": "get_community_details", "args": {{"community_id": 3}}}}
+→ Liste tous les membres d'un secteur spécifique
+
+5️⃣ RAPPORT DE FRAUDE
+{{"tool": "get_fraud_report", "args": {{}}}}
+→ Affiche le tableau complet des anomalies détectées
+
+6️⃣ ZOOM VISUEL
+{{"tool": "highlight_community", "args": {{"target_id": 3}}}}
+{{"tool": "highlight_node", "args": {{"node_id": "Client:CLI-2026-0001"}}}}
+
+7️⃣ CODE PYTHON (Dernier recours uniquement)
+{{"tool": "python_interpreter", "args": {{"code": "..."}}}}
+
+⚠️ RÈGLES STRICTES :
+
+🔒 ACCÈS NetworkX :
+- CORRECT : `G.nodes['Client:CLI-2026-0001']['Ville']`
+- CORRECT : `attrs = G.nodes['Client:CLI-2026-0001']`
+- ❌ FAUX : `noeud[0].get('Ville')` → noeud est une liste d'IDs, pas de dicts !
+
+📋 COLONNES EXCEL (Sensible à la casse) :
+- ✅ 'Ville', 'Profession', 'Nom', 'Date_Naissance'
+- ❌ 'ville', 'profession' n'existent pas
+
+🎯 PRIORITÉ DES OUTILS :
+1. Pour chercher un ID → search_by_id
+2. Pour les communautés → get_community_stats (pas de code)
+3. Pour les fraudes → get_fraud_report
+4. Python → SEULEMENT si aucun outil ne convient
+
+💡 FORMAT DE RÉPONSE :
+- Toujours répondre en langage naturel
+- Utiliser des tableaux Markdown si pertinent
+- Ne jamais demander à l'utilisateur d'exécuter du code
+"""
+
+    def _format_messages_for_groq(self, system_prompt, chat_history, user_message):
+        msgs = [{"role": "system", "content": system_prompt}]
+        for m in chat_history[-8:]:
             role = "assistant" if m["role"] in ["model", "assistant"] else "user"
-            messages.append({"role": role, "content": str(m["content"])})
-            
-        # Injection du résultat technique si disponible
-        if context_result:
-            messages.append({"role": "user", "content": f"RÉSULTAT DE L'OUTIL (Données Réelles) : {context_result}. Maintenant, synthétise une réponse pour l'utilisateur sans mentionner le code technique."})
-        else:
-            messages.append({"role": "user", "content": user_message})
-
-        # Cascade des modèles
-        for model_name in self.MODEL_CASCADE:
-            response_text = self._call_llm(model_name, messages)
-            if response_text:
-                return self._parse_response(response_text)
-        
-        return "⚠️ Service indisponible (Quotas épuisés sur tous les modèles).", None
+            content = str(m.get("content", ""))
+            if content.strip(): msgs.append({"role": role, "content": content})
+        msgs.append({"role": "user", "content": user_message})
+        return msgs
 
-    def _parse_response(self, text):
-        """Nettoie la réponse pour extraire le JSON ou le texte."""
-        clean_text = re.sub(r"```json", "", text, flags=re.IGNORECASE)
-        clean_text = re.sub(r"```", "", clean_text).strip()
+    def _format_messages_for_gemini(self, system_prompt, chat_history, user_message):
+        msgs = [{"role": "user", "parts": [system_prompt]}]
+        for m in chat_history[-8:]:
+            role = "user" if m["role"] == "user" else "model"
+            content = str(m.get("content", ""))
+            if content.strip(): msgs.append({"role": role, "parts": [content]})
+        msgs.append({"role": "user", "parts": [user_message]})
+        return msgs
+
+    def ask(self, user_message, chat_history):
+        system_prompt = self.build_system_prompt()
+        last_error = None
         
-        # Détection JSON pour action
-        if "{" in clean_text and "tool" in clean_text:
+        for model_name in self.MODEL_CASCADE:
             try:
-                start = clean_text.find("{")
-                end = clean_text.rfind("}") + 1
-                json_str = clean_text[start:end]
-                action = json.loads(json_str)
-                return None, action
-            except:
-                pass
-        
-        return text, None
+                response_text = ""
+                if "gemini" in model_name:
+                    if not self.google_key: raise Exception("No Google Key")
+                    formatted_msgs = self._format_messages_for_gemini(system_prompt, chat_history, user_message)
+                    model = genai.GenerativeModel(model_name)
+                    res = model.generate_content(formatted_msgs)
+                    response_text = res.text
+                else:
+                    if not self.groq_client: raise Exception("No Groq Key")
+                    formatted_msgs = self._format_messages_for_groq(system_prompt, chat_history, user_message)
+                    completion = self.groq_client.chat.completions.create(
+                        model=model_name, messages=formatted_msgs, temperature=0.2, stop=None
+                    )
+                    response_text = completion.choices[0].message.content
+
+                # Extraction de l'action JSON
+                clean_text = re.sub(r"```json", "", response_text, flags=re.IGNORECASE)
+                clean_text = re.sub(r"```", "", clean_text).strip()
+                
+                action = None
+                if "{" in clean_text and "}" in clean_text:
+                    try:
+                        json_start = clean_text.find("{")
+                        json_end = clean_text.rfind("}") + 1
+                        json_str = clean_text[json_start:json_end]
+                        action = json.loads(json_str)
+                        # On retire le JSON du texte si présent
+                        clean_text = clean_text[:json_start] + clean_text[json_end:]
+                        clean_text = clean_text.strip()
+                    except: pass
+                
+                return clean_text, action
+
+            except Exception as e:
+                last_error = str(e)
+                continue
+
+        return f"⚠️ ERREUR CASCADE : {last_error}", None