Update app.py

app.py

@@ -9,22 +9,19 @@ import time # For profiling if needed
 
 # --- Module Imports ---
 from gradio_utils import get_url_user_token
-
 # Functions from newly created/refactored modules
 from config import (
     LINKEDIN_CLIENT_ID_ENV_VAR, BUBBLE_APP_NAME_ENV_VAR,
-    BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR
-)
+    BUBBLE_API_KEY_PRIVATE_ENV_VAR, BUBBLE_API_ENDPOINT_ENV_VAR)
 from state_manager import process_and_store_bubble_token
 from sync_logic import sync_all_linkedin_data_orchestrator
 from ui_generators import (
     display_main_dashboard,
     run_mentions_tab_display,
     run_follower_stats_tab_display,
-    build_analytics_tab_plot_area, # Import the updated UI builder
-    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON # Import icons
+    build_analytics_tab_plot_area, 
+    BOMB_ICON, EXPLORE_ICON, FORMULA_ICON, ACTIVE_ICON 
 )
-# Corrected import for analytics_data_processing
 from analytics_data_processing import prepare_filtered_analytics_data
 from analytics_plot_generator import (
     generate_posts_activity_plot, 
@@ -45,7 +42,12 @@ from analytics_plot_generator import (
     generate_content_format_breakdown_plot,
     generate_content_topic_breakdown_plot
 )
-from formulas import PLOT_FORMULAS # Import the formula descriptions
+from formulas import PLOT_FORMULAS 
+
+# --- NEW CHATBOT MODULE IMPORTS ---
+from chatbot_prompts import get_initial_insight_and_suggestions
+from chatbot_handler import generate_llm_response
+# --- END NEW CHATBOT MODULE IMPORTS ---
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
@@ -72,27 +74,24 @@ PLOT_ID_TO_FORMULA_KEY_MAP = {
     "post_frequency_cs": "post_frequency",
     "content_format_breakdown_cs": "content_format_breakdown",
     "content_topic_breakdown_cs": "content_topic_breakdown",
-    "mention_analysis_volume": "mentions_activity", # Mapped to the general mentions_activity
-    "mention_analysis_sentiment": "mention_sentiment" # Mapped to the general mention_sentiment
+    "mention_analysis_volume": "mentions_activity", 
+    "mention_analysis_sentiment": "mention_sentiment"
 }
 
-
 # --- Analytics Tab: Plot Figure Generation Function ---
 def update_analytics_plots_figures(token_state_value, date_filter_option, custom_start_date, custom_end_date):
     logging.info(f"Updating analytics plot figures. Filter: {date_filter_option}, Custom Start: {custom_start_date}, Custom End: {custom_end_date}")
     num_expected_plots = 19 
-
     if not token_state_value or not token_state_value.get("token"):
         message = "❌ Accesso negato. Nessun token. Impossibile generare le analisi."
         logging.warning(message)
         placeholder_figs = [create_placeholder_plot(title="Accesso Negato", message="Nessun token.") for _ in range(num_expected_plots)]
         return [message] + placeholder_figs
-
     try:
-        (filtered_merged_posts_df,
-         filtered_mentions_df,
-         date_filtered_follower_stats_df,
-         raw_follower_stats_df,
+        (filtered_merged_posts_df, 
+         filtered_mentions_df, 
+         date_filtered_follower_stats_df, 
+         raw_follower_stats_df, 
          start_dt_for_msg, end_dt_for_msg) = \
             prepare_filtered_analytics_data(
                 token_state_value, date_filter_option, custom_start_date, custom_end_date
@@ -102,55 +101,64 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
         logging.error(error_msg, exc_info=True)
         placeholder_figs = [create_placeholder_plot(title="Errore Preparazione Dati", message=str(e)) for _ in range(num_expected_plots)]
         return [error_msg] + placeholder_figs
-
+    
     date_column_posts = token_state_value.get("config_date_col_posts", "published_at")
     date_column_mentions = token_state_value.get("config_date_col_mentions", "date")
     media_type_col_name = token_state_value.get("config_media_type_col", "media_type")
     eb_labels_col_name = token_state_value.get("config_eb_labels_col", "li_eb_label")
-
+    
     plot_figs = []
     try:
-        fig_mentions_activity_shared = generate_mentions_activity_plot(filtered_mentions_df, date_column=date_column_mentions)
-        fig_mention_sentiment_shared = generate_mention_sentiment_plot(filtered_mentions_df)
-
-        plot_figs.append(generate_followers_count_over_time_plot(date_filtered_follower_stats_df, type_value='follower_gains_monthly'))
-        plot_figs.append(generate_followers_growth_rate_plot(date_filtered_follower_stats_df, type_value='follower_gains_monthly'))
-        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_geo', plot_title="Follower per Località"))
-        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_function', plot_title="Follower per Ruolo"))
-        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_industry', plot_title="Follower per Settore"))
-        plot_figs.append(generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_seniority', plot_title="Follower per Anzianità"))
-        plot_figs.append(generate_engagement_rate_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_reach_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_impressions_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_likes_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_clicks_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_shares_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_comments_over_time_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_comments_sentiment_breakdown_plot(filtered_merged_posts_df, sentiment_column='comment_sentiment'))
-        plot_figs.append(generate_post_frequency_plot(filtered_merged_posts_df, date_column=date_column_posts))
-        plot_figs.append(generate_content_format_breakdown_plot(filtered_merged_posts_df, format_col=media_type_col_name))
-        plot_figs.append(generate_content_topic_breakdown_plot(filtered_merged_posts_df, topics_col=eb_labels_col_name))
-        plot_figs.append(fig_mentions_activity_shared) 
-        plot_figs.append(fig_mention_sentiment_shared)
-
+        # Generate plots, ensuring all 19 slots are potentially filled
+        plot_fns_args = [
+            (generate_followers_count_over_time_plot, [date_filtered_follower_stats_df, 'follower_gains_monthly']),
+            (generate_followers_growth_rate_plot, [date_filtered_follower_stats_df, 'follower_gains_monthly']),
+            (generate_followers_by_demographics_plot, [raw_follower_stats_df, 'follower_geo', "Follower per Località"]),
+            (generate_followers_by_demographics_plot, [raw_follower_stats_df, 'follower_function', "Follower per Ruolo"]),
+            (generate_followers_by_demographics_plot, [raw_follower_stats_df, 'follower_industry', "Follower per Settore"]),
+            (generate_followers_by_demographics_plot, [raw_follower_stats_df, 'follower_seniority', "Follower per Anzianità"]),
+            (generate_engagement_rate_over_time_plot, [filtered_merged_posts_df, date_column_posts]),
+            (generate_reach_over_time_plot, [filtered_merged_posts_df, date_column_posts]),
+            (generate_impressions_over_time_plot, [filtered_merged_posts_df, date_column_posts]),
+            (generate_likes_over_time_plot, [filtered_merged_posts_df, date_column_posts]),
+            (generate_clicks_over_time_plot, [filtered_merged_posts_df, date_column_posts]),
+            (generate_shares_over_time_plot, [filtered_merged_posts_df, date_column_posts]),
+            (generate_comments_over_time_plot, [filtered_merged_posts_df, date_column_posts]),
+            (generate_comments_sentiment_breakdown_plot, [filtered_merged_posts_df, 'comment_sentiment']),
+            (generate_post_frequency_plot, [filtered_merged_posts_df, date_column_posts]),
+            (generate_content_format_breakdown_plot, [filtered_merged_posts_df, media_type_col_name]),
+            (generate_content_topic_breakdown_plot, [filtered_merged_posts_df, eb_labels_col_name]),
+            (generate_mentions_activity_plot, [filtered_mentions_df, date_column_mentions]), # Shared for mention_analysis_volume
+            (generate_mention_sentiment_plot, [filtered_mentions_df]) # Shared for mention_analysis_sentiment
+        ]
+
+        for i, (plot_fn, args) in enumerate(plot_fns_args):
+            try:
+                fig = plot_fn(*args)
+                plot_figs.append(fig)
+            except Exception as plot_e:
+                logging.error(f"Error generating plot for slot {i} ({plot_fn.__name__}): {plot_e}", exc_info=True)
+                plot_figs.append(create_placeholder_plot(title=f"Errore Grafico {i+1}", message=f"Dettaglio: {str(plot_e)[:100]}"))
+        
         message = f"📊 Analisi aggiornate per il periodo: {date_filter_option}"
-        if date_filter_option == "Custom Range":
+        if date_filter_option == "Intervallo Personalizzato": # Corrected from "Custom Range"
             s_display = start_dt_for_msg.strftime('%Y-%m-%d') if start_dt_for_msg else "Qualsiasi"
             e_display = end_dt_for_msg.strftime('%Y-%m-%d') if end_dt_for_msg else "Qualsiasi"
             message += f" (Da: {s_display} A: {e_display})"
-
+        
         final_plot_figs = []
         for i, p_fig in enumerate(plot_figs):
-            if p_fig is not None and not isinstance(p_fig, str):
+            if p_fig is not None and not isinstance(p_fig, str): # Checking if it's a valid plot object
                 final_plot_figs.append(p_fig)
             else:
-                logging.warning(f"Generazione figura grafico fallita o tipo inatteso per slot {i}, uso placeholder. Figura: {p_fig}")
+                logging.warning(f"Plot generation failed or unexpected type for slot {i}, using placeholder. Figure: {p_fig}")
                 final_plot_figs.append(create_placeholder_plot(title="Errore Grafico", message="Impossibile generare questa figura."))
         
+        # Ensure the list has exactly num_expected_plots items
         while len(final_plot_figs) < num_expected_plots:
-            logging.warning(f"Aggiungo figura mancante. Previste {num_expected_plots}, ottenute {len(final_plot_figs)}.")
-            final_plot_figs.append(create_placeholder_plot(title="Grafico Mancante", message="Impossibile generare la figura del grafico."))
-        
+            logging.warning(f"Adding missing plot placeholder. Expected {num_expected_plots}, got {len(final_plot_figs)}.")
+            final_plot_figs.append(create_placeholder_plot(title="Grafico Mancante", message="Figura non generata."))
+            
         return [message] + final_plot_figs[:num_expected_plots]
 
     except Exception as e:
@@ -163,7 +171,6 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
 # --- Gradio UI Blocks ---
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                title="LinkedIn Organization Dashboard") as app:
-
     token_state = gr.State(value={
         "token": None, "client_id": None, "org_urn": None,
         "bubble_posts_df": pd.DataFrame(), "bubble_post_stats_df": pd.DataFrame(),
@@ -171,14 +178,21 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         "fetch_count_for_api": 0, "url_user_token_temp_storage": None,
         "config_date_col_posts": "published_at", "config_date_col_mentions": "date",
         "config_date_col_followers": "date", "config_media_type_col": "media_type",
-        "config_eb_labels_col": "li_eb_label" 
+        "config_eb_labels_col": "li_eb_label"
     })
+    
+    # --- NEW CHATBOT STATES ---
+    # Stores chat history for each plot_id: {plot_id: [{"role": "user/assistant", "content": "..."}, ...]}
+    chat_histories_st = gr.State({}) 
+    # Stores the plot_id of the currently active chat, e.g., "followers_count"
+    current_chat_plot_id_st = gr.State(None) 
+    # --- END NEW CHATBOT STATES ---
 
     gr.Markdown("# 🚀 LinkedIn Organization Dashboard")
     url_user_token_display = gr.Textbox(label="User Token (Nascosto)", interactive=False, visible=False)
     status_box = gr.Textbox(label="Stato Generale Token LinkedIn", interactive=False, value="Inizializzazione...")
     org_urn_display = gr.Textbox(label="URN Organizzazione (Nascosto)", interactive=False, visible=False)
-
+    
     app.load(fn=get_url_user_token, inputs=None, outputs=[url_user_token_display, org_urn_display], api_name="get_url_params", show_progress=False)
 
     def initial_load_sequence(url_token, org_urn_val, current_state):
@@ -192,7 +206,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             sync_data_btn = gr.Button("🔄 Sincronizza Dati LinkedIn", variant="primary", visible=False, interactive=False)
             sync_status_html_output = gr.HTML("<p style='text-align:center;'>Stato sincronizzazione...</p>")
             dashboard_display_html = gr.HTML("<p style='text-align:center;'>Caricamento dashboard...</p>")
-
+            
             org_urn_display.change(
                 fn=initial_load_sequence,
                 inputs=[url_user_token_display, org_urn_display, token_state],
@@ -202,16 +216,15 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
 
         with gr.TabItem("2️⃣ Analisi", id="tab_analytics"):
             gr.Markdown("## 📈 Analisi Performance LinkedIn")
-            gr.Markdown("Seleziona un intervallo di date. Clicca i pulsanti per le azioni.")
-
+            gr.Markdown("Seleziona un intervallo di date. Clicca i pulsanti (💣 Insights, ƒ Formula, 🧭 Esplora) su un grafico per azioni.")
             analytics_status_md = gr.Markdown("Stato analisi...")
-
+            
             with gr.Row():
                 date_filter_selector = gr.Radio(
                     ["Sempre", "Ultimi 7 Giorni", "Ultimi 30 Giorni", "Intervallo Personalizzato"],
                     label="Seleziona Intervallo Date", value="Sempre", scale=3
                 )
-                with gr.Column(scale=2):
+                with gr.Column(scale=2): # Ensure this column is defined for date pickers
                     custom_start_date_picker = gr.DateTime(label="Data Inizio", visible=False, include_time=False, type="datetime")
                     custom_end_date_picker = gr.DateTime(label="Data Fine", visible=False, include_time=False, type="datetime")
 
@@ -226,7 +239,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                 inputs=[date_filter_selector],
                 outputs=[custom_start_date_picker, custom_end_date_picker]
             )
-
+            
             plot_configs = [
                 {"label": "Numero di Follower nel Tempo", "id": "followers_count", "section": "Dinamiche dei Follower"},
                 {"label": "Tasso di Crescita Follower", "id": "followers_growth_rate", "section": "Dinamiche dei Follower"},
@@ -250,162 +263,325 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
             ]
             assert len(plot_configs) == 19, "Mancata corrispondenza in plot_configs e grafici attesi."
 
-            active_panel_action_state = gr.State(None)
-            explored_plot_id_state = gr.State(None)
-
-            plot_ui_objects = {}
+            active_panel_action_state = gr.State(None) # Stores {"plot_id": "...", "type": "insights/formula"}
+            explored_plot_id_state = gr.State(None) # Stores plot_id of the currently "explored" (maximized) plot
+            
+            plot_ui_objects = {} # Will be populated by build_analytics_tab_plot_area
 
             with gr.Row(equal_height=False):
                 with gr.Column(scale=8) as plots_area_col:
                     plot_ui_objects = build_analytics_tab_plot_area(plot_configs)
-
-                with gr.Column(scale=4, visible=False) as global_actions_column_ui:
-                    gr.Markdown("### 💡 Contenuto Generato")
-                    global_actions_markdown_ui = gr.Markdown("Clicca un pulsante (💣, ƒ) su un grafico per vedere il contenuto qui.")
-
-            # --- Event Handler for Insights and Formula Buttons ---
-            def handle_panel_action(plot_id_clicked, action_type, current_active_action_from_state, current_token_state_val):
-                logging.info(f"Azione '{action_type}' per grafico: {plot_id_clicked}. Attualmente attivo da stato: {current_active_action_from_state}")
-
-                if not plot_ui_objects or plot_id_clicked not in plot_ui_objects:
-                    logging.error(f"plot_ui_objects non popolato o plot_id {plot_id_clicked} non trovato durante handle_panel_action.")
-                    error_updates = [gr.update(visible=False), "Errore: Componenti UI non pronti.", None] + [gr.update() for _ in range(2 * len(plot_configs))]
-                    return error_updates
-
-                clicked_plot_label = plot_ui_objects.get(plot_id_clicked, {}).get("label", "Grafico Selezionato")
+                
+                # --- UPDATED GLOBAL ACTIONS COLUMN with CHATBOT ---
+                with gr.Column(scale=4, visible=False) as global_actions_column_ui: # This column's visibility is controlled
+                    gr.Markdown("### 💡 Azioni Contestuali Grafico") # General title for the panel
+                    
+                    # Chatbot components (initially hidden)
+                    insights_chatbot_ui = gr.Chatbot(
+                        label="Chat Insights", type="messages", height=450, 
+                        bubble_full_width=False, visible=False, show_label=False,
+                        placeholder="L'analisi AI del grafico apparirà qui. Fai domande di approfondimento!"
+                    )
+                    insights_chat_input_ui = gr.Textbox(
+                        label="La tua domanda:", placeholder="Chiedi all'AI riguardo a questo grafico...", 
+                        lines=2, visible=False, show_label=False
+                    )
+                    with gr.Row(visible=False) as insights_suggestions_row_ui:
+                        insights_suggestion_1_btn = gr.Button(value="Suggerimento 1", size="sm", min_width=50)
+                        insights_suggestion_2_btn = gr.Button(value="Suggerimento 2", size="sm", min_width=50)
+                        insights_suggestion_3_btn = gr.Button(value="Suggerimento 3", size="sm", min_width=50)
+                    
+                    # Formula display component (initially hidden)
+                    formula_display_markdown_ui = gr.Markdown(
+                        "I dettagli sulla formula/metodologia appariranno qui.", visible=False
+                    )
+                # --- END UPDATED GLOBAL ACTIONS COLUMN ---
+
+            # --- Event Handler for Insights (Chatbot) and Formula Buttons ---
+            async def handle_panel_action(
+                plot_id_clicked: str, 
+                action_type: str, # "insights" or "formula"
+                current_active_action_from_state: dict, # Stored active action {"plot_id": ..., "type": ...}
+                # token_state_val: dict, # No longer directly needed here for chat/formula text
+                current_chat_histories: dict, # from chat_histories_st
+                current_chat_plot_id: str # from current_chat_plot_id_st
+            ):
+                logging.info(f"Azione '{action_type}' per grafico: {plot_id_clicked}. Attualmente attivo: {current_active_action_from_state}")
+                
+                # Find the label for the clicked plot_id
+                clicked_plot_config = next((p for p in plot_configs if p["id"] == plot_id_clicked), None)
+                if not clicked_plot_config:
+                    logging.error(f"Configurazione non trovata per plot_id {plot_id_clicked}")
+                    # Basic error feedback if needed, though this shouldn't happen if UI is built correctly
+                    return [gr.update(visible=False)] * 7 + [current_active_action_from_state, current_chat_plot_id, current_chat_histories] + [gr.update() for _ in range(2 * len(plot_configs))]
+
+                clicked_plot_label = clicked_plot_config["label"]
                 
                 hypothetical_new_active_state = {"plot_id": plot_id_clicked, "type": action_type}
                 is_toggling_off = current_active_action_from_state == hypothetical_new_active_state
                 
                 new_active_action_state_to_set = None
-                content_text = ""
-                action_col_visible = False
+                action_col_visible_update = gr.update(visible=True)
+                
+                # Default visibility for components in the action column
+                insights_chatbot_visible_update = gr.update(visible=False)
+                insights_chat_input_visible_update = gr.update(visible=False)
+                insights_suggestions_row_visible_update = gr.update(visible=False)
+                formula_display_visible_update = gr.update(visible=False)
+                
+                # Chat-specific updates
+                chatbot_content_update = gr.update()
+                suggestion_1_update = gr.update()
+                suggestion_2_update = gr.update()
+                suggestion_3_update = gr.update()
+                new_current_chat_plot_id = current_chat_plot_id # Preserve by default
+                updated_chat_histories = current_chat_histories # Preserve by default
+
+                # Formula-specific updates
+                formula_content_update = gr.update()
 
                 if is_toggling_off:
                     new_active_action_state_to_set = None
-                    content_text = f"Pannello {action_type.capitalize()} per '{clicked_plot_label}' chiuso."
-                    action_col_visible = False
+                    action_col_visible_update = gr.update(visible=False)
+                    new_current_chat_plot_id = None # Clear active chat plot ID when panel closes
                     logging.info(f"Chiusura pannello {action_type} per {plot_id_clicked}")
                 else:
                     new_active_action_state_to_set = hypothetical_new_active_state
-                    action_col_visible = True
                     if action_type == "insights":
-                        # TODO: Implementare generazione insight reali
-                        content_text = f"**Approfondimenti per: {clicked_plot_label}**\n\nID Grafico: `{plot_id_clicked}`.\n(Placeholder generazione insight AI)"
+                        insights_chatbot_visible_update = gr.update(visible=True)
+                        insights_chat_input_visible_update = gr.update(visible=True)
+                        insights_suggestions_row_visible_update = gr.update(visible=True)
+                        
+                        new_current_chat_plot_id = plot_id_clicked
+                        chat_history_for_this_plot = current_chat_histories.get(plot_id_clicked, [])
+                        
+                        if not chat_history_for_this_plot: # First time opening chat for this plot
+                            initial_insight_msg, suggestions = get_initial_insight_and_suggestions(plot_id_clicked, clicked_plot_label)
+                            chat_history_for_this_plot = [initial_insight_msg]
+                            updated_chat_histories = current_chat_histories.copy()
+                            updated_chat_histories[plot_id_clicked] = chat_history_for_this_plot
+                        else: # History exists, get suggestions again (or could store them)
+                            _, suggestions = get_initial_insight_and_suggestions(plot_id_clicked, clicked_plot_label)
+
+                        chatbot_content_update = gr.update(value=chat_history_for_this_plot)
+                        suggestion_1_update = gr.update(value=suggestions[0])
+                        suggestion_2_update = gr.update(value=suggestions[1])
+                        suggestion_3_update = gr.update(value=suggestions[2])
+                        logging.info(f"Apertura pannello CHAT per {plot_id_clicked} ('{clicked_plot_label}')")
+
                     elif action_type == "formula":
+                        formula_display_visible_update = gr.update(visible=True)
                         formula_key = PLOT_ID_TO_FORMULA_KEY_MAP.get(plot_id_clicked)
+                        formula_text = f"**Formula/Metodologia per: {clicked_plot_label}**\n\nID Grafico: `{plot_id_clicked}`.\n\n"
                         if formula_key and formula_key in PLOT_FORMULAS:
                             formula_data = PLOT_FORMULAS[formula_key]
-                            content_text = f"### {formula_data['title']}\n\n"
-                            content_text += f"**Descrizione:**\n{formula_data['description']}\n\n"
-                            content_text += "**Come viene calcolato:**\n" # Titolo sezione in italiano
+                            formula_text += f"### {formula_data['title']}\n\n"
+                            formula_text += f"**Descrizione:**\n{formula_data['description']}\n\n"
+                            formula_text += "**Come viene calcolato:**\n"
                             for step in formula_data['calculation_steps']:
-                                content_text += f"{step}\n" # Rimosso il "-" per evitare doppio bullet point
+                                formula_text += f"- {step}\n"
                         else:
-                            content_text = f"**Formula/Metodologia per: {clicked_plot_label}**\n\nID Grafico: `{plot_id_clicked}`.\n(Nessuna informazione dettagliata sulla formula trovata per questo ID grafico in `formulas.py`)"
-                        logging.info(f"Visualizzazione formula per {plot_id_clicked} (mappato a {formula_key})")
-                    logging.info(f"Apertura/passaggio a pannello {action_type} per {plot_id_clicked}")
-
-                all_button_updates = []
+                            formula_text += "(Nessuna informazione dettagliata sulla formula trovata per questo ID grafico in `formulas.py`)"
+                        formula_content_update = gr.update(value=formula_text)
+                        new_current_chat_plot_id = None # Clear active chat plot ID when formula panel opens
+                        logging.info(f"Apertura pannello FORMULA per {plot_id_clicked} (mappato a {formula_key})")
+                
+                # Update button icons
+                all_button_icon_updates = []
                 for cfg_item in plot_configs:
                     p_id_iter = cfg_item["id"]
-                    if p_id_iter in plot_ui_objects:
-                        if new_active_action_state_to_set == {"plot_id": p_id_iter, "type": "insights"}:
-                            all_button_updates.append(gr.update(value=ACTIVE_ICON))
-                        else:
-                            all_button_updates.append(gr.update(value=BOMB_ICON))
-
-                        if new_active_action_state_to_set == {"plot_id": p_id_iter, "type": "formula"}:
-                            all_button_updates.append(gr.update(value=ACTIVE_ICON))
-                        else:
-                            all_button_updates.append(gr.update(value=FORMULA_ICON))
+                    # Insights (Bomb) button
+                    if new_active_action_state_to_set == {"plot_id": p_id_iter, "type": "insights"}:
+                        all_button_icon_updates.append(gr.update(value=ACTIVE_ICON))
                     else:
-                        all_button_updates.extend([gr.update(), gr.update()])
+                        all_button_icon_updates.append(gr.update(value=BOMB_ICON))
+                    # Formula button
+                    if new_active_action_state_to_set == {"plot_id": p_id_iter, "type": "formula"}:
+                        all_button_icon_updates.append(gr.update(value=ACTIVE_ICON))
+                    else:
+                        all_button_icon_updates.append(gr.update(value=FORMULA_ICON))
                 
                 final_updates = [
-                    gr.update(visible=action_col_visible),
-                    gr.update(value=content_text),
-                    new_active_action_state_to_set
-                ] + all_button_updates
+                    action_col_visible_update,
+                    insights_chatbot_visible_update, chatbot_content_update,
+                    insights_chat_input_visible_update,
+                    insights_suggestions_row_visible_update, suggestion_1_update, suggestion_2_update, suggestion_3_update,
+                    formula_display_visible_update, formula_content_update,
+                    new_active_action_state_to_set, # For active_panel_action_state
+                    new_current_chat_plot_id,      # For current_chat_plot_id_st
+                    updated_chat_histories         # For chat_histories_st
+                ] + all_button_icon_updates
                 
                 return final_updates
 
+            # --- Event Handler for Chat Message Submission ---
+            async def handle_chat_message_submission(
+                user_message: str, 
+                current_plot_id: str, # From current_chat_plot_id_st
+                chat_histories: dict, # From chat_histories_st
+                # token_state_val: dict # If needed for context, but LLM should get context from history
+            ):
+                if not current_plot_id or not user_message.strip():
+                    # Return current history for the plot_id if message is empty
+                    history_for_plot = chat_histories.get(current_plot_id, [])
+                    return history_for_plot, "", chat_histories # Chatbot, Textbox, Histories State
+
+                # Find plot label for context
+                plot_config = next((p for p in plot_configs if p["id"] == current_plot_id), None)
+                plot_label = plot_config["label"] if plot_config else "Grafico Selezionato"
+
+                history_for_plot = chat_histories.get(current_plot_id, []).copy()
+                history_for_plot.append({"role": "user", "content": user_message})
+                
+                # Show user message immediately
+                yield history_for_plot, "", chat_histories # Update chatbot, clear input, keep histories
+
+                # Generate bot response
+                bot_response_text = await generate_llm_response(user_message, current_plot_id, plot_label, history_for_plot)
+                
+                history_for_plot.append({"role": "assistant", "content": bot_response_text})
+                
+                updated_chat_histories = chat_histories.copy()
+                updated_chat_histories[current_plot_id] = history_for_plot
+                
+                yield history_for_plot, "", updated_chat_histories # Final update
+
+            # --- Event Handler for Suggested Question Click ---
+            async def handle_suggested_question_click(
+                suggestion_text: str,
+                current_plot_id: str, # From current_chat_plot_id_st
+                chat_histories: dict, # From chat_histories_st
+                # token_state_val: dict
+            ):
+                # This will effectively call handle_chat_message_submission
+                # We need to ensure the output signature matches what Gradio expects for this button's .click event
+                # which is the same as handle_chat_message_submission's output.
+                # The 'yield' pattern is for streaming, if handle_chat_message_submission uses it, this should too.
+                
+                # Simulate the submission process
+                if not current_plot_id or not suggestion_text.strip():
+                    history_for_plot = chat_histories.get(current_plot_id, [])
+                    return history_for_plot, "", chat_histories 
+
+                plot_config = next((p for p in plot_configs if p["id"] == current_plot_id), None)
+                plot_label = plot_config["label"] if plot_config else "Grafico Selezionato"
+
+                history_for_plot = chat_histories.get(current_plot_id, []).copy()
+                history_for_plot.append({"role": "user", "content": suggestion_text})
+                
+                yield history_for_plot, "", chat_histories # Update chatbot, clear input (though no input here), keep histories
+
+                bot_response_text = await generate_llm_response(suggestion_text, current_plot_id, plot_label, history_for_plot)
+                history_for_plot.append({"role": "assistant", "content": bot_response_text})
+                
+                updated_chat_histories = chat_histories.copy()
+                updated_chat_histories[current_plot_id] = history_for_plot
+                
+                yield history_for_plot, "", updated_chat_histories
+
+
+            # --- Explore button logic (remains largely the same) ---
             def handle_explore_click(plot_id_clicked, current_explored_plot_id_from_state):
+                # (This function's logic for showing/hiding plot panels based on explore state)
+                # ... (original logic from user's code) ...
                 logging.info(f"Click su Esplora per: {plot_id_clicked}. Attualmente esplorato da stato: {current_explored_plot_id_from_state}")
-
                 if not plot_ui_objects:
                     logging.error("plot_ui_objects non popolato durante handle_explore_click.")
-                    return [current_explored_plot_id_from_state] + [gr.update() for _ in range(2 * len(plot_configs))] 
-
+                    # Need to return updates for all explore buttons and panels
+                    updates_for_missing_ui = [current_explored_plot_id_from_state] 
+                    for _ in plot_configs:
+                        updates_for_missing_ui.extend([gr.update(), gr.update()]) # panel, button
+                    return updates_for_missing_ui
+                
                 new_explored_id_to_set = None
                 is_toggling_off = (plot_id_clicked == current_explored_plot_id_from_state)
-
+                
                 if is_toggling_off:
                     new_explored_id_to_set = None
                     logging.info(f"Interruzione esplorazione grafico: {plot_id_clicked}")
                 else:
                     new_explored_id_to_set = plot_id_clicked
                     logging.info(f"Esplorazione grafico: {plot_id_clicked}")
-                
+                                
                 panel_and_button_updates = []
                 for cfg in plot_configs:
                     p_id = cfg["id"]
                     if p_id in plot_ui_objects:
                         panel_visible = not new_explored_id_to_set or (p_id == new_explored_id_to_set)
-                        panel_and_button_updates.append(gr.update(visible=panel_visible))
-                        
-                        if p_id == new_explored_id_to_set:
+                        panel_and_button_updates.append(gr.update(visible=panel_visible)) # Panel component
+                                                
+                        if p_id == new_explored_id_to_set: # Explored button icon
                             panel_and_button_updates.append(gr.update(value=ACTIVE_ICON))
                         else:
                             panel_and_button_updates.append(gr.update(value=EXPLORE_ICON))
-                    else:
+                    else: # Should not happen if UI built correctly
                         panel_and_button_updates.extend([gr.update(), gr.update()])
-                
-                final_updates = [new_explored_id_to_set] + panel_and_button_updates
+                                
+                final_updates = [new_explored_id_to_set] + panel_and_button_updates # state + N*(panel_update, button_update)
                 return final_updates
 
-            action_buttons_outputs_list = [
-                global_actions_column_ui,
-                global_actions_markdown_ui,
-                active_panel_action_state
+            # --- Define output lists for event handlers ---
+            
+            # Outputs for handle_panel_action (insights/formula clicks)
+            action_panel_outputs_list = [
+                global_actions_column_ui, # Column visibility
+                insights_chatbot_ui, insights_chatbot_ui, # Visibility, Content for chatbot
+                insights_chat_input_ui, # Visibility for chat input
+                insights_suggestions_row_ui, insights_suggestion_1_btn, insights_suggestion_2_btn, insights_suggestion_3_btn, # Row visibility, button content
+                formula_display_markdown_ui, formula_display_markdown_ui, # Visibility, Content for formula
+                active_panel_action_state, 
+                current_chat_plot_id_st,
+                chat_histories_st
             ]
-            for cfg_item_action in plot_configs:
+            for cfg_item_action in plot_configs: # Add bomb and formula button icon updates
                 pid_action = cfg_item_action["id"]
                 if pid_action in plot_ui_objects:
-                    action_buttons_outputs_list.append(plot_ui_objects[pid_action]["bomb_button"])
-                    action_buttons_outputs_list.append(plot_ui_objects[pid_action]["formula_button"])
-                else:
-                    action_buttons_outputs_list.extend([None, None])
+                    action_panel_outputs_list.append(plot_ui_objects[pid_action]["bomb_button"])
+                    action_panel_outputs_list.append(plot_ui_objects[pid_action]["formula_button"])
+                else: # Should not happen
+                    action_panel_outputs_list.extend([None, None]) 
 
+            # Outputs for handle_explore_click
             explore_buttons_outputs_list = [explored_plot_id_state]
             for cfg_item_explore in plot_configs:
                 pid_explore = cfg_item_explore["id"]
                 if pid_explore in plot_ui_objects:
                     explore_buttons_outputs_list.append(plot_ui_objects[pid_explore]["panel_component"])
                     explore_buttons_outputs_list.append(plot_ui_objects[pid_explore]["explore_button"])
-                else:
+                else: # Should not happen
                     explore_buttons_outputs_list.extend([None, None])
 
-            action_click_inputs = [active_panel_action_state, token_state]
+            # Inputs for action clicks (insights/formula)
+            action_click_inputs = [
+                active_panel_action_state, 
+                # token_state, # No longer passing full token_state if not needed by handle_panel_action
+                chat_histories_st,
+                current_chat_plot_id_st
+            ]
+            # Inputs for explore clicks
             explore_click_inputs = [explored_plot_id_state]
 
+            # Wire up action and explore buttons
             for config_item in plot_configs:
                 plot_id = config_item["id"]
+                plot_label = config_item["label"] # Get label for context
                 if plot_id in plot_ui_objects:
                     ui_obj = plot_ui_objects[plot_id]
-
+                    # Insights (Bomb) Button
                     ui_obj["bomb_button"].click(
-                        fn=lambda current_active_val, current_token_val, p_id=plot_id: handle_panel_action(p_id, "insights", current_active_val, current_token_val),
-                        inputs=action_click_inputs,
-                        outputs=action_buttons_outputs_list,
+                        fn=lambda current_active_val, current_chats_val, current_chat_pid, p_id=plot_id: handle_panel_action(p_id, "insights", current_active_val, current_chats_val, current_chat_pid),
+                        inputs=action_click_inputs, # current_active_action_from_state, current_chat_histories, current_chat_plot_id
+                        outputs=action_panel_outputs_list,
                         api_name=f"action_insights_{plot_id}"
                     )
+                    # Formula Button
                     ui_obj["formula_button"].click(
-                        fn=lambda current_active_val, current_token_val, p_id=plot_id: handle_panel_action(p_id, "formula", current_active_val, current_token_val),
+                        fn=lambda current_active_val, current_chats_val, current_chat_pid, p_id=plot_id: handle_panel_action(p_id, "formula", current_active_val, current_chats_val, current_chat_pid),
                         inputs=action_click_inputs,
-                        outputs=action_buttons_outputs_list,
+                        outputs=action_panel_outputs_list,
                         api_name=f"action_formula_{plot_id}"
                     )
+                    # Explore Button
                     ui_obj["explore_button"].click(
                         fn=lambda current_explored_val, p_id=plot_id: handle_explore_click(p_id, current_explored_val),
                         inputs=explore_click_inputs,
@@ -414,74 +590,130 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
                     )
                 else:
                     logging.warning(f"Oggetto UI per plot_id '{plot_id}' non trovato durante il tentativo di associare i gestori di click.")
+            
+            # Wire up chat input submission
+            chat_submission_outputs = [insights_chatbot_ui, insights_chat_input_ui, chat_histories_st]
+            insights_chat_input_ui.submit(
+                fn=handle_chat_message_submission,
+                inputs=[insights_chat_input_ui, current_chat_plot_id_st, chat_histories_st], # token_state removed
+                outputs=chat_submission_outputs,
+                api_name="submit_chat_message"
+            )
+
+            # Wire up suggested question buttons
+            insights_suggestion_1_btn.click(
+                fn=handle_suggested_question_click,
+                inputs=[insights_suggestion_1_btn, current_chat_plot_id_st, chat_histories_st], # token_state removed
+                outputs=chat_submission_outputs, # Same outputs as direct message submission
+                api_name="click_suggestion_1"
+            )
+            insights_suggestion_2_btn.click(
+                fn=handle_suggested_question_click,
+                inputs=[insights_suggestion_2_btn, current_chat_plot_id_st, chat_histories_st], # token_state removed
+                outputs=chat_submission_outputs,
+                api_name="click_suggestion_2"
+            )
+            insights_suggestion_3_btn.click(
+                fn=handle_suggested_question_click,
+                inputs=[insights_suggestion_3_btn, current_chat_plot_id_st, chat_histories_st], # token_state removed
+                outputs=chat_submission_outputs,
+                api_name="click_suggestion_3"
+            )
 
-            def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val):
-                logging.info("Aggiornamento di tutti gli elementi UI delle analisi e reset delle azioni.")
+
+            # --- Function to refresh all analytics UI elements (plots and action panel states) ---
+            def refresh_all_analytics_ui_elements(current_token_state, date_filter_val, custom_start_val, custom_end_val, current_chat_histories):
+                logging.info("Aggiornamento di tutti gli elementi UI delle analisi e reset delle azioni/chat.")
                 plot_generation_results = update_analytics_plots_figures(
                     current_token_state, date_filter_val, custom_start_val, custom_end_val
                 )
-
                 status_message_update = plot_generation_results[0]
-                generated_plot_figures = plot_generation_results[1:] 
-
-                all_updates = [status_message_update]
-
+                generated_plot_figures = plot_generation_results[1:]
+                
+                all_updates = [status_message_update] # For analytics_status_md
+                
+                # Add plot figure updates
                 for i in range(len(plot_configs)): 
                     if i < len(generated_plot_figures):
-                        all_updates.append(generated_plot_figures[i])
-                    else:
+                        all_updates.append(generated_plot_figures[i]) # Plot component
+                    else: # Should not happen if update_analytics_plots_figures is correct
                         all_updates.append(create_placeholder_plot("Errore Figura", f"Figura mancante per grafico {plot_configs[i]['id']}"))
                 
-                all_updates.append(gr.update(visible=False))
-                all_updates.append(gr.update(value="Clicca un pulsante (💣, ƒ) su un grafico..."))
-                all_updates.append(None)
-
+                # Reset global actions column and its content
+                all_updates.extend([
+                    gr.update(visible=False), # global_actions_column_ui
+                    gr.update(value=[], visible=False), # insights_chatbot_ui (clear history, hide)
+                    gr.update(value="", visible=False), # insights_chat_input_ui (clear text, hide)
+                    gr.update(visible=False), # insights_suggestions_row_ui
+                    gr.update(value="Suggerimento 1", visible=True), # insights_suggestion_1_btn (reset text, keep visible within hidden row)
+                    gr.update(value="Suggerimento 2", visible=True), # insights_suggestion_2_btn
+                    gr.update(value="Suggerimento 3", visible=True), # insights_suggestion_3_btn
+                    gr.update(value="I dettagli sulla formula/metodologia appariranno qui.", visible=False), # formula_display_markdown_ui
+                    None, # active_panel_action_state (reset to None)
+                    None, # current_chat_plot_id_st (reset to None)
+                    current_chat_histories, # chat_histories_st (preserve existing histories across refresh unless explicitly cleared)
+                                            # If you want to clear all chats on refresh: use `{}` instead of current_chat_histories
+                ])
+                
+                # Reset action buttons (bomb, formula, explore icons) and plot panel visibility (for explore)
                 for cfg in plot_configs: 
                     pid = cfg["id"]
                     if pid in plot_ui_objects:
-                        all_updates.append(gr.update(value=BOMB_ICON))
-                        all_updates.append(gr.update(value=FORMULA_ICON))
-                        all_updates.append(gr.update(value=EXPLORE_ICON))
-                        all_updates.append(gr.update(visible=True))
-                    else:
+                        all_updates.append(gr.update(value=BOMB_ICON))    # bomb_button
+                        all_updates.append(gr.update(value=FORMULA_ICON)) # formula_button
+                        all_updates.append(gr.update(value=EXPLORE_ICON)) # explore_button
+                        all_updates.append(gr.update(visible=True))       # panel_component (reset to default visibility)
+                    else: # Should not happen
                         all_updates.extend([None, None, None, None])
                 
-                all_updates.append(None)
-                logging.info(f"Preparati {len(all_updates)} aggiornamenti per il refresh delle analisi.")
+                all_updates.append(None) # explored_plot_id_state (reset to None)
+                
+                logging.info(f"Preparati {len(all_updates)} aggiornamenti per il refresh completo delle analisi.")
                 return all_updates
 
-            apply_filter_and_sync_outputs_list = [analytics_status_md]
-            
-            for config_item_filter_sync in plot_configs: 
+            # Define the output list for apply_filter_btn and sync events that refresh analytics
+            apply_filter_and_sync_outputs_list = [analytics_status_md] # Status message
+            # Add plot components
+            for config_item_filter_sync in plot_configs:
                 pid_filter_sync = config_item_filter_sync["id"]
                 if pid_filter_sync in plot_ui_objects and "plot_component" in plot_ui_objects[pid_filter_sync]:
                     apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync]["plot_component"])
                 else:
-                    apply_filter_and_sync_outputs_list.append(None)
+                    apply_filter_and_sync_outputs_list.append(None) # Placeholder if UI object not found
             
+            # Add updates for the global actions column and its contents + states
             apply_filter_and_sync_outputs_list.extend([
-                global_actions_column_ui,
-                global_actions_markdown_ui,
-                active_panel_action_state
+                global_actions_column_ui,       # Column visibility
+                insights_chatbot_ui,            # Chatbot content and visibility
+                insights_chat_input_ui,         # Chat input text and visibility
+                insights_suggestions_row_ui,    # Suggestions row visibility
+                insights_suggestion_1_btn,      # Suggestion button 1 text/visibility
+                insights_suggestion_2_btn,      # Suggestion button 2 text/visibility
+                insights_suggestion_3_btn,      # Suggestion button 3 text/visibility
+                formula_display_markdown_ui,    # Formula markdown content and visibility
+                active_panel_action_state,      # State for active panel
+                current_chat_plot_id_st,        # State for current chat plot ID
+                chat_histories_st               # State for all chat histories
             ])
-            
-            for cfg_filter_sync_btns in plot_configs: 
+
+            # Add updates for individual plot action buttons (bomb, formula, explore) and plot panels (explore visibility)
+            for cfg_filter_sync_btns in plot_configs:
                 pid_filter_sync_btns = cfg_filter_sync_btns["id"]
                 if pid_filter_sync_btns in plot_ui_objects:
                     apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["bomb_button"])
                     apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["formula_button"])
                     apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["explore_button"])
-                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["panel_component"])
+                    apply_filter_and_sync_outputs_list.append(plot_ui_objects[pid_filter_sync_btns]["panel_component"]) # For explore visibility
                 else:
-                    apply_filter_and_sync_outputs_list.extend([None, None, None, None])
-
-            apply_filter_and_sync_outputs_list.append(explored_plot_id_state)
+                    apply_filter_and_sync_outputs_list.extend([None, None, None, None]) # Placeholders
+            
+            apply_filter_and_sync_outputs_list.append(explored_plot_id_state) # State for explored plot ID
+            
+            logging.info(f"Output totali definiti per apply_filter/sync: {len(apply_filter_and_sync_outputs_list)}")
             
-            logging.info(f"Output totali per apply_filter/sync: {len(apply_filter_and_sync_outputs_list)}")
-
             apply_filter_btn.click(
                 fn=refresh_all_analytics_ui_elements,
-                inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
+                inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
                 outputs=apply_filter_and_sync_outputs_list,
                 show_progress="full"
             )
@@ -499,35 +731,38 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky"),
         with gr.TabItem("4️⃣ Statistiche Follower", id="tab_follower_stats"):
             refresh_follower_stats_btn = gr.Button("🔄 Aggiorna Visualizzazione Statistiche Follower", variant="secondary")
             follower_stats_html = gr.HTML("Statistiche follower...")
-            with gr.Row():
+            with gr.Row(): # Ensure plots are within rows or columns for layout
                 fs_plot_monthly_gains = gr.Plot(label="Guadagni Mensili Follower")
             with gr.Row():
                 fs_plot_seniority = gr.Plot(label="Follower per Anzianità (Top 10 Organici)")
                 fs_plot_industry = gr.Plot(label="Follower per Settore (Top 10 Organici)")
-
+            
             refresh_follower_stats_btn.click(
                 fn=run_follower_stats_tab_display, inputs=[token_state],
                 outputs=[follower_stats_html, fs_plot_monthly_gains, fs_plot_seniority, fs_plot_industry],
                 show_progress="full"
             )
-
+            
+    # Sync data flow
     sync_event_part1 = sync_data_btn.click(
         fn=sync_all_linkedin_data_orchestrator,
         inputs=[token_state], outputs=[sync_status_html_output, token_state], show_progress="full"
     )
-    sync_event_part2 = sync_event_part1.then(
-        fn=process_and_store_bubble_token,
+    sync_event_part2 = sync_event_part1.then( # Use .then() for sequential execution
+        fn=process_and_store_bubble_token, # This function was defined in state_manager.py
         inputs=[url_user_token_display, org_urn_display, token_state],
-        outputs=[status_box, token_state, sync_data_btn], show_progress=False
+        outputs=[status_box, token_state, sync_data_btn], show_progress=False # Assuming this is correct from original
     )
     sync_event_part3 = sync_event_part2.then(
-        fn=display_main_dashboard,
+        fn=display_main_dashboard, # This function was defined in ui_generators.py
         inputs=[token_state], outputs=[dashboard_display_html], show_progress=False
     )
+    # After sync, refresh analytics tab including plots and resetting chat/formula panels
     sync_event_final = sync_event_part3.then(
         fn=refresh_all_analytics_ui_elements,
-        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker],
-        outputs=apply_filter_and_sync_outputs_list, show_progress="full"
+        inputs=[token_state, date_filter_selector, custom_start_date_picker, custom_end_date_picker, chat_histories_st],
+        outputs=apply_filter_and_sync_outputs_list, # Use the comprehensive list
+        show_progress="full"
     )
 
 if __name__ == "__main__":
@@ -537,10 +772,10 @@ if __name__ == "__main__":
        not os.environ.get(BUBBLE_API_KEY_PRIVATE_ENV_VAR) or \
        not os.environ.get(BUBBLE_API_ENDPOINT_ENV_VAR):
         logging.warning("ATTENZIONE: Variabili d'ambiente Bubble non completamente impostate.")
-
+    
     try:
         logging.info(f"Versione Matplotlib: {matplotlib.__version__}, Backend: {matplotlib.get_backend()}")
-    except ImportError:
-        logging.error("Matplotlib non è installato. I grafici non verranno generati.")
-
-    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    except ImportError: # Matplotlib might not be an explicit import if only used by plot generators
+        logging.warning("Matplotlib non trovato direttamente, ma potrebbe essere usato dai generatori di grafici.")
+        
+    app.launch(server_name="0.0.0.0", server_port=7860, debug=True)