irrobustimento del processo semantico

api.py

@@ -24,8 +24,8 @@ class DiscoveryRequest(BaseModel):
 # Carico i pesi dei modelli all'avvio del server (Warm-up)
 print("⏳ Inizializzazione modelli (SentenceTransformers e Llama3)...")
 splitter = ActivaSemanticSplitter(model_name="all-MiniLM-L6-v2")
-gold_path = os.path.join("data", "gold_standard", "examples.json")
-extractor = NeuroSymbolicExtractor(model_name="llama3", gold_standard_path=gold_path)
+schema_path = os.path.join("data", "schemas", "ARCO_schema.json")
+extractor = NeuroSymbolicExtractor(model_name="llama3", schema_path=schema_path)
 persister = KnowledgeGraphPersister()
 resolver = EntityResolver(neo4j_driver=persister.driver, similarity_threshold=0.85)
 validator = SemanticValidator()

app.py

@@ -54,8 +54,8 @@ def get_splitter():
 
 @st.cache_resource
 def get_extractor():
-    gold_path = os.path.join("data", "gold_standard", "examples.json")
-    return NeuroSymbolicExtractor(model_name="llama3", gold_standard_path=gold_path)
+    schema_path = os.path.join("data", "schemas", "ARCO_schema.json")
+    return NeuroSymbolicExtractor(model_name="llama3", schema_path=schema_path)
 
 @st.cache_resource(show_spinner="🧩 Inizializzazione Entity Resolver...")
 def get_resolver():

data/schemas/arco_schema.json

@@ -0,0 +1,42 @@
+[
+  {
+    "id": "arco:CulturalProperty",
+    "type": "Class",
+    "description": "Qualsiasi bene culturale, materiale o immateriale. Include monumenti, reperti archeologici, statue, dipinti, edifici storici, strade antiche come la Via Appia."
+  },
+  {
+    "id": "cis:CulturalInstituteOrSite",
+    "type": "Class",
+    "description": "Un istituto o luogo della cultura. Include musei, archivi, biblioteche, parchi archeologici, complessi monumentali."
+  },
+  {
+    "id": "l0:Location",
+    "type": "Class",
+    "description": "Un'entità geografica o amministrativa. Include città, comuni, regioni, nazioni, fiumi, o aree topografiche."
+  },
+  {
+    "id": "core:Event",
+    "type": "Class",
+    "description": "Un evento storico, una battaglia, una mostra, una scoperta archeologica o una campagna di scavo."
+  },
+  {
+    "id": "a-loc:hasCurrentLocation",
+    "type": "Property",
+    "description": "Collega un bene culturale al luogo fisico o all'istituto (es. un museo) in cui è attualmente conservato o esposto."
+  },
+  {
+    "id": "core:hasPart",
+    "type": "Property",
+    "description": "Indica che un'entità contiene o è composta da un'altra entità. Utile per indicare che un museo contiene una collezione, o una città contiene un'area."
+  },
+  {
+    "id": "cis:hasSite",
+    "type": "Property",
+    "description": "Collega un istituto culturale (come un museo) alla sua sede fisica o al comune in cui si trova."
+  },
+  {
+    "id": "ti:atTime",
+    "type": "Property",
+    "description": "Collega un evento, una scoperta o un reperto alla sua epoca, data o periodo storico."
+  }
+]

src/extraction/extractor.py

@@ -17,20 +17,20 @@ load_dotenv() # in locale carica il file .env , su HF non trovando il file utili
 
 # --- DEFINIZIONE DELLO SCHEMA ---
 class GraphTriple(BaseModel):
-    subject: str = Field(..., description="Entità sorgente (Canonical).")
-    predicate: str = Field(..., description="Relazione (snake_case).")
+    subject: str = Field(..., description="Entità sorgente.")
+    predicate: str = Field(..., description="Relazione (es. arco:hasCurrentLocation).")
     object: str = Field(..., description="Entità target.")
     confidence: float = Field(..., description="Confidenza (0.0 - 1.0).")
-    source: Optional[str] = Field(None, description="ID del documento o chunk.")
+    source: Optional[str] = Field(None)
 
 class KnowledgeGraphExtraction(BaseModel):
     reasoning: Optional[str] = Field(None, description="Breve ragionamento logico.")
-    entities: List[str] = Field(default_factory=list, description="Lista di entità rilevanti estratte, incluse quelle senza relazioni.")
+    entities: List[str] = Field(default_factory=list, description="TUTTE le entità estratte, incluse quelle isolate/orfane.")
     triples: List[GraphTriple]
 
-# --- ESTRATTORE DINAMICO (Dynamic Few-Shot) ---
+# --- ESTRATTORE DINAMICO (Schema-RAG) ---
 class NeuroSymbolicExtractor:
-    def __init__(self, model_name="llama3", temperature=0, gold_standard_path=None):
+    def __init__(self, model_name="llama3", temperature=0, schema_path=None):
         
         hf_token = os.getenv("HF_TOKEN")
         groq_api_key=os.getenv("GROQ_API_KEY")
@@ -57,8 +57,7 @@ class NeuroSymbolicExtractor:
             try:
                 self.llm = ChatGroq(
                     temperature=0, 
-                    model="llama-3.1-8b-instant", 
-                    #model="llama-3.3-70b-versatile", #modello più performante, numero di token maggiori ma richiede un credito di utilizzo più elevato
+                    model="llama-3.3-70b-versatile",
                     api_key=os.getenv("GROQ_API_KEY")
                 )
             except Exception as e:
@@ -79,109 +78,88 @@ class NeuroSymbolicExtractor:
         print("🧠 Caricamento modello embedding per Dynamic Selection...")
         self.embedding_model = HuggingFaceEmbeddings(model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
 
-        # Caricamento e Indicizzazione Gold Standard
-        self.examples = []
-        self.example_embeddings = None
+        # Caricamento vocabolario ontologico
+        self.ontology_elements = []
+        self.ontology_embeddings = None
         
-        if gold_standard_path and os.path.exists(gold_standard_path):
-            print(f"🌟 Indicizzazione vettoriale Gold Standard da: {gold_standard_path}")
-            self._index_examples(gold_standard_path)
-        else:
-            # Crea una lista vuota per evitare crash se il path non esiste
-            print("⚠️ Nessun Gold Standard trovato. Modalità Zero-Shot.")
+        if schema_path and os.path.exists(schema_path):
+            print(f"🌟 Indicizzazione vettoriale Ontologia da: {schema_path}")
+            self._index_ontology(schema_path)
 
-        # Template Specializzato (Prompt Engineering)
-        self.system_template_base = """Sei un Agente Cognitivo (AC).
-        Il tuo compito è trasformare il testo non strutturato in un Digital Twin Graph (RDF) conforme allo standard italiano ArCo.
+        # Template Specializzato con regole di Graceful Degradation
+        self.system_template_base = """Sei un Agente Cognitivo per l'estrazione dati (Information Extraction).
+        Il tuo compito è analizzare il testo e generare un JSON contenente entità e relazioni.
+        
+        REGOLE FONDAMENTALI:
+        1. Estrai TUTTI i concetti rilevanti e inseriscili nell'array "entities" (anche se non sai come collegarli).
+        2. Per creare le "triples", puoi usare ESCLUSIVAMENTE le seguenti Classi (per rdf:type) e Proprietà che sono pertinenti a questo testo:
+        
+        CLASSI CONSENTITE (usa come oggetto quando predicate = rdf:type):
+        {retrieved_classes}
+        
+        PROPRIETÀ CONSENTITE (usa come predicate):
+        {retrieved_properties}
         
-        SCHEMA JSON RICHIESTO:
+        REGOLE DI GRACEFUL DEGRADATION E ANTI-ALLUCINAZIONE (CRITICO):
+        - Relazioni (Fallback): Se due entità sono correlate ma nessuna delle proprietà fornite è adatta al contesto esatto, non inventare predicati. Usa il predicato 'skos:related'.
+        - Classificazione (rdf:type): Se non trovi una Classe specifica esatta tra quelle fornite per tipizzare un'entità, NON FORZARE la classificazione in classi errate. Usa i tipi di salvataggio universali: 'core:Agent' per le persone/popoli, 'core:Concept' per concetti astratti/materiali, 'l0:Location' per i luoghi geografici. 
+        - Entità Orfane: Se sei in forte dubbio su come collegare o classificare un'entità testuale, limitati a inserirla nell'array "entities" come orfana senza creare alcuna tripla. Non inquinare il grafo con dati inesatti.
+        
+        Rispondi SOLO ed ESCLUSIVAMENTE con un JSON valido strutturato così:
         {{
-            "reasoning": "Spiega brevemente perché hai scelto queste classi/relazioni...",
-            "entities": ["Nome Entità 1", "Nome Entità 2 Isolata"],
+            "reasoning": "Breve logica delle estrazioni fatte...",
+            "entities": ["Entità 1", "Entità orfana"],
             "triples": [
-                {{"subject": "Entità", "predicate": "prefix:Relazione", "object": "Entità", "confidence": 0.95}}
+                {{"subject": "Entità 1", "predicate": "rdf:type", "object": "Classe Consentita", "confidence": 0.9}},
+                {{"subject": "Entità 1", "predicate": "Proprietà Consentita", "object": "Entità 2", "confidence": 0.8}}
             ]
         }}
-        
-        ONTOLOGIA DI RIFERIMENTO ArCo (Usa rigorosamente questi prefissi):
-        - arco: (Beni Culturali) -> Tipologia del bene (es. arco:HistoricOrArtisticProperty, arco:ArchaeologicalProperty).
-        - cis: (Luoghi della Cultura) -> Musei, siti, parchi (es. cis:CulturalInstituteOrSite, cis:hasSite).
-        - a-loc: (Localizzazione) -> Relazioni spaziali e contenimento (es. a-loc:hasCulturalPropertyAddress, a-loc:isLocatedIn).
-        - ti: (Tempo) -> Datazioni ed epoche (es. ti:hasTimeInterval, ti:atTime).
-        - ro: (Ruoli e Agenti) -> Autori, committenti, scopritori (es. ro:hasRole, ro:isRoleOf).
-        - core: (Core) -> Relazioni di base e tipologie (es. core:hasType, core:hasConcept).
-        
-        ESEMPI CONTESTUALI (Dynamic Few-Shot):
-        {selected_examples}
-        
-        REGOLE DI CONFIDENZA (Trust Layer):
-        - 1.0 (Fatto Curato): Informazione esplicita e certa nel testo.
-        - 0.8 - 0.9 (Inferenza): Deduzione logica forte ma non esplicita.
-        - < 0.7 (Ipotesi): Associazione probabile ma incerta (da marcare per revisione umana).
-
-        VINCOLI SULLE ENTITÀ (CRITICO):
-        - L'array "entities" deve contenere ESCLUSIVAMENTE parole o frasi realmente estratte dal testo sorgente.
-        - È SEVERAMENTE VIETATO inserire i prefissi ontologici (es. arco:, core:, cis:, ro:) o i nomi delle 
-        classi all'interno dell'array "entities". I prefissi vanno utilizzati ESCLUSIVAMENTE come valore del campo "predicate" all'interno delle triple.
-        
-        Canonicalizza i nomi (es. "Il Parco" -> "Parco Archeologico di Canne della Battaglia").
-        Rispondi ESCLUSIVAMENTE con un JSON valido.
         """
 
-    def _index_examples(self, path: str):
-        """Carica il JSON e calcola i vettori per ogni esempio."""
+    def _index_ontology(self, path: str):
         try:
             with open(path, 'r', encoding='utf-8') as f:
-                self.examples = json.load(f)
-            
-            # Estraggo solo il testo di input per calcolare l'embedding
-            texts = [ex['text'] for ex in self.examples]
-            self.example_embeddings = self.embedding_model.embed_documents(texts)
-            print(f"✅ Indicizzati {len(self.examples)} esempi di Gold Standard.")
+                self.ontology_elements = json.load(f)
+            # Vettorizziamo le descrizioni semantiche delle classi/proprietà
+            texts = [el['description'] for el in self.ontology_elements]
+            self.ontology_embeddings = self.embedding_model.embed_documents(texts)
+            print(f"✅ Indicizzati {len(self.ontology_elements)} elementi dell'ontologia.")
         except Exception as e:
-            print(f"❌ Errore indicizzazione Gold Standard: {e}")
-            self.examples = []
+            print(f"❌ Errore indicizzazione Ontologia: {e}")
 
-    def _get_relevant_examples(self, query_text: str, k=2) -> str:
-        """
-        Trova i k esempi più simili semanticamente al chunk attuale.
-        """
-        if not self.examples or self.example_embeddings is None:
-            return "Nessun esempio disponibile."
+    def _retrieve_schema(self, query_text: str, top_k_classes=3, top_k_props=4):
+        if not self.ontology_elements or self.ontology_embeddings is None:
+            return "Nessuna classe specifica.", "skos:related"
 
-        # Embed del chunk attuale
         query_embedding = self.embedding_model.embed_query(query_text)
+        similarities = cosine_similarity([query_embedding], self.ontology_embeddings)[0]
         
-        # Calcolo similarità coseno
-        similarities = cosine_similarity([query_embedding], self.example_embeddings)[0]
+        # Ordiniamo gli indici per similarità
+        sorted_indices = np.argsort(similarities)[::-1]
         
-        # Selezione dei top-k
-        top_k_indices = np.argsort(similarities)[-k:][::-1]
+        classes = []
+        properties = []
         
-        formatted_text = ""
-        for i, idx in enumerate(top_k_indices):
-            ex = self.examples[idx]
-            sim_score = similarities[idx]
-            formatted_text += f"\n--- ESEMPIO RILEVANTE #{i+1} (Sim: {sim_score:.2f}) ---\n"
-            formatted_text += f"INPUT: {ex['text']}\n"
-            
-            output_dict = {
-                "reasoning": ex.get("reasoning", "N/A"),
-                "entities": ex.get("entities", []),
-                "triples": ex.get("triples", [])
-            }
-            formatted_text += f"OUTPUT: {json.dumps(output_dict, ensure_ascii=False)}\n"
-            
-        return formatted_text
+        for idx in sorted_indices:
+            element = self.ontology_elements[idx]
+            if element["type"] == "Class" and len(classes) < top_k_classes:
+                classes.append(f"- {element['id']}: {element['description']}")
+            elif element["type"] == "Property" and len(properties) < top_k_props:
+                properties.append(f"- {element['id']}: {element['description']}")
+                
+        return "\n".join(classes), "\n".join(properties)
 
     def extract(self, text_chunk: str, source_id: str = "unknown", max_retries=3) -> KnowledgeGraphExtraction:
-        print(f"🧠 Processing {source_id} (Dynamic Mode)...")
+        print(f"🧠 Processing {source_id} (Schema-RAG Mode)...")
         
-        # Selezione Esempi
-        relevant_examples_str = self._get_relevant_examples(text_chunk, k=2)
+        # 1. Recupero dinamico dello schema basato sul testo
+        retrieved_classes, retrieved_properties = self._retrieve_schema(text_chunk)
         
-        # Costruzione Prompt Finale
-        final_sys_text = self.system_template_base.format(selected_examples=relevant_examples_str)
+        # 2. Iniezione nel prompt
+        final_sys_text = self.system_template_base.format(
+            retrieved_classes=retrieved_classes,
+            retrieved_properties=retrieved_properties
+        )
         
         sys_msg = SystemMessage(content=final_sys_text)
         
@@ -208,7 +186,6 @@ class NeuroSymbolicExtractor:
                 if not content:
                     raise ValueError("Il modello ha restituito una stringa vuota o un formato non parsabile.")
 
-
                 data = json.loads(content)
                 
                 # Normalizzazione output
@@ -219,7 +196,7 @@ class NeuroSymbolicExtractor:
                     triples = [GraphTriple(**t) for t in data.get("triples", [])]
                     validated_data = KnowledgeGraphExtraction(
                         reasoning=data.get("reasoning", "N/A"),
-                        entities=data.get("entities", []), # 
+                        entities=data.get("entities", []), 
                         triples=triples
                     )
                 

src/utils/build_schema.py

@@ -0,0 +1,121 @@
+import os
+import json
+from pathlib import Path
+from rdflib import Graph
+
+def build_schema_from_ontology(owl_folder_path: str, output_json_path: str):
+    print(f"⏳ Inizializzazione Graph e caricamento file .owl da {owl_folder_path}...")
+    g = Graph()
+    
+    # 1. Caricamento di tutti i moduli dell'ontologia
+    owl_files = list(Path(owl_folder_path).glob('**/*.owl'))
+    if not owl_files:
+        print("❌ Nessun file .owl trovato nella directory specificata.")
+        return
+
+    for file_path in owl_files:
+        try:
+            # I file .owl standard sono scritti in RDF/XML
+            g.parse(file_path, format="xml")
+            print(f"  -> Caricato (XML): {file_path.name}")
+        except Exception as e_xml:
+            try:
+                g.parse(file_path, format="turtle")
+                print(f"  -> Caricato (Turtle): {file_path.name}")
+            except Exception as e_ttl:
+                print(f"  ⚠️ Impossibile parsare {file_path.name}. XML err: {e_xml} | TTL err: {e_ttl}")
+
+
+    print("✅ Ontologia caricata in memoria. Esecuzione query SPARQL...")
+
+    # 2. Query SPARQL per estrarre Classi e ObjectProperties con le loro descrizioni in italiano
+    sparql_query = """
+    PREFIX owl: <http://www.w3.org/2002/07/owl#>
+    PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+
+    SELECT DISTINCT ?entity ?type ?label ?comment
+    WHERE {
+      {
+        ?entity a owl:Class .
+        BIND("Class" AS ?type)
+      } UNION {
+        ?entity a owl:ObjectProperty .
+        BIND("Property" AS ?type)
+      }
+      
+      # Recuperiamo le label in italiano (o senza lingua)
+      OPTIONAL { 
+          ?entity rdfs:label ?label . 
+          FILTER(LANGMATCHES(LANG(?label), "it") || LANG(?label) = "") 
+      }
+      
+      # Recuperiamo i commenti/definizioni in italiano (o senza lingua)
+      OPTIONAL { 
+          ?entity rdfs:comment ?comment . 
+          FILTER(LANGMATCHES(LANG(?comment), "it") || LANG(?comment) = "") 
+      }
+      
+      # Filtriamo per evitare i blank nodes (nodi senza URI)
+      FILTER(isIRI(?entity))
+    }
+    """
+
+    results = g.query(sparql_query)
+    
+    schema_elements = {}
+
+    # 3. Elaborazione e formattazione dei risultati
+    for row in results:
+        entity_uri = row.entity
+        entity_type = str(row.type)
+        label = str(row.label) if row.label else ""
+        comment = str(row.comment) if row.comment else ""
+        
+        # Trasformiamo l'URI lungo in un prefisso leggibile (es. arco:CulturalProperty)
+        try:
+            prefix, namespace, name = g.compute_qname(entity_uri)
+            qname = f"{prefix}:{name}"
+        except Exception:
+            # Fallback se non riesce a calcolare il prefisso
+            qname = str(entity_uri).split('/')[-1].split('#')[-1]
+
+        # Costruiamo la descrizione aggregata per l'LLM
+        description_parts = []
+        if label: description_parts.append(label)
+        if comment: description_parts.append(comment)
+        
+        final_description = " - ".join(description_parts)
+
+        # Se una classe non ha né label né commento, la scartiamo per non confondere l'LLM
+        if not final_description.strip():
+            continue
+
+        # Usiamo un dizionario per evitare duplicati (spesso le ontologie definiscono la stessa classe in più file)
+        if qname not in schema_elements:
+            schema_elements[qname] = {
+                "id": qname,
+                "type": entity_type,
+                "description": final_description.strip()
+            }
+
+    # 4. Salvataggio in JSON
+    output_list = list(schema_elements.values())
+    
+    with open(output_json_path, 'w', encoding='utf-8') as f:
+        json.dump(output_list, f, ensure_ascii=False, indent=2)
+
+    print(f"🎉 Finito! Generato dizionario con {len(output_list)} elementi.")
+    print(f"💾 Salvato in: {output_json_path}")
+
+
+if __name__ == "__main__":
+    # Esempio di utilizzo:
+    # Assicurati di scaricare i file .ttl di ArCo e metterli in una cartella, ad es. 'data/arco_raw/'
+    NOME_ONTOLOGIA = "ARCO"
+    INPUT_FOLDER = f"data/ontologie_raw/{NOME_ONTOLOGIA}" 
+    OUTPUT_FILE = f"data/schemas/{NOME_ONTOLOGIA}_schema.json"
+    
+    # Crea la directory di output se non esiste
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+    
+    build_schema_from_ontology(INPUT_FOLDER, OUTPUT_FILE)

src/validation/shapes/schema_constraints.ttl

@@ -1,37 +1,36 @@
 @prefix sh: <http://www.w3.org/ns/shacl#> .
 @prefix skos: <http://www.w3.org/2004/02/skos/core#> .
 @prefix ex: <http://activa.ai/ontology/> .
+@prefix arco: <https://w3id.org/arco/ontology/arco/> .
 @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
 
-# REGOLA GENERALE PER TUTTI I CONCETTI
-ex:ConceptShape
+# 1. REGOLA BASE: Ogni entità (soggetto o oggetto) deve avere un nome testuale (Label)
+ex:NodeLabelShape
     a sh:NodeShape ;
-    sh:targetClass skos:Concept ;
-    
-    # 1. Obbligo di Label (Accetta qualsiasi Literal con lingua)
+    sh:targetSubjectsOf skos:prefLabel ;
     sh:property [
         sh:path skos:prefLabel ;
         sh:minCount 1 ;
         sh:nodeKind sh:Literal ;
-        sh:message "Ogni concetto deve avere una label."
-    ] ;
+        sh:message "Errore Topologico: Ogni entità nel grafo deve possedere un nome leggibile."
+    ] .
 
-    # 2. Relazione: Related
+# 2. REGOLA RELAZIONALE: Le proprietà non devono puntare a testi (Literal), ma ad altri nodi (IRI)
+ex:ObjectPropertyShape
+    a sh:NodeShape ;
+    sh:targetSubjectsOf skos:prefLabel ; # Si applica a tutti i nodi
     sh:property [
         sh:path skos:related ;
-        sh:class skos:Concept ;
-        sh:message "La relazione 'related' deve puntare a un nodo di tipo Concept."
-    ] ;
-    
-    # 3. Relazione: Situato In
-    sh:property [
-        sh:path ex:situato_in ;
-        sh:class skos:Concept
-    ] ;
-    
-    # 4. Relazione: Broader
+        sh:nodeKind sh:IRI ;
+        sh:message "Errore Semantico (skos:related): Le relazioni generiche devono collegare due nodi distinti, non un nodo a un testo."
+    ] .
+
+# 3. REGOLA ONTOLOGICA: Se un nodo ha un rdf:type, deve essere un IRI (es. arco:CulturalProperty)
+ex:TypeShape
+    a sh:NodeShape ;
+    sh:targetSubjectsOf rdf:type ;
     sh:property [
-        sh:path skos:broader ;
-        sh:class skos:Concept
+        sh:path rdf:type ;
+        sh:nodeKind sh:IRI ;
+        sh:message "Errore Ontologico: La classe assegnata tramite rdf:type deve essere un URI valido dell'ontologia, non una stringa."
     ] .

src/validation/validator.py

@@ -5,11 +5,17 @@ from pyshacl import validate
 
 class SemanticValidator:
     def __init__(self):
-        # Definisco i namespace
-        self.EX = Namespace("http://activa.ai/ontology/")
         self.shapes_file = os.path.join(os.path.dirname(__file__), "shapes/schema_constraints.ttl")
         
-        # Carica le shapes se il file esiste, altrimenti usa grafo vuoto
+        # Dizionario dei Namespace ufficiali di ArCo e fallback
+        self.namespaces = {
+            "arco": Namespace("https://w3id.org/arco/ontology/arco/"),
+            "core": Namespace("https://w3id.org/arco/ontology/core/"),
+            "a-loc": Namespace("https://w3id.org/arco/ontology/location/"),
+            "cis": Namespace("http://dati.beniculturali.it/cis/"),
+            "ex": Namespace("http://activa.ai/ontology/") # Fallback per le entità
+        }
+        
         if os.path.exists(self.shapes_file):
             self.shacl_graph = Graph()
             self.shacl_graph.parse(self.shapes_file, format="turtle")
@@ -18,44 +24,51 @@ class SemanticValidator:
             print("⚠️  File SHACL non trovato. Validazione disabilitata.")
             self.shacl_graph = None
 
+    def _get_uri(self, text_val):
+        """Metodo di supporto per tradurre un testo 'prefisso:nome' in un URIRef reale."""
+        if ":" in text_val and not text_val.startswith("http"):
+            prefix, name = text_val.split(":", 1)
+            if prefix in self.namespaces:
+                return self.namespaces[prefix][name]
+        
+        # Se è un'entità senza prefisso (es. "Menhir di Canne"), uso il namespace custom
+        clean_name = text_val.replace(" ", "_").replace("'", "").replace('"', "")
+        return self.namespaces["ex"][clean_name]
+
     def _json_to_rdf(self, entities, triples):
-        """Converte le triple e le entità isolate in un grafo RDFLib in memoria."""
+        """Converte dinamicamente rispettando l'ontologia ArCo."""
         g = Graph()
+        # Registriamo i prefissi nel grafo per leggibilità
+        for prefix, ns in self.namespaces.items():
+            g.bind(prefix, ns)
         g.bind("skos", SKOS)
-        g.bind("ex", self.EX)
 
-        # Aggiungo le entità isolate come Nodi
+        # 1. Popolamento Entità Isolate (Orfani)
         if entities:
             for ent in entities:
-                # Gestisce sia se 'ent' è una stringa semplice, sia se è un dict (es. da entity_resolver)
                 label = ent["label"] if isinstance(ent, dict) else str(ent)
-                ent_uri = URIRef(self.EX[label.replace(" ", "_")])
-                
-                g.add((ent_uri, RDF.type, SKOS.Concept))
+                ent_uri = self._get_uri(label)
                 g.add((ent_uri, SKOS.prefLabel, Literal(label, lang="it")))
 
-        # Aggiungo le Triple
+        # 2. Popolamento delle Triple
         if triples:
             for t in triples:
-                subj_uri = URIRef(self.EX[t.subject.replace(" ", "_")])
-                obj_uri = URIRef(self.EX[t.object.replace(" ", "_")])
+                subj_uri = self._get_uri(t.subject)
                 
-                # Aggiungo il tipo Concept per soggetto e oggetto
-                g.add((subj_uri, RDF.type, SKOS.Concept))
+                # Assicuriamoci che ogni nodo abbia un nome leggibile
                 g.add((subj_uri, SKOS.prefLabel, Literal(t.subject, lang="it")))
-                
-                g.add((obj_uri, RDF.type, SKOS.Concept))
-                g.add((obj_uri, SKOS.prefLabel, Literal(t.object, lang="it")))
 
-                # Mappo il predicato
-                if t.predicate == "skos:related" or t.predicate == "related":
-                    pred = SKOS.related
-                elif t.predicate == "skos:broader" or t.predicate == "broader":
-                    pred = SKOS.broader
+                if t.predicate in ["rdf:type", "a", "type"]:
+                    # Se l'LLM sta classificando il nodo (es. oggetto = arco:CulturalProperty)
+                    obj_uri = self._get_uri(t.object)
+                    g.add((subj_uri, RDF.type, obj_uri))
                 else:
-                    pred = self.EX[t.predicate]
-
-                g.add((subj_uri, pred, obj_uri))
+                    # Se è una relazione standard (es. a-loc:hasCurrentLocation)
+                    pred_uri = self._get_uri(t.predicate)
+                    obj_uri = self._get_uri(t.object)
+                    
+                    g.add((subj_uri, pred_uri, obj_uri))
+                    g.add((obj_uri, SKOS.prefLabel, Literal(t.object, lang="it")))
             
         return g
 
@@ -67,7 +80,7 @@ class SemanticValidator:
         if not self.shacl_graph:
             return True, "No Constraints", None
 
-        # Passo entrambe le liste al convertitore
+        # Passiamo entrambe le liste al convertitore
         data_graph = self._json_to_rdf(entities, triples)
         
         print("🔍 Esecuzione Validazione SHACL...")