termine refactoring v1

README.md

@@ -15,47 +15,44 @@ short_description: Neurosymbolic prototype for automatic semantic discovery
 ![FastAPI](https://img.shields.io/badge/framework-FastAPI-009688)
 ![Streamlit](https://img.shields.io/badge/UI-Streamlit-FF4B4B)
 ![Neo4j](https://img.shields.io/badge/graphdb-Neo4j-green)
-![Status](https://img.shields.io/badge/status-advanced%20prototype-orange)
+![LLM](https://img.shields.io/badge/LLM-Groq%20%7C%20Llama%203-black)
+![Status](https://img.shields.io/badge/status-Phase%201%20Completed-success)
 
-Questo repository contiene un **prototipo avanzato per la scoperta semantica automatica (Automated Semantic Discovery)**. Il sistema agisce come un microservizio finalizzato alla generazione di **ontologie leggere** e **vocabolari semantici** a partire da testo non strutturato, ponendosi come strumento abilitante per l'estrazione dati su larga scala in scenari aziendali e di BPO.
+Questo repository contiene un **prototipo avanzato per la scoperta semantica automatica (Automated Semantic Discovery)**. Il sistema agisce come un microservizio finalizzato alla generazione di **ontologie authoritative** e **Knowledge Graphs** a partire da testo non strutturato. 
 
-Il progetto è progettato con una doppia interfaccia:
-1. **API REST (Headless):** Ideale per l'integrazione asincrona e l'orchestrazione da parte di backend esterni ad alte prestazioni.
-2. **Web UI (Streamlit):** Un'interfaccia interattiva ottimizzata per il deploy su Hugging Face Spaces, perfetta per demo, test curati e visualizzazione topologica.
+Nasce come strumento abilitante per scenari aziendali e di BPO, dove l'estrazione massiva di dati deve coniugarsi con il rigore dei vocabolari semantici formali (es. ArCo, OntoPiA, CIDOC-CRM).
 
-Il progetto implementa una **pipeline neuro-simbolica state-of-the-art** che fonde:
-- La flessibilità semantica dei **Large Language Models (LLM)** e dei **modelli vettoriali** (*Neuro*).
-- Il rigore deterministico della validazione **SHACL**, della risoluzione tramite **Vector Database** e dell'**Entity Linking** (*Symbolic*).
+Il progetto espone una doppia interfaccia:
+1. **API REST (FastAPI):** Ideale per l'integrazione asincrona e l'orchestrazione da parte di backend esterni ad alte prestazioni (es. Go/Java).
+2. **Web UI (Streamlit):** Un'interfaccia interattiva, perfetta per demo, test curati e visualizzazione topologica del grafo.
 
-## Obiettivi del prototipo
+## Il Paradigma Neuro-Simbolico
 
-- Dimostrare la fattibilità di una **pipeline automatizzata e in-memory di Semantic Knowledge Discovery**.
-- Ridurre il *knowledge acquisition bottleneck* ancorando le entità isolate a vocabolari globali (es. Wikidata).
-- Validare un approccio a microservizi (stateless per l'inferenza, stateful per la risoluzione) integrabile nativamente in ecosistemi aziendali eterogenei.
-- Fornire un solido strato di persistenza pronto per alimentare applicazioni di **GraphRAG**.
+Il progetto supera i limiti dei tradizionali sistemi RAG o delle semplici estrazioni LLM implementando una pipeline ibrida:
+- **Neuro (AI Generativa & Vettoriale):** Sfrutta la comprensione del testo dei Large Language Models (tramite Groq/Llama 3) e il clustering semantico basato su embedding spaziali (`sentence-transformers`).
+- **Symbolic (Logica Deterministica):** Applica regole algoritmiche rigide per la validazione ontologica (**SHACL** via `pyshacl`), il Type-Driven Domain Traversal (**TDDT**) e l'Entity Linking formale.
 
-## Workflow Architetturale
+## Workflow Architetturale (Fase 1)
 
-La pipeline elabora i dati esclusivamente in memoria ed è orchestrata in **moduli indipendenti e sequenziali**:
+La pipeline elabora i dati in memoria ed è orchestrata in moduli sequenziali indipendenti:
 
-### 1. Ingestion & Semantic Chunking (`semantic_splitter.py`)
-- Segmentazione del testo basata su **similarità semantica vettoriale** (`sentence-transformers`), garantendo la coerenza tematica dei frammenti elaborati senza scritture su disco.
+### 1. Semantic Chunking (`semantic_splitter.py`)
+Segmentazione dinamica del testo basata su **cosine similarity** vettoriale. L'algoritmo calcola i percentili di distanza per individuare i reali "punti di rottura" argomentativi, garantendo chunk semanticamente coesi.
 
-### 2. Neuro-Symbolic Extraction (`extractor.py`)
-- Architettura **Schema-RAG**: iniezione dinamica nel prompt dell'LLM delle definizioni ontologiche (es. ArCo) più pertinenti al frammento di testo, recuperate tramite vector search.
-- Implementazione di meccanismi di **Graceful Degradation** e fallback semantici per azzerare le allucinazioni ontologiche su entità orfane.
-- Forzatura dell'output in strutture dati tipizzate tramite validazione **Pydantic**.
+### 2. Type-Driven Domain Traversal - TDDT (`extractor.py`)
+Estrazione relazionale a "imbuto" in due passaggi (Pass 1: Macro-Categorizzazione e Specializzazione; Pass 2: Estrazione Relazionale). Il modello linguistico è vincolato tramite *Structured Outputs* (Pydantic JSON Schema) a utilizzare esclusivamente gli URI presenti nel **Domain Index**, azzerando le allucinazioni sui tipi.
 
-### 3. Stateful Entity Resolution & Linking (`entity_resolver.py`)
-- Deduplica locale in RAM tramite clustering spaziale (**DBSCAN** su embedding cosine-similarity).
-- Risoluzione globale interrogando i **Vector Index nativi di Neo4j**.
-- **Entity Linking** asincrono tramite chiamate REST all'API di **Wikidata** per l'ancoraggio semantico (`owl:sameAs`).
+### 3. Hybrid Entity Resolution (`entity_resolver.py`)
+- Deduplica locale in RAM tramite clustering spaziale (**DBSCAN**).
+- Normalizzazione del "Label Bloat" tramite algoritmi di **Majority Voting** sui tipi ontologici.
+- Risoluzione globale sui **Vector Index nativi di Neo4j**.
+- **Entity Linking** asincrono tramite chiamate REST all'API di **Wikidata** per l'ancoraggio a concetti universali (`owl:sameAs`).
 
-### 4. Semantic Validation (`validator.py`)
-- Validazione topologica e qualitativa dei dati estratti applicando vincoli ontologici deterministici (**SHACL**) tramite `pyshacl`, garantendo la coerenza del grafo prima della persistenza.
+### 4. SHACL Blocking & Validation (`validator.py` & `build_schema.py`)
+Costruzione automatica di vincoli SHACL a partire dal dizionario ontologico. Durante l'estrazione, un reasoner OWL RL convalida la conformità (Domain/Range) delle triple. Le triple invalide vengono deviate su una DLQ (Dead Letter Queue) in MongoDB per non corrompere il grafo principale.
 
-### 5. Knowledge Graph Persistence (`graph_loader.py`)
-- Salvataggio massivo e transazionale (`UNWIND` Cypher) su database a grafo **Neo4j**, includendo gli embedding vettoriali per le ricerche future.
+### 5. Graph Persistence (`graph_loader.py`)
+Salvataggio massivo transazionale (`UNWIND` Cypher) su database a grafo **Neo4j**, includendo tracciabilità della fonte (`evidence`, `reasoning`) per garantire la massima *Explainability*.
 
 ## Struttura del repository
 
@@ -65,8 +62,10 @@ prototipo/
 ├── assets/
 │   └── style.css
 │
-├── data/
-│   └── arco_schema.json      # Dizionario ontologico indicizzato per lo Schema-RAG
+├── ontology/
+│   ├── domain_index.json         # Indice gerarchico delle ontologie (JSON)
+│   └── shapes/
+│       └── auto_constraints.ttl  # Regole SHACL autogenerate
 │
 ├── src/
 │   ├── ingestion/
@@ -74,17 +73,16 @@ prototipo/
 │   ├── extraction/
 │   │   └── extractor.py
 │   ├── validation/
-│   │   ├── validator.py
-│   │   └── shapes/
-│   │       └── schema_constraints.ttl  # Regole SHACL
+│   │   └── validator.py
 │   └── graph/
 │       ├── graph_loader.py
 │       └── entity_resolver.py
 │
-├── app.py                  # Entrypoint Web UI (Streamlit / Hugging Face)
+├── app.py                  # Entrypoint Web UI (Streamlit)
 ├── api.py                  # Entrypoint API REST (FastAPI)
-├── Dockerfile              # Configurazione container per HF Spaces
-├── .env.example            # Template per le variabili d'ambiente locali
+├── build_schema.py         # Script per la generazione di index e shapes SHACL
+├── Dockerfile              # Configurazione container
+├── .env.example            
 ├── requirements.txt        
 └── README.md
 ```
@@ -92,19 +90,11 @@ prototipo/
 ## Tech Stack & Requisiti
 
 - **Linguaggio**: Python 3.13
-- **Database**: Neo4j (Consigliato AuraDB cloud per istanze distribuite)
+- **Database**: Neo4j (Graph), MongoDB (DLQ)
 - **Interfacce**: FastAPI, Uvicorn, Streamlit
-
-### Core Libraries
-
-- **Neuro / LLM** 
-  `transformers`, `langchain`, `langchain-huggingface`, `langchain-groq`, `sentence-transformers`
-
-- **Symbolic / Graph** 
-  `neo4j`, `rdflib`, `pyshacl`, `scikit-learn`
-
-- **UI & Viz:**  
-  `streamlit`, `pyvis`, `pandas`
+- **Core Libraries**:
+  - **Neuro** : `langchain`, `langchain-huggingface`, `langchain-groq`, `scikit-learn`
+  - **Symbolic** : `neo4j`, `rdflib`, `pyshacl`, `pydantic`
 
 > Le dipendenze complete sono elencate in `requirements.txt`.
 
@@ -116,15 +106,15 @@ Per testare il sistema in locale, creare un file `.env` a partire dal template:
 NEO4J_URI=neo4j+s://<tuo-cluster>.databases.neo4j.io
 NEO4J_USER=neo4j
 NEO4J_PASSWORD=la_tua_password
-HF_TOKEN=tuo_token_huggingface_opzionale
-GROQ_API_KEY=tua_api_key_groq_opzionale
+MONGO_URI=mongodb://localhost:27017/
+GROQ_API_KEY=tua_api_key_groq
+ONTOLOGY_PATH=./ontology
 ```
-(Nota: Su Hugging Face Spaces, queste variabili vanno configurate nei "Secrets" delle impostazioni).
 
 ## Installazione ed Esecuzione
 
 ```bash
-# 1. Clona il repository e posizionati nella cartella
+# 1. Clona il repository
 git clone [https://github.com/](https://github.com/)<username>/<repository>.git
 cd prototipo
 
@@ -135,10 +125,13 @@ source venv/bin/activate      # Linux / macOS
 
 # 3. Installa le dipendenze
 pip install -r requirements.txt
+
+# 4. Genera gli indici ontologici (una tantum)
+python build_schema.py
 ```
-## Modalità 1: Interfaccia Visuale (Demo / HITL)
+## Modalità 1: Web UI (Streamlit)
 
-Avvia la dashboard per testare visivamente l'estrazione e ispezionare il grafo interattivo:
+Avvia la dashboard interattiva per visualizzare il grafo e testare l'estrazione:
 
 ```bash
 streamlit run app.py
@@ -146,9 +139,9 @@ streamlit run app.py
 
 L'interfaccia sarà disponibile su `http://localhost:8501`.
 
-## Modalità 2: Servizio API (Integrazione Backend)
+## Modalità 2: API REST Headless
 
-Avvia il motore in modalità headless per metterlo in ascolto di payload JSON:
+Avvia il motore in ascolto per l'orchestrazione backend:
 
 ```bash
 python api.py
@@ -170,13 +163,6 @@ Il sistema produce una risposta JSON strutturata contenente:
 - **Rate Limiting Wikidata**: Le chiamate di Entity Linking dipendono dai tempi di risposta dell'API pubblica di Wikidata; per ingestion intensive è consigliato l'uso di cache locali stratificate.
 - **Dipendenza da Vocabolari**: L'accuratezza dell'estrazione semantica tramite Schema-RAG fluttua in base alla ricchezza descrittiva del dizionario JSON ontologico fornito in ingresso.
 
-## Possibili estensioni future
-
-- Disaccoppiamento architetturale: implementazione di un orchestratore ad alte prestazioni (es. in Golang) per gestire code di messaggistica asincrone e chiamare l'API Python solo per l'inferenza pura.
-- Sviluppo di uno strato GraphRAG.
-- Creazione di una dashboard operativa SPA (es. in Angular) connessa direttamente a Neo4j per la validazione Human-in-the-Loop su larga scala nei processi di BPO.
-- Dockerizzazione multi-container per deploy enterprise in ambienti Kubernetes.
-
 ## Riferimenti
 
 **Automated Semantic Discovery – Generazione Neuro-Simbolica di Ontologie Leggere e Vocabolari Semantici**  

app.py

@@ -70,6 +70,24 @@ def get_validator():
         shapes_file="ontology/shapes/auto_constraints.ttl"
     )
 
+COLOR_PALETTE = {
+    "arco_CulturalProperty": "#FF5733", # Arancio
+    "core_Agent": "#33FF57",           # Verde
+    "l0_Location": "#3357FF",          # Blu
+    "l0_Object": "#F333FF",            # Viola
+    "core_EventOrSituation": "#FFD433",# Giallo
+    "clv_City": "#33FFF3",             # Turchese
+    "DEFAULT": "#97C2FC"               # Blu standard
+}
+
+def get_node_color(labels):
+    specific_labels = [l for l in labels if l != 'Resource']
+    if not specific_labels:
+        return COLOR_PALETTE["DEFAULT"]
+    
+    label = specific_labels[0]
+    return COLOR_PALETTE.get(label, COLOR_PALETTE["DEFAULT"])
+
 # Pre-load dei modelli in memoria
 _ = get_splitter()
 _ = get_extractor()
@@ -353,40 +371,112 @@ with tab_vis:
     if driver:
         col_ctrl, col_info = st.columns([1, 4])
         with col_ctrl:
-            physics = st.checkbox("Abilita Fisica (Gravità)", value=True)
             generate_graph = st.button("🔄 Genera / Aggiorna Grafo", type="primary")
         
         if generate_graph:
             with st.spinner("Estrazione dati e generazione del grafo interattivo..."):
                 cypher_vis = """
-                MATCH (s)-[r]->(o) 
-                RETURN COALESCE(s["label"], s["name"], head(labels(s))) as src, 
-                       type(r) as rel, 
-                       COALESCE(o["label"], o["name"], head(labels(o))) as dst 
-                LIMIT 300
+                MATCH (s:Resource)
+                OPTIONAL MATCH (s)-[r]->(o:Resource)
+                RETURN 
+                    s.label AS src, 
+                    labels(s) AS src_labels, 
+                    type(r) AS rel, 
+                    o.label AS dst, 
+                    labels(o) AS dst_labels
                 """
                 graph_data = run_query(driver, cypher_vis)
                 
                 if graph_data:
-                    net = Network(height="600px", width="100%", bgcolor="#222222", font_color="white", notebook=False)
+                    net = Network(height="800px", width="100%", bgcolor="#222222", font_color="white", notebook=False)
+                    
                     for item in graph_data:
-                        src, dst, rel = str(item['src']), str(item['dst']), str(item['rel'])
-                        net.add_node(src, label=src, color="#4facfe", title=src)
-                        net.add_node(dst, label=dst, color="#00f2fe", title=dst)
-                        net.add_edge(src, dst, title=rel, label=rel)
+                        if item['src']:
+                            src_label_text = str(item['src'])
+                            src_color = get_node_color(item['src_labels'])
+                            net.add_node(src_label_text, label=src_label_text, color=src_color, title=f"Labels: {item['src_labels']}")
+                        
+                        if item['dst'] and item['rel']:
+                            dst_label_text = str(item['dst'])
+                            rel_type = str(item['rel'])
+                            dst_color = get_node_color(item['dst_labels'])
+                            
+                            net.add_node(dst_label_text, label=dst_label_text, color=dst_color, title=f"Labels: {item['dst_labels']}")
+                            
+                            net.add_edge(src_label_text, dst_label_text, title=rel_type)
                     
-                    net.toggle_physics(physics)
+                    net.force_atlas_2based(
+                        gravity=-50,
+                        central_gravity=0.01,
+                        spring_length=100,
+                        spring_strength=0.08,
+                        damping=0.4
+                    )
+                    net.toggle_physics(True)
                     
                     with tempfile.NamedTemporaryFile(delete=False, suffix='.html') as tmp:
                         net.save_graph(tmp.name)
                         with open(tmp.name, 'r', encoding='utf-8') as f:
-                            st.session_state.graph_html = f.read()
+                            raw_html = f.read()
+                            
+                            fullscreen_addon = """
+                            <style>
+                                /* Quando l'iframe entra in fullscreen, forziamo il div di Pyvis a coprire l'intero schermo */
+                                :fullscreen #mynetwork { height: 100vh !important; width: 100vw !important; }
+                                :-webkit-full-screen #mynetwork { height: 100vh !important; width: 100vw !important; }
+                                :-moz-full-screen #mynetwork { height: 100vh !important; width: 100vw !important; }
+                                
+                                #fs-btn {
+                                    position: absolute; top: 15px; right: 15px; z-index: 9999;
+                                    width: 40px; height: 40px;
+                                    background-color: rgba(34, 34, 34, 0.7);
+                                    color: #4facfe; border: 1px solid #4facfe; border-radius: 8px;
+                                    cursor: pointer; display: flex; align-items: center; justify-content: center;
+                                    box-shadow: 0 4px 6px rgba(0,0,0,0.3); transition: all 0.2s ease-in-out;
+                                }
+                                #fs-btn:hover { background-color: #4facfe; color: white; }
+                            </style>
+
+                            <button id="fs-btn" onclick="toggleFullScreen()" title="Schermo Intero">
+                                <svg id="fs-icon" xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                                    <path d="M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3"></path>
+                                </svg>
+                            </button>
+
+                            <script>
+                            const iconExpand = '<path d="M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3"></path>';
+                            const iconCompress = '<path d="M8 3v3a2 2 0 0 1-2 2H3m18 0h-3a2 2 0 0 1-2-2V3m0 18v-3a2 2 0 0 1 2-2h3M3 16h3a2 2 0 0 1 2 2v3"></path>';
+                            
+                            function toggleFullScreen() {
+                              if (!document.fullscreenElement) {
+                                  document.documentElement.requestFullscreen().catch(err => console.log(err));
+                              } else {
+                                if (document.exitFullscreen) { document.exitFullscreen(); }
+                              }
+                            }
+
+                            // Ascoltiamo l'evento fullscreen per cambiare l'icona (Espandi/Riduci) anche se l'utente preme "ESC"
+                            document.addEventListener('fullscreenchange', (event) => {
+                                const icon = document.getElementById('fs-icon');
+                                if (document.fullscreenElement) {
+                                    icon.innerHTML = iconCompress;
+                                    document.getElementById('fs-btn').title = "Riduci Schermo";
+                                } else {
+                                    icon.innerHTML = iconExpand;
+                                    document.getElementById('fs-btn').title = "Schermo Intero";
+                                }
+                            });
+                            </script>
+                            </body>
+                            """
+                            
+                            st.session_state.graph_html = raw_html.replace("</body>", fullscreen_addon)
                 else:
                     st.warning("Il grafo è attualmente vuoto.")
                     st.session_state.graph_html = None
 
         if st.session_state.graph_html:
-            components.html(st.session_state.graph_html, height=600, scrolling=True)
+            components.html(st.session_state.graph_html, height=800, scrolling=True)
         else:
             st.info("👆 Clicca su 'Genera / Aggiorna Grafo' per visualizzare i dati attuali di Neo4j.")
             

src/extraction/extractor.py

@@ -145,12 +145,17 @@ class NeuroSymbolicExtractor:
         # ==========================================
         roots_text = "\n".join([f"- {uri} — \"{data['label']}: {data['description']}\"" for uri, data in self.root_classes.items()])
         
-        sys_l1 = f"""Identifica le entità principali nel testo e assegna a ciascuna la macro-categoria più appropriata.
-Puoi assegnare fino a 2 candidati per entità se sei incerto, ordinandoli per confidenza.
+        sys_l1 = f"""Sei un estrattore esperto di entità semantiche per il dominio dei Beni Culturali. Il tuo unico compito è individuare le entità rilevanti nel testo e classificarle.
 
 MACRO-CATEGORIE DISPONIBILI:
-{roots_text}"""
-        
+{roots_text}
+
+REGOLE DI ESTRAZIONE (TASSATIVE E OBBLIGATORIE):
+1. DIVIETO DI ALLUCINAZIONE URI: Usa ESCLUSIVAMENTE gli URI esatti elencati sopra. È severamente vietato usare etichette inventate come "Person", "Location" o "Group". Se devi categorizzare una persona, usa l'URI corrispondente agli Agenti (es. core:Agent o l0:Agent).
+2. RUMORE EDITORIALE: IGNORA e non estrarre MAI riferimenti alla struttura del libro o alle immagini. È vietato estrarre entità che contengono o sono composte da: "Capitolo", "Sezione", "Tavola", "Fig.", "Figura", "Pagina", "Pag.".
+3. Estrai SOLO veri monumenti storici, luoghi geografici reali, personaggi storici, popoli e concetti architettonici.
+4. Puoi assegnare fino a 2 candidati per entità, ordinandoli per confidenza logica.
+"""
         res_l1: MacroClassificationResult = self._execute_with_retry(
             self.chain_pass1_l1, 
             [SystemMessage(content=sys_l1), HumanMessage(content=text_chunk)]
@@ -204,7 +209,7 @@ SOTTO-TIPI DISPONIBILI:
         # PASS 2: Estrazione Relazionale
         # ==========================================
         # Mappa dei tipi finali
-        typed_entities_map = {e.name: e.type for e in res_l2.entities}
+        typed_entities_map = {e.name: e.type.strip() for e in res_l2.entities}
         
         # Recupero deterministico delle proprietà
         valid_properties = []
@@ -228,10 +233,12 @@ PROPRIETÀ CONSENTITE (con vincoli domain → range):
 {props_text}
 - skos:related: Qualsiasi → Qualsiasi (Usa SOLO se nessuna proprietà sopra descrive accuratamente il legame)
 
-REGOLE CRITICHE:
+REGOLE CRITICHE E OBBLIGATORIE:
 1. Usa SOLO le proprietà elencate sopra.
-2. Rispetta rigorosamente i vincoli ontologici: il tipo del 'subject' DEVE essere compatibile con il domain, e il tipo dell''object' con il range.
-3. Compila sempre i campi 'evidence' citando esattamente il testo, e 'reasoning' spiegando la scelta logica.
+2. Usa ESCLUSIVAMENTE le entità presenti nella lista "ENTITÀ IDENTIFICATE". È severamente vietato inventare o aggiungere entità non presenti in questo elenco.
+3. I campi 'subject_type' e 'object_type' sono OBBLIGATORI. Devi sempre compilarli copiando esattamente il tipo indicato tra parentesi nella lista delle entità.
+4. Rispetta rigorosamente i vincoli ontologici: il tipo del 'subject' DEVE essere compatibile con il domain, e il tipo dell''object' con il range.
+5. Compila sempre i campi 'evidence' citando esattamente il testo, e 'reasoning' spiegando la scelta logica.
 """
         
         final_res: KnowledgeGraphExtraction = self._execute_with_retry(

src/graph/entity_resolver.py

@@ -1,5 +1,6 @@
 import numpy as np
 import requests
+from collections import Counter
 from sklearn.cluster import DBSCAN
 from langchain_huggingface import HuggingFaceEmbeddings
 
@@ -48,21 +49,30 @@ class EntityResolver:
             "search": entity_name,
             "language": "it",
             "format": "json",
-            "limit": 1 # Ci serve solo il top-match per fare riconciliazione a tappeto, niente paginazione.
+            "limit": 1
         }
+        
+        headers = {
+            "User-Agent": "ActivaSemanticDiscoveryBot/1.0 (https://activadigital.it; contact@activadigital.it) python-requests"
+        }
+        
         try:
-            # Metto un timeout super restrittivo (3s). Se Wikidata è congestionato, 
-            # preferisco fallire silenziosamente il linking piuttosto che bloccare tutta l'ingestion della pipeline.
-            response = requests.get(url, params=params, timeout=3.0)
+            response = requests.get(url, params=params, headers=headers, timeout=3.0)
+            
             if response.status_code == 200:
                 data = response.json()
                 if data.get("search"):
                     best_match = data["search"][0]
                     return f"wd:{best_match['id']}"
                 else:
-                    print(f"   [DEBUG] Wikidata non ha trovato corrispondenze per: '{entity_name}'")    
+                    print(f"   [DEBUG] Wikidata vuoto per: '{entity_name}'")
+                    pass
+            else:
+                print(f"   ⚠️ Wikidata ha rifiutato la richiesta. Status: {response.status_code}")
+                
         except Exception as e:
             print(f"   ⚠️ Errore lookup Wikidata per '{entity_name}' (ignorato): {e}")
+            
         return None
 
     def resolve_entities(self, extracted_entities, triples):
@@ -142,4 +152,44 @@ class EntityResolver:
 
         resolved_entities = list(set([entity_replacement_map.get(e, e) for e in extracted_entities]))
 
-        return resolved_entities, resolved_triples, entities_to_save
+        resolved_triples = self._normalize_types(resolved_triples)
+
+        return resolved_entities, resolved_triples, entities_to_save
+
+
+    def _normalize_types(self, resolved_triples):
+        print("⚖️ Normalizzazione Ontologica: Avvio Majority Voting per i tipi...")
+        
+        # 1. Raccogliamo i voti: contiamo quante volte ogni tipo viene assegnato a un'entità
+        type_votes = {}
+        
+        for t in resolved_triples:
+            # Conteggio per il subject
+            if t.subject not in type_votes:
+                type_votes[t.subject] = Counter()
+            type_votes[t.subject][t.subject_type] += 1
+            
+            # Conteggio per l'object
+            if t.object not in type_votes:
+                type_votes[t.object] = Counter()
+            type_votes[t.object][t.object_type] += 1
+
+        # 2. Eleggiamo il vincitore: creiamo una mappa definitiva { "Nome Entità": "Tipo Dominante" }
+        canonical_types = {}
+        for entity, counter in type_votes.items():
+            # most_common(1) restituisce una lista di tuple es. [('cis:CreativeWork', 4)]
+            winning_type = counter.most_common(1)[0][0]
+            canonical_types[entity] = winning_type
+            
+            # Opzionale: log se c'è stata una correzione
+            if len(counter) > 1:
+                print(f"   -> Normalizzata '{entity}' a {winning_type} (Scartati: {list(counter.keys())})")
+
+        # 3. Riscriviamo le triple con il tipo vincitore
+        final_triples = []
+        for t in resolved_triples:
+            t.subject_type = canonical_types[t.subject]
+            t.object_type = canonical_types[t.object]
+            final_triples.append(t)
+
+        return final_triples

src/graph/graph_loader.py

@@ -77,7 +77,7 @@ class KnowledgeGraphPersister:
         # Convenzione Neo4j: le relationships sono sempre in UPPERCASE
         return clean.upper() if clean else "RELATED_TO"
 
-    def save_triples(self, triples):
+    def  save_triples(self, triples):
         if not self.driver or not triples:
             return