Update app.py

app.py

@@ -9,7 +9,7 @@ import numpy as np
 import faiss
 import pandas as pd
 from huggingface_hub import CommitScheduler
-from datetime import datetime
+from datetime import datetime, timedelta
 import uuid
 from user_agents import parse as parse_ua
 import schedule
@@ -46,54 +46,6 @@ scheduler = CommitScheduler(
 
 # --- Globala variabler ---
 last_log = None  # Sparar loggdata från senaste svar för feedback
-# Lägg till i början av skriptet med andra globala variabler
-active_sessions = {}  # Dictionary för att spåra aktiva sessioner: {session_id: (senaste_tid, meddelanden)}
-# --- Slack Webhook funktionalitet ---
-def send_report_to_slack(subject, content):
-    """Skickar rapport till Slack via webhook."""
-    webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
-    if not webhook_url:
-        print("Slack webhook URL saknas i miljövariabler")
-        return False
-    
-    try:
-        print(f"Skickar rapport till Slack: {subject}")
-        
-        # Formatera meddelandet för Slack
-        message = {
-            "blocks": [
-                {
-                    "type": "header",
-                    "text": {
-                        "type": "plain_text",
-                        "text": subject
-                    }
-                },
-                {
-                    "type": "section",
-                    "text": {
-                        "type": "mrkdwn",
-                        "text": content
-                    }
-                }
-            ]
-        }
-        
-        response = requests.post(
-            webhook_url,
-            json=message,
-            headers={"Content-Type": "application/json"}
-        )
-        
-        if response.status_code == 200:
-            print(f"Slack-rapport skickad framgångsrikt")
-            return True
-        else:
-            print(f"Slack-anrop misslyckades: {response.status_code}, {response.text}")
-            return False
-    except Exception as e:
-        print(f"Fel vid sändning till Slack: {type(e).__name__}: {e}")
-        return False
 
 # --- Laddar textkällor ---
 def load_local_files():
@@ -234,7 +186,44 @@ def vote(data: gr.LikeData):
     with scheduler.lock:
         with open(log_file_path, "a", encoding="utf-8") as log_file:
             log_file.write(json.dumps(log_entry) + "\n")
-    # Inget utdata krävs här, Gradio hanterar färgändringarna.
+    
+    # Skicka feedback till Slack
+    try:
+        webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+        if webhook_url and feedback_type == "down":  # Skicka bara negativ feedback
+            feedback_message = {
+                "blocks": [
+                    {
+                        "type": "header",
+                        "text": {
+                            "type": "plain_text",
+                            "text": "⚠️ Negativ feedback registrerad"
+                        }
+                    },
+                    {
+                        "type": "section",
+                        "text": {
+                            "type": "mrkdwn",
+                            "text": f"*Fråga:* {last_log.get('user_message', 'Okänd fråga')}"
+                        }
+                    },
+                    {
+                        "type": "section",
+                        "text": {
+                            "type": "mrkdwn", 
+                            "text": f"*Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry.get('bot_reply', '')) > 300 else ''}"
+                        }
+                    }
+                ]
+            }
+            # Skicka asynkront
+            threading.Thread(
+                target=lambda: requests.post(webhook_url, json=feedback_message),
+                daemon=True
+            ).start()
+    except Exception as e:
+        print(f"Kunde inte skicka feedback till Slack: {e}")
+    
     return
 
 # --- Rapportering ---
@@ -287,260 +276,132 @@ def get_feedback_stats(logs):
     
     return feedback_count, negative_feedback_examples
 
-# Skicka statusrapport till Slack
-def send_status_slack():
-    """Skickar ett statusmeddelande till Slack med utökad statistik."""
-    print("Försöker skicka status-rapport till Slack...")
+# --- Slack-integration ---
+def simple_status_report():
+    """Förenklad statusrapport som garanterar att data skickas."""
+    print("Skickar förenklad statusrapport till Slack...")
     
     try:
-        # Samla in statistik
-        logs = read_logs()
-        
-        # Beräkna tid för 24 timmar sedan och 14 dagar sedan
-        now = datetime.now()
-        yesterday = now - timedelta(days=1)
-        two_weeks_ago = now - timedelta(days=14)
-        
-        # Konvertera timestamps till datetime
-        for log in logs:
-            if 'timestamp' in log:
-                try:
-                    log['datetime'] = datetime.strptime(log['timestamp'], "%Y-%m-%d %H:%M:%S")
-                except:
-                    log['datetime'] = now  # Default om formatering misslyckas
-        
-        # Filtrera loggar för senaste 24h och 14 dagar
-        logs_24h = [log for log in logs if 'datetime' in log and log['datetime'] >= yesterday]
-        logs_14d = [log for log in logs if 'datetime' in log and log['datetime'] >= two_weeks_ago]
-        
-        # 1. Samla statistik
-        conversations = get_latest_conversations(logs)
-        feedback_stats, negative_examples = get_feedback_stats(logs)
-        
-        # Basinformation
-        total_sessions = len(set(log.get('session_id', 'unknown') for log in logs if 'session_id' in log))
-        total_questions = sum(1 for log in logs if 'user_message' in log)
-        
-        # 24h statistik
-        sessions_24h = len(set(log.get('session_id', 'unknown') for log in logs_24h if 'session_id' in log))
-        messages_24h = sum(1 for log in logs_24h if 'user_message' in log)
-        
-        # Beräkna snitt antal meddelanden per session (om minst en session finns)
-        avg_messages_per_session = round(messages_24h / sessions_24h, 2) if sessions_24h > 0 else 0
-        
-        # Snittsvarstid
-        response_times_24h = [log.get('response_time', 0) for log in logs_24h if 'response_time' in log]
-        avg_response_time = round(sum(response_times_24h) / len(response_times_24h), 2) if response_times_24h else 0
-        
-        # 14 dagars statistik
-        messages_14d = sum(1 for log in logs_14d if 'user_message' in log)
-        unique_users_14d = len(set(log.get('user_id', 'unknown') for log in logs_14d if 'user_id' in log))
-        
-        # Likes och dislikes
-        likes_24h = sum(1 for log in logs_24h if log.get('feedback') == 'up')
-        dislikes_24h = sum(1 for log in logs_24h if log.get('feedback') == 'down')
-        
-        # Browser-fördelning
-        browser_counts = {}
-        for log in logs_24h:
-            if 'browser' in log:
-                browser = log['browser']
-                browser_counts[browser] = browser_counts.get(browser, 0) + 1
+        # Läs loggfilen rad för rad för att undvika JSON-parsningsproblem
+        messages = []
+        sessions = set()
+        users = set()
+        feedback_up = 0
+        feedback_down = 0
         
-        # Sortera browsers efter antal
-        top_browsers = sorted(browser_counts.items(), key=lambda x: x[1], reverse=True)[:3]
-        browser_text = ", ".join([f"{browser}: {count}" for browser, count in top_browsers]) if top_browsers else "Ingen data"
-        
-        # 2. Formatera för Slack (Markdown)
-        slack_date = now.strftime("%Y-%m-%d")
-        subject = f"ChargeNode AI Bot - Daglig rapport {slack_date}"
+        try:
+            with open(log_file_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    try:
+                        # Försök tolka JSON-data
+                        data = json.loads(line.strip())
+                        
+                        # Samla grundläggande statistik direkt från rå data
+                        if 'user_message' in data:
+                            messages.append(data)
+                        if 'session_id' in data:
+                            sessions.add(data['session_id'])
+                        if 'user_id' in data:
+                            users.add(data['user_id'])
+                        if 'feedback' in data:
+                            if data['feedback'] == 'up':
+                                feedback_up += 1
+                            elif data['feedback'] == 'down':
+                                feedback_down += 1
+                    except json.JSONDecodeError:
+                        continue  # Hoppa över ogiltiga rader
+        except Exception as e:
+            # Om filläsning misslyckas helt, rapportera detta
+            webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+            error_payload = {
+                "text": f"⚠️ *Fel vid läsning av loggfil:* {str(e)}"
+            }
+            requests.post(webhook_url, json=error_payload)
+            return False
+            
+        # Skapa enkel statistik som garanterat fungerar
+        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        subject = f"ChargeNode AI Bot - Status {now}"
         
         content = f"""
-*ChargeNode AI Bot - Statusrapport {now.strftime('%Y-%m-%d %H:%M:%S')}*
-
-*Sammanfattning*
-- Datum: {slack_date}
-- Antal meddelanden senaste 24h: {messages_24h}
-- Unika sessioner senaste 24h: {sessions_24h}
-- Meddelanden per session (snitt): {avg_messages_per_session}
-- Snittsvarstid senaste 24h: {avg_response_time} sekunder
-- Antal meddelanden (14 dagar): {messages_14d}
-- Unika användare (14 dagar): {unique_users_14d}
-- Tumme upp senaste 24h: {likes_24h}
-- Tumme ned senaste 24h: {dislikes_24h}
-- Browser-fördelning senaste 24h: {browser_text}
-
-*Trender*
-- Totalt antal sessioner: {total_sessions}
-- Totalt antal frågor: {total_questions}
-
-*De 5 senaste frågorna*
-"""
-        
-        # Lägg till de senaste frågorna (begränsa till 5 för Slack)
-        for i, conv in enumerate(conversations[:5]):
-            content += f"""
-> *Tid:* {conv['timestamp']}
-> *Fråga:* {conv['user_message']}
-> *Svar:* {conv['bot_reply'][:150]}...
+*ChargeNode AI Bot - Statusrapport*
+
+*Basstatistik* (direkt från loggfiler)
+- Tidpunkt: {now}
+- Totalt antal meddelanden: {len(messages)}
+- Unika sessioner: {len(sessions)}
+- Unika användare: {len(users)}
+- Tumme upp: {feedback_up}
+- Tumme ned: {feedback_down}
+
+*Senaste aktivitet*
 """
         
-        # Lägg till negativ feedback
-        content += "\n*Exempel på negativ feedback*\n"
-        
-        if negative_examples:
-            for example in negative_examples[:3]:  # Begränsa till 3 för Slack
+        # Lägg till de 3 senaste meddelandena (om det finns några)
+        recent_messages = sorted(messages, key=lambda x: x.get('timestamp', ''), reverse=True)[:3]
+        if recent_messages:
+            for msg in recent_messages:
+                user_message = msg.get('user_message', 'Okänd fråga')
+                bot_reply = msg.get('bot_reply', 'Okänt svar')
+                timestamp = msg.get('timestamp', 'Okänd tid')
+                
                 content += f"""
-> *Fråga:* {example['user_message']}
-> *Svar:* {example['bot_reply'][:150]}...
+> *Tid:* {timestamp}
+> *Fråga:* {user_message[:100]}{"..." if len(user_message) > 100 else ""}
+> *Svar:* {bot_reply[:100]}{"..." if len(bot_reply) > 100 else ""}
 """
         else:
-            content += "_Inga exempel på negativ feedback hittades._"
+            content += "_Inga meddelanden hittades_"
+        
+        # Skicka till Slack med enkel webhook
+        webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+        if not webhook_url:
+            print("Slack webhook URL saknas")
+            return False
+            
+        payload = {
+            "blocks": [
+                {
+                    "type": "header",
+                    "text": {
+                        "type": "plain_text",
+                        "text": subject
+                    }
+                },
+                {
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": content
+                    }
+                }
+            ]
+        }
         
-        # 3. Skicka till Slack
-        success = send_report_to_slack(subject, content)
+        response = requests.post(webhook_url, json=payload)
         
-        if success:
-            print(f"Status-rapport skickad till Slack: {now}")
+        if response.status_code == 200:
+            print(f"Förenklad statusrapport skickad till Slack: {now}")
             return True
         else:
-            print("Status-rapport till Slack misslyckades.")
+            print(f"Slack-anrop misslyckades: {response.status_code}, {response.text}")
             return False
+            
     except Exception as e:
-        print(f"Fel vid sändning av status-rapport till Slack: {e}")
-        return False
-
-# Funktion för att skicka en avslutad session till Slack
-def send_session_to_slack(session_id, messages):
-    """Skickar en avslutad chatsession till Slack."""
-    if not messages:
-        return False
-    
-    try:
-        user_messages = [msg for msg in messages if msg.get('role') == 'user']
-        bot_messages = [msg for msg in messages if msg.get('role') == 'assistant']
-        
-        if not user_messages:
-            return False  # Ingen användarsession att rapportera
-        
-        # Räkna feedback
-        likes = sum(1 for msg in messages if msg.get('feedback') == 'up')
-        dislikes = sum(1 for msg in messages if msg.get('feedback') == 'down')
-        
-        # Hämta information om sessionen
-        first_msg_time = messages[0].get('timestamp', 'okänd tid')
-        last_msg_time = messages[-1].get('timestamp', 'okänd tid')
-        
-        # Formatera sessionen för Slack
-        subject = f"Avslutad chatsession {session_id[:8]} - {first_msg_time}"
+        print(f"Fel vid sändning av förenklad statusrapport: {e}")
         
-        content = f"""
-*Chatsession avslutad*
-- *Session ID:* {session_id[:8]}...
-- *Starttid:* {first_msg_time}
-- *Sluttid:* {last_msg_time}
-- *Antal frågor:* {len(user_messages)}
-- *Antal svar:* {len(bot_messages)}
-- *Tumme upp:* {likes}
-- *Tumme ned:* {dislikes}
-
-*Konversation:*
-"""
-        
-        # Lägg till konversationen
-        for i, msg in enumerate(messages):
-            if msg.get('role') == 'user':
-                content += f"> *Användare:* {msg.get('content', '')}\n\n"
-            elif msg.get('role') == 'assistant':
-                content += f"> *Bot:* {msg.get('content', '')[:150]}...\n\n"
-        
-        # Skicka till Slack
-        success = send_report_to_slack(subject, content)
-        return success
-    except Exception as e:
-        print(f"Fel vid sändning av sessionrapport till Slack: {e}")
+        # Skicka felmeddelande till Slack som sista utväg
+        try:
+            webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+            error_payload = {
+                "text": f"⚠️ *Fel vid generering av statusrapport:* {str(e)}"
+            }
+            requests.post(webhook_url, json=error_payload)
+        except:
+            pass
+            
         return False
 
-# Modifiera respond-funktionen för att spåra sessioner
-def respond(message, chat_history, request: gr.Request):
-    global last_log, active_sessions
-    start = time.time()
-    response = generate_answer(message)
-    elapsed = round(time.time() - start, 2)
-
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    session_id = str(uuid.uuid4())
-    user_id = request.client.host if request else "okänd"
-
-    # Resten av din befintliga kod här...
-    
-    # Spara sessionsdata för chattrapporter
-    if last_log and 'session_id' in last_log:
-        # Använd session_id från tidigare logg om det finns
-        session_id = last_log.get('session_id')
-    
-    # Uppdatera aktiva sessioner
-    if session_id not in active_sessions:
-        active_sessions[session_id] = {
-            'last_activity': datetime.now(),
-            'messages': []
-        }
-    
-    # Lägg till användarfråga
-    active_sessions[session_id]['messages'].append({
-        'role': 'user',
-        'content': message,
-        'timestamp': timestamp
-    })
-    
-    # Lägg till bot-svar
-    active_sessions[session_id]['messages'].append({
-        'role': 'assistant',
-        'content': response,
-        'timestamp': timestamp
-    })
-    
-    # Uppdatera senaste aktivitet
-    active_sessions[session_id]['last_activity'] = datetime.now()
-    
-    # Fortsätt med din befintliga kod...
-    chat_history.append({"role": "user", "content": message})
-    chat_history.append({"role": "assistant", "content": response})
-    return "", chat_history
-
-# Periodisk kontroll av inaktiva sessioner
-def check_inactive_sessions():
-    """Kontrollerar efter inaktiva sessioner och skickar dem till Slack."""
-    now = datetime.now()
-    sessions_to_remove = []
-    
-    for session_id, session_data in active_sessions.items():
-        last_activity = session_data['last_activity']
-        inactive_time = (now - last_activity).total_seconds() / 60  # i minuter
-        
-        if inactive_time >= 2:  # Inaktiv i minst 2 minuter
-            # Skicka sessionen till Slack
-            send_session_to_slack(session_id, session_data['messages'])
-            sessions_to_remove.append(session_id)
-    
-    # Ta bort skickade sessioner
-    for session_id in sessions_to_remove:
-        del active_sessions[session_id]
-
-# Uppdatera schemaläggningsfunktionen för att kontrollera inaktiva sessioner
-def run_scheduler():
-    """Kör schemaläggaren i en separat tråd."""
-    # Schemalägga rapporter till Slack
-    schedule.every().day.at("09:32").do(send_status_slack)
-    schedule.every().day.at("15:00").do(send_status_slack)
-    schedule.every().day.at("08:00").do(send_status_slack)
-    
-    # Kontrollera inaktiva sessioner var 30:e sekund
-    schedule.every(30).seconds.do(check_inactive_sessions)
-    
-    while True:
-        schedule.run_pending()
-        time.sleep(10)  # Kontrollera var 10:e sekund
 def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
     """Skickar en supportförfrågan till Slack."""
     try:
@@ -550,52 +411,89 @@ def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
             if msg['role'] == 'user':
                 chat_content += f">*Användare:* {msg['content']}\n\n"
             elif msg['role'] == 'assistant':
-                chat_content += f">*Bot:* {msg['content']}\n\n"
+                chat_content += f">*Bot:* {msg['content'][:300]}{'...' if len(msg['content']) > 300 else ''}\n\n"
         
         # Skapa rubrik och innehåll
-        subject = f"Support förfrågan från ChargeNode AI Bot - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
-        
-        content = f"""
-*Användarinformation*
-- *Områdeskod:* {områdeskod or 'Ej angiven'}
-- *Uttagsnummer:* {uttagsnummer or 'Ej angiven'}
-- *Email:* {email}
-- *Tidpunkt:* {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
-*Chatthistorik*
-{chat_content}
-"""
+        webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+        if not webhook_url:
+            print("Slack webhook URL saknas")
+            return False
+            
+        payload = {
+            "blocks": [
+                {
+                    "type": "header",
+                    "text": {
+                        "type": "plain_text",
+                        "text": f"Support förfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+                    }
+                },
+                {
+                    "type": "section",
+                    "fields": [
+                        {
+                            "type": "mrkdwn",
+                            "text": f"*Områdeskod:* {områdeskod or 'Ej angiven'}"
+                        },
+                        {
+                            "type": "mrkdwn",
+                            "text": f"*Uttagsnummer:* {uttagsnummer or 'Ej angiven'}"
+                        },
+                        {
+                            "type": "mrkdwn",
+                            "text": f"*Email:* {email}"
+                        },
+                        {
+                            "type": "mrkdwn",
+                            "text": f"*Tidpunkt:* {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+                        }
+                    ]
+                },
+                {
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": "*Chatthistorik:*\n" + chat_content
+                    }
+                }
+            ]
+        }
         
-        # Skicka till Slack
-        success = send_report_to_slack(subject, content)
-        return success
+        response = requests.post(webhook_url, json=payload)
+        if response.status_code == 200:
+            print("Support-förfrågan skickad till Slack")
+            return True
+        else:
+            print(f"Slack-anrop för support misslyckades: {response.status_code}, {response.text}")
+            return False
     except Exception as e:
         print(f"Fel vid sändning av support till Slack: {type(e).__name__}: {e}")
         return False
 
 # --- Schemaläggning av rapporter ---
 def run_scheduler():
-    """Kör schemaläggaren i en separat tråd."""
-    # Schemalägga rapporter till Slack
-    schedule.every().day.at("09:32").do(send_status_slack)
-    schedule.every().day.at("15:00").do(send_status_slack)
-    schedule.every().day.at("08:00").do(send_status_slack)
+    """Kör schemaläggaren i en separat tråd med förenklad statusrapportering."""
+    # Använd den förenklade funktionen för rapportering
+    schedule.every().day.at("08:00").do(simple_status_report)
+    schedule.every().day.at("12:00").do(simple_status_report)
+    schedule.every().day.at("17:00").do(simple_status_report)
     
     while True:
         schedule.run_pending()
         time.sleep(60)  # Kontrollera varje minut
 
-# Starta schemaläggaren i en separat tråd
+        # Starta schemaläggaren i en separat tråd
 scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
 scheduler_thread.start()
 
-# Skicka status-rapport till Slack vid uppstart
+# Kör en statusrapport direkt vid uppstart för att verifiera att allt fungerar
 try:
-    send_status_slack()
+    print("Försöker skicka startrapport till Slack...")
+    simple_status_report()
 except Exception as e:
-    print(f"Kunde inte skicka status-rapport till Slack vid uppstart: {e}")
+    print(f"Kunde inte skicka startrapport: {e}")
 
-# --- Gradio with Chatbot and support functionality ---
+# --- Gradio UI ---
 initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
 
 custom_css = """
@@ -605,13 +503,12 @@ h1 {font-family: Helvetica, sans-serif; color: #2a9d8f; text-align: center; marg
 #chatbot_conversation { max-height: 300px; overflow-y: auto; }
 .gr-button {background-color: #2a9d8f; color: #fff; border: none; border-radius: 4px; padding: 8px 16px; margin: 5px;}
 .gr-button:hover {background-color: #264653;}
-.support-btn {background-color: #e76f51; margin-top: 5px; margin-bottom: 10px;}
-.support-btn:hover {background-color: #e85d04;}
+.support-btn {background-color: #000000; color: #ffffff; margin-top: 5px; margin-bottom: 10px;}
+.support-btn:hover {background-color: #333333;}
 .flex-row {display: flex; flex-direction: row; gap: 5px;}
 .gr-form {padding: 10px; border: 1px solid #eee; border-radius: 4px; margin-bottom: 10px;}
 .chat-preview {max-height: 150px; overflow-y: auto; border: 1px solid #eee; padding: 8px; margin-top: 10px; font-size: 12px; background-color: #f9f9f9;}
 .success-message {font-size: 16px; font-weight: normal; margin-bottom: 15px;}
-
 /* Dölj Gradio-footer */
 footer {display: none !important;}
 .footer {display: none !important;}
@@ -656,7 +553,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
     
     # Success message (initially hidden)
     with gr.Group(visible=False) as success_interface:
-        gr.Markdown("Tack för att du kontaktar använt vår chat. All information är skickad till vår kundtjänst. Vi återkommer inom kort", elem_classes="success-message")
+        gr.Markdown("Tack för att du kontaktar support@chargenode.eu. Vi återkommer inom kort", elem_classes="success-message")
         back_to_chat_btn = gr.Button("Tillbaka till chatten")
     
     def respond(message, chat_history, request: gr.Request):
@@ -667,6 +564,11 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
 
         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         session_id = str(uuid.uuid4())
+        
+        # Använd session_id från tidigare logg om det finns
+        if last_log and 'session_id' in last_log:
+            session_id = last_log.get('session_id')
+            
         user_id = request.client.host if request else "okänd"
 
         ua_str = request.headers.get("user-agent", "")
@@ -702,6 +604,55 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
                 log_file.write(json.dumps(log_data) + "\n")
         last_log = log_data
 
+        # Skicka varje konversation direkt till Slack
+        try:
+            webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+            if webhook_url:
+                # Förenkla innehållet för att säkerställa att det fungerar
+                slack_message = {
+                    "blocks": [
+                        {
+                            "type": "header",
+                            "text": {
+                                "type": "plain_text",
+                                "text": f"Ny konversation {timestamp}"
+                            }
+                        },
+                        {
+                            "type": "section",
+                            "text": {
+                                "type": "mrkdwn",
+                                "text": f"*Användare:* {message}"
+                            }
+                        },
+                        {
+                            "type": "section",
+                            "text": {
+                                "type": "mrkdwn",
+                                "text": f"*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}"
+                            }
+                        },
+                        {
+                            "type": "context",
+                            "elements": [
+                                {
+                                    "type": "mrkdwn",
+                                    "text": f"Session: {session_id[:8]}... | Browser: {browser} | Platform: {platform}"
+                                }
+                            ]
+                        }
+                    ]
+                }
+                
+                # Använd asynkront anrop för att inte blockera svarstiden
+                # Detta kräver att requests körs i en separat tråd
+                threading.Thread(
+                    target=lambda: requests.post(webhook_url, json=slack_message),
+                    daemon=True
+                ).start()
+        except Exception as e:
+            print(f"Kunde inte skicka konversation till Slack: {e}")
+
         chat_history.append({"role": "user", "content": message})
         chat_history.append({"role": "assistant", "content": response})
         return "", chat_history