handling contexts

app.backup

@@ -1,126 +0,0 @@
-import sys
-import time
-import gradio as gr
-
-from config import initialize, check_user
-
-
-llm_manager, qdrant_manager = initialize()
-if llm_manager is None:
-    print("Error: Failed to initialize configuration: llm_manager. Exiting application.", flush=True)
-    sys.exit(1)
-if qdrant_manager is None:
-    print("Error: Failed to initialize configuration: qdrant_manager. Exiting application.", flush=True)
-    sys.exit(1)
-
-def reset_textbox():
-    """Clears the textbox after sending a message."""
-    return gr.update(value="")
-
-def slow_echo(message, history):
-    if history is None:
-        history = []  # Ensure history is initialized
-
-    # Append user message with role "user"
-    history.append({"role": "user", "content": message})
-
-    # Placeholder for assistant response
-    bot_entry = {"role": "assistant", "content": ""}
-    history.append(bot_entry)
-
-    response = "You typed: "
-
-    for i in range(len(message)):
-        time.sleep(0.05)
-        response += message[i]
-        bot_entry["content"] = response  # Update assistant's response progressively
-        yield history  # Yield updated history in the correct format
-
-    yield history  # Final yield with full message
-
-def llm_send_message(message, history):
-    if history is None:
-        history = []
-
-    # Append user message to history
-    history.append({"role": "user", "content": message})
-
-    yield history 
-
-    # Placeholder for assistant response
-    bot_entry = {"role": "assistant", "content": ""}
-    history.append(bot_entry)
-
-    # Send message to LLM and stream response
-    response = ""
-    for chunk in llm_manager.send_message(message):  # Streaming response
-        time.sleep(0.01)  # Simulate gradual output
-        response += chunk
-        bot_entry["content"] = response  # Update assistant response progressively
-        yield history  # Yield updated history
-
-    yield history  # Final yield
-
-def authenticate(username, password):
-    if check_user(username, password):
-        print("🔑 Login successful!")
-        return gr.update(visible=False), gr.update(visible=True), gr.update(value="", visible=False)  # Hide login, show chatbot, clear error
-    else:
-        print("❌ Incorrect username or password")
-        return gr.update(visible=True), gr.update(visible=True), gr.update(value="❌ Incorrect username or password", visible=True)  # Show error
-
-with gr.Blocks(fill_height=True) as demo:
-    
-    with gr.Column(visible=True) as login_section:
-        gr.Markdown("### 🔒 Login Required")
-        username_input = gr.Textbox(label="Username")
-        password_input = gr.Textbox(label="Password", type="password")
-        login_button = gr.Button("Login")
-        error_message = gr.Text("", visible=False)
-
-    with gr.Column(visible=False) as chat_section:
-
-        chat_configuration = gr.Markdown("")
-    
-        chat = gr.Chatbot(
-            label="Video Helper",
-            type="messages"
-        ) 
-
-        input = gr.Textbox(
-            label="Input", 
-            placeholder="Type something here..."
-        )
-
-        stored_message = gr.State()
-
-        input.submit(
-            fn=lambda text: (text, ""),
-            inputs=[input],  
-            outputs=[stored_message, input]
-        ).then(
-            #fn=llm_send_message,  
-            fn=slow_echo,
-            inputs=[stored_message, chat],
-            outputs=chat
-        )
-
-        send_btn = gr.Button("Send")  
-        send_btn.click(
-            fn=lambda text: (text, ""),  
-            inputs=[input],  
-            outputs=[stored_message, input]  
-        ).then(
-            fn=llm_send_message,  
-            inputs=[stored_message, chat],  
-            outputs=chat
-        )
-
-    login_button.click(
-        authenticate, 
-        [username_input, password_input], 
-        [login_section, chat_section, error_message]
-    )
-
-if __name__ == "__main__":
-    demo.launch()

app.py

@@ -33,27 +33,81 @@ def set_interactive_state(interactive: bool):
         gr.update(interactive=interactive)   # send_btn
     )
 
-def _add_trust_icon(text, level):
+# def _add_trust_icon(text, level):
+#     icons = {
+#         "high": "🟢",  # alta affidabilità
+#         "medium": "🟡",  # simile ma non perfetto
+#         "summary": "🟠",  # riassunto usato
+#         "low": "🔴",  # basato solo sulla chat
+#         "no_context": "⚪️"
+#     }
+#     label = {
+#         "high": "Reliable",
+#         "medium": "Moderate Similarity",
+#         "summary": "Summary Used",
+#         "low": "No Source Match",
+#         "no_context": "No Context"
+#     }
+
+#     icon = icons.get(level, "⚪️")
+#     tooltip = label.get(level, "Unknown")
+
+#     # Prepend semaforo + etichetta (puoi anche usare HTML per Gradio futuro)
+#     return f"{icon} *{tooltip}*\n\n{text}"
+
+def _add_trust_icon(text, support_level="unknown"):
     icons = {
-        "high": "🟢",  # alta affidabilità
-        "medium": "🟡",  # simile ma non perfetto
-        "summary": "🟠",  # riassunto usato
-        "low": "🔴",  # basato solo sulla chat
-        "no_context": "⚪️"
+        "green": "🟢",
+        "yellow": "🟡",
+        "red": "🔴",
+        "unknown": "⚪️"
     }
-    label = {
-        "high": "Reliable",
-        "medium": "Moderate Similarity",
-        "summary": "Summary Used",
-        "low": "No Source Match",
-        "no_context": "No Context"
+
+    labels = {
+        "green": "Supported by context",
+        "yellow": "Partially supported",
+        "red": "Not supported",
+        "unknown": "Support level unknown"
     }
 
-    icon = icons.get(level, "⚪️")
-    tooltip = label.get(level, "Unknown")
+    icon = icons.get(support_level, "⚪️")
+    label = labels.get(support_level, "Support level unknown")
+
+    return f"{icon} *{label}*\n\n{text}"
+
+
+
+def toggle_study_mode(is_study, index, history):
+    if is_study:
+        # 🔙 Uscita dalla modalità studio → torna alla modalità standard
+        return (
+            "🎓 Study",                  # bottone torna Studio
+            gr.update(visible=True),     # chat
+            gr.update(visible=True),     # input
+            gr.update(visible=True),     # send_btn
+            gr.update(visible=False),    # study_chat
+            gr.update(visible=True),     # summary_mode_btn
+            gr.update(visible=False),    # chunk_nav
+            index,
+            history,
+            False
+        )
+    else:
+        # 🎓 Entrata in modalità studio
+        return (
+            "❌ Studio off",
+            gr.update(visible=False),    # chat
+            gr.update(visible=False),    # input
+            gr.update(visible=False),    # send_btn
+            gr.update(visible=True),     # study_chat
+            gr.update(visible=False),    # summary_mode_btn
+            gr.update(visible=True),     # chunk_nav
+            0,
+            [],  # nuova chat studio
+            True
+        )
+
 
-    # Prepend semaforo + etichetta (puoi anche usare HTML per Gradio futuro)
-    return f"{icon} *{tooltip}*\n\n{text}"
 
 def get_summary(summary_type, history):
     if history is None:
@@ -70,12 +124,40 @@ def get_summary(summary_type, history):
         label = "❓ Unknown Summary"
 
     if content:
+        history.append({"role": "user", "content": "Summary requested."})
         history.append({"role": "assistant", "content": f"{label}\n\n{content}"})
     else:
         history.append({"role": "assistant", "content": f"⚠️ No {label.lower()} available."})
 
     return history
 
+# def send_chat_message(message, history):
+#     if history is None:
+#         history = []
+
+#     history.append({"role": "user", "content": message})
+#     bot_entry = {"role": "assistant", "content": ""}
+#     history.append(bot_entry)
+
+#     response = ""
+#     context_level = "high"  # default
+
+#     # ✅ Usa la nuova funzione standard che restituisce dict con context_level
+#     stream = llm_manager.stream_message_standard(message)
+
+#     for chunk in stream:
+#         if isinstance(chunk, dict):  # nuova struttura
+#             response += chunk["content"]
+#             context_level = chunk.get("context_level", "high")
+#         else:  # retrocompatibilità, se mai usato
+#             response += chunk
+
+#         # aggiornamento in tempo reale
+#         bot_entry["content"] = _add_trust_icon(response, context_level)
+#         yield history
+
+#     yield history
+
 def send_chat_message(message, history):
     if history is None:
         history = []
@@ -85,21 +167,60 @@ def send_chat_message(message, history):
     history.append(bot_entry)
 
     response = ""
-    context_level = "high"  # default in caso non venga restituito
+    context_level = "high"  # default
+    support_level = "green"  # default (safe fallback)
 
-    # Supporta nuova struttura restituita da stream_message
-    stream = llm_manager.stream_message(message, contextualize=True)
+    # ✅ Usa la nuova funzione standard che restituisce dict con context_level e support_level
+    stream = llm_manager.stream_message_standard(message)
 
     for chunk in stream:
-        if isinstance(chunk, dict):  # nuova versione con chunk + livello
-            response += chunk["content"]
-            context_level = chunk.get("context_level", "high")
+        if isinstance(chunk, dict):  # nuova struttura
+            content = chunk.get("content")
+            if content:
+                response += content
+
+            support_level = chunk.get("support_level", support_level)
+            #print(f"🔍 SUPPORT LEVEL RECEIVED: {support_level}")
+            bot_entry["content"] = _add_trust_icon(response, support_level)
+            yield history
+
         else:  # retrocompatibilità
             response += chunk
+            bot_entry["content"] = _add_trust_icon(response, support_level)
+            yield history
+
+
+def load_chunk(index, history):
+    chunk = qdrant_manager.get_chunk_by_index(index)
+    if chunk:
+        llm_manager.set_focus_on_chunk(chunk)
+
+        # Aggiungi messaggio assistant con il contenuto del chunk
+        history.append({"role": "assistant", "content": f"📚 **Chunk {index + 1}**\n\n{chunk}"})
+        return history, gr.update(visible=index > 0), gr.update(visible=True)
+    else:
+        history.append({"role": "assistant", "content": "⚠️ Chunk non trovato."})
+        return history, gr.update(visible=False), gr.update(visible=False)
+
+def handle_study_message(msg, index, history):
+    if history is None:
+        history = []
+
+    history.append({"role": "user", "content": msg})
+    bot_entry = {"role": "assistant", "content": ""}
+    history.append(bot_entry)
+
+    response = ""
+    context_level = None
+
+    for partial in llm_manager.stream_message_study(msg):
+        content = partial.get("content")
+        support_level = partial.get("support_level", "unknown")
 
-        # aggiorna contenuto in tempo reale
-        bot_entry["content"] = _add_trust_icon(response, context_level)
-        yield history
+        if content:
+            response += content
+            bot_entry["content"] = _add_trust_icon(response, support_level)
+            yield history
 
     yield history
 
@@ -116,6 +237,7 @@ def authenticate(username, password):
         return (
             gr.update(visible=False),  # Hide login
             gr.update(visible=True),   # Show chat
+            gr.update(visible=True),   # Show nav
             gr.update(value="", visible=False),  # Clear error
             assistant_msgs  # Initial chat history
         )
@@ -129,6 +251,7 @@ def authenticate(username, password):
 
 with gr.Blocks(fill_height=True) as demo:
 
+    # === LOGIN ===
     with gr.Column(visible=True) as login_section:
         gr.Markdown("### 🔒 Login Required")
         username_input = gr.Textbox(label="Username")
@@ -136,83 +259,155 @@ with gr.Blocks(fill_height=True) as demo:
         login_button = gr.Button("Login")
         error_message = gr.Text("", visible=False)
 
+    # === SEZIONE CHAT (visibile per default) ===
     with gr.Column(visible=False) as chat_section:
-        
         chat_configuration = gr.Markdown("")
-
         spinner = gr.Markdown("⏳ Sto pensando...", visible=False)
 
-        with gr.Row():
-            map_btn = gr.Button("🧾 Map Summary")
-            stuff_btn = gr.Button("📚 Stuff Summary")
-        
-        chat = gr.Chatbot(
-            label="Video Helper",
-            type="messages"
-        )
-
-        input = gr.Textbox(
-            label="Input",
-            placeholder="Type something here..."
-        )
+        input = gr.Textbox(label="Input", placeholder="Type something here...")
         send_btn = gr.Button("Send")
 
         stored_message = gr.State()
         chat_history = gr.State(value=[])
 
-        map_btn.click(
-            fn=lambda history: get_summary("map", history),
-            inputs=[chat_history],
-            outputs=[chat]
-        )
+    # === SEZIONE STUDIO (mostrata solo quando attiva) ===
+    with gr.Column(visible=False) as study_chat:
+        study_chatbox = gr.Chatbot(label="Study Moxde", type="messages")
+        study_input = gr.Textbox(placeholder="Ask something about the current chunk...")
+        study_send = gr.Button("Send")
 
-        stuff_btn.click(
-            fn=lambda history: get_summary("stuff", history),
-            inputs=[chat_history],
-            outputs=[chat]
-        )
+    # === NAVIGAZIONE MODALITÀ ===
+    with gr.Row(visible=False) as nav_section:
+        study_mode_btn = gr.Button("🎓 Study")
+        summary_mode_btn = gr.Button("🧠 Summary")
 
-        input.submit(
-            fn=lambda x: (x, ""),
-            inputs=input,
-            outputs=[stored_message, input]
-        ).then(
-            fn=show_spinner,
-            outputs=[spinner]
-        ).then(
-            fn=send_chat_message,
-            inputs=[stored_message, chat_history],
-            outputs=chat
-        ).then(
-            fn=hide_spinner,
-            outputs=[spinner]
-        )
-        
-        send_btn.click(
-            fn=lambda x: (x, ""),
-            inputs=input,
-            outputs=[stored_message, input]
-        ).then(
-            fn=show_spinner,
-            outputs=[spinner]
-        ).then(
-            fn=send_chat_message,
-            inputs=[stored_message, chat_history],
-            outputs=chat
-        ).then(
-            fn=hide_spinner,
-            outputs=[spinner]
-        )
+    # === NAVIGAZIONE CHUNKS (mostrata solo in modalità studio) ===
+    with gr.Row(visible=False) as chunk_nav:
+        prev_chunk_btn = gr.Button("⬅️ Previous Chunk")
+        next_chunk_btn = gr.Button("➡️ Next Chunk")
+
+    # === STATE ===
+    study_chunk_index = gr.State(value=0)
+    study_history = gr.State(value=[])
+    is_study_mode = gr.State(value=False)
 
+    # === AUTENTICAZIONE ===
     login_button.click(
         authenticate,
         [username_input, password_input],
-        [login_section, chat_section, error_message, chat_history]
+        [login_section, chat_section, nav_section, error_message, chat_history]
     ).then(
         fn=lambda history: history,
         inputs=[chat_history],
         outputs=[chat]
     )
 
+    # === CHAT STANDARD ===
+    input.submit(
+        fn=lambda x: (x, ""),
+        inputs=input,
+        outputs=[stored_message, input]
+    ).then(
+        fn=show_spinner,
+        outputs=[spinner]
+    ).then(
+        fn=send_chat_message,
+        inputs=[stored_message, chat_history],
+        outputs=chat
+    ).then(
+        fn=hide_spinner,
+        outputs=[spinner]
+    )
+
+    send_btn.click(
+        fn=lambda x: (x, ""),
+        inputs=input,
+        outputs=[stored_message, input]
+    ).then(
+        fn=show_spinner,
+        outputs=[spinner]
+    ).then(
+        fn=send_chat_message,
+        inputs=[stored_message, chat_history],
+        outputs=chat
+    ).then(
+        fn=hide_spinner,
+        outputs=[spinner]
+    )
+
+    # === CHAT STUDIO ===
+    study_input.submit(
+        fn=lambda x: (x, ""),
+        inputs=study_input,
+        outputs=[stored_message, study_input]
+    ).then(
+        fn=handle_study_message,
+        inputs=[stored_message, study_chunk_index, study_history],
+        outputs=study_chatbox
+    )
+
+    study_send.click(
+        fn=lambda x: (x, ""),
+        inputs=study_input,
+        outputs=[stored_message, study_input]
+    ).then(
+        fn=handle_study_message,
+        inputs=[stored_message, study_chunk_index, study_history],
+        outputs=study_chatbox
+    )
+
+    # === MODALITÀ STUDIO ON/OFF ===
+    study_mode_btn.click(
+        fn=toggle_study_mode,
+        inputs=[is_study_mode, study_chunk_index, study_history],
+        outputs=[
+            study_mode_btn,
+            chat,
+            input,
+            send_btn,
+            study_chat,
+            summary_mode_btn,
+            chunk_nav,
+            study_chunk_index,
+            study_history,
+            is_study_mode
+        ]
+    ).then(
+        fn=load_chunk,
+        inputs=[study_chunk_index, study_history],
+        outputs=[study_chatbox, prev_chunk_btn, next_chunk_btn]
+    )
+
+    # === MOSTRA SUMMARY (solo modalità standard) ===
+    summary_mode_btn.click(
+        fn=get_summary,
+        inputs=[gr.State("map"), chat_history],
+        outputs=[chat]
+    )
+
+    # === NAVIGAZIONE CHUNKS ===
+    next_chunk_btn.click(
+        fn=lambda idx: idx + 1,
+        inputs=study_chunk_index,
+        outputs=study_chunk_index
+    ).then(
+        fn=load_chunk,
+        inputs=[study_chunk_index, study_history],
+        outputs=[study_chatbox, prev_chunk_btn, next_chunk_btn]
+    )
+
+    prev_chunk_btn.click(
+        fn=lambda idx: max(idx - 1, 0),
+        inputs=study_chunk_index,
+        outputs=study_chunk_index
+    ).then(
+        fn=load_chunk,
+        inputs=[study_chunk_index, study_history],
+        outputs=[study_chatbox, prev_chunk_btn, next_chunk_btn]
+    )
+
+
+
+
 if __name__ == "__main__":
     demo.launch()

config.py

@@ -9,6 +9,10 @@ MODEL = "gpt-4o-mini"
 LANGUAGE = "en"
 
 crossencoder_model = None
+crossencoder_model_name = None
+#crossencoder_model_name = "cross-encoder/ms-marco-MiniLM-L-6-v2"
+#crossencoder_model_name = "cross-encoder/ms-marco-MiniLM-L-12-v2"  
+
 credentials = {}
 
 def check_user(username, password):
@@ -25,9 +29,9 @@ def initialize(app=None):
     try:
         load_dotenv()
 
-        if crossencoder_model is None:
+        if crossencoder_model_name:
             print("Loading CrossEncoder model...")
-            crossencoder_model = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")
+            crossencoder_model = CrossEncoder(crossencoder_model_name)
             print("CrossEncoder model loaded!")
 
         credentials[os.getenv("USERNAME")] = os.getenv("PASSWORD")

data/txt/Key statisitcs startups.txt

@@ -1,5 +1,3 @@
-(Transcribed by TurboScribe.ai. Go Unlimited to remove this message.)
-
 Hi everyone and welcome to this video lecture from the Entrepreneurial Literacy Initiative. I am Martti Wask and today we're going to present to you some brief key statistics about entrepreneurship. Before we go into the mud, let me give you some brief definition of what I understand about a startup. 
 
 So to some extent startups are just like any other business, right, or more specifically small businesses because they're small at the beginning. But there are three characteristics that make them unique. Startups are young, high growth orientated businesses.

utilities/llm/LlmManager.py

@@ -1,76 +1,139 @@
+import json, re
 from langchain_openai import ChatOpenAI
 from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
 from utilities.vectorstore.SummaryManager import SummaryManager
 
 MAX_MESSAGES = 50
 
-system_message_it = """
-Sei ELI, un assistente che aiuta gli studenti ad analizzare un video e rispondere a domande su di esso.
-Basandoti sul contesto fornito, rispondi alla domanda dell'utente.
-
-- Contesto: {context}
-- Domanda: {question}
-"""
+# system_message_it = """
+# Sei ELI, un assistente che aiuta gli studenti ad analizzare un video e rispondere a domande su di esso.
+# Basandoti sul contesto fornito, rispondi alla domanda dell'utente.
+
+# - Contesto: {context}
+# - Domanda: {question}
+# """
+
+# system_message_en = """
+# You are ELI, an assistant that helps students analyze a video and answer questions about it.
+# Based on the provided context, answer the user's question.
+
+# - Context: {context}
+# - Question: {question}
+# """
+
+# def get_system_message(language="en"):
+#     if language == "it":
+#         return system_message_it
+#     else:
+#         return system_message_en
+
+# fallback_prompt_en = """
+# You are ELI, an assistant that helps students analyze a video and answer questions about it.
+# Unfortunately, no relevant context could be found in the provided material.
+
+# - If possible, try to answer based on the previous conversation.
+# - Otherwise, inform the user that no verified information is available to answer the question reliably.
+
+# - Question: {question}
+# """
+
+# fallback_prompt_it = """
+# Sei ELI, un assistente che aiuta gli studenti ad analizzare un video e rispondere a domande su di esso.
+# Purtroppo, non è stato trovato alcun contesto rilevante nei materiali forniti.
+
+# - Se possibile, prova a rispondere basandoti sulla conversazione precedente.
+# - Altrimenti, informa l’utente che non hai informazioni verificate per rispondere in modo affidabile.
+
+# - Domanda: {question}
+# """
+
+# def get_fallback_prompt(language="en"):
+#     fallback_prompts = {
+#         "en": fallback_prompt_en,
+#         "it": fallback_prompt_it
+#     }
+#     return fallback_prompts.get(language, fallback_prompts["en"])
+
+# def get_disclaimer(context_level, language="en"):
+#     disclaimers = {
+#         "en": {
+#             "medium": "\n\n⚠️ Note: the retrieved context has moderate similarity. The answer may not be fully reliable.",
+#             "summary": "\n\n🟠 Note: the context is based on a general summary of the content. Please verify the information if needed.",
+#             "low": "\n\n⚠️ No reliable information was found in the source material. The answer may rely only on the conversation.",
+#             "no_context": "\n\n⚠️ No context available. The assistant will try to respond based on previous conversation, if possible."
+#         },
+#         "it": {
+#             "medium": "\n\n⚠️ Nota: il contesto recuperato ha una similarità moderata. La risposta potrebbe non essere pienamente affidabile.",
+#             "summary": "\n\n🟠 Nota: il contesto usato è un riassunto generale del contenuto. Verifica le fonti se necessario.",
+#             "low": "\n\n⚠️ Nessuna informazione affidabile trovata nei materiali. La risposta potrebbe basarsi solo sulla conversazione.",
+#             "no_context": "\n\n⚠️ Nessun contesto disponibile. L’assistente proverà a rispondere in base alla conversazione, se possibile."
+#         }
+#     }
+
+#     return disclaimers.get(language, {}).get(context_level, "")
 
 system_message_en = """
 You are ELI, an assistant that helps students analyze a video and answer questions about it.
-Based on the provided context, answer the user's question.
 
-- Context: {context}
-- Question: {question}
-"""
+Evaluate how well the provided context supports answering the user's question.
 
-def get_system_message(language="en"):
-    if language == "it":
-        return system_message_it
-    else:
-        return system_message_en
+If the context is not sufficient, you may use the previous conversation to help answer, if possible.
 
-fallback_prompt_en = """
-You are ELI, an assistant that helps students analyze a video and answer questions about it.
-Unfortunately, no relevant context could be found in the provided material.
+Use one of the following support levels:
+- green: clearly supported by the context
+- yellow: partially supported or inferred
+- red: not supported by the context (but you may still answer based on the conversation)
+
+At the beginning of your answer, write a line with the support level in the following format:
+
+[SUPPORT: green]
+
+Then go to the next line and provide the actual answer, with proper formatting.
 
-- If possible, try to answer based on the previous conversation.
-- Otherwise, inform the user that no verified information is available to answer the question reliably.
+Context:
+{context}
 
-- Question: {question}
+Question:
+{question}
 """
 
-fallback_prompt_it = """
+
+
+
+system_message_it = """
 Sei ELI, un assistente che aiuta gli studenti ad analizzare un video e rispondere a domande su di esso.
-Purtroppo, non è stato trovato alcun contesto rilevante nei materiali forniti.
 
-- Se possibile, prova a rispondere basandoti sulla conversazione precedente.
-- Altrimenti, informa l’utente che non hai informazioni verificate per rispondere in modo affidabile.
+Valuta quanto il contesto fornito ti permette di rispondere in modo affidabile alla domanda.
 
-- Domanda: {question}
+Se il contesto non è sufficiente, puoi anche usare la conversazione precedente per rispondere, se disponibile.
+
+Usa uno dei seguenti livelli di supporto:
+- verde: supportata chiaramente dal contesto
+- giallo: supportata parzialmente o inferita
+- rosso: non supportata dal contesto (ma potresti rispondere comunque grazie alla conversazione)
+
+All'inizio della tua risposta scrivi una riga con il livello di supporto nel formato:
+
+[SUPPORT: verde]
+
+Poi vai a capo e fornisci la risposta normalmente, con la formattazione corretta.
+
+Contesto:
+{context}
+
+Domanda:
+{question}
 """
 
-def get_fallback_prompt(language="en"):
-    fallback_prompts = {
-        "en": fallback_prompt_en,
-        "it": fallback_prompt_it
-    }
-    return fallback_prompts.get(language, fallback_prompts["en"])
-
-
-def get_disclaimer(context_level, language="en"):
-    disclaimers = {
-        "en": {
-            "medium": "\n\n⚠️ Note: the retrieved context has moderate similarity. The answer may not be fully reliable.",
-            "summary": "\n\n🟠 Note: the context is based on a general summary of the content. Please verify the information if needed.",
-            "low": "\n\n⚠️ No reliable information was found in the source material. The answer may rely only on the conversation.",
-            "no_context": "\n\n⚠️ No context available. The assistant will try to respond based on previous conversation, if possible."
-        },
-        "it": {
-            "medium": "\n\n⚠️ Nota: il contesto recuperato ha una similarità moderata. La risposta potrebbe non essere pienamente affidabile.",
-            "summary": "\n\n🟠 Nota: il contesto usato è un riassunto generale del contenuto. Verifica le fonti se necessario.",
-            "low": "\n\n⚠️ Nessuna informazione affidabile trovata nei materiali. La risposta potrebbe basarsi solo sulla conversazione.",
-            "no_context": "\n\n⚠️ Nessun contesto disponibile. L’assistente proverà a rispondere in base alla conversazione, se possibile."
-        }
-    }
 
-    return disclaimers.get(language, {}).get(context_level, "")
+
+
+def get_system_message(language="en"):
+    if language == "it":
+        return system_message_it
+    else:
+        return system_message_en
+
 
 class LlmManager():
 
@@ -88,48 +151,177 @@ class LlmManager():
     def reset_messages(self, context, question):
         self.messages = [SystemMessage(content=self.system_message.format(context=context, question=question))]
 
-    def stream_message(self, message, contextualize=False):
+    # def stream_message_standard(self, message):
+    #     """
+    #     Modalità STANDARD: recupera il contesto semanticamente da Qdrant.
+    #     """
+    #     context = ""
+    #     context_level = "no_context"
+
+    #     if self.qdrant_manager and self.qdrant_manager.is_loaded():
+    #         context, context_level = self.qdrant_manager.get_context_for_query(message)
+    #         print(f"📚 Contesto recuperato [{context_level}]: {context[:100]}")
+
+    #     disclaimer = get_disclaimer(context_level, self.language)
+    #     base_prompt = get_system_message(self.language)
+
+    #     # Fallback se il contesto è debole o assente
+    #     if not context.strip() and context_level in ["low", "no_context"]:
+    #         formatted_message = get_fallback_prompt(self.language).format(question=message)
+    #     else:
+    #         formatted_message = base_prompt.format(context=context, question=message) + disclaimer
+
+    #     # Aggiorna o imposta il messaggio di sistema
+    #     if self.messages and isinstance(self.messages[0], SystemMessage):
+    #         self.messages[0] = SystemMessage(content=formatted_message)
+    #     else:
+    #         self.messages.insert(0, SystemMessage(content=formatted_message))
+
+    #     self.messages.append(HumanMessage(content=message))
+    #     self._roll_messages()
+
+    #     response = ""
+    #     for chunk in self.llm.stream(self.messages):
+    #         response += chunk.content
+    #         yield {"content": chunk.content, "context_level": context_level}  # ✅ stream + context_level
+
+    #     self.messages.append(AIMessage(content=response))
+
+    def stream_message_standard(self, message):
         """
-        Streaming equivalente a send_message, con gestione dinamica del contesto e localizzazione.
+        Modalità STANDARD:
+        - Recupera contesto da Qdrant
+        - Costruisce prompt con system message
+        - Mantiene memoria conversazionale
+        - Streamma solo la parte di risposta dopo [SUPPORT: ...]
         """
-        if contextualize:
-            context = ""
-            context_level = "no_context"
+        context = ""
+        context_level = "no_context"
+
+        if self.qdrant_manager and self.qdrant_manager.is_loaded():
+            context, context_level = self.qdrant_manager.get_context_for_query(message)
+            print(f"📚 Contesto recuperato [{context_level}]: {context[:100]}")
 
-            if self.qdrant_manager and self.qdrant_manager.is_loaded():
-                context, context_level = self.qdrant_manager.get_context_for_query(message)
-                print(f"📚 Contesto recuperato [{context_level}]: {context[:100]}")
+        base_prompt = get_system_message(self.language)
 
-            disclaimer = get_disclaimer(context_level, self.language)
-            base_prompt = get_system_message(self.language)
+        formatted_message = base_prompt.format(context=context, question=message)
 
-            # Caso: contesto assente (no_context/low) ➝ prompt fallback
-            if not context.strip() and context_level in ["low", "no_context"]:
-                formatted_message = get_fallback_prompt(self.language).format(question=message)
-            else:
-                formatted_message = base_prompt.format(context=context, question=message) + disclaimer
+        # Mantieni la cronologia
+        if self.messages and isinstance(self.messages[0], SystemMessage):
+            self.messages[0] = SystemMessage(content=formatted_message)
+        else:
+            self.messages.insert(0, SystemMessage(content=formatted_message))
+
+        self.messages.append(HumanMessage(content=message))
+        self._roll_messages()
+
+        buffer = ""
+        response = ""
+        support_level = None
+        start_streaming = False
 
-            # Inserisci o aggiorna il SystemMessage
-            if self.messages and isinstance(self.messages[0], SystemMessage):
-                self.messages[0] = SystemMessage(content=formatted_message)
+        for chunk in self.llm.stream(self.messages):
+            chunk_text = chunk.content
+            if not start_streaming:
+                buffer += chunk_text
+                match = re.search(r"\[SUPPORT:\s*(green|yellow|red|verde|giallo|rosso)\]", buffer, re.IGNORECASE)
+                if match:
+                    raw_level = match.group(1).lower().strip()
+                    support_level = {
+                        "verde": "green",
+                        "giallo": "yellow",
+                        "rosso": "red"
+                    }.get(raw_level, raw_level)
+
+                    print(f"✅ SUPPORT LEVEL: {support_level}")
+
+                    # Inizia lo streaming dal contenuto dopo il tag
+                    after = buffer[match.end():].lstrip()
+                    if after:
+                        response += after
+                        #yield {"content": after, "context_level": context_level}
+                        yield {"content": after, "support_level": support_level or "unknown"}
+                    buffer = ""
+                    start_streaming = True
             else:
-                self.messages.insert(0, SystemMessage(content=formatted_message))
+                response += chunk_text
+                #yield {"content": chunk_text, "context_level": context_level}
+                yield {"content": chunk_text, "support_level": support_level or "unknown"}
 
-            # Aggiungi il messaggio utente
-            self.messages.append(HumanMessage(content=message))
+        response = response.strip()
+        print(f"🤖 ELI: {response}")
+        self.messages.append(AIMessage(content=response))
+
+        yield {
+            "content": None,
+            #"context_level": context_level,
+            "support_level": support_level or "unknown"
+        }
 
-        else:
-            self.messages.append(HumanMessage(content=message))
 
+    def stream_message_study(self, message):
+        """
+        Modalità STUDIO: il contesto è già stato fissato tramite set_focus_on_chunk().
+        La risposta include anche il livello di supporto ([SUPPORT: ...]).
+        """
+        context_level = "fixed"  # contesto chunk-based
+        self.messages.append(HumanMessage(content=message))
         self._roll_messages()
 
+        buffer = ""
         response = ""
+        support_level = None
+        start_streaming = False
+
         for chunk in self.llm.stream(self.messages):
-            response += chunk.content
-            yield {"content": chunk.content, "context_level": context_level}
+            chunk_text = chunk.content
+            if not start_streaming:
+                buffer += chunk_text
+                match = re.search(r"\[SUPPORT:\s*(green|yellow|red|verde|giallo|rosso)\]", buffer, re.IGNORECASE)
+                if match:
+                    raw_level = match.group(1).lower().strip()
+                    support_level = {
+                        "verde": "green",
+                        "giallo": "yellow",
+                        "rosso": "red"
+                    }.get(raw_level, raw_level)
+
+                    print(f"✅ SUPPORT LEVEL (study): {support_level}")
+
+                    after = buffer[match.end():].lstrip()
+                    if after:
+                        response += after
+                        yield {"content": after, "support_level": support_level or "unknown"}
+                    buffer = ""
+                    start_streaming = True
+            else:
+                response += chunk_text
+                yield {"content": chunk_text, "support_level": support_level or "unknown"}
 
         self.messages.append(AIMessage(content=response))
-        return response, context_level
+
+        yield {
+            "content": None,
+            "support_level": support_level or "unknown"
+        }
+
+
+    # def stream_message_study(self, message):
+    #     """
+    #     Modalità STUDIO: il contesto è già stato fissato tramite set_focus_on_chunk().
+    #     """
+    #     context_level = "fixed"  # 🔐 contesto chunk-based
+
+    #     self.messages.append(HumanMessage(content=message))
+    #     self._roll_messages()
+
+    #     response = ""
+    #     for chunk in self.llm.stream(self.messages):
+    #         response += chunk.content
+    #         yield {"content": chunk.content, "context_level": context_level}
+
+    #     self.messages.append(AIMessage(content=response))
+
 
     def send_message(self, message, contextualize=False):
         if contextualize:
@@ -203,6 +395,11 @@ class LlmManager():
         summary, _, _ = summary_manager.do_summary_stuff()
         return summary
 
+    def set_focus_on_chunk(self, chunk_text):
+        self.messages = [
+            SystemMessage(content=self.system_message.format(context=chunk_text, question=""))
+        ]
+
     def _roll_messages(self):
         """
         Keeps only the last `MAX_MESSAGES` from `messages`, excluding the first (SystemMessage).

utilities/vectorstore/QdrantLangchainManager.py

@@ -200,6 +200,34 @@ class QdrantLangchainManager:
             print(f"Error fetching documents from Qdrant: {e}")
             return []
 
+    def get_chunk_by_index(self, index: int):
+        try:
+            results = self.client.scroll(
+                collection_name=self.collection_name,
+                scroll_filter=Filter(
+                    must=[
+                        FieldCondition(
+                            key="metadata.chunk_index", 
+                            match=MatchValue(value=index)
+                        ),
+                        FieldCondition(
+                            key="metadata.type", 
+                            match=MatchValue(value="content")
+                        )
+                    ]
+                ),
+                limit=1,
+                with_payload=True
+            )
+
+            if results[0]:
+                return results[0][0].payload.get("page_content", "")
+            else:
+                return None
+        except Exception as e:
+            print(f"❌ Error retrieving chunk {index}: {e}")
+            return None
+
     def get_context_for_query(self, query, top_k=8):
         print("🔎 get_context_for_query:", query)
 
@@ -219,7 +247,14 @@ class QdrantLangchainManager:
                 print("⚠️ Nessun documento con type='content' trovato.")
                 return "", "no_context"
 
-            print(f"📦 Trovati {len(docs_with_scores)} documenti candidati.")
+            # print(f"📦 Trovati {len(docs_with_scores)} documenti candidati.")
+
+            # Log original scores (solo per confronto visivo)
+            # print("\n📄 Original similarity scores (with sigmoid just for print):")
+            # for i, (doc, original_score) in enumerate(docs_with_scores):
+            #     chunk_index = doc.metadata.get("chunk_index", "-")
+            #     sigmoid_score = sigmoid(torch.tensor(original_score)).item()
+            #     print(f"{i+1:02d}. chunk_index={chunk_index}, original_score={original_score:.3f}, sigmoid(original)={sigmoid_score:.3f}")
 
             # Se non c'è reranker, usa soglia base
             if not self.reranker:
@@ -241,9 +276,9 @@ class QdrantLangchainManager:
             high_conf, medium_conf = [], []
 
             for (doc, _), score in reranked:
-                if score > 0.7:
+                if score > 1:
                     high_conf.append(doc.page_content)
-                elif score > 0.3:
+                elif score > -5:
                     medium_conf.append(doc.page_content)
 
             if high_conf:
@@ -287,7 +322,6 @@ class QdrantLangchainManager:
             print(f"❌ Errore nel recupero del contesto: {e}")
             return "", "no_context"
 
-
     def delete_collection(self, collection_name):
         try:
             self.client.delete_collection(collection_name)
@@ -331,34 +365,25 @@ class QdrantLangchainManager:
         
         return merged_chunks, merge_performed
     
-    # def _reranking(self, query, docs_with_scores):
-    #     if not self.reranker:
-    #         print("⚠️ Reranker not initialized. Skipping reranking.")
-    #         return docs_with_scores
-        
-    #     query_pairs = [(query, doc.page_content) for doc, _ in docs_with_scores]
-    #     new_scores = self.reranker.predict(query_pairs)
-    #     return sorted(zip(docs_with_scores, new_scores), key=lambda x: x[1], reverse=True)
-
     def _reranking(self, query, docs_with_scores):
         if not self.reranker:
             print("⚠️ Reranker not initialized. Skipping reranking.")
             return docs_with_scores
-        
+
+        # Prepara input per reranker
         query_pairs = [(query, doc.page_content) for doc, _ in docs_with_scores]
-        
-        # Calcola i logit grezzi
+
+        # Ottieni i punteggi dal reranker (già in scala 0–1, ma non da sigmoid)
         raw_scores = self.reranker.predict(query_pairs)
-        
-        # Applica sigmoid per ottenere probabilità tra 0 e 1
-        prob_scores = sigmoid(torch.tensor(raw_scores)).tolist()
 
-        # Log per debugging
-        print("📈 Reranking scores (sigmoid-normalized):")
-        for i, ((doc, old_score), prob) in enumerate(zip(docs_with_scores, prob_scores)):
-            print(f"{i+1:02d}. chunk_index={doc.metadata.get('chunk_index', '-')}, score={prob:.3f}")
+        print("\n📈 Reranker scores (raw):")
+        for i, ((doc, _), score) in enumerate(zip(docs_with_scores, raw_scores)):
+            chunk_index = doc.metadata.get("chunk_index", "-")
+            print(f"{i+1:02d}. chunk_index={chunk_index}, reranked_score={score:.4f}")
+
+        # Ritorna risultati ordinati per score decrescente
+        return sorted(zip(docs_with_scores, raw_scores), key=lambda x: x[1], reverse=True)
 
-        return sorted(zip(docs_with_scores, prob_scores), key=lambda x: x[1], reverse=True)
 
     def _calculate_tokens(self, text):
         """Calculate the number of tokens in the given text."""

utilities/vectorstore/SummaryManager.py

@@ -220,14 +220,24 @@ class SummaryManager:
             print("❌ No documents found in collection.")
             return None, 0, 0
 
-        print(len(all_documents), flush=True)
+        # STEP 2: filtra fuori i documenti di tipo summary
+        filtered_docs = [
+            doc for doc in all_documents
+            if not str(doc["payload"].get("type", "")).endswith("summary")
+        ]
+
+        if not filtered_docs:
+            print("❌ No non-summary documents available for summarization.")
+            return None, 0, 0
+
+        print(f"📄 {len(filtered_docs)} documents after filtering summaries.", flush=True)
 
-        # STEP 2: extract vectors & text
-        embeddings = [doc["vector"] for doc in all_documents]
-        documents = [doc["payload"]["page_content"] for doc in all_documents]
-        metadata = [doc["payload"] for doc in all_documents]
+        # STEP 3: extract vectors & text
+        embeddings = [doc["vector"] for doc in filtered_docs]
+        documents = [doc["payload"]["page_content"] for doc in filtered_docs]
+        metadata = [doc["payload"] for doc in filtered_docs]
 
-        # STEP 3: select up to MAX_SELECTED_DOCS chunks via KMeans
+        # STEP 4: select up to MAX_SELECTED_DOCS chunks via KMeans
         MAX_SELECTED_DOCS = 5
         selected_docs = self._select_best_chunks(
             documents=documents,
@@ -239,7 +249,7 @@ class SummaryManager:
         total_tokens = sum(self.llm.get_num_tokens(doc.page_content) for doc in selected_docs)
         print(f"✅ Selected {len(selected_docs)} docs with total tokens: {total_tokens}")
 
-        # STEP 4: load LangChain prompts
+        # STEP 5: load LangChain prompts
         map_prompt_template = PromptTemplate(template=get_map_prompt(self.language), input_variables=["text"])
         combine_prompt_template = PromptTemplate(template=get_combine_prompt(self.language), input_variables=["text"])
 
@@ -257,7 +267,7 @@ class SummaryManager:
             token_count = self.llm.get_num_tokens(doc.page_content)
             print(f"Chunk {i+1}: {token_count} tokens")
 
-        # STEP 5: run the chain with token tracking
+        # STEP 6: run the chain with token tracking
         with get_openai_callback() as cb:
             result = summary_chain.invoke({"input_documents": selected_docs})
             input_tokens_used = cb.prompt_tokens
@@ -268,7 +278,7 @@ class SummaryManager:
         full_summary = result['output_text']
         print("✅ Map-reduce summary generated.")
 
-        # STEP 6: store the final summary
+        # STEP 7: store the final summary
         inserted = self.qdrant_manager.insert_text(
             text=full_summary,
             metadata={
@@ -301,14 +311,22 @@ class SummaryManager:
             print("❌ No documents found in collection.")
             return None, 0, 0
 
-        #print(len(all_documents), flush=True)
+        # STEP 2: filtra fuori i documenti di tipo summary
+        filtered_docs = [
+            doc for doc in all_documents
+            if not str(doc["payload"].get("type", "")).endswith("summary")
+        ]
 
-        # STEP 2: extract vectors & text
-        embeddings = [doc["vector"] for doc in all_documents]
-        documents = [doc["payload"]["page_content"] for doc in all_documents]
-        metadata = [doc["payload"] for doc in all_documents]
+        if not filtered_docs:
+            print("❌ No non-summary documents available for summarization.")
+            return None, 0, 0
 
-        # STEP 3: selezione intelligente con fallback a clustering
+        # STEP 3: extract vectors & text
+        embeddings = [doc["vector"] for doc in filtered_docs]
+        documents = [doc["payload"]["page_content"] for doc in filtered_docs]
+        metadata = [doc["payload"] for doc in filtered_docs]
+
+        # STEP 4: selezione intelligente con fallback a clustering
         selected_docs = self._get_chunks_for_stuff(
             documents=documents,
             metadata=metadata,
@@ -321,7 +339,7 @@ class SummaryManager:
         total_tokens = sum(self.llm.get_num_tokens(doc.page_content) for doc in selected_docs)
         print(f"✅ Selected {len(selected_docs)} docs with total tokens: {total_tokens}")
 
-        # STEP 4: load chain
+        # STEP 5: load chain
         combine_prompt_template = PromptTemplate(
             template=get_combine_prompt(self.language),
             input_variables=["text"]
@@ -335,7 +353,7 @@ class SummaryManager:
             verbose=False
         )
 
-        # STEP 5: run the chain with token tracking
+        # STEP 6: run the chain with token tracking
         with get_openai_callback() as cb:
             result = summary_chain.invoke({"input_documents": selected_docs})
             input_tokens_used = cb.prompt_tokens
@@ -346,7 +364,7 @@ class SummaryManager:
         full_summary = result['output_text']
         print("✅ Stuff summary generated.")
 
-        # STEP 6: store the final summary
+        # STEP 7: store the final summary
         inserted = self.qdrant_manager.insert_text(
             text=full_summary,
             metadata={
@@ -359,7 +377,7 @@ class SummaryManager:
             print("📝 Final summary saved to vector store.")
 
         return full_summary, input_tokens_used, output_tokens_used
-    
+
     def _find_closest_embeddings(self,vectors, num_clusters, kmeans):
         closest_indices = []
         for i in range(num_clusters):

utils.py

@@ -78,7 +78,15 @@ def chat_with_bot(llm_manager, contextualize=True):
         except Exception as e:
             print(f"⚠️ Error: {e}\n")
 
+def get_chunk(collection_name, chunk_id):
+    """Retrieve a specific chunk from a Qdrant collection."""
+    
+    # Carica la collection se esiste
+    if not qdrant_manager.get_collection(collection_name):
+        print(f"❌ Collection '{collection_name}' non trovata.")
+        return None
 
+    return qdrant_manager.get_chunk_by_index(chunk_id)
 
 llm_manager, qdrant_manager = initialize()
 
@@ -86,10 +94,10 @@ llm_manager, qdrant_manager = initialize()
 collection_name="key_statistics"
 
 llm_manager, qdrant_manager = initialize()
-if qdrant_manager.get_collection(collection_name):
-    llm_manager.set_qdrant_manager(qdrant_manager)
+# if qdrant_manager.get_collection(collection_name):
+#     llm_manager.set_qdrant_manager(qdrant_manager)
 
-chat_with_bot(llm_manager)
+#chat_with_bot(llm_manager)
 
 #manage_collection(file_name, collection_name)
 #summary=get_initial_summary(collection_name)
@@ -99,4 +107,7 @@ chat_with_bot(llm_manager)
 # if summary:
 #     print(f"✅ Summary:\n{summary}")
 # else:
-#     print("⚠️ Nessun riassunto generato.")
+#     print("⚠️ Nessun riassunto generato.")
+
+text=get_chunk(collection_name, 1)
+print(text)