versione aggiornata con ollama

app.py

@@ -1,18 +1,12 @@
 import streamlit as st
-from ragpipeline import (RAGPipeline,Retriever,ChatBot)
+from ragpipeline import (RAGPipeline,Retriever,OllamaChatbot)
 import tempfile
 import pandas as pd
-from textutils import ParagraphDocumentProcessor, DocumentProcessor,WholeTextDocumentProcessor
+from textutils import ParagraphDocumentProcessor, SmallFragmentDocumentProcessor,WholeTextDocumentProcessor
 from HFChatbot import HFBot
 import os
 
-
 def main():
-    UPLOAD_DIR = "/tmp/"
-    os.makedirs(UPLOAD_DIR, exist_ok=True)
-    
-    codice_tabella = f"<table><tr><td>💡AURA:</td><td> AI-Driven Unified Regulatory Audit</td></tr></table>"
-    st.markdown(codice_tabella, unsafe_allow_html=True)
 
     if "faiss_builder" not in st.session_state:
         ragpipeline = RAGPipeline(numero_frammenti=10)
@@ -26,47 +20,100 @@ def main():
     if "indice_creato" not in st.session_state:
         st.session_state["indice_creato"] = False
 
-    modelliLLM = [
-        'Almawave/Velvet-2B',
-        'Almawave/Velvet-14B',
-        'mistralai/Mistral-7B-Instruct-v0.1',
-        'sapienzanlp/Minerva-350M-base-v1.0',
-        'Qwen/Qwen3-0.6B'
+
+
+    modelliVelvet = [
+            'Almawave/Velvet-2B',
+            'Almawave/Velvet-14B',
+            
     ]
+    modelliLLM = [
+            'Almawave/Velvet-2B',
+            'Almawave/Velvet-14B',
+            
+            'mistralai/Mistral-7B-Instruct-v0.1',
+            'Qwen/Qwen2.5-1.5B',
+            'BlackBeenie/Qwen3-30B-A3B-Q4_K_M-GGUF'
+        ]
+    
     modelliOllama = [
-        
-        'deepseek-r1:1.5b',
-        'qwen2.5:7b',
-        'deepseek-r1:7b',
-        'llama3.2:3b',
         'Almawave/Velvet:2B',
         'Almawave/Velvet:14b',
-        'mistral:latest',
-        "vaiton/minerva",
-        'qwen2.5:0.5b',
-        'qwen3:4b',
-        'minerva',
-        'nemo',
-        'deepseek-r1:14b',
+        'llama3.1:8b-instruct-q4_K_M',
         'qwen3:14b',
-        'phi4-mini-reasoning',
-        'gemma3:12b',
-        
-        ]
-
-    modello_scelto = st.selectbox("Seleziona un modello:", modelliLLM)
+        'qwen3:30b-a3b'
+                
+    ]
+    ## indica se sono sullo spaces di HF (deve essere inserita uan variabile I_AM_ON_HF)
+    sono_su_hf =os.environ.get('I_AM_ON_HF', False)
+    ## se sono su Hugginh Face non uso ollama
+    if  not  sono_su_hf:
+        modelliLLM.append("----- USARE SOLO CON OLLAMA -----")
+        for mollama in modelliOllama:
+            modelliLLM.append(mollama)
+    
+    UPLOAD_DIR="/tmp/"
+    if "indice_creato" not in st.session_state:
+        st.session_state["indice_creato"] = False
+    if "faiss_builder" not in st.session_state:
+        ragpipeline = RAGPipeline( )
+    codice_tabella = f"<table><tr><td>💡AURA:</td><td> AI-Utilizzata per la Regolarità Amministrativa</td></tr></table>"
+    st.markdown(codice_tabella, unsafe_allow_html=True)
+    st.title("Cosa è AURA?")
+    st.write("""
+            Questo strumento, attualmente in fase sperimentale, è stato sviluppato per eseguire controlli di 
+            regolarità amministrativa ai sensi dell’art. 147-bis del D.Lgs. 267/2000, 
+            con riferimento agli atti relativi al PNRR.
+            È in continua evoluzione. Per testarne il funzionamento, è sufficiente caricare un file PDF contenente 
+            una determinazione dirigenziale.
+            AURA analizzerà il documento e fornirà risposte basate su una check-list predefinita di domande.
+             <p>
+             AURA è un sistema RAG <em>Retrieval Augmented Generation</em> che dato un atto amministrativo ed eventuali allegati
+             ed una o più domande contenute in una <em>check list</em> di regolarità amministrativa, ricerca nei documenti
+             i frammenti rilevanti per la domanda; questi assieme ad alcune istruzioni (<em>In-context learning</em>) 
+             vengono inviati  ad un LLM <em>Large Language Model</em> 
+             al fine  di generare una risposta corretta e coerente con i frammenti rilevanti.
+             </p>
+             <p>
+             Questa versione di AURA utilizza Velvet:2B di Almawave, rilasciato sotto 
+             <a href="https://www.apache.org/licenses/LICENSE-2.0">Licenza Apache 2.0</a>  come LLM.
+             </p>
+            
+             """ , unsafe_allow_html=True)
+
+    st.warning("Attenzione questo tool è sperimentale. AURA può sbagliare")
+    if not sono_su_hf: 
+        modello_scelto = st.selectbox("Seleziona un modello:", modelliLLM, index=0)
+    else:
+        modello_scelto = st.selectbox("Seleziona un modello:", modelliVelvet, index=0)
     st.write(f"Hai selezionato: {modello_scelto}")
+    
+    if not sono_su_hf:
+        st.title("Generazione testo")
+        generatoriLLM =  {
+            'Hugging Face Transformers': "HF",
+            'Ollama in locale' :"OLLAMA"
+        }
+        selected_generator= st.selectbox("Scegli lo strumento per interagire con LLM", generatoriLLM.keys())
+        chiave_LLM=generatoriLLM[selected_generator]            
+        st.write(f"Hai selezionato {selected_generator}")
+    else:
+        chiave_LLM="HF"
 
+        
     st.title("Suddivisione in paragrafi")
     docprocessor_options = {
-        "ParagraphDocumentProcessor": ParagraphDocumentProcessor(),
-        "WholeText": WholeTextDocumentProcessor()
+        "Small Fragments (più veloce ma poco preciso)": SmallFragmentDocumentProcessor(),
+        "ParagraphDocumentProcessor (più lento e leggermente più preciso)": ParagraphDocumentProcessor(),
+        "WholeText (viene generato un solo grande frammento, può confondere gli LLM)": WholeTextDocumentProcessor(),
     }
     selected_docprocessor = st.selectbox("Divisione in paragrafi", docprocessor_options.keys())
-    docprocessor = docprocessor_options[selected_docprocessor]
+    ragpipeline.docprocessor = docprocessor_options[selected_docprocessor]
     st.write(f"Hai selezionato: **{selected_docprocessor}**")
 
-    ragpipeline.docprocessor = docprocessor
+
+
+    
     if not st.session_state["indice_creato"]:
         st.subheader("Carica l'atto principale (Determinazione)")
 
@@ -125,9 +172,15 @@ def main():
             if domanda.strip().upper() == "FINE":
                 st.stop()
 
-            #cb = ChatBot(model_name="flaollama", model_orig=modello_scelto)
+            if chiave_LLM ==  "HF":
+                    LLM=HFBot(model_name=modello_scelto)
+            elif chiave_LLM == "OLLAMA":
+                    LLM=OllamaChatbot(model_name="flaollama",model_orig=modello_scelto)
+            else:
+                    LLM=HFBot(model_name=modello_scelto)
+
+
 
-            cb  = HFBot(model_name=modello_scelto)
 
             ret = Retriever(
                 indice=ragpipeline.indice,
@@ -140,7 +193,7 @@ def main():
 
             ret.esegui_query(top_k=3)
 
-            risposta = cb.generate(
+            risposta = LLM.generate(
                 query=domanda,
                 relevant_docs=ret.passaggi_rilevanti,
                 attributi_frammenti_rilevanti=ret.attributi_rilevanti,
@@ -158,7 +211,7 @@ def main():
             id_frammenti_recuperati =  ":".join(sorted(set(elemento['id'] for elemento in ret.attributi_rilevanti)))
             dump  = {
                  'timestamp': ragpipeline.timestamp,
-                "modello": cb.model_orig, 
+                "modello": modello_scelto, 
                 "documenti": st.session_state.get("main_pdf_nome", "non disponibile"),
                 "file_recuperati": "",
                 "file_gold": "",
@@ -167,7 +220,7 @@ def main():
                 "domanda":domanda,
                 "istruzioni":istruzione, 
                 "risposta_gold": " ", 
-                "risposta":cb.pulisci_risposta(risposta)}
+                "risposta":LLM.pulisci_risposta(risposta)}
 
             RAGPipeline.dump_excel(dizionario=dump,filename="dumpChatbot.xlsx")
 

ragpipeline.py

@@ -118,17 +118,32 @@ class Retriever:
         self.attributi_rilevanti = [self.attributi_frammenti[j] for j in indices[0]] #passaggi rilevanti
         
 
+
 class ChatBot:
+    def pulisci_risposta(self,
+                             response: str):
+        retval=re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip() 
+       
+        retval = retval.replace("\n", " ").replace("\t", " ").replace("|", " ")
+
+        return retval
+    
+    def chat(self, domanda: str, istruzioni: str = None, frammenti =[]) -> str:
+        raise NotImplementedError("Questo metodo deve essere implementato nelle sottoclassi.")
+    def generate(self, relevant_docs = [], attributi_frammenti_rilevanti = [],  query="", istruzioni :str = None ) -> str:
+        raise NotImplementedError("Questo metodo deve essere implementato nelle sottoclassi.")
+
+class OllamaChatbot(ChatBot):
     def __init__(self, 
                  model_name: str = "flaollama",
                  model_orig: str = "mistral"  ,
                  model_system=(
-                "Sei un esperto di diritto amministrativo che deve eseguire il "
-                "controllo di regolarità amministrativa su un atto amministrativo di un comune italiano. "
-                "Ti verranno forniti un atto amministrativo  (determinazione dirigenziale) ed eventuali allegati, questi sono forniti come frammenti rilevanti. "
-                "Utilizza solamente i frammenti che ti verranno inviati."
-                "Rispondi in Italiano usando al massimo 50 parole. "
-                "Basati esclusivamente sul seguente testo: "
+                """Sei un esperto di diritto amministrativo che deve eseguire il 
+                controllo di regolarità amministrativa su un atto amministrativo di un comune italiano. 
+                Ti verranno forniti un atto amministrativo  (determinazione dirigenziale) ed eventuali allegati, questi sono forniti come frammenti rilevanti. 
+                Utilizza solamente i frammenti che ti verranno inviati.
+                Rispondi in Italiano usando al massimo 50 parole. 
+                Basati esclusivamente sul seguente testo: """
             ),
                 dump_filename="dump.csv"
                      ):
@@ -141,31 +156,6 @@ class ChatBot:
             from_=model_orig, 
             system = model_system
         )
-
-    def dump_excel(self, dizionario, filename ):
-        RAGPipeline.dump_excel(dizionario=dizionario, filename=filename)
-
-    def dump_csv(self,dizionario):
-        """Salva un dizionario in un file CSV con separatore '|' accodando i dati se il file esiste."""
-        file_esiste = os.path.isfile(self.dump_filename)
-
-        with open(self.dump_filename, mode="a", newline="", encoding="utf-8") as file:
-            writer = csv.writer(file, delimiter="|")
-
-            # Scrive l'intestazione solo se il file viene creato ex novo
-            if not file_esiste:
-                writer.writerow(dizionario.keys())
-
-            # Scrive i valori come una nuova riga
-            writer.writerow([str(val).replace("\n", "").replace("\r", "").replace("\t", "") for val in dizionario.values()])
-
-    def pulisci_risposta(self,
-                             response: str):
-        retval=re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip() 
-       
-        retval = retval.replace("\n", " ").replace("\t", " ").replace("|", " ")
-
-        return retval
     def chat(self, domanda: str, istruzioni: str = None, frammenti =[]) -> str:
         prompt = f"ISTRUZIONI: {istruzioni}\n\nCONTESTO:\n" + "\n".join(frammenti) + f"\n\nDOMANDA: {domanda}"
         
@@ -175,13 +165,7 @@ class ChatBot:
         
         return response["message"]["content"]
 
-    def generate(self,
-             relevant_docs = [],
-             attributi_frammenti_rilevanti = [],
-             query="",
-             istruzioni :str = None ##togliere
-             ):
-        
+    def generate(self, relevant_docs = [], attributi_frammenti_rilevanti = [],  query="", istruzioni :str = None ):
         i = 0
         #print (f"DIMESIONE FILE {len(relevant_files)}")
         #print (f"DIMESIONE TESTI {len(relevant_docs)}")

textutils.py

@@ -2,7 +2,7 @@
 import pandas as pd
 import re
 import PyPDF2
-from dizionario_acronimi import acronimi
+
 import unicodedata
 
 class DocumentProcessor:
@@ -57,8 +57,7 @@ class DocumentProcessor:
             for page in reader.pages:
                 page_text = page.extract_text() or ""
                 full_text += page_text 
-            for acr, espansione in acronimi.items():
-                full_text = full_text.replace(acr,espansione)
+
        return full_text
 
     def chunk_text_by_paragraph(self,text: str):
@@ -146,15 +145,43 @@ class ParagraphDocumentProcessor(DocumentProcessor):
     
 class WholeTextDocumentProcessor(DocumentProcessor) :
         def scomponi_in_frammenti(self, testo:str, numero_frammenti: int = 1):
-            print("WholeTextDocumeptProcessor !!!")
             return [testo]
+        
+class SmallFragmentDocumentProcessor(DocumentProcessor):
+    def scomponi_in_frammenti(self, testo:str, numero_frammenti: int = 1):
+         return self.dividi_testo_in_frammenti(testo)
+    
+    def dividi_testo_in_frammenti(self,testo, lunghezza_massima=1000):
+        frammenti = []
+        inizio = 0
+
+        while inizio < len(testo):
+            fine = inizio + lunghezza_massima
+
+            # Se siamo alla fine del testo, aggiungiamo e usciamo
+            if fine >= len(testo):
+                frammenti.append(testo[inizio:].strip())
+                break
+
+            # Cerca l'ultimo spazio prima del limite per evitare di tagliare la parola
+            fine_corretto = testo.rfind(" ", inizio, fine)
+            if fine_corretto == -1 or fine_corretto <= inizio:
+                # Se non troviamo spazi, tagliamo brutalmente
+                fine_corretto = fine
+
+            frammento = testo[inizio:fine_corretto].strip()
+            frammenti.append(frammento)
+            inizio = fine_corretto
+
+        return frammenti
 
 
 
 
-    
 
         
 
+            
+