creazione progetto

.env

@@ -0,0 +1,4 @@
+AZURE_ENDPOINT_EMB="https://pr-giorno6-embeddings-resource.cognitiveservices.azure.com/openai/deployments/text-embedding-ada-002/embeddings?api-version=2023-05-15"
+AZURE_API_KEY_EMB="k9qAhDsM91sdoW79twYQCEqAjIPjGGV7JxSEztsGid3EqQktnEsCJQQJ99BFACHrzpqXJ3w3AAAAACOGNMeC"
+AZURE_ENDPOINT="https://pr-giorno6-rag-resource.cognitiveservices.azure.com/"
+AZURE_API_KEY="3MwIo1ZmFJvm1bEY5dW8AlJB3rfard2ux1oH6JoShy76Uo1q34ZMJQQJ99BFACHrzpqXJ3w3AAAAACOGLOIY"

CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## [Documentato] - 2025-06-30
+
+### Added
+- Documentazione tecnica completa
+- Analisi automatizzata del progetto
+- Template per future implementazioni
+
+### Documentation
+- README.md principale
+- Documentazione tecnica in docs/
+- Guide di architettura e utilizzo
+
+*Changelog generato automaticamente*

README.md

@@ -1,10 +1,205 @@
----
-title: Progetto Hackathon
-emoji: 🦀
-colorFrom: red
-colorTo: purple
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🔒 Anonimizzatore Documenti con AI
+
+Sistema completo per anonimizzazione e analisi intelligente di documenti testuali con protezione privacy GDPR.
+
+## 🚀 Funzionalità
+
+- **🔐 Anonimizzazione Automatica**: NER + Regex per proteggere dati sensibili
+- **💬 RAG Chatbot**: Chat intelligente sui documenti anonimizzati  
+- **🤖 Multi-Agent AI**: 4 agenti CrewAI per analisi approfondite
+- **📊 Dashboard Web**: Interfaccia Streamlit completa
+- **📥 Export Risultati**: Download JSON strutturati
+
+## 📋 Requisiti
+
+- Python 3.8+
+- Account Azure OpenAI
+- Dipendenze in `requirements.txt`
+
+## ⚙️ Installazione
+
+1. **Clona il repository**
+```bash
+git clone <repo-url>
+cd document_anonymizer
+```
+
+2. **Installa dipendenze**
+```bash
+pip install -r requirements.txt
+```
+
+3. **Configura variabili d'ambiente**
+```bash
+cp .env.example .env
+```
+
+Modifica `.env` con le tue credenziali Azure:
+```
+AZURE_ENDPOINT=https://your-resource.openai.azure.com/
+AZURE_API_KEY=your-api-key
+AZURE_ENDPOINT_EMB=https://your-embedding-resource.openai.azure.com/
+AZURE_API_KEY_EMB=your-embedding-api-key
+```
+
+4. **Avvia l'applicazione**
+```bash
+streamlit run main.py
+```
+
+## 🎯 Come Usare
+
+### 1. Upload Documenti
+- Carica file `.txt` nella tab "Upload"
+- Supporta upload multipli
+
+### 2. Anonimizzazione
+- Vai alla tab "Anonimizzazione" 
+- Clicca "Avvia Anonimizzazione"
+- Revisiona e modifica entità rilevate
+- Conferma i documenti
+
+### 3. Analisi AI
+- Tab "Analisi": Analisi Azure OpenAI per singoli documenti
+- Tab "RAG": Chat interattiva con i documenti
+- Tab "CrewAI": Analisi multi-agente avanzate
+
+## 🤖 Agenti CrewAI
+
+- **📄 Document Analyst**: Classificazione e analisi strutturale
+- **😊 Sentiment Analyst**: Analisi emozioni e trend
+- **🎯 Strategy Coordinator**: Sintesi executive e raccomandazioni
+
+## 📁 Struttura Progetto
+
+```
+document_anonymizer/
+├── main.py                 # App Streamlit principale
+├── config.py              # Configurazioni sistema
+├── anonymizer.py          # Sistema anonimizzazione NER+Regex
+├── ai_processor.py        # Azure + RAG + CrewAI
+├── ui_components.py       # Componenti UI riutilizzabili
+├── utils.py               # Funzioni utility
+├── requirements.txt       # Dipendenze Python
+├── .env.example          # Template environment
+└── README.md             # Questa documentazione
+```
+
+## 🔐 Privacy & Sicurezza
+
+- **Privacy by Design**: Anonimizzazione prima di qualsiasi elaborazione AI
+- **GDPR Compliant**: Nessun dato sensibile inviato ai modelli
+- **Controllo Manuale**: Revisione ed editing delle entità rilevate
+- **Tracciabilità**: Cronologia completa delle operazioni
+
+## 🛠️ Entità Supportate
+
+### Regex Pattern
+- **IBAN**: Codici bancari italiani
+- **EMAIL**: Indirizzi email
+- **CF**: Codici fiscali italiani
+- **CARD**: Numeri carte di credito
+- **PHONE**: Numeri di telefono
+
+### NER (Named Entity Recognition)
+- **PER**: Nomi di persone
+- **ORG**: Organizzazioni
+- **LOC**: Luoghi
+- **MISC**: Entità varie
+
+## 📊 Tipi di Analisi CrewAI
+
+### 🔍 Comprensiva
+Analisi completa con tutti e 4 gli agenti per insights 360°
+
+### 📄 Documentale  
+Focus su classificazione, struttura e organizzazione documenti
+
+### 😊 Sentiment
+Analisi emozioni, soddisfazione e trend comunicazioni
+
+### 🔍 RAG Avanzata
+Query complesse con recupero semantico e correlazioni
+
+### ⚙️ Personalizzata
+Selezione manuale agenti per analisi su misura
+
+## 🔧 Configurazione Avanzata
+
+### Modelli Azure
+Modifica in `config.py`:
+```python
+DEPLOYMENT_NAME = "gpt-4o"  # Tuo deployment chat
+AZURE_EMBEDDING_DEPLOYMENT_NAME = "text-embedding-ada-002"  # Tuo deployment embedding
+```
+
+### Pattern Regex Personalizzati
+Aggiungi in `config.py`:
+```python
+REGEX_PATTERNS = {
+    # Pattern esistenti...
+    "CUSTOM_PATTERN": r'your_regex_here'
+}
+```
+
+## 🐛 Troubleshooting
+
+### Errore Azure OpenAI
+- Verifica credenziali in `.env`
+- Controlla deployment names
+- Verifica quota e limiti Azure
+
+### Errore NER Model
+- Controlla connessione internet
+- Aumenta timeout download modello
+- Usa cache Hugging Face
+
+### Performance Lente
+- Riduci dimensione documenti
+- Usa meno chunks per RAG
+- Ottimizza parametri CrewAI
+
+## 📈 Esempi Query
+
+### Business Intelligence
+```
+"Analizza i temi principali nei documenti e identifica possibili rischi operativi"
+```
+
+### Customer Service
+```
+"Valuta il sentiment nelle comunicazioni clienti e suggerisci miglioramenti"
+```
+
+### Compliance
+```
+"Verifica la conformità delle comunicazioni e identifica potenziali problemi legali"
+```
+
+### Strategic Analysis
+```
+"Fornisci un'analisi comprensiva con raccomandazioni strategiche actionable"
+```
+
+## 🤝 Contributi
+
+1. Fork il progetto
+2. Crea feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit modifiche (`git commit -m 'Add AmazingFeature'`)
+4. Push al branch (`git push origin feature/AmazingFeature`)
+5. Apri Pull Request
+
+## 📄 Licenza
+
+Distribuito sotto licenza MIT. Vedi `LICENSE` per maggiori informazioni.
+
+## 📞 Supporto
+
+Per supporto e domande:
+- Apri una Issue su GitHub
+- Contatta il team di sviluppo
+- Consulta la documentazione Azure OpenAI
+
+---
+
+**⚡ Quick Start**: `pip install -r requirements.txt && streamlit run main.py`

data/Mail.txt

@@ -0,0 +1,23 @@
+Da: mario.rossi85@email.com
+A: supporto@smartdocs.srl
+Data: 20 Giugno 2025, 12:30
+Oggetto: Richiesta Cambio IBAN e Chiarimenti Fattura N. 734/2025
+
+Spett.le SmartDocs Srl,
+
+Mi chiamo Mario Rossi e vi contatto in qualità di vostro cliente con Codice Fiscale RSSMRA85M01H501Z.
+
+Vi scrivo in merito all'ultima fattura, la N. 734/2025, che presenta un importo che non mi torna. Vorrei ricevere dei chiarimenti in merito.
+
+Cogliendo l'occasione, vorrei anche aggiornare le mie coordinate bancarie per la domiciliazione dei pagamenti futuri. Il mio attuale indirizzo di fatturazione, che vi prego di non modificare, è Via Garibaldi 10, 20121 Milano (MI).
+
+Il vecchio IBAN da disattivare è IT60X0542811101000000123456.
+
+Vi prego di addebitare le prossime fatture sul mio nuovo conto corrente, il cui IBAN è IT12Y0306909606100000012345.
+
+Per qualsiasi necessità o per fornirmi i chiarimenti richiesti, potete contattarmi telefonicamente al numero 333 1234567.
+
+In attesa di un vostro gentile riscontro, porgo cordiali saluti.
+
+Distinti saluti,
+Mario Rossi

data/contratto1.txt

@@ -0,0 +1,37 @@
+DISDETTA CONTRATTO - RACCOMANDATA A/R
+
+Spett.le TELECOM PLUS S.P.A.
+Servizio Clienti
+Via delle Telecomunicazioni 100
+00100 Roma
+
+Milano, 27 giugno 2025
+
+Oggetto: DISDETTA IMMEDIATA contratto telefonico n. TC789456123 - SERVIZIO PESSIMO
+
+Con la presente comunico la DISDETTA IMMEDIATA del contratto di telefonia mobile intestato a:
+Nome: Roberto Neri
+Codice Cliente: 7894561230
+Numero: +39 335-1122334
+
+MOTIVAZIONI della disdetta (gravi inadempienze contrattuali):
+
+1. COPERTURA INESISTENTE: In 8 mesi di contratto, nella mia zona residenziale (Zona San Siro, Milano) il segnale è SEMPRE assente o insufficiente. Chiamate che cadono continuamente, internet inutilizzabile.
+
+2. FATTURAZIONI ERRATE: Ho ricevuto 3 addebiti non dovuti per servizi mai richiesti (€ 45 totali) che, nonostante le segnalazioni, NON avete mai rimborsato.
+
+3. ASSISTENZA CLIENTI INADEGUATA: Tempo di attesa medio 45 minuti, operatori incompetenti che non risolvono mai i problemi. Ho perso GIORNI interi al telefono con voi.
+
+4. PROMESSE NON MANTENUTE: Mi avevate garantito "copertura ottimale" e "assistenza premium" - TUTTO FALSO!
+
+Pretendo:
+- Cessazione immediata del servizio senza penali (giusta causa ex art. 1456 C.C.)
+- Rimborso degli addebiti non dovuti (€ 45)
+- Rimborso quota parte ultimo mese non utilizzabile
+
+Se non riceverò conferma entro 7 giorni, procederò per vie legali.
+
+NON consiglierò MAI i vostri servizi a nessuno.
+
+Distinti saluti,
+Roberto Neri

data/contratto2.txt

@@ -0,0 +1,52 @@
+🤝 ACCORDO DI PARTNERSHIP STRATEGICA 🤝
+
+Tra le prestigiose aziende:
+
+🏢 INNOVATECH S.R.L.
+Via Tecnologia 45 - 20099 Milano (MI)
+P.IVA: 12345678901
+Rappresentata dall'Amministratore Delegato Ing. Marco Bernardini
+
+🏢 FUTURE SOLUTIONS S.P.A.  
+Corso Europa 123 - 20100 Milano (MI)
+P.IVA: 98765432109
+Rappresentata dal Presidente Dott.ssa Anna Verdi
+
+Si stipula il presente accordo di collaborazione con grande entusiasmo e fiducia reciproca!
+
+🎯 OBIETTIVI DELLA PARTNERSHIP:
+- Sviluppo congiunto di soluzioni innovative per l'industria 4.0
+- Condivisione know-how e best practices tecnologiche  
+- Espansione su mercati internazionali (Focus: Germania e Francia)
+- Ricerca e sviluppo progetti all'avanguardia
+
+💰 ASPETTI ECONOMICI:
+- Investimento comune: € 500.000 (50% ciascuna parte)
+- Ripartizione ricavi: 60% InnovaTech - 40% Future Solutions
+- Durata: 3 anni rinnovabili automaticamente
+- Target fatturato congiunto primo anno: € 2.000.000
+
+🌟 VANTAGGI ESCLUSIVI:
+✅ Accesso reciproco a tecnologie proprietarie
+✅ Team di lavoro integrato (20 ingegneri top-level)
+✅ Sinergie commerciali e di marketing
+✅ Condivisione reti distributive europee
+✅ Supporto R&D per brevetti internazionali
+
+🎉 MILESTONE PREVISTE:
+- Luglio 2025: Lancio primo prodotto congiunto
+- Settembre 2025: Partecipazione fiera tecnologica Monaco
+- Dicembre 2025: Apertura filiale comune Berlino
+- Marzo 2026: Presentazione piattaforma AI proprietaria
+
+Le parti si impegnano a collaborare con spirito costruttivo e trasparenza totale per il successo di questa entusiasmante avventura imprenditoriale!
+
+Milano, 27 giugno 2025
+
+Firma InnovaTech: _________________    Firma Future Solutions: _________________
+    (Ing. M. Bernardini)                    (Dott.ssa A. Verdi)
+
+Testimoni:
+Dr. Roberto Fiori _________________    Avv. Silvia Monti _________________
+
+🍾 Brindisi di celebrazione previsto per il 30/06/2025 ore 18:00! 🥂

data/contratto3.txt

@@ -0,0 +1,29 @@
+CONTRATTO DI LOCAZIONE AD USO ABITATIVO
+
+Tra:
+LOCATORE: Sig.ra Maria Bianchi, nata a Milano il 12/03/1975, residente in Via Roma 45, Milano (MI), C.F. BNCMRA75C52F205X
+
+CONDUTTORE: Sig. Giuseppe Verdi, nato a Torino il 08/07/1990, residente in Via Garibaldi 23, Torino (TO), C.F. VRDGPP90L08L219Y
+
+IMMOBILE: Appartamento sito in Milano, Via Manzoni 78, piano 3°, composto da 3 vani più servizi, superficie 85 mq, categoria catastale A/2, foglio 123, particella 456.
+
+CONDIZIONI:
+- Durata: 4 anni dal 01/09/2025 al 31/08/2029
+- Canone mensile: € 1.200,00 (milleduecento/00)
+- Deposito cauzionale: € 2.400,00 (due trimestri)
+- Spese condominiali: a carico del conduttore, stimate in € 150,00 mensili
+
+CLAUSOLE PARTICOLARI:
+1. Il conduttore si impegna a mantenere l'immobile in buono stato di conservazione
+2. Non sono ammessi animali domestici
+3. Il pagamento deve avvenire entro il giorno 5 di ogni mese
+4. Eventuali modifiche strutturali devono essere preventivamente autorizzate
+5. Il conduttore è responsabile delle utenze (luce, gas, acqua, telefono)
+
+Il presente contratto è regolato dalla Legge 431/98 e successive modificazioni.
+
+Milano, 25 agosto 2025
+
+Firma Locatore: _________________    Firma Conduttore: _________________
+
+Registrato a Milano il _________ al n. _______ Serie ___

data/email1.txt

@@ -0,0 +1,11 @@
+Gentile Dott. Rossi,
+
+mi chiamo Luca Bianchi, nato a Milano il 12/03/1985, attualmente residente in Via Roma 24, 20121 Milano.
+
+Le scrivo in merito a un accredito errato sul mio conto bancario IT60X0542811101000000123456 presso la banca Intesa Sanpaolo.
+In allegato trova una copia del mio codice fiscale: BNCGLC85C12F205X.
+
+In attesa di un suo riscontro, porgo cordiali saluti.
+Luca Bianchi
+luca.bianchi85@gmail.com
+Telefono: +39 349 123 4567

data/email2.txt

@@ -0,0 +1,23 @@
+Oggetto: INACCETTABILE - Ritardo nella consegna e prodotto danneggiato
+
+Gentili Signori,
+
+sono ESTREMAMENTE deluso e arrabbiato per il servizio pessimo che ho ricevuto dalla vostra azienda.
+
+Ho ordinato il 15 maggio un laptop del valore di €1.200 con consegna garantita entro 5 giorni lavorativi. Sono passate DUE SETTIMANE e il prodotto è arrivato oggi in condizioni VERGOGNOSE: la scatola era completamente ammaccata e lo schermo del laptop presenta una crepa evidente.
+
+Questo è inaccettabile! Ho pagato per un prodotto nuovo e perfetto, non per un rottame. Inoltre, la vostra assistenza clienti è stata inutile: nessuno ha risposto alle mie 4 chiamate e alle 3 email inviate.
+
+Pretendo IMMEDIATAMENTE:
+1. La sostituzione completa del prodotto
+2. Il rimborso delle spese di spedizione
+3. Un risarcimento per il disagio causato
+
+Se non riceverò una risposta entro 48 ore, sarò costretto a rivolgermi alle autorità competenti e a pubblicare recensioni negative su tutti i portali online.
+
+Questa è l'ultima volta che ordino da voi.
+
+Distinti saluti,
+Marco Rossi
+Tel: 339-1234567
+Email: m.rossi@email.com

data/email3.txt

@@ -0,0 +1,20 @@
+Oggetto: Grazie di cuore per il servizio eccezionale! ⭐⭐⭐⭐⭐
+
+Carissimi,
+
+non riesco a contenere la mia gioia e devo assolutamente condividere con voi quanto sono soddisfatto del vostro servizio!
+
+Ho ricevuto ieri il set di mobili per il soggiorno che avevo ordinato due settimane fa, e devo dire che avete superato ogni mia aspettativa. La qualità è semplicemente fantastica, i materiali sono pregiati e la lavorazione è impeccabile. Inoltre, il team di montaggio è stato professionale, gentile e ha completato tutto in tempi record.
+
+Ma ciò che mi ha colpito di più è stata l'attenzione ai dettagli: avete persino pulito tutto dopo il montaggio e mi avete spiegato come prendermi cura al meglio dei mobili. Questo è quello che chiamo VERO servizio clienti!
+
+Sono così entusiasta che ho già consigliato la vostra azienda a tre amici, e sto già pensando di ordinare i mobili per la camera da letto.
+
+Continuate così, siete davvero i migliori del settore!
+
+Con immensa gratitudine,
+Sofia Martinelli
+📧 s.martinelli@email.com
+📱 347-9876543
+
+P.S. Allego alcune foto del risultato finale - sono orgogliosissima del mio nuovo soggiorno!

data/email4.txt

@@ -0,0 +1,34 @@
+Oggetto: Aggiornamento procedure sicurezza ufficio - Effettivo dal 01/07/2025
+
+Gentili Colleghi,
+
+con la presente comunico l'aggiornamento delle procedure di sicurezza che entreranno in vigore dal 1° luglio 2025, come da delibera del Consiglio di Amministrazione del 20 giugno 2025.
+
+Le principali modifiche riguardano:
+
+1. ACCESSO AGLI UFFICI
+- Obbligo di badge magnetico per tutti i dipendenti
+- Registrazione orari di entrata e uscita tramite lettore automatico
+- Accesso visitatori solo previo appuntamento e accompagnamento
+
+2. PROCEDURE EMERGENZA
+- Nomina di due nuovi addetti antincendio per il piano terra
+- Aggiornamento planimetrie di evacuazione (affisse in bacheca)
+- Simulazione evacuazione programmata per il 15 luglio ore 11:00
+
+3. GESTIONE DOCUMENTI
+- Archivio cartaceo: accesso solo con autorizzazione scritta del responsabile
+- Documenti riservati: obbligo di utilizzo cassaforte ufficio
+- Divieto di lasciare documenti sui piani di lavoro oltre l'orario di ufficio
+
+Si ricorda che il mancato rispetto delle procedure comporterà l'applicazione del regolamento disciplinare aziendale.
+
+Per chiarimenti contattare l'Ufficio Risorse Umane (int. 245).
+
+Cordiali saluti,
+
+Dott.ssa Elena Marchetti
+Responsabile Risorse Umane
+ALFA CONSULTING S.R.L.
+elena.marchetti@alfaconsulting.it
+Tel. 02-12345678 int. 201

data/fattura1.txt

@@ -0,0 +1,44 @@
+🌟 FATTURA SERVIZI MATRIMONIALI 🌟
+N° WED2025/078 - Data: 27/06/2025
+
+DREAM WEDDING di Valentina Rossi & Co.
+Via dei Fiori 23 - 20125 Milano (MI)
+P.IVA: 11223344556 ✨
+Tel: 02-5555777 | Email: info@dreamwedding.it
+www.dreamwedding.it
+
+CLIENTI:
+Sig. Alessandro Conti & Sig.ra Giulia Romano
+Via Primavera 12 - 20100 Milano (MI)
+C.F. Alessandro: CNTLSN85M15F205K
+C.F. Giulia: RMNGLA88D25F205P
+
+💕 MATRIMONIO DEL 15/06/2025 - VILLA GRAN PARADISO 💕
+
+SERVIZI FORNITI:
+🎊 Wedding Planner completo (6 mesi coordinamento)              € 3.500,00
+🌺 Allestimento floreale cerimonia e ricevimento               € 2.200,00
+📸 Servizio fotografico professionale (10 ore)                € 1.800,00
+🎵 DJ e service audio completo                                € 1.200,00
+🍰 Torta nuziale 3 piani (80 persone)                        € 450,00
+🎁 Bomboniere personalizzate (80 pezzi)                       € 320,00
+✨ Luci d'atmosfera e decorazioni extra                        € 680,00
+
+TOTALE SERVIZI                                                € 10.150,00
+SCONTO FEDELTÀ CLIENTI AFFEZIONATI 10% 💝                    € -1.015,00
+
+IMPONIBILE                                                    € 9.135,00
+IVA 22%                                                       € 2.009,70
+TOTALE FATTURA                                               € 11.144,70
+
+SALDO (già versato acconto € 5.000,00)                       € 6.144,70
+
+Pagamento: Bonifico bancico entro 30 giorni
+IBAN: IT89 K033 5901 6001 0000 0012 345
+
+Gentili Alessandro e Giulia,
+è stato un onore organizzare il vostro matrimonio da sogno! 
+Grazie per averci scelto per il vostro giorno più bello! 💕
+
+Con affetto,
+Valentina e tutto il team Dream Wedding 🌟

data/fattura2.txt

@@ -0,0 +1,34 @@
+FATTURA N° 2025/0145
+Data: 27/06/2025
+
+STUDIO TECNICO ARCHITETTO LUIGI FERRETTI
+Via Dante 67 - 20121 Milano (MI)
+P.IVA: 12345678901
+Tel: 02-1234567 - Email: info@studioferretti.it
+
+CLIENTE:
+IMMOBILIARE CENTRALE S.R.L.
+Via Torino 45 - 20123 Milano (MI)
+P.IVA: 98765432109
+Codice Destinatario: ABC1234
+
+DESCRIZIONE PRESTAZIONI:
+- Progettazione architettonica preliminare uffici                   € 2.500,00
+- Consulenza tecnica per pratiche edilizie                         € 800,00
+- Sopralluogo e rilievo stato di fatto                            € 450,00
+- Elaborazione planimetrie e sezioni                              € 600,00
+
+TOTALE IMPONIBILE                                                  € 4.350,00
+IVA 22%                                                           € 957,00
+TOTALE FATTURA                                                    € 5.307,00
+
+Contributo previdenziale 4% (Cassa Ingegneri e Architetti)        € 174,00
+Ritenuta d'acconto 20% (su imponibile + contributo)              € 904,80
+
+NETTO A PAGARE                                                    € 4.576,20
+
+Modalità di pagamento: Bonifico bancario
+Scadenza: 27/07/2025 (30 giorni data fattura)
+IBAN: IT60 X054 2811 1010 0000 0123 456
+
+Causale: Fattura n. 2025/0145 del 27/06/2025

data/hr_payslip.txt

@@ -0,0 +1,11 @@
+Gentile Team HR di EY,
+
+sono Giulia Verdi (giulia.verdi@outlook.it), assunta il 01/09/2022, e attualmente in servizio presso l’ufficio di Bologna.
+Il mio codice fiscale è VRDGLL94A41A944C e il conto bancario per l'accredito dello stipendio è IT80P0306909606100000123456.
+
+Vorrei sapere se è disponibile la Certificazione Unica (CU) 2024 e se verrà caricata sulla piattaforma MyEY.
+
+Vi ringrazio anticipatamente.
+
+Cordiali saluti,
+Giulia Verdi

data/legal_communication.txt

@@ -0,0 +1,11 @@
+Gentile Studio Legale Ferri,
+
+mi chiamo Marco Neri, nato a Cagliari il 22/07/1979, attualmente residente in Via Dante 12, 09100 Cagliari.
+La contatto in merito alla questione legale che coinvolge TechNova S.p.A., con sede a Roma, presso la quale ho lavorato dal 2018 al 2023.
+
+I miei dati personali includono il codice fiscale NRIMRC79L22B354U e l’IBAN IT35Z0200801035000101123456.
+Vi prego di confermare la ricezione del presente messaggio e di informarmi sui prossimi passi.
+
+Cordiali saluti,
+Marco Neri
+marco.neri1979@hotmail.com

data/notifica.txt

@@ -0,0 +1 @@
+Meeting con Giovanni alla Sala numero 2 il giorno 12 Marzo

data/report1.txt

@@ -0,0 +1,75 @@
+🌟 RELAZIONE FINALE PROGETTO "SMART OFFICE 2025" 🌟
+Data: 27 giugno 2025
+
+Gentile Direzione Generale,
+
+è con immensa soddisfazione e orgoglio che presento la relazione conclusiva del progetto "Smart Office 2025", che si è rivelato un SUCCESSO STRAORDINARIO oltre ogni più rosea aspettativa!
+
+📊 RISULTATI CONSEGUITI (Obiettivi superati del 150%!):
+
+✅ EFFICIENZA OPERATIVA
+- Produttività aumentata del 45% (target: 25%) 
+- Tempi di elaborazione documenti: -60%
+- Riduzione errori amministrativi: 89%
+- Automazione processi: 95% procedure digitalizzate
+
+✅ SODDISFAZIONE DIPENDENTI  
+- Survey interna: 96% giudizi ECCELLENTI
+- Richieste smart working: +300% (ma gestite perfettamente!)
+- Assenteismo: ridotto del 35%
+- Team building spontaneo: fenomeno bellissimo da osservare!
+
+✅ SOSTENIBILITÀ AMBIENTALE
+- Consumo carta: -78% (abbiamo salvato una foresta! 🌳)
+- Energia elettrica: -32% grazie ai sensori intelligenti
+- Rifiuti ufficio: -65% 
+- Certificazione ISO 14001: OTTENUTA con punteggio massimo!
+
+✅ RISULTATI ECONOMICI FANTASTICI
+- ROI: 340% in soli 6 mesi (incredibile!)
+- Costi operativi: ridotti di € 180.000/anno
+- Investimento recuperato: già al 85%
+- Nuovi clienti acquisiti grazie all'immagine innovativa: +28%
+
+🎯 INNOVAZIONI DI MAGGIOR SUCCESSO:
+
+🤖 SISTEMA AI "SOFIA" (Smart Office Intelligent Assistant)
+Il nostro assistente virtuale è diventato la mascotte dell'ufficio! Gestisce il 90% delle richieste routine e i colleghi hanno iniziato a chiamarla affettuosamente "la nostra Sofia". Ha persino imparato a ricordare i compleanni di tutti!
+
+📱 APP MOBILE "MyOffice"  
+Utilizzo quotidiano: 98% dipendenti. Funzionalità più amata: "Coffee Alert" che avvisa quando il caffè è appena pronto! Geniale e molto apprezzata.
+
+🌐 PIATTAFORMA COLLABORATIVA CLOUD
+Zero downtime in 6 mesi! Collaborazione remota fluida al 100%. Alcuni clienti ci hanno chiesto di replicare il sistema per loro!
+
+💚 WELLNESS CORNER DIGITALE
+Monitoraggio qualità aria, suggerimenti pausa, playlist personalizzate. Il wellness score medio dell'ufficio è "OTTIMO" per il 94% del tempo lavorativo.
+
+🏆 RICONOSCIMENTI ESTERNI:
+- Premio "Innovazione Digitale 2025" - Camera di Commercio Milano
+- Caso studio presentato al convegno "Future of Work" - Bocconi  
+- Articolo su Harvard Business Review Italia (in uscita!)
+- Richieste visite studio da 12 aziende europee
+
+👏 IL TEAM DEL PROGETTO:
+Voglio ringraziare pubblicamente il team eccezionale che ha reso possibile questo miracolo:
+- Ing. Laura Colombo (Project Manager): Leadership ispirazionale
+- Dr. Andrea Fontana (IT Specialist): Genio tecnico 
+- Dott.ssa Marta Pellegrini (Change Manager): Empatia e professionalità
+- Tutto il team di sviluppo: 15 persone STRAORDINARIE
+
+🎉 CONCLUSIONI:
+Il progetto "Smart Office 2025" non è solo riuscito, è diventato un MODELLO per l'intero settore! Abbiamo trasformato il nostro ambiente di lavoro in un ecosistema digitale armonioso dove tecnologia e umanità convivono perfettamente.
+
+I dipendenti arrivano al mattino con il sorriso, i clienti sono entusiasti delle nostre innovazioni, e la competitività aziendale è aumentata esponenzialmente.
+
+🚀 PROSSIMI PASSI:
+Propongo di avviare immediatamente "Smart Office 3.0" per consolidare la nostra leadership tecnologica!
+
+Con gratitudine e entusiasmo per i successi futuri,
+
+Dott.ssa Chiara Benedetti
+Direttore Innovazione e Sviluppo
+c.benedetti@azienda.it | Tel: 02-7777999
+
+P.S. Allego 47 foto del progetto e 200+ feedback entusiastici dei dipendenti! 📸✨

data/report2.txt

@@ -0,0 +1,56 @@
+REPORT URGENTE - GRAVI DISFUNZIONI SISTEMA INFORMATICO
+Data: 27/06/2025 - Priorità: MASSIMA
+
+Destinatario: Direzione Generale, CTO, Responsabile IT
+Da: Dott. Francesco Lombardi - Responsabile Operazioni
+
+PREMESSA:
+La situazione del sistema informatico aziendale è DEGENERATA oltre ogni limite di tolleranza. I continui malfunzionamenti stanno paralizzando l'intera operatività aziendale con danni economici incalcolabili.
+
+PROBLEMI CRITICI RILEVATI:
+
+1. SERVER PRINCIPALE - COLLASSI QUOTIDIANI
+- 15 blocchi totali negli ultimi 7 giorni
+- Perdita dati: 3 database corrotti irreversibilmente  
+- Downtime complessivo: 47 ore in una settimana
+- INACCETTABILE per un'azienda della nostra dimensione!
+
+2. RETE AZIENDALE - PRESTAZIONI DISASTROSE
+- Velocità di connessione: 20% rispetto ai parametri contrattuali
+- Email server: funzionante solo 6 ore su 24
+- Condivisione files: IMPOSSIBILE da 5 giorni
+- I dipendenti NON RIESCONO A LAVORARE!
+
+3. SOFTWARE GESTIONALE - COMPLETAMENTE INADEGUATO
+- Crash dell'applicazione: 8-10 volte al giorno
+- Dati clienti inaccessibili da 72 ore
+- Fatturazione elettronica: BLOCCATA da giovedì
+- Contabilità: calcoli errati per € 50.000
+
+4. BACKUP SYSTEM - TOTALMENTE COMPROMESSO
+- Ultimo backup funzionante: 12 giorni fa
+- Sistema di sicurezza: DISATTIVATO da settimane
+- Rischio perdita TUTTI i dati aziendali
+
+CONSEGUENZE DEVASTANTI:
+- Ordini clienti persi: € 120.000 in 3 giorni
+- Reclami clienti: +400% rispetto al mese scorso  
+- Produttività dipendenti: -70%
+- Reputation aziendale: COMPROMESSA GRAVEMENTE
+
+AZIONI IMMEDIATE RICHIESTE:
+1. Sostituzione TOTALE dell'infrastruttura IT entro 48 ore
+2. Contratto assistenza H24 con azienda specializzata SERIA
+3. Licenziamento immediato del fornitore attuale
+4. Budget emergenza: minimo € 200.000
+
+Se non si interviene SUBITO, l'azienda rischia il fallimento!
+
+La mia responsabilità è avvisarvi: HO FATTO IL MIO DOVERE.
+Ora spetta alla Direzione AGIRE IMMEDIATAMENTE!
+
+Dott. Francesco Lombardi
+Responsabile Operazioni
+f.lombardi@azienda.it - Tel. 02-9999888 (SEMPRE RAGGIUNGIBILE)
+
+NOTA: Invio copia per conoscenza anche al Consiglio di Amministrazione

docs/ARCHITECTURE.md

@@ -0,0 +1,291 @@
+# Agentic RAG Advanced Documentation  
+
+![Project Status: In Progress](https://img.shields.io/badge/status-in%20progress-orange)  
+![Python Version](https://img.shields.io/badge/python-3.9%2B-blue)  
+![LangChain](https://img.shields.io/badge/LangChain-Enabled-brightgreen)  
+![Azure OpenAI](https://img.shields.io/badge/Azure%20OpenAI-GPT--4-informational)  
+
+---
+
+## Table of Contents  
+1. [Advanced Architecture Overview](#advanced-architecture-overview)  
+   - [System Architecture Diagram](#system-architecture-diagram)  
+   - [Process Flow Diagrams](#process-flow-diagrams)  
+   - [Component Interactions](#component-interactions)  
+   - [Database Schema](#database-schema)  
+2. [Specialized Guides](#specialized-guides)  
+   - [DevOps Deployment Guide](#devops-deployment-guide)  
+   - [Security Best Practices](#security-best-practices)  
+   - [Performance Tuning](#performance-tuning)  
+   - [Monitoring and Observability](#monitoring-and-observability)  
+   - [Testing Strategies](#testing-strategies)  
+3. [In-Depth Technical Documentation](#in-depth-technical-documentation)  
+   - [Design Patterns](#design-patterns)  
+   - [Architectural Decisions and Trade-Offs](#architectural-decisions-and-trade-offs)  
+   - [Dependency Mapping](#dependency-mapping)  
+   - [Error Handling Strategy](#error-handling-strategy)  
+4. [Templates and Boilerplate](#templates-and-boilerplate)  
+   - [Feature Template](#feature-template)  
+   - [Example Configurations](#example-configurations)  
+   - [Automation Scripts](#automation-scripts)  
+   - [Docker and Kubernetes Configurations](#docker-and-kubernetes-configurations)  
+5. [Governance and Processes](#governance-and-processes)  
+   - [Code Review Guidelines](#code-review-guidelines)  
+   - [Branch Strategy](#branch-strategy)  
+   - [CI/CD Pipeline](#ci/cd-pipeline)  
+   - [Release Process](#release-process)  
+
+---
+
+## Advanced Architecture Overview  
+
+### System Architecture Diagram  
+
+```mermaid
+graph TD
+    User[User Interface (Streamlit)] -->|Sends Requests| API[REST API Gateway]
+    API -->|Processes Requests| Orchestrator[Multi-Agent Orchestrator (CrewAI)]
+    Orchestrator -->|Anonymize Data| NER[NER Anonymizer Module]
+    Orchestrator -->|Query GPT-4| GPT[Azure GPT-4 Processor]
+    Orchestrator -->|Retrieve Data| DB[Document Vector Database (FAISS)]
+    GPT --> Dashboard[Interactive Dashboard]
+    DB --> GPT
+    NER --> Dashboard
+```
+
+---
+
+### Process Flow Diagrams  
+
+#### Data Anonymization Flow  
+
+```mermaid
+flowchart TD
+    Start[Input Document]
+    Start --> |Recognize Entities| NER[NER Anonymization Engine]
+    NER --> |Mask Sensitive Information| MaskedDoc[Masked Document]
+    MaskedDoc --> |Save to Secure DB| DB[(Database)]
+    MaskedDoc --> Output[Anonymized Output]
+```
+
+#### Semantic Query Workflow  
+
+```mermaid
+flowchart TD
+    Query[User Query] -->|Embed Query| Embedding[Embedding Generation]
+    Embedding -->|Search Similar Vectors| FAISS[FAISS Database]
+    FAISS -->|Retrieve Relevant Context| Context[Contextual Data]
+    Context -->|Augment Query| GPT[Azure GPT-4]
+    GPT --> Answer[Generated Answer]
+```
+
+---
+
+### Component Interactions  
+
+```mermaid
+graph LR
+    Frontend[User Interface] --> Backend[API Gateway]
+    Backend --> Orchestrator
+    Orchestrator --> Modules{Processing Modules}
+    Modules --> DB[Database]
+    Modules --> LLM[Azure GPT-4]
+```
+
+---
+
+### Database Schema  
+
+| **Table Name**      | **Description**                       | **Key Fields**             |  
+|----------------------|---------------------------------------|----------------------------|  
+| `documents`          | Stores uploaded and processed docs   | `doc_id`, `content`        |  
+| `anonymous_entities` | Tracks anonymized entities           | `entity_id`, `doc_id`      |  
+| `query_logs`         | Logs semantic queries and responses  | `query_id`, `timestamp`    |  
+
+---
+
+## Specialized Guides  
+
+### DevOps Deployment Guide  
+
+1. **Infrastructure Setup**:  
+   - Provision an Azure Virtual Machine with at least **8 CPUs and 32GB RAM**.  
+   - Add storage for large-scale document processing.  
+
+2. **Install Dependencies**:  
+   ```bash
+   apt update && apt install -y python3.9 python3-pip docker.io
+   pip install -r requirements.txt
+   ```
+
+3. **Setup Docker**:  
+   Create a `Dockerfile` for local builds:  
+   ```dockerfile
+   FROM python:3.9-slim
+   WORKDIR /app
+   COPY . .
+   RUN pip install -r requirements.txt
+   CMD ["python", "main.py"]
+   ```
+
+4. **Deploy Using Docker Compose**:  
+   ```yaml
+   version: '3'
+   services:
+     api:
+       build: .
+       ports:
+         - "8000:8000"
+       environment:
+         AZURE_KEY: "your-azure-key"
+   ```  
+
+5. **Kubernetes Deployment**: Refer to [this guide](#docker-and-kubernetes-configurations).  
+
+---
+
+### Security Best Practices  
+
+- **API Keys Management**: Use Azure Managed Service Identity for secure secrets storage.  
+- **Data Encryption**: Ensure TLS/SSL encryption for all API traffic.  
+- **Access Control**: Implement Role-Based Access Control (RBAC) for sensitive endpoints.  
+
+---
+
+### Performance Tuning  
+
+1. Optimize GPT-4 querying by using embeddings for context filtering prior to API requests.  
+2. Enable multi-threading in the CrewAI orchestrator to handle concurrent tasks.  
+
+---
+
+### Monitoring and Observability  
+
+- **Prometheus Integration**: Export metrics for anonymization time, query processing, and API latency.  
+- **Grafana Dashboards**: Visualize real-time pipeline performance.  
+
+---
+
+### Testing Strategies  
+
+1. **Unit Testing**: For individual modules (`pytest` recommended).  
+2. **Integration Testing**: Simulate end-to-end document anonymization and querying.  
+3. **Load Testing**: Verify performance at scale using `locust.io`.  
+
+---
+
+## In-Depth Technical Documentation  
+
+### Design Patterns  
+
+- **Pipeline Pattern**: For sequential document processing.  
+- **Microservices**: Each module (NER, RAG, etc.) is stateless and deployable as an independent service.  
+
+---
+
+### Architectural Decisions and Trade-Offs  
+
+- **Database Choice**: Chose FAISS for fast vector processing over traditional SQL solutions.  
+- **Cloud Provider**: Azure selected for GPT-4 and machine-learning optimizations.  
+
+---
+
+### Dependency Mapping  
+
+| **Dependency**   | **Version**    | **Purpose**                                |  
+|-------------------|----------------|--------------------------------------------|  
+| `LangChain`       | `>=0.5.0`      | RAG implementation                         |  
+| `transformers`    | `>=4.10.0`     | NER and embeddings                         |  
+| `faiss-cpu`       | `>=1.7.0`      | Vector search database                     |  
+
+---
+
+### Error Handling Strategy  
+
+- **Retries**: Use exponential backoff for Azure API calls.  
+- **Logging**: Ensure all errors are logged to a central ELK stack (Elasticsearch, Logstash, Kibana).  
+
+---
+
+## Templates and Boilerplate  
+
+### Feature Template  
+
+**Feature Name**:  
+Description:  
+Owner:  
+
+---
+
+### Example Configurations  
+
+**Streamlit Configuration:**  
+```python
+[server]
+headless = true
+port = 8501
+```
+
+---
+
+### Automation Scripts  
+
+- **Deployment Automation**:  
+   ```bash
+   ./deploy.sh
+   ```
+
+---
+
+### Docker and Kubernetes Configurations  
+
+```yaml
+apiVersion: apps/v1  
+kind: Deployment  
+metadata:
+  name: agentic-rag  
+spec:
+  replicas: 3  
+  selector:
+    matchLabels:
+      app: agentic-rag  
+  template:
+    metadata:
+      labels:
+        app: agentic-rag  
+    spec:
+      containers:
+      - name: agentic-rag-api  
+        image: agentic-rag:latest  
+```
+
+---
+
+## Governance and Processes  
+
+### Code Review Guidelines  
+
+- Ensure all new features include unit tests.  
+- Verify adherence to the PEP-8 coding standard.  
+
+---
+
+### Branch Strategy  
+
+- Use **GitFlow** with `feature/`, `release/`, and `hotfix/` prefixes.  
+
+---
+
+### CI/CD Pipeline  
+
+1. Automated builds on `push` events to `main`.  
+2. Deploy to staging for all pull requests.  
+
+---
+
+### Release Process  
+
+- Generate a changelog using conventional commits.  
+- Tag releases with semantic versioning (`vX.Y.Z`).  
+
+---

docs/INDEX.md

@@ -0,0 +1,112 @@
+# 📚 Indice Documentazione
+
+Documentazione tecnica completa generata automaticamente per questo progetto.
+
+## 🎯 Panoramica
+
+Questa documentazione è stata creata utilizzando un sistema di **3 agenti CrewAI specializzati** che hanno analizzato il progetto per fornire:
+
+- **Analisi architetturale** completa
+- **Guide tecniche** dettagliate  
+- **Template riutilizzabili** per future implementazioni
+- **Best practices** e raccomandazioni
+
+---
+
+## 📋 Documenti Disponibili
+
+### 🚀 **Documenti Principali**
+
+#### 📖 **Documentazione Principale**
+**File**: [`README.md`](README.md)  
+**Descrizione**: Guida completa con installazione, configurazione e utilizzo del progetto
+
+#### 🏗️ **Architettura e Design**
+**File**: [`ARCHITECTURE.md`](ARCHITECTURE.md)  
+**Descrizione**: Diagrammi di sistema, design patterns, deployment e best practices
+
+#### 📋 **Template Riutilizzabili**
+**File**: [`PROMPT_TEMPLATE.md`](PROMPT_TEMPLATE.md)  
+**Descrizione**: Template e prompt per generare documentazione simile per altri progetti
+
+#### 🔍 **Analisi Tecnica**
+**File**: [`TECHNICAL_ANALYSIS.md`](TECHNICAL_ANALYSIS.md)  
+**Descrizione**: Analisi approfondita di tecnologie, dipendenze e decisioni implementative
+
+---
+
+## 🗂️ Struttura Documentazione
+
+```
+docs/
+├── 📖 README.md              # Guida principale e installazione
+├── 🏗️ ARCHITECTURE.md       # Architettura e diagrammi  
+├── 🔍 TECHNICAL_ANALYSIS.md  # Analisi tecnica dettagliata
+├── 📋 PROMPT_TEMPLATE.md     # Template riutilizzabili
+└── 📑 INDEX.md               # Questo indice
+```
+
+---
+
+## 🚀 Percorso di Lettura Consigliato
+
+### 👋 **Per Nuovi Utenti**
+1. **Inizia qui**: [`README.md`](README.md) - Setup e primo utilizzo
+2. **Comprendi il progetto**: [`TECHNICAL_ANALYSIS.md`](TECHNICAL_ANALYSIS.md) - Panoramica tecnica
+
+### 🛠️ **Per Sviluppatori**  
+1. **Architettura**: [`ARCHITECTURE.md`](ARCHITECTURE.md) - Design e best practices
+2. **Implementazione**: [`TECHNICAL_ANALYSIS.md`](TECHNICAL_ANALYSIS.md) - Dettagli tecnici
+3. **Estensioni**: [`PROMPT_TEMPLATE.md`](PROMPT_TEMPLATE.md) - Template per nuove feature
+
+### 🚀 **Per DevOps/Deploy**
+1. **Setup**: [`README.md`](README.md) - Installazione e configurazione
+2. **Architettura**: [`ARCHITECTURE.md`](ARCHITECTURE.md) - Deployment e monitoring
+
+---
+
+## 📊 Statistiche Documentazione
+
+- **📁 File documentazione**: 4
+- **🤖 Agenti utilizzati**: 3 (DocumentAnalyzer, ContentProcessor, Documentation)
+- **📅 Generato il**: 2025-06-30 14:46:10
+- **🔄 Aggiornamenti**: Rigenerabile in qualsiasi momento
+
+---
+
+## 🎯 Come Usare Questa Documentazione
+
+### 📖 **Lettura Sequenziale**
+Segui l'ordine consigliato sopra per una comprensione completa del progetto.
+
+### 🔍 **Consultazione Specifica**  
+Vai direttamente al documento che ti interessa usando i link sopra.
+
+### 📋 **Riferimenti Futuri**
+Usa i template per creare documentazione simile per altri progetti.
+
+---
+
+## 🔄 Aggiornamento Documentazione
+
+Questa documentazione è **completamente rigenerabile**. Per aggiornare:
+
+1. **Ricarica il progetto** nel sistema CrewAI
+2. **Riesegui l'analisi** completa
+3. **Scarica la nuova versione** documentata
+
+I template in [`PROMPT_TEMPLATE.md`](PROMPT_TEMPLATE.md) permettono di **mantenere coerenza** tra diverse versioni della documentazione.
+
+---
+
+## 📞 Supporto
+
+- **🐛 Problemi**: Consulta prima [`README.md`](README.md) e [`TECHNICAL_ANALYSIS.md`](TECHNICAL_ANALYSIS.md)
+- **🏗️ Architettura**: Vedi [`ARCHITECTURE.md`](ARCHITECTURE.md) per questioni di design
+- **🔧 Personalizzazioni**: Usa [`PROMPT_TEMPLATE.md`](PROMPT_TEMPLATE.md) come base
+
+---
+
+*🤖 Documentazione generata automaticamente dal sistema CrewAI con 3 agenti specializzati*
+
+*✨ Per rigenerare questa documentazione o applicarla ad altri progetti, utilizza i template forniti*

docs/PROMPT_TEMPLATE.md

@@ -0,0 +1,198 @@
+# Prompt Template
+
+Questo template è stato generato automaticamente per il progetto.
+
+## Template
+
+```
+---
+
+## Prompt Template: **Modulare e Riutilizzabile per Progetto Tecnico**
+
+### **SEZIONE CONTESTO**  
+```
+# **Descrizione del Progetto**  
+Descrivi brevemente il progetto, includendo obiettivi principali e scopo.  
+
+**Nome Progetto**: {PROJECT_NAME}  
+**Descrizione Generale**: {PROJECT_DESCRIPTION}  
+- **Obiettivi Principali**:  
+  1. {OBJECTIVE_1}  
+  2. {OBJECTIVE_2}  
+  3. {OBJECTIVE_3}  
+
+**Tecnologie Utilizzate**:  
+- Linguaggi: {LANGUAGES_USED}  
+- Librerie/Framework:  
+  1. {LIBRARY_1}  
+  2. {LIBRARY_2}  
+  3. {LIBRARY_3}  
+
+**Architettura del Progetto**:  
+- Struttura generale: {ARCHITECTURE_OVERVIEW}  
+- Moduli chiave:  
+  - {MODULE_1}  
+  - {MODULE_2}  
+  - {MODULE_3}  
+
+**Obiettivi e Requisiti Funzionali**:  
+1. {REQUIREMENT_1}  
+2. {REQUIREMENT_2}  
+3. {REQUIREMENT_3}  
+```
+
+---
+
+### **SEZIONE ISTRUZIONI**  
+```
+# **Istruzioni per Implementazione o Modifica**  
+Fornisci istruzioni dettagliate con placeholder che possono essere adattati a task specifici.  
+
+### **Passaggi da Seguire per Completare il Task**:  
+1. **Input e Setup**:  
+   - Carica il file o dataset di esempio in formato: {INPUT_FORMAT}  
+   - Configura le variabili d’ambiente utilizzando il file `{CONFIG_FILE}`.  
+
+2. **Anonimizzazione e Analisi**:  
+   - Utilizza il modulo `{ANONYMIZATION_MODULE}` per eseguire l'anonimizzazione dei dati con il seguente comando:  
+     ```
+     python {SCRIPT_NAME} --input {INPUT_PATH} --output {OUTPUT_PATH}
+     ```  
+   - Per implementare un nuovo modello di NER, inserisci il modello `{NEW_MODEL_NAME}` nella configurazione del modulo `{NER_MODULE}`.  
+
+3. **Integrazione Multi-Agente**:  
+   - Definisci gli agenti richiesti nel file `{AGENT_CONFIG_FILE}`.  
+   - Avvia la pipeline tramite il comando:  
+     ```
+     python {AGENT_SCRIPT} --config {AGENT_CONFIG_PATH}
+     ```  
+
+4. **Modifica o Implementazione Specifica**:  
+   - Sostituisci `{PLACEHOLDER_CODE_OR_FUNCTION}` nel modulo `{SPECIFIC_MODULE}` come segue:  
+     ```
+     def {FUNCTION_NAME}(params):
+         # New implementation here
+         return updated_result
+     ```  
+
+### **Dettagli di Configurazione**  
+- File di configurazione richiesti:  
+  - `{CONFIG_FILE_1}`  
+  - `{CONFIG_FILE_2}`  
+
+- Variabili d’ambiente chiave:  
+  ```
+  API_KEY={YOUR_API_KEY}  
+  ENDPOINT={YOUR_ENDPOINT}  
+  MODEL_NAME={MODEL_NAME}  
+  ```  
+
+### **Good Practices**  
+- **Backup**: Effettua un backup dei dati caricati nella cartella `{BACKUP_FOLDER}` prima di processarli.  
+- **Logging**: Utilizza sempre il modulo `{LOGGING_MODULE}` per monitorare l'esecuzione.  
+```
+
+---
+
+### **SEZIONE ESEMPI**  
+```
+# **Codice di Esempio**  
+
+### **Anonimizzazione con Modulistica NER**  
+Esegui un mascheramento di dati sensibili utilizzando una regex e modelli NER.  
+```python
+from transformers import pipeline  
+import re  
+
+def anonymize_text(text):  
+    # Named Entity Recognition  
+    ner_model = pipeline("ner", model="{MODEL_NAME}", tokenizer="{TOKENIZER_NAME}")  
+    entities = ner_model(text)  
+    
+    # Mascherare con regex entità sensibili  
+    anonymized_text = re.sub(r"{PATTERN}", "{MASKING_VALUE}", text)  
+    return anonymized_text  
+
+input_text = "Informazioni sensibili: Nome=John, IBAN=DE89 3704 0044 0532 0130 00."  
+print(anonymize_text(input_text))  
+```  
+
+### **Esempio di RAG Workflow con LangChain**  
+Esegui il retrieval semantico su una knowledge base per rispondere a domande.  
+```python
+from langchain.chains import RetrievalQA  
+from langchain.vectorstores import FAISS  
+from langchain.llms.openai import OpenAI  
+
+# Setup del modello e vector store  
+vector_store = FAISS.load_local("{VECTOR_STORE_PATH}")  
+qa_chain = RetrievalQA(llm=OpenAI(model="{GPT_MODEL}"), retriever=vector_store.as_retriever())  
+
+# Domanda di esempio  
+query = "Qual è l'analisi contenuta nel documento X?"  
+response = qa_chain.run(query)  
+print(response)  
+```  
+
+### **Orchestrazione Multi-Agente**  
+Utilizza CrewAI per analisi distribuita.  
+```python
+from crewai.agent import Agent  
+from crewai.orchestrator import Orchestrator  
+
+# Definizione agenti  
+agent1 = Agent(name="SentimentAnalysisAgent", task="{TASK}", model="{MODEL_NAME}")  
+agent2 = Agent(name="SummarizationAgent", task="text_summary", model="{MODEL_NAME}")  
+
+# Orchestrazione  
+orchestrator = Orchestrator(agents=[agent1, agent2])  
+orchestrator.run(input_data="{INPUT_PATH}")  
+```  
+
+---
+
+### **SEZIONE OUTPUT**  
+```
+# **Formato Output Desiderato**  
+Specifica come l'output deve essere strutturato per soddisfare i criteri.  
+
+### **Formato e Struttura dei Dati**  
+- Formato file: {OUTPUT_FORMAT}  
+- Struttura dei dati:  
+  ```json  
+  {  
+      "document_id": "{ID}",  
+      "analysis_results": {  
+          "anonymization_status": "{STATUS}",  
+          "key_insights": [  
+              "{INSIGHT_1}",  
+              "{INSIGHT_2}"  
+          ]  
+      }  
+  }  
+  ```  
+
+### **Criteri di Qualità dell’Output**  
+1. **Accuratezza**: Dati anonimizzati al 100% con nessuna informazione sensibile visibile.  
+2. **Completeness**: Ogni documento deve includere un set completo di analisi (anonimizzazione, sintesi, sentiment analysis).  
+3. **Formato Consistente**: Risultati esportati come JSON, leggibile e standard.  
+
+### **Guida per Validazione**  
+Esegui un controllo di validazione su campioni usando il modulo `{VALIDATION_MODULE}` e il comando:  
+```
+python validate.py --input {OUTPUT_PATH} --schema {SCHEMA_PATH}  
+```
+```
+
+---
+
+Questo prompt template modulare offre una struttura completa per descrivere, istruire e contestualizzare un progetto basato su tecnologie avanzate con Placeholders chiaramente definiti. È progettato per essere riutilizzabile su diversi tipi di implementazioni simili al progetto **Agentic RAG**.
+```
+
+## Come utilizzare
+
+1. Copia il template sopra
+2. Sostituisci le variabili con i valori appropriati
+3. Utilizza per generare documentazione simile
+
+*Generato automaticamente il 2025-06-30 14:46:10*

docs/TECHNICAL_ANALYSIS.md

@@ -0,0 +1,159 @@
+# Analisi Tecnica
+
+## Panoramica
+
+---
+## 1. **PANORAMICA GENERALE**  
+
+### Tipo di Progetto/Contenuto
+Il progetto denominato **Agentic RAG** si concentra sull'implementazione di una pipeline di elaborazione documentale automatizzata, con lo scopo di:
+- Garantire **anonimizzazione completa dei dati sensibili** nei documenti tramite tecniche avanzate di riconoscimento entità (NER) e regex.
+- Offrire **analisi semantica** e risposte intelligenti basandosi su modelli LLM (Large Language Models).
+- Costruire una **piattaforma scalabile** che integri tecnologie multi-agente per processi di analisi avanzata.
+
+### Tecnologie Principali Identificate
+- **Linguaggi**: Python.  
+- **Framework & librerie principali**:
+  - [LangChain](https://www.langchain.com): Per l'implementazione della Retrieval-Augmented Generation (RAG).
+  - [Streamlit](https://streamlit.io): Per la costruzione dell'interfaccia web.
+  - [Transformers](https://huggingface.co): Per tecniche di analisi NER con modelli come BERT.
+  - [Azure OpenAI](https://azure.microsoft.com/en-us/services/openai/): Per GPT-4 e gestioni embedding per la similarità semantica.
+  - CrewAI: Per orchestrazione di moduli multi-agente.
+- **Soluzioni cloud**:
+  - Azure Integration per GPT-4, embeddings e API OpenAI.
+
+### Struttura Generale
+- **Moduli Software**:
+  - `NERAnonimizer` per l'anonimizzazione.
+  - `AzureProcessor` per la gestione delle analisi tramite GPT-4.
+  - Multi-agente CrewAI per un'analisi distribuita.
+- **Struttura di Presentazione**:
+  - Una dashboard interattiva basata su Streamlit.
+- **Pipeline di Elaborazione**:
+  Il progetto segue un flusso operativo ben definito: **Upload → Anonimizzazione → Analisi → RAG → Multi-Agent Processing → Risultati Finali**.
+
+---
+
+## 2. **ANALISI TECNICA**
+
+### Linguaggi di Programmazione Utilizzati
+- **Python**: Linguaggio principale identificato per tutti i livelli implementativi.
+
+### Framework e Librerie Identificate
+- **LangChain**: Utilizzata per il retrieval semantico dei documenti e la costruzione di chatbot avanzati utilizzando il paradigma Retrieval-Augmented Generation.
+- **Transformers**: Libreria Hugging Face integrata per implementare modelli di Named Entity Recognition (NER) come `"Davlan/bert-base-multilingual-cased-ner-hrl"`.
+- **Streamlit**: Utilizzato per l'interfaccia grafica (dashboard web interattiva).
+- **FAISS (Facebook AI Similarity Search)**: Per la creazione di un Index semantico di vector embedding.
+- **OpenAI Integration**: Per connettività alla piattaforma Azure e utilizzo di modelli GPT-4 e specifici embedding.
+- **dotenv**: Per la gestione delle variabili di configurazione (.env).
+
+### Pattern Architetturali Rilevati
+- **Pipeline di Elaborazione Dati**:
+  1. Analisi e anonimizzazione iniziale tramite moduli NER & regex.
+  2. Creazione di una knowledge base con embeddings per query semantiche.
+  3. Supporto multi-agente tramite CrewAI.
+- **Architettura Layered** (a 5 livelli): Presentazione, Privacy, Semantica, Multi-Agent, Persistenza.
+- **Design Orientato alla Privacy (Privacy by Design)**: Mascheramento dati prima di tutte le elaborazioni AI.
+
+### File di Configurazione Trovati
+- `.env`: File caricati tramite `load_dotenv` per centralizzare:
+  - Chiavi e endpoint API di Azure.
+  - Configurazioni di deploy LLM (`gpt-4o`) e modelli NER.
+
+---
+
+## 3. **STRUTTURA ORGANIZZATIVA**
+
+### Organizzazione Cartelle/File
+```
+Gruppo_2/
+├── 01_Agentic_RAG.py       # Codice principale backend
+├── 01_risposta_progettuale.md   # Analisi e documentazione high-level
+├── 02_Documentazione.md    # Documentazione approfondita tecnica
+├── 02_schema_architetturale.md  # Schema architetturale dettagliato
+├── 03_documenti/           # Documenti sample per test pipeline
+    ├── email3.txt
+    ├── email4.txt
+    ├── notifica.txt
+    ├── report2.txt
+├── 04_documenti/           # Folder per documenti generici anonimi
+└── .env                    # Configurazione sensibile (.gitignored)
+```
+
+### Moduli Principali
+1. **`Config`**:
+   - Gestisce tutte le configurazioni centrali, incluse variabili di ambiente.
+2. **`NERAnonimizer`**:
+   - Effettua mascheramento dati sensibili tramite regex e BERT NER.
+3. **`AzureProcessor`**:
+   - Connette e utilizza GPT-4 e altre capacità AI offerte da Azure OpenAI.
+4. **`CrewAI`**:
+   - Orchestrazione di agenti per processi paralleli distribuiti (analisi multi-agente).
+
+### Punti di Ingresso (Entry Points)
+- **`main()` in 01_Agentic_RAG.py**:
+  - Inizializza la pipeline principale.
+  - Caricamento documenti, setup agenti, esecuzione task CrewAI.
+- **Streamlit Dashboard**:
+  - Entry point utente per operazioni gestionali.
+
+### Dipendenze Principali
+- **Python Core Modules**:
+  - `os`, `re`, `json`, `tempfile`, `pathlib`, `pandas`, `numpy`.
+- **Cloud Services**:
+  - Azure: API embedding, GPT-4 inclusa.
+- **LLM e NLP Tools**:
+  - LangChain, Transformers, FAISS.
+- **Strumenti interattivi**:
+  - Streamlit.
+  
+---
+
+## 4. **CONTESTO FUNZIONALE**
+
+### Funzionalità Principali
+1. **Anonimizzazione Dati Sensibili**:
+   - Mascheramento di dati sensibili come IBAN, email, numeri di carte tramite regex.
+   - Riconoscimento di entità personali/organizzative attraverso NER multilingua.
+2. **Analisi e RAG Integration**:
+   - Recupero e analisi semantica con LangChain+FAISS.
+   - Codifica e costruzione di knowledge base nel vector store.
+3. **Processing Multi-Agente**:
+   - CrewAI consente orchestrazione di analisi parallelizzate suddivise in specializzazioni come sentiment analysis o sintesi documentale.
+4. **Reportistica ed Esportazione**:
+   - Generazione di file JSON contenenti tutte le analisi.
+   - Persistenza di cronologia, log, e risultati utente.
+
+### API o Interfacce Esposte
+- **LangChain Vector Retrieval**:
+  - Accesso per query semantiche e augmented answers.
+- **Streamlit GUI** (frontend integrato):
+  - Tab dedicati per: caricamento file, anonimizzazione, analisi, chatbot interattivi, e gestione multi-agente.
+  
+### Processi di Business Identificati
+- **Conformità Privacy (GDPR)**:
+  - Tutta l’elaborazione avviene su dati anonimizzati.
+  - Export finale contiene solo dati "sicuri".
+- **Analisi Documentale Automatica**:
+  - I documenti caricati subiscono un flusso standardizzato di:
+    - Anonimizzazione.
+    - Classificazione.
+    - Sintesi semantica.
+    - Risposte intelligenti via RAG.
+  
+### Workflow Principali
+1. **Data Processing Workflow**:
+   - Analisi completa basata sull'orchestrazione degli agenti CrewAI.
+   - Editing manuale opzionale sull'interfaccia Streamlit.
+2. **Collaborative Task Management**:
+   - Crew di agenti specializzati automatizza la gestione di più task su documenti multipli.
+
+---
+
+**Complessivamente**, il progetto **Agentic RAG** implementa una pipeline avanzata focalizzata sull'anonimizzazione predittiva, analisi AI distribuita, e presentazione scalabile consolidando tecnologie moderne come NER, regex, LangChain e sistemi multi-agente per rispondere a bisogni legati a privacy, intelligenza aziendale e conformità normativa.
+
+## Metadata
+
+- **Generato il**: 2025-06-30 14:46:10
+- **Tipo sorgente**: File ZIP
+- **Nome sorgente**: Gruppo_2.zip

index.html

@@ -1,19 +1,19 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>
+<!doctype html>
+<html>
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width" />
+		<title>My static Space</title>
+		<link rel="stylesheet" href="style.css" />
+	</head>
+	<body>
+		<div class="card">
+			<h1>Welcome to your static Space!</h1>
+			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
+			<p>
+				Also don't forget to check the
+				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
+			</p>
+		</div>
+	</body>
+</html>

requirements.txt

@@ -0,0 +1,9 @@
+streamlit
+transformers
+langchain
+openai
+python-dotenv
+crewai
+faiss-cpu
+pandas
+numpy

src/ai_processor.py

@@ -0,0 +1,434 @@
+"""
+Tutti i componenti AI: Azure, RAG e CrewAI.
+"""
+
+import re
+from typing import Dict, List
+import streamlit as st
+from openai import AzureOpenAI
+
+# LangChain imports
+from langchain_text_splitters import CharacterTextSplitter
+from langchain_openai import AzureOpenAIEmbeddings, AzureChatOpenAI
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+from langchain_core.prompts import PromptTemplate
+
+# CrewAI imports
+from crewai import Agent, Task, Crew
+from crewai.llm import LLM
+
+from config import Config
+
+class AzureProcessor:
+    """Processore Azure OpenAI"""
+    
+    def __init__(self):
+        self.client = None
+        self.setup_client()
+    
+    def setup_client(self):
+        """Setup client Azure"""
+        if Config.AZURE_API_KEY and Config.AZURE_ENDPOINT:
+            try:
+                self.client = AzureOpenAI(
+                    api_key=Config.AZURE_API_KEY,
+                    api_version=Config.AZURE_API_VERSION,
+                    azure_endpoint=Config.AZURE_ENDPOINT
+                )
+            except Exception as e:
+                st.error(f"Errore Azure OpenAI: {e}")
+                self.client = None
+        else:
+            st.warning("Credenziali Azure OpenAI non trovate.")
+    
+    def process_document(self, anonymized_text: str) -> str:
+        """Processa documento con AI"""
+        if not self.client:
+            return "Azure OpenAI non configurato."
+        
+        try:
+            messages = [
+                {
+                    "role": "system",
+                    "content": (
+                        "Analizza il documento anonimizzato e fornisci:\n"
+                        "1. Tipo di documento\n"
+                        "2. Riepilogo (max 5 righe)\n"
+                        "3. Analisi semantica (temi, sentiment)\n"
+                        "4. Risposta suggerita se è comunicazione cliente\n"
+                        "Usa solo i contenuti del documento fornito."
+                    )
+                },
+                {
+                    "role": "user",
+                    "content": f"Analizza questo documento:\n\n{anonymized_text}"
+                }
+            ]
+            
+            response = self.client.chat.completions.create(
+                model=Config.DEPLOYMENT_NAME,
+                messages=messages,
+                max_tokens=800,
+                temperature=0.7
+            )
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            return f"Errore analisi AI: {e}"
+
+class RAGChatbot:
+    """Chatbot RAG con LangChain"""
+ 
+    def __init__(self):
+        self.vector_store = None
+        self.qa_chain = None
+        self.embeddings = None
+        self.llm = None
+        self.setup_langchain_components()
+ 
+    def setup_langchain_components(self):
+        """Setup componenti LangChain"""
+        if not (Config.AZURE_API_KEY and Config.AZURE_ENDPOINT and
+                Config.AZURE_EMBEDDING_API_KEY and Config.AZURE_EMBEDDING_ENDPOINT):
+            st.warning("Credenziali Azure incomplete. RAG non disponibile.")
+            return
+ 
+        try:
+            # Embeddings
+            self.embeddings = AzureOpenAIEmbeddings(
+                model=Config.AZURE_EMBEDDING_DEPLOYMENT_NAME,
+                api_version=Config.AZURE_API_VERSION,
+                azure_endpoint=Config.AZURE_EMBEDDING_ENDPOINT,
+                api_key=Config.AZURE_EMBEDDING_API_KEY,
+                chunk_size=16
+            )
+            
+            # LLM
+            self.llm = AzureChatOpenAI(
+                deployment_name=Config.DEPLOYMENT_NAME,
+                azure_endpoint=Config.AZURE_ENDPOINT,
+                api_key=Config.AZURE_API_KEY,
+                api_version=Config.AZURE_API_VERSION,
+                temperature=0.2
+            )
+        except Exception as e:
+            st.error(f"Errore setup LangChain: {e}")
+            self.embeddings = None
+            self.llm = None
+ 
+    def build_vector_store(self, anonymized_docs: Dict[str, Dict]):
+        """Costruisce vector store FAISS"""
+        if not self.embeddings or not self.llm:
+            st.error("Componenti LangChain non configurati.")
+            return
+ 
+        # Prepara testi per RAG
+        all_texts = []
+        for filename, doc_data in anonymized_docs.items():
+            if doc_data.get('confirmed', False):
+                all_texts.append(f"Documento {filename}:\n{doc_data['anonymized']}")
+ 
+        if not all_texts:
+            st.warning("Nessun documento confermato per RAG.")
+            return
+ 
+        with st.spinner("Creando vector store..."):
+            # Chunking
+            combined_text = "\n\n".join(all_texts)
+            text_splitter = CharacterTextSplitter(
+                separator="\n\n",
+                chunk_size=1000,
+                chunk_overlap=200,
+                length_function=len,
+            )
+            texts = text_splitter.split_text(combined_text)
+            
+            # Crea FAISS index
+            self.vector_store = FAISS.from_texts(texts, self.embeddings)
+            st.success(f"Vector store con {len(texts)} chunks creato.")
+            
+            # Setup QA chain
+            qa_prompt = """Usa il contesto per rispondere alla domanda.
+Se non sai la risposta, dillo chiaramente.
+
+{context}
+
+Domanda: {question}
+Risposta:"""
+            
+            QA_PROMPT = PromptTemplate.from_template(qa_prompt)
+            
+            self.qa_chain = RetrievalQA.from_chain_type(
+                llm=self.llm,
+                chain_type="stuff",
+                retriever=self.vector_store.as_retriever(),
+                return_source_documents=True,
+                chain_type_kwargs={"prompt": QA_PROMPT}
+            )
+ 
+    def answer_question(self, query: str) -> str:
+        """Risponde usando RAG"""
+        if not self.qa_chain:
+            return "RAG non pronto. Costruisci prima il knowledge base."
+ 
+        try:
+            result = self.qa_chain.invoke({"query": query})
+            answer = result["result"]
+            
+            # Aggiungi fonti se disponibili
+            source_docs = result.get("source_documents", [])
+            if source_docs:
+                answer += "\n\n**Fonti:**\n"
+                for i, doc in enumerate(source_docs):
+                    match = re.search(r"Documento (.*?):\n", doc.page_content)
+                    source_info = f" (da {match.group(1)})" if match else ""
+                    answer += f"- ...{doc.page_content[-100:]}{source_info}\n"
+            
+            return answer
+        except Exception as e:
+            return f"Errore RAG: {e}"
+    
+    def get_relevant_context(self, query: str, max_docs: int = 3) -> str:
+        """Estrae contesto rilevante per query"""
+        if not self.vector_store:
+            return ""
+        
+        try:
+            docs = self.vector_store.similarity_search(query, k=max_docs)
+            context = "\n\n".join([doc.page_content for doc in docs])
+            return context
+        except Exception as e:
+            return f"Errore contesto: {e}"
+
+class CrewAIManager:
+    """Manager agenti CrewAI"""
+   
+    def __init__(self, rag_chatbot: RAGChatbot):
+        self.rag_chatbot = rag_chatbot
+        self.agents = None
+        self.llm = None
+        self.setup_crew()
+   
+    def setup_crew(self):
+        """Setup agenti CrewAI"""
+        if not Config.AZURE_API_KEY:
+            st.warning("Azure non disponibile per CrewAI")
+            return
+       
+        try:
+            # LLM per CrewAI
+            self.llm = LLM(
+                model=f"azure/{Config.DEPLOYMENT_NAME}",
+                api_key=Config.AZURE_API_KEY,
+                base_url=Config.AZURE_ENDPOINT,
+                api_version=Config.AZURE_API_VERSION
+            )
+           
+            # Agenti
+            document_analyst = Agent(
+                role="Document Analyst",
+                goal="Analizzare documenti anonimizzati e fornire insights",
+                backstory="Esperto analista documenti con focus su privacy e compliance. "
+                         "Lavori solo con documenti anonimizzati per proteggere i dati.",
+                llm=self.llm,
+                verbose=True,
+                allow_delegation=False,
+                max_iter=3
+            )
+           
+            rag_specialist = Agent(
+                role="RAG Specialist",
+                goal="Rispondere a domande usando il sistema RAG",
+                backstory="Esperto in Information Retrieval e RAG systems. "
+                         "Specializzato nel recupero di informazioni da documenti anonimizzati.",
+                llm=self.llm,
+                verbose=True,
+                allow_delegation=False,
+                max_iter=3
+            )
+           
+            sentiment_analyst = Agent(
+                role="Sentiment Analyst",
+                goal="Analizzare sentiment e emozioni nei documenti",
+                backstory="Esperto in sentiment analysis e behavioral analytics. "
+                         "Identifichi emozioni, trend e segnali nei documenti.",
+                llm=self.llm,
+                verbose=True,
+                allow_delegation=False,
+                max_iter=3
+            )
+           
+            strategy_coordinator = Agent(
+                role="Strategy Coordinator",
+                goal="Coordinare analisi e fornire raccomandazioni strategiche",
+                backstory="Senior consultant con background in strategic management. "
+                         "Traduci insights tecnici in raccomandazioni business concrete.",
+                llm=self.llm,
+                verbose=True,
+                allow_delegation=True,
+                max_iter=4
+            )
+           
+            self.agents = {
+                'document_analyst': document_analyst,
+                'rag_specialist': rag_specialist,
+                'sentiment_analyst': sentiment_analyst,
+                'strategy_coordinator': strategy_coordinator
+            }
+           
+            st.success("✅ Agenti CrewAI configurati")
+           
+        except Exception as e:
+            st.error(f"Errore setup CrewAI: {e}")
+            self.agents = None
+   
+    def create_analysis_task(self, query: str, analysis_type: str = "comprehensive") -> str:
+        """Crea task di analisi per il crew"""
+        if not self.agents:
+            return "CrewAI non configurato"
+       
+        try:
+            # Ottieni contesto dal RAG
+            context = self.rag_chatbot.get_relevant_context(query, max_docs=5)
+            
+            tasks = []
+            
+            if analysis_type in ["comprehensive", "document"]:
+                # Task analisi documentale
+                doc_task = Task(
+                    description=f"""
+                    Analizza documenti per: {query}
+                    
+                    CONTESTO: {context}
+                    
+                    Fornisci:
+                    - Tipo e classificazione documenti
+                    - Temi e argomenti principali
+                    - Elementi rilevanti business
+                    - Note compliance
+                    """,
+                    expected_output="Analisi strutturata con classificazione e insights",
+                    agent=self.agents['document_analyst']
+                )
+                tasks.append(doc_task)
+            
+            if analysis_type in ["comprehensive", "sentiment"]:
+                # Task sentiment
+                sentiment_task = Task(
+                    description=f"""
+                    Analizza sentiment per: {query}
+                    
+                    CONTESTO: {context}
+                    
+                    Valuta:
+                    - Sentiment generale (scala 1-10)
+                    - Emozioni prevalenti
+                    - Trend comunicazioni
+                    - Segnali rischio/opportunità
+                    """,
+                    expected_output="Analisi sentiment con valutazioni quantitative",
+                    agent=self.agents['sentiment_analyst']
+                )
+                tasks.append(sentiment_task)
+            
+            if analysis_type in ["comprehensive", "rag"]:
+                # Task RAG
+                rag_task = Task(
+                    description=f"""
+                    Rispondi usando RAG: {query}
+                    
+                    CONTESTO: {context}
+                    
+                    Includi:
+                    - Risposta diretta
+                    - Evidenze documenti
+                    - Correlazioni trovate
+                    - Informazioni mancanti
+                    - Suggerimenti approfondimento
+                    """,
+                    expected_output="Risposta RAG con evidenze",
+                    agent=self.agents['rag_specialist']
+                )
+                tasks.append(rag_task)
+            
+            # Task coordinamento (sempre incluso)
+            coord_task = Task(
+                description=f"""
+                Sintetizza risultati per: {query}
+                
+                Crea sintesi con:
+                - Executive Summary (3 punti)
+                - Insights strategici 
+                - Raccomandazioni prioritarie
+                - Next steps concreti
+                - Valutazione rischi
+                
+                Output executive-ready e actionable.
+                """,
+                expected_output="Sintesi strategica con raccomandazioni",
+                agent=self.agents['strategy_coordinator']
+            )
+            tasks.append(coord_task)
+           
+            # Crea crew
+            crew = Crew(
+                agents=list(self.agents.values()),
+                tasks=tasks,
+                verbose=True
+            )
+           
+            with st.spinner(f"Eseguendo analisi {analysis_type}..."):
+                result = crew.kickoff()
+            
+            return str(result)
+           
+        except Exception as e:
+            return f"Errore CrewAI: {e}"
+    
+    def create_custom_task(self, query: str, selected_agents: List[str], custom_instructions: str = "") -> str:
+        """Task personalizzate con agenti specifici"""
+        if not self.agents:
+            return "CrewAI non configurato"
+        
+        try:
+            context = self.rag_chatbot.get_relevant_context(query, max_docs=5)
+            
+            tasks = []
+            agents_to_use = []
+            
+            for agent_key in selected_agents:
+                if agent_key in self.agents:
+                    agents_to_use.append(self.agents[agent_key])
+                    
+                    task = Task(
+                        description=f"""
+                        {custom_instructions if custom_instructions else f'Analizza secondo il ruolo di {agent_key}'}
+                        
+                        QUERY: {query}
+                        CONTESTO: {context}
+                        
+                        Fornisci analisi specializzata secondo il tuo ruolo.
+                        """,
+                        expected_output=f"Analisi specializzata da {agent_key}",
+                        agent=self.agents[agent_key]
+                    )
+                    tasks.append(task)
+            
+            if not tasks:
+                return "Nessun agente valido selezionato"
+            
+            crew = Crew(
+                agents=agents_to_use,
+                tasks=tasks,
+                verbose=True
+            )
+            
+            with st.spinner(f"Eseguendo task con {len(agents_to_use)} agenti..."):
+                result = crew.kickoff()
+            
+            return str(result)
+            
+        except Exception as e:
+            return f"Errore task personalizzato: {e}"

src/anonymizer.py

@@ -0,0 +1,101 @@
+"""
+Sistema di anonimizzazione con NER e regex.
+"""
+
+import re
+from typing import Dict, Tuple
+from transformers import pipeline
+import streamlit as st
+from config import Config, REGEX_PATTERNS
+
+class NERAnonimizer:
+    """Anonimizzatore con NER e regex"""
+    
+    def __init__(self):
+        self.regex_patterns = REGEX_PATTERNS
+        self._ner_pipe = None
+    
+    @property
+    def ner_pipe(self):
+        """Lazy loading del modello NER"""
+        if self._ner_pipe is None:
+            with st.spinner("Caricamento modello NER..."):
+                try:
+                    self._ner_pipe = pipeline(
+                        "ner",
+                        model=Config.NER_MODEL,
+                        aggregation_strategy="simple"
+                    )
+                except Exception as e:
+                    st.error(f"Errore caricamento NER: {e}")
+                    return None
+        return self._ner_pipe
+    
+    def mask_with_regex(self, text: str) -> Tuple[str, Dict]:
+        """Applica mascheramento con regex"""
+        masked_text = text
+        found_entities = {}
+        
+        # Ordina pattern per lunghezza (più lunghi prima)
+        sorted_patterns = sorted(
+            self.regex_patterns.items(), 
+            key=lambda item: len(item[1]), 
+            reverse=True
+        )
+
+        for label, pattern in sorted_patterns:
+            matches = list(re.finditer(pattern, masked_text, flags=re.IGNORECASE))
+            for match in reversed(matches):
+                original = match.group()
+                if original.startswith('[') and original.endswith(']'):
+                    continue
+
+                placeholder = f"[{label}_{len(found_entities)}]"
+                found_entities[placeholder] = original
+                masked_text = masked_text[:match.start()] + placeholder + masked_text[match.end():]
+        
+        return masked_text, found_entities
+    
+    def mask_with_ner(self, text: str) -> Tuple[str, Dict]:
+        """Applica mascheramento con NER"""
+        if not self.ner_pipe:
+            return text, {}
+            
+        try:
+            entities = self.ner_pipe(text)
+            entity_map = {}
+            
+            sorted_entities = sorted(entities, key=lambda x: x['start'], reverse=True)
+            
+            for ent in sorted_entities:
+                if ent['score'] > 0.5:
+                    label = ent['entity_group']
+                    original_text = text[ent['start']:ent['end']]
+                    
+                    if original_text.startswith('[') and original_text.endswith(']'):
+                        continue
+
+                    placeholder = f"[{label}_{len(entity_map)}]"
+                    entity_map[placeholder] = original_text
+                    
+                    text = text[:ent['start']] + placeholder + text[ent['end']:]
+            
+            return text, entity_map
+            
+        except Exception as e:
+            st.error(f"Errore NER: {e}")
+            return text, {}
+    
+    def anonymize(self, text: str) -> Tuple[str, Dict]:
+        """Pipeline completa di anonimizzazione"""
+        if not text or not text.strip():
+            return text, {}
+        
+        # Regex prima, poi NER
+        masked_text, regex_entities = self.mask_with_regex(text)
+        final_text, ner_entities = self.mask_with_ner(masked_text)
+        
+        # Combina entità
+        all_entities = {**regex_entities, **ner_entities}
+        
+        return final_text, all_entities

src/config.py

@@ -0,0 +1,37 @@
+"""
+Configurazioni per il sistema di anonimizzazione documenti.
+"""
+
+import os
+from dotenv import load_dotenv
+
+# Carica variabili d'ambiente
+load_dotenv()
+
+class Config:
+    """Configurazione del sistema"""
+    
+    # Modelli AI
+    NER_MODEL = "Davlan/bert-base-multilingual-cased-ner-hrl"
+    
+    # Azure OpenAI
+    AZURE_ENDPOINT = os.getenv("AZURE_ENDPOINT")
+    AZURE_API_KEY = os.getenv("AZURE_API_KEY")
+    AZURE_EMBEDDING_ENDPOINT = os.getenv("AZURE_ENDPOINT_EMB", os.getenv("AZURE_ENDPOINT"))
+    AZURE_EMBEDDING_API_KEY = os.getenv("AZURE_API_KEY_EMB", os.getenv("AZURE_API_KEY"))
+    AZURE_API_VERSION = "2024-02-01"
+    DEPLOYMENT_NAME = "gpt-4o"
+    AZURE_EMBEDDING_DEPLOYMENT_NAME = "text-embedding-ada-002"
+
+# Pattern regex per entità sensibili
+REGEX_PATTERNS = {
+    "IBAN": r'\bIT\d{2}(?: ?[A-Z0-9]){11,30}\b',
+    "EMAIL": r'\b[\w\.-]+@[\w\.-]+\.\w{2,}\b',
+    "CF": r'\b[A-Z]{6}[0-9]{2}[A-Z][0-9]{2}[A-Z][0-9]{3}[A-Z]\b',
+    "CARD": r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b',
+    "PHONE": r'\b\+?[0-9\s\-\(\)]{8,15}\b'
+}
+
+# Configura OPENAI_API_KEY per compatibilità
+if Config.AZURE_API_KEY:
+    os.environ["OPENAI_API_KEY"] = Config.AZURE_API_KEY

src/main.py

@@ -0,0 +1,361 @@
+"""
+App principale Streamlit per l'anonimizzazione documenti.
+"""
+
+import streamlit as st
+import json
+import pandas as pd
+from ui_components import (
+    setup_page_config, display_sidebar, display_entity_editor,
+    display_file_preview, display_analysis_results, display_crewai_result,
+    display_progress_metrics, display_examples_section, create_download_button
+)
+from utils import (
+    init_session_state, process_uploaded_files, run_anonymization,
+    run_ai_analysis, build_rag_knowledge_base, export_results_json,
+    get_confirmed_docs_count, reset_document_state, add_chat_message,
+    add_crewai_result, clear_crewai_history
+)
+
+def main():
+    """Funzione principale dell'app"""
+    
+    # Setup
+    setup_page_config()
+    init_session_state()
+    
+    # Header
+    st.title("🔒 Anonimizzatore Documenti con NER, RAG e CrewAI")
+    st.markdown("---")
+    
+    # Sidebar
+    display_sidebar()
+    
+    # Main tabs
+    tab1, tab2, tab3, tab4, tab5 = st.tabs([
+        "📤 Upload", 
+        "🔍 Anonimizzazione", 
+        "📊 Analisi", 
+        "💬 Chatbot RAG", 
+        "🤖 CrewAI"
+    ])
+    
+    # TAB 1: Upload
+    with tab1:
+        upload_tab()
+    
+    # TAB 2: Anonimizzazione
+    with tab2:
+        anonymization_tab()
+    
+    # TAB 3: Analisi
+    with tab3:
+        analysis_tab()
+    
+    # TAB 4: RAG
+    with tab4:
+        rag_tab()
+    
+    # TAB 5: CrewAI
+    with tab5:
+        crewai_tab()
+
+def upload_tab():
+    """Tab per upload file"""
+    st.header("📤 Carica Documenti")
+    
+    uploaded_files = st.file_uploader(
+        "Carica uno o più file .txt",
+        type=['txt'],
+        accept_multiple_files=True,
+        help="Seleziona i file di testo da anonimizzare"
+    )
+    
+    if uploaded_files:
+        if process_uploaded_files(uploaded_files):
+            st.success(f"Caricati {len(uploaded_files)} file")
+            st.rerun()
+        else:
+            st.info("Nessun nuovo file caricato.")
+        
+        # Mostra anteprima
+        st.subheader("📄 File caricati")
+        for filename, file_data in st.session_state.uploaded_files.items():
+            display_file_preview(filename, file_data['content'])
+
+def anonymization_tab():
+    """Tab per anonimizzazione"""
+    st.header("🔍 Anonimizzazione e Revisione")
+    
+    if not st.session_state.uploaded_files:
+        st.warning("⚠️ Carica prima alcuni documenti nella tab 'Upload'")
+        return
+    
+    # Bottone anonimizzazione
+    if st.button("🚀 Avvia Anonimizzazione", type="primary"):
+        run_anonymization()
+        st.rerun()
+    
+    # Mostra documenti anonimizzati
+    if st.session_state.anonymized_docs:
+        st.subheader("📝 Revisiona Documenti Anonimizzati")
+        
+        for filename, doc_data in st.session_state.anonymized_docs.items():
+            with st.expander(
+                f"📄 {filename} {'✅' if doc_data['confirmed'] else '⏳'}", 
+                expanded=not doc_data['confirmed']
+            ):
+                
+                col1, col2 = st.columns(2)
+                
+                # Testo originale
+                with col1:
+                    st.write("**Testo Originale:**")
+                    preview = doc_data['original'][:300]
+                    if len(doc_data['original']) > 300:
+                        preview += "..."
+                    
+                    st.text_area(
+                        "Originale",
+                        value=preview,
+                        height=200,
+                        disabled=True,
+                        key=f"orig_{filename}",
+                        label_visibility="collapsed"
+                    )
+                
+                # Testo anonimizzato
+                with col2:
+                    st.write("**Testo Anonimizzato:**")
+                    edited_text = st.text_area(
+                        "Anonimizzato (modificabile)",
+                        value=doc_data['anonymized'],
+                        height=200,
+                        key=f"anon_{filename}",
+                        label_visibility="collapsed"
+                    )
+                    
+                    # Aggiorna se modificato
+                    if edited_text != doc_data['anonymized']:
+                        st.session_state.anonymized_docs[filename]['anonymized'] = edited_text
+                
+                # Editor entità
+                updated_entities = display_entity_editor(dict(doc_data['entities']), filename)
+                
+                # Bottoni azione
+                col_confirm, col_reset = st.columns(2)
+                
+                with col_confirm:
+                    if st.button(f"✅ Conferma {filename}", key=f"confirm_{filename}"):
+                        st.session_state.anonymized_docs[filename]['confirmed'] = True
+                        st.session_state.anonymized_docs[filename]['entities'] = updated_entities
+                        st.success(f"✅ {filename} confermato!")
+                        st.session_state.vector_store_built = False
+                        st.rerun()
+                
+                with col_reset:
+                    if st.button(f"🔄 Reset {filename}", key=f"reset_{filename}"):
+                        reset_document_state(filename)
+                        st.rerun()
+        
+        # Statistiche progresso
+        display_progress_metrics()
+
+def analysis_tab():
+    """Tab per analisi AI"""
+    st.header("📊 Analisi AI")
+    
+    confirmed_docs = {k: v for k, v in st.session_state.anonymized_docs.items() 
+                     if v.get('confirmed', False)}
+    
+    if not confirmed_docs:
+        st.warning("⚠️ Conferma prima alcuni documenti anonimizzati")
+        return
+    
+    st.write(f"Documenti confermati pronti: **{len(confirmed_docs)}**")
+    
+    if st.button("🤖 Avvia Analisi AI", type="primary"):
+        run_ai_analysis()
+    
+    # Mostra risultati
+    if st.session_state.processed_docs:
+        st.subheader("📋 Risultati Analisi")
+        
+        for filename, result in st.session_state.processed_docs.items():
+            display_analysis_results(filename, result)
+            
+            # Download JSON
+            result_json = export_results_json({
+                'filename': filename,
+                'anonymized_text': result['anonymized_text'],
+                'analysis': result['analysis'],
+                'entities': result['entities'],
+                'entities_count': result['entities_count']
+            }, f"analisi_{filename}")
+            
+            create_download_button(
+                result_json,
+                f"analisi_{filename}.json",
+                f"💾 Scarica {filename}",
+                f"download_{filename}"
+            )
+
+def rag_tab():
+    """Tab per RAG chatbot"""
+    st.header("💬 Chatta con i Documenti")
+    
+    confirmed_docs = {k: v for k, v in st.session_state.anonymized_docs.items() 
+                     if v.get('confirmed', False)}
+    
+    if not confirmed_docs:
+        st.warning("⚠️ Carica e conferma documenti per abilitare il chatbot")
+        return
+    
+    # Costruisci knowledge base
+    if build_rag_knowledge_base():
+        st.info(f"Chatbot pronto per {len(confirmed_docs)} documenti")
+        
+        # Mostra cronologia chat
+        for message in st.session_state.chat_history:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+        
+        # Input utente
+        if prompt := st.chat_input("Fai una domanda sui documenti..."):
+            # Aggiungi messaggio utente
+            add_chat_message("user", prompt)
+            with st.chat_message("user"):
+                st.markdown(prompt)
+            
+            # Genera risposta
+            with st.chat_message("assistant"):
+                with st.spinner("Generando risposta..."):
+                    response = st.session_state.rag_chatbot.answer_question(prompt)
+                    st.markdown(response)
+            
+            # Aggiungi risposta
+            add_chat_message("assistant", response)
+    else:
+        st.error("Impossibile costruire knowledge base. Verifica configurazione Azure.")
+
+def crewai_tab():
+    """Tab per CrewAI"""
+    st.header("🤖 Analisi Multi-Agente CrewAI")
+    
+    confirmed_docs = {k: v for k, v in st.session_state.anonymized_docs.items() 
+                     if v.get('confirmed', False)}
+    
+    if not confirmed_docs:
+        st.warning("⚠️ Conferma documenti per abilitare CrewAI")
+        return
+    
+    if not st.session_state.crewai_manager.agents:
+        st.error("❌ CrewAI non configurato. Verifica Azure OpenAI.")
+        return
+    
+    # Assicura knowledge base
+    build_rag_knowledge_base()
+    
+    st.success(f"🎯 CrewAI pronto per {len(confirmed_docs)} documenti")
+    
+    # Configurazione analisi
+    st.subheader("⚙️ Configurazione Analisi")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        analysis_type = st.selectbox(
+            "Tipo di Analisi",
+            options=["comprehensive", "document", "sentiment", "rag", "custom"],
+            format_func=lambda x: {
+                "comprehensive": "🔍 Analisi Comprensiva",
+                "document": "📄 Analisi Documentale",
+                "sentiment": "😊 Sentiment Analysis",
+                "rag": "🔍 Query RAG Avanzata",
+                "custom": "⚙️ Personalizzata"
+            }[x]
+        )
+    
+    with col2:
+        if analysis_type == "custom":
+            selected_agents = st.multiselect(
+                "Agenti da utilizzare",
+                options=list(st.session_state.crewai_manager.agents.keys()),
+                default=["strategy_coordinator"],
+                format_func=lambda x: {
+                    "document_analyst": "📄 Document Analyst",
+                    "rag_specialist": "🔍 RAG Specialist", 
+                    "strategy_coordinator": "🎯 Strategy Coordinator",
+                    "sentiment_analyst": "😊 Sentiment Analyst"
+                }.get(x, x)
+            )
+        else:
+            selected_agents = []
+    
+    # Query input
+    st.subheader("❓ Query per l'Analisi")
+    query_input = st.text_area(
+        "Inserisci la tua domanda:",
+        placeholder="Es: Analizza i temi principali e identifica rischi operativi...",
+        height=100
+    )
+    
+    # Istruzioni personalizzate
+    if analysis_type == "custom":
+        custom_instructions = st.text_area(
+            "Istruzioni Personalizzate:",
+            placeholder="Istruzioni specifiche per gli agenti...",
+            height=80
+        )
+    else:
+        custom_instructions = ""
+    
+    # Bottoni
+    col_analyze, col_clear = st.columns(2)
+    
+    with col_analyze:
+        if st.button("🚀 Avvia Analisi CrewAI", type="primary", disabled=not query_input.strip()):
+            if analysis_type == "custom" and not selected_agents:
+                st.error("Seleziona almeno un agente")
+            else:
+                # Esegui analisi
+                if analysis_type == "custom":
+                    result = st.session_state.crewai_manager.create_custom_task(
+                        query_input, selected_agents, custom_instructions
+                    )
+                else:
+                    result = st.session_state.crewai_manager.create_analysis_task(
+                        query_input, analysis_type
+                    )
+                
+                # Salva risultato
+                add_crewai_result(query_input, analysis_type, result, selected_agents)
+                st.success("✅ Analisi CrewAI completata!")
+    
+    with col_clear:
+        if st.button("🗑️ Pulisci Cronologia"):
+            clear_crewai_history()
+            st.success("Cronologia pulita!")
+            st.rerun()
+    
+    # Mostra risultati
+    if st.session_state.crewai_history:
+        st.subheader("📋 Risultati Analisi CrewAI")
+        
+        for i, analysis in enumerate(reversed(st.session_state.crewai_history)):
+            display_crewai_result(analysis, len(st.session_state.crewai_history) - i)
+            
+            # Download
+            result_json = export_results_json(analysis, f"crewai_analysis_{i}")
+            create_download_button(
+                result_json,
+                f"crewai_analysis_{analysis['timestamp'].replace(':', '-').replace(' ', '_')}.json",
+                "💾 Scarica Risultato",
+                f"download_crewai_{i}"
+            )
+    
+    # Esempi
+    display_examples_section()
+
+if __name__ == "__main__":
+    main()

src/ui_components.py

@@ -0,0 +1,243 @@
+"""
+Componenti UI riutilizzabili per Streamlit.
+"""
+
+import streamlit as st
+import pandas as pd
+from typing import Dict
+from config import Config
+
+def setup_page_config():
+    """Configura la pagina Streamlit"""
+    st.set_page_config(
+        page_title="Anonimizzatore Documenti",
+        page_icon="🔒",
+        layout="wide"
+    )
+
+def display_sidebar():
+    """Mostra sidebar con configurazioni"""
+    with st.sidebar:
+        st.header("⚙️ Configurazione")
+        
+        # Status Azure
+        if Config.AZURE_API_KEY and Config.AZURE_ENDPOINT:
+            st.success("✅ Azure OpenAI configurato")
+            st.info(f"Chat Model: {Config.DEPLOYMENT_NAME}")
+            st.info(f"Embedding Model: {Config.AZURE_EMBEDDING_DEPLOYMENT_NAME}")
+        else:
+            st.error("❌ Azure OpenAI non configurato")
+            st.write("Configura le variabili d'ambiente:")
+            st.code("""
+AZURE_ENDPOINT=your_endpoint
+AZURE_API_KEY=your_api_key
+AZURE_ENDPOINT_EMB=your_embedding_endpoint
+AZURE_API_KEY_EMB=your_embedding_api_key
+            """)
+        
+        st.markdown("---")
+        
+        # Statistiche documenti
+        if 'uploaded_files' in st.session_state and st.session_state.uploaded_files:
+            st.subheader("📊 Statistiche")
+            uploaded_count = len(st.session_state.uploaded_files)
+            anonymized_count = len(st.session_state.get('anonymized_docs', {}))
+            confirmed_count = sum(1 for doc in st.session_state.get('anonymized_docs', {}).values() 
+                                if doc.get('confirmed', False))
+            
+            st.metric("File caricati", uploaded_count)
+            st.metric("Anonimizzati", anonymized_count)
+            st.metric("Confermati", confirmed_count)
+            
+            if confirmed_count > 0:
+                if st.session_state.get('vector_store_built', False):
+                    st.success("✅ Knowledge Base pronto")
+                else:
+                    st.info("🔄 Knowledge Base da costruire")
+        
+        st.markdown("---")
+        
+        # Reset button
+        if st.button("🔄 Reset sessione"):
+            for key in list(st.session_state.keys()):
+                del st.session_state[key]
+            st.rerun()
+
+def display_entity_editor(entities: Dict, doc_key: str):
+    """Editor per entità rilevate"""
+    if not entities:
+        st.info("Nessuna entità sensibile rilevata.")
+        return entities
+    
+    st.subheader("🔍 Entità rilevate")
+    st.write("Verifica e modifica le entità sensibili:")
+    
+    current_entities_list = list(entities.items())
+    updated_entities_dict = {}
+    deleted_placeholders = set()
+
+    for i, (placeholder, original_value) in enumerate(current_entities_list):
+        col1, col2, col3 = st.columns([2, 3, 1])
+        
+        with col1:
+            st.write(f"**{placeholder}**")
+        
+        with col2:
+            new_value = st.text_input(
+                "Valore originale",
+                value=original_value,
+                key=f"{doc_key}_{placeholder}_value_{i}"
+            )
+            updated_entities_dict[placeholder] = new_value
+        
+        with col3:
+            if st.button("🗑️", key=f"{doc_key}_{placeholder}_delete_{i}", help="Rimuovi"):
+                deleted_placeholders.add(placeholder)
+    
+    # Gestisci cancellazioni
+    if deleted_placeholders:
+        final_entities = {k: v for k, v in updated_entities_dict.items() 
+                         if k not in deleted_placeholders}
+        st.session_state.anonymized_docs[doc_key]['entities'] = final_entities
+        
+        # Re-anonimizza testo
+        from anonymizer import NERAnonimizer
+        anonymizer = NERAnonimizer()
+        st.session_state.anonymized_docs[doc_key]['anonymized'], _ = anonymizer.anonymize(
+            st.session_state.anonymized_docs[doc_key]['original']
+        )
+        st.session_state.vector_store_built = False
+        st.rerun()
+    
+    return updated_entities_dict
+
+def display_file_preview(filename: str, content: str, max_chars: int = 500):
+    """Mostra anteprima file"""
+    with st.expander(f"📄 {filename} ({len(content)} caratteri)"):
+        preview_text = content[:max_chars]
+        if len(content) > max_chars:
+            preview_text += "..."
+        
+        st.text_area(
+            "Contenuto",
+            value=preview_text,
+            height=150,
+            disabled=True,
+            key=f"preview_{filename}",
+            label_visibility="collapsed"
+        )
+
+def display_analysis_results(filename: str, result: Dict):
+    """Mostra risultati analisi"""
+    with st.expander(f"📊 Analisi: {filename}"):
+        # Metriche
+        col1, col2, col3 = st.columns(3)
+        col1.metric("Caratteri testo", len(result['anonymized_text']))
+        col2.metric("Entità trovate", result['entities_count'])
+        col3.metric("Stato", "✅ Completato")
+        
+        # Testo anonimizzato
+        st.subheader("📄 Testo Anonimizzato")
+        st.text_area(
+            "Testo processato",
+            value=result['anonymized_text'],
+            height=150,
+            disabled=True,
+            key=f"analysis_text_{filename}"
+        )
+        
+        # Analisi AI
+        st.subheader("🤖 Analisi AI")
+        st.markdown(result['analysis'])
+        
+        # Entità
+        if result['entities']:
+            st.subheader("🔍 Entità Anonimizzate")
+            entities_df = pd.DataFrame([
+                {
+                    'Placeholder': k, 
+                    'Valore Originale': v, 
+                    'Tipo': k.split('_')[0].replace('[', '')
+                }
+                for k, v in result['entities'].items()
+            ])
+            st.dataframe(entities_df, use_container_width=True)
+
+def display_crewai_result(analysis: Dict, index: int):
+    """Mostra risultato analisi CrewAI"""
+    with st.expander(
+        f"🤖 Analisi {index}: {analysis['analysis_type'].upper()} - {analysis['timestamp']}"
+    ):
+        # Info header
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Tipo Analisi", analysis['analysis_type'].capitalize())
+        
+        with col2:
+            st.metric("Timestamp", analysis['timestamp'])
+        
+        with col3:
+            agents_used = analysis.get('agents_used', 'auto')
+            if agents_used == 'auto':
+                agent_count = "Automatico"
+            elif isinstance(agents_used, list):
+                agent_count = f"{len(agents_used)} agenti"
+            else:
+                agent_count = str(agents_used)
+            st.metric("Agenti", agent_count)
+        
+        # Query e risultato
+        st.subheader("❓ Query Originale")
+        st.info(analysis['query'])
+        
+        st.subheader("🎯 Risultato Analisi")
+        st.markdown(analysis['result'])
+
+def display_progress_metrics():
+    """Mostra metriche di progresso"""
+    if 'anonymized_docs' in st.session_state:
+        confirmed_count = sum(1 for doc in st.session_state.anonymized_docs.values() 
+                            if doc.get('confirmed', False))
+        total_count = len(st.session_state.anonymized_docs)
+        
+        if total_count > 0:
+            st.metric(
+                "Progresso Conferme",
+                f"{confirmed_count}/{total_count}",
+                delta=f"{(confirmed_count/total_count)*100:.1f}%"
+            )
+
+def display_examples_section():
+    """Mostra esempi di query CrewAI"""
+    with st.expander("💡 Esempi di Query per CrewAI"):
+        st.markdown("""
+        **Analisi Comprensiva:**
+        - "Fornisci un'analisi completa dei documenti identificando rischi, opportunità e raccomandazioni strategiche"
+        - "Analizza la comunicazione aziendale e suggerisci miglioramenti nella gestione clienti"
+        
+        **Analisi Documentale:**
+        - "Classifica i documenti per tipologia e identifica pattern ricorrenti"
+        - "Analizza la struttura e organizzazione delle informazioni nei documenti"
+        
+        **Sentiment Analysis:**
+        - "Valuta il sentiment generale nelle comunicazioni e identifica aree di miglioramento"
+        - "Analizza le emozioni e i trend nei feedback dei clienti"
+        
+        **Query RAG Avanzata:**
+        - "Trova tutte le menzioni di problemi operativi e le relative soluzioni proposte"
+        - "Estrai informazioni su scadenze, deadline e milestone importanti"
+        
+        **Personalizzata:**
+        - Combina agenti specifici per analisi mirate alle tue esigenze
+        """)
+
+def create_download_button(data: str, filename: str, label: str, key: str):
+    """Crea bottone download con dati"""
+    st.download_button(
+        label=label,
+        data=data,
+        file_name=filename,
+        mime="application/json",
+        key=key
+    )

src/utils.py

@@ -0,0 +1,229 @@
+"""
+Funzioni utility e gestione stato sessione.
+"""
+
+import streamlit as st
+import json
+import pandas as pd
+from datetime import datetime
+from anonymizer import NERAnonimizer
+from ai_processor import AzureProcessor, RAGChatbot, CrewAIManager
+
+def init_session_state():
+    """Inizializza stato sessione"""
+    if 'anonymizer' not in st.session_state:
+        st.session_state.anonymizer = NERAnonimizer()
+    
+    if 'processor' not in st.session_state:
+        st.session_state.processor = AzureProcessor()
+    
+    if 'rag_chatbot' not in st.session_state:
+        st.session_state.rag_chatbot = RAGChatbot()
+    
+    if 'crewai_manager' not in st.session_state:
+        st.session_state.crewai_manager = CrewAIManager(st.session_state.rag_chatbot)
+    
+    if 'uploaded_files' not in st.session_state:
+        st.session_state.uploaded_files = {}
+    
+    if 'anonymized_docs' not in st.session_state:
+        st.session_state.anonymized_docs = {}
+    
+    if 'processed_docs' not in st.session_state:
+        st.session_state.processed_docs = {}
+    
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+    
+    if 'crewai_history' not in st.session_state:
+        st.session_state.crewai_history = []
+    
+    if 'vector_store_built' not in st.session_state:
+        st.session_state.vector_store_built = False
+
+def validate_file_upload(uploaded_file) -> bool:
+    """Valida file caricato"""
+    if not uploaded_file:
+        return False
+    
+    # Controlla estensione
+    if not uploaded_file.name.endswith('.txt'):
+        st.error("Solo file .txt sono supportati")
+        return False
+    
+    # Controlla dimensione (max 10MB)
+    if uploaded_file.size > 10 * 1024 * 1024:
+        st.error("File troppo grande (max 10MB)")
+        return False
+    
+    return True
+
+def process_uploaded_files(uploaded_files):
+    """Processa file caricati"""
+    new_files_uploaded = False
+    
+    for file in uploaded_files:
+        if validate_file_upload(file) and file.name not in st.session_state.uploaded_files:
+            try:
+                content = file.read().decode('utf-8')
+                st.session_state.uploaded_files[file.name] = {
+                    'content': content,
+                    'size': len(content)
+                }
+                new_files_uploaded = True
+            except Exception as e:
+                st.error(f"Errore lettura file {file.name}: {e}")
+    
+    if new_files_uploaded:
+        # Reset stato quando si caricano nuovi file
+        st.session_state.anonymized_docs = {}
+        st.session_state.processed_docs = {}
+        st.session_state.vector_store_built = False
+        st.session_state.chat_history = []
+        st.session_state.crewai_history = []
+        return True
+    
+    return False
+
+def run_anonymization():
+    """Esegue anonimizzazione su tutti i file"""
+    if not st.session_state.uploaded_files:
+        st.warning("Nessun file caricato")
+        return
+    
+    progress_bar = st.progress(0)
+    total_files = len(st.session_state.uploaded_files)
+    
+    for i, (filename, file_data) in enumerate(st.session_state.uploaded_files.items()):
+        progress_bar.progress((i + 1) / total_files, f"Processando {filename}...")
+        
+        # Anonimizza
+        anonymized_text, entities = st.session_state.anonymizer.anonymize(file_data['content'])
+        
+        st.session_state.anonymized_docs[filename] = {
+            'original': file_data['content'],
+            'anonymized': anonymized_text,
+            'entities': entities,
+            'confirmed': False
+        }
+    
+    progress_bar.empty()
+    st.success("✅ Anonimizzazione completata!")
+    st.session_state.vector_store_built = False
+
+def run_ai_analysis():
+    """Esegue analisi AI sui documenti confermati"""
+    confirmed_docs = {k: v for k, v in st.session_state.anonymized_docs.items() 
+                     if v.get('confirmed', False)}
+    
+    if not confirmed_docs:
+        st.warning("Nessun documento confermato")
+        return
+    
+    progress_bar = st.progress(0)
+    
+    for i, (filename, doc_data) in enumerate(confirmed_docs.items()):
+        progress_bar.progress((i + 1) / len(confirmed_docs), f"Analizzando {filename}...")
+        
+        # Analisi Azure
+        analysis = st.session_state.processor.process_document(doc_data['anonymized'])
+        
+        st.session_state.processed_docs[filename] = {
+            'anonymized_text': doc_data['anonymized'],
+            'entities_count': len(doc_data['entities']),
+            'analysis': analysis,
+            'entities': doc_data['entities']
+        }
+    
+    progress_bar.empty()
+    st.success("✅ Analisi completata!")
+
+def build_rag_knowledge_base():
+    """Costruisce knowledge base RAG"""
+    confirmed_docs = {k: v for k, v in st.session_state.anonymized_docs.items() 
+                     if v.get('confirmed', False)}
+    
+    if not confirmed_docs:
+        st.warning("Nessun documento confermato per RAG")
+        return False
+    
+    if not st.session_state.vector_store_built:
+        with st.spinner("Costruendo knowledge base..."):
+            st.session_state.rag_chatbot.build_vector_store(confirmed_docs)
+            st.session_state.vector_store_built = True
+            return True
+    
+    return True
+
+def export_results_json(results: dict, filename_prefix: str) -> str:
+    """Esporta risultati in JSON"""
+    export_data = {
+        **results,
+        'metadata': {
+            'exported_at': datetime.now().isoformat(),
+            'total_items': len(results) if isinstance(results, dict) else 1
+        }
+    }
+    
+    return json.dumps(export_data, indent=2, ensure_ascii=False, default=str)
+
+def get_confirmed_docs_count() -> int:
+    """Ritorna numero documenti confermati"""
+    if 'anonymized_docs' not in st.session_state:
+        return 0
+    
+    return sum(1 for doc in st.session_state.anonymized_docs.values() 
+              if doc.get('confirmed', False))
+
+def reset_document_state(filename: str):
+    """Reset stato documento specifico"""
+    if filename in st.session_state.uploaded_files:
+        original_data = st.session_state.uploaded_files[filename]
+        anonymized_text, entities = st.session_state.anonymizer.anonymize(original_data['content'])
+        
+        st.session_state.anonymized_docs[filename] = {
+            'original': original_data['content'],
+            'anonymized': anonymized_text,
+            'entities': entities,
+            'confirmed': False
+        }
+        st.session_state.vector_store_built = False
+
+def add_chat_message(role: str, content: str):
+    """Aggiunge messaggio alla chat history"""
+    st.session_state.chat_history.append({
+        "role": role,
+        "content": content
+    })
+
+def add_crewai_result(query: str, analysis_type: str, result: str, agents_used=None):
+    """Aggiunge risultato CrewAI alla history"""
+    analysis_result = {
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "query": query,
+        "analysis_type": analysis_type,
+        "result": result,
+        "agents_used": agents_used if agents_used else "auto"
+    }
+    
+    st.session_state.crewai_history.append(analysis_result)
+
+def clear_chat_history():
+    """Pulisce cronologia chat"""
+    st.session_state.chat_history = []
+
+def clear_crewai_history():
+    """Pulisce cronologia CrewAI"""
+    st.session_state.crewai_history = []
+
+def get_system_stats() -> dict:
+    """Ritorna statistiche sistema"""
+    return {
+        'uploaded_files': len(st.session_state.get('uploaded_files', {})),
+        'anonymized_docs': len(st.session_state.get('anonymized_docs', {})),
+        'confirmed_docs': get_confirmed_docs_count(),
+        'processed_docs': len(st.session_state.get('processed_docs', {})),
+        'chat_messages': len(st.session_state.get('chat_history', [])),
+        'crewai_analyses': len(st.session_state.get('crewai_history', [])),
+        'vector_store_ready': st.session_state.get('vector_store_built', False)
+    }

style.css

@@ -1,28 +1,28 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}
+body {
+	padding: 2rem;
+	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
+}
+
+h1 {
+	font-size: 16px;
+	margin-top: 0;
+}
+
+p {
+	color: rgb(107, 114, 128);
+	font-size: 15px;
+	margin-bottom: 10px;
+	margin-top: 5px;
+}
+
+.card {
+	max-width: 620px;
+	margin: 0 auto;
+	padding: 16px;
+	border: 1px solid lightgray;
+	border-radius: 16px;
+}
+
+.card p:last-child {
+	margin-bottom: 0;
+}

tests/conftest.py

@@ -0,0 +1,183 @@
+"""
+Configurazioni pytest e fixtures condivise.
+"""
+
+import pytest
+import os
+import tempfile
+from unittest.mock import Mock, patch
+import sys
+from pathlib import Path
+
+# Aggiungi src al path per import
+sys.path.insert(0, r"Giorno_10\src")
+
+@pytest.fixture
+def sample_text():
+    """Testo di esempio per test"""
+    return """
+    Gentile Mario Rossi,
+    
+    La contatto in merito alla fattura n. 12345.
+    Il suo codice fiscale RSSMRA80A01H501Z risulta corretto.
+    
+    Per il pagamento può utilizzare:
+    IBAN: IT60 X054 2811 1010 0000 0123 456
+    Email: mario.rossi@example.com
+    Telefono: +39 333 1234567
+    
+    Carta: 4532 1234 5678 9012
+    
+    Cordiali saluti,
+    Ufficio Amministrazione
+    ACME SpA
+    """
+
+@pytest.fixture
+def sample_text_no_entities():
+    """Testo senza entità sensibili"""
+    return """
+    Questo è un documento di prova
+    che non contiene informazioni sensibili.
+    
+    Solo testo normale per i test.
+    """
+
+@pytest.fixture
+def sample_empty_text():
+    """Testo vuoto"""
+    return ""
+
+@pytest.fixture
+def sample_entities():
+    """Entità di esempio per test"""
+    return {
+        "[PER_0]": "Mario Rossi",
+        "[CF_0]": "RSSMRA80A01H501Z",
+        "[IBAN_0]": "IT60 X054 2811 1010 0000 0123 456",
+        "[EMAIL_0]": "mario.rossi@example.com",
+        "[PHONE_0]": "+39 333 1234567",
+        "[CARD_0]": "4532 1234 5678 9012",
+        "[ORG_0]": "ACME SpA"
+    }
+
+@pytest.fixture
+def mock_azure_config():
+    """Mock configurazioni Azure"""
+    with patch.dict(os.environ, {
+        'AZURE_ENDPOINT': 'https://test.openai.azure.com/',
+        'AZURE_API_KEY': 'test-api-key',
+        'AZURE_ENDPOINT_EMB': 'https://test-emb.openai.azure.com/',
+        'AZURE_API_KEY_EMB': 'test-emb-key'
+    }):
+        yield
+
+@pytest.fixture
+def mock_azure_client():
+    """Mock client Azure OpenAI"""
+    mock_client = Mock()
+    
+    # Mock response per chat completion
+    mock_response = Mock()
+    mock_response.choices = [Mock()]
+    mock_response.choices[0].message.content = "Test analysis result"
+    
+    mock_client.chat.completions.create.return_value = mock_response
+    
+    return mock_client
+
+@pytest.fixture
+def mock_ner_pipeline():
+    """Mock pipeline NER"""
+    mock_pipeline = Mock()
+    
+    # Mock entità rilevate
+    mock_entities = [
+        {
+            'entity_group': 'PER',
+            'score': 0.9,
+            'start': 8,
+            'end': 19,
+            'word': 'Mario Rossi'
+        },
+        {
+            'entity_group': 'ORG', 
+            'score': 0.8,
+            'start': 200,
+            'end': 208,
+            'word': 'ACME SpA'
+        }
+    ]
+    
+    mock_pipeline.return_value = mock_entities
+    return mock_pipeline
+
+@pytest.fixture
+def temp_test_file():
+    """File temporaneo per test"""
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        f.write("Test content for file operations")
+        temp_path = f.name
+    
+    yield temp_path
+    
+    # Cleanup
+    if os.path.exists(temp_path):
+        os.unlink(temp_path)
+
+@pytest.fixture
+def mock_streamlit():
+    """Mock componenti Streamlit per test"""
+    with patch('streamlit.error') as mock_error, \
+         patch('streamlit.warning') as mock_warning, \
+         patch('streamlit.success') as mock_success, \
+         patch('streamlit.info') as mock_info, \
+         patch('streamlit.spinner') as mock_spinner:
+        
+        # Spinner context manager
+        mock_spinner.return_value.__enter__ = Mock()
+        mock_spinner.return_value.__exit__ = Mock(return_value=None)
+        
+        yield {
+            'error': mock_error,
+            'warning': mock_warning, 
+            'success': mock_success,
+            'info': mock_info,
+            'spinner': mock_spinner
+        }
+
+@pytest.fixture
+def sample_anonymized_docs():
+    """Documenti anonimizzati di esempio"""
+    return {
+        'document1.txt': {
+            'original': 'Documento con Mario Rossi e mario@email.com',
+            'anonymized': 'Documento con [PER_0] e [EMAIL_0]',
+            'entities': {
+                '[PER_0]': 'Mario Rossi',
+                '[EMAIL_0]': 'mario@email.com'
+            },
+            'confirmed': True
+        },
+        'document2.txt': {
+            'original': 'Altro documento con ACME SpA',
+            'anonymized': 'Altro documento con [ORG_0]',
+            'entities': {
+                '[ORG_0]': 'ACME SpA'
+            },
+            'confirmed': False
+        }
+    }
+
+# Configurazioni pytest
+def pytest_configure(config):
+    """Configurazione pytest"""
+    config.addinivalue_line(
+        "markers", "slow: marks tests as slow (deselect with '-m \"not slow\"')"
+    )
+    config.addinivalue_line(
+        "markers", "integration: marks tests as integration tests"
+    )
+    config.addinivalue_line(
+        "markers", "azure: marks tests that require Azure credentials"
+    )

tests/pytest_ini.txt

@@ -0,0 +1,56 @@
+[tool:pytest]
+# Configurazione pytest
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+
+# Markers personalizzati
+markers =
+    slow: marks tests as slow (deselect with '-m "not slow"')
+    integration: marks tests as integration tests
+    azure: marks tests that require Azure credentials
+    unit: marks tests as unit tests
+    smoke: marks tests as smoke tests
+
+# Opzioni di default
+addopts = 
+    --strict-markers
+    --strict-config
+    --verbose
+    --tb=short
+    --cov=.
+    --cov-report=term-missing
+    --cov-report=html:htmlcov
+    --cov-fail-under=80
+    -p no:warnings
+
+# Filtri warning
+filterwarnings =
+    ignore::UserWarning
+    ignore::DeprecationWarning
+    ignore::PendingDeprecationWarning
+
+# Configurazione coverage
+[coverage:run]
+source = .
+omit = 
+    tests/*
+    venv/*
+    env/*
+    .venv/*
+    setup.py
+    conftest.py
+
+[coverage:report]
+exclude_lines =
+    pragma: no cover
+    def __repr__
+    if self.debug:
+    if settings.DEBUG
+    raise AssertionError
+    raise NotImplementedError
+    if 0:
+    if __name__ == .__main__.:
+    class .*\bProtocol\):
+    @(abc\.)?abstractmethod

tests/test_anonymizer.py

@@ -0,0 +1,278 @@
+"""
+Test per sistema anonimizzazione.
+"""
+import sys
+import os
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'src')))
+
+import pytest
+from unittest.mock import Mock, patch
+from anonymizer import NERAnonimizer
+
+class TestNERAnonimizer:
+    """Test classe NERAnonimizer"""
+    
+    def test_init(self):
+        """Test inizializzazione"""
+        anonymizer = NERAnonimizer()
+        assert anonymizer.regex_patterns is not None
+        assert anonymizer._ner_pipe is None
+    
+    @patch('anonymizer.pipeline')
+    def test_ner_pipe_lazy_loading(self, mock_pipeline, mock_streamlit):
+        """Test lazy loading del modello NER"""
+        anonymizer = NERAnonimizer()
+        
+        # Prima chiamata - dovrebbe caricare il modello
+        pipe = anonymizer.ner_pipe
+        assert mock_pipeline.called
+        
+        # Seconda chiamata - dovrebbe usare cache
+        mock_pipeline.reset_mock()
+        pipe2 = anonymizer.ner_pipe
+        assert not mock_pipeline.called
+        assert pipe == pipe2
+    
+    def test_mask_with_regex_basic(self, sample_text):
+        """Test mascheramento regex base"""
+        anonymizer = NERAnonimizer()
+        
+        masked_text, entities = anonymizer.mask_with_regex(sample_text)
+        
+        # Verifica che abbia trovato entità
+        assert len(entities) > 0
+        
+        # Verifica che le entità siano nel formato corretto
+        for placeholder, original in entities.items():
+            assert placeholder.startswith('[')
+            assert placeholder.endswith(']')
+            assert '_' in placeholder
+            assert original in sample_text
+            assert placeholder in masked_text
+    
+    def test_mask_with_regex_iban(self):
+        """Test mascheramento IBAN specifico"""
+        anonymizer = NERAnonimizer()
+        text = "Il mio IBAN è IT60 X054 2811 1010 0000 0123 456 per i pagamenti"
+        
+        masked_text, entities = anonymizer.mask_with_regex(text)
+        
+        # Dovrebbe trovare l'IBAN
+        iban_entities = [k for k in entities.keys() if k.startswith('[IBAN_')]
+        assert len(iban_entities) == 1
+        
+        iban_placeholder = iban_entities[0]
+        assert entities[iban_placeholder] == "IT60 X054 2811 1010 0000 0123 456"
+        assert iban_placeholder in masked_text
+    
+    def test_mask_with_regex_email(self):
+        """Test mascheramento email"""
+        anonymizer = NERAnonimizer()
+        text = "Contattami su mario.rossi@example.com o test@domain.co.uk"
+        
+        masked_text, entities = anonymizer.mask_with_regex(text)
+        
+        # Dovrebbe trovare 2 email
+        email_entities = [k for k in entities.keys() if k.startswith('[EMAIL_')]
+        assert len(email_entities) == 2
+        
+        email_values = [entities[k] for k in email_entities]
+        assert "mario.rossi@example.com" in email_values
+        assert "test@domain.co.uk" in email_values
+    
+    def test_mask_with_regex_cf(self):
+        """Test mascheramento codice fiscale"""
+        anonymizer = NERAnonimizer()
+        text = "Il codice fiscale è RSSMRA80A01H501Z"
+        
+        masked_text, entities = anonymizer.mask_with_regex(text)
+        
+        cf_entities = [k for k in entities.keys() if k.startswith('[CF_')]
+        assert len(cf_entities) == 1
+        assert entities[cf_entities[0]] == "RSSMRA80A01H501Z"
+    
+    def test_mask_with_regex_empty_text(self, sample_empty_text):
+        """Test con testo vuoto"""
+        anonymizer = NERAnonimizer()
+        
+        masked_text, entities = anonymizer.mask_with_regex(sample_empty_text)
+        
+        assert masked_text == sample_empty_text
+        assert len(entities) == 0
+    
+    def test_mask_with_regex_no_entities(self, sample_text_no_entities):
+        """Test con testo senza entità"""
+        anonymizer = NERAnonimizer()
+        
+        masked_text, entities = anonymizer.mask_with_regex(sample_text_no_entities)
+        
+        assert masked_text == sample_text_no_entities
+        assert len(entities) == 0
+    
+    def test_mask_with_ner_success(self, mock_ner_pipeline, mock_streamlit):
+        """Test mascheramento NER con successo"""
+        anonymizer = NERAnonimizer()
+        anonymizer._ner_pipe = mock_ner_pipeline
+        
+        text = "Mario Rossi lavora in ACME SpA"
+        
+        masked_text, entities = anonymizer.mask_with_ner(text)
+        
+        # Verifica chiamata al modello
+        assert mock_ner_pipeline.called
+        
+        # Verifica entità trovate
+        assert len(entities) == 2
+        per_entities = [k for k in entities.keys() if k.startswith('[PER_')]
+        org_entities = [k for k in entities.keys() if k.startswith('[ORG_')]
+        
+        assert len(per_entities) == 1
+        assert len(org_entities) == 1
+    
+    def test_mask_with_ner_no_model(self, mock_streamlit):
+        """Test NER senza modello caricato"""
+        anonymizer = NERAnonimizer()
+        anonymizer._ner_pipe = None
+        
+        text = "Mario Rossi lavora in ACME SpA"
+        
+        masked_text, entities = anonymizer.mask_with_ner(text)
+        
+        # Dovrebbe ritornare testo invariato
+        assert masked_text == text
+        assert len(entities) == 0
+    
+    def test_mask_with_ner_low_confidence(self, mock_streamlit):
+        """Test NER con confidence bassa"""
+        anonymizer = NERAnonimizer()
+        
+        # Mock con score basso
+        mock_pipe = Mock()
+        mock_pipe.return_value = [
+            {
+                'entity_group': 'PER',
+                'score': 0.3,  # Sotto threshold (0.5)
+                'start': 0,
+                'end': 11,
+                'word': 'Mario Rossi'
+            }
+        ]
+        anonymizer._ner_pipe = mock_pipe
+        
+        text = "Mario Rossi"
+        masked_text, entities = anonymizer.mask_with_ner(text)
+        
+        # Non dovrebbe mascherare con confidence bassa
+        assert masked_text == text
+        assert len(entities) == 0
+    
+    def test_anonymize_complete_pipeline(self, sample_text, mock_ner_pipeline, mock_streamlit):
+        """Test pipeline completa di anonimizzazione"""
+        anonymizer = NERAnonimizer()
+        anonymizer._ner_pipe = mock_ner_pipeline
+        
+        anonymized_text, all_entities = anonymizer.anonymize(sample_text)
+        
+        # Verifica che sia diverso dall'originale
+        assert anonymized_text != sample_text
+        
+        # Verifica che contenga placeholder
+        assert '[' in anonymized_text and ']' in anonymized_text
+        
+        # Verifica che abbia trovato entità da entrambi i sistemi
+        assert len(all_entities) > 0
+        
+        # Verifica mix di entità regex e NER
+        regex_entities = [k for k in all_entities.keys() 
+                         if any(k.startswith(f'[{t}_') for t in ['IBAN', 'EMAIL', 'CF', 'CARD', 'PHONE'])]
+        ner_entities = [k for k in all_entities.keys() 
+                       if any(k.startswith(f'[{t}_') for t in ['PER', 'ORG'])]
+        
+        assert len(regex_entities) > 0  # Dovrebbe trovare entità regex
+        assert len(ner_entities) > 0    # Dovrebbe trovare entità NER
+    
+    def test_anonymize_empty_text(self, sample_empty_text):
+        """Test anonimizzazione testo vuoto"""
+        anonymizer = NERAnonimizer()
+        
+        anonymized_text, entities = anonymizer.anonymize(sample_empty_text)
+        
+        assert anonymized_text == sample_empty_text
+        assert len(entities) == 0
+    
+    def test_anonymize_preserves_structure(self, mock_streamlit):
+        """Test che l'anonimizzazione preservi la struttura del testo"""
+        anonymizer = NERAnonimizer()
+        
+        text = """Documento importante
+        
+        Dati cliente:
+        - Nome: Mario Rossi
+        - Email: mario@test.com
+        
+        Fine documento."""
+        
+        anonymized_text, entities = anonymizer.anonymize(text)
+        
+        # Dovrebbe preservare newline e struttura
+        assert '\n' in anonymized_text
+        assert 'Documento importante' in anonymized_text
+        assert 'Fine documento.' in anonymized_text
+    
+    def test_placeholder_uniqueness(self, sample_text, mock_ner_pipeline, mock_streamlit):
+        """Test che i placeholder siano unici"""
+        anonymizer = NERAnonimizer()
+        anonymizer._ner_pipe = mock_ner_pipeline
+        
+        anonymized_text, entities = anonymizer.anonymize(sample_text)
+        
+        # Tutti i placeholder dovrebbero essere unici
+        placeholders = list(entities.keys())
+        assert len(placeholders) == len(set(placeholders))
+        
+        # Ogni placeholder dovrebbe apparire nel testo
+        for placeholder in placeholders:
+            assert placeholder in anonymized_text
+
+class TestAnonymizerEdgeCases:
+    """Test casi limite"""
+    
+    def test_already_masked_text(self, mock_streamlit):
+        """Test testo già parzialmente mascherato"""
+        anonymizer = NERAnonimizer()
+        
+        text = "Contatta [EMAIL_0] per info su [CF_0]"
+        masked_text, entities = anonymizer.mask_with_regex(text)
+        
+        # Non dovrebbe ri-mascherare placeholder esistenti
+        assert masked_text == text
+        assert len(entities) == 0
+    
+    def test_overlapping_patterns(self, mock_streamlit):
+        """Test pattern che si sovrappongono"""
+        anonymizer = NERAnonimizer()
+        
+        # Testo con potenziali sovrapposizioni
+        text = "Email test@domain.com nel sito https://test@domain.com"
+        
+        masked_text, entities = anonymizer.mask_with_regex(text)
+        
+        # Dovrebbe gestire correttamente le sovrapposizioni
+        assert len(entities) >= 1
+        assert all(placeholder in masked_text for placeholder in entities.keys())
+    
+    def test_special_characters(self, mock_streamlit):
+        """Test caratteri speciali"""
+        anonymizer = NERAnonimizer()
+        
+        text = "Email: test@domain.com; IBAN: IT60X05428111010000001234567!"
+        
+        masked_text, entities = anonymizer.mask_with_regex(text)
+        
+        # Dovrebbe trovare entità anche con caratteri speciali intorno
+        email_found = any('EMAIL' in k for k in entities.keys())
+        iban_found = any('IBAN' in k for k in entities.keys())
+        
+        assert email_found
+        assert iban_found

tests/test_config.py

@@ -0,0 +1,175 @@
+"""
+Test per configurazioni sistema.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'src')))
+
+import pytest
+import os
+from unittest.mock import patch
+from config import Config, REGEX_PATTERNS
+
+class TestConfig:
+    """Test classe Config"""
+    
+    def test_config_attributes_exist(self):
+        """Test che tutti gli attributi richiesti esistano"""
+        assert hasattr(Config, 'NER_MODEL')
+        assert hasattr(Config, 'AZURE_ENDPOINT')
+        assert hasattr(Config, 'AZURE_API_KEY')
+        assert hasattr(Config, 'DEPLOYMENT_NAME')
+        
+    def test_ner_model_default(self):
+        """Test modello NER di default"""
+        assert Config.NER_MODEL == "Davlan/bert-base-multilingual-cased-ner-hrl"
+        
+    def test_deployment_name_default(self):
+        """Test deployment name di default"""
+        assert Config.DEPLOYMENT_NAME == "gpt-4o"
+        
+    def test_api_version_default(self):
+        """Test API version di default"""
+        assert Config.AZURE_API_VERSION == "2024-02-01"
+    
+    @patch.dict(os.environ, {
+        'AZURE_ENDPOINT': 'https://test.openai.azure.com/',
+        'AZURE_API_KEY': 'test-key'
+    })
+    def test_azure_config_from_env(self):
+        """Test lettura configurazione da environment"""
+        # Reload config per leggere nuove env vars
+        import importlib
+        import config
+        importlib.reload(config)
+        
+        assert config.Config.AZURE_ENDPOINT == 'https://test.openai.azure.com/'
+        assert config.Config.AZURE_API_KEY == 'test-key'
+    
+    @patch.dict(os.environ, {}, clear=True)
+    def test_azure_config_missing(self):
+        """Test configurazione Azure mancante"""
+        import importlib
+        import config
+        importlib.reload(config)
+        
+        assert config.Config.AZURE_ENDPOINT is None
+        assert config.Config.AZURE_API_KEY is None
+    
+    def test_openai_api_key_set(self):
+        """Test che OPENAI_API_KEY sia settata se Azure disponibile"""
+        with patch.dict(os.environ, {'AZURE_API_KEY': 'test-key'}):
+            import importlib
+            import config
+            importlib.reload(config)
+            
+            assert os.environ.get('OPENAI_API_KEY') == 'test-key'
+
+class TestRegexPatterns:
+    """Test pattern regex"""
+    
+    def test_regex_patterns_exist(self):
+        """Test che tutti i pattern esistano"""
+        required_patterns = ["IBAN", "EMAIL", "CF", "CARD", "PHONE"]
+        
+        for pattern in required_patterns:
+            assert pattern in REGEX_PATTERNS
+            assert isinstance(REGEX_PATTERNS[pattern], str)
+            assert len(REGEX_PATTERNS[pattern]) > 0
+    
+    def test_iban_pattern(self):
+        """Test pattern IBAN italiano"""
+        import re
+        pattern = re.compile(REGEX_PATTERNS["IBAN"])
+        
+        # IBAN valido
+        assert pattern.search("IT60 X054 2811 1010 0000 0123 4567")
+        assert pattern.search("IT60X05428111010000001234567")
+        
+        # IBAN invalido
+        assert not pattern.search("GB60 X054 2811 1010 0000 0123 456")  # Non IT
+        assert not pattern.search("IT60 X054")  # Troppo corto
+    
+    def test_email_pattern(self):
+        """Test pattern email"""
+        import re
+        pattern = re.compile(REGEX_PATTERNS["EMAIL"])
+        
+        # Email valide
+        assert pattern.search("test@example.com")
+        assert pattern.search("user.name@domain.co.uk")
+        assert pattern.search("test123@test-domain.org")
+        
+        # Email invalide
+        assert not pattern.search("invalid-email")
+        assert not pattern.search("@domain.com")
+        assert not pattern.search("test@")
+    
+    def test_cf_pattern(self):
+        """Test pattern codice fiscale"""
+        import re
+        pattern = re.compile(REGEX_PATTERNS["CF"])
+        
+        # CF valido (formato)
+        assert pattern.search("RSSMRA80A01H501Z")
+        assert pattern.search("VRDLCU85D15F205W")
+        
+        # CF invalido
+        assert not pattern.search("RSSMRA80A01H501")  # Troppo corto
+        assert not pattern.search("rssmra80a01h501z")  # Minuscolo
+        assert not pattern.search("123456789012345")   # Solo numeri
+    
+    def test_card_pattern(self):
+        """Test pattern carta di credito"""
+        import re
+        pattern = re.compile(REGEX_PATTERNS["CARD"])
+        
+        # Carte valide (formato)
+        assert pattern.search("1234 5678 9012 3456")
+        assert pattern.search("1234-5678-9012-3456")
+        assert pattern.search("1234567890123456")
+        
+        # Carte invalide
+        assert not pattern.search("1234 5678 9012")     # Troppo corto
+        assert not pattern.search("abcd efgh ijkl mnop") # Lettere
+    
+    def test_phone_pattern(self):
+        """Test pattern telefono"""
+        import re
+        pattern = re.compile(REGEX_PATTERNS["PHONE"])
+        
+        # Telefoni validi
+        assert pattern.search("+39 333 1234567")
+        assert pattern.search("333-123-4567")
+        assert pattern.search("(02) 12345678")
+        assert pattern.search("3331234567")
+        
+        # Telefoni invalidi
+        assert not pattern.search("123")      # Troppo corto
+        assert not pattern.search("abc-def")  # Lettere
+
+class TestPatternValidation:
+    """Test validazione pattern"""
+    
+    def test_all_patterns_compile(self):
+        """Test che tutti i pattern si compilino correttamente"""
+        import re
+        
+        for name, pattern in REGEX_PATTERNS.items():
+            try:
+                re.compile(pattern)
+            except re.error:
+                pytest.fail(f"Pattern {name} non valido: {pattern}")
+    
+    def test_patterns_not_empty(self):
+        """Test che nessun pattern sia vuoto"""
+        for name, pattern in REGEX_PATTERNS.items():
+            assert pattern.strip(), f"Pattern {name} è vuoto"
+    
+    def test_patterns_have_word_boundaries(self):
+        """Test che i pattern usino word boundaries appropriati"""
+        for name, pattern in REGEX_PATTERNS.items():
+            # La maggior parte dei pattern dovrebbe avere \b per word boundary
+            if name in ["IBAN", "CF", "CARD", "PHONE"]:
+                assert "\\b" in pattern, f"Pattern {name} dovrebbe usare word boundaries"

tests/test_readme.md

@@ -0,0 +1,295 @@
+# 🧪 Test Suite
+
+Suite di test automatici per il sistema di anonimizzazione documenti.
+
+## 📋 Struttura Test
+
+```
+tests/
+├── conftest.py              # Fixtures e configurazioni pytest
+├── test_config.py           # Test configurazioni sistema
+├── test_anonymizer.py       # Test anonimizzazione NER+Regex
+├── test_ai_processor.py     # Test componenti AI (Azure+RAG+CrewAI)
+├── test_utils.py            # Test funzioni utility
+├── sample_data/             # Dati di test
+└── README.md               # Questa documentazione
+```
+
+## 🚀 Come Eseguire i Test
+
+### Setup Iniziale
+```bash
+# Installa dipendenze test
+pip install -r requirements-test.txt
+
+# Installa dipendenze principali
+pip install -r requirements.txt
+```
+
+### Esecuzione Base
+```bash
+# Tutti i test
+pytest
+
+# Test specifico
+pytest tests/test_anonymizer.py
+
+# Test con coverage
+pytest --cov
+
+# Test veloci (escludi slow)
+pytest -m "not slow"
+```
+
+### Esecuzione Avanzata
+```bash
+# Test in parallelo
+pytest -n auto
+
+# Test con output dettagliato
+pytest -v
+
+# Test solo falliti
+pytest --lf
+
+# Test con benchmark
+pytest --benchmark-only
+```
+
+## 🏷️ Markers Disponibili
+
+### **@pytest.mark.unit**
+Test unitari veloci (<1s)
+```bash
+pytest -m unit
+```
+
+### **@pytest.mark.integration** 
+Test di integrazione (<10s)
+```bash
+pytest -m integration
+```
+
+### **@pytest.mark.slow**
+Test lenti (>10s)
+```bash
+pytest -m "not slow"  # Escludi
+pytest -m slow        # Solo lenti
+```
+
+### **@pytest.mark.azure**
+Test che richiedono Azure (con credenziali)
+```bash
+pytest -m "not azure"  # Senza Azure
+```
+
+## 🎯 Coverage Report
+
+### Generazione Report
+```bash
+# HTML report
+pytest --cov --cov-report=html
+open htmlcov/index.html
+
+# Terminal report
+pytest --cov --cov-report=term-missing
+
+# XML report (per CI/CD)
+pytest --cov --cov-report=xml
+```
+
+### Target Coverage
+- **Minimo**: 80% overall
+- **Obiettivo**: 90%+ per moduli core
+- **Critico**: 95%+ per anonimizzazione
+
+## 🧩 Test Categories
+
+### **Unit Tests (80%)**
+- Funzioni singole isolate
+- Mock dipendenze esterne
+- Execution rapida
+
+### **Integration Tests (15%)**
+- Componenti che interagiscono
+- Mock servizi esterni (Azure)
+- Execution media
+
+### **End-to-End Tests (5%)**
+- Workflow completi
+- Test con UI Streamlit
+- Execution lenta
+
+## 📊 Test Data
+
+### **Fixtures Disponibili**
+- `sample_text`: Documento con entità varie
+- `sample_text_no_entities`: Testo pulito
+- `sample_entities`: Mappa entità esempio
+- `mock_azure_client`: Client Azure mockato
+- `mock_ner_pipeline`: Pipeline NER mockato
+
+### **Sample Data**
+```
+tests/sample_data/
+├── sample_document.txt         # Doc normale con entità
+├── sample_with_entities.txt    # Doc ricco di entità
+└── sample_empty.txt           # Doc vuoto
+```
+
+## 🔧 Configurazione
+
+### **pytest.ini**
+Configurazione pytest con:
+- Markers personalizzati
+- Coverage settings
+- Warning filters
+- Default options
+
+### **conftest.py**
+Fixtures condivise:
+- Mock Azure OpenAI
+- Mock Streamlit components
+- Test data generators
+- Environment setup
+
+## 🐛 Debugging Test
+
+### **Test Falliti**
+```bash
+# Re-run solo falliti
+pytest --lf
+
+# Stop al primo fallimento
+pytest -x
+
+# Debug mode
+pytest --pdb
+```
+
+### **Test Specifici**
+```bash
+# Singolo test
+pytest tests/test_anonymizer.py::TestNERAnonimizer::test_anonymize_complete_pipeline
+
+# Classe di test
+pytest tests/test_anonymizer.py::TestNERAnonimizer
+
+# Con keyword
+pytest -k "anonymize and not slow"
+```
+
+## 🚀 CI/CD Integration
+
+### **GitHub Actions Example**
+```yaml
+- name: Run Tests
+  run: |
+    pytest --cov --cov-report=xml
+    
+- name: Upload Coverage
+  uses: codecov/codecov-action@v3
+```
+
+### **Pre-commit Hooks**
+```bash
+# Installa pre-commit
+pip install pre-commit
+pre-commit install
+
+# Test automatici prima del commit
+pre-commit run --all-files
+```
+
+## 📈 Performance Testing
+
+### **Benchmark Tests**
+```bash
+# Solo benchmark
+pytest --benchmark-only
+
+# Salva risultati
+pytest --benchmark-save=baseline
+
+# Confronta con baseline
+pytest --benchmark-compare=baseline
+```
+
+### **Memory Testing**
+```bash
+# Con memory profiler
+pytest --memray
+
+# Test memory leaks
+pytest --memray --trace-memory
+```
+
+## 🔍 Quality Checks
+
+### **Code Quality**
+```bash
+# Linting
+flake8 .
+
+# Formatting
+black --check .
+
+# Import sorting
+isort --check-only .
+```
+
+### **Security Scanning**
+```bash
+# Security vulnerabilities
+bandit -r .
+
+# Dependency check
+safety check
+```
+
+## 📝 Writing New Tests
+
+### **Naming Convention**
+- File: `test_<module>.py`
+- Class: `Test<ComponentName>`
+- Method: `test_<what_it_tests>`
+
+### **Test Structure**
+```python
+def test_function_behavior():
+    # Arrange
+    input_data = "test input"
+    expected = "expected output"
+    
+    # Act
+    result = function_under_test(input_data)
+    
+    # Assert
+    assert result == expected
+```
+
+### **Best Practices**
+- ✅ Test one thing per test
+- ✅ Use descriptive names
+- ✅ Mock external dependencies
+- ✅ Test edge cases
+- ✅ Keep tests independent
+
+## 🎪 Quick Commands
+
+```bash
+# Full test suite
+make test
+
+# Fast tests only
+make test-fast
+
+# Coverage report
+make coverage
+
+# Quality checks
+make lint
+
+# All checks
+make check-all
+```

tests/test_requirements.txt

@@ -0,0 +1,23 @@
+# Test Dependencies
+pytest>=7.4.0
+pytest-cov>=4.1.0
+pytest-mock>=3.11.0
+pytest-xdist>=3.3.1
+
+# Mocking and fixtures
+responses>=0.23.0
+factory-boy>=3.3.0
+
+# Coverage reporting
+coverage>=7.3.0
+
+# Code quality
+flake8>=6.0.0
+black>=23.7.0
+isort>=5.12.0
+
+# Performance testing (optional)
+pytest-benchmark>=4.0.0
+
+# Async testing (if needed)
+pytest-asyncio>=0.21.0

tests/test_utils.py

@@ -0,0 +1,317 @@
+"""
+Test per funzioni utility.
+"""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'src')))
+
+import pytest
+import json
+import tempfile
+import os
+from unittest.mock import Mock, patch, MagicMock
+from datetime import datetime
+from utils import (
+    validate_file_upload, export_results_json, get_confirmed_docs_count,
+    add_chat_message, add_crewai_result, get_system_stats
+)
+
+class TestFileValidation:
+    """Test validazione file"""
+    
+    def test_validate_file_upload_valid(self):
+        """Test file valido"""
+        mock_file = Mock()
+        mock_file.name = "test.txt"
+        mock_file.size = 1024  # 1KB
+        
+        assert validate_file_upload(mock_file) == True
+    
+    def test_validate_file_upload_none(self):
+        """Test file None"""
+        assert validate_file_upload(None) == False
+    
+    @patch('streamlit.error')
+    def test_validate_file_upload_wrong_extension(self, mock_error):
+        """Test estensione file sbagliata"""
+        mock_file = Mock()
+        mock_file.name = "test.pdf"
+        mock_file.size = 1024
+        
+        result = validate_file_upload(mock_file)
+        
+        assert result == False
+        mock_error.assert_called_once()
+    
+    @patch('streamlit.error')
+    def test_validate_file_upload_too_large(self, mock_error):
+        """Test file troppo grande"""
+        mock_file = Mock()
+        mock_file.name = "test.txt"
+        mock_file.size = 11 * 1024 * 1024  # 11MB
+        
+        result = validate_file_upload(mock_file)
+        
+        assert result == False
+        mock_error.assert_called_once()
+
+class TestExportResults:
+    """Test export risultati"""
+    
+    def test_export_results_json_basic(self):
+        """Test export JSON base"""
+        data = {"test": "value", "number": 123}
+        
+        result = export_results_json(data, "test")
+        
+        # Verifica che sia JSON valido
+        parsed = json.loads(result)
+        assert parsed["test"] == "value"
+        assert parsed["number"] == 123
+        assert "metadata" in parsed
+        assert "exported_at" in parsed["metadata"]
+    
+    def test_export_results_json_with_datetime(self):
+        """Test export con datetime"""
+        data = {"timestamp": datetime.now()}
+        
+        result = export_results_json(data, "test")
+        
+        # Non dovrebbe lanciare errori
+        parsed = json.loads(result)
+        assert "timestamp" in parsed
+    
+    def test_export_results_json_metadata(self):
+        """Test metadati export"""
+        data = {"item1": "value1", "item2": "value2"}
+        
+        result = export_results_json(data, "test")
+        parsed = json.loads(result)
+        
+        assert "metadata" in parsed
+        assert parsed["metadata"]["total_items"] == 2
+        assert "exported_at" in parsed["metadata"]
+        
+        # Verifica formato ISO datetime
+        timestamp = parsed["metadata"]["exported_at"]
+        datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+
+class TestSessionStateHelpers:
+    """Test helper per session state"""
+    
+    @patch('streamlit.session_state', {})
+    def test_get_confirmed_docs_count_empty(self):
+        """Test conteggio documenti confermati vuoto"""
+        result = get_confirmed_docs_count()
+        assert result == 0
+    
+    @patch('streamlit.session_state')
+    def test_get_confirmed_docs_count_with_docs(self, mock_session):
+        """Test conteggio documenti confermati"""
+        mock_session.get.return_value = {
+            'doc1': {'confirmed': True},
+            'doc2': {'confirmed': False},
+            'doc3': {'confirmed': True}
+        }
+        
+        result = get_confirmed_docs_count()
+        assert result == 2
+    
+    @patch('streamlit.session_state')
+    def test_add_chat_message(self, mock_session):
+        """Test aggiunta messaggio chat"""
+        mock_session.chat_history = []
+        
+        add_chat_message("user", "Test message")
+        
+        assert len(mock_session.chat_history) == 1
+        assert mock_session.chat_history[0]["role"] == "user"
+        assert mock_session.chat_history[0]["content"] == "Test message"
+    
+    @patch('streamlit.session_state')
+    def test_add_crewai_result(self, mock_session):
+        """Test aggiunta risultato CrewAI"""
+        mock_session.crewai_history = []
+        
+        add_crewai_result("test query", "comprehensive", "test result", ["agent1"])
+        
+        assert len(mock_session.crewai_history) == 1
+        result = mock_session.crewai_history[0]
+        
+        assert result["query"] == "test query"
+        assert result["analysis_type"] == "comprehensive"
+        assert result["result"] == "test result"
+        assert result["agents_used"] == ["agent1"]
+        assert "timestamp" in result
+
+class TestSystemStats:
+    """Test statistiche sistema"""
+    
+    @patch('streamlit.session_state')
+    def test_get_system_stats_empty(self, mock_session):
+        """Test statistiche sistema vuoto"""
+        mock_session.get.return_value = {}
+        
+        stats = get_system_stats()
+        
+        assert stats['uploaded_files'] == 0
+        assert stats['anonymized_docs'] == 0
+        assert stats['confirmed_docs'] == 0
+        assert stats['processed_docs'] == 0
+        assert stats['chat_messages'] == 0
+        assert stats['crewai_analyses'] == 0
+        assert stats['vector_store_ready'] == False
+    
+    @patch('streamlit.session_state')
+    def test_get_system_stats_populated(self, mock_session):
+        """Test statistiche sistema con dati"""
+        def mock_get(key, default=None):
+            data = {
+                'uploaded_files': {'file1': {}, 'file2': {}},
+                'anonymized_docs': {
+                    'file1': {'confirmed': True},
+                    'file2': {'confirmed': False}
+                },
+                'processed_docs': {'file1': {}},
+                'chat_history': [{'role': 'user'}, {'role': 'assistant'}],
+                'crewai_history': [{'query': 'test'}],
+                'vector_store_built': True
+            }
+            return data.get(key, default)
+        
+        mock_session.get.side_effect = mock_get
+        
+        with patch('utils.get_confirmed_docs_count', return_value=1):
+            stats = get_system_stats()
+        
+        assert stats['uploaded_files'] == 2
+        assert stats['anonymized_docs'] == 2
+        assert stats['confirmed_docs'] == 1
+        assert stats['processed_docs'] == 1
+        assert stats['chat_messages'] == 2
+        assert stats['crewai_analyses'] == 1
+        assert stats['vector_store_ready'] == True
+
+class TestFileOperations:
+    """Test operazioni file"""
+    
+    def test_temp_file_creation_and_cleanup(self, temp_test_file):
+        """Test creazione e cleanup file temporaneo"""
+        # File dovrebbe esistere
+        assert os.path.exists(temp_test_file)
+        
+        # Contenuto dovrebbe essere corretto
+        with open(temp_test_file, 'r') as f:
+            content = f.read()
+        assert content == "Test content for file operations"
+        
+        # Dopo il test, il file viene automaticamente rimosso dal fixture
+
+class TestDataProcessing:
+    """Test elaborazione dati"""
+    
+    def test_json_serialization_complex_data(self):
+        """Test serializzazione dati complessi"""
+        complex_data = {
+            "string": "test",
+            "number": 123,
+            "float": 45.67,
+            "boolean": True,
+            "null": None,
+            "list": [1, 2, 3],
+            "nested": {
+                "inner": "value"
+            },
+            "datetime": datetime.now()
+        }
+        
+        result = export_results_json(complex_data, "complex")
+        
+        # Dovrebbe serializzare senza errori
+        parsed = json.loads(result)
+        assert parsed["string"] == "test"
+        assert parsed["number"] == 123
+        assert parsed["float"] == 45.67
+        assert parsed["boolean"] == True
+        assert parsed["null"] is None
+        assert parsed["list"] == [1, 2, 3]
+        assert parsed["nested"]["inner"] == "value"
+        assert "datetime" in parsed  # Convertito in stringa
+
+class TestErrorHandling:
+    """Test gestione errori"""
+    
+    @patch('streamlit.session_state', side_effect=Exception("Session state error"))
+    def test_get_confirmed_docs_count_exception(self):
+        """Test gestione eccezione in conteggio documenti"""
+        # Dovrebbe gestire l'eccezione e tornare 0
+        result = get_confirmed_docs_count()
+        assert result == 0
+    
+    def test_export_results_with_non_serializable(self):
+        """Test export con oggetti non serializzabili"""
+        class NonSerializable:
+            pass
+        
+        data = {"object": NonSerializable()}
+        
+        # Dovrebbe gestire oggetti non serializzabili
+        result = export_results_json(data, "test")
+        parsed = json.loads(result)
+        
+        # L'oggetto dovrebbe essere convertito in stringa
+        assert "object" in parsed
+
+class TestValidationHelpers:
+    """Test helper di validazione"""
+    
+    def test_validate_file_upload_edge_cases(self):
+        """Test casi limite validazione file"""
+        # File con nome vuoto
+        mock_file = Mock()
+        mock_file.name = ""
+        mock_file.size = 1024
+        
+        with patch('streamlit.error'):
+            result = validate_file_upload(mock_file)
+            assert result == False
+        
+        # File esattamente al limite (10MB)
+        mock_file.name = "test.txt"
+        mock_file.size = 10 * 1024 * 1024
+        
+        result = validate_file_upload(mock_file)
+        assert result == True
+        
+        # File con estensione maiuscola
+        mock_file.name = "test.TXT"
+        mock_file.size = 1024
+        
+        result = validate_file_upload(mock_file)
+        assert result == True
+
+class TestIntegrationHelpers:
+    """Test helper per integrazione"""
+    
+    @patch('streamlit.session_state')
+    def test_session_state_integration(self, mock_session):
+        """Test integrazione con session state"""
+        # Simula stato iniziale
+        mock_session.chat_history = []
+        mock_session.crewai_history = []
+        
+        # Aggiungi dati
+        add_chat_message("user", "Hello")
+        add_chat_message("assistant", "Hi there")
+        add_crewai_result("test query", "sentiment", "positive result")
+        
+        # Verifica stato finale
+        assert len(mock_session.chat_history) == 2
+        assert len(mock_session.crewai_history) == 1
+        
+        # Verifica contenuti
+        assert mock_session.chat_history[0]["role"] == "user"
+        assert mock_session.chat_history[1]["role"] == "assistant"
+        assert mock_session.crewai_history[0]["analysis_type"] == "sentiment"