creazione dell'app

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)
+    }