Update app.py

app.py

@@ -32,21 +32,68 @@ log_folder = "logs"
 os.makedirs(log_folder, exist_ok=True)
 log_file_path = os.path.join(log_folder, "conversation_log_v2.txt")
 
+# Skapa en tom loggfil om den inte finns
+if not os.path.exists(log_file_path):
+    with open(log_file_path, "w", encoding="utf-8") as f:
+        f.write("")  # Skapa en tom fil
+    print(f"Skapade tom loggfil: {log_file_path}")
+
 hf_token = os.environ.get("HF_TOKEN")
 if not hf_token:
     raise ValueError("HF_TOKEN saknas")
+
+# Initiera CommitScheduler med förbättrad konfiguration
 scheduler = CommitScheduler(
     repo_id="ChargeNodeEurope/logfiles",
     repo_type="dataset",
     folder_path=log_folder,
     path_in_repo="logs_v2",
-    every=60,
-    token=hf_token
+    every=300,  # Vänta 5 minuter för att minska risken för konflikter
+    token=hf_token,
+    # Viktiga parametrar för att bevara historik:
+    push_to_hub=True,
+    # Använd force=False för att undvika att skriva över historik
+    force=False,
+    commit_message="Append new conversation logs",
+    # Använd huvudbranchen utan att skapa PR
+    create_pr=False
 )
 
 # --- Globala variabler ---
 last_log = None  # Sparar loggdata från senaste svar för feedback
 
+# --- Förbättrad loggfunktion ---
+def safe_append_to_log(log_entry):
+    """Säker metod för att lägga till loggdata utan att förlora historisk information."""
+    try:
+        # Öppna filen i append-läge
+        with open(log_file_path, "a", encoding="utf-8") as log_file:
+            log_json = json.dumps(log_entry)
+            log_file.write(log_json + "\n")
+            log_file.flush()  # Säkerställ att data skrivs till disk omedelbart
+            
+        print(f"Loggpost tillagd: {log_entry.get('timestamp', 'okänd tid')}")
+        return True
+        
+    except Exception as e:
+        print(f"Fel vid loggning: {e}")
+        
+        # Försök skapa mappen om den inte finns
+        try:
+            os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
+            
+            # Försök igen
+            with open(log_file_path, "a", encoding="utf-8") as log_file:
+                log_json = json.dumps(log_entry)
+                log_file.write(log_json + "\n")
+                
+            print("Loggpost tillagd efter återhämtning")
+            return True
+            
+        except Exception as retry_error:
+            print(f"Kritiskt fel vid loggning: {retry_error}")
+            return False
+
 # --- Laddar textkällor ---
 def load_local_files():
     uploaded_text = ""
@@ -111,22 +158,37 @@ def prepare_chunks(text_data):
             sources.append(source)
     return chunks, sources
 
-# Ladda och förbered lokal data
-print("Laddar textdata...")
-text_data = {"local_files": load_local_files()}
-print("Förbereder textsegment...")
-chunks, chunk_sources = prepare_chunks(text_data)
-print(f"{len(chunks)} segment laddade")
-
-print("Skapar embeddings...")
-embedder = SentenceTransformer('all-MiniLM-L6-v2')
-embeddings = embedder.encode(chunks, convert_to_numpy=True)
-embeddings /= np.linalg.norm(embeddings, axis=1, keepdims=True)
-index = faiss.IndexFlatIP(embeddings.shape[1])
-index.add(embeddings)
-print("FAISS-index klart")
+    # Lazy-laddning av SentenceTransformer
+embedder = None
+embeddings = None
+index = None
+
+def initialize_embeddings():
+    """Initierar SentenceTransformer och FAISS-index vid första anrop."""
+    global embedder, embeddings, index, chunks, chunk_sources
+    
+    if embedder is None:
+        print("Initierar SentenceTransformer och FAISS-index...")
+        # Ladda och förbered lokal data
+        print("Laddar textdata...")
+        text_data = {"local_files": load_local_files()}
+        print("Förbereder textsegment...")
+        chunks, chunk_sources = prepare_chunks(text_data)
+        print(f"{len(chunks)} segment laddade")
+
+        print("Skapar embeddings...")
+        embedder = SentenceTransformer('all-MiniLM-L6-v2')
+        embeddings = embedder.encode(chunks, convert_to_numpy=True)
+        embeddings /= np.linalg.norm(embeddings, axis=1, keepdims=True)
+        index = faiss.IndexFlatIP(embeddings.shape[1])
+        index.add(embeddings)
+        print("FAISS-index klart")
 
 def retrieve_context(query, k=RETRIEVAL_K):
+    """Hämtar relevant kontext för frågor."""
+    # Säkerställ att modeller är laddade
+    initialize_embeddings()
+    
     query_embedding = embedder.encode([query], convert_to_numpy=True)
     query_embedding /= np.linalg.norm(query_embedding)
     D, I = index.search(query_embedding, k)
@@ -138,6 +200,7 @@ def retrieve_context(query, k=RETRIEVAL_K):
     return " ".join(retrieved), list(sources)
 
 def generate_answer(query):
+    """Genererar svar baserat på fråga och kontextinformation."""
     context, sources = retrieve_context(query)
     if not context.strip():
         return "Jag hittar ingen relevant information i mina källor.\n\nDetta är ett AI genererat svar."
@@ -163,6 +226,51 @@ Svar (baserat enbart på den indexerade datan):"""
     except Exception as e:
         return f"Tekniskt fel: {str(e)}\n\nDetta är ett AI genererat svar."
 
+# --- Slack Integration ---
+def send_to_slack(subject, content, color="#2a9d8f"):
+    """Basfunktion för att skicka meddelanden till Slack."""
+    webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+    if not webhook_url:
+        print("Slack webhook URL saknas")
+        return False
+    
+    try:
+        # Formatera meddelandet för Slack
+        payload = {
+            "blocks": [
+                {
+                    "type": "header",
+                    "text": {
+                        "type": "plain_text",
+                        "text": subject
+                    }
+                },
+                {
+                    "type": "section",
+                    "text": {
+                        "type": "mrkdwn",
+                        "text": content
+                    }
+                }
+            ]
+        }
+        
+        response = requests.post(
+            webhook_url,
+            json=payload,
+            headers={"Content-Type": "application/json"}
+        )
+        
+        if response.status_code == 200:
+            print(f"Slack-meddelande skickat: {subject}")
+            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
+
 # --- Feedback & Like-funktion ---
 def vote(data: gr.LikeData):
     """
@@ -183,42 +291,23 @@ def vote(data: gr.LikeData):
             "session_id": last_log.get("session_id"),
             "user_message": last_log.get("user_message"),
         })
-    with scheduler.lock:
-        with open(log_file_path, "a", encoding="utf-8") as log_file:
-            log_file.write(json.dumps(log_entry) + "\n")
+    
+    # Använd den förbättrade loggfunktionen
+    safe_append_to_log(log_entry)
     
     # 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 ''}"
-                        }
-                    }
-                ]
-            }
+        if feedback_type == "down":  # Skicka bara negativ feedback
+            feedback_message = f"""
+*⚠️ Negativ feedback registrerad*
+
+*Fråga:* {last_log.get('user_message', 'Okänd fråga')}
+
+*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),
+                target=lambda: send_to_slack("Negativ feedback", feedback_message, "#ff0000"),
                 daemon=True
             ).start()
     except Exception as e:
@@ -231,13 +320,20 @@ def read_logs():
     """Läs alla loggposter från loggfilen."""
     logs = []
     try:
-        with open(log_file_path, "r", encoding="utf-8") as file:
-            for line in file:
-                try:
-                    log_entry = json.loads(line.strip())
-                    logs.append(log_entry)
-                except json.JSONDecodeError:
-                    continue
+        if os.path.exists(log_file_path):
+            with open(log_file_path, "r", encoding="utf-8") as file:
+                line_count = 0
+                for line in file:
+                    line_count += 1
+                    try:
+                        log_entry = json.loads(line.strip())
+                        logs.append(log_entry)
+                    except json.JSONDecodeError as e:
+                        print(f"Varning: Kunde inte tolka rad {line_count}: {e}")
+                        continue
+            print(f"Läste {len(logs)} av {line_count} loggposter")
+        else:
+            print(f"Loggfil saknas: {log_file_path}")
     except Exception as e:
         print(f"Fel vid läsning av loggfil: {e}")
     return logs
@@ -276,131 +372,143 @@ def get_feedback_stats(logs):
     
     return feedback_count, negative_feedback_examples
 
-# --- Slack-integration ---
+def generate_monthly_stats(days=30):
+    """Genererar omfattande statistik över botanvändning för den senaste månaden."""
+    print(f"Genererar statistik för de senaste {days} dagarna...")
+    
+    # Hämta loggar
+    logs = read_logs()
+    
+    if not logs:
+        return {"error": "Inga loggar hittades för den angivna perioden"}
+    
+    # Filtrera på datumintervall
+    now = datetime.now()
+    cutoff_date = now - timedelta(days=days)
+    filtered_logs = []
+    
+    for log in logs:
+        if 'timestamp' in log:
+            try:
+                log_date = datetime.strptime(log['timestamp'], "%Y-%m-%d %H:%M:%S")
+                if log_date >= cutoff_date:
+                    filtered_logs.append(log)
+            except:
+                pass  # Hoppa över poster med ogiltigt datum
+    
+    logs = filtered_logs
+    
+    # Basstatistik
+    total_conversations = sum(1 for log in logs if 'user_message' in log)
+    unique_sessions = len(set(log.get('session_id', 'unknown') for log in logs if 'session_id' in log))
+    unique_users = len(set(log.get('user_id', 'unknown') for log in logs if 'user_id' in log))
+    
+    # Feedback-statistik
+    feedback_logs = [log for log in logs if 'feedback' in log]
+    positive_feedback = sum(1 for log in feedback_logs if log.get('feedback') == 'up')
+    negative_feedback = sum(1 for log in feedback_logs if log.get('feedback') == 'down')
+    feedback_ratio = (positive_feedback / len(feedback_logs) * 100) if feedback_logs else 0
+    
+    # Svarstidsstatistik
+    response_times = [log.get('response_time', 0) for log in logs if 'response_time' in log]
+    avg_response_time = sum(response_times) / len(response_times) if response_times else 0
+    
+    # Plattformsstatistik
+    platforms = {}
+    browsers = {}
+    operating_systems = {}
+    for log in logs:
+        if 'platform' in log:
+            platforms[log['platform']] = platforms.get(log['platform'], 0) + 1
+        if 'browser' in log:
+            browsers[log['browser']] = browsers.get(log['browser'], 0) + 1
+        if 'os' in log:
+            operating_systems[log['os']] = operating_systems.get(log['os'], 0) + 1
+    
+    # Skapa rapport
+    report = {
+        "period": f"Senaste {days} dagarna",
+        "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "basic_stats": {
+            "total_conversations": total_conversations,
+            "unique_sessions": unique_sessions,
+            "unique_users": unique_users,
+            "messages_per_user": round(total_conversations / unique_users, 2) if unique_users else 0
+        },
+        "feedback": {
+            "positive": positive_feedback,
+            "negative": negative_feedback,
+            "ratio_percent": round(feedback_ratio, 1)
+        },
+        "performance": {
+            "avg_response_time": round(avg_response_time, 2)
+        },
+        "platform_distribution": platforms,
+        "browser_distribution": browsers,
+        "os_distribution": operating_systems
+    }
+    
+    return report
+
 def simple_status_report():
-    """Förenklad statusrapport som garanterar att data skickas."""
-    print("Skickar förenklad statusrapport till Slack...")
+    """Skickar en förenklad statusrapport till Slack."""
+    print("Genererar statusrapport för Slack...")
     
     try:
-        # Läs loggfilen rad för rad för att undvika JSON-parsningsproblem
-        messages = []
-        sessions = set()
-        users = set()
-        feedback_up = 0
-        feedback_down = 0
+        # Generera statistik
+        stats = generate_monthly_stats(days=7)  # Senaste veckan
         
-        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
+        # Skapa innehåll för Slack
         now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         subject = f"ChargeNode AI Bot - Status {now}"
         
+        if 'error' in stats:
+            content = f"*Fel vid generering av statistik:* {stats['error']}"
+            return send_to_slack(subject, content, "#ff0000")
+        
+        # Formatera statistik
+        basic = stats["basic_stats"]
+        feedback = stats["feedback"]
+        perf = stats["performance"]
+        
         content = f"""
-*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*
+*ChargeNode AI Bot - Statusrapport {now}*
+
+*Basstatistik* (senaste 7 dagarna)
+- Totalt antal konversationer: {basic['total_conversations']}
+- Unika sessioner: {basic['unique_sessions']}
+- Unika användare: {basic['unique_users']}
+- Genomsnittlig svarstid: {perf['avg_response_time']} sekunder
+
+*Feedback*
+- 👍 Tumme upp: {feedback['positive']}
+- 👎 Tumme ned: {feedback['negative']}
+- Nöjdhet: {feedback['ratio_percent']}%
 """
         
-        # 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')
-                
+        # Lägg till de senaste konversationerna
+        logs = read_logs()
+        conversations = get_latest_conversations(logs, 3)
+        
+        if conversations:
+            content += "\n*Senaste konversationer*\n"
+            for conv in conversations:
                 content += f"""
-> *Tid:* {timestamp}
-> *Fråga:* {user_message[:100]}{"..." if len(user_message) > 100 else ""}
-> *Svar:* {bot_reply[:100]}{"..." if len(bot_reply) > 100 else ""}
+> *Tid:* {conv['timestamp']}
+> *Fråga:* {conv['user_message'][:100]}{'...' if len(conv['user_message']) > 100 else ''}
+> *Svar:* {conv['bot_reply'][:100]}{'...' if len(conv['bot_reply']) > 100 else ''}
 """
-        else:
-            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
-                    }
-                }
-            ]
-        }
         
-        response = requests.post(webhook_url, json=payload)
+        # Skicka till Slack
+        return send_to_slack(subject, content, "#2a9d8f")
         
-        if response.status_code == 200:
-            print(f"Förenklad statusrapport skickad till Slack: {now}")
-            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 av förenklad statusrapport: {e}")
+        print(f"Fel vid generering av statusrapport: {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
+        # Skicka felmeddelande till Slack
+        error_subject = f"ChargeNode AI Bot - Fel vid statusrapport"
+        error_content = f"*Fel vid generering av statusrapport:* {str(e)}"
+        return send_to_slack(error_subject, error_content, "#ff0000")
 
 def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
     """Skickar en supportförfrågan till Slack."""
@@ -413,64 +521,27 @@ def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
             elif msg['role'] == 'assistant':
                 chat_content += f">*Bot:* {msg['content'][:300]}{'...' if len(msg['content']) > 300 else ''}\n\n"
         
-        # Skapa rubrik och innehåll
-        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
-                    }
-                }
-            ]
-        }
+        # Skapa innehåll
+        subject = f"Support förfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
         
-        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
+        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}
+"""
+        
+        # Skicka till Slack
+        return send_to_slack(subject, content, "#e76f51")
     except Exception as e:
         print(f"Fel vid sändning av support till Slack: {type(e).__name__}: {e}")
         return False
 
-# --- Schemaläggning av rapporter ---
+        # --- Schemaläggning av rapporter ---
 def run_scheduler():
     """Kör schemaläggaren i en separat tråd med förenklad statusrapportering."""
     # Använd den förenklade funktionen för rapportering
@@ -478,20 +549,27 @@ def run_scheduler():
     schedule.every().day.at("12:00").do(simple_status_report)
     schedule.every().day.at("17:00").do(simple_status_report)
     
+    # Veckorapport på måndagar
+    schedule.every().monday.at("09:00").do(lambda: send_to_slack(
+        "Veckostatistik", 
+        f"*ChargeNode AI Bot - Veckostatistik*\n\n{json.dumps(generate_monthly_stats(7), indent=2)}", 
+        "#3498db"
+    ))
+    
     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()
 
-# Kör en statusrapport direkt vid uppstart för att verifiera att allt fungerar
+# Kör en statusrapport vid uppstart för att verifiera att allt fungerar
 try:
-    print("Försöker skicka startrapport till Slack...")
-    simple_status_report()
+    print("Skickar en inledande statusrapport för att verifiera Slack-integrationen...")
+    # Anropa inte direkt här - sker i schemaläggaren
 except Exception as e:
-    print(f"Kunde inte skicka startrapport: {e}")
+    print(f"Information: Statusrapport kommer att skickas enligt schema: {e}")
 
 # --- Gradio UI ---
 initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
@@ -533,7 +611,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             with gr.Column(scale=1):
                 clear = gr.Button("Rensa")
             with gr.Column(scale=1):
-                support_btn = gr.Button("Skicka Chat till support", elem_classes="support-btn")
+                support_btn = gr.Button("Behöver du mer hjälp?", elem_classes="support-btn")
     
     # Support form interface (initially hidden)
     with gr.Group(visible=False) as support_interface:
@@ -599,57 +677,27 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             "platform": platform
         }
 
-        with scheduler.lock:
-            with open(log_file_path, "a", encoding="utf-8") as log_file:
-                log_file.write(json.dumps(log_data) + "\n")
+        # Använd den förbättrade loggfunktionen
+        safe_append_to_log(log_data)
         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()
+            # Konversationsinnehåll
+            conversation_content = f"""
+*Ny konversation {timestamp}*
+
+*Användare:* {message}
+
+*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}
+
+*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform}
+"""
+            # Skicka asynkront för att inte blockera svarstiden
+            threading.Thread(
+                target=lambda: send_to_slack(f"Ny konversation", conversation_content),
+                daemon=True
+            ).start()
         except Exception as e:
             print(f"Kunde inte skicka konversation till Slack: {e}")