Update src/modules/jasmine_agent.py

src/modules/jasmine_agent.py

@@ -1,184 +1,639 @@
 """
-MODULE JASMINE AGENT - PROFESSIONAL V25
-========================================
+MODULE ONTOLOGY GRAPH - V20 PROFESSIONAL
+=========================================
 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
+✅ Cache déterministe des communautés
+✅ Outils pré-codés performants
+✅ Contexte RAG complet pour l'IA
+✅ Formatage automatique des résultats
+✅ Graphe optimisé pour lisibilité
 """
 
-import google.generativeai as genai
-from groq import Groq
-import json
 import streamlit as st
+import pandas as pd
+import networkx as nx
+from pyvis.network import Network
+import tempfile
+import streamlit.components.v1 as components
+import json
+import sys
 import os
-import re
-
-class JasmineAgent:
-    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
-
-        # Cascade de modèles
-        self.MODEL_CASCADE = [
-            "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):
-        """Système prompt avec RAG complet"""
-        
-        # 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', {})
-        
-        # 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"
-        
-        # 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)}
-"""
-        
-        return f"""
-Tu es JASMINE, Analyste de Données Expert spécialisée en Graphes RDF.
+import time
+import io
+import contextlib
 
-{excel_context}
-{graph_context}
+# --- IMPORTS ---
+try:
+    from src.Algorithms.graph_louvain_pagerank import apply_ai_algorithms
+    from src.Algorithms.Fraud_Detection import detect_fraud_logic
+    from src.modules.jasmine_agent import JasmineAgent
+except ImportError:
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../')))
+    from src.Algorithms.graph_louvain_pagerank import apply_ai_algorithms
+    from src.Algorithms.Fraud_Detection import detect_fraud_logic
+    from src.modules.jasmine_agent import JasmineAgent
 
-🔧 TES OUTILS DISPONIBLES :
+# ==============================================================================
+# 1. OUTILS PRÉ-CODÉS (Plus de recalculs aléatoires)
+# ==============================================================================
 
-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
+def search_by_id(entity_id, G):
+    """Recherche optimisée par ID avec formatage automatique"""
+    # Normalisation de l'ID
+    if ':' not in entity_id:
+        # Recherche partielle
+        matches = [n for n in G.nodes if entity_id.upper() in n.upper()]
+        if not matches:
+            return f"❌ Aucune entité trouvée pour '{entity_id}'"
+        entity_id = matches[0]
+    
+    if entity_id not in G.nodes:
+        return f"❌ L'entité '{entity_id}' n'existe pas dans le graphe"
+    
+    # Récupération des attributs
+    attrs = dict(G.nodes[entity_id])
+    
+    # Formatage en tableau
+    result = f"### 📋 Profil de {attrs.get('label', entity_id)}\n\n"
+    result += "| Propriété | Valeur |\n|-----------|--------|\n"
+    
+    priority_keys = ['label', 'Nom', 'Ville', 'Profession', 'Date_Naissance', 'Montant', 'Statut']
+    displayed = set()
+    
+    for key in priority_keys:
+        if key in attrs and key not in ['group', 'color', 'shape', 'title', 'size']:
+            result += f"| {key} | {attrs[key]} |\n"
+            displayed.add(key)
+    
+    for key, val in attrs.items():
+        if key not in displayed and key not in ['group', 'color', 'shape', 'title', 'size', 'pagerank_score', 'community_id']:
+            result += f"| {key} | {val} |\n"
+    
+    # Relations
+    neighbors = list(G.successors(entity_id))
+    if neighbors:
+        result += f"\n### 🔗 Relations ({len(neighbors)})\n\n"
+        result += "| Type | Entité | Relation |\n|------|--------|----------|\n"
+        for n in neighbors[:10]:
+            edge_data = G[entity_id][n]
+            n_label = G.nodes[n].get('label', n)
+            n_type = G.nodes[n].get('group', 'Inconnu')
+            rel = edge_data.get('label', 'lié_à')
+            result += f"| {n_type} | {n_label} | {rel} |\n"
+    
+    return result
 
-2️⃣ RECHERCHE PAR ATTRIBUT
-{{"tool": "search_by_attribute", "args": {{"attr_name": "Ville", "value": "Paris"}}}}
-→ Trouve toutes les entités avec cet attribut
+def search_by_attribute(attr_name, value, G):
+    """Recherche par attribut (Ville, Profession, etc.)"""
+    matches = []
+    for node, data in G.nodes(data=True):
+        if data.get(attr_name) == value:
+            matches.append((node, data.get('label', node), data.get('group', 'N/A')))
+    
+    if not matches:
+        return f"❌ Aucune entité avec {attr_name}='{value}'"
+    
+    result = f"### 🔍 Entités avec {attr_name} = '{value}' ({len(matches)} résultats)\n\n"
+    result += "| ID | Nom | Type |\n|----|-----|------|\n"
+    for node_id, label, group in matches[:50]:
+        result += f"| {node_id} | {label} | {group} |\n"
+    
+    return result
 
-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)
+def get_community_stats(communities_cache):
+    """Statistiques des communautés (Pré-calculées)"""
+    if not communities_cache:
+        return "❌ Aucune communauté détectée"
+    
+    result = "### 🏘️ Secteurs Détectés (Algorithme Louvain)\n\n"
+    result += "| ID | Nom du Secteur | Membres | Leader (PageRank) |\n"
+    result += "|----|----------------|---------|-------------------|\n"
+    
+    for cid, info in sorted(communities_cache.items(), key=lambda x: x[1]['size'], reverse=True):
+        result += f"| {cid} | {info['alias']} | {info['size']} | {info['leader_name']} |\n"
+    
+    return result
 
-4️⃣ DÉTAILS D'UNE COMMUNAUTÉ
-{{"tool": "get_community_details", "args": {{"community_id": 3}}}}
-→ Liste tous les membres d'un secteur spécifique
+def get_community_details(community_id, G):
+    """Liste tous les membres d'une communauté"""
+    members = [(n, G.nodes[n]) for n in G.nodes if G.nodes[n].get('community_id') == community_id]
+    
+    if not members:
+        return f"❌ Aucun membre dans la communauté {community_id}"
+    
+    result = f"### 👥 Membres du Secteur #{community_id} ({len(members)} personnes)\n\n"
+    result += "| ID | Nom | Type | Influence |\n|----|-----|------|------------|\n"
+    
+    for node_id, data in sorted(members, key=lambda x: x[1].get('pagerank_score', 0), reverse=True)[:30]:
+        label = data.get('label', node_id)
+        group = data.get('group', 'N/A')
+        pr = data.get('pagerank_score', 0)
+        result += f"| {node_id} | {label} | {group} | {pr:.4f} |\n"
+    
+    return result
 
-5️⃣ RAPPORT DE FRAUDE
-{{"tool": "get_fraud_report", "args": {{}}}}
-→ Affiche le tableau complet des anomalies détectées
+def get_fraud_report(df_fraud):
+    """Affiche le rapport de fraude formaté"""
+    if df_fraud.empty:
+        return "✅ Aucune anomalie détectée"
+    
+    result = f"### 🚨 Rapport de Fraude ({len(df_fraud)} anomalies)\n\n"
+    result += df_fraud.to_markdown(index=False)
+    return result
 
-6️⃣ ZOOM VISUEL
-{{"tool": "highlight_community", "args": {{"target_id": 3}}}}
-{{"tool": "highlight_node", "args": {{"node_id": "Client:CLI-2026-0001"}}}}
+# ==============================================================================
+# 2. MOTEUR D'EXÉCUTION + VALIDATION
+# ==============================================================================
 
-7️⃣ CODE PYTHON (Dernier recours uniquement)
-{{"tool": "python_interpreter", "args": {{"code": "..."}}}}
+def validate_code_security(code_str):
+    """Validation de sécurité du code Python"""
+    dangerous_patterns = [
+        'import os', 'import sys', 'import subprocess', 
+        '__import__', 'eval(', 'exec(', 'open(',
+        'st.session_state', 'st.secrets'
+    ]
+    
+    for pattern in dangerous_patterns:
+        if pattern in code_str:
+            return False, f"⚠️ Code interdit : '{pattern}' n'est pas autorisé"
+    
+    return True, "OK"
 
-⚠️ RÈGLES STRICTES :
+def execute_generated_code(code_str, G, df_fraud):
+    """Exécute le code avec validation de sécurité"""
+    # Validation
+    is_safe, msg = validate_code_security(code_str)
+    if not is_safe:
+        return msg
+    
+    output_capture = io.StringIO()
+    local_env = {
+        "G": G,
+        "df_fraud": df_fraud,
+        "nx": nx,
+        "pd": pd,
+        "result": None
+    }
 
-🔒 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 !
+    error_msg = None
+    output = ""
 
-📋 COLONNES EXCEL (Sensible à la casse) :
-- ✅ 'Ville', 'Profession', 'Nom', 'Date_Naissance'
-- ❌ 'ville', 'profession' n'existent pas
+    try:
+        with contextlib.redirect_stdout(output_capture):
+            exec(code_str, {}, local_env)
+        output = output_capture.getvalue()
+    except Exception as e:
+        error_msg = f"ERREUR PYTHON : {type(e).__name__}: {e}"
 
-🎯 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
+    if error_msg:
+        return f"⚠️ {error_msg}"
+    elif output.strip():
+        return f"{output}"
+    else:
+        return "[INFO] Code exécuté sans sortie"
 
-💡 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 execute_agent_tool(tool_name, args, G, df_fraud, communities_cache):
+    """Dispatcher des outils avec formatage automatique"""
+    result_data = ""
+    visual_update = None
+    
+    # === OUTILS PRÉ-CODÉS ===
+    if tool_name == "search_by_id":
+        entity_id = args.get("entity_id", "")
+        result_data = search_by_id(entity_id, G)
+    
+    elif tool_name == "search_by_attribute":
+        attr_name = args.get("attr_name", "")
+        value = args.get("value", "")
+        result_data = search_by_attribute(attr_name, value, G)
+    
+    elif tool_name == "get_community_stats":
+        result_data = get_community_stats(communities_cache)
+    
+    elif tool_name == "get_community_details":
+        community_id = args.get("community_id")
+        result_data = get_community_details(community_id, G)
+    
+    elif tool_name == "get_fraud_report":
+        result_data = get_fraud_report(df_fraud)
+    
+    # === ACTIONS VISUELLES ===
+    elif tool_name == "highlight_community":
+        tid = args.get("target_id")
+        if tid is not None:
+            visual_update = {"action": "highlight_community", "target_id": int(tid)}
+            result_data = f"✅ Zoom visuel activé sur le secteur #{tid}"
+    
+    elif tool_name == "highlight_node":
+        node_id = args.get("node_id", "")
+        if node_id in G.nodes:
+            visual_update = {"action": "highlight_node", "target_id": node_id}
+            result_data = f"✅ Zoom sur {node_id}"
+        else:
+            result_data = f"❌ Nœud '{node_id}' introuvable"
+    
+    elif tool_name == "reset_view":
+        visual_update = {"action": "reset_view"}
+        result_data = "✅ Vue réinitialisée"
+    
+    # === INTERPRÉTEUR PYTHON (Dernier recours) ===
+    elif tool_name == "python_interpreter":
+        code = args.get("code", "")
+        if not code: 
+            result_data = "❌ Code vide"
+        else:
+            result_data = execute_generated_code(code, G, df_fraud)
+    
+    else:
+        result_data = f"❌ Outil inconnu : {tool_name}"
+
+    return result_data, visual_update
 
-    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"
-            content = str(m.get("content", ""))
-            if content.strip(): msgs.append({"role": role, "content": content})
-        msgs.append({"role": "user", "content": user_message})
-        return msgs
-
-    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
+# ==============================================================================
+# 3. STYLE (Inchangé)
+# ==============================================================================
+def apply_gotham_theme():
+    st.markdown("""
+    <style>
+    .stApp { background-color: #0d1117 !important; color: #c9d1d9; }
+    .ontology-title { color: #ffffff !important; font-family: 'Space Grotesk', sans-serif !important; text-transform: uppercase; font-weight: 700; font-size: 1.4rem; margin: 0; padding: 0; letter-spacing: 1.5px; }
+    .aip-card-header { background-color: #21262d; border: 1px solid #30363d; border-bottom: none; border-radius: 6px 6px 0 0; padding: 12px 20px; font-family: 'Space Grotesk', sans-serif; font-size: 0.8rem; font-weight: 600; color: #8b949e; display: flex; justify-content: space-between; align-items: center; letter-spacing: 1px; }
+    [data-testid="stVerticalBlock"] [data-testid="stVerticalBlockBorderWrapper"] > div { background-color: #161b22; border-radius: 0 0 6px 6px !important; border: 1px solid #30363d !important; border-top: none !important; }
+    .user-msg { text-align: right; color: #58a6ff; background: rgba(88, 166, 255, 0.05); border: 1px solid rgba(88, 166, 255, 0.2); padding: 12px; border-radius: 6px; margin-bottom: 10px; font-size: 0.9rem; font-family: 'Inter', sans-serif; }
+    .bot-msg { text-align: left; color: #c9d1d9; background: rgba(48, 54, 61, 0.5); border: 1px solid #30363d; padding: 12px; border-radius: 6px; margin-bottom: 10px; font-size: 0.9rem; font-family: 'Inter', sans-serif; white-space: pre-wrap; }
+    code { color: #e83e8c; background: rgba(255,255,255,0.1); padding: 2px 4px; border-radius: 4px; }
+    pre { background: #0d1117 !important; border: 1px solid #30363d; border-radius: 6px; padding: 10px; }
+    iframe { border: 1px solid #30363d !important; border-radius: 6px; }
+    </style>
+    """, unsafe_allow_html=True)
+
+# ==============================================================================
+# 4. DATA INGESTION (Optimisée avec cache)
+# ==============================================================================
+def get_fixed_colors():
+    return {
+        "Client": "#1E88E5", 
+        "Garant": "#8E44AD", 
+        "Pret": "#F39C12", 
+        "Telephone": "#E74C3C", 
+        "Email": "#D35400", 
+        "Adresse": "#27AE60", 
+        "Transaction": "#00BCD4",
+        "Prop": "#6C757D"
+    }
+
+def get_node_style(entity_type):
+    clean = str(entity_type).strip()
+    fixed = get_fixed_colors()
+    return fixed.get(clean, "#34495E"), "dot"
+
+def safe_open_sheet(client, name):
+    for i in range(5):
+        try: return client.open(name)
+        except: time.sleep(1)
+    return None
+
+def safe_get_records(sh, w_name):
+    for i in range(3):
+        try: return pd.DataFrame(sh.worksheet(w_name).get_all_records())
+        except: time.sleep(1)
+    return pd.DataFrame()
+
+def extract_triplets(ontology_df, client, sheet_name):
+    """Extraction avec cache pour le RAG"""
+    triplets = []
+    sh = safe_open_sheet(client, sheet_name)
+    if not sh: return pd.DataFrame(), {}
+    
+    # 1. Chargement de toutes les feuilles
+    cache = {}
+    sheets_columns = {}  # Pour le RAG
+    
+    for s in ontology_df['Sheet'].unique():
+        df = safe_get_records(sh, s)
+        if not df.empty: 
+            df.columns = df.columns.str.strip()
+            cache[s] = df
+            sheets_columns[s] = df.columns.tolist()
+    
+    # 2. Fusion des données par ID
+    master_data = {}
+    for sheet_name, df in cache.items():
+        id_col = next((c for c in df.columns if any(x in c for x in ['ID_Client', 'ID_Garant', 'ClientID', 'GarantID'])), None)
+        if id_col:
+            for _, row in df.iterrows():
+                uid = str(row[id_col]).strip().upper()
+                if uid not in master_data: master_data[uid] = {}
+                master_data[uid].update({k: v for k, v in row.to_dict().items() if v and str(v).strip()})
+
+    # 3. Création des triplets
+    for _, rule in ontology_df.iterrows():
+        df = cache.get(rule['Sheet'])
+        if df is None or rule['SubjectCol'] not in df.columns: continue
         
-        for model_name in self.MODEL_CASCADE:
-            try:
-                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
+        for _, row in df.iterrows():
+            s_val = str(row.get(rule['SubjectCol'], '')).strip().upper()
+            if not s_val: continue
+            
+            s_id = f"{rule['SubjectClass']}:{s_val}"
+            full_props = master_data.get(s_val, row.to_dict())
+            
+            if rule['ObjectType'] == 'relation':
+                ocol = str(rule['ObjectColOrConcept'])
+                oval = str(row.get(ocol, '')).strip()
+                if oval: 
+                    o_cls = ocol.replace("ID_", "") if "ID_" in ocol and ocol != "ID_Officiel" else "ID_Officiel" if ocol == "ID_Officiel" else ocol
+                    triplets.append({
+                        "subject": s_id, 
+                        "predicate": rule['Predicate'], 
+                        "object": f"{o_cls}:{oval.upper()}", 
+                        "object_type": "entity", 
+                        "subject_props": full_props
+                    })
+            elif rule['ObjectType'] == 'data_property':
+                oval = str(row.get(rule['ObjectColOrConcept'], '')).strip()
+                if oval: 
+                    triplets.append({
+                        "subject": s_id, 
+                        "predicate": rule['Predicate'], 
+                        "object": oval, 
+                        "object_type": "literal", 
+                        "subject_props": full_props
+                    })
+    
+    return pd.DataFrame(triplets), sheets_columns
+
+def build_communities_cache(G):
+    """Construit le cache déterministe des communautés"""
+    communities = {}
+    comm_members = {}
+    
+    # Groupement par communauté
+    for n, d in G.nodes(data=True):
+        cid = d.get('community_id')
+        if cid is not None:
+            if cid not in comm_members:
+                comm_members[cid] = []
+            comm_members[cid].append(n)
+    
+    # Calcul des infos pour chaque communauté
+    for cid, members in comm_members.items():
+        # Leader = plus haut PageRank
+        leader = max(members, key=lambda n: G.nodes[n].get('pagerank_score', 0))
+        leader_name = G.nodes[leader].get('Nom', G.nodes[leader].get('label', leader))
+        
+        # Alias
+        alias = f"Secteur {leader_name}"
+        
+        communities[cid] = {
+            'size': len(members),
+            'leader': leader,
+            'leader_name': leader_name,
+            'alias': alias,
+            'members': members
+        }
+    
+    return communities
+
+def apply_visual_actions(G, action_data):
+    """Application des actions visuelles"""
+    if not action_data: return G
+    action_type = action_data.get("action")
+    
+    if action_type == "highlight_community":
+        target_id = action_data.get("target_id")
+        for node in G.nodes:
+            if G.nodes[node].get('community_id') != target_id:
+                G.nodes[node]['color'] = 'rgba(50, 50, 50, 0.1)'
+                G.nodes[node]['opacity'] = 0.1
+                G.nodes[node]['borderWidth'] = 0
+            else: 
+                G.nodes[node]['borderWidth'] = 4
+    
+    elif action_type == "highlight_node":
+        target_id = action_data.get("target_id")
+        for node in G.nodes:
+            if node != target_id:
+                G.nodes[node]['color'] = 'rgba(50, 50, 50, 0.1)'
+                G.nodes[node]['opacity'] = 0.1
+            else:
+                G.nodes[node]['borderWidth'] = 5
+                G.nodes[node]['size'] = 50
+    
+    elif action_type == "highlight_risk":
+        for node in G.nodes:
+            if G.nodes[node].get('color') != "#FF0000":
+                G.nodes[node]['color'] = 'rgba(50, 50, 50, 0.1)'
+                G.nodes[node]['opacity'] = 0.1
+    
+    return G
+
+# ==============================================================================
+# 5. MAIN ORCHESTRATOR
+# ==============================================================================
+def show_ontology_graph(client, sheet_name):
+    apply_gotham_theme()
+    
+    # API KEYS
+    try:
+        if "GOOGLE_API_KEY" in st.secrets and not os.environ.get("GOOGLE_API_KEY"):
+            os.environ["GOOGLE_API_KEY"] = st.secrets["GOOGLE_API_KEY"]
+        if "GROQ_API_KEY" in st.secrets and not os.environ.get("GROQ_API_KEY"):
+            os.environ["GROQ_API_KEY"] = st.secrets["GROQ_API_KEY"]
+    except: pass
+
+    # Session state
+    if "chat_history" not in st.session_state: 
+        st.session_state["chat_history"] = []
+    if "current_visual_action" not in st.session_state: 
+        st.session_state["current_visual_action"] = None
+    if "jasmine_active" not in st.session_state: 
+        st.session_state["jasmine_active"] = False
+    if "communities_cache" not in st.session_state:
+        st.session_state["communities_cache"] = {}
+
+    # UI
+    c1, c2 = st.columns([5, 1])
+    with c1: 
+        st.markdown('<h1 class="ontology-title">JUMEAU NUMÉRIQUE - VUE OPÉRATIONNELLE</h1>', unsafe_allow_html=True)
+    with c2:
+        if st.toggle("TERMINAL", value=st.session_state["jasmine_active"]): 
+            st.session_state["jasmine_active"] = True
+        else: 
+            st.session_state["jasmine_active"] = False
+
+    # DATA LOADING
+    ontology_df = pd.DataFrame(safe_get_records(safe_open_sheet(client, sheet_name), "Ontology"))
+    if ontology_df.empty: 
+        st.caption("Chargement..."); 
+        return
+    
+    triplets_df, sheets_columns = extract_triplets(ontology_df, client, sheet_name)
+    if triplets_df.empty: 
+        st.error("Aucune donnée."); 
+        return
+
+    # GRAPH BUILD
+    G = nx.DiGraph()
+    for _, r in triplets_df.iterrows():
+        s, p, o = r['subject'], r['predicate'], r['object']
+        if s not in G.nodes:
+            c, sh = get_node_style(s.split(':')[0])
+            props = r.get('subject_props', {})
+            G.add_node(s, label=s.split(':')[1] if ':' in s else s, group=s.split(':')[0], 
+                      color=c, shape=sh, title=str(props), **props)
+        
+        if r['object_type'] == 'entity':
+            if o not in G.nodes:
+                c, sh = get_node_style(o.split(':')[0])
+                G.add_node(o, label=o.split(':')[1] if ':' in o else o, group=o.split(':')[0], 
+                          color=c, shape=sh, title=o)
+            G.add_edge(s, o, label=p)
+        else:
+            pid = f"Prop:{hash(o)%10000}"
+            G.add_node(pid, label=o[:20], group="Prop", color="#6C757D", shape="text", size=12, font={'size': 10})
+            G.add_edge(s, pid, label=p, dashes=True)
+
+    # Algorithmes
+    G, risk_nodes, df_fraud = detect_fraud_logic(G)
+    G, ai_metadata = apply_ai_algorithms(G)
+    
+    # Cache des communautés (une seule fois)
+    if not st.session_state["communities_cache"]:
+        st.session_state["communities_cache"] = build_communities_cache(G)
+    
+    # Contexte pour le RAG
+    data_context = {
+        'sheets_columns': sheets_columns,
+        'graph_stats': {
+            'total_nodes': G.number_of_nodes(),
+            'total_edges': G.number_of_edges(),
+            'num_communities': ai_metadata.get('louvain_communities_count', 0),
+            'fraud_nodes': len(risk_nodes)
+        },
+        'communities_cache': st.session_state["communities_cache"]
+    }
+
+    # === CHAT & EXECUTION ===
+    if st.session_state["jasmine_active"]:
+        col_chat, col_graph = st.columns([2, 3], gap="medium")
+        
+        with col_chat:
+            st.markdown("""<div class="aip-card-header"><span>AIP TERMINAL</span><span style="color:#00E676;">● ONLINE</span></div>""", unsafe_allow_html=True)
+            
+            with st.container(height=700):
+                if not st.session_state["chat_history"]: 
+                    st.markdown('<div class="bot-msg">🟢 Jasmine Core Initialized<br>Type votre requête...</div>', unsafe_allow_html=True)
                 
-                return clean_text, action
+                for msg in st.session_state["chat_history"]:
+                    if msg.get("type") == "tool_result": 
+                        continue
+                    css = "user-msg" if msg["role"] == "user" else "bot-msg"
+                    content = msg["content"].replace("\n", "<br>")
+                    st.markdown(f'<div class="{css}">{content}</div>', unsafe_allow_html=True)
 
-            except Exception as e:
-                last_error = str(e)
-                continue
+            if prompt := st.chat_input("Ordre..."):
+                st.session_state["chat_history"].append({"role": "user", "content": prompt})
+                
+                # Initialisation de l'agent avec contexte
+                agent = JasmineAgent(data_context=data_context)
+                resp_text, tool_action = agent.ask(prompt, st.session_state["chat_history"])
+                
+                # Réponse immédiate de l'IA
+                if resp_text: 
+                    st.session_state["chat_history"].append({"role": "assistant", "content": resp_text})
+                
+                # Exécution de l'outil si demandé
+                if tool_action:
+                    with st.spinner("⚙️ Exécution..."):
+                        exec_result, visual_update = execute_agent_tool(
+                            tool_action.get("tool"), 
+                            tool_action.get("args", {}), 
+                            G, 
+                            df_fraud,
+                            st.session_state["communities_cache"]
+                        )
+                        
+                        # Stockage caché du résultat technique
+                        st.session_state["chat_history"].append({
+                            "role": "user", 
+                            "content": f"[RÉSULTAT OUTIL]\n{exec_result}", 
+                            "type": "tool_result"
+                        })
+                        
+                        if visual_update: 
+                            st.session_state["current_visual_action"] = visual_update
+                        
+                        # L'IA synthétise le résultat
+                        final_resp, _ = agent.ask(
+                            "Synthétise ce résultat en langage naturel pour l'utilisateur.", 
+                            st.session_state["chat_history"]
+                        )
+                        
+                        if final_resp: 
+                            st.session_state["chat_history"].append({"role": "assistant", "content": final_resp})
+                
+                st.rerun()
+    else:
+        col_graph = st.container()
 
-        return f"⚠️ ERREUR CASCADE : {last_error}", None
+    # === GRAPH RENDER (Optimisé) ===
+    with col_graph:
+        if st.session_state["current_visual_action"]: 
+            G = apply_visual_actions(G, st.session_state["current_visual_action"])
+        
+        nt = Network(height="740px", width="100%", bgcolor="#0d1117", font_color="#c9d1d9")
+        nt.from_nx(G)
+        
+        # Options optimisées pour lisibilité
+        options = {
+            "physics": {
+                "forceAtlas2Based": {
+                    "gravitationalConstant": -120,
+                    "centralGravity": 0.015,
+                    "springLength": 250,
+                    "springConstant": 0.05,
+                    "damping": 0.4,
+                    "avoidOverlap": 0.8
+                },
+                "solver": "forceAtlas2Based",
+                "stabilization": {"iterations": 200},
+                "minVelocity": 0.5
+            },
+            "nodes": {
+                "font": {"size": 14, "face": "Inter", "color": "#ffffff"},
+                "borderWidth": 2,
+                "borderWidthSelected": 4
+            },
+            "edges": {
+                "smooth": {"type": "continuous"},
+                "font": {"size": 11, "align": "middle", "color": "#8b949e"},
+                "arrows": {"to": {"enabled": True, "scaleFactor": 0.5}}
+            },
+            "interaction": {
+                "hover": True,
+                "navigationButtons": False,
+                "keyboard": True,
+                "zoomView": True
+            }
+        }
+        
+        nt.set_options(json.dumps(options))
+        path = tempfile.gettempdir() + "/ontology_viz.html"
+        nt.save_graph(path)
+        
+        with open(path, 'r', encoding='utf-8') as f: 
+            html_content = f.read()
+        
+        custom_css = """<style>
+        body { background-color: #0d1117 !important; margin: 0; padding: 0; } 
+        #mynetwork { background-color: #0d1117 !important; width: 100%; height: 740px; }
+        </style>"""
+        html_content = html_content.replace('</head>', f'{custom_css}</head>')
+        
+        components.html(html_content, height=740, scrolling=False)
+        
+        if st.session_state["current_visual_action"]:
+            if st.button("RÉINITIALISER VUE", key="rst_btn"):
+                st.session_state["current_visual_action"] = None
+                st.rerun()