Initial clean commit without secrets

.gitignore

@@ -0,0 +1,23 @@
+# --- PYTHON & BACKEND ---
+venv/
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+temp_uploads/
+.pytest_cache/
+
+# --- NODE & FRONTEND ---
+node_modules/
+frontend/node_modules/
+frontend/dist/
+frontend/build/
+.eslintcache
+
+# --- OS & IDE ---
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+*.log
+

README.md

@@ -0,0 +1,2 @@
+# GraphRAG
+Sistema RAG avanzato che combina Neo4j e LangGraph per analisi deterministiche di PDF. Sfrutta Mistral come router strategico per query vettoriali o Cypher, GLiNER per l’estrazione di entità e BGE-Reranker per la precisione. Frontend in React con rendering Markdown e Backend in FastAPI. PDF interrogabili in chat in linguaggio naturale.

agentLogic/graph.py

@@ -0,0 +1,25 @@
+from langgraph.graph import StateGraph, END
+from agentLogic.state import AgentState
+from agentLogic.nodes import node_router, node_retriever, node_generator, node_reranker, node_rewriter
+
+workflow = StateGraph(AgentState)
+
+#Aggiunta Nodi
+workflow.add_node("rewriter", node_rewriter)
+workflow.add_node("router", node_router)
+workflow.add_node("retriever", node_retriever)
+workflow.add_node("reranker", node_reranker)
+workflow.add_node("generator", node_generator)
+
+#Definizione Percorso
+workflow.set_entry_point("rewriter")
+workflow.add_edge("rewriter", "router")
+workflow.add_edge("router", "retriever")
+workflow.add_edge("retriever", "reranker")
+workflow.add_edge("reranker", "generator") 
+workflow.add_edge("generator", END)
+
+app = workflow.compile()
+
+
+    

agentLogic/nodes.py

@@ -0,0 +1,375 @@
+#Questo file contiene la logica per i due modelli
+
+import os
+import json
+import re
+import logging
+from groq import Groq
+from mistralai import Mistral
+from agentLogic.state import AgentState
+from db.graph_db import GraphDB
+from processingPdf.reranker import Reranker
+from processingPdf.indexer import Indexer
+
+logger = logging.getLogger(__name__)
+
+groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+mistral_client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
+
+# Inizializziamo i modelli pesanti fuori dai nodi per caricarli una sola volta all'avvio
+# Fondamentale per le performance di FastAPI
+indexer_instance = Indexer() 
+reranker_model = Reranker()
+
+#Estrae e pulisce il JSON dall'output dell'LLM
+def extract_json(text):
+    try:
+        #Cerca il blocco tra parentesi graffe
+        match = re.search(r'\{.*\}', text, re.DOTALL)
+        if match:
+            return json.loads(match.group(0))
+        return json.loads(text)
+    except Exception as e:
+        logger.error(f"Errore nel parsare il JSON: {e}")
+        return {"route": "vector", "entities": [], "keywords": []}
+
+#Nodo rewriter: Pulisce la query, corregge errori e agisce da Guardrail. precedentemente aveva anche una funzione di
+# ampliamento contestuale ma ho deciso di eliminare l'espansione semantica forzata per evitare di compromettere il contesto del RAG come successo in fase di testing
+def node_rewriter(state: AgentState):
+    user_query = state["query"]
+
+    prompt = f"""
+    ### ROLE
+    Sei un correttore ortografico e/o grammaticale e sintattico. Il tuo unico output deve essere la query corretta.
+
+    ### TASK
+    1. **Correzione**: Correggi eventuali errori di ortografia, sintassi, grammaticali o di battitura.
+    2. **Minimalismo**: NON AGGIUNGERE contesto, sinonimi o interpretazioni. Se la domanda è chiara (es. "cos'è la persona"), lasciala IDENTICA.
+
+    ### ESEMPI
+    Input: "cos'è la 'persona'?" -> Output: cos'è la 'persona'?
+    Input: "spiegami il prompt pstern" -> Output: spiegami il prompt pattern
+    Input: "Quali sono i sui sinotmi?" -> Output: Quali sono i suoi sintomi?
+
+    USER QUERY: "{user_query}"
+    OUTPUT:
+    """
+
+    completion = groq_client.chat.completions.create(
+        model="llama-3.1-8b-instant",
+        messages=[
+            {"role": "system", "content": "Sei un correttore di testo puro. Non salutare. Non spiegare. Restituisci SOLO il risultato."},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0.0 
+    )
+
+    rewritten_query = completion.choices[0].message.content.strip()
+    #pulizia ulteriore 
+    rewritten_query = rewritten_query.replace('Output:', '').replace('"', '').strip()
+
+    print(f"DEBUG - Query Rewriting: '{user_query}' -> '{rewritten_query}'")
+    
+    return {"query": rewritten_query}
+
+#Nodo 1: utilizzo mistral per decidere la strategia di ricerca"
+def node_router(state: AgentState):
+    """
+    Nodo 1: Utilizza Mistral per decidere la strategia di ricerca.
+    Implementa Role Prompting, Few-Shot, Constraint Enforcement e Output Structuring.
+    """
+    
+    # Nota: Usiamo le doppie parentesi graffe {{ }} per includere JSON letterali nelle f-strings.
+    prompt = f"""
+    ### ROLE
+    Sei l'Analizzatore Logico di un sistema RAG (Retrieval-Augmented Generation) avanzato. 
+    Il tuo unico compito è decostruire la domanda dell'utente per determinare la migliore strategia di recupero dati da un database a grafo Neo4j.
+
+    ### DOMINIO CONTESTUALE
+    I documenti analizzati possono appartenere a domini eterogenei: medico-sanitario, tecnico, giuridico, ecc.
+    Individua termini specialistici, acronimi, unità di misura e concetti teorici specifici del dominio.
+
+    ### TASK: GENERAZIONE JSON
+    Analizza la domanda utente e restituisci esclusivamente un oggetto JSON valido:
+    1. `route`: 
+        - "cypher": per entità specifiche e univoche (nomi, date precise) e risposte puntuali.
+        - "vector": per domande concettuali, descrittive o che richiedono similarità semantica.
+        - "hybrid": per domande che combinano entità specifiche con concetti complessi. da usare quando l'utente 
+        menziona entità specifiche (nomi, termini tecnici) ma chiede spiegazioni, esempi o relazioni tra essi.
+    2. `entities`: Lista delle entità nominate (es. ["Mario Rossi", "BMI"]).
+    3. `keywords`: Lista di 3-5 keyword per la ricerca vettoriale (sostantivi normalizzati).
+
+    ### ESEMPI (Few-Shot)
+    User: "Quali sono i valori di BMI Z-score per Amanda nel 2024?"
+    Output: {{ "route": "cypher", "entities": ["Amanda", "BMI Z-score", "2024"], "keywords": ["valori bmi z-score", "paziente amanda", "dati 2024"] }}
+
+    User: "Spiegami come la dieta influisce sulla crescita dei bambini con CF."
+    Output: {{ "route": "vector", "entities": ["CF"], "keywords": ["dieta fibrosi cistica", "crescita bambini", "nutrizione"] }}
+
+    ### VINCOLI RIGIDI (PENALITÀ DI OUTPUT)
+    - L’output deve essere SOLO JSON valido.
+    - NON aggiungere introduzioni, commenti o spiegazioni.
+    - Ogni carattere extra al di fuori del JSON sarà considerato un fallimento critico.
+
+    ### ESEMPIO DI STRUTTURA ATTESA
+    User: "Qual è il BMI di Mario Rossi nel 2023?"
+    Output: {{
+        "route": "hybrid",
+        "entities": ["Mario Rossi", "BMI", "2023"],
+        "keywords": ["valutazione BMI", "Mario Rossi", "cartella clinica 2023"]
+    }}
+
+    ### DOMANDA DA ANALIZZARE
+    "{state['query']}"
+    """
+
+    response = mistral_client.chat.complete(
+        model="labs-devstral-small-2512",
+        messages=[{"role": "user", "content": prompt}]
+    )
+
+    # Estrazione e parsing del JSON dalla risposta del modello
+    content = response.choices[0].message.content
+    intent_json = extract_json(content)
+    
+    # Fondamentale: restituiamo il dizionario parsato per i nodi successivi
+    return {"intent_data": intent_json}
+
+# Esegue la ricerca ibrida su neo4j basandosi sull'intent
+def node_retriever(state: AgentState):
+    intent = state["intent_data"]
+    target_file = state["filename"] 
+    db = GraphDB()
+    collected_chunks = []
+    seen_ids = set()
+
+    # Stampo l'intent per monitorare le decisioni del Router in tempo reale
+    print(f"DEBUG - Intent ricevuto: {intent}")
+
+    # 1. RICERCA PER ENTITÀ (STRATEGIA CYPHER)
+    # Se il router ha scelto 'cypher' o 'hybrid', interrogo il grafo tramite le entità estratte
+    if intent.get("route") in ["cypher", "hybrid"]:
+        entities = intent.get("entities", [])
+        for entity in entities:
+            entity_name = entity["value"] if isinstance(entity, dict) else entity
+            
+            # Nota: Al momento entity_search esegue una ricerca globale. 
+            results = db.entity_search(entity_name)
+            for res in results:
+                # Aggiungo un controllo di sicurezza per assicurarmi di prendere solo i chunk del documento corrente
+                if res["chunk_id"] not in seen_ids and res.get("filename") == target_file:
+                    content_text = res.get("node_content", "")
+                    collected_chunks.append(f"[Entity Match: {entity_name}] {content_text}")
+                    seen_ids.add(res["chunk_id"])
+    
+    # 2. RICERCA VETTORIALE (STRATEGIA SEMANTICA)
+    # Se il router ha scelto 'vector' o 'hybrid', utilizzo gli embeddings per la similarità
+    if intent.get("route") in ["vector", "hybrid"]:
+        keywords = intent.get("keywords", [])
+        search_query = " ".join(keywords) if keywords else state["query"]
+        
+        # Uso l'istanza caricata all'avvio del server
+        embedding = indexer_instance.generate_embeddings(search_query)
+        
+        # Ho deciso di passare 'target_file' come parametro 'filename' per attivare il filtro Cypher 
+        # interno alla query vettoriale e isolare il documento
+        vector_results = db.query_vector_index(
+            "chunk_embeddings_index", 
+            embedding, 
+            k=15, 
+            filename=target_file
+        )
+        
+        # Estraggo lo score del miglior risultato locale per decidere se attivare la ricerca globale
+        max_local_score = vector_results[0]["score"] if vector_results else 0
+        print(f"DEBUG - Risultati vettoriali trovati per {target_file}: {len(vector_results)} (Max Score: {max_local_score})")
+        
+        for res in vector_results:
+            if res["chunk_id"] not in seen_ids:
+                #includo metadati nel testo del chunk per permettere al generatore di citare la fonte
+                #mi interessa sapere, nella risposta finale, da che file è stata tratta l'informazione
+                source_info = f"[Fonte: {res.get('filename')} | Sezione: {res.get('section', 'N/A')}]"
+                content_text = res.get("node_content", "")
+                collected_chunks.append(f"{source_info} [Vector Match] {content_text}")
+                seen_ids.add(res["chunk_id"])
+
+        #attivo la GLOBAL VECTOR SEARCH se la pertinenza locale è bassa (< 0.7)
+        if max_local_score < 0.7:
+            print(f"DEBUG - Score locale basso ({max_local_score}), attivo Global Vector Search...")
+            
+            #eseguo semplicemente la query senza passare il filename per cercare in tutto il database
+            global_results = db.query_vector_index(
+                "chunk_embeddings_index", 
+                embedding, 
+                k=5, 
+                filename=None 
+            )
+            
+            for res in global_results:
+                #evito duplicati se per caso la ricerca globale ripesca chunk già visti nel locale
+                if res["chunk_id"] not in seen_ids:
+                    source_info = f"[Fonte: {res.get('filename')} | Sezione: {res.get('section', 'N/A')}]"
+                    content_text = res.get("node_content", "")
+                    collected_chunks.append(f"{source_info} [Global Vector Match] {content_text}")
+                    seen_ids.add(res["chunk_id"])
+
+    # se i metodi precedenti non producono risultati,
+    # forzo una ricerca vettoriale sull'intera query originale filtrata per il file corrente
+    if not collected_chunks:
+        print(f"DEBUG - Fallback: nessuna informazione con keyword in {target_file}, procedo con query completa.")
+        embedding_fallback = indexer_instance.generate_embeddings(state["query"])
+        
+        # Anche nel fallback, forzo il filtro sul filename per evitare contaminazioni
+        fallback_results = db.query_vector_index(
+            "chunk_embeddings_index", 
+            embedding_fallback, 
+            k=3, 
+            filename=target_file
+        )
+        for res in fallback_results:
+            if res["chunk_id"] not in seen_ids:
+                source_info = f"[Fonte: {res.get('filename')} | Sezione: {res.get('section', 'N/A')}]"
+                content_text = res.get("node_content", "")
+                collected_chunks.append(f"{source_info} [Fallback Match] {content_text}")
+                seen_ids.add(res["chunk_id"])
+
+    # gestisco esplicitamente il caso di assenza totale di dati per evitare errori nel Generator
+    if not collected_chunks:
+        collected_chunks = [f"Nessuna informazione specifica trovata nel database per il file {target_file}."]
+
+    db.close()
+    # stampo quanti chunk sto effettivamente restituendo allo stato
+    print(f"DEBUG - RETRIEVER sta inviando allo stato {len(collected_chunks)} chunk")
+    
+    return {"context_chunks": collected_chunks}
+
+#Nodo reranker, ottiene i 15 chunks più pertinenti dal retriever e si occupa di prendere i 5 veramente più pertinenti rispetto alla domanda dell'utente
+def node_reranker(state: AgentState):
+    query = state["query"]
+    chunks = state.get("context_chunks", [])
+    intent = state.get("intent_data", {})
+
+    #decido di eseguire il reranking sempre se abbiamo più di 5 chunk, 
+    #a prescindere dalla rotta, per garantire la qualità.
+    if len(chunks) <= 5: 
+        return {"context_chunks": chunks}
+    
+    print(f"DEBUG Reranker: Analizzo {len(chunks)} chunk...")
+
+    #eseguo il reranking tramite il modello BGE-Reranker-v2-m3
+    refined_chunks = reranker_model.rerank(query, chunks, top_n=5)
+    print(f"DEBUG Reranker: Ho selezionato i {len(refined_chunks)} migliori.")
+    return {"context_chunks": refined_chunks}
+
+#Nodo finale: uso Llama per la risposta
+def node_generator(state: AgentState):
+    chunks = state.get('context_chunks', [])
+    print(f"DEBUG - Numero di chunk passati al generatore: {len(chunks)}")
+    
+    context = "\n\n".join(chunks)
+    
+    if not context.strip():
+        print("DEBUG - ATTENZIONE: Il contesto finale per l'LLM è vuoto!!!")
+    
+#ho deciso di determinare l'approccio in base ai tag presenti nei chunk reali
+    has_vector = any("[Vector Match]" in c or "[Fallback Match]" in c for c in chunks)
+    has_entity = any("[Entity Match]" in c for c in chunks)
+
+    if has_vector and has_entity:
+        approach = "Hybrid"
+    elif has_vector:
+        approach = "Vector Match"
+    elif has_entity:
+        approach = "Entity Match"
+    else:
+        approach = "Non applicabile"
+
+    prompt = f"""
+    ### ROLE
+    Sei un assistente virtuale altamente specializzato nell’analisi di documenti medici e tecnico-scientifici.
+    Il tuo compito è generare risposte **accurate, verificabili ed evidence-based**, evitando qualsiasi forma di inferenza non supportata dalle fonti fornite.
+
+    ---
+
+    ### CONTESTO FORNITO (FONTI VERIFICATE)
+    Di seguito sono riportati uno o più frammenti di documenti (chunk) estratti dal database.
+    Ogni frammento è preceduto dall’etichetta del metodo di recupero:
+    - [Vector Match]: recupero per similarità semantica
+    - [Entity Match]: recupero basato su entità esplicite
+
+    Usa **solo ed esclusivamente** le informazioni contenute in questi frammenti.
+
+    ---------------------
+    {context}
+    ---------------------
+
+    ### ISTRUZIONI DI CITAZIONE OBBLIGATORIE
+    1. Se utilizzi informazioni provenienti da un file diverso da '{state['filename']}', 
+       devi indicare esplicitamente a fine risposta da quale file e sezione hai tratto l'integrazione.
+    2. Usa il formato: "Fonti esterne utilizzate: [Nome File] (Sezione)".
+
+    ---
+
+    ### ISTRUZIONI DI GENERAZIONE (OBBLIGATORIE)
+
+    1. **Aderenza totale alle fonti**
+    - Rispondi alla domanda utilizzando **unicamente** le informazioni presenti nel contesto fornito.
+    - Non introdurre conoscenze esterne, linee guida generali o interpretazioni personali.
+
+    2. **Gestione dell’informazione insufficiente**
+    - Se il contesto non contiene dati sufficienti, completi o direttamente pertinenti per rispondere alla domanda,
+        devi rispondere **esattamente** con la seguente frase (senza aggiunte):
+        > "Mi dispiace, ma il documento fornito non contiene informazioni sufficienti per rispondere a questa domanda."
+
+    3. **Divieto assoluto di allucinazioni**
+    - Non dedurre, stimare, generalizzare o “completare” informazioni mancanti.
+    - Se un dato non è esplicitamente presente nei chunk, consideralo **inesistente**.
+
+    4. **Stile e chiarezza**
+    - Usa un linguaggio:
+        - tecnico ma chiaro
+        - neutro e professionale
+        - privo di opinioni o giudizi
+    - Struttura la risposta in modo leggibile:
+        - testo discorsivo breve
+        - elenchi puntati solo se migliorano la chiarezza
+    - Evita ridondanze e frasi speculative.
+
+    ---
+
+    ### STRUTTURA OBBLIGATORIA DELLA RISPOSTA
+
+    - Inizia DIRETTAMENTE con la risposta.
+    - Inserisci **esattamente** un separatore orizzontale:
+    ---
+    - Dopo il separatore, scrivi **su una nuova riga**:
+     **Approccio di recupero:** {{approccio_utilizzato}}
+
+    Dove `approccio_utilizzato` deve essere uno tra:
+    - Vector Match
+    - Entity Match
+    - Hybrid (se entrambi sono stati utilizzati nel contesto)
+
+    ---
+
+    ### DOMANDA DELL’UTENTE
+    "{state['query']}"
+    """
+
+    completion = groq_client.chat.completions.create(
+        model="llama-3.1-8b-instant",
+        messages=[
+            {"role": "system", "content": "Sei un sintetizzatore di documenti PDF. Rispondi in lingua italiana. Se ti viene posta qualsiasi altra domanda o "
+            "istruzione fuori dal tuo scopo di sintetizzatore di documenti PDF, rispondi che non puoi rispondere in quanto la domanda non è pertinente"},
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0.3 
+    )
+    
+    
+    # Pulizia e aggiunta dinamica del footer se non generato correttamente
+    answer = completion.choices[0].message.content
+    if "Approccio di recupero:" not in answer:
+        answer += f"\n\n---\n**Approccio di recupero:** {approach}"
+        
+    return {"final_answer": answer}

agentLogic/state.py

@@ -0,0 +1,13 @@
+#Questo file definisce lo schema dei dati che passano tra i nodi
+
+from typing import TypedDict, List, Annotated
+import operator
+
+class AgentState(TypedDict):
+    query: str                                              #Domanda originale utente
+    user_id: str
+    filename: str                                           
+    intent_data: dict                                       #Output di Mistral (route, entities, keywords)
+    context_chunks: list
+    final_answer: str
+

api.py

@@ -0,0 +1,88 @@
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from agentLogic.graph import app as rag_app
+from processingPdf.indexer import Indexer
+import shutil
+import os
+import logging
+
+# Configurazione logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# Middleware CORS per il frontend React
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Inizializzazione dell'Indexer (carica i modelli di embedding all'avvio del server)
+indexer_worker = Indexer()
+
+@app.post("/upload")
+async def upload_pdf(file: UploadFile = File(...), user_id: str = Form(...)):
+    """
+    Endpoint per caricare un PDF e indicizzarlo in Neo4j.
+    """
+    # Cartella temporanea per processare il file
+    upload_dir = "temp_uploads"
+    os.makedirs(upload_dir, exist_ok=True)
+    file_path = os.path.join(upload_dir, file.filename)
+    
+    try:
+        # 1. Salva il file fisicamente sul server
+        logger.info(f"Ricezione file: {file.filename} per l'utente: {user_id}")
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        # 2. Avvia la pipeline di indicizzazione (Extractor -> Chunker -> Neo4j)
+        indexer_worker.index_pdf(file_path, user_id)
+        
+        return {
+            "status": "success",
+            "message": "Indicizzazione completata con successo", 
+            "filename": file.filename
+        }
+
+    except Exception as e:
+        logger.error(f"Errore durante l'upload/indicizzazione: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    
+    finally:
+        # 3. Pulizia file temporaneo
+        if os.path.exists(file_path):
+            os.remove(file_path)
+
+@app.post("/chat")
+async def chat(query: str, filename: str, user_id: str):
+    """
+    Endpoint per interrogare il sistema GraphRAG tramite LangGraph.
+    """
+    try:
+        # Stato iniziale per il grafo
+        initial_state = {
+            "query": query,
+            "user_id": user_id,
+            "filename": filename,
+            "intent_data": {},
+            "context_chunks": [],
+            "final_answer": ""
+        }
+        
+        # Esecuzione del workflow
+        result = rag_app.invoke(initial_state)
+        
+        return {"answer": result["final_answer"]}
+    
+    except Exception as e:
+        logger.error(f"Errore nella chat endpoint: {str(e)}")
+        raise HTTPException(status_code=500, detail="Errore durante l'elaborazione della domanda.")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("api:app", host="127.0.0.1", port=8000, reload=True)

db/graph_db.py

@@ -0,0 +1,238 @@
+#Questo file gestisce la connessione e tutte le query Cypher
+
+from neo4j import GraphDatabase, exceptions
+import logging
+import os
+from typing import List, Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+logging.basicConfig(level=logging.INFO)
+
+#Classe per la gestione della connessione e delle operazioni di base con Neo4j
+class GraphDB:
+    def __init__(self, uri: Optional[str] = None, user: Optional[str] = None, password: Optional[str] = None, database: Optional[str] = None):
+
+        #Carica credenziali dalle varibiali dambiente o usa i default del progetto
+        self.uri = uri or os.getenv("NEO4J_URI")
+        self.user = user or os.getenv("NEO4J_USERNAME")
+        self.password = password or os.getenv("NEO4J_PASSWORD")
+        self.database = database or os.getenv("NEO4J_DATABASE")
+
+        # VALIDAZIONE: Forza la presenza di tutte le variabili
+        if not all([self.uri, self.user, self.password, self.database]):
+            missing_vars = [name for name, val in [
+                ("NEO4J_URI", self.uri), 
+                ("NEO4J_USERNAME", self.user), 
+                ("NEO4J_PASSWORD", self.password), 
+                ("NEO4J_DATABASE", self.database)
+            ] if not val]
+            
+            # Rilancia un errore chiaro se le credenziali non sono definite nell'ambiente
+            raise ValueError(
+                f"Credenziali Neo4j mancanti. Assicurati che le seguenti variabili siano definite nel file .env e caricate correttamente: {', '.join(missing_vars)}"
+            )
+        
+        self.driver = None
+
+        try:
+            self.driver = GraphDatabase.driver(self.uri, auth=(self.user, self.password))
+            self.driver.verify_connectivity()
+
+            self.create_indexes_and_constraints()
+            logger.info(f"Connessione a Neo4j (DB: {self.database}) stabilita con successo.")
+        except Exception as e:
+            logger.error(f"Errore durante la connessione a Neo4j su {self.uri}: {e}")
+            raise
+    
+    #Chiude la connessione al driver Neo4j
+    def close(self):
+        if self.driver:
+            self.driver.close()
+            logger.info("Connessione a Neo4j chiusa.")
+    
+    #Crea indici e vincoli essenziali per le performance del RAG
+    def create_indexes_and_constraints(self):
+        index_queries = [
+            #Vincoli per l'unicità dei nodi principali (Documenti, Utenti)
+            "CREATE CONSTRAINT IF NOT EXISTS FOR (d:Document) REQUIRE d.filename IS UNIQUE",
+            "CREATE CONSTRAINT IF NOT EXISTS FOR (u:User) REQUIRE u.id IS UNIQUE",
+            #Indice per la ricerca di Chunk tramite ID (utile per la citazione del chunk)
+            "CREATE INDEX IF NOT EXISTS FOR (c:Chunk) ON (c.chunk_id)",
+        ]
+
+        with self.driver.session(database=self.database) as session:
+            for query in index_queries:
+                try:
+                    session.run(query)
+                except exceptions.ClientError as e:
+                    #Logga l'errore, ma ignora quelli noti di indice/vincolo già esistente
+                    if "IndexAlreadyExists" not in e.message and "ConstraintAlreadyExists" not in e.message:
+                        logger.error(f"Errore nell'esecuzione della query indice '{query}': {e}")
+                        raise
+                except Exception as e:
+                    logger.error(f"Errore inatteso nell'esecuzione della query indice '{query}': {e}")
+                    raise
+        
+        logger.info("Indici e vincoli Neo4j verificati/creati.")
+
+    
+    # --- Operazioni Crud per il RAG ---
+    #Crea o Aggiorna un nodo Document
+    def create_document_node(self, filename: str, title: str = None):
+        query = """
+        MERGE (d:Document {filename: $filename})
+        ON CREATE SET
+            d.created_at = datetime(),
+            d.title = COALESCE($title, $filename)
+        ON MATCH SET d.last_updated = datetime()
+        RETURN d
+        """
+        return self.run_query(query, {"filename": filename, "title": title})
+    
+    #Crea o aggiorna un nodo User e registra l'attività
+    def create_user_node(self, user_id: str):
+        query = """
+        MERGE (u:User {id: $user_id})
+        ON CREATE SET u.created_at = datetime(), u.last_activity = datetime()
+        ON MATCH SET u.last_activity = datetime()
+        RETURN u
+        """
+        return self.run_query(query, {"user_id": user_id})
+    
+    #Crea una relazione ACCESSED tra User e Document
+    def link_user_to_document(self, user_id: str, filename: str):
+        query = """
+        MATCH (u:User {id: $user_id})
+        MATCH (d:Document {filename: $filename})
+        MERGE (u)-[r:ACCESSED]->(d)
+        ON CREATE SET r.first_access = datetime(), r.last_access = datetime()
+        ON MATCH SET r.last_access = datetime()
+        RETURN u, d, r
+        """
+        return self.run_query(query, {"user_id": user_id, "filename": filename})
+    
+    #Aggiunge un nodo Chunk collegato al nodo Document
+    def add_chunk_to_document(self, filename: str, chunk_id: str, content: str, embedding: List[float], metadata: Dict[str, Any]):
+        query = """
+        MATCH (d:Document {filename: $filename})
+        MERGE (c:Chunk {chunk_id: $chunk_id})
+        SET c.content = $content,
+            c.embedding = $embedding,
+            c.section = $section,
+            c.source = $filename,
+            c.last_updated = datetime()
+        MERGE (d)-[:HAS_CHUNK]->(c)
+        RETURN c
+        """
+        parameters = {
+            "filename": filename,
+            "chunk_id": chunk_id,
+            "content": content,
+            "embedding": embedding,
+            "section": metadata.get("section", "unspecified")
+        }
+        return self.run_query(query, parameters)
+    
+    #Crea un indice vettoriale per la ricerca di similarità
+    def create_vector_index(self, index_name: str, node_label: str, property_name: str, vector_dimensions: int):        
+        query = f"""
+        CREATE VECTOR INDEX {index_name} IF NOT EXISTS 
+        FOR (n:{node_label})
+        ON (n.{property_name})
+        OPTIONS {{
+            indexConfig: {{
+                `vector.dimensions`: {vector_dimensions},
+                `vector.similarity_function`: 'cosine'
+            }}
+        }}
+        """
+        try:
+            self.run_query(query)
+            logger.info(f"Indice vettoriale '{index_name}' creato con successo per {node_label}.")
+        except Exception as e:
+            logger.error(f"Errore nella creazione dell'indice vettoriale '{index_name}': {e}")
+            raise
+
+        #Esegue una ricerca vettoriale, opzionalemnte filtrata per documento
+    def query_vector_index(self, index_name: str, query_embedding: List[float], k: int = 5, filename: Optional[str] = None) -> List[Dict[str, Any]]:
+
+        # db.index.vector.queryNodes è la procedura Cypher per la ricerca vettoriale
+        if filename:
+            # Ricerca filtrata per documento specifico (più precisa)
+            query = f"""
+            CALL db.index.vector.queryNodes('{index_name}', $k, $query_embedding)
+            YIELD node, score
+            WITH node, score
+            MATCH (d:Document {{filename: $filename}})-[:HAS_CHUNK]->(node)
+            RETURN node.content AS node_content, score, node.chunk_id AS chunk_id, node.section AS section, d.filename AS filename
+            """
+            parameters = {"query_embedding": query_embedding, "filename": filename, "k": k}
+        else:
+            # Ricerca globale su tutti i documenti (usato per cross-document search)
+            query = f"""
+            CALL db.index.vector.queryNodes('{index_name}', $k, $query_embedding)
+            YIELD node, score
+            RETURN node.content AS node_content, score, node.chunk_id AS chunk_id, node.section AS section, node.source AS filename
+            """
+            parameters = {"query_embedding": query_embedding, "k": k}
+        
+        results = []
+        try:
+            records = self.run_query(query, parameters)
+            for record in records:
+                results.append({
+                    "node_content": record["node_content"],
+                    "score": record["score"],
+                    "chunk_id": record["chunk_id"],
+                    "section": record.get("section", "N/A"), # Usiamo .get per sicurezza
+                    "filename": record.get("filename", "Unknown"),
+                })
+            logger.debug(f"Ricerca vettoriale ha trovato {len(results)} risultati.")
+            return results
+        except Exception as e:
+            logger.error(f"Errore durante la query dell'indice vettoriale: {e}")
+            return []
+    
+    def add_entity_to_chunk(self, entity_name, entity_type, chunk_id):
+        query = """
+        MERGE (e:Entity {name: $name, type: $type})
+        WITH e
+        MATCH (c:Chunk {chunk_id: $chunk_id})
+        MERGE (c)-[:CONTAINS_ENTITY]->(e)
+        """
+        params = {"name": entity_name, "type": entity_type, "chunk_id": chunk_id}
+        self.run_query(query, params)
+
+    #Esegue una ricerca esatta basata sui nodi Entity
+    def entity_search(self, entity_name: str) -> List[Dict[str, Any]]:
+        query = """
+        MATCH (e:Entity)
+        WHERE toLower(e.name) = toLower($name)
+        MATCH (e)<-[:CONTAINS_ENTITY]-(c:Chunk)
+        RETURN c.content AS node_content, c.chunk_id AS chunk_id, 1.0 AS score, c.section AS section, c.source AS filename
+        LIMIT 5
+        """
+        results = []
+        try:
+            records = self.run_query(query, {"name": entity_name})
+            for record in records:
+                results.append({
+                    "node_content": record.get("node_content"),
+                    "chunk_id": record.get("chunk_id"),
+                    "score": record.get("score"),
+                    "section": record.get("section"),
+                    "filename": record.get("filename")
+                })
+            return results
+        except Exception as e:
+            logger.error(f"Errore nella ricerca per entità '{entity_name}': {e}")
+            return []
+    
+    def run_query(self, query: str, parameters: Optional[Dict[str, Any]] = None):
+        if not self.driver:
+            raise RuntimeError("Driver Neo4j non inizializzato.")
+
+        with self.driver.session(database=self.database) as session:
+            result = session.run(query, parameters)
+            return result.data()

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,73 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```

frontend/eslint.config.js

@@ -0,0 +1,23 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+  },
+])

frontend/index.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html lang="it">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RAG Chatbot - Il Tuo Assistente PDF Intelligente</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=Outfit:wght@400;600;800&display=swap" rel="stylesheet">
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

frontend/metadata.json

@@ -0,0 +1,5 @@
+{
+  "name": "RAG Chatbot Assistant",
+  "description": "A modern, high-performance landing page and application for intelligent PDF interaction. Upload your documents and chat with an AI expert indexed specifically on your content.",
+  "requestFramePermissions": []
+}

frontend/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "lucide-react": "^0.562.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@tailwindcss/postcss": "^4.1.18",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.5",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.1",
+    "autoprefixer": "^10.4.23",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.1.18",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.46.4",
+    "vite": "^7.2.4"
+  }
+}

frontend/postcss.config.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    '@tailwindcss/postcss': {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.tsx

@@ -0,0 +1,584 @@
+import React, { useState, useEffect, useRef } from 'react';
+import type { Message, UserData } from './types';
+import { AppStep } from './types';
+import { IconFileUp, IconSend, IconBot, IconGear, IconSparkles, IconArrowRight, IconLayers, IconDatabase, IconWorkflow, IconGlobe } from './components/Icons';
+import ReactMarkdown from 'react-markdown';
+
+const App: React.FC = () => {
+  const [step, setStep] = useState<AppStep>(AppStep.NAME_INPUT);
+  const [previousStep, setPreviousStep] = useState<AppStep | null>(null);
+  const [userData, setUserData] = useState<UserData>({ name: '' });
+  const [progress, setProgress] = useState(0);
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [inputValue, setInputValue] = useState('');
+  const [isTyping, setIsTyping] = useState(false);
+  const [showPlusMenu, setShowPlusMenu] = useState(false);
+  const chatEndRef = useRef<HTMLDivElement>(null);
+
+  const scrollToBottom = () => {
+    chatEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+  };
+
+  useEffect(() => {
+    scrollToBottom();
+  }, [messages, isTyping]);
+
+  const handleNameSubmit = (e: React.FormEvent) => {
+    e.preventDefault();
+    if (userData.name.trim()) {
+      setStep(AppStep.PDF_UPLOAD);
+    }
+  };
+
+  const handleFileUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    if (file) {
+      setUserData({ ...userData, fileName: file.name });
+      setStep(AppStep.PROCESSING);
+      setProgress(10); 
+
+      const formData = new FormData();
+      formData.append('file', file);
+      formData.append('user_id', userData.name);
+
+      // Incremento simulato della barra per dare feedback visuale durante l'elaborazione pesante
+      const progressInterval = setInterval(() => {
+        setProgress(prev => (prev < 90 ? prev + 5 : prev));
+      }, 800);
+
+      try {
+        const response = await fetch('http://127.0.0.1:8000/upload', {
+          method: 'POST',
+          body: formData,
+        });
+
+        clearInterval(progressInterval);
+
+        if (response.ok) {
+          setProgress(100);
+          setTimeout(() => {
+            setStep(AppStep.CHAT);
+            setMessages([{ 
+              role: 'ai', 
+              content: 'PRESET_WELCOME', 
+              timestamp: new Date() 
+            }]);
+          }, 600);
+        } else {
+          throw new Error("Errore durante l'elaborazione del server");
+        }
+      } catch (error) {
+        clearInterval(progressInterval);
+        console.error("Errore durante l'ingestione:", error);
+        alert("Errore nel caricamento del file. Assicurati che il backend sia attivo e Neo4j sia raggiungibile.");
+        setStep(AppStep.PDF_UPLOAD);
+      }
+    }
+  };
+
+  const truncateFileName = (name: string, limit = 25) => {
+    if (name.length <= limit) return name;
+    return name.substring(0, limit) + '...';
+  };
+
+  const handleHomeClick = () => {
+    setStep(AppStep.NAME_INPUT);
+    setUserData({ name: '' });
+    setMessages([]);
+    setProgress(0);
+  };
+
+  const handleHowItWorksClick = () => {
+    setPreviousStep(step);
+    setStep(AppStep.HOW_IT_WORKS);
+  };
+
+  const returnFromHowItWorks = () => {
+    if (previousStep) {
+      setStep(previousStep);
+    } else {
+      setStep(AppStep.NAME_INPUT);
+    }
+  };
+
+  const handleSendMessage = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!inputValue.trim() || isTyping) return;
+
+    const userMsg: Message = {
+      role: 'user',
+      content: inputValue,
+      timestamp: new Date()
+    };
+
+    setMessages(prev => [...prev, userMsg]);
+    setInputValue('');
+    setIsTyping(true);
+
+    try {
+      const queryParams = new URLSearchParams({
+        query: inputValue,
+        filename: userData.fileName || "documento",
+        user_id: userData.name
+      });
+
+      const response = await fetch(`http://127.0.0.1:8000/chat?${queryParams}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      });
+
+      if (!response.ok) throw new Error('Errore nella risposta del server');
+
+      const data = await response.json();
+
+      setMessages(prev => [...prev, {
+        role: 'ai',
+        content: data.answer,
+        timestamp: new Date()
+      }]);
+    } catch (error) {
+      console.error("Errore chat:", error);
+      setMessages(prev => [...prev, {
+        role: 'ai',
+        content: "Scusa, si è verificato un errore nel collegamento con il server. Assicurati che il backend sia attivo.",
+        timestamp: new Date()
+      }]);
+    } finally {
+      setIsTyping(false);
+    }
+  };
+
+  const isInitialPage = step === AppStep.NAME_INPUT || step === AppStep.PDF_UPLOAD || step === AppStep.PROCESSING;
+
+  return (
+    <div className="min-h-screen w-screen flex flex-col font-outfit bg-white overflow-x-hidden">
+      
+      {/* Header */}
+      <header className={`glass-header fixed top-0 w-full z-50 py-3 md:py-4 px-4 md:px-12 flex justify-between items-center transition-opacity ${step === AppStep.CHAT || step === AppStep.HOW_IT_WORKS ? 'opacity-30 hover:opacity-100' : 'opacity-100'}`}>
+        <div 
+          onClick={handleHomeClick}
+          className="flex items-center gap-2 cursor-pointer group"
+        >
+          <div className="bg-[#FF6600] text-white p-1.5 md:p-2 rounded-lg group-hover:scale-105 transition-transform flex items-center justify-center">
+            <IconBot className="w-6 h-6 md:w-8 h-8" />
+          </div>
+          <span className="text-xl md:text-2xl font-extrabold tracking-tighter transition-colors group-hover:text-[#FF6600]">RAG Chatbot</span>
+        </div>
+        <div>
+          <button 
+            onClick={handleHowItWorksClick}
+            className="group bg-[#FF6600] text-white w-10 h-10 md:w-auto md:px-4 md:py-2 rounded-lg font-bold text-sm hover:bg-black transition-all active:scale-95 shadow-lg shadow-[#FF6600]/20 flex items-center justify-center"
+          >
+            <span className="md:hidden text-black font-black text-lg group-hover:text-white transition-colors">?</span>
+            <span className="hidden md:inline">Come funziona</span>
+          </button>
+        </div>
+      </header>
+
+      {/* Main Container */}
+      <main className={`flex-grow flex flex-col items-center ${(step === AppStep.CHAT || step === AppStep.HOW_IT_WORKS) ? 'h-screen pt-20' : 'pt-28 md:pt-32'}`}>
+        
+        <div className={`w-full ${(step === AppStep.CHAT || step === AppStep.HOW_IT_WORKS) ? 'h-full flex flex-col' : 'max-w-4xl'}`}>
+          
+          {/* INITIAL STEPS (NAME & UPLOAD) */}
+          {(step === AppStep.NAME_INPUT || step === AppStep.PDF_UPLOAD) && (
+            <div className="text-center mb-10 md:mb-12 animate-in fade-in slide-in-from-bottom-4 duration-700 px-6">
+              <h1 className="text-4xl md:text-6xl font-black mb-4 leading-tight">
+                Il Tuo Assistente PDF <br/> 
+                <span className="text-[#FF6600]">Intelligente</span>
+              </h1>
+              <h2 className="text-base md:text-xl text-gray-600 font-light max-w-2xl mx-auto mb-10">
+                Carica il tuo PDF e lascialo analizzare dal nostro sistema: Poni domande in chat in linguaggio naturale e ottieni risposte mirate basate esclusivamente sul contenuto del file.
+              </h2>
+
+              <div className="flex flex-row items-center justify-center gap-2 md:gap-8 mb-12">
+                <div className="flex flex-col items-center gap-3 w-20 md:w-32 group cursor-default">
+                  <div className={`w-12 h-12 md:w-16 md:h-16 rounded-full border-2 flex items-center justify-center transition-all bg-gray-50 border-gray-100 text-gray-400 group-hover:text-[#FF6600] group-hover:border-[#FF6600]/30 group-hover:bg-[#FF6600]/5`}>
+                    <IconFileUp className="w-5 h-5 md:w-7 md:h-7" />
+                  </div>
+                  <p className={`text-[8px] md:text-[10px] font-bold tracking-widest uppercase transition-colors text-gray-400 group-hover:text-[#FF6600]`}>1. Upload</p>
+                </div>
+                <div><IconArrowRight className="text-gray-200 w-3 h-3 md:w-5 md:h-5 animate-pulse" /></div>
+                <div className="flex flex-col items-center gap-3 w-20 md:w-32 group cursor-default">
+                  <div className="w-12 h-12 md:w-16 md:h-16 rounded-full bg-gray-50 border-2 border-gray-100 flex items-center justify-center text-gray-400 group-hover:text-[#FF6600] group-hover:border-[#FF6600]/30 group-hover:bg-[#FF6600]/5 transition-all">
+                    <div className="relative">
+                       <IconGear className="w-5 h-5 md:w-7 md:h-7 animate-gear-rotate" />
+                       <span className="absolute -top-1 -right-1 bg-[#FF6600] text-white text-[6px] md:text-[8px] font-bold px-1 rounded-sm">PDF</span>
+                    </div>
+                  </div>
+                  <p className="text-[8px] md:text-[10px] font-bold tracking-widest uppercase text-gray-400 group-hover:text-[#FF6600] transition-colors">2. Analisi</p>
+                </div>
+                <div><IconArrowRight className="text-gray-200 w-3 h-3 md:w-5 md:h-5 animate-pulse" /></div>
+                <div className="flex flex-col items-center gap-3 w-20 md:w-32 group cursor-default">
+                  <div className="w-12 h-12 md:w-16 md:h-16 rounded-full bg-gray-50 border-2 border-gray-100 flex items-center justify-center text-gray-400 shadow-sm group-hover:text-[#FF6600] group-hover:border-[#FF6600]/30 group-hover:bg-[#FF6600]/5 transition-all">
+                    <IconSparkles className="w-5 h-5 md:w-7 md:h-7" />
+                  </div>
+                  <p className="text-[8px] md:text-[10px] font-bold tracking-widest uppercase text-gray-400 group-hover:text-[#FF6600] transition-colors">3. Chat</p>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {step === AppStep.NAME_INPUT && (
+            <div className="flex justify-center py-2 animate-in fade-in slide-in-from-top-4 duration-500 px-6">
+              <div className="bg-white border border-black/5 p-8 md:p-10 rounded-[2.5rem] shadow-2xl max-w-md w-full orange-glow transition-all">
+                <form onSubmit={handleNameSubmit} className="flex flex-col gap-6 md:gap-8">
+                  <div>
+                    <label className="block text-xs font-bold uppercase tracking-[0.2em] text-gray-400 mb-4 ml-2">Inserisci il tuo nome o User ID</label>
+                    <input 
+                      type="text" 
+                      value={userData.name}
+                      onChange={(e) => setUserData({...userData, name: e.target.value})}
+                      placeholder="Es: Laura"
+                      className="w-full bg-gray-50 border-2 border-transparent focus:border-[#FF6600]/30 focus:bg-white outline-none px-6 md:px-8 py-4 md:py-5 rounded-[1.5rem] text-lg md:text-xl font-semibold text-black placeholder:text-gray-300 transition-all shadow-sm"
+                      autoFocus
+                    />
+                  </div>
+                  <button type="submit" disabled={!userData.name.trim()} className="bg-[#FF6600] text-white font-bold py-4 md:py-5 rounded-[1.5rem] hover:bg-black shadow-lg shadow-[#FF6600]/20 transition-all transform active:scale-95 disabled:opacity-30">Continua</button>
+                </form>
+              </div>
+            </div>
+          )}
+
+          {step === AppStep.PDF_UPLOAD && (
+            <div className="flex flex-col items-center py-2 animate-in fade-in slide-in-from-bottom-8 duration-700 px-6">
+              <div className="text-center mb-8">
+                <h3 className="text-2xl md:text-3xl font-black text-black mb-2 tracking-tighter uppercase font-outfit">Ciao <span className="text-[#FF6600]">{userData.name}</span></h3>
+                <p className="text-gray-400 font-medium">Siamo pronti ad analizzare il tuo file.</p>
+              </div>
+              <div className="bg-white border-2 border-dashed border-gray-200 p-8 md:p-12 rounded-[3rem] max-w-2xl w-full flex flex-col items-center justify-center gap-6 hover:border-[#FF6600] group transition-all cursor-pointer relative shadow-sm">
+                <input type="file" accept="application/pdf" onChange={handleFileUpload} className="absolute inset-0 opacity-0 cursor-pointer" />
+                <div className="bg-gray-50 p-4 md:p-6 rounded-full group-hover:bg-[#FF6600]/10 transition-colors">
+                  <IconFileUp className="w-10 h-10 md:w-12 md:h-12 text-gray-300 group-hover:text-[#FF6600]" />
+                </div>
+                <div className="text-center">
+                  <p className="text-lg md:text-xl font-bold mb-1">Carica il documento ed inizia a chattare</p>
+                  <p className="text-gray-400 text-sm font-medium">Trascina qui il file o clicca per sfogliare</p>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {step === AppStep.PROCESSING && (
+            <div className="flex-grow flex flex-col items-center justify-center py-16 gap-8 animate-in fade-in px-6">
+              <div className="relative w-20 h-20 md:w-24 md:h-24">
+                <div className="absolute inset-0 border-4 border-gray-50 rounded-full"></div>
+                <div className="absolute inset-0 border-4 border-t-[#FF6600] rounded-full animate-spin"></div>
+              </div>
+              <div className="text-center max-md:max-w-xs max-w-md">
+                <h3 className="text-xl md:text-2xl font-extrabold mb-2">Stiamo processando il tuo documento...</h3>
+                <p className="text-gray-500 mb-8 font-light">Quasi pronto...</p>
+                <div className="w-full bg-gray-50 h-2 rounded-full overflow-hidden">
+                  <div className="bg-[#FF6600] h-full transition-all duration-300" style={{ width: `${progress}%` }}></div>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* CHAT STEP */}
+          {step === AppStep.CHAT && (
+            <div className="flex-grow flex flex-col w-full max-w-3xl mx-auto h-full overflow-hidden">
+              <div className="flex-grow overflow-y-auto px-6 py-10 space-y-12 chat-scroll">
+                {messages.map((msg, idx) => {
+                  if (msg.content === 'PRESET_WELCOME') {
+                    return (
+                      <div key={idx} className="animate-in slide-in-from-bottom-4 duration-700">
+                        <div className="flex items-start gap-5">
+                           <div className="w-12 h-12 rounded-2xl bg-[#FF6600] flex items-center justify-center shadow-lg shadow-[#FF6600]/20 flex-shrink-0">
+                             <div className="relative flex items-center justify-center w-full h-full">
+                               <IconBot className="w-9 h-9" />
+                               <div className="absolute -top-1 -right-1 bg-white text-black text-[7px] font-black px-1 rounded-sm border border-black/5 uppercase">PDF</div>
+                             </div>
+                           </div>
+                           <div className="flex flex-col gap-1 pt-1">
+                            <h2 className="text-xl font-normal text-gray-500 font-verdana leading-tight">
+                              <span className="text-[#FF6600] font-medium">{userData.name}</span>, il file{" "}
+                              <span className="text-black font-medium hover:text-[#FF6600] cursor-pointer transition-colors" title={userData.fileName}>
+                                "{truncateFileName(userData.fileName || '', 40)}" 
+                              </span>{" "}
+                              è pronto.
+                            </h2>
+                            <p className="text-sm font-light text-gray-400">
+                              Chiedimi qualunque cosa!
+                            </p>
+                          </div>
+                        </div>
+                      </div>
+                    );
+                  }
+
+                  const isUser = msg.role === 'user';
+                  return (
+                    <div 
+                      key={idx} 
+                      className={`flex ${isUser ? 'justify-end' : 'justify-start'} animate-in fade-in duration-300`}
+                    >
+                      <div className={`flex gap-4 max-w-[85%] ${isUser ? 'flex-row-reverse' : 'flex-row'}`}>
+                        {!isUser && (
+                          <div className="w-10 h-10 rounded-lg bg-gray-50 flex items-center justify-center flex-shrink-0 mt-1">
+                            <IconBot className="w-7 h-7" />
+                          </div>
+                        )}
+                        <div className={`p-4 ${
+                          isUser 
+                          ? 'bg-gray-100 text-gray-800 rounded-2xl rounded-tr-none' 
+                          : 'text-gray-700 leading-relaxed text-[15px] markdown-container'
+                        }`}>
+                          {/* Rendering Markdown per interpretare il grassetto e altre formattazioni */}
+                          <div className="font-verdana">
+                            <ReactMarkdown>
+                              {msg.content}
+                            </ReactMarkdown>
+                          </div>
+                          <p className="text-[9px] mt-2 opacity-30 font-bold tracking-tighter">
+                            {msg.timestamp.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}
+                          </p>
+                        </div>
+                      </div>
+                    </div>
+                  );
+                })}
+                {isTyping && (
+                  <div className="flex justify-start animate-in fade-in">
+                    <div className="flex gap-4">
+                      <div className="w-10 h-10 rounded-lg bg-gray-50 flex items-center justify-center">
+                        <IconBot className="w-7 h-7 opacity-30 animate-pulse" />
+                      </div>
+                      <div className="flex gap-1.5 items-center py-2">
+                        <span className="w-1.5 h-1.5 bg-gray-200 rounded-full animate-bounce"></span>
+                        <span className="w-1.5 h-1.5 bg-gray-200 rounded-full animate-bounce delay-150"></span>
+                        <span className="w-1.5 h-1.5 bg-gray-200 rounded-full animate-bounce delay-300"></span>
+                      </div>
+                    </div>
+                  </div>
+                )}
+                <div ref={chatEndRef} />
+              </div>
+
+              <div className="px-6 pb-10 pt-4 bg-white">
+                <form onSubmit={handleSendMessage} className="relative max-w-2xl mx-auto">
+                  <div className="relative flex items-center bg-gray-50 border border-gray-100 rounded-[2.5rem] p-2 focus-within:bg-white focus-within:ring-2 focus-within:ring-[#FF6600]/10 transition-all shadow-sm">
+                    <div className="relative flex-shrink-0">
+                      <button 
+                        type="button" 
+                        onClick={() => setShowPlusMenu(!showPlusMenu)}
+                        className={`w-12 h-12 flex items-center justify-center rounded-full transition-all ${showPlusMenu ? 'bg-black text-white' : 'bg-[#FF6600] text-white hover:bg-black'}`}
+                      >
+                        <span className={`text-2xl transition-transform font-light ${showPlusMenu ? 'rotate-45' : ''}`}>+</span>
+                      </button>
+                      {showPlusMenu && (
+                        <div className="absolute bottom-full left-0 mb-4 bg-white border border-gray-100 rounded-2xl shadow-xl p-2 min-w-[150px] animate-in fade-in slide-in-from-bottom-2">
+                          <button 
+                            onClick={() => {
+                              setStep(AppStep.PDF_UPLOAD);
+                              setShowPlusMenu(false);
+                            }}
+                            className="w-full text-left px-4 py-3 text-sm font-semibold hover:bg-gray-50 rounded-xl transition-colors flex items-center gap-3 text-gray-700"
+                          >
+                            <IconFileUp className="w-4 h-4 text-[#FF6600]" />
+                            Cambia PDF
+                          </button>
+                        </div>
+                      )}
+                    </div>
+                    <input 
+                      type="text" 
+                      value={inputValue}
+                      onChange={(e) => setInputValue(e.target.value)}
+                      placeholder="Scrivi un messaggio..."
+                      className="flex-grow bg-transparent border-none outline-none px-4 md:px-6 py-4 text-[14px] md:text-[15px] text-gray-800 placeholder:text-gray-300 font-verdana"
+                    />
+                    <button 
+                      type="submit"
+                      disabled={!inputValue.trim() || isTyping}
+                      className="text-[#FF6600] w-10 h-10 md:w-12 md:h-12 flex items-center justify-center flex-shrink-0 rounded-full hover:bg-[#FF6600]/10 disabled:opacity-10 transition-all"
+                    >
+                      <IconSend className="w-5 h-5 md:w-6 md:h-6" />
+                    </button>
+                  </div>
+                  <p className="text-[6px] text-center text-gray-300 mt-4 tracking-[0.2em] uppercase font-bold px-4">
+                    Qualsiasi sistema, per quanto sofisticato sia, può commettere errori e non può sostituirsi ad un attenta lettura del documento
+                  </p>
+                </form>
+              </div>
+            </div>
+          )}
+
+          {/* HOW IT WORKS STEP */}
+          {step === AppStep.HOW_IT_WORKS && (
+            <div className="flex-grow overflow-y-auto px-6 py-10 chat-scroll animate-in fade-in duration-700">
+              <div className="max-w-4xl mx-auto space-y-12 pb-20">
+                <div className="text-center mb-16">
+                  <h1 className="text-4xl md:text-5xl font-black mb-4 font-outfit">Architettura <span className="text-[#FF6600]">GraphRAG</span></h1>
+                  <p className="text-gray-500 font-light text-lg">Un sistema di recupero deterministico potenziato da orchestratori LLM.</p>
+                </div>
+
+                <div className="grid md:grid-cols-2 gap-8">
+                  <div className="bg-white border border-gray-100 p-8 rounded-3xl shadow-sm hover:orange-glow transition-all">
+                    <div className="bg-[#FF6600] text-white w-12 h-12 rounded-xl flex items-center justify-center mb-6">
+                      <IconFileUp className="w-6 h-6" />
+                    </div>
+                    <h3 className="text-xl font-bold mb-3">Ingestion & Struttura</h3>
+                    <p className="text-gray-600 font-light text-sm leading-relaxed">
+                      Il PDF non viene solo "letto", ma processato per estrarre la <strong>gerarchia logica</strong>. Utilizziamo librerie specializzate per ricostruire tabelle, titoli e sezioni, garantendo che l'informazione non perda mai il suo contesto originale durante la scomposizione.
+                    </p>
+                  </div>
+
+                  <div className="bg-white border border-gray-100 p-8 rounded-3xl shadow-sm hover:orange-glow transition-all">
+                    <div className="bg-black text-white w-12 h-12 rounded-xl flex items-center justify-center mb-6">
+                      <IconLayers className="w-6 h-6" />
+                    </div>
+                    <h3 className="text-xl font-bold mb-3">Chunking</h3>
+                    <p className="text-gray-600 font-light text-sm leading-relaxed">
+                      Applichiamo una strategia di <strong>chunking ricorsivo</strong>. Il testo viene diviso in frammenti ottimizzati per gli embedding, mantenendo sovrapposizioni intelligenti tra i paragrafi per non interrompere la coerenza semantica tra i nodi del database.
+                    </p>
+                  </div>
+
+                  <div className="bg-white border border-gray-100 p-8 rounded-3xl shadow-sm hover:orange-glow transition-all">
+                    <div className="bg-black text-white w-12 h-12 rounded-xl flex items-center justify-center mb-6">
+                      <IconDatabase className="w-6 h-6" />
+                    </div>
+                    <h3 className="text-xl font-bold mb-3">Knowledge Graph (Neo4j)</h3>
+                    <p className="text-gray-600 font-light text-sm leading-relaxed">
+                      I chunk e le entità vengono mappati in <strong>Neo4j</strong>. Ogni frammento diventa un nodo collegato non solo vettorialmente, ma anche per relazione logica (es. "appartiene alla sezione X"). Questo permette una navigazione dei dati multimodale: semantica e a grafo.
+                    </p>
+                  </div>
+
+                  <div className="bg-white border border-gray-100 p-8 rounded-3xl shadow-sm hover:orange-glow transition-all">
+                    <div className="bg-black text-white w-12 h-12 rounded-xl flex items-center justify-center mb-6">
+                      <IconWorkflow className="w-6 h-6" />
+                    </div>
+                    <h3 className="text-xl font-bold mb-3">LangGraph</h3>
+                    <p className="text-gray-500 font-light text-sm leading-relaxed">
+                      L'intero flusso è gestito da <strong>LangGraph</strong>. Un sistema a stati finiti che coordina i nodi di analisi, recupero e validazione. Questo garantisce che ogni query segua un percorso logico rigoroso prima di produrre un output.
+                    </p>
+                  </div>
+                </div>
+
+                <div className="bg-gray-50 border border-gray-100 p-10 rounded-[3rem] shadow-inner">
+                  <div className="text-center mb-10">
+                    <h3 className="text-2xl font-black mb-2 font-outfit">Recupero <span className="text-[#FF6600]">Ibrido & Intelligente</span></h3>
+                    <p className="text-gray-500 text-sm font-light max-w-2xl mx-auto">
+                      l'LLM agisce esclusivamente come Orchestratore Decisionale: analizza l'intento della domanda per determinare la rotta di recupero ottimale.                      </p>
+                  </div>
+
+                  <div className="grid md:grid-cols-2 gap-8">
+                    <div className="space-y-6">
+                      <div className="bg-white p-6 rounded-2xl shadow-sm border border-black/5">
+                        <div className="flex items-center gap-3 mb-3">
+                          <div className="bg-[#FF6600]/10 px-2 py-1 rounded md font-bold text-[#FF6600] text-[10px] uppercase">Routing</div>
+                          <h4 className="font-bold text-sm">Mistral come Router Strategico</h4>
+                        </div>
+                        <p className="text-xs text-gray-600 leading-relaxed font-light">
+                          Utilizziamo <strong>Mistral</strong> per decidere la via di recupero. Se la domanda contiene entità specifiche già mappate nel DB, Mistral formula una <strong>Query Cypher</strong> basata sulle NE estratte.
+                        </p>
+                      </div>
+                      
+                      <div className="bg-white p-6 rounded-2xl shadow-sm border border-black/5">
+                        <div className="flex items-center gap-3 mb-3">
+                          <div className="bg-black/5 px-2 py-1 rounded md font-bold text-gray-500 text-[10px] uppercase">Vector</div>
+                          <h4 className="font-bold text-sm">Ricerca Vettoriale</h4>
+                        </div>
+                        <p className="text-xs text-gray-600 leading-relaxed font-light">
+                          Il sistema attiva una ricerca vettoriale quando il router identifica quesiti di natura concettuale o descrittiva.
+                        </p>
+                      </div>
+                    </div>
+
+                    <div className="space-y-6">
+                      <div className="bg-white p-6 rounded-2xl shadow-sm border border-black/5">
+                        <div className="flex items-center gap-3 mb-3">
+                          <div className="bg-[#FF6600]/10 px-2 py-1 rounded md font-bold text-[#FF6600] text-[10px] uppercase">Entities</div>
+                          <h4 className="font-bold text-sm">Named Entity Extraction (GLiNER)</h4>
+                        </div>
+                        <p className="text-xs text-gray-600 leading-relaxed font-light">
+                          Sfruttiamo GLiNER per identificare entità chiave (nomi, luoghi, termini tecnici) sia nel documento che nella domanda utente.
+                        </p>
+                      </div>
+
+                      <div className="bg-white p-6 rounded-2xl shadow-sm border border-black/5">
+                        <div className="flex items-center gap-3 mb-3">
+                          <div className="bg-black/5 px-2 py-1 rounded md font-bold text-gray-500 text-[10px] uppercase">Rerank</div>
+                          <h4 className="font-bold text-sm">Reranking-v2-m3</h4>
+                        </div>
+                        <p className="text-xs text-gray-600 leading-relaxed font-light">
+                          I risultati grezzi del database vengono filtrati da un <strong>Cross-Encoder</strong>, nello specifico il modello BGE-Reranker-v2-m3.
+                        </p>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+
+                <div className="bg-white border border-gray-100 p-8 rounded-[3rem] shadow-sm hover:orange-glow transition-all max-w-2xl mx-auto">
+                  <div className="flex flex-col items-center text-center">
+                    <div className="bg-[#FF6600] text-white w-14 h-14 rounded-2xl flex items-center justify-center mb-6 shadow-lg shadow-[#FF6600]/20">
+                      <IconGlobe className="w-8 h-8" />
+                    </div>
+                    <h3 className="text-2xl font-black mb-3 font-outfit">Ricerca Globale</h3>
+                    <p className="text-gray-600 font-light text-sm leading-relaxed">
+                      Se la ricerca vettoriale sul documento attivo produce uno score di pertinenza basso, il sistema attiva automaticamente una <strong>Ricerca globale</strong>.
+                    </p>
+                  </div>
+                </div>
+
+                <div className="flex flex-col items-center text-center max-w-2xl mx-auto space-y-6">
+                  <div className="bg-[#FF6600] text-white w-16 h-16 rounded-2xl flex items-center justify-center shadow-lg shadow-[#FF6600]/20">
+                    <IconBot className="w-10 h-10" />
+                  </div>
+                  <h3 className="text-2xl font-black font-outfit">Sintesi</h3>
+                  <p className="text-gray-600 font-light leading-relaxed">
+                    L'LLM finale non genera testo libero ma agisce esclusivamente da sintetizzatore: riceve i dati filtrati e produce una risposta ancorata a una fonte certa.
+                  </p>
+                </div>
+
+                <div className="flex justify-center pt-10">
+                  <button 
+                    onClick={returnFromHowItWorks}
+                    className="bg-black text-white px-12 py-5 rounded-2xl font-bold hover:bg-[#FF6600] transition-all shadow-xl active:scale-95"
+                  >
+                    Torna alla Chat
+                  </button>
+                </div>
+              </div>
+            </div>
+          )}
+        </div>
+      </main>
+
+      {/* Developer Footer */}
+      {isInitialPage && (
+        <div className="w-full mt-20 py-12 px-6 border-t border-gray-100 flex flex-col items-center gap-6 animate-in fade-in slide-in-from-bottom-4 duration-1000 bg-white">
+          <div className="flex items-center gap-8">
+            <a href="https://github.com/ValerioBotto" target="_blank" rel="noopener noreferrer" className="group flex flex-col items-center gap-2">
+              <div className="p-3 bg-gray-50 rounded-xl group-hover:bg-black group-hover:text-white transition-all">
+                <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"><path d="M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4"></path><path d="M9 18c-4.51 2-5-2-7-2"></path></svg>
+              </div>
+              <span className="text-[10px] font-bold uppercase tracking-widest text-gray-400 group-hover:text-black">GitHub</span>
+            </a>
+            <a href="https://www.linkedin.com/in/valerio-botto-4844b2190/" target="_blank" rel="noopener noreferrer" className="group flex flex-col items-center gap-2">
+              <div className="p-3 bg-gray-50 rounded-xl group-hover:bg-[#0077b5] group-hover:text-white transition-all">
+                <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"><path d="M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z"></path><rect width="4" height="12" x="2" y="9"></rect><circle cx="4" cy="4" r="2"></circle></svg>
+              </div>
+              <span className="text-[10px] font-bold uppercase tracking-widest text-gray-400 group-hover:text-[#0077b5]">LinkedIn</span>
+            </a>
+          </div>
+          <div className="text-center">
+            <p className="text-[10px] text-gray-300 font-black tracking-[0.4em] uppercase">
+              Developed by <span className="text-black">Valerio Botto</span>
+            </p>
+          </div>
+        </div>
+      )}
+
+      {(step !== AppStep.CHAT && step !== AppStep.HOW_IT_WORKS && !isInitialPage) && (
+        <footer className="py-10 text-center border-t border-gray-50 bg-white">
+          <p className="text-[10px] text-gray-300 font-black tracking-[0.4em] uppercase">
+            &copy; 2024 RAG CHATBOT
+          </p>
+        </footer>
+      )}
+    </div>
+  );
+};
+
+export default App;

frontend/src/components/Icons.tsx

@@ -0,0 +1,72 @@
+import React from 'react';
+
+export const IconUser = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><path d="M19 21v-2a4 4 0 0 0-4-4H9a4 4 0 0 0-4 4v2"></path><circle cx="12" cy="7" r="4"></circle></svg>
+);
+
+export const IconFileUp = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline><line x1="12" y1="18" x2="12" y2="12"></line><polyline points="9 15 12 12 15 15"></polyline></svg>
+);
+
+export const IconSend = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><line x1="22" y1="2" x2="11" y2="13"></line><polygon points="22 2 15 22 11 13 2 9 22 2"></polygon></svg>
+);
+
+export const IconBot = ({ className }: { className?: string }) => (
+  <svg viewBox="0 0 100 100" className={className} xmlns="http://www.w3.org/2000/svg" fill="none">
+    {/* Antenna - positioned slightly more to the edge and shorter to allow larger head */}
+    <path d="M78 30 L78 18" stroke="black" strokeWidth="4.5" strokeLinecap="round"/>
+    <circle cx="78" cy="14" r="5.5" fill="black"/>
+    
+    {/* Ears - larger and hugging the head more closely */}
+    <rect x="10" y="42" width="12" height="28" rx="6" fill="white" stroke="black" strokeWidth="4.5"/>
+    <rect x="78" y="42" width="12" height="28" rx="6" fill="white" stroke="black" strokeWidth="4.5"/>
+    
+    {/* Head - expanded size to be more prominent */}
+    <rect x="18" y="26" width="64" height="58" rx="16" fill="white" stroke="black" strokeWidth="4.5"/>
+    
+    {/* Eyes - slightly larger ovals */}
+    <ellipse cx="36" cy="52" rx="4.5" ry="8" fill="black"/>
+    <ellipse cx="64" cy="52" rx="4.5" ry="8" fill="black"/>
+    
+    {/* Blush - vibrant orange circles */}
+    <circle cx="30" cy="62" r="6" fill="#FF8C42"/>
+    <circle cx="70" cy="62" r="6" fill="#FF8C42"/>
+    
+    {/* Smile - cute curve */}
+    <path d="M44 62 Q50 69 56 62" stroke="black" strokeWidth="3.5" strokeLinecap="round" fill="none"/>
+  </svg>
+);
+
+export const IconGear = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z"></path><circle cx="12" cy="12" r="3"></circle></svg>
+);
+
+export const IconSparkles = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><path d="m12 3-1.912 5.813a2 2 0 0 1-1.275 1.275L3 12l5.813 1.912a2 2 0 0 1 1.275 1.275L12 21l1.912-5.813a2 2 0 0 1 1.275-1.275L21 12l-5.813-1.912a2 2 0 0 1-1.275-1.275L12 3Z"></path><path d="M5 3v4"></path><path d="M19 17v4"></path><path d="M3 5h4"></path><path d="M17 19h4"></path></svg>
+);
+
+export const IconArrowRight = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><path d="M5 12h14"></path><path d="m12 5 7 7-7 7"></path></svg>
+);
+
+export const IconLayers = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><path d="m12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.91a1 1 0 0 0 0-1.83Z"></path><path d="m2.6 12.08 8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.91"></path><path d="m2.6 17.08 8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.91"></path></svg>
+);
+
+export const IconDatabase = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><ellipse cx="12" cy="5" rx="9" ry="3"></ellipse><path d="M3 5V19A9 3 0 0 0 21 19V5"></path><path d="M3 12A9 3 0 0 0 21 12"></path></svg>
+);
+
+export const IconWorkflow = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
+    <circle cx="7" cy="7" r="3" />
+    <circle cx="17" cy="17" r="3" />
+    <path d="M10 7h4a3 3 0 0 1 3 3v4" />
+    <path d="M14 17h-4a3 3 0 0 1-3-3v-4" />
+  </svg>
+);
+
+export const IconGlobe = ({ className }: { className?: string }) => (
+  <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}><circle cx="12" cy="12" r="10"></circle><line x1="2" y1="12" x2="22" y2="12"></line><path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"></path></svg>
+);

frontend/src/index.css

@@ -0,0 +1,48 @@
+@import "tailwindcss";
+
+@layer base {
+  body {
+    min-height: 100vh;
+    width: 100vw;
+    background-color: white;
+    color: black;
+    font-family: 'Inter', sans-serif;
+  }
+}
+
+.font-outfit { font-family: 'Outfit', sans-serif; }
+.font-verdana { font-family: 'Verdana', sans-serif; }
+
+.glass-header {
+  background: rgba(255, 255, 255, 0.8);
+  backdrop-filter: blur(10px);
+  border-bottom: 1px solid rgba(0, 0, 0, 0.05);
+}
+
+.orange-glow { box-shadow: 0 0 20px rgba(255, 102, 0, 0.2); }
+.orange-glow:hover { box-shadow: 0 0 30px rgba(255, 102, 0, 0.4); }
+
+@keyframes rotate-gear {
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+}
+.animate-gear-rotate { animation: rotate-gear 8s linear infinite; }
+
+.chat-scroll::-webkit-scrollbar { width: 4px; }
+.chat-scroll::-webkit-scrollbar-thumb {
+  background: rgba(0, 0, 0, 0.05);
+  border-radius: 10px;
+}
+
+.markdown-container strong {
+  font-weight: bold;
+  color: #FF6600;
+}
+
+.markdown-container p {
+  margin-bottom: 0.5rem;
+}
+
+.markdown-container p:last-child {
+  margin-bottom: 0;
+}

frontend/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/src/types.ts

@@ -0,0 +1,21 @@
+
+export type AppStep = 'NAME_INPUT' | 'PDF_UPLOAD' | 'PROCESSING' | 'CHAT' | 'HOW_IT_WORKS';
+
+export const AppStep = {
+  NAME_INPUT: 'NAME_INPUT',
+  PDF_UPLOAD: 'PDF_UPLOAD',
+  PROCESSING: 'PROCESSING',
+  CHAT: 'CHAT',
+  HOW_IT_WORKS: 'HOW_IT_WORKS'
+} as const;
+
+export interface Message {
+  role: 'user' | 'ai';
+  content: string;
+  timestamp: Date;
+}
+
+export interface UserData {
+  name: string;
+  fileName?: string;
+}

frontend/tailwind.config.js

@@ -0,0 +1,12 @@
+// filepath: c:\Users\valer\Desktop\File\RAG\frontend\tailwind.config.js
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./src/**/*.{js,ts,jsx,tsx}",
+    "./public/index.html",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}

frontend/tsconfig.app.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

frontend/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

frontend/tsconfig.node.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

frontend/vite.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})

main.py

@@ -0,0 +1,116 @@
+import streamlit as st
+import os
+import logging
+from processingPdf.loader import get_layout_extractor
+from processingPdf.logicSections import extract_logical_sections
+from processingPdf.chunker import split_sections_into_chunks
+from processingPdf.indexer import Indexer
+from db.graph_db import GraphDB
+from dotenv import load_dotenv
+
+# Importazione del workflow LangGraph
+from agentLogic.graph import app as rag_app
+
+# Configurazione Logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+st.set_page_config(page_title="RAG Chatbot - PDF", layout="wide")
+
+# Inizializzazione componenti nel session_state
+if "indexer" not in st.session_state:
+    st.session_state.indexer = Indexer()
+if "layout_extractor" not in st.session_state:
+    st.session_state.layout_extractor = get_layout_extractor()
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+if "pdf_ready" not in st.session_state:
+    st.session_state.pdf_ready = False
+
+st.title("RAG Chatbot")
+st.markdown("Carica un PDF per indicizzarlo su Neo4j e iniziare a chattare.")
+
+# --- SIDEBAR: CARICAMENTO E INDICIZZAZIONE ---
+with st.sidebar:
+    st.header("Profilo Utente")
+    
+    user_name_input = st.text_input("Ciao! Inserisci il tuo nome/nickname", placeholder="es. Laura")
+    user_id_clean = user_name_input.strip().lower().replace(" ", "_")
+    
+    if not user_id_clean:
+        st.warning("Inserisci un nome utente per procedere.")
+    else:
+        st.success(f"Loggato come: {user_id_clean}")
+    
+    st.divider()
+    st.header("Caricamento PDF")
+    uploaded_file = st.file_uploader("Scegli un file PDF", type="pdf")
+    
+    if uploaded_file is not None and user_id_clean:
+        if st.button("Indicizza Documento"):
+            with st.spinner("Elaborazione in corso..."):
+                try:
+                    file_bytes = uploaded_file.getvalue()
+                    filename = uploaded_file.name
+                    
+                    doc = st.session_state.layout_extractor(file_bytes)
+                    sections = extract_logical_sections(doc)
+                    chunks = split_sections_into_chunks(sections, filename)
+                    
+                    st.session_state.indexer.index_chunks_to_neo4j(filename, chunks, user_id_clean)
+                    
+                    st.success(f"Ottimo {user_id_clean}! {len(chunks)} chunk indicizzati con successo.")
+                    st.session_state.pdf_ready = True
+                    st.session_state.current_user = user_id_clean
+                except Exception as e:
+                    st.error(f"Errore durante l'indicizzazione: {e}")
+                    logger.error(f"Errore: {e}", exc_info=True)
+
+# --- AREA CHAT ---
+st.divider()
+
+# Visualizzazione cronologia
+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 sul documento..."):
+    st.session_state.chat_history.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    with st.chat_message("assistant"):
+        response_placeholder = st.empty()
+        
+        if not st.session_state.pdf_ready:
+            full_response = "Per favore, carica e indicizza un PDF prima di iniziare la chat."
+            response_placeholder.markdown(full_response)
+        else:
+            with st.spinner("Ricerca e generazione risposta in corso..."):
+                try:
+                    # Preparazione dello stato iniziale per il grafo
+                    initial_state = {
+                        "query": prompt,
+                        "user_id": st.session_state.current_user,
+                        "filename": uploaded_file.name,
+                        "intent_data": {},
+                        "context_chunks": [],
+                        "final_answer": ""
+                    }
+                    
+                    # Esecuzione del workflow LangGraph
+                    # Usiamo invoke per ottenere il risultato finale dopo che tutti i nodi sono stati processati
+                    result = rag_app.invoke(initial_state)
+                    
+                    full_response = result.get("final_answer", "Non sono riuscito a generare una risposta.")
+                    response_placeholder.markdown(full_response)
+                    
+                except Exception as e:
+                    full_response = f"Errore durante l'elaborazione della domanda: {e}"
+                    response_placeholder.error(full_response)
+                    logger.error(f"Errore Chat: {e}", exc_info=True)
+        
+        st.session_state.chat_history.append({"role": "assistant", "content": full_response})

package-lock.json

@@ -0,0 +1,1242 @@
+{
+  "name": "RAG",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "react-markdown": "^10.1.0"
+      }
+    },
+    "node_modules/@types/debug": {
+      "version": "4.1.12",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
+      "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "license": "MIT"
+    },
+    "node_modules/@types/estree-jsx": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
+      "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "*"
+      }
+    },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.8",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.8.tgz",
+      "integrity": "sha512-3MbSL37jEchWZz2p2mjntRZtPt837ij10ApxKfgmXCTuHWagYg7iA5bqPw6C8BMPfwidlvfPI/fxOc42HLhcyg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+      "license": "MIT"
+    },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz",
+      "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==",
+      "license": "ISC"
+    },
+    "node_modules/bail": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
+      "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz",
+      "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-reference-invalid": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz",
+      "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decode-named-character-reference": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.2.0.tgz",
+      "integrity": "sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/estree-util-is-identifier-name": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz",
+      "integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "license": "MIT"
+    },
+    "node_modules/hast-util-to-jsx-runtime": {
+      "version": "2.3.6",
+      "resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
+      "integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "style-to-js": "^1.0.0",
+        "unist-util-position": "^5.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/html-url-attributes": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.1.tgz",
+      "integrity": "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/inline-style-parser": {
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
+      "integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
+      "license": "MIT"
+    },
+    "node_modules/is-alphabetical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
+      "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-alphanumerical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz",
+      "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==",
+      "license": "MIT",
+      "dependencies": {
+        "is-alphabetical": "^2.0.0",
+        "is-decimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-decimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz",
+      "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-hexadecimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
+      "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/longest-streak": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
+      "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/mdast-util-from-markdown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.2.tgz",
+      "integrity": "sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark": "^4.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdx-expression": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
+      "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdx-jsx": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+      "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdxjs-esm": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz",
+      "integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-phrasing": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
+      "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-markdown": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
+      "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-phrasing": "^4.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "unist-util-visit": "^5.0.0",
+        "zwitch": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
+      "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz",
+      "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-core-commonmark": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz",
+      "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-destination": "^2.0.0",
+        "micromark-factory-label": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-factory-title": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-html-tag-name": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-destination": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
+      "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-label": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
+      "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-space": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
+      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-title": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
+      "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-whitespace": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
+      "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-chunked": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
+      "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-classify-character": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
+      "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-combine-extensions": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
+      "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-numeric-character-reference": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
+      "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-string": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
+      "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-html-tag-name": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
+      "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-normalize-identifier": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
+      "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-resolve-all": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
+      "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-subtokenize": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz",
+      "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/parse-entities": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz",
+      "integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "character-entities-legacy": "^3.0.0",
+        "character-reference-invalid": "^2.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "is-alphanumerical": "^2.0.0",
+        "is-decimal": "^2.0.0",
+        "is-hexadecimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/parse-entities/node_modules/@types/unist": {
+      "version": "2.0.11",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+      "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+      "license": "MIT"
+    },
+    "node_modules/property-information": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz",
+      "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
+      "integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-markdown": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/react-markdown/-/react-markdown-10.1.0.tgz",
+      "integrity": "sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "hast-util-to-jsx-runtime": "^2.0.0",
+        "html-url-attributes": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.0.0",
+        "unified": "^11.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "@types/react": ">=18",
+        "react": ">=18"
+      }
+    },
+    "node_modules/remark-parse": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
+      "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-rehype": {
+      "version": "11.1.2",
+      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.2.tgz",
+      "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "unified": "^11.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/space-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/stringify-entities": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^3.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/style-to-js": {
+      "version": "1.1.21",
+      "resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.21.tgz",
+      "integrity": "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "style-to-object": "1.0.14"
+      }
+    },
+    "node_modules/style-to-object": {
+      "version": "1.0.14",
+      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.14.tgz",
+      "integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==",
+      "license": "MIT",
+      "dependencies": {
+        "inline-style-parser": "0.2.7"
+      }
+    },
+    "node_modules/trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/trough": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
+      "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/unified": {
+      "version": "11.0.5",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
+      "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "bail": "^2.0.0",
+        "devlop": "^1.0.0",
+        "extend": "^3.0.0",
+        "is-plain-obj": "^4.0.0",
+        "trough": "^2.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz",
+      "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "react-markdown": "^10.1.0"
+  }
+}

processingPdf/chunker.py

@@ -0,0 +1,73 @@
+# Questa parte si occupa di segmentare il testo delle sezioni in blocchi più piccoli (chunks)
+# adatti alla ricerca vettoriale, utilizzando RecursiveCharacterTextSplitter (RCTS) di LangChain.
+
+import logging
+from typing import List, Dict
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+
+logger = logging.getLogger(__name__)
+
+class Chunker:
+    def __init__(self, chunk_size: int = 600, chunk_overlap: int = 100):
+        # Inizializzazione splitter
+        # Usa il RCTS per suddividere il testo usando una lista di separatori (newline, doppia newline, spazi, etc)
+        # preservando la coerenza testuale e semantica
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=self.chunk_size,
+            chunk_overlap=self.chunk_overlap,
+            separators=["\n\n", "\n", ". ", "! ", "? ", " ", ""],
+            length_function=len,
+        )
+
+    # Questa funzione divide le sezioni logiche del documento in chunk di dimensione fissa con sovrapposizione
+    # Tra gli args abbiamo:
+    # sections: Dizionario con titoli di sezione e relativi testi
+    # filename: Nome del file PDF originale (usato per i metadati)
+    # Restituisce una lista di oggetti Document di LangChain, ciascuno contenente un chunk e i suoi metadati
+    def create_chunks(self, sections: Dict[str, str], filename: str) -> List[Document]:
+        
+        # Gestione input
+        if not sections:
+            logger.warning("Nessuna sezione fornita per il chunking")
+            return []
+        
+        all_chunks: List[Document] = []
+
+        # Iterazione e Chunking
+        for section_title, section_text in sections.items():
+            if not section_text.strip():
+                logger.debug(f"Salto sezione vuota: '{section_title}'")
+                continue
+            
+            try:
+                # Normalizzo il testo in lowercase
+                section_text = section_text.lower()
+                
+                # 1. Divide il testo della sezione (lo splitter accetta una lista di testi)
+                chunks_for_section = self.text_splitter.create_documents([section_text])
+                
+                # 2. Aggiunge metadati a ciascun chunk
+                for i, chunk in enumerate(chunks_for_section):
+                    # Metadato 'source' per il nome del documento
+                    chunk.metadata["source"] = filename
+                    
+                    # Metadato 'section' per il titolo logico (per il RAG)
+                    chunk.metadata["section"] = section_title
+                    
+                    # ID univoco per il chunk (combinazione di filename, sezione e indice)
+                    # Normalizziamo il titolo della sezione per un ID più pulito e sicuro
+                    clean_section_id = section_title.lower().replace(' ', '_').replace('/', '_').replace(':', '_')
+                    chunk.metadata["chunk_id"] = f"{filename}_{clean_section_id}_{i}"
+                    
+                    all_chunks.append(chunk)
+                
+                logger.debug(f"Sezione '{section_title}' divisa in {len(chunks_for_section)} chunk.")
+            
+            except Exception as e:
+                logger.error(f"Errore durante il chunking della sezione '{section_title}': {e}")
+
+        logger.info(f"Totale {len(all_chunks)} chunk generati.")
+        return all_chunks

processingPdf/extractor.py

@@ -0,0 +1,114 @@
+#Questo documento incapsula la logica per l'estrazione delle NE e del testo strutturato
+
+from gliner import GLiNER
+import torch
+import logging
+from processingPdf.loader import get_layout_extractor, load_pdf_from_bytes
+from processingPdf.logicSections import extract_logical_sections
+
+logger = logging.getLogger(__name__)
+
+class PDFExtractor:
+    def __init__(self):
+        self.layout_extractor = get_layout_extractor()
+
+    def extract_sections(self, file_path: str):
+        # Legge il file in bytes per spaCyLayout
+        with open(file_path, "rb") as f:
+            pdf_bytes = f.read()
+        
+        # Carica il documento ed estrae il layout
+        doc = load_pdf_from_bytes(pdf_bytes, self.layout_extractor)
+        
+        # Suddivide in sezioni logiche
+        if doc:
+            return extract_logical_sections(doc)
+        return {}
+
+class EntityExtractor:
+    _model = None
+    @staticmethod
+    def get_model():
+        if EntityExtractor._model is None:
+            logger.info("Caricamento del modello GLiNER...")
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            EntityExtractor._model = GLiNER.from_pretrained("urchade/gliner_medium-v2.1").to(device)
+        return EntityExtractor._model
+    
+    @staticmethod
+    def extract_ne(text: str):
+        model = EntityExtractor.get_model()
+
+        labels = [
+    # --- GENERAL & IDENTIFIERS ---
+    "Person", "Organization", "Location", "Date", "Time", 
+    "Product", "Event", "Nationality", "Language",
+
+    # --- BUROCRATICO, NORMATIVO & BANDI ---
+    "Normative Reference",      # Articoli di legge, decreti, commi
+    "Public Body",              # Enti pubblici (es. Ministero, Commissione Europea)
+    "Deadline",                 # Scadenze per bandi, domande o pagamenti
+    "Requirement",              # Requisiti di partecipazione o criteri di accesso
+    "Amount",                   # Cifre monetarie, borse di studio, tasse
+    "Evaluation Criteria",      # Criteri di punteggio o valutazione
+    "Document Type",            # Es. ISEE, Marca da bollo, Certificato di laurea
+
+    # --- TECNICO & MANUALE DI ISTRUZIONI ---
+    "Component",                # Parti di macchinari o componenti hardware
+    "Technical Specification",   # Es. 220V, 50Hz, risoluzione 4K, velocità rotazione
+    "Error Code",               # Codici errore (es. E04, 404, Fault-01)
+    "Safety Instruction",       # Avvertenze di sicurezza o pericoli
+    "Tool",                     # Strumenti necessari (es. chiave inglese, cacciavite)
+    "Operation Mode",           # Modalità operative (es. Standby, Manuale, Eco)
+
+    # --- SCIENTIFICO, CHIMICO & FISICO ---
+    "Scientific Term",          # Termini tecnici generali
+    "Chemical Compound",        # Formule e nomi di sostanze (es. H2O, Glucosio)
+    "Theory/Law",               # Leggi fisiche o teorie (es. Legge di Ohm, Relatività)
+    "Measurement Unit",         # Unità di misura (es. Joule, Watt, Nanometri)
+    "Phenomenon",               # Fenomeni naturali o reazioni (es. Ossidazione, Gravità)
+
+    # --- MEDICO & CLINICO ---
+    "Clinical Condition",       # Malattie, patologie o sintomi
+    "Medical Parameter",        # Es. Glicemia, Pressione Arteriosa, Frequenza Cardiaca
+    "Anatomical Structure",     # Organi, ossa, muscoli o tessuti
+    "Drug/Medication",          # Nomi di farmaci o principi attivi
+    "Diagnostic Test",          # Es. Risonanza Magnetica, Analisi del sangue
+
+    # --- ACCADEMICO & SCOLASTICO ---
+    "Academic Subject",         # Materie (es. Storia Moderna, Fisica Quantistica)
+    "Exam/Test Name",           # Titoli di esami o test (es. Test TOLC, Prova Scritta)
+    "Degree Course",            # Corsi di laurea o diplomi
+    "Bibliographic Source",     # Citazioni, autori o titoli di testi universitari
+
+    # --- STORICO & NARRATIVO (FANTASCIENZA) ---
+    "Historical Period",        # Ere, secoli o movimenti (es. Illuminismo, Paleolitico)
+    "Fictional Species",        # Es. Androidi, Alieni, Specie di fantasia
+    "Technological Concept",    # Tecnologie immaginarie o concetti futuristici
+
+    # --- QUANTITATIVO ---
+    "Percentage",               # Percentuali e tassi
+    "Quantity",                 # Quantità generiche non monetarie
+    "Distance"                  # Distanze e lunghezze
+]
+        
+        entities_found = model.predict_entities(text, labels, threshold=0.5)
+
+        entities = []
+        seen = set() # Per tracciare i duplicati nello stesso chunk
+
+        for ent in entities_found:
+            text_clean = ent["text"].strip().lower()
+            label_clean = ent["label"].upper().replace(" ", "_")
+            
+            # Creiamo una chiave univoca per il set
+            entity_key = (text_clean, label_clean)
+            
+            if entity_key not in seen:
+                entities.append({
+                    "text": text_clean,
+                    "label": label_clean
+                })
+                seen.add(entity_key)
+            
+        return entities

processingPdf/indexer.py

@@ -0,0 +1,117 @@
+#Questo file è responsabile di due compiti principali: caricare il modello di embedding 
+#e orchestrare l'indicizzazione completa su Neo4j
+
+import logging
+import torch
+from typing import List
+from langchain_core.documents import Document as LangchainDocument
+from sentence_transformers import SentenceTransformer
+from processingPdf.extractor import EntityExtractor
+from dotenv import load_dotenv
+import os
+
+from db.graph_db import GraphDB
+
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+#Gestisce il caricamento del modello di emedding e l'indicizzazione dei chunk in Neo4j
+class Indexer:
+    def __init__(self):
+        try:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            logger.info(f"Caricamento del modello di embedding sul dispositivo: {device}")
+            #sentence-transformers gestisce l'ottimizzazione del caricamento
+            self.embedding_model = SentenceTransformer(os.getenv("EMBEDDING_MODEL_NAME"), device=device)
+            self.embedding_dimensions = self.embedding_model.get_sentence_embedding_dimension()
+            logger.info(f"Modello di embedding '{os.getenv('EMBEDDING_MODEL_NAME')}' caricato con {self.embedding_dimensions} dimensioni.")
+        except Exception as e:
+            logger.error(f"Errore durante il caricamento del modello di embedding: {e}")
+            raise e
+
+    #Genera l'embedding vettoriale per un dato testo. Aggiungo un cast a List[float] per compatibilità con Neo4j
+    def generate_embeddings(self, text:str) -> List[float]:
+        return self.embedding_model.encode(text).tolist()
+    
+    #Orchestra l'indicizzazione dei chunk in Neo4j, gestendo la creazione del documento, dell'utente, del link e dell'inidice vettoriale
+    def index_chunks_to_neo4j(self, filename: str, chunks: list, user_id: str, lang: str = "it"):
+        if not chunks:
+            logger.warning("Nessun chunk fornito per l'indicizzazione.")
+            return
+        
+        graph_db = None
+        try:
+            # 1. Inizializzo la connessione a Neo4j
+            graph_db = GraphDB()
+
+            # 2. Creazione/Aggiornamento nodi user e document
+            graph_db.create_user_node(user_id)
+            graph_db.create_document_node(filename)
+            graph_db.link_user_to_document(user_id, filename)
+
+            # 3. Creazione indice vettoriale (se non esiste)
+            graph_db.create_vector_index(
+                index_name="chunk_embeddings_index",
+                node_label="Chunk",
+                property_name="embedding",
+                vector_dimensions=self.embedding_dimensions
+            )
+
+            # 4. Inserimento chunk ed embedding
+            for i, chunk in enumerate(chunks):
+                content = chunk.page_content
+                metadata = chunk.metadata
+                
+                # Ho deciso di assicurarmi che esista sempre un chunk_id valido
+                chunk_id = metadata.get("chunk_id") or f"{filename}_{i}"
+
+                # Genero l'embedding per il contenuto corrente
+                embedding = self.generate_embeddings(content)
+
+                # Ho deciso di implementare un controllo di sicurezza bloccante: 
+                # se l'embedding è vuoto o ha dimensioni errate, salto l'inserimento per evitare nodi "sporchi"
+                if not embedding or len(embedding) != self.embedding_dimensions:
+                    logger.error(f"FALLIMENTO CRITICO: Ho rilevato un embedding non valido per il chunk {chunk_id}. Dimensione: {len(embedding) if embedding else 0}")
+                    continue
+
+                # Salvo il chunk, l'embedding e i metadati in Neo4j
+                graph_db.add_chunk_to_document(filename, chunk_id, content, embedding, metadata)
+                logger.debug(f"Ho indicizzato con successo il chunk '{chunk_id}' per il file '{filename}'.")
+
+                # Estrazione e collegamento delle entità tramite GLiNER
+                try:
+                    entities = EntityExtractor.extract_ne(content)
+                    for ent in entities:
+                        graph_db.add_entity_to_chunk(ent["text"], ent["label"], chunk_id)
+                except Exception as ne_e:
+                    # Ho deciso di loggare l'errore delle entità come warning per non bloccare l'intera pipeline
+                    logger.warning(f"Non sono riuscito a estrarre entità per il chunk {chunk_id}: {ne_e}")
+            
+            logger.info(f"Ho completato l'indicizzazione di {len(chunks)} chunk per il file '{filename}'.")
+        
+        except Exception as e:
+            logger.error(f"Ho riscontrato un errore fatale durante l'indicizzazione in Neo4j per '{filename}': {e}")
+            raise
+        finally:
+            if graph_db:
+                graph_db.close()
+            
+    # Metodo coordinatore per processare il file fisico
+    def index_pdf(self, file_path: str, user_id: str):
+        # Import locali per gestire la pipeline
+        from processingPdf.extractor import PDFExtractor 
+        from processingPdf.chunker import Chunker
+        
+        filename = os.path.basename(file_path)
+        
+        # 1. Estrazione del testo strutturato dal PDF
+        extractor = PDFExtractor() 
+        sections = extractor.extract_sections(file_path) 
+        
+        # 2. Suddivisione delle sezioni in chunk
+        chunker = Chunker()
+        chunks = chunker.create_chunks(sections, filename)
+        
+        # 3. Indicizzazione finale su Neo4j 
+        self.index_chunks_to_neo4j(filename, chunks, user_id)

processingPdf/loader.py

@@ -0,0 +1,34 @@
+#Questa parte è responsabile dell'estrazione del testo e delle informazioni sul
+#layout utilizzando spaCyLayout
+
+import spacy
+from typing import Any
+from spacy_layout import spaCyLayout
+import logging
+
+logger = logging.getLogger(__name__)
+
+#Configurazione del logger
+logging.basicConfig(level=logging.INFO)
+
+#Funzione per inizializzare e restituire l'istanza di spacy con il componenete spacylayout
+#Ci permette di analizzare la struttura del PDF (colonne, titoli, etc.)
+def get_layout_extractor():
+    #Inizializza un modello spaCy vuoto in italiano
+    nlp = spacy.blank("it")
+    #Aggiunge il componente spaCyLayout al modello
+    layout_extractor = spaCyLayout(nlp)
+
+    logger.info("Estrattore spaCyLayout per PDF inizializzato")
+    return layout_extractor
+
+#Funzione per caricare il documento da bytes
+def load_pdf_from_bytes(pdf_bytes: bytes, layout_extractor: Any):
+    try:
+        #Chiama l'estrattore sui bytes del PDF
+        doc = layout_extractor(pdf_bytes)
+        logger.info("Estrazione del layout del PDF completata")
+        return doc
+    except Exception as e:
+        logger.error(f"Errore durante il caricamento o l'estrazione del PDF: {e}")
+        return None

processingPdf/logicSections.py

@@ -0,0 +1,85 @@
+#Questa parte si occupa di suddividere il documento processato in sezioni logiche
+#(capitoli, sottosezioni, etc.) sfruttando le etichette di layout.
+
+import logging
+from typing import Dict, Any
+
+logger = logging.getLogger(__name__)
+
+#Suddivide il documneto spaCy in sezioni logiche basandosi sulle etichette di layout. Il "doc" è il documento spaCy processato da load_pdf_from_bytes
+#Ritorna un dizionario dove la chiave è il titolo della sezione e il valore è il testo associato
+def extract_logical_sections(doc: Any) -> Dict[str, Any]:
+    sections = {}
+    #Questo è un titolo segnaposto per eventuale contenuto iniziale non etichettato da un header
+    current_title = "preambolo_documento"
+    sections[current_title] = ""
+
+    #Etichette che indicano l'inizio di una NUOVA SEZIONE LOGICA
+    SECTION_LABELS = ("SECTION_HEADER", "TITLE", "BOLD", "BOLD_CAPTION")
+
+    #Etichette di Contenuto (da trattare come corpo testuale)
+    CONTENT_LABELS = ("TEXT", "LIST", "PARAGRAPH")
+
+    if not hasattr(doc, 'spans') or not doc.spans.get ("layout"):
+        if hasattr(doc, 'text') and doc.text.strip():
+            logger.warning("Nessun layout distinto trovato, restituisco il documento completo come sezione unica.")
+            return {"documento_completo": doc.text.strip()}
+        return {}
+    
+    #Itera su tutti gli span etichettati
+    for span in doc.spans.get("layout", []):
+        label = span.label_.upper()
+        span_text = span.text.strip()
+
+        if not span_text:
+            continue
+        
+        #1. Identificazione e cambio di sezione
+        if label in SECTION_LABELS:
+            potential_title = span_text.lower()
+            #Assicuriamo l'unicità e un minimo di lunghezza
+            if len(potential_title) > 3 and potential_title not in sections:
+                current_title = potential_title
+                sections[current_title] = ""
+            elif current_title in sections:
+                #Se il titolo non cambia, aggiungiamo il testo (utile per titoli multi-linea)
+                sections[current_title] += span_text + "\n"
+        
+        #2. Gestione Esplicita di informazioni tabulari e immagini
+        elif label == "TABLE_CAPTION":
+            #Usiamo la caption come nuovo titolo di sezione temporaneo
+            current_title = f"tabella: {span_text.lower()[:100]}"
+            if current_title not in sections:
+                sections[current_title] = span_text + "\n"
+
+        elif label == "FIGURE_CAPTION":
+            #Usiamo la caption come nuovo titolo di sezione temporaneo (per immagini ora)
+            current_title = f"figura: {span_text.lower()[:100]}"
+            if current_title not in sections:
+                sections[current_title] = span_text + "\n"
+        
+        #3. Gestione del Testo del Corpo/Contenuto
+        elif label in CONTENT_LABELS:
+            #Aggiunge il testo sotto la sezione corrente o preambolo
+            sections[current_title] += span_text + "\n"
+        
+        #4. Blocchi di contenuto generici (Es. Table o Figure senza caption)
+        elif label in ("TABLE", "FIGURE"):
+            # Se la label è TABLE o FIGURE e non abbiamo ancora una caption, 
+            # usiamo un titolo generico per non perdere il testo.
+            if "tabella:" not in current_title and "figura:" not in current_title:
+                 current_title = f"blocco_generico_{label.lower()}"
+                 if current_title not in sections:
+                     sections[current_title] = ""
+            sections[current_title] += span_text + "\n"
+        
+    #Pulisce le sezioni vuote e rimuove spazi iniziali/finali
+    cleaned_sections = {k: v.strip() for k, v in sections.items() if v.strip()}
+
+    #Gestisce il caso di documenti con molto rumore o layout non convenzionale
+    if not cleaned_sections and hasattr(doc, 'text') and doc.text.strip():
+        logger.warning("Suddivisione per layout fallita, ritorno il documento completo come sezione unica.")
+        return {"documento_completo": doc.text.strip()}
+        
+    logger.info(f"Documento suddiviso in {len(cleaned_sections)} sezioni logiche.")
+    return cleaned_sections

processingPdf/reranker.py

@@ -0,0 +1,28 @@
+import torch
+import logging
+from sentence_transformers import CrossEncoder
+
+logger = logging.getLogger(__name__)
+
+class Reranker:
+    def __init__(self, model_name="BAAI/bge-reranker-v2-m3"):
+        try:
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            #il CrossEncoder riceve coppie (domanda, chunk) e restituisce un punteggio
+            self.model = CrossEncoder(model_name, device=device)
+            logger.info(f"Re-ranker '{model_name}' caricato con successo.")
+        except Exception as e:
+            logger.error(f"Errore nel caricamento del Re-ranker: {e}")
+            raise
+    
+    #riceve la query e la lista di chunks restituendo i top 5 (in questo caso) più rilevanti
+    def rerank(self, query: str, documents: list, top_n: int = 5):
+        if not documents:
+            return []
+        #coppie per il cross encoder
+        pairs = [[query, doc] for doc in documents]
+        #calcolo gli score di pertinenza
+        scores = self.model.predict(pairs)
+        #unisco i chunks ai loro score e li ordino
+        scored_docs= sorted(zip(scores, documents), key=lambda x: x[0], reverse=True)
+        return [doc for score, doc in scored_docs[:top_n]]

requirements.txt

@@ -0,0 +1,17 @@
+fastapi
+gliner
+groq
+hf_xet
+huggingface_hub
+langchain-core
+langchain-text-splitters
+langgraph
+mistralai
+neo4j
+python-dotenv
+python-multipart
+sentence-transformers
+spacy
+spacy-layout
+torch
+uvicorn