integrata riconciliazione semantica ed estrazione singole entità

.env.example

@@ -0,0 +1,22 @@
+# ==========================================
+# CONFIGURAZIONE AMBIENTE LOCALE
+# ==========================================
+# Copia questo file rinominandolo in ".env" e inserisci i tuoi valori.
+# ATTENZIONE: Non committare MAI il file ".env" nel repository!
+
+# --- Credenziali Backend LLM ---
+# Token per le Inference API di Hugging Face (necessario per Llama 3 / Mistral)
+HF_TOKEN=hf_qui_il_tuo_token_huggingface
+
+# (Opzionale) API Key per Groq, usato come fallback ultra-veloce nell'extractor
+GROQ_API_KEY=gsk_qui_la_tua_api_key_groq
+
+# --- Connessione Knowledge Graph (Neo4j AuraDB o Locale) ---
+# URI di connessione al database (es. neo4j+s://xxxxx.databases.neo4j.io per AuraDB)
+NEO4J_URI=bolt://localhost:7687 
+
+# Utente del database (di default 'neo4j')
+NEO4J_USER=neo4j
+
+# Password del database
+NEO4J_PASSWORD=la_tua_password_super_segreta

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+.env

Dockerfile

@@ -1,32 +1,24 @@
-# Usa un'immagine base di Python
-FROM python:3.10-slim
+FROM python:3.13-slim
 
-# Imposta la workdir
 WORKDIR /app
 
-# Installa le dipendenze di sistema necessarie (es. per pyvis o compilatori)
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-# Copia i requirements e installali
 COPY requirements.txt .
-RUN pip3 install -r requirements.txt
+RUN pip3 install --no-cache-dir -r requirements.txt
 
 RUN python -m nltk.downloader punkt punkt_tab
-
 RUN python -m spacy download it_core_news_sm
 
-# Copia tutto il codice dell'applicazione
 COPY . .
 
-# Espone la porta usata da Hugging Face Spaces (7860)
 EXPOSE 7860
 
-# Healthcheck per monitorare lo stato dello space (corretta porta 7860)
+# Healthcheck per monitorare lo stato dello space
 HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
 
-# Comando di avvio specifico per Streamlit su Docker
 ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -6,62 +6,55 @@ colorFrom: blue
 colorTo: red
 pinned: false
 emoji: 🧠
-short_description: prototipo di sistema per la scoperta semantica automatica
+short_description: Prototipo API neuro-simbolico per la scoperta semantica automatica e Knowledge Graph
 ---
 
 # Automated Semantic Discovery – Prototype
 
-![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![Python](https://img.shields.io/badge/python-3.13-blue)
+![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-research%20prototype-orange)
+![Status](https://img.shields.io/badge/status-advanced%20prototype-orange)
 
-Questo repository contiene un **prototipo di sistema per la scoperta semantica automatica (Automated Semantic Discovery)**, finalizzato alla generazione di **ontologie leggere** e **vocabolari semantici** a partire da **corpora documentali non strutturati**.
+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. 
 
-Il progetto nasce come **proof-of-concept di ricerca** e implementa una **pipeline neuro-simbolica** che integra:
+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.
 
-- la potenza rappresentazionale dei **modelli vettoriali** (*Neuro*);
-- regole di **estrazione ed inferenza NLP** (*Symbolic*).
+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*).
 
 ## Obiettivi del prototipo
 
-Il prototipo ha i seguenti obiettivi principali:
-
-- dimostrare la fattibilità di una **pipeline automatizzata di Semantic Knowledge Discovery**;
-- ridurre il **knowledge acquisition bottleneck** nella costruzione di grafi di conoscenza;
-- validare un **approccio modulare e scalabile** alla scoperta semantica;
-- fornire una **base sperimentale per architetture GraphRAG**.
-
-> Il sistema **non è un prodotto industriale**, ma un **laboratorio sperimentale orientato alla ricerca applicata**.
+- 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**.
 
 ## Workflow Architetturale
 
-<p align="center">
-  <img src="docs/workflow.png" alt="Workflow Architetturale della Pipeline Neuro-Simbolica" width="90%">
-</p>
-
-## Moduli della Pipeline
-
-La pipeline è organizzata in **moduli indipendenti e sequenziali**.
-
-### 1. Ingestion & Pre-processing
+La pipeline elabora i dati esclusivamente in memoria ed è orchestrata in **moduli indipendenti e sequenziali**:
 
-- Caricamento dei documenti testuali.
-- Normalizzazione e pulizia del testo.
+### 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.
 
-### 2. Semantic Chunking (Componente *Neuro*)
+### 2. Neuro-Symbolic Extraction (`extractor.py`)
+- Estrazione dinamica (Dynamic Few-Shot) di entità e relazioni tramite **LLM (Llama 3 / Groq / HF)**.
+- Forzatura dell'output in strutture dati tipizzate tramite validazione **Pydantic**, con recupero di concetti isolati.
 
-- Segmentazione del testo basata su **similarità semantica vettoriale**, non solo sintattica.
-- Utilizzo di **modelli di embedding** per garantire la coerenza tematica dei frammenti.
+### 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. Information Extraction (Componente *Simbolica*)
+### 4. Semantic Validation (`validator.py`)
+- Validazione topologica e qualitativa dei dati estratti applicando vincoli ontologici deterministici (**SHACL**) tramite `pyshacl`.
 
-- Estrazione di **entità (NER)** e **relazioni** tramite analisi delle dipendenze sintattiche.
-- Produzione di **strutture intermedie** sotto forma di **triple concettuali (Soggetto–Predicato–Oggetto)**.
-
-### 4. Knowledge Graph Construction
-
-- Mapping delle triple estratte nel **modello a grafo**.
-- Persistenza su **database a grafo (Neo4j)**.
+### 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.
 
 ## Struttura del repository
 
@@ -69,134 +62,116 @@ La pipeline è organizzata in **moduli indipendenti e sequenziali**.
 prototipo/
 │
 ├── data/
-│   ├── examples/           # Documenti da utilizzare nella demo del prototipo
-│   ├── raw/                # Documenti di input grezzi
-│   ├── processed/          # Output intermedi (chunk, debug JSON)
-│   └── gold_standard/      # Esempi e dati di riferimento
+│   └── gold_standard/      # Esempi (JSON) per il prompt dinamico dell'LLM
 │
 ├── src/
 │   ├── ingestion/
 │   │   └── semantic_splitter.py
 │   ├── extraction/
 │   │   └── extractor.py
+│   ├── validation/
+│   │   ├── validator.py
+│   │   └── shapes/
+│   │       └── schema_constraints.ttl  # Regole SHACL
 │   └── graph/
-│       └── graph_builder.py
+│       ├── graph_loader.py
+│       └── entity_resolver.py
 │
-├── neo4j/                  # Script o Docker Compose per il DB
-├── .env.example            # Template per le variabili d'ambiente
-├── requirements.txt
+├── app.py                  # Entrypoint Web UI (Streamlit / Hugging Face)
+├── api.py                  # Entrypoint API REST (FastAPI)
+├── Dockerfile              # Configurazione container per HF Spaces
+├── .env.example            # Template per le variabili d'ambiente locali
+├── requirements.txt        
 └── README.md
 ```
 
 ## Tech Stack & Requisiti
 
-- **Linguaggio**: Python 3.10+
-- **Database**: Neo4j (Community / Enterprise)
+- **Linguaggio**: Python 3.13
+- **Database**: Neo4j (Consigliato AuraDB cloud per istanze distribuite)
+- **Interfacce**: FastAPI, Uvicorn, Streamlit
 
 ### Core Libraries
 
-- **Neuro / Vectors**  
-  `sentence-transformers`, `scikit-learn`
+- **Neuro / LLM** 
+  `transformers`, `langchain`, `langchain-huggingface`, `langchain-groq`, `sentence-transformers`
 
-- **NLP / Symbolic**  
-  `spacy`, `nltk`
+- **Symbolic / Graph** 
+  `neo4j`, `rdflib`, `pyshacl`, `scikit-learn`
 
-- **Data & Graph**  
-  `pandas`, `neo4j-driver`
+- **UI & Viz:**  
+  `streamlit`, `pyvis`, `pandas`
 
 > Le dipendenze complete sono elencate in `requirements.txt`.
 
-## Configurazione
+## Configurazione Locale
 
-Creare un file `.env` nella root del progetto:
+Per testare il sistema in locale, creare un file `.env` a partire dal template:
 
 ```env
-NEO4J_URI=bolt://localhost:7687
+NEO4J_URI=neo4j+s://<tuo-cluster>.databases.neo4j.io
 NEO4J_USER=neo4j
-NEO4J_PASSWORD=la_tua_password_locale
+NEO4J_PASSWORD=la_tua_password
+HF_TOKEN=tuo_token_huggingface_opzionale
+GROQ_API_KEY=tua_api_key_groq_opzionale
 ```
+(Nota: Su Hugging Face Spaces, queste variabili vanno configurate nei "Secrets" delle impostazioni).
 
-**Nota**: assicurarsi che il file `.env` sia incluso nel `.gitignore`.
-
-## Installazione
+## Installazione ed Esecuzione
 
 ```bash
-git clone https://github.com/<username>/<repository>.git
+# 1. Clona il repository e posizionati nella cartella
+git clone [https://github.com/](https://github.com/)<username>/<repository>.git
 cd prototipo
 
+# 2. Crea l'ambiente virtuale e attivalo
 python -m venv venv
 source venv/bin/activate      # Linux / macOS
-# venv\\Scripts\activate   # Windows
+# venv\Scripts\activate       # Windows
 
+# 3. Installa le dipendenze
 pip install -r requirements.txt
 ```
+## Modalità 1: Interfaccia Visuale (Demo / HITL)
 
-## Utilizzo del prototipo
-
-### 1. Inserimento dei documenti
-
-Copiare i documenti in `data/raw/`.
-
-### 2. Segmentazione semantica
+Avvia la dashboard per testare visivamente l'estrazione e ispezionare il grafo interattivo:
 
 ```bash
-python src/ingestion/semantic_splitter.py
+streamlit run app.py
 ```
 
-### 3. Estrazione di entità e relazioni
+L'interfaccia sarà disponibile su `http://localhost:8501`.
 
-```bash
-python src/extraction/extractor.py
-```
+## Modalità 2: Servizio API (Integrazione Backend)
 
-### 4. Costruzione del Knowledge Graph
+Avvia il motore in modalità headless per metterlo in ascolto di payload JSON:
 
 ```bash
-python src/graph/graph_builder.py
+python api.py
 ```
 
-## Output
-
-Il sistema produce:
-
-- file JSON intermedi per il tracciamento e il debug della pipeline;
-- dati strutturati utilizzabili per validazione manuale o semi-automatica;
-- un Knowledge Graph persistente su Neo4j, interrogabile tramite Cypher.
-
-## Risultati e Validazione Visiva
-
-Questa sezione mostra alcuni output significativi del prototipo, 
-utilizzati per la validazione qualitativa della pipeline di scoperta semantica.
-
-### Validazione delle estrazioni
-
-<p align="center">
-  <img src="docs/validation.png" alt="Validazione delle entità estratte" width="90%">
-</p>
-
-Lo screenshot mostra esempi di entità e relazioni estratte a partire dai chunk semantici,
-utilizzati per verificare la correttezza e la coerenza delle triple generate.
+L'endpoint sarà disponibile su `http://0.0.0.0:5000/api/discover`.
 
-### Visualizzazione del Knowledge Graph
+## Output dell'API
 
-<p align="center">
-  <img src="docs/graph.png" alt="Grafo risultante su Neo4j" width="90%">
-</p>
+Il sistema produce una risposta JSON strutturata contenente:
 
-Il grafo risultante è persistito su Neo4j ed esplorabile tramite Neo4j Browser,
-consentendo l’analisi interattiva delle entità e delle relazioni scoperte.
+- Statistiche di esecuzione (tempo, chunk elaborati).
+- Esito della validazione SHACL.
+- La lista completa delle triple riconciliate e validate.
+- Il feedback di avvenuto inserimento massivo su Neo4j.
 
 ## Limiti noti
 
-- **Scalabilità**: prototipo non ottimizzato per ingestione massiva.
-- **Reasoning**: regole simboliche basate su euristiche, dominio-dipendenti.
-- **LLM**: uso intenzionalmente limitato per privilegiare determinismo e spiegabilità.
+- **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 LLM**: L'accuratezza dell'estrazione (confidence) fluttua in base al modello configurato e necessita di continui affinamenti del file `examples.json` (Gold Standard).
 
 ## Possibili estensioni future
 
-- Integrazione LLM / GraphRAG
-- Supporto RDF / OWL / SHACL
-- Dockerizzazione
+- 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
 

api.py

@@ -0,0 +1,127 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+import os
+import time
+import hashlib
+
+from src.ingestion.semantic_splitter import ActivaSemanticSplitter
+from src.extraction.extractor import NeuroSymbolicExtractor
+from src.validation.validator import SemanticValidator
+from src.graph.graph_loader import KnowledgeGraphPersister
+from src.graph.entity_resolver import EntityResolver
+
+app = FastAPI(
+    title="Automated Semantic Discovery API", 
+    description="Endpoint per l'ingestion testuale e l'estrazione neuro-simbolica",
+    version="1.0"
+)
+
+# Struttura del JSON in ingresso
+class DiscoveryRequest(BaseModel):
+    documentText: str
+
+# 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)
+persister = KnowledgeGraphPersister()
+resolver = EntityResolver(neo4j_driver=persister.driver, similarity_threshold=0.85)
+validator = SemanticValidator()
+print("✅ Modelli caricati e pronti a ricevere richieste!")
+
+# Endpoint principale
+@app.post("/api/discover")
+def run_discovery(payload: DiscoveryRequest):
+    start_time = time.time()
+    raw_text = payload.documentText
+
+    if not raw_text or not raw_text.strip():
+        raise HTTPException(status_code=400, detail="Il testo fornito è vuoto.")
+
+    # --- FASE 1: INGESTION ---
+    chunks, _, _ = splitter.create_chunks(raw_text, percentile_threshold=90)
+    
+    # --- FASE 2: EXTRACTION ---
+    all_triples = []
+    all_entities = []
+    for i, chunk in enumerate(chunks):
+        chunk_id = f"api_req_chunk_{i+1}"
+        extraction_result = extractor.extract(chunk, source_id=chunk_id)
+        
+        if extraction_result:
+            if extraction_result.triples:
+                all_triples.extend(extraction_result.triples)
+            if hasattr(extraction_result, 'entities') and extraction_result.entities:
+                all_entities.extend(extraction_result.entities)
+
+    if not all_triples:
+        return {
+            "status": "success", 
+            "message": "Nessuna entità trovata.", 
+            "graph_data": [] # Restituisco un array vuoto invece di fallire
+        }
+
+    # --- FASE 2.1: SYMBOLIC RESOLUTION ---
+    entities_to_save = []
+    try:
+        all_entities, all_triples, entities_to_save = resolver.resolve_entities(all_entities, all_triples)
+    except Exception as e:
+        print(f"⚠️ Errore nel resolver (skip): {e}")
+
+    # --- FASE 2.2: VALIDATION ---
+    is_valid, report, _ = validator.validate_batch(entities_to_save, all_triples)
+    if not is_valid:
+        print("\n❌ [SHACL VALIDATION FAILED] Rilevate entità o relazioni non conformi all'ontologia:")
+        # Il report di pyshacl contiene già l'elenco esatto dei nodi e delle regole violate
+        print(report)
+        print("-" * 60)
+    else:
+        print("\n✅ [SHACL VALIDATION SUCCESS] Tutte le triple ed entità rispettano i vincoli.")
+
+    # --- FASE 3: PERSISTENCE (Neo4j) ---
+    try:
+        persister.save_entities_and_triples(entities_to_save, all_triples)
+        persister.close()
+    except Exception as e:
+        print(f"⚠️ Errore salvataggio Neo4j: {e}")
+
+    graph_data = []
+    for t in all_triples:
+        subj = getattr(t, 'subject', t[0] if isinstance(t, tuple) else str(t))
+        pred = getattr(t, 'predicate', t[1] if isinstance(t, tuple) else '')
+        obj = getattr(t, 'object', t[2] if isinstance(t, tuple) else '')
+
+        if isinstance(t, tuple) and len(t) > 3:
+            conf = t[3]
+        else:
+            conf = getattr(t, 'confidence', 1.0)
+        
+        subj_str = str(subj)
+        pred_str = str(pred)
+        obj_str = str(obj)
+
+        # Genero un ID univoco ma stabile per il nodo di partenza basato sul suo nome.
+        node_id = hashlib.md5(subj_str.encode('utf-8')).hexdigest()
+
+        graph_data.append({
+            "start_node_id": node_id,
+            "start_node_label": subj_str,
+            "relationship_type": pred_str,
+            "end_node_label": obj_str,
+            "confidence": float(conf)
+        })
+
+    return {
+        "status": "success",
+        "message": "Estrazione semantica completata",
+        "execution_time_seconds": round(time.time() - start_time, 2),
+        "chunks_processed": len(chunks),
+        "triples_extracted": len(graph_data),
+        "shacl_valid": is_valid,
+        "graph_data": graph_data 
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=5000)

app.py

@@ -1,10 +1,7 @@
 import streamlit as st
 import os
-import shutil
-import csv
-import json
+import tempfile
 import pandas as pd
-from datetime import datetime
 from neo4j import GraphDatabase
 from pyvis.network import Network
 import streamlit.components.v1 as components
@@ -13,6 +10,7 @@ from dotenv import load_dotenv
 # --- IMPORT MODULI SPECIFICI ---
 from src.ingestion.semantic_splitter import ActivaSemanticSplitter
 from src.extraction.extractor import NeuroSymbolicExtractor, GraphTriple
+from src.validation.validator import SemanticValidator
 from src.graph.graph_loader import KnowledgeGraphPersister
 from src.graph.entity_resolver import EntityResolver
 
@@ -25,64 +23,60 @@ st.set_page_config(
     page_icon="🧠"
 )
 
-# --- CSS CUSTOM PER UX MIGLIORATA ---
-# Rende le card più leggibili e stilizza i messaggi di stato
-st.markdown("""
-<style>
-    .step-card {
-        padding: 20px;
-        border-radius: 10px;
-        border: 1px solid #e0e0e0;
-        margin-bottom: 20px;
-        background-color: #262730;
-    }
-    .step-header {
-        font-size: 1.2rem;
-        font-weight: bold;
-        margin-bottom: 10px;
-        color: #4facfe;
-    }
-    .success-box {
-        padding: 10px;
-        background-color: rgba(76, 175, 80, 0.1);
-        border-left: 5px solid #4CAF50;
-        border-radius: 5px;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-# --- SESSION STATE MANAGEMENT ---
+def local_css(file_name):
+    with open(file_name, "r") as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+local_css("assets/style.css")
+
+# --- SESSION STATE MANAGEMENT (In-Memory per HF Spaces) ---
 if 'pipeline_stage' not in st.session_state:
-    st.session_state.pipeline_stage = 0  # 0: Init, 1: Chunked, 2: Extracted, 3: Loaded
-if 'current_file' not in st.session_state:
-    st.session_state.current_file = None
+    st.session_state.pipeline_stage = 0  
+if 'document_text' not in st.session_state:
+    st.session_state.document_text = ""
+if 'chunks' not in st.session_state:
+    st.session_state.chunks = []
+if 'extraction_data' not in st.session_state:
+    st.session_state.extraction_data = {"entities": [], "triples": []}
+if 'graph_html' not in st.session_state:
+    st.session_state.graph_html = None
 
 def reset_pipeline():
     st.session_state.pipeline_stage = 0
-    st.session_state.current_file = None
-    # Pulisce i file processati per evitare incongruenze
-    if os.path.exists("data/processed"):
-        shutil.rmtree("data/processed")
-    os.makedirs("data/processed", exist_ok=True)
+    st.session_state.document_text = ""
+    st.session_state.chunks = []
+    st.session_state.extraction_data = {"entities": [], "triples": []}
 
 # --- CACHING RISORSE ---
 @st.cache_resource
 def get_splitter():
-    return ActivaSemanticSplitter()
+    return ActivaSemanticSplitter(model_name="all-MiniLM-L6-v2")
 
 @st.cache_resource
 def get_extractor():
-    return NeuroSymbolicExtractor()
+    gold_path = os.path.join("data", "gold_standard", "examples.json")
+    return NeuroSymbolicExtractor(model_name="llama3", gold_standard_path=gold_path)
 
-@st.cache_resource
+@st.cache_resource(show_spinner="🧩 Inizializzazione Entity Resolver...")
 def get_resolver():
-    return EntityResolver(similarity_threshold=0.85)
+    return EntityResolver(neo4j_driver=None, similarity_threshold=0.85)
+
+@st.cache_resource
+def get_validator():
+    return SemanticValidator()
+
+#carico subito i vari oggetti così da evitare rallentamenti nelle varie fasi della pipeline
+_ = get_splitter()
+_ = get_extractor()
+_ = get_validator()
 
 # --- FUNZIONI NEO4J ---
 def get_driver(uri, user, password):
     if not uri or not password: return None
     try:
-        return GraphDatabase.driver(uri, auth=(user, password))
+        driver = GraphDatabase.driver(uri, auth=(user, password))
+        driver.verify_connectivity()
+        return driver
     except: return None
 
 def run_query(driver, query, params=None):
@@ -94,38 +88,26 @@ def run_query(driver, query, params=None):
 # --- UI: SIDEBAR ---
 st.sidebar.title("⚙️ Configurazione")
 
-# Recuperiamo le variabili d'ambiente (Server Side)
-# NOTA: Queste variabili contengono i veri segreti ma NON vengono passate al frontend
 env_uri = os.getenv("NEO4J_URI", "")
 env_user = os.getenv("NEO4J_USER", "neo4j")
 env_password = os.getenv("NEO4J_PASSWORD", "")
 env_hf_token = os.getenv("HF_TOKEN", "")
 
 st.sidebar.subheader("Backend AI")
-# LOGICA SICURA: Se il token esiste nei secrets, mostriamo solo un badge verde.
-# Non mostriamo mai il token nel campo input (value=...).
 if env_hf_token:
     st.sidebar.success("✅ HF Token: Configurato da Secrets")
-    # Se l'utente vuole sovrascriverlo, può usare questo campo opzionale
     hf_token_input = st.sidebar.text_input("Sovrascrivi Token (Opzionale)", type="password", key="hf_token_override")
-    if hf_token_input:
-        os.environ["HF_TOKEN"] = hf_token_input
+    if hf_token_input: os.environ["HF_TOKEN"] = hf_token_input
 else:
     hf_token_input = st.sidebar.text_input("Inserisci HF Token", type="password")
-    if hf_token_input:
-        os.environ["HF_TOKEN"] = hf_token_input
+    if hf_token_input: os.environ["HF_TOKEN"] = hf_token_input
 
 st.sidebar.subheader("Knowledge Graph")
-# URI e User non sono segreti critici, possiamo mostrarli pre-compilati
 uri = st.sidebar.text_input("URI", value=env_uri)
 user = st.sidebar.text_input("User", value=env_user)
 
-# LOGICA SICURA: Gestione Password
-# Non usiamo 'value=env_password' per evitare che finisca nell'HTML.
-pwd_placeholder = "✅ Configurato da Secrets (Lascia vuoto)" if env_password else "Inserisci Password"
+pwd_placeholder = "✅ Configurato (Lascia vuoto)" if env_password else "Inserisci Password"
 password_input = st.sidebar.text_input("Password", type="password", placeholder=pwd_placeholder)
-
-# Determiniamo quale password usare (Input Utente > Secret Env)
 password = password_input if password_input else env_password
 
 driver = None
@@ -133,7 +115,6 @@ if uri and password:
     driver = get_driver(uri, user, password)
     if driver:
         st.sidebar.success("🟢 Connesso a Neo4j")
-        # Aggiorniamo l'ambiente per i moduli backend che usano os.getenv
         os.environ["NEO4J_URI"] = uri
         os.environ["NEO4J_USER"] = user
         os.environ["NEO4J_PASSWORD"] = password
@@ -146,9 +127,8 @@ if st.sidebar.button("🔄 Reset Pipeline", on_click=reset_pipeline):
 
 # --- MAIN HEADER ---
 st.title("🧠 Automated Semantic Discovery Prototype")
-st.markdown("**Pipeline Sequenziale Neuro-Simbolica**")
+st.markdown("**Endpoint per l'ingestion testuale e l'estrazione neuro-simbolica**")
 
-# --- TAB LOGIC ---
 tab_gen, tab_val, tab_vis = st.tabs([
     "⚙️ 1. Pipeline Generativa", 
     "🔍 2. Validazione (HITL)", 
@@ -159,192 +139,176 @@ tab_gen, tab_val, tab_vis = st.tabs([
 # TAB 1: PIPELINE GENERATIVA (STEPPER UI)
 # ==============================================================================
 with tab_gen:
-    # --- SELEZIONE FILE ---
-    st.subheader("1. Sorgente Documentale")
-    st.info("Seleziona uno degli scenari dimostrativi validati per avviare la pipeline.")
+    st.subheader("1. Ingestion Documentale")
+    st.info("Inserisci il testo da analizzare nel campo sottostante.")
     
-    selected_file = None
-    os.makedirs("data/raw", exist_ok=True)
-    os.makedirs("data/processed", exist_ok=True)
-    os.makedirs("data/examples", exist_ok=True)
-
-    # Logica semplificata: Solo esempi demo
-    files = [f for f in os.listdir("data/examples") if f.endswith(".txt")]
-    if files:
-        choice = st.selectbox("Scenario Disponibile:", files, index=0)
-        if choice:
-            src = os.path.join("data/examples", choice)
-            dst = os.path.join("data/raw", choice)
-            shutil.copy(src, dst)
-            selected_file = choice
-    else:
-        st.warning("⚠️ Nessun file trovato in data/examples. Aggiungi file .txt alla cartella per procedere.")
-
-    # Logica di cambio file: se cambia il file, resetta la pipeline
-    if selected_file and selected_file != st.session_state.current_file:
-        st.session_state.current_file = selected_file
-        st.session_state.pipeline_stage = 0 
-        st.rerun()
-
-    if not selected_file:
-        st.stop()
+    with st.form("ingestion_form"):
+        input_text = st.text_area("Testo del documento:", value=st.session_state.document_text, height=200)
+        submitted = st.form_submit_button("Salva Testo e Prepara Pipeline")
+        
+        if submitted:
+            if input_text != st.session_state.document_text and input_text.strip() != "":
+                st.session_state.document_text = input_text
+                st.session_state.pipeline_stage = 0
+                st.rerun()
 
     st.markdown("---")
-    
-    # --- PROGRESS BAR ---
-    # stage 0 -> 0%, stage 1 -> 33%, stage 2 -> 66%, stage 3 -> 100%
     progress_val = int((st.session_state.pipeline_stage / 3) * 100)
     st.progress(progress_val, text=f"Progresso Pipeline: {progress_val}%")
 
     # ==========================
-    # FASE A: CHUNKING
+    # FASE 1: CHUNKING
     # ==========================
     with st.container():
-        st.markdown(f"### {'✅' if st.session_state.pipeline_stage >= 1 else '1️⃣'} Fase A: Semantic Chunking")
+        st.markdown(f"### {'✅' if st.session_state.pipeline_stage >= 1 else '1️⃣'} Fase 1: Semantic Chunking")
+
+        with st.expander("ℹ️ Cosa fa questa fase?"):
+            st.write("Segmenta il testo in frammenti coerenti analizzando la similarità semantica vettoriale tra le frasi. " \
+            "A differenza di un taglio rigido per numero di parole, questo approccio garantisce che i concetti non vengano interrotti bruscamente, " \
+            "ottimizzando il contesto per l'LLM.")
         
         if st.session_state.pipeline_stage >= 1:
-            # Stato Completato: Mostra riassunto
-            with open("data/processed/chunks.json", "r") as f:
-                chunks = json.load(f)
+            chunks = st.session_state.chunks
             st.markdown(f"""
             <div class="success-box">
-                <b>Chunking completato!</b> Generati {len(chunks)} frammenti semantici.<br>
-                Modello vettoriale utilizzato: <i>MiniLM-L12-v2</i>
+                <b>Chunking completato!</b> Generati {len(chunks)} frammenti semantici.
             </div>
             """, unsafe_allow_html=True)
             with st.expander("Vedi dettagli frammenti"):
-                st.json(chunks[:3]) # Mostra solo i primi 3 per pulizia
+                st.json(chunks) 
         else:
-            # Stato Attivo: Bottone azione
-            st.markdown("Segmentazione del testo basata sulla coerenza semantica vettoriale.")
-            if st.button("Avvia Analisi Semantica", type="primary"):
-                with st.spinner("Calcolo vettori e segmentazione..."):
+            if st.button("Avvia Semantic Splitter", type="primary"):
+                with st.spinner("Creazione chunks in corso..."):
                     try:
-                        with open(os.path.join("data/raw", selected_file), "r", encoding="utf-8") as f:
-                            text_content = f.read()
-                        
                         splitter = get_splitter()
-                        chunks, dists, threshold = splitter.create_chunks(text_content)
-                        
-                        with open("data/processed/chunks.json", "w", encoding="utf-8") as f:
-                            json.dump(chunks, f, ensure_ascii=False, indent=2)
+                        chunks, _, _ = splitter.create_chunks(input_text, percentile_threshold=90)
                         
+                        # Salvataggio in-memory
+                        st.session_state.chunks = chunks
                         st.session_state.pipeline_stage = 1
                         st.rerun()
                     except Exception as e:
-                        st.error(f"Errore: {e}")
+                        st.error(f"Errore durante il chunking: {e}")
 
     st.markdown("⬇️")
 
     # ==========================
-    # FASE B: EXTRACTION
+    # FASE 2: EXTRACTION
     # ==========================
     is_step_b_unlocked = st.session_state.pipeline_stage >= 1
     
     with st.container():
-        # Header grigio se bloccato, bianco (per dark mode) se attivo
         color = "white" if is_step_b_unlocked else "gray"
         icon = "✅" if st.session_state.pipeline_stage >= 2 else ("2️⃣" if is_step_b_unlocked else "🔒")
-        st.markdown(f"<h3 style='color:{color}'>{icon} Fase B: Information Extraction</h3>", unsafe_allow_html=True)
-        
-        if not is_step_b_unlocked:
-            st.caption("Completa la Fase A per sbloccare l'estrazione.")
-        
-        elif st.session_state.pipeline_stage >= 2:
-            # Stato Completato
-            with open("data/processed/triples_raw.json", "r") as f:
-                triples = json.load(f)
-            st.markdown(f"""
-            <div class="success-box">
-                <b>Estrazione completata!</b> Identificate {len(triples)} triple candidate.<br>
-                Motore Neuro-Simbolico: <i>Llama3/Mistral + Dependecy Parsing</i>
-            </div>
-            """, unsafe_allow_html=True)
-            with st.expander("Vedi esempio triple"):
-                st.dataframe(pd.DataFrame(triples).head(5), hide_index=True)
-        else:
-            # Stato Attivo
-            st.markdown("Estrazione di Entità e Relazioni tramite approccio Neuro-Simbolico.")
-            if st.button("Avvia Estrazione Ontologica", type="primary"):
-                with st.spinner("Processando frammenti con LLM..."):
-                    try:
-                        with open("data/processed/chunks.json", "r", encoding="utf-8") as f:
-                            chunks = json.load(f)
-                        
-                        extractor = get_extractor()
-                        all_triples = []
-                        prog_bar = st.progress(0)
-                        
-                        for i, chunk in enumerate(chunks):
-                            res = extractor.extract(chunk, source_id=selected_file)
-                            all_triples.extend([t.model_dump() for t in res.triples])
-                            prog_bar.progress((i+1)/len(chunks))
-                        
-                        with open("data/processed/triples_raw.json", "w", encoding="utf-8") as f:
-                            json.dump(all_triples, f, ensure_ascii=False, indent=2)
-                        
-                        st.session_state.pipeline_stage = 2
-                        st.rerun()
-                    except Exception as e:
-                        st.error(f"Errore: {e}")
+        st.markdown(f"<h3 style='color:{color}'>{icon} Fase 2: Neuro-Symbolic Extraction</h3>", unsafe_allow_html=True)
+
+        with st.expander("ℹ️ Cosa fa questa fase?"):
+            st.write("Invia i frammenti al Large Language Model (es. Llama 3) per estrarre dinamicamente entità e relazioni. " \
+            "L'approccio Neuro-Simbolico forza l'output del modello a rispettare una struttura dati rigorosa (JSON tipizzato) prima di procedere.")
+
+            if not is_step_b_unlocked:
+                st.caption("Completa la Fase 1 per sbloccare l'estrazione.")
+            elif st.session_state.pipeline_stage >= 2:
+                data = st.session_state.extraction_data
+                st.markdown(f"""
+                <div class="success-box">
+                    <b>Estrazione completata!</b> Identificate {len(data['entities'])} entità e {len(data['triples'])} triple.
+                </div>
+                """, unsafe_allow_html=True)
+                with st.expander("Vedi dati estratti"):
+                    st.write("Entità Trovate:", data['entities'])
+                    st.dataframe(pd.DataFrame(data['triples']), hide_index=True)
+            else:
+                if st.button("Avvia Estrazione Ontologica", type="primary"):
+                    with st.spinner("Invocazione modello sui frammenti..."):
+                        try:
+                            chunks = st.session_state.chunks
+                            extractor = get_extractor()
+                            all_triples = []
+                            all_entities = []
+                            prog_bar = st.progress(0)
+                            
+                            for i, chunk in enumerate(chunks):
+                                chunk_id = f"st_req_chunk_{i+1}"
+                                res = extractor.extract(chunk, source_id=chunk_id)
+                                
+                                if res:
+                                    if res.triples: all_triples.extend([t.model_dump() for t in res.triples])
+                                    if res.entities: all_entities.extend(res.entities)
+                                    
+                                prog_bar.progress((i+1)/len(chunks))
+                            
+                            # Salvataggio in-memory
+                            st.session_state.extraction_data = {"entities": all_entities, "triples": all_triples}
+                            st.session_state.pipeline_stage = 2
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"Errore: {e}")
 
     st.markdown("⬇️")
 
     # ==========================
-    # FASE C: GRAPH POPULATION
+    # FASE 3: RESOLUTION & PERSISTENCE
     # ==========================
     is_step_c_unlocked = st.session_state.pipeline_stage >= 2
     
     with st.container():
         color = "white" if is_step_c_unlocked else "gray"
         icon = "✅" if st.session_state.pipeline_stage >= 3 else ("3️⃣" if is_step_c_unlocked else "🔒")
-        st.markdown(f"<h3 style='color:{color}'>{icon} Fase C: Graph Construction</h3>", unsafe_allow_html=True)
+        st.markdown(f"<h3 style='color:{color}'>{icon} Fase 3: Resolution, Validation & Graph Population</h3>", unsafe_allow_html=True)
+
+        with st.expander("ℹ️ Cosa fa questa fase?"):
+            st.write("Unisce ed elimina i duplicati delle entità (Entity Resolution) sfruttando i Vector Index di Neo4j e chiamate esterne. " \
+            "Successivamente, applica regole deterministiche (SHACL) per validare le triple estratte e le salva permanentemente nel database a grafo.")
 
         if not is_step_c_unlocked:
-            st.caption("Completa la Fase B per popolare il grafo.")
-        
+            st.caption("Completa la Fase 2 per procedere.")
         elif st.session_state.pipeline_stage >= 3:
             st.markdown("""
             <div class="success-box">
-                <b>Grafo Aggiornato!</b> I dati sono stati caricati su Neo4j.<br>
-                Puoi esplorarli nei tab "Validazione" e "Visualizzazione".
+                <b>Grafo Aggiornato!</b> I dati sono stati validati e caricati su Neo4j.
             </div>
             """, unsafe_allow_html=True)
-            if st.button("Riavvia con nuovo file"):
-                reset_pipeline()
-                st.rerun()
         else:
-            st.markdown("Entity Resolution (Deduplica) e Caricamento su Neo4j.")
             if not driver:
                 st.error("⚠️ Connettiti a Neo4j (nella sidebar) per procedere.")
             else:
-                if st.button("Genera Knowledge Graph", type="primary"):
-                    with st.spinner("Risoluzione entità e scrittura DB..."):
+                if st.button("Genera e Valida Knowledge Graph", type="primary"):
+                    with st.spinner("Risoluzione entità, validazione SHACL e scrittura..."):
                         try:
-                            with open("data/processed/triples_raw.json", "r", encoding="utf-8") as f:
-                                raw_data = json.load(f)
-                            
-                            triples_objs = [GraphTriple(**t) for t in raw_data]
+                            raw_data = st.session_state.extraction_data
+                            all_entities = raw_data.get("entities", [])
+                            all_triples = [GraphTriple(**t) for t in raw_data.get("triples", [])]
                             
                             resolver = get_resolver()
-                            resolved = resolver.resolve_entities(triples_objs)
+                            resolver.driver = driver
+                            all_entities, all_triples, entities_to_save = resolver.resolve_entities(all_entities, all_triples)
+                            
+                            validator = get_validator()
+                            is_valid, report, _ = validator.validate_batch(entities_to_save, all_triples)
                             
-                            persister = KnowledgeGraphPersister()
-                            persister.save_triples(resolved)
+                            if not is_valid:
+                                st.markdown(f"""
+                                <div class="warning-box">
+                                    <b>Attenzione:</b> La validazione SHACL ha rilevato violazioni. Guarda il log console per i dettagli.
+                                </div>
+                                """, unsafe_allow_html=True)
+                            
+                            persister = KnowledgeGraphPersister() 
+                            persister.save_entities_and_triples(entities_to_save, all_triples)
                             persister.close()
                             
                             st.session_state.pipeline_stage = 3
                             st.rerun()
                         except Exception as e:
-                            st.error(f"Errore: {e}")
+                            st.error(f"Errore critico: {e}")
 
 # ==============================================================================
-# TAB 2: VALIDAZIONE (Codice invariato, solo stile)
+# TAB 2 & 3: VALIDAZIONE E VISUALIZZAZIONE
 # ==============================================================================
 with tab_val:
     st.header("Curation & Feedback Loop")
     if driver:
-        # Recupera statistiche rapide
         stats = run_query(driver, "MATCH (n) RETURN count(n) as nodes, count{()-->()} as rels")
         if stats:
             c1, c2 = st.columns(2)
@@ -357,58 +321,59 @@ with tab_val:
                COALESCE(s.label, s.name, head(labels(s))) as Soggetto, 
                type(r) as Predicato, 
                COALESCE(o.label, o.name, head(labels(o))) as Oggetto, 
-               COALESCE(r.confidence, 0.85) as Confidenza
-        ORDER BY Confidenza ASC LIMIT 50
+               COALESCE(r.confidence, 1.0) as Confidenza
+        ORDER BY Confidenza ASC
         """
         triples_data = run_query(driver, cypher_val)
         
         if triples_data:
             df = pd.DataFrame(triples_data)
-            st.dataframe(df.drop(columns=["id"]), use_container_width=True, hide_index=True)
+            st.dataframe(df.drop(columns=["id"]), width='stretch', hide_index=True)
         else:
             st.info("Grafo vuoto.")
     else:
         st.warning("Database non connesso.")
 
-# ==============================================================================
-# TAB 3: VISUALIZZAZIONE
-# ==============================================================================
 with tab_vis:
     st.header("Esplorazione Topologica")
     if driver:
         col_ctrl, col_info = st.columns([1, 4])
         with col_ctrl:
             physics = st.checkbox("Abilita Fisica (Gravità)", value=True)
-            if st.button("🔄 Ricarica Dati"):
-                st.rerun()
+            generate_graph = st.button("🔄 Genera / Aggiorna Grafo", type="primary")
         
-        # Logica di visualizzazione automatica (non dipendente da un bottone)
-        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 100
-        """
-        graph_data = run_query(driver, cypher_vis)
-        
-        if graph_data:
-            net = Network(height="600px", 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)
-            
-            net.toggle_physics(physics)
-            path = "data/processed/graph_viz.html"
-            os.makedirs("data/processed", exist_ok=True)
-            net.save_graph(path)
-            
-            with open(path, 'r', encoding='utf-8') as f:
-                html_string = f.read()
-            components.html(html_string, height=600, scrolling=True)
+        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 
+                """
+                graph_data = run_query(driver, cypher_vis)
+                
+                if graph_data:
+                    net = Network(height="600px", 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)
+                    
+                    net.toggle_physics(physics)
+                    
+                    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()
+                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)
         else:
-            st.info("Il grafo è attualmente vuoto o non raggiungibile.")
+            st.info("👆 Clicca su 'Genera / Aggiorna Grafo' per visualizzare i dati attuali di Neo4j.")
+            
     else:
         st.warning("Database non connesso. Configura le credenziali nella sidebar.")

app/ui.py

@@ -1,161 +0,0 @@
-import streamlit as st
-from neo4j import GraphDatabase
-import pandas as pd
-from pyvis.network import Network
-import streamlit.components.v1 as components
-import os
-import csv
-from datetime import datetime
-from dotenv import load_dotenv
-
-# --- CONFIGURAZIONE ---
-
-# Carica variabili d'ambiente
-load_dotenv()
-
-st.set_page_config(page_title="Activa Semantic Discovery", layout="wide")
-# Usa le variabili d'ambiente (con fallback per sicurezza locale)
-URI = os.getenv("NEO4J_URI", "neo4j+s://99ed65ab.databases.neo4j.io")
-USER = os.getenv("NEO4J_USER", "99ed65ab")
-PASSWORD = os.getenv("NEO4J_PASSWORD", "4z86xz3Zwd5D7nt_lqIgE5O1NPmghKfoad6q_lL2YGs")
-AUTH = (USER, PASSWORD)
-
-# --- CONNESSIONE NEO4J ---
-@st.cache_resource
-def get_driver():
-    return GraphDatabase.driver(URI, auth=AUTH)
-
-def run_query(query, params=None):
-    driver = get_driver()
-    with driver.session() as session:
-        result = session.run(query, params)
-        return [r.data() for r in result]
-
-# --- LOGICA CORE: FEEDBACK LOOP (Nuova Funzionalità) ---
-def reject_relationship(rel_id, subj, pred, obj, reason="Human Rejection"):
-    """
-    1. Cancella dal DB (Azione Reale).
-    2. Salva in CSV per Active Learning (Data Lineage del rifiuto).
-    """
-    # 1. Cancellazione Reale
-    query = "MATCH ()-[r]->() WHERE elementId(r) = $id DELETE r"
-    try:
-        run_query(query, {"id": rel_id})
-    except Exception as e:
-        st.error(f"Errore durante la cancellazione: {e}")
-        return False
-    
-    # 2. Logging per Fine-Tuning
-    log_file = "rejected_triples.csv"
-    file_exists = os.path.isfile(log_file)
-    
-    try:
-        with open(log_file, mode='a', newline='', encoding='utf-8') as f:
-            writer = csv.writer(f)
-            if not file_exists:
-                writer.writerow(["timestamp", "subject", "predicate", "object", "reason"])
-            writer.writerow([datetime.now(), subj, pred, obj, reason])
-        return True
-    except Exception as e:
-        st.warning(f"Relazione cancellata dal DB, ma errore nel log CSV: {e}")
-        return True
-
-# --- UI: HEADER ---
-st.title("🧠 Automated Semantic Discovery | Lab")
-st.markdown("""
-**Piattaforma Human-in-the-Loop** per la validazione delle ontologie generate.
-Vedi Sezione 5.2.4 della Relazione Tecnica.
-""")
-
-# --- UI: KPI METRICS (Mantenuti dalla versione vecchia perché più completi) ---
-col1, col2, col3 = st.columns(3)
-try:
-    node_count = run_query("MATCH (n) RETURN count(n) as count")[0]['count']
-    rel_count = run_query("MATCH ()-[r]->() RETURN count(r) as count")[0]['count']
-    concept_count = run_query("MATCH (n:Resource) RETURN count(n) as count")[0]['count']
-    
-    col1.metric("Nodi Totali", node_count)
-    col2.metric("Relazioni Attive", rel_count)
-    col3.metric("Concetti Semantici", concept_count)
-except Exception as e:
-    st.error(f"Errore connessione Neo4j: {e}")
-    st.stop()
-
-# --- UI: TAB DI NAVIGAZIONE ---
-tab1, tab2 = st.tabs(["🔍 Validazione (Active Learning)", "🕸️ Visualizzazione Grafo"])
-
-# --- TAB 1: CURATION TABLE (Aggiornato con Lineage e Delete Reale) ---
-with tab1:
-    st.subheader("Curation & Feedback Loop")
-    st.info("Qui l'esperto valida le ipotesi dell'IA. Le cancellazioni addestrano il modello futuro.")
-    
-    # Query aggiornata: Recupera anche 'r.source' (Lineage)
-    triples_data = run_query("""
-        MATCH (s)-[r]->(o) 
-        RETURN elementId(r) as id, s.label as Soggetto, type(r) as Predicato, o.label as Oggetto, r.confidence as Confidenza, r.source as Fonte
-        ORDER BY r.confidence ASC LIMIT 50
-    """)
-    
-    if triples_data:
-        df = pd.DataFrame(triples_data)
-        
-        # Selezione Riga
-        selection = st.dataframe(
-            df.drop(columns=["id"]),
-            width='stretch',
-            hide_index=True,
-            selection_mode="single-row",
-            on_select="rerun"
-        )
-        
-        # Azione di Reject
-        if selection.selection.rows:
-            idx = selection.selection.rows[0]
-            row = df.iloc[idx]
-            
-            st.error(f"Stai per rifiutare: **{row['Soggetto']}** --[{row['Predicato']}]--> **{row['Oggetto']}**")
-            
-            if st.button("🗑️ CONFERMA RIFIUTO (Training Feedback)", type="primary"):
-                success = reject_relationship(row['id'], row['Soggetto'], row['Predicato'], row['Oggetto'])
-                if success:
-                    st.success("Relazione eliminata e loggata per il ri-addestramento!")
-                    st.rerun()
-    else:
-        st.info("Nessuna relazione da validare o DB vuoto.")
-
-# --- TAB 2: GRAPH VISUALIZATION (Mantenuto dalla versione vecchia per la Fisica) ---
-with tab2:
-    st.subheader("Esplorazione Topologica")
-    
-    # Manteniamo la checkbox della fisica (utile per grafi grandi)
-    physics = st.checkbox("Abilita Fisica (Gravità)", value=True)
-    
-    net = Network(height="600px", width="100%", bgcolor="#222222", font_color="white", notebook=False)
-    
-    # Carichiamo i dati (Max 100 relazioni)
-    graph_data = run_query("MATCH (s)-[r]->(o) RETURN s.label as src, type(r) as rel, o.label as dst LIMIT 100")
-    
-    if graph_data:
-        for item in graph_data:
-            # Colori personalizzati come nel vecchio file
-            net.add_node(item['src'], label=item['src'], color="#4facfe") 
-            net.add_node(item['dst'], label=item['dst'], color="#00f2fe")
-            net.add_edge(item['src'], item['dst'], title=item['rel'], label=item['rel'])
-        
-        # Applichiamo la fisica se selezionata
-        net.toggle_physics(physics)
-        
-        try:
-            path = "tmp_graph.html"
-            net.save_graph(path)
-            with open(path, 'r', encoding='utf-8') as f:
-                html_string = f.read()
-            components.html(html_string, height=600, scrolling=True)
-        except Exception as e:
-            st.error(f"Errore generazione grafo: {e}")
-    else:
-        st.write("Grafo vuoto.")
-
-# Footer
-st.markdown("---")
-st.caption("Activa Digital | Next Gen Tech | Prototipo v0.2 (Feedback Loop Enabled)")

assets/style.css

@@ -0,0 +1,61 @@
+.step-card { 
+    padding: 20px; 
+    border-radius: 10px; 
+    border: 1px solid #e0e0e0; 
+    margin-bottom: 20px; 
+    background-color: #262730; 
+}
+
+.step-header { 
+    font-size: 1.2rem; 
+    font-weight: bold; 
+    margin-bottom: 10px; 
+    color: #4facfe; 
+}
+
+.success-box { 
+    padding: 10px; 
+    background-color: rgba(76, 175, 80, 0.1); 
+    border-left: 5px solid #4CAF50; 
+    border-radius: 5px; 
+}
+
+.warning-box { 
+    padding: 10px; 
+    background-color: rgba(255, 152, 0, 0.1); 
+    border-left: 5px solid #FF9800; 
+    border-radius: 5px; 
+    margin-top: 10px;
+}
+
+[data-testid="stExpander"] {
+    background-color: rgba(38, 39, 48, 0.4); 
+    border: 1px solid rgba(79, 172, 254, 0.3); 
+    border-radius: 8px;
+    transition: border 0.3s ease, background-color 0.3s ease;
+    margin-top: 5px;
+    margin-bottom: 15px;
+}
+
+[data-testid="stExpander"]:hover {
+    border: 1px solid rgba(79, 172, 254, 0.8); 
+    background-color: rgba(38, 39, 48, 0.6);
+}
+
+[data-testid="stExpander"] summary p {
+    color: #a0a0a0; 
+    font-weight: 500;
+    font-size: 0.95rem;
+}
+
+[data-testid="stExpander"]:hover summary p {
+    color: #4facfe;
+    transition: color 0.2s ease;
+}
+
+[data-testid="stExpanderDetails"] {
+    color: #cccccc;
+    font-size: 0.9rem;
+    line-height: 1.6;
+    padding-top: 10px;
+}

data/examples/intelligenza_artificiale.txt

@@ -1,9 +0,0 @@
-L'Intelligenza Artificiale (IA) è un ramo dell'informatica che mira a creare sistemi capaci di eseguire compiti che richiedono normalmente l'intelligenza umana.
-Questi compiti includono il riconoscimento vocale, la visione artificiale e la traduzione automatica.
-
-Le reti neurali profonde (Deep Learning) sono alla base dei recenti progressi nell'IA generativa.
-Modelli come i Transformer permettono di analizzare grandi quantità di dati testuali per estrarre significati semantici.
-Tuttavia, questi sistemi statistici mancano spesso di capacità di ragionamento logico formale.
-
-Per superare questo limite, si sta sviluppando l'approccio Neuro-Simbolico.
-Questo paradigma integra la flessibilità delle reti neurali con la precisione delle regole logiche e dei grafi di conoscenza (Knowledge Graphs), migliorando l'affidabilità e la spiegabilità dei risultati.

data/examples/parco_canne_battaglia.txt

@@ -1,9 +0,0 @@
-Il Parco Archeologico di Canne della Battaglia si trova su un'altura lungo la riva destra del fiume Ofanto, a pochi chilometri dalla foce.
-Il sito è celebre per la storica battaglia del 216 a.C., dove l'esercito cartaginese guidato da Annibale accerchiò e distrusse le legioni romane, nonostante l'inferiorità numerica.
-
-L'area archeologica comprende l'Antiquarium e la Cittadella medievale.
-All'interno dell'Antiquarium sono conservati reperti che vanno dalla preistoria al medioevo, inclusi corredi funerari e ceramiche geometriche daunia.
-La Cittadella conserva i resti del castello e della basilica maggiore, testimonianza dell'importanza strategica del luogo anche in epoca successiva alla battaglia.
-
-Recenti scavi hanno portato alla luce una necropoli medievale, suggerendo che l'insediamento fosse densamente abitato fino al XII secolo.
-I visitatori possono percorrere i sentieri che costeggiano le mura difensive e osservare la piana dell'Ofanto, teatro dello scontro militare.

data/examples/venezia_monumentale.txt

@@ -1,10 +0,0 @@
-La Basilica di San Marco a Venezia è il principale monumento religioso della città e uno dei simboli dell'arte veneto-bizantina.
-Situata nell'omonima piazza, la basilica fungeva da cappella palatina del Palazzo Ducale ed è collegata ad esso tramite la Porta della Carta.
-
-L'edificio presenta una pianta a croce greca con cinque cupole.
-La facciata è decorata con mosaici dorati, bassorilievi e marmi orientali, frutto del bottino della Quarta Crociata, tra cui i celebri Cavalli di San Marco (quelli esposti all'esterno sono copie).
-L'interno è rivestito da oltre 8000 metri quadrati di mosaici a fondo oro che narrano storie bibliche e agiografiche.
-
-Il Palazzo Ducale, adiacente alla basilica, è un capolavoro del gotico veneziano.
-Fu sede del Doge e delle magistrature statali della Serenissima Repubblica.
-Al suo interno si trovano la Scala d'Oro e la Sala del Maggior Consiglio, che ospita il "Paradiso" di Tintoretto, una delle tele più grandi al mondo.

data/gold_standard/examples.json

@@ -1,63 +1,70 @@
 [
   {
-    "text": "Il Menhir di Canne, situato lungo la strada provinciale, è un monolite calcareo che fungeva da segnacolo funerario o confine territoriale in epoca pre-romana.",
+    "text": "Il Menhir di Canne, situato lungo la strada provinciale, è un monolite calcareo che fungeva da segnacolo funerario o, secondo una teoria recente e dibattuta, da confine territoriale.",
+    "reasoning": "L'entità fisica e la localizzazione sono fatti certi (1.0). L'uso come segnacolo è consolidato ma non assoluto (0.9), mentre l'uso come confine è esplicitamente presentato come teoria incerta, quindi assegno un'ipotesi (0.6).",
+    "entities": [
+      "Menhir di Canne",
+      "Strada Provinciale",
+      "Segnacolo funerario",
+      "Confine territoriale"
+    ],
     "triples": [
-      {"subject": "Menhir di Canne", "predicate": "rdf:type", "object": "xchh:HeritageObject", "confidence": 1.0},
-      {"subject": "Menhir di Canne", "predicate": "crm:P45_consists_of", "object": "Calcare", "confidence": 1.0},
-      {"subject": "Menhir di Canne", "predicate": "crm:P2_has_type", "object": "Segnacolo funerario", "confidence": 0.9},
-      {"subject": "Menhir di Canne", "predicate": "crm:P53_has_former_or_current_location", "object": "Strada Provinciale", "confidence": 1.0}
+      {"subject": "Menhir di Canne", "predicate": "core:hasType", "object": "arco:ArchaeologicalProperty", "confidence": 1.0},
+      {"subject": "Menhir di Canne", "predicate": "a-loc:isLocatedIn", "object": "Strada Provinciale", "confidence": 1.0},
+      {"subject": "Menhir di Canne", "predicate": "core:hasConcept", "object": "Segnacolo funerario", "confidence": 0.9},
+      {"subject": "Menhir di Canne", "predicate": "core:hasConcept", "object": "Confine territoriale", "confidence": 0.6}
     ]
   },
   {
-    "text": "La Battaglia di Canne del 216 a.C. vide la vittoria dell'esercito cartaginese guidato da Annibale contro le legioni romane.",
+    "text": "La Battaglia di Canne del 216 a.C. vide la vittoria dell'esercito cartaginese guidato da Annibale. Le dinamiche dell'accerchiamento fanno presumere una conoscenza pregressa del terreno fangoso da parte dei comandanti.",
+    "reasoning": "La battaglia, la data e gli agenti coinvolti sono certi (1.0). La conoscenza del terreno da parte di Annibale è una deduzione forte derivata dalle tattiche, quindi è un'inferenza logica (0.85).",
+    "entities": [
+      "Battaglia di Canne",
+      "216 a.C.",
+      "Esercito Cartaginese",
+      "Annibale",
+      "Conoscenza del terreno"
+    ],
     "triples": [
-      {"subject": "Battaglia di Canne", "predicate": "rdf:type", "object": "xchh:HistoricalEvent", "confidence": 1.0},
-      {"subject": "Battaglia di Canne", "predicate": "crm:P4_has_time-span", "object": "216 a.C.", "confidence": 1.0},
-      {"subject": "Battaglia di Canne", "predicate": "crm:P11_had_participant", "object": "Esercito Cartaginese", "confidence": 1.0},
-      {"subject": "Annibale", "predicate": "crm:P14_carried_out_by", "object": "Esercito Cartaginese", "confidence": 0.95}
+      {"subject": "Battaglia di Canne", "predicate": "core:hasType", "object": "core:Event", "confidence": 1.0},
+      {"subject": "Battaglia di Canne", "predicate": "ti:atTime", "object": "216 a.C.", "confidence": 1.0},
+      {"subject": "Battaglia di Canne", "predicate": "ro:involvesAgent", "object": "Esercito Cartaginese", "confidence": 1.0},
+      {"subject": "Annibale", "predicate": "core:hasConcept", "object": "Conoscenza del terreno", "confidence": 0.85}
     ]
   },
   {
-    "text": "L'Antiquarium custodisce un prezioso corredo funerario proveniente dalla necropoli dauna, inclusi vasi a figure rosse.",
+    "text": "L'Antiquarium custodisce un prezioso corredo funerario proveniente dalla necropoli dauna. Alcuni dettagli pittorici sui vasi a figure rosse fanno sospettare un'influenza diretta della bottega del Pittore di Dario. All'ingresso della struttura è esposta anche una piccola stele iscritta.",
+    "reasoning": "Aggiunta un'entità isolata ('stele iscritta') che non ha relazioni esplicite nel testo con gli altri reperti, ma va comunque tracciata. L'attribuzione alla bottega rimane un'ipotesi (0.5).",
+    "entities": [
+      "Antiquarium",
+      "Corredo funerario",
+      "Vasi a figure rosse",
+      "Bottega del Pittore di Dario",
+      "Stele iscritta"
+    ],
     "triples": [
-      {"subject": "Antiquarium", "predicate": "rdf:type", "object": "xchh:Place", "confidence": 1.0},
-      {"subject": "Corredo funerario", "predicate": "crm:P55_has_current_location", "object": "Antiquarium", "confidence": 1.0},
-      {"subject": "Corredo funerario", "predicate": "crm:P108i_was_produced_by", "object": "Cultura Dauna", "confidence": 0.9},
-      {"subject": "Vasi a figure rosse", "predicate": "crm:P46_is_composed_of", "object": "Corredo funerario", "confidence": 1.0}
+      {"subject": "Antiquarium", "predicate": "core:hasType", "object": "cis:CulturalInstituteOrSite", "confidence": 1.0},
+      {"subject": "Corredo funerario", "predicate": "a-loc:hasCurrentLocation", "object": "Antiquarium", "confidence": 1.0},
+      {"subject": "Corredo funerario", "predicate": "core:hasPart", "object": "Vasi a figure rosse", "confidence": 1.0},
+      {"subject": "Vasi a figure rosse", "predicate": "ro:hasAuthor", "object": "Bottega del Pittore di Dario", "confidence": 0.5}
     ]
   },
   {
-    "text": "Il visitatore, avvicinandosi al totem multimediale, attiva l'esperienza di Realtà Aumentata che mostra la ricostruzione della cittadella medievale.",
+    "text": "Durante i recenti scavi nell'area nord, sono state rinvenute tre monete puniche d'argento mescolate a ceneri vicino a una struttura di accampamento. In un settore adiacente è stato trovato un elmo in bronzo frammentario.",
+    "reasoning": "L'elmo in bronzo è un reperto rilevante ma nel testo non è relazionato direttamente a ceneri o monete. Lo estraggo come entità isolata. Le monete e le ceneri suggeriscono un accampamento cartaginese (0.8).",
+    "entities": [
+      "Area nord",
+      "Monete puniche d'argento",
+      "Struttura di accampamento",
+      "Accampamento Cartaginese",
+      "Evento di incendio",
+      "Elmo in bronzo"
+    ],
     "triples": [
-      {"subject": "Visitatore", "predicate": "rdf:type", "object": "xcha:Agent", "confidence": 1.0},
-      {"subject": "Esperienza AR", "predicate": "rdf:type", "object": "xche:ExperienceSession", "confidence": 1.0},
-      {"subject": "Visitatore", "predicate": "xch:activates", "object": "Esperienza AR", "confidence": 1.0},
-      {"subject": "Esperienza AR", "predicate": "xch:visualizes", "object": "Cittadella Medievale", "confidence": 1.0}
-    ]
-  },
-  {
-    "text": "I resti della Domus Apula testimoniano l'organizzazione abitativa romana. Le mura sono realizzate in opera reticolata.",
-    "triples": [
-      {"subject": "Domus Apula", "predicate": "rdf:type", "object": "xchh:Site", "confidence": 1.0},
-      {"subject": "Domus Apula", "predicate": "crm:P2_has_type", "object": "Abitazione Romana", "confidence": 0.9},
-      {"subject": "Mura", "predicate": "crm:P46_forms_part_of", "object": "Domus Apula", "confidence": 1.0},
-      {"subject": "Mura", "predicate": "crm:P32_used_general_technique", "object": "Opera Reticolata", "confidence": 1.0}
-    ]
-  },
-  {
-    "text": "L'Agente Cognitivo ha inferito con una confidenza del 90% che il frammento ceramico appartiene al periodo tardo-antico.",
-    "triples": [
-      {"subject": "Agente Cognitivo", "predicate": "rdf:type", "object": "xcha:ArtificialAgent", "confidence": 1.0},
-      {"subject": "Frammento ceramico", "predicate": "xch:hasInferredPeriod", "object": "Periodo Tardo-Antico", "confidence": 0.9},
-      {"subject": "Inferenza", "predicate": "prov:wasGeneratedBy", "object": "Agente Cognitivo", "confidence": 1.0}
-    ]
-  },
-  {
-    "text": "Il progetto Canusium xCH mira a creare un'eterotopia digitale per la valorizzazione del patrimonio culturale della provincia BAT.",
-    "triples": [
-      {"subject": "Canusium xCH", "predicate": "rdf:type", "object": "xch:Project", "confidence": 1.0},
-      {"subject": "Canusium xCH", "predicate": "xch:targetsDomain", "object": "Patrimonio Culturale", "confidence": 1.0},
-      {"subject": "Provincia BAT", "predicate": "crm:P89_falls_within", "object": "Puglia", "confidence": 1.0}
+      {"subject": "Area nord", "predicate": "core:hasPart", "object": "Monete puniche d'argento", "confidence": 1.0},
+      {"subject": "Area nord", "predicate": "core:hasPart", "object": "Struttura di accampamento", "confidence": 1.0},
+      {"subject": "Struttura di accampamento", "predicate": "core:hasConcept", "object": "Accampamento Cartaginese", "confidence": 0.8},
+      {"subject": "Area nord", "predicate": "core:hasConcept", "object": "Evento di incendio", "confidence": 0.75}
     ]
   }
 ]

data/processed/chunks_debug.txt

@@ -1,6 +0,0 @@
---- CHUNK 0 ---
-Il Menhir di Canne della Battaglia rappresenta uno dei punti di ancoraggio simbolici e spaziali più densi del Parco Archeologico. Isolato ma al centro di un paesaggio carico di memoria, il monolite diventa un nodo di connessione tra materia e contesto. L'obiettivo del progetto Canusium xCH non è la mera restituzione digitale dell'oggetto, ma la costruzione di una soglia esperienziale.
-
---- CHUNK 1 ---
-L'esperienza comincia nell'approccio fisico al luogo. Avvicinandosi al Menhir, l'utente viene riconosciuto dal sistema tramite geo-anchoring e riceve sul proprio dispositivo un invito discreto ad attivare la modalità immersiva. La sovrapposizione digitale appare come una finestra trasparente che mantiene visibile il paesaggio, mentre introduce il modello 3D calibrato.
-

data/raw/menhir_test.txt

@@ -1,5 +0,0 @@
-Il Menhir di Canne della Battaglia rappresenta uno dei punti di ancoraggio simbolici e spaziali più densi del Parco Archeologico.
-Isolato ma al centro di un paesaggio carico di memoria, il monolite diventa un nodo di connessione tra materia e contesto.
-L'obiettivo del progetto Canusium xCH non è la mera restituzione digitale dell'oggetto, ma la costruzione di una soglia esperienziale.
-L'esperienza comincia nell'approccio fisico al luogo. Avvicinandosi al Menhir, l'utente viene riconosciuto dal sistema tramite geo-anchoring e riceve sul proprio dispositivo un invito discreto ad attivare la modalità immersiva.
-La sovrapposizione digitale appare come una finestra trasparente che mantiene visibile il paesaggio, mentre introduce il modello 3D calibrato.

data/raw/venezia_arte.doc

@@ -1,13 +0,0 @@
-Il Palazzo Ducale, capolavoro dell'arte gotica, sorge in Piazza San Marco a Venezia.
-Antica sede del Doge e delle magistrature veneziane, è il simbolo della potenza della Serenissima.
-Fondato nel IX secolo, l'edificio ha subito numerose ristrutturazioni a causa di incendi devastanti.
-La struttura attuale è il risultato dei lavori iniziati nel 1340.
-
-All'interno del palazzo si possono ammirare opere di inestimabile valore.
-La Sala del Maggior Consiglio ospita "Il Paradiso", una tela monumentale dipinta da Jacopo Tintoretto e dalla sua bottega tra il 1588 e il 1592.
-Questa sala era il cuore politico della Città Lagunare, dove si riunivano i nobili per prendere decisioni di stato.
-Un altro protagonista della decorazione interna è Paolo Veronese, che ha realizzato lo splendido soffitto della Sala del Collegio.
-
-Collegato al Palazzo Ducale tramite il celebre Ponte dei Sospiri, si trova il palazzo delle Prigioni Nuove.
-Il ponte, costruito nel 1600 in stile barocco, attraversa il Rio di Palazzo ed era attraversato dai condannati.
-Venezia continua ad attrarre milioni di visitatori che rimangono incantati dalla sua storia millenaria e dalla sua architettura unica al mondo.

docker-compose.yml

@@ -1,26 +0,0 @@
-services:
-  neo4j:
-    image: neo4j:5.15.0-community
-    container_name: activa_graph_db
-    ports:
-      - "7474:7474" # Browser UI
-      - "7687:7687" # Python Driver
-    environment:
-      - NEO4J_AUTH=neo4j/activa_semantic_lab
-      # Carica APOC e GDS automaticamente
-      - NEO4J_PLUGINS=["apoc", "graph-data-science"]
-      # CONFIGURAZIONE CRUCIALE PER N10S (Neosemantics)
-      - NEO4J_dbms_security_procedures_unrestricted=n10s.*,apoc.*
-      - NEO4J_dbms_security_procedures_allowlist=n10s.*,apoc.*,gds.*
-      # Memoria
-      - NEO4J_dbms_memory_heap_initial__size=1G
-      - NEO4J_dbms_memory_heap_max__size=2G
-    volumes:
-      # Mappa le cartelle che hai creato tu nella root
-      - ./neo4j/data:/data
-      - ./neo4j/plugins:/plugins
-    healthcheck:
-      test: ["CMD-SHELL", "wget --no-verbose --tries=1 --spider localhost:7474 || exit 1"]
-      interval: 10s
-      timeout: 5s
-      retries: 5

main.py

@@ -1,131 +0,0 @@
-import sys
-import os
-import time
-import glob
-
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-from src.ingestion.semantic_splitter import ActivaSemanticSplitter
-from src.extraction.extractor import NeuroSymbolicExtractor
-from src.validation.validator import SemanticValidator
-from src.graph.graph_loader import KnowledgeGraphPersister
-from src.graph.entity_resolver import EntityResolver
-
-def pipeline_execution():
-    print("\n🚀 AVVIO PIPELINE AUTOMATED DISCOVERY\n" + "="*50)
-
-    raw_text = load_raw_documents()
-    
-    if not raw_text:
-        print("⚠️ Nessun file trovato in data/raw/. Uso testo di default.")
-        raw_text = """
-        La Basilica di San Marco a Venezia è il principale luogo di culto della città.
-        È uno degli esempi più noti di architettura italo-bizantina.
-        """
-
-    # --- FASE 1: INGESTION ---
-    print("\n[FASE 1] Ingestion & Semantic Chunking...")
-    try:
-        # Usa un modello piccolo per lo splitting veloce
-        splitter = ActivaSemanticSplitter(model_name="all-MiniLM-L6-v2")
-        # percentile_threshold=90 significa: taglia solo quando la similarità scende molto
-        chunks, _, _ = splitter.create_chunks(raw_text, percentile_threshold=90)
-        save_chunks_to_processed(chunks)
-        print(f"✅ Testo diviso in {len(chunks)} segmenti semantici.")
-    except Exception as e:
-        print(f"❌ Errore in Fase 1: {e}")
-        return
-
-    # --- FASE 2: EXTRACTION ---
-    print("\n[FASE 2] Init Neuro-Symbolic Core (Llama 3)...")
-
-    gold_path = os.path.join("data", "gold_standard", "examples.json")
-
-    try:
-        # Assicurati che Ollama sia attivo!
-        extractor = NeuroSymbolicExtractor(model_name="llama3", gold_standard_path=gold_path) 
-    except Exception as e:
-        print(f"❌ Errore connessione Ollama: {e}")
-        return
-    
-    all_triples = []
-    
-    print(f"🔄 Avvio estrazione su {len(chunks)} chunk...")
-    for i, chunk in enumerate(chunks):
-        chunk_id = f"doc_sample_chunk_{i+1}"
-        
-        print(f"\n   Processing {chunk_id} ({len(chunk)} chars)...")
-        
-        # Invoca Llama 3
-        extraction_result = extractor.extract(chunk, source_id=chunk_id)
-        
-        if extraction_result and extraction_result.triples:
-            count = len(extraction_result.triples)
-            print(f"   -> Estratte {count} triple.")
-            # Aggiungiamo le triple alla lista totale
-            all_triples.extend(extraction_result.triples)
-        else:
-            print("   -> Nessuna tripla trovata (o errore parsing).")
-
-    print(f"\n✅ Totale triple raccolte: {len(all_triples)}")
-
-    if not all_triples:
-        print("⚠️ Nessuna tripla da salvare. Pipeline terminata.")
-        return
-    
-    # --- FASE 2.5: SYMBOLIC RESOLUTION & CANONICALIZATION ---
-    # Implementazione Sezione 4.1 del Documento
-    print("\n[FASE 2.5] Entity Resolution & Canonicalization (DBSCAN)...")
-    try:
-        resolver = EntityResolver(similarity_threshold=0.85)
-        # Sovrascriviamo le triple con quelle pulite
-        all_triples = resolver.resolve_entities(all_triples)
-        print("✅ Risoluzione entità completata.")
-    except Exception as e:
-        print(f"⚠️ Errore nel resolver (skip): {e}")
-    
-    print("\n[FASE 2.6] Validazione Semantica (SHACL)...")
-    validator = SemanticValidator()
-    is_valid, report, _ = validator.validate_batch(all_triples)
-    
-    if is_valid:
-        print("✅ Validazione passata. I dati rispettano l'ontologia.")
-    else:
-        print("⚠️  Warning: Rilevate violazioni SHACL.")
-        print("   (In produzione, queste triple verrebbero scartate o mandate in Human Review)")
-        # Per ora procediamo, ma in un sistema reale fermeremmo qui le triple corrotte.
-        print(report)
-
-    # --- FASE 3: PERSISTENCE ---
-    print("\n[FASE 3] Graph Construction & Persistence (Neo4j)...")
-    try:
-        persister = KnowledgeGraphPersister()
-        persister.save_triples(all_triples)
-        persister.close()
-        print("\n🎉 PIPELINE COMPLETATA CON SUCCESSO!")
-        print("👉 Vai su http://localhost:7474 ed esegui: MATCH (n)-[r]->(m) RETURN n,r,m")
-    except Exception as e:
-        print(f"❌ Errore in Fase 3 (Neo4j): {e}")
-
-def load_raw_documents(directory="data/raw"):
-    """Legge tutti i file .txt nella cartella raw."""
-    texts = []
-    files = glob.glob(os.path.join(directory, "*.txt"))
-    print(f"📂 Trovati {len(files)} documenti in {directory}")
-    for f_path in files:
-        with open(f_path, 'r', encoding='utf-8') as f:
-            texts.append(f.read())
-    return "\n\n".join(texts)
-
-def save_chunks_to_processed(chunks, directory="data/processed"):
-    """Salva i chunk su disco per debug."""
-    os.makedirs(directory, exist_ok=True)
-    with open(os.path.join(directory, "chunks_debug.txt"), "w", encoding="utf-8") as f:
-        for i, c in enumerate(chunks):
-            f.write(f"--- CHUNK {i} ---\n{c}\n\n")
-    print(f"💾 Chunk salvati in {directory}/chunks_debug.txt")
-
-if __name__ == "__main__":
-    start_time = time.time()
-    pipeline_execution()
-    print(f"\n⏱️ Tempo totale esecuzione: {time.time() - start_time:.2f} secondi")

requirements.txt

@@ -3,30 +3,32 @@ langchain>=0.3.0
 langchain-community>=0.3.0
 langchain-ollama>=0.2.0 
 langchain-huggingface>=0.1.0   
+langchain-groq
 langchain-core
 huggingface_hub
 
 # --- Data Validation ---
 pydantic>=2.0
-pyshacl                        # Per validazione SHACL
+pyshacl
 
 # --- NLP & Semantic Chunking ---
-sentence-transformers          # Backend per HuggingFace
-scikit-learn                   # Per cosine similarity
+sentence-transformers
+scikit-learn
 numpy
-matplotlib                     # Per grafici di analisi
-nltk                           # Per lo splitting linguistico avanzato
-pandas
+nltk
 spacy
 
 # --- Graph Database & Semantic Web ---
-neo4j>=5.0.0                   # Driver Python ufficiale
-rdflib                         # Gestione RDF
-networkx                       # Calcoli su grafo (usato da PyVis/Streamlit)
-
-# --- Frontend ---
-streamlit>=1.30.0
-pyvis                          # Visualizzazione interattiva
+neo4j>=5.0.0
+rdflib
 
+# --- Web & API ---
+fastapi
+uvicorn
+requests
+streamlit         
+pyvis           
+pandas  
+         
 # --- Utilities ---
 python-dotenv

src/extraction/extractor.py

@@ -5,13 +5,17 @@ from typing import List, Optional
 from pydantic import BaseModel, Field, ValidationError
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+from langchain_groq import ChatGroq
 
-# Gestione Multi-Backend (Locale vs Cloud)
 from langchain_ollama import ChatOllama
 from langchain_huggingface import HuggingFaceEmbeddings, ChatHuggingFace, HuggingFaceEndpoint
 from sklearn.metrics.pairwise import cosine_similarity
+from dotenv import load_dotenv
 
-# --- 1. DEFINIZIONE DELLO SCHEMA ---
+
+load_dotenv() # in locale carica il file .env , su HF non trovando il file utilizza i secrets inseriti nella sezione settings.
+
+# --- DEFINIZIONE DELLO SCHEMA ---
 class GraphTriple(BaseModel):
     subject: str = Field(..., description="Entità sorgente (Canonical).")
     predicate: str = Field(..., description="Relazione (snake_case).")
@@ -21,13 +25,15 @@ class GraphTriple(BaseModel):
 
 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.")
     triples: List[GraphTriple]
 
-# --- 2. ESTRATTORE DINAMICO (Dynamic Few-Shot) ---
+# --- ESTRATTORE DINAMICO (Dynamic Few-Shot) ---
 class NeuroSymbolicExtractor:
     def __init__(self, model_name="llama3", temperature=0, gold_standard_path=None):
         
         hf_token = os.getenv("HF_TOKEN")
+        groq_api_key=os.getenv("GROQ_API_KEY")
         
         if hf_token:
             print("☁️ Rilevato ambiente Cloud (HF Spaces). Utilizzo HuggingFace Inference API.")
@@ -46,6 +52,17 @@ class NeuroSymbolicExtractor:
             except Exception as e:
                 print(f"❌ Errore connessione HF API: {e}. Fallback su CPU locale (sconsigliato).")
                 raise e
+        elif groq_api_key:
+            print("☁️ Rilevato ambiente Groq Cloud!")
+            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
+                    api_key=os.getenv("GROQ_API_KEY")
+                )
+            except Exception as e:
+                print(f"❌ Errore Groq API {e}")           
         else:
             print(f"🏠 Ambiente Locale rilevato. Inizializzazione Ollama: {model_name}...")
             try:
@@ -58,11 +75,11 @@ class NeuroSymbolicExtractor:
             except Exception as e:
                  print(f"⚠️ Errore Ollama: {e}")
 
-        # 2. Modello Embedding per la selezione dinamica
+        # Modello Embedding per la selezione dinamica
         print("🧠 Caricamento modello embedding per Dynamic Selection...")
         self.embedding_model = HuggingFaceEmbeddings(model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
 
-        # 3. Caricamento e Indicizzazione Gold Standard
+        # Caricamento e Indicizzazione Gold Standard
         self.examples = []
         self.example_embeddings = None
         
@@ -74,23 +91,25 @@ class NeuroSymbolicExtractor:
             print("⚠️ Nessun Gold Standard trovato. Modalità Zero-Shot.")
 
         # Template Specializzato (Prompt Engineering)
-        self.system_template_base = """Sei l'Agente Cognitivo (AC) del sistema Canusium xCH.
-        Il tuo compito è trasformare il testo non strutturato in un Digital Twin Graph (RDF).
+        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.
         
         SCHEMA JSON RICHIESTO:
         {{
             "reasoning": "Spiega brevemente perché hai scelto queste classi/relazioni...",
+            "entities": ["Nome Entità 1", "Nome Entità 2 Isolata"],
             "triples": [
                 {{"subject": "Entità", "predicate": "prefix:Relazione", "object": "Entità", "confidence": 0.95}}
             ]
         }}
         
-        ONTOLOGIA DI RIFERIMENTO (Usa questi prefissi):
-        - xchh: (Heritage) -> Per oggetti fisici, siti, reperti (es. xchh:HeritageObject, xchh:Site).
-        - crm: (CIDOC-CRM) -> Per relazioni standard (es. crm:P55_has_current_location, crm:P4_has_time-span).
-        - xche: (Experience) -> Per sessioni AR/VR, visitatori, interazioni (es. xche:ExperienceSession).
-        - xcha: (Agents) -> Per agenti umani o artificiali.
-        - skos: -> Per concetti generici o gerarchie.
+        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}
@@ -99,8 +118,13 @@ class NeuroSymbolicExtractor:
         - 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").
+        Canonicalizza i nomi (es. "Il Parco" -> "Parco Archeologico di Canne della Battaglia").
         Rispondi ESCLUSIVAMENTE con un JSON valido.
         """
 
@@ -110,7 +134,7 @@ class NeuroSymbolicExtractor:
             with open(path, 'r', encoding='utf-8') as f:
                 self.examples = json.load(f)
             
-            # Estraiamo solo il testo di input per calcolare l'embedding
+            # 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.")
@@ -125,13 +149,13 @@ class NeuroSymbolicExtractor:
         if not self.examples or self.example_embeddings is None:
             return "Nessun esempio disponibile."
 
-        # 1. Embed del chunk attuale
+        # Embed del chunk attuale
         query_embedding = self.embedding_model.embed_query(query_text)
         
-        # 2. Calcolo similarità coseno
+        # Calcolo similarità coseno
         similarities = cosine_similarity([query_embedding], self.example_embeddings)[0]
         
-        # 3. Selezione dei top-k
+        # Selezione dei top-k
         top_k_indices = np.argsort(similarities)[-k:][::-1]
         
         formatted_text = ""
@@ -140,9 +164,13 @@ class NeuroSymbolicExtractor:
             sim_score = similarities[idx]
             formatted_text += f"\n--- ESEMPIO RILEVANTE #{i+1} (Sim: {sim_score:.2f}) ---\n"
             formatted_text += f"INPUT: {ex['text']}\n"
-            # Gestione sicura nel caso triples manchi
-            triples_out = ex.get('triples', [])
-            formatted_text += f"OUTPUT: {json.dumps({'triples': triples_out}, ensure_ascii=False)}\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
 
@@ -177,6 +205,10 @@ class NeuroSymbolicExtractor:
                 elif "```" in content:
                     content = content.split("```")[1].split("```")[0].strip()
 
+                if not content:
+                    raise ValueError("Il modello ha restituito una stringa vuota o un formato non parsabile.")
+
+
                 data = json.loads(content)
                 
                 # Normalizzazione output
@@ -187,6 +219,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", []), # 
                         triples=triples
                     )
                 

src/graph/entity_resolver.py

@@ -1,77 +1,133 @@
 import numpy as np
+import requests
 from sklearn.cluster import DBSCAN
 from langchain_huggingface import HuggingFaceEmbeddings
-from collections import Counter
 
 class EntityResolver:
-    def __init__(self, model_name="all-MiniLM-L6-v2", similarity_threshold=0.85):
-        """
-        Inizializza il modello per il calcolo delle similarità.
-        similarity_threshold: quanto devono essere vicini i vettori (0-1).
-                              Convertito in 'eps' per DBSCAN.
-        """
-        print("🧩 Inizializzazione Entity Resolver (DBSCAN)...")
+    def __init__(self, neo4j_driver, model_name="all-MiniLM-L6-v2", similarity_threshold=0.85):
+        print("🧩 Inizializzazione Entity Resolver Ibrido (Vector Search + Wikidata EL)...")
         self.embedding_model = HuggingFaceEmbeddings(model_name=model_name)
-        # DBSCAN usa la distanza, non la similarità. Distanza = 1 - Similarità.
-        # Se threshold è 0.85 (alta similarità), eps deve essere 0.15 (bassa distanza).
         self.eps = 1 - similarity_threshold
+        self.similarity_threshold = similarity_threshold
+        self.driver = neo4j_driver
+    
+    def _find_canonical_in_db(self, embedding_vector):
+        """Interroga l'indice vettoriale di Neo4j per trovare il nodo più simile."""
+        if not self.driver: return None
+        
+        query = """
+        CALL db.index.vector.queryNodes('entity_embeddings', 1, $embedding)
+        YIELD node, score
+        WHERE score >= $threshold
+        RETURN node.label AS canonical_label, score
+        """
+        with self.driver.session() as session:
+            result = session.run(query, embedding=embedding_vector, threshold=self.similarity_threshold)
+            record = result.single()
+            if record:
+                return record["canonical_label"]
+        return None
 
-    def resolve_entities(self, triples):
+    def _link_to_wikidata(self, entity_name):
         """
-        Prende una lista di triple (GraphTriple) e normalizza i nomi delle entità.
+        Interroga l'API di Wikidata per trovare un match diretto (Entity Linking).
+        Ritorna l'URI di Wikidata (es. wd:Q12345) o None.
         """
-        if not triples:
-            return []
+        url = "https://www.wikidata.org/w/api.php"
+        params = {
+            "action": "wbsearchentities",
+            "search": entity_name,
+            "language": "it",
+            "format": "json",
+            "limit": 1 # Prendo solo il best match per la riconciliazione automatica
+        }
+        try:
+            # Timeout breve per non bloccare la pipeline se Wikidata è lento
+            response = requests.get(url, params=params, timeout=3.0)
+            if response.status_code == 200:
+                data = response.json()
+                if not data.get("search"):
+                    print(f"   [DEBUG] Wikidata non ha trovato corrispondenze per: '{entity_name}'")
+                    
+                if data.get("search"):
+                    best_match = data["search"][0]
+                    return f"wd:{best_match['id']}"
+        except Exception as e:
+            print(f"   ⚠️ Errore lookup Wikidata per '{entity_name}': {e}")
+        return None
 
-        # 1. Estrazione di tutte le entità uniche (Soggetti e Oggetti)
-        all_entities = set()
+    def resolve_entities(self, extracted_entities, triples):
+        if not triples and not extracted_entities:
+            return [], []
+
+        # Raccolgo tutte le entità uniche dal chunk corrente
+        chunk_entities = set(extracted_entities)
         for t in triples:
-            all_entities.add(t.subject)
-            all_entities.add(t.object)
-        
-        unique_entities = list(all_entities)
-        print(f"   Analisi di {len(unique_entities)} entità uniche per deduplica...")
+            chunk_entities.add(t.subject)
+            chunk_entities.add(t.object)
+        unique_chunk_entities = list(chunk_entities)
 
-        if len(unique_entities) < 2:
-            return triples
+        if not unique_chunk_entities:
+            return [], triples
 
-        # 2. Calcolo Embeddings
-        embeddings = self.embedding_model.embed_documents(unique_entities)
-        X = np.array(embeddings)
+        # Calcolo gli embedding per il batch locale
+        embeddings = self.embedding_model.embed_documents(unique_chunk_entities)
+        
+        # Local Batch Deduplication
+        clustering = DBSCAN(eps=self.eps, min_samples=1, metric='cosine').fit(np.array(embeddings))
+        
+        local_cluster_map = {}
+        for entity, emb, label in zip(unique_chunk_entities, embeddings, clustering.labels_):
+            if label not in local_cluster_map:
+                local_cluster_map[label] = []
+            local_cluster_map[label].append({"name": entity, "embedding": emb})
 
-        # 3. Clustering DBSCAN
-        # metrica='cosine' è fondamentale per vettori semantici
-        clustering = DBSCAN(eps=self.eps, min_samples=1, metric='cosine').fit(X)
-        labels = clustering.labels_
+        entity_replacement_map = {}
+        entities_to_save = [] # Array di {label, embedding, wikidata_sameAs}
 
-        # 4. Creazione Mappa {Variante -> Canonico}
-        # Raggruppiamo le entità per Cluster ID
-        cluster_map = {}
-        for entity, label in zip(unique_entities, labels):
-            if label not in cluster_map:
-                cluster_map[label] = []
-            cluster_map[label].append(entity)
+        # Global Database Resolution & Wikidata Linking
+        for label, items in local_cluster_map.items():
+            local_canonical_item = sorted(items, key=lambda x: len(x["name"]), reverse=True)[0]
+            local_canonical_name = local_canonical_item["name"]
+            local_canonical_emb = local_canonical_item["embedding"]
 
-        # Per ogni cluster, eleggiamo il "Canonico" (es. la stringa più lunga)
-        entity_replacement_map = {}
-        for label, variants in cluster_map.items():
-            if len(variants) > 1:
-                # Euristiche di canonicalizzazione:
-                # 1. Preferisci quella che inizia con maiuscola
-                # 2. Preferisci la più lunga (spesso più descrittiva: "San Marco" vs "Basilica di San Marco")
-                canonical = sorted(variants, key=len, reverse=True)[0]
-                print(f"   ✨ Deduplica: {variants} -> '{canonical}'")
-                for v in variants:
-                    entity_replacement_map[v] = canonical
+            db_canonical_name = self._find_canonical_in_db(local_canonical_emb)
+
+            if db_canonical_name:
+                # Caso A: Neo4j conosce già questa entità (ha già il suo embedding e potenziale URI)
+                final_canonical = db_canonical_name
+                print(f"   🔗 Match Globale: '{local_canonical_name}' -> '{db_canonical_name}' (Neo4j)")
             else:
-                entity_replacement_map[variants[0]] = variants[0]
+                # Caso B: È un'entità veramente nuova. Tento l'Entity Linking!
+                final_canonical = local_canonical_name
+                
+                # Chiamata a Wikidata
+                wikidata_uri = self._link_to_wikidata(final_canonical)
+                
+                entity_dict = {
+                    "label": final_canonical,
+                    "embedding": local_canonical_emb,
+                    "wikidata_sameAs": wikidata_uri
+                }
+                
+                if wikidata_uri:
+                    print(f"   ✨ Nuova Entità: '{final_canonical}' 🌍 Linked to: {wikidata_uri}")
+                else:
+                    print(f"   ✨ Nuova Entità: '{final_canonical}' (No Wiki link)")
+                    
+                entities_to_save.append(entity_dict)
+
+            # Mappo le varianti locali al canonico
+            for item in items:
+                entity_replacement_map[item["name"]] = final_canonical
 
-        # 5. Riscrittura Triple
+        # Riscrittura Output
         resolved_triples = []
         for t in triples:
-            # Sostituiamo soggetto e oggetto con le versioni canoniche
             t.subject = entity_replacement_map.get(t.subject, t.subject)
             t.object = entity_replacement_map.get(t.object, t.object)
             resolved_triples.append(t)
 
-        return resolved_triples
+        resolved_entities = list(set([entity_replacement_map.get(e, e) for e in extracted_entities]))
+
+        return resolved_entities, resolved_triples, entities_to_save

src/graph/graph_loader.py

@@ -3,17 +3,16 @@ from collections import defaultdict
 from neo4j import GraphDatabase
 from dotenv import load_dotenv
 
-# Carica variabili d'ambiente
-load_dotenv()
+load_dotenv() # in locale carica il file .env , su HF non trovando il file utilizza i secrets inseriti nella sezione settings.
 
 class KnowledgeGraphPersister:
     def __init__(self):
         """
         Inizializza il driver Neo4j e crea i vincoli necessari per le performance.
         """
-        uri = os.getenv("NEO4J_URI", "neo4j+s://748d6c94.databases.neo4j.io")
-        user = os.getenv("NEO4J_USER", "neo4j")
-        password = os.getenv("NEO4J_PASSWORD", "t1bT1DiXwDOGMYfX89qR20loSN8FXurB3Dfg8bPQcTI")
+        uri = os.getenv("NEO4J_URI")
+        user = os.getenv("NEO4J_USER")
+        password = os.getenv("NEO4J_PASSWORD")
         
         try:
             self.driver = GraphDatabase.driver(uri, auth=(user, password))
@@ -38,13 +37,26 @@ class KnowledgeGraphPersister:
         """
         if not self.driver: return
         query = "CREATE CONSTRAINT resource_uri_unique IF NOT EXISTS FOR (n:Resource) REQUIRE n.uri IS UNIQUE"
+        query_vector = """
+        CREATE VECTOR INDEX entity_embeddings IF NOT EXISTS 
+        FOR (n:Resource) ON (n.embedding) 
+        OPTIONS {indexConfig: {
+            `vector.dimensions`: 384, 
+            `vector.similarity_function`: 'cosine'
+        }}
+        """
         with self.driver.session() as session:
             try:
                 session.run(query)
-                print("⚡ Vincoli/Indici Neo4j verificati.")
+                print("⚡ Vincolo di unicità verificato.")
+            except Exception as e:
+                print(f"⚠️ Warning vincolo unicità: {e}")
+                
+            try:
+                session.run(query_vector)
+                print("⚡ Vector Index verificato.")
             except Exception as e:
-                # Spesso fallisce se l'utente non ha permessi admin o se esiste già con nome diverso
-                print(f"⚠️ Warning creazione indici: {e}")
+                print(f"⚠️ Warning vector index: {e}")
 
     def sanitize_name(self, name):
         """
@@ -57,20 +69,17 @@ class KnowledgeGraphPersister:
     def sanitize_predicate(self, pred):
         """
         Pulisce il predicato per evitare Cypher Injection.
-        FIX: Gestisce meglio i separatori (:, -, spazio) sostituendoli con underscore
-        per evitare predicati illeggibili come XCHEHASOBJECT.
-        Es. xche:has_object -> XCHE_HAS_OBJECT
         """
         if not pred: return "RELATED_TO"
         
-        # 1. Normalizzazione preliminare dei separatori comuni
-        # Sostituisce i due punti dei namespace e trattini con underscore
+        # Normalizzazione preliminare dei separatori comuni
+        # Sostituisco i due punti dei namespace e trattini con underscore
         pred = pred.replace(":", "_").replace("-", "_").replace(" ", "_")
         
-        # 2. Rimozione caratteri non sicuri (mantiene solo alfanumerici e underscore)
+        # Rimozione caratteri non sicuri (mantiene solo alfanumerici e underscore)
         clean = "".join(x for x in pred if x.isalnum() or x == "_")
         
-        # 3. Conversione in uppercase (convenzione Neo4j per Relationships)
+        # Conversione in uppercase (convenzione Neo4j per Relationships)
         return clean.upper() if clean else "RELATED_TO"
 
     def save_triples(self, triples):
@@ -83,7 +92,7 @@ class KnowledgeGraphPersister:
 
         print(f"💾 Preparazione Batch di {len(triples)} triple...")
 
-        # 1. Raggruppamento per Predicato
+        # Raggruppamento per Predicato
         batched_by_pred = defaultdict(list)
         
         for t in triples:
@@ -99,7 +108,7 @@ class KnowledgeGraphPersister:
             }
             batched_by_pred[safe_pred].append(item)
 
-        # 2. Esecuzione Transazioni (Una per tipo di relazione)
+        # Esecuzione Transazioni (Una per tipo di relazione)
         with self.driver.session() as session:
             for pred, data_list in batched_by_pred.items():
                 try:
@@ -110,6 +119,39 @@ class KnowledgeGraphPersister:
 
         print("✅ Salvataggio completato.")
 
+    def save_entities_and_triples(self, entities_to_save, triples):
+        """Salva prima i nodi isolati (con i loro vettori), poi le relazioni."""
+        if not self.driver: return
+
+        # Salvataggio Nodi (anche senza relazioni, includendo l'embedding)
+        if entities_to_save:
+            print(f"💾 Salvataggio di {len(entities_to_save)} nodi singoli con vettori...")
+            
+            # Aggiungo il campo "uri" calcolandolo dalla label
+            node_batch = []
+            for item in entities_to_save:
+                item["uri"] = self.sanitize_name(item["label"])
+                node_batch.append(item)
+                
+            with self.driver.session() as session:
+                session.execute_write(self._unwind_write_nodes, node_batch)
+
+        # Salvataggio Triple
+        if triples:
+            self.save_triples(triples)
+
+    @staticmethod
+    def _unwind_write_nodes(tx, batch_data):
+        query = (
+            "UNWIND $batch AS row "
+            "MERGE (n:Resource {uri: row.uri}) "
+            "ON CREATE SET n.label = row.label, "
+            "              n.embedding = row.embedding, "
+            "              n.wikidata_sameAs = row.wikidata_sameAs, "
+            "              n.last_updated = datetime() "
+        )
+        tx.run(query, batch=batch_data)
+
     @staticmethod
     def _unwind_write_tx(tx, predicate, batch_data):
         """

src/ingestion/semantic_splitter.py

@@ -1,32 +1,21 @@
 import os
 import re
 import numpy as np
-import matplotlib.pyplot as plt
 from sklearn.metrics.pairwise import cosine_similarity
 from dotenv import load_dotenv
 from langchain_huggingface import HuggingFaceEmbeddings
 
-load_dotenv()
+load_dotenv() # in locale carica il file .env , su HF non trovando il file utilizza i secrets inseriti nella sezione settings.
 
 class ActivaSemanticSplitter:
     def __init__(self, model_name="sentence-transformers/all-MiniLM-L6-v2", batch_size=32):
         self.batch_size = batch_size
-        provider = os.getenv("EMBEDDING_PROVIDER", "huggingface").lower()
         
-        print(f"🔄 Inizializzazione Embedding Engine (Provider: {provider})...")
+        print("🔄 Inizializzazione HuggingFace Embedding Engine...")
         
         try:
-            if provider == "openai":
-                from langchain_openai import OpenAIEmbeddings
-                api_key = os.getenv("OPENAI_API_KEY")
-                if not api_key:
-                    raise ValueError("OPENAI_API_KEY mancante nel file .env")
-                self.embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
-            else:
-                self.embedding_model = HuggingFaceEmbeddings(model_name=model_name)
-                
+            self.embedding_model = HuggingFaceEmbeddings(model_name=model_name)    
             print("✅ Modello caricato correttamente.")
-            
         except Exception as e:
             print(f"❌ Errore caricamento modello: {e}")
             raise e
@@ -38,7 +27,7 @@ class ActivaSemanticSplitter:
         text = text.strip()
         try:
             import nltk
-            # Assicuriamoci che i dati ci siano
+            # Controllo che i dati ci siano
             try:
                 nltk.data.find('tokenizers/punkt')
                 nltk.data.find('tokenizers/punkt_tab')
@@ -46,9 +35,8 @@ class ActivaSemanticSplitter:
                 print("⬇️ Download risorse NLTK...")
                 nltk.download('punkt', quiet=True)
                 nltk.download('punkt_tab', quiet=True)
-            
-            # FIX: Carichiamo il tokenizer italiano specifico
-            # Invece di usare sent_tokenize() che è una black box, carichiamo l'oggetto.
+
+            # Invece di usare sent_tokenize() che è una black box, carico l'oggetto.
             try:
                 tokenizer = nltk.data.load('tokenizers/punkt/italian.pickle')
             except:
@@ -57,7 +45,6 @@ class ActivaSemanticSplitter:
                 tokenizer = PunktSentenceTokenizer()
 
             # --- LISTA ECCEZIONI ABBREVIAZIONI ---
-            # Diciamo al tokenizer che queste parole seguite da punto NON chiudono la frase
             custom_abbrevs = ['sec', 's', 'prof', 'dott', 'avv', 'pag', 'fig', 'nr', 'art']
             for abbr in custom_abbrevs:
                 tokenizer._params.abbrev_types.add(abbr)
@@ -94,7 +81,9 @@ class ActivaSemanticSplitter:
         distances = []
         for i in range(len(embeddings) - 1):
             similarity = cosine_similarity([embeddings[i]], [embeddings[i+1]])[0][0]
-            distances.append(similarity)
+            #(0 = identiche, 1 = completamente diverse)
+            distance = 1.0 - similarity 
+            distances.append(distance)
             
         return distances, embeddings
 
@@ -109,8 +98,10 @@ class ActivaSemanticSplitter:
         if not distances:
             return [text], [], 0
 
-        threshold = np.percentile(distances, 100 - percentile_threshold)
-        indices_above_thresh = [i for i, x in enumerate(distances) if x < threshold]
+        threshold = np.percentile(distances, percentile_threshold)
+        
+        # Un breakpoint avviene quando la distanza supera la soglia
+        indices_above_thresh = [i for i, x in enumerate(distances) if x > threshold]
         
         chunks = []
         start_index = 0

src/validation/validator.py

@@ -5,7 +5,7 @@ from pyshacl import validate
 
 class SemanticValidator:
     def __init__(self):
-        # Definiamo i namespace
+        # Definisco i namespace
         self.EX = Namespace("http://activa.ai/ontology/")
         self.shapes_file = os.path.join(os.path.dirname(__file__), "shapes/schema_constraints.ttl")
         
@@ -18,46 +18,57 @@ class SemanticValidator:
             print("⚠️  File SHACL non trovato. Validazione disabilitata.")
             self.shacl_graph = None
 
-    def _json_to_rdf(self, triples):
-        """Converte le triple JSON (Pydantic) in un grafo RDFLib in memoria."""
+    def _json_to_rdf(self, entities, triples):
+        """Converte le triple e le entità isolate in un grafo RDFLib in memoria."""
         g = Graph()
         g.bind("skos", SKOS)
         g.bind("ex", self.EX)
 
-        for t in triples:
-            # Creiamo URI sanitizzati
-            subj_uri = URIRef(self.EX[t.subject.replace(" ", "_")])
-            obj_uri = URIRef(self.EX[t.object.replace(" ", "_")])
-            
-            # Aggiungiamo il tipo Concept
-            g.add((subj_uri, RDF.type, SKOS.Concept))
-            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")))
+        # Aggiungo le entità isolate come Nodi
+        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))
+                g.add((ent_uri, SKOS.prefLabel, Literal(label, lang="it")))
+
+        # Aggiungo le Triple
+        if triples:
+            for t in triples:
+                subj_uri = URIRef(self.EX[t.subject.replace(" ", "_")])
+                obj_uri = URIRef(self.EX[t.object.replace(" ", "_")])
+                
+                # Aggiungo il tipo Concept per soggetto e oggetto
+                g.add((subj_uri, RDF.type, SKOS.Concept))
+                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")))
 
-            # Mappiamo il predicato (se è standard o custom)
-            if t.predicate == "skos:related" or t.predicate == "related":
-                pred = SKOS.related
-            elif t.predicate == "skos:broader" or t.predicate == "broader":
-                pred = SKOS.broader
-            else:
-                # Fallback su namespace custom per predicati non standard (es. situato_in)
-                pred = self.EX[t.predicate]
+                # 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
+                else:
+                    pred = self.EX[t.predicate]
 
-            g.add((subj_uri, pred, obj_uri))
+                g.add((subj_uri, pred, obj_uri))
             
         return g
 
-    def validate_batch(self, triples):
+    def validate_batch(self, entities, triples):
         """
-        Esegue la validazione SHACL sulle triple.
+        Esegue la validazione SHACL sia sulle entità isolate che sulle triple.
         Ritorna (is_valid, report_text, rdf_graph)
         """
         if not self.shacl_graph:
             return True, "No Constraints", None
 
-        data_graph = self._json_to_rdf(triples)
+        # Passo entrambe le liste al convertitore
+        data_graph = self._json_to_rdf(entities, triples)
         
         print("🔍 Esecuzione Validazione SHACL...")
         conforms, report_graph, report_text = validate(