Update src/modules/jasmine_agent.py

src/modules/jasmine_agent.py

@@ -1,7 +1,8 @@
 """
-MODULE JASMINE AGENT - V27 SPARQL EDITION
-=========================================
-L'agent utilise maintenant un vrai raisonnement sémantique et structuré.
+MODULE JASMINE AGENT - V29 DYNAMIC ONTOLOGY
+===========================================
+L'agent lit dynamiquement la structure depuis la feuille Excel 'Ontology'.
+Plus besoin de hardcoder le schéma.
 """
 import google.generativeai as genai
 from groq import Groq
@@ -11,8 +12,12 @@ import os
 import re
 
 class JasmineAgent:
-    def __init__(self, rdf_store):
-        # ... (Config API Keys identique à avant) ...
+    def __init__(self, rdf_store, ontology_rules):
+        """
+        :param rdf_store: L'objet d'accès à la base RDF
+        :param ontology_rules: Liste de dicts représentant la feuille Excel 'Ontology'
+        """
+        # 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"]
@@ -25,51 +30,91 @@ class JasmineAgent:
         self.groq_client = Groq(api_key=self.groq_key) if self.groq_key else None
         
         self.rdf_store = rdf_store
-        self.available_predicates = rdf_store.get_schema() if rdf_store else ""
-
+        self.ontology_rules = ontology_rules
+        
         # 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"
 
+
+
         ]
 
+    def _generate_dynamic_schema_prompt(self):
+        """Transforme les règles Excel en instructions SPARQL claires"""
+        schema_desc = ""
+        relations = []
+        properties = []
+
+        for rule in self.ontology_rules:
+            subject = rule.get('SubjectClass', 'Entity')
+            predicate = rule.get('Predicate', 'unknown')
+            obj = rule.get('ObjectColOrConcept', 'unknown')
+            obj_type = rule.get('ObjectType', 'data_property')
+            
+            # Nettoyage du nom du prédicat (gestion des prefixes)
+            pred_clean = predicate if ":" in predicate else f"vortex:{predicate}"
+
+            if obj_type == 'relation':
+                relations.append(f"- {subject} --[{pred_clean}]--> {obj} (URI)")
+            else:
+                properties.append(f"- {subject} a la propriété '{pred_clean}' ({obj})")
+
+        return f"""
+🗺️ CARTOGRAPHIE DYNAMIQUE (Générée depuis ta feuille Ontology) :
+
+A. RELATIONS (Liens entre entités - URIs) :
+   *(Utilise FILTER(CONTAINS(STR(?o), 'valeur')) pour chercher dedans)*
+{chr(10).join(sorted(relations))}
+
+B. PROPRIÉTÉS (Texte/Nombres - Literals) :
+   *(Utilise FILTER(?o = 'valeur') ou CONTAINS)*
+{chr(10).join(sorted(properties))}
+"""
+
     def build_system_prompt(self):
-        # NOTE : Les doubles accolades {{ }} sont pour le f-string Python
+        dynamic_schema = self._generate_dynamic_schema_prompt()
+        
         return f"""
-Tu es JASMINE, un AGENT DATA INTELLIGENT. Tu interroges un Knowledge Graph via SPARQL.
+Tu es JASMINE, un Agent Data. Tu convertis le Langage Naturel en SPARQL en respectant STRICTEMENT le schéma ci-dessous.
+
+{dynamic_schema}
 
-🗺️ CARTOGRAPHIE DES DONNÉES (RÉALITÉ DU TERRAIN) :
 PREFIX: vortex: <http://vortex.ai/ontology#>
-{self.available_predicates}
 
-⚠️ RÈGLE D'OR SPARQL :
-1. Les prédicats sont EXACTS (sensible à la casse). Si la liste ci-dessus dit `vortex:Ville`, N'UTILISE PAS `vortex:habite`.
-2. Pour les valeurs (Objets), utilise souvent `FILTER(CONTAINS(?variable, "Texte"))` car les URIs peuvent être complexes.
-3. Ne mets pas de guillemets autour des URIs dans le WHERE, sauf si ce sont des chaînes (Literal).
+⚠️ RÈGLES CRITIQUES DE SYNTAXE SPARQL :
+1. **RELATIONS vs PROPRIÉTÉS** :
+   - Regarde la liste ci-dessus. Si c'est une RELATION (URI), tu NE PEUX PAS faire `?s predicate 'String'`.
+   - Tu dois faire : `?s predicate ?o . FILTER(CONTAINS(STR(?o), 'Dakar'))`
+   
+2. **NOMS EXACTS** : N'invente aucun prédicat. Utilise uniquement ceux listés dans la Cartographie (ex: `vortex:habite_ville`, `vortex:secteur_act`).
+
+3. **WORKFLOW** :
+   - Etape 1 : `search_semantic` pour trouver comment s'écrivent les choses (ex: est-ce 'Commercial' ou 'Vente' ?).
+   - Etape 2 : `execute_sparql` pour récupérer les IDs et les infos.
 
 🛠️ TES OUTILS :
 
-1️⃣ 🧠 RECHERCHE SÉMANTIQUE (FAISS)
+1️⃣ 🧠 RECHERCHE SÉMANTIQUE
 {{"tool": "search_semantic", "args": {{"query": "..."}}}}
-→ Pour trouver comment s'écrit une entité (ex: est-ce `vortex:DAKAR` ou `vortex:Ville_Dakar` ?).
 
 2️⃣ ⚡ REQUÊTE SPARQL
-{{"tool": "execute_sparql", "args": {{"query": "SELECT ?s ?p ?o WHERE ..."}}}}
-→ Pour récupérer les données.
-→ ASTUCE : Si tu ne connais pas le prédicat, fais : `SELECT ?p ?o WHERE {{ vortex:ID_TROUVÉ ?p ?o }}` pour inspecter l'entité.
-
-Exemple Workflow Correct :
-User: "Cherche un commercial"
-Toi: {{"tool": "search_semantic", "args": {{"query": "Commercial"}}}}
-[Système: vortex:Metier_Commercial]
-Toi: {{"tool": "execute_sparql", "args": {{"query": "SELECT ?s WHERE {{ ?s vortex:Profession ?o . FILTER(CONTAINS(?o, 'Commercial')) }}"}}}}
+{{"tool": "execute_sparql", "args": {{"query": "SELECT ?nom ?ville WHERE {{ ?s vortex:secteur_act ?secteur . FILTER(CONTAINS(STR(?secteur), 'Commercial')) . ?s vortex:habite_ville ?ville . FILTER(CONTAINS(STR(?ville), 'Dakar')) . ?s vortex:nom ?nom }}"}}}}
 
+⚠️ ACTION UNIQUE : Un seul JSON par réponse. STOP après le JSON.
 """
-
+    
+    # ... (Les méthodes _format_messages_... et ask restent inchangées)
     def _format_messages_for_groq(self, system_prompt, chat_history, user_message):
         msgs = [{"role": "system", "content": system_prompt}]
         for m in chat_history[-8:]:
@@ -123,7 +168,6 @@ Toi: {{"tool": "execute_sparql", "args": {{"query": "SELECT ?s WHERE {{ ?s vorte
                     )
                     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()
                 
@@ -134,7 +178,6 @@ Toi: {{"tool": "execute_sparql", "args": {{"query": "SELECT ?s WHERE {{ ?s vorte
                         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 pour l'affichage
                         clean_text = clean_text[:json_start] + clean_text[json_end:]
                         clean_text = clean_text.strip()
                     except: