Update app.py

app.py

@@ -3,6 +3,7 @@ import json
 import time
 import requests
 from anthropic import Anthropic
+from openai import OpenAI
 import gradio as gr
 import pandas as pd
 from huggingface_hub import CommitScheduler
@@ -14,20 +15,21 @@ import threading
 from sentence_transformers import SentenceTransformer
 import numpy as np
 import faiss
-import re
 
 # --- Konfiguration ---
 CHARGENODE_URL = "https://www.chargenode.eu"
-MAX_CHUNK_SIZE = 2000
-CHUNK_OVERLAP = 200
-RETRIEVAL_K = 5
-
-# Uppdaterad modell till Sonnet 4
-MODEL_NAME = "claude-sonnet-4-20250514"
+MAX_CHUNK_SIZE = 1024  # Storlek på chunker för indexering
+RETRIEVAL_K = 8        # Antal chunker att hämta vid varje sökning
 
 # Kontrollera om vi kör i Hugging Face-miljön
 IS_HUGGINGFACE = os.environ.get("SPACE_ID") is not None
 
+# OpenAI-klient behålls för bakåtkompatibilitet
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    raise ValueError("OPENAI_API_KEY saknas")
+client = OpenAI(api_key=OPENAI_API_KEY)
+
 # Lägg till Anthropic API-nyckel och klient
 ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY")
 if not ANTHROPIC_API_KEY:
@@ -41,7 +43,7 @@ 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("")
+        f.write("")  # Skapa en tom fil
     print(f"Skapade tom loggfil: {log_file_path}")
 
 hf_token = os.environ.get("HF_TOKEN")
@@ -67,7 +69,6 @@ embeddings = None
 index = None
 chunks = []
 chunk_sources = []
-faq_dict = {}  # Dictionary för direktmatchning av vanliga frågor
 
 # --- Förbättrad loggfunktion ---
 def safe_append_to_log(log_entry):
@@ -105,7 +106,7 @@ def safe_append_to_log(log_entry):
 def load_local_files():
     """Laddar alla lokala filer och returnerar som en sammanhängande text."""
     uploaded_text = ""
-    allowed = [".txt", ".csv", ".xls", ".xlsx"]  # Tog bort .docx och .pdf
+    allowed = [".txt", ".docx", ".pdf", ".csv", ".xls", ".xlsx"]
     excluded = ["requirements.txt", "app.py", "conversation_log.txt", "conversation_log_v2.txt", "secrets", "prompt.txt"]
     for file in os.listdir("."):
         if file.lower().endswith(tuple(allowed)) and file not in excluded:
@@ -113,6 +114,14 @@ def load_local_files():
                 if file.endswith(".txt"):
                     with open(file, "r", encoding="utf-8") as f:
                         content = f.read()
+                elif file.endswith(".docx"):
+                    from docx import Document  # Import sker vid behov
+                    content = "\n".join([p.text for p in Document(file).paragraphs])
+                elif file.endswith(".pdf"):
+                    import PyPDF2  # Import sker vid behov
+                    with open(file, "rb") as f:
+                        reader = PyPDF2.PdfReader(f)
+                        content = "\n".join([p.extract_text() or "" for p in reader.pages])
                 elif file.endswith(".csv"):
                     content = pd.read_csv(file).to_string()
                 elif file.endswith((".xls", ".xlsx")):
@@ -154,104 +163,29 @@ def load_prompt():
         print(f"Fel vid inläsning av prompt.txt: {e}, använder standardprompt")
         return "Du är ChargeNode's AI-assistent. Svara på frågor om ChargeNode's produkter och tjänster baserat på den tillhandahållna informationen."
 
-# --- Förbättrad chunking ---
+# Förbered textsegment
 def prepare_chunks(text_data):
     """Delar upp texten i mindre segment för embedding och sökning."""
-    chunks_list, sources_list = [], []
-    global faq_dict
-    
+    chunks, sources = [], []
     for source, text in text_data.items():
-        # Split text into paragraph-sized chunks
         paragraphs = [p for p in text.split("\n") if p.strip()]
-        
-        # Process FAQ-specific content better
-        i = 0
-        current_file_chunks = []
-        current_file_sources = []
-        while i < len(paragraphs):
-            # Start a new chunk
-            current_chunk = ""
-            start_idx = i
-            
-            # Check for FAQ format
-            if i < len(paragraphs) and paragraphs[i].startswith("Fråga:"):
-                question = paragraphs[i][7:].strip()  # Extract the question text
-                current_chunk = paragraphs[i]
-                i += 1
-                
-                # Add content until we reach the next question or MAX_CHUNK_SIZE
-                while i < len(paragraphs) and not paragraphs[i].startswith("Fråga:"):
-                    # Add this paragraph if it doesn't exceed chunk size
-                    if len(current_chunk) + len(paragraphs[i]) + 1 <= MAX_CHUNK_SIZE:
-                        current_chunk += "\n" + paragraphs[i]
-                    else:
-                        # If we're already processing a FAQ answer, don't break mid-answer
-                        if "Svar:" in current_chunk:
-                            # We prefer to keep whole answers together, so let's break only if answer is too long
-                            if len(current_chunk) > MAX_CHUNK_SIZE * 1.5:  # Allow some overflow
-                                break
-                            else:
-                                current_chunk += "\n" + paragraphs[i]
-                        else:
-                            break
-                    i += 1
-                
-                # Store FAQ pairs in the dictionary for direct lookup
-                if "Svar:" in current_chunk:
-                    answer_start = current_chunk.find("Svar:")
-                    answer_text = current_chunk[answer_start + 5:].strip()
-                    
-                    # Add the original question to the dictionary
-                    faq_dict[question.lower()] = answer_text
+        chunk = ""
+        for para in paragraphs:
+            if len(chunk) + len(para) + 1 <= MAX_CHUNK_SIZE:
+                chunk += " " + para
             else:
-                # Handle non-FAQ text using sliding window
-                while i < len(paragraphs) and len(current_chunk) + len(paragraphs[i]) + 1 <= MAX_CHUNK_SIZE:
-                    if current_chunk:
-                        current_chunk += " " + paragraphs[i]
-                    else:
-                        current_chunk = paragraphs[i]
-                    i += 1
-            
-            # Save the chunk if it has content
-            if current_chunk.strip():
-                current_file_chunks.append(current_chunk.strip())
-                current_file_sources.append(source)
-            
-            # If we've added a chunk but haven't advanced, we need to move forward
-            if i == start_idx:
-                i += 1
-        
-        # Create overlapping chunks for better context preservation for THIS source
-        overlap_chunks_for_file = []
-        overlap_sources_for_file = []
-        
-        for j in range(len(current_file_chunks)):
-            overlap_chunks_for_file.append(current_file_chunks[j])
-            overlap_sources_for_file.append(current_file_sources[j])
-            
-            if j < len(current_file_chunks) - 1:
-                # Calculate available space in the current chunk
-                space_left = MAX_CHUNK_SIZE - len(current_file_chunks[j])
-                
-                # If there's enough space, add part of the next chunk
-                if space_left >= CHUNK_OVERLAP:
-                    # Ensure we don't duplicate if chunks are already naturally overlapping significantly
-                    if not current_file_chunks[j].endswith(current_file_chunks[j+1][:CHUNK_OVERLAP]):
-                         overlap_text = current_file_chunks[j] + " " + current_file_chunks[j+1][:CHUNK_OVERLAP]
-                         if len(overlap_text) <= MAX_CHUNK_SIZE: # Ensure overlap doesn't exceed max size
-                            overlap_chunks_for_file.append(overlap_text)
-                            overlap_sources_for_file.append(current_file_sources[j])
-
-        chunks_list.extend(overlap_chunks_for_file)
-        sources_list.extend(overlap_sources_for_file)
-        
-    print(f"Genererade {len(chunks_list)} chunks med {len(faq_dict)} FAQ-par")
-    return chunks_list, sources_list
-
+                if chunk.strip():
+                    chunks.append(chunk.strip())
+                    sources.append(source)
+                chunk = para
+        if chunk.strip():
+            chunks.append(chunk.strip())
+            sources.append(source)
+    return chunks, sources
 
 def initialize_embeddings():
     """Initierar SentenceTransformer och FAISS-index vid första anrop."""
-    global embedder, embeddings, index, chunks, chunk_sources, faq_dict
+    global embedder, embeddings, index, chunks, chunk_sources
     
     if embedder is None:
         print("Initierar SentenceTransformer och FAISS-index...")
@@ -262,143 +196,65 @@ def initialize_embeddings():
         chunks, chunk_sources = prepare_chunks(text_data)
         print(f"{len(chunks)} segment laddade")
 
-        if not chunks:
-            print("Varning: Inga chunks genererades. Kontrollera textkällor och chunking-logik.")
-            # Sätt upp tomma men giltiga strukturer för att undvika fel senare
-            embedder = SentenceTransformer('all-MiniLM-L6-v2')
-            embeddings = np.array([]).reshape(0, embedder.get_sentence_embedding_dimension())
-            index = faiss.IndexFlatIP(embedder.get_sentence_embedding_dimension())
-            print("FAISS-index initialiserat tomt då inga chunks fanns.")
-            return
-
         print("Skapar embeddings...")
         embedder = SentenceTransformer('all-MiniLM-L6-v2')
         embeddings = embedder.encode(chunks, convert_to_numpy=True)
-        
-        # Normalisera embeddings för IndexFlatIP (dot product)
-        if embeddings.ndim == 2 and embeddings.shape[0] > 0:
-            embeddings_norm = np.linalg.norm(embeddings, axis=1, keepdims=True)
-            # Undvik division med noll om någon norm är noll
-            embeddings_norm[embeddings_norm == 0] = 1e-10 
-            embeddings = embeddings / embeddings_norm
-            
-            index = faiss.IndexFlatIP(embeddings.shape[1])
-            index.add(embeddings)
-            print("FAISS-index klart")
-        else:
-            print("Varning: Inga embeddings genererades, FAISS-index kan vara tomt eller ogiltigt.")
-            # Fallback: skapa ett tomt index om embeddings är tomma
-            dimension = embedder.get_sentence_embedding_dimension() if embedder else 384
-            index = faiss.IndexFlatIP(dimension)
-            print("FAISS-index initialiserat tomt.")
-
-        print(f"FAQ Dictionary innehåller {len(faq_dict)} nycklar")
-
-def check_direct_match(query):
-    """Kontrollerar om frågan matchar någon av våra fördefinierade FAQ-svar."""
-    query_lower = query.lower().strip('?').strip()
-    
-    # Check if query directly matches a FAQ
-    if query_lower in faq_dict:
-        return faq_dict[query_lower]
-    
-    # Check for close matches using pattern matching
-    for key, value in faq_dict.items():
-        # Check if key and query share important terms
-        query_terms = set(re.findall(r'\w+', query_lower))
-        key_terms = set(re.findall(r'\w+', key))
-        if len(query_terms.intersection(key_terms)) >= 2:  # At least 2 words in common
-            return value
-    
-    return None
+        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 med direkt matchning för vanliga frågor."""
+    """Hämtar relevant kontext för frågor."""
     # Säkerställ att modeller är laddade
     initialize_embeddings()
     
-    # Först, kolla efter direktmatchningar för vanliga frågor
-    direct_match = check_direct_match(query)
-    if direct_match:
-        print(f"Direkt matchning hittad för frågan: {query}")
-        return f"Fråga: {query}\nSvar: {direct_match}", ["direct_match"]
-    
-    # Om ingen direktmatchning, använd vanlig embedding-sökning
-    if embedder is None or index is None or index.ntotal == 0:
-        print("Varning: Embedder eller FAISS-index är inte korrekt initierat eller är tomt. Returnerar tom kontext.")
-        return "", []
-
     query_embedding = embedder.encode([query], convert_to_numpy=True)
-    # Normalisera query_embedding på samma sätt som indexets embeddings
-    query_embedding_norm = np.linalg.norm(query_embedding)
-    if query_embedding_norm == 0: query_embedding_norm = 1e-10
-    query_embedding = query_embedding / query_embedding_norm
-    
+    query_embedding /= np.linalg.norm(query_embedding)
     D, I = index.search(query_embedding, k)
-    retrieved, sources_set = [], set()
+    retrieved, sources = [], set()
     for idx in I[0]:
-        if 0 <= idx < len(chunks):
+        if idx < len(chunks):
             retrieved.append(chunks[idx])
-            sources_set.add(chunk_sources[idx])
-    return " ".join(retrieved), list(sources_set)
+            sources.add(chunk_sources[idx])
+    return " ".join(retrieved), list(sources)
 
 # Ladda prompt template
 prompt_template = load_prompt()
 
-def format_chat_history_for_claude(chat_history):
-    """Formaterar chatthistoriken för Claude API med endast de senaste meddelandena för att undvika token-gränser."""
-    # Ta endast de senaste 10 meddelandena för att hålla kontexten hanterbar
-    recent_history = chat_history[-10:] if len(chat_history) > 10 else chat_history
-    
-    messages = []
-    for msg in recent_history:
-        if msg["role"] in ["user", "assistant"]:
-            messages.append({
-                "role": msg["role"],
-                "content": msg["content"]
-            })
-    
-    return messages
-
-def generate_answer(query, chat_history=None):
-    """Genererar svar baserat på fråga, chatthistorik och retrieval-baserad kontext med Claude Sonnet 4."""
+def generate_answer(query):
+    """Genererar svar baserat på fråga och retrieval-baserad kontext med Claude Haiku."""
     # Hämta relevant kontext via RAG istället för hela databasen
     context, sources = retrieve_context(query)
     
     if not context.strip():
-        print("Ingen RAG-kontext hittades. Försöker svara utan.")
-
-    # System-prompts
-    system_prompt = prompt_template
-    
-    # Förbered meddelanden för Claude API
-    messages = []
+        return "Jag hittar ingen relevant information i mina källor.\n\nDetta är ett AI genererat svar."
     
-    # Lägg till chatthistorik om den finns och är meningsfull
-    if chat_history and len(chat_history) > 1:
-        formatted_history = format_chat_history_for_claude(chat_history[:-1])
-        messages.extend(formatted_history)
+    # System-prompts och användarfråga
+    system_prompt = prompt_template
     
-    # Skapa användarmeddelandet med kontext och aktuell fråga
-    user_message_content = f"Relevant kontext för frågan:\n{context}\n\nMin fråga är: {query}"
-    if not context.strip():
-        user_message_content = f"Min fråga är: {query}"
-        
-    messages.append({"role": "user", "content": user_message_content})
+    # Skapa ett renare användarmeddelande med bara den relevanta kontexten
+    user_message = f"""Jag har en fråga om ChargeNode.
+
+Relevant kontext för frågan:
+{context}
+
+Min fråga är: {query}"""
     
     try:
-        # Använd Claude Sonnet 4 med RAG-baserad kontext och chatthistorik
+        # Använd Claude Haiku med RAG-baserad kontext
         response = anthropic_client.messages.create(
-            model=MODEL_NAME,
-            max_tokens=1024,
+            model="claude-3-7-sonnet-20250219",
+            max_tokens=500,
             temperature=0.3,
             system=system_prompt,
-            messages=messages
+            messages=[
+                {"role": "user", "content": user_message}
+            ]
         )
         answer = response.content[0].text
         return answer + "\n\nAI-genererat. Otillräcklig hjälp? Kontakta support@chargenode.eu eller 010-2051055"
     except Exception as e:
-        print(f"Fel vid API-anrop: {str(e)}")
         return f"Tekniskt fel: {str(e)}\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
 
 # --- Slack Integration ---
@@ -450,7 +306,7 @@ def send_to_slack(subject, content, color="#2a9d8f"):
 def vote(data: gr.LikeData):
     """
     Hanterar feedback från Gradio's inbyggda like-funktion.
-    data.liked är True om upvote, annars False.
+    data.liked är True om uppvote, annars False.
     data.value innehåller information om meddelandet.
     """
     feedback_type = "up" if data.liked else "down"
@@ -472,7 +328,7 @@ def vote(data: gr.LikeData):
     
     # Skicka feedback till Slack
     try:
-        if feedback_type == "down" and last_log:
+        if feedback_type == "down":  # Skicka bara negativ feedback
             feedback_message = f"""
 *⚠️ Negativ feedback registrerad*
 
@@ -572,9 +428,7 @@ def generate_monthly_stats(days=30):
                 pass  # Hoppa över poster med ogiltigt datum
     
     logs = filtered_logs
-    if not logs:
-        return {"error": f"Inga loggar hittades för de senaste {days} dagarna"}
-
+    
     # 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))
@@ -587,7 +441,7 @@ def generate_monthly_stats(days=30):
     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 and isinstance(log.get('response_time'), (int, float))]
+    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
@@ -636,8 +490,8 @@ def simple_status_report():
         stats = generate_monthly_stats(days=7)  # Senaste veckan
         
         # Skapa innehåll för Slack
-        now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        subject = f"ChargeNode AI Bot - Status {now_str}"
+        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']}"
@@ -649,7 +503,7 @@ def simple_status_report():
         perf = stats["performance"]
         
         content = f"""
-*ChargeNode AI Bot - Statusrapport {now_str}*
+*ChargeNode AI Bot - Statusrapport {now}*
 
 *Basstatistik* (senaste 7 dagarna)
 - Totalt antal konversationer: {basic['total_conversations']}
@@ -664,8 +518,8 @@ def simple_status_report():
 """
         
         # Lägg till de senaste konversationerna
-        all_logs = read_logs()
-        conversations = get_latest_conversations(all_logs, 3)
+        logs = read_logs()
+        conversations = get_latest_conversations(logs, 3)
         
         if conversations:
             content += "\n*Senaste konversationer*\n"
@@ -687,12 +541,12 @@ def simple_status_report():
         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_list):
+def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
     """Skickar en supportförfrågan till Slack."""
     try:
         # Formatera chat-historiken
         chat_content = ""
-        for msg in chat_history_list:
+        for msg in chat_history:
             if msg['role'] == 'user':
                 chat_content += f">*Användare:* {msg['content']}\n\n"
             elif msg['role'] == 'assistant':
@@ -741,6 +595,13 @@ def run_scheduler():
 scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
 scheduler_thread.start()
 
+# Kör en statusrapport vid uppstart för att verifiera att allt fungerar
+try:
+    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"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?"}]
 
@@ -804,16 +665,11 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         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_list, request: gr.Request):
+    def respond(message, chat_history, request: gr.Request):
         global last_log
-        start_time = time.time()
-        
-        # Lägg till användarens nuvarande meddelande i historiken FÖRE anrop till generate_answer
-        chat_history_list.append({"role": "user", "content": message})
-
-        # Skicka den uppdaterade chatthistoriken till generate_answer
-        response_text = generate_answer(message, chat_history_list) 
-        elapsed = round(time.time() - start_time, 2)
+        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())
@@ -826,7 +682,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
 
         ua_str = request.headers.get("user-agent", "")
         ref = request.headers.get("referer", "")
-        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0].strip()
+        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0]
         ua = parse_ua(ua_str)
         browser = f"{ua.browser.family} {ua.browser.version_string}"
         osys = f"{ua.os.family} {ua.os.version_string}"
@@ -834,7 +690,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         platform = "webb"
         if "chargenode.eu" in ref:
             platform = "chargenode.eu"
-        elif "localhost" in ref or "127.0.0.1" in ref:
+        elif "localhost" in ref:
             platform = "test"
         elif "app" in ref:
             platform = "app"
@@ -844,29 +700,31 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             "user_id": user_id,
             "session_id": session_id,
             "user_message": message,
-            "bot_reply": response_text,
+            "bot_reply": response,
             "response_time": elapsed,
             "ip": ip,
             "browser": browser,
             "os": osys,
-            "platform": platform,
-            "chat_history_length": len(chat_history_list)
+            "platform": platform
         }
 
+        # Använd den förbättrade loggfunktionen
         safe_append_to_log(log_data)
         last_log = log_data
 
         # Skicka varje konversation direkt till Slack
         try:
+            # Konversationsinnehåll
             conversation_content = f"""
 *Ny konversation {timestamp}*
 
 *Användare:* {message}
 
-*Bot:* {response_text[:300]}{'...' if len(response_text) > 300 else ''}
+*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}
 
-*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform} | Chat längd: {len(chat_history_list)} meddelanden
+*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
@@ -874,26 +732,26 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         except Exception as e:
             print(f"Kunde inte skicka konversation till Slack: {e}")
 
-        # Användarens meddelande är redan tillagt, lägg bara till assistentens svar.
-        chat_history_list.append({"role": "assistant", "content": response_text})
-        return "", chat_history_list
+        chat_history.append({"role": "user", "content": message})
+        chat_history.append({"role": "assistant", "content": response})
+        return "", chat_history
     
-    def format_chat_preview(chat_history_list):
-        if not chat_history_list:
+    def format_chat_preview(chat_history):
+        if not chat_history:
             return "Ingen chatthistorik att visa."
         
         preview = ""
-        for msg_item in chat_history_list:
-            sender = "Användare" if msg_item["role"] == "user" else "Bot"
-            content = msg_item["content"]
+        for msg in chat_history:
+            sender = "Användare" if msg["role"] == "user" else "Bot"
+            content = msg["content"]
             if len(content) > 100:  # Truncate long messages
                 content = content[:100] + "..."
             preview += f"**{sender}:** {content}\n\n"
         
         return preview
     
-    def show_support_form(chat_history_list):
-        preview = format_chat_preview(chat_history_list)
+    def show_support_form(chat_history):
+        preview = format_chat_preview(chat_history)
         return {
             chat_interface: gr.Group(visible=False),
             support_interface: gr.Group(visible=True),
@@ -908,82 +766,84 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             success_interface: gr.Group(visible=False)
         }
     
-    def submit_support_form(omr_kod, uttags_nr, email_addr, chat_history_list):
+    def submit_support_form(områdeskod, uttagsnummer, email, chat_history):
         """Hanterar formulärinskickningen med bättre felhantering."""
-        print(f"Support-förfrågan: områdeskod={omr_kod}, uttagsnummer={uttags_nr}, email={email_addr}")
+        print(f"Support-förfrågan: områdeskod={områdeskod}, uttagsnummer={uttagsnummer}, email={email}")
         
+        # Validera input med tydligare loggning
         validation_errors = []
         
-        if omr_kod and not omr_kod.isdigit():
-            print(f"Validerar områdeskod: '{omr_kod}' (felaktig)")
+        if områdeskod and not områdeskod.isdigit():
+            print(f"Validerar områdeskod: '{områdeskod}' (felaktig)")
             validation_errors.append("Områdeskod måste vara numerisk.")
         else:
-            print(f"Validerar områdeskod: '{omr_kod}' (ok)")
+            print(f"Validerar områdeskod: '{områdeskod}' (ok)")
         
-        if uttags_nr and not uttags_nr.isdigit():
-            print(f"Validerar uttagsnummer: '{uttags_nr}' (felaktig)")
+        if uttagsnummer and not uttagsnummer.isdigit():
+            print(f"Validerar uttagsnummer: '{uttagsnummer}' (felaktig)")
             validation_errors.append("Uttagsnummer måste vara numerisk.")
         else:
-            print(f"Validerar uttagsnummer: '{uttags_nr}' (ok)")
+            print(f"Validerar uttagsnummer: '{uttagsnummer}' (ok)")
         
-        if not email_addr:
+        if not email:
             print("Validerar email: (saknas)")
             validation_errors.append("En giltig e-postadress krävs.")
-        elif '@' not in email_addr or '.' not in email_addr.split('@')[-1]:
-            print(f"Validerar email: '{email_addr}' (felaktigt format)")
+        elif '@' not in email or '.' not in email.split('@')[1]:
+            print(f"Validerar email: '{email}' (felaktigt format)")
             validation_errors.append("En giltig e-postadress krävs.")
         else:
-            print(f"Validerar email: '{email_addr}' (ok)")
+            print(f"Validerar email: '{email}' (ok)")
         
+        # Om det finns valideringsfel
         if validation_errors:
             print(f"Valideringsfel: {validation_errors}")
-            error_message_md = "**Fel:**\n" + "\n".join(f"- {err}" for err in validation_errors)
             return {
-                chat_interface: gr.update(visible=False),
-                support_interface: gr.update(visible=True),
-                success_interface: gr.update(visible=False),
-                chat_preview: gr.update(value=error_message_md)
+                chat_interface: gr.Group(visible=False),
+                support_interface: gr.Group(visible=True),
+                success_interface: gr.Group(visible=False),
+                chat_preview: "\n".join(["**Fel:**"] + validation_errors)
             }
         
+        # Om formuläret klarade valideringen, försök skicka till Slack
         try:
             print("Försöker skicka supportförfrågan till Slack...")
             
+            # Skapa en förenklad chathistorik för loggning
             chat_summary = []
-            for msg_item in chat_history_list:
-                if 'role' in msg_item and 'content' in msg_item:
-                    chat_summary.append(f"{msg_item['role']}: {msg_item['content'][:30]}...")
+            for msg in chat_history:
+                if 'role' in msg and 'content' in msg:
+                    chat_summary.append(f"{msg['role']}: {msg['content'][:30]}...")
             print(f"Chatthistorik att skicka: {chat_summary}")
             
-            success = send_support_to_slack(omr_kod, uttags_nr, email_addr, chat_history_list)
+            # Skicka till Slack
+            success = send_support_to_slack(områdeskod, uttagsnummer, email, chat_history)
             
             if success:
                 print("Support-förfrågan skickad till Slack framgångsrikt")
                 return {
-                    chat_interface: gr.update(visible=False),
-                    support_interface: gr.update(visible=False),
-                    success_interface: gr.update(visible=True)
+                    chat_interface: gr.Group(visible=False),
+                    support_interface: gr.Group(visible=False),
+                    success_interface: gr.Group(visible=True)
                 }
             else:
                 print("Support-förfrågan till Slack misslyckades")
-                error_message_md = "**Ett fel uppstod när meddelandet skulle skickas. Vänligen försök igen senare.**"
                 return {
-                    chat_interface: gr.update(visible=False),
-                    support_interface: gr.update(visible=True),
-                    success_interface: gr.update(visible=False),
-                    chat_preview: gr.update(value=error_message_md)
+                    chat_interface: gr.Group(visible=False),
+                    support_interface: gr.Group(visible=True),
+                    success_interface: gr.Group(visible=False),
+                    chat_preview: "**Ett fel uppstod när meddelandet skulle skickas. Vänligen försök igen senare.**"
                 }
         except Exception as e:
             print(f"Oväntat fel vid hantering av support-formulär: {e}")
-            error_message_md = f"**Ett oväntat fel uppstod: {str(e)}**"
             return {
-                chat_interface: gr.update(visible=False),
-                support_interface: gr.update(visible=True),
-                success_interface: gr.update(visible=False),
-                chat_preview: gr.update(value=error_message_md)
+                chat_interface: gr.Group(visible=False),
+                support_interface: gr.Group(visible=True),
+                success_interface: gr.Group(visible=False),
+                chat_preview: f"**Ett fel uppstod: {str(e)}**"
             }
     
     msg.submit(respond, [msg, chatbot], [msg, chatbot])
-    clear.click(lambda: initial_chat, None, chatbot, queue=False)
+    clear.click(lambda: None, None, chatbot, queue=False)
     support_btn.click(show_support_form, chatbot, [chat_interface, support_interface, success_interface, chat_preview])
     back_btn.click(back_to_chat, None, [chat_interface, support_interface, success_interface])
     back_to_chat_btn.click(back_to_chat, None, [chat_interface, support_interface, success_interface])
@@ -999,4 +859,4 @@ initialize_embeddings()
 print("Embedding-modell och index redo!")
 
 if __name__ == "__main__":
-    app.launch(share=IS_HUGGINGFACE)
+    app.launch(share=True)