Update app.py

app.py

@@ -24,7 +24,7 @@ CHUNK_OVERLAP = 200    # Nytt: Overlapping chunks för att inte tappa kontext
 RETRIEVAL_K = 5        # Antal chunker att hämta vid varje sökning
 
 # Uppdaterad modell till Sonnet 4
-MODEL_NAME = "claude-sonnet-4-20250514"
+MODEL_NAME = "claude-3-sonnet-20240229" # Behåller din specificerade Sonnet, Claude-3.5-Sonnet är "claude-3-5-sonnet-20240620"
 
 # Kontrollera om vi kör i Hugging Face-miljön
 IS_HUGGINGFACE = os.environ.get("SPACE_ID") is not None
@@ -172,7 +172,7 @@ def load_prompt():
 # --- Förbättrad chunking ---
 def prepare_chunks(text_data):
     """Delar upp texten i mindre segment för embedding och sökning med särskild hänsyn till FAQ-format."""
-    chunks, sources = [], []
+    chunks_list, sources_list = [], [] # Renamed to avoid conflict with global 'chunks' and 'sources'
     global faq_dict
     
     for source, text in text_data.items():
@@ -181,6 +181,8 @@ def prepare_chunks(text_data):
         
         # Process FAQ-specific content better
         i = 0
+        current_file_chunks = []
+        current_file_sources = []
         while i < len(paragraphs):
             # Start a new chunk
             current_chunk = ""
@@ -216,7 +218,7 @@ def prepare_chunks(text_data):
                     
                     # Add variations with common synonyms for payment-related questions
                     if any(term in question.lower() for term in ["betalsätt", "betalmetod", "betalmedel", "kort", 
-                                                              "betalkort", "betalning", "betala"]):
+                                                                "betalkort", "betalning", "betala"]):
                         payment_variations = [
                             "hur ändrar jag betalmedel",
                             "hur byter jag betalsätt",
@@ -241,41 +243,41 @@ def prepare_chunks(text_data):
             
             # Save the chunk if it has content
             if current_chunk.strip():
-                chunks.append(current_chunk.strip())
-                sources.append(source)
+                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
-        overlap_chunks = []
-        overlap_sources = []
+        # Create overlapping chunks for better context preservation for THIS source
+        overlap_chunks_for_file = []
+        overlap_sources_for_file = []
         
-        for j in range(0, len(chunks)):
-            overlap_chunks.append(chunks[j])
-            overlap_sources.append(sources[j])
+        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])
             
-            # Create an overlapping chunk with the next chunk if it exists
-            if j < len(chunks) - 1 and chunks[j].endswith(chunks[j+1][:CHUNK_OVERLAP]):
-                # Skip if there's already significant overlap
-                continue
-                
-            if j < len(chunks) - 1:
+            if j < len(current_file_chunks) - 1:
                 # Calculate available space in the current chunk
-                space_left = MAX_CHUNK_SIZE - len(chunks[j])
+                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:
-                    overlap_text = chunks[j] + " " + chunks[j+1][:CHUNK_OVERLAP]
-                    overlap_chunks.append(overlap_text)
-                    overlap_sources.append(sources[j])
+                    # Ensure we don't duplicate if chunks are already naturally overlapping significantly
+                    # This check could be more sophisticated, but a simple end/start check helps
+                    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]) # or a combined source if preferred
+
+        chunks_list.extend(overlap_chunks_for_file)
+        sources_list.extend(overlap_sources_for_file)
         
-        chunks = overlap_chunks
-        sources = overlap_sources
-    
-    print(f"Genererade {len(chunks)} chunks med {len(faq_dict)} FAQ-par")
-    return chunks, sources
+    print(f"Genererade {len(chunks_list)} chunks med {len(faq_dict)} FAQ-par")
+    return chunks_list, sources_list
+
 
 def initialize_embeddings():
     """Initierar SentenceTransformer och FAISS-index vid första anrop."""
@@ -287,17 +289,41 @@ def initialize_embeddings():
         print("Laddar textdata...")
         text_data = {"local_files": load_local_files()}
         print("Förbereder textsegment...")
-        chunks, chunk_sources = prepare_chunks(text_data)
+        chunks, chunk_sources = prepare_chunks(text_data) # Assign to global chunks and chunk_sources
         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') # Ladda embedder ändå
+            embeddings = np.array([]).reshape(0, embedder.get_sentence_embedding_dimension())
+            index = faiss.IndexFlatIP(embedder.get_sentence_embedding_dimension())
+            # index.add() kommer inte anropas om embeddings är tomma.
+            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)
-        embeddings /= np.linalg.norm(embeddings, axis=1, keepdims=True)
-        index = faiss.IndexFlatIP(embeddings.shape[1])
-        index.add(embeddings)
-        print("FAISS-index klart")
         
+        # Normalisera embeddings för IndexFlatIP (dot product)
+        if embeddings.ndim == 2 and embeddings.shape[0] > 0: # Check if embeddings is not empty
+            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 # Default dimension
+            index = faiss.IndexFlatIP(dimension)
+            print("FAISS-index initialiserat tomt.")
+
         # Print FAQ dictionary keys for debugging
         print(f"FAQ Dictionary innehåller {len(faq_dict)} nycklar")
         if len(faq_dict) > 0:
@@ -334,8 +360,8 @@ OBS! Se till att kortet har pengar och att det är upplåst för internetbetalni
         if ("ändra" in query_lower or "byta" in query_lower or "uppdatera" in query_lower) and \
            ("ändra" in key or "byta" in key or "uppdatera" in key):
             # Check if key and query share important terms
-            query_terms = set(query_lower.split())
-            key_terms = set(key.split())
+            query_terms = set(re.findall(r'\w+', query_lower)) # Use regex to get words
+            key_terms = set(re.findall(r'\w+', key))
             if len(query_terms.intersection(key_terms)) >= 2:  # At least 2 words in common
                 return value
     
@@ -353,15 +379,24 @@ def retrieve_context(query, k=RETRIEVAL_K):
         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: # Check if index is usable
+        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)
-    query_embedding /= np.linalg.norm(query_embedding)
+    # 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 # Undvik division med noll
+    query_embedding = query_embedding / query_embedding_norm
+    
     D, I = index.search(query_embedding, k)
-    retrieved, sources = [], set()
+    retrieved, sources_set = [], set() # Renamed to avoid conflict
     for idx in I[0]:
-        if idx < len(chunks):
+        if 0 <= idx < len(chunks): # Ensure index is valid
             retrieved.append(chunks[idx])
-            sources.add(chunk_sources[idx])
-    return " ".join(retrieved), list(sources)
+            sources_set.add(chunk_sources[idx]) # Use chunk_sources which is global
+    return " ".join(retrieved), list(sources_set)
+
 
 # Ladda prompt template
 prompt_template = load_prompt()
@@ -369,6 +404,7 @@ 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
+    # En "tur" är en user + assistant. Så 10 meddelanden = 5 turns.
     recent_history = chat_history[-10:] if len(chat_history) > 10 else chat_history
     
     messages = []
@@ -384,39 +420,40 @@ def format_chat_history_for_claude(chat_history):
 def generate_answer(query, chat_history=None):
     """Genererar svar baserat på fråga, chatthistorik och retrieval-baserad kontext med Claude Sonnet 4."""
     # Hämta relevant kontext via RAG istället för hela databasen
-    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."
+    context, sources = retrieve_context(query) # sources är en lista med källor
     
+    if not context.strip(): # Om context är tom, efterfråga mer info eller ge standard svar
+        # Detta kan hända om RAG inte hittar något relevant.
+        # Vi kan fortfarande försöka svara med Claude, men utan RAG-kontext.
+        print("Ingen RAG-kontext hittades. Försöker svara utan.")
+        # return "Jag hittar ingen relevant information i mina källor för att svara på din fråga. Kan du omformulera eller ge mer detaljer?\n\nDetta är ett AI genererat svar."
+
     # System-prompts
     system_prompt = prompt_template
     
     # Förbered meddelanden för Claude API
-    messages = []
+    messages = [] # Starta med en tom lista för varje nytt anrop
     
-    # Lägg till chatthistorik om den finns
-    if chat_history and len(chat_history) > 1:
-        # Formatera tidigare meddelanden (exkludera det senaste som är den aktuella frågan)
+    # Lägg till chatthistorik om den finns och är meningsfull
+    # chat_history inkluderar nu den aktuella användarfrågan som sista element.
+    # Vi vill skicka historiken *före* den aktuella frågan till format_chat_history_for_claude.
+    if chat_history and len(chat_history) > 1: # Minst en tidigare tur (user + assistant) + aktuell user
+        # chat_history[:-1] kommer att exkludera den aktuella användarens fråga, vilket är korrekt här.
         formatted_history = format_chat_history_for_claude(chat_history[:-1])
         messages.extend(formatted_history)
     
     # Skapa användarmeddelandet med kontext och aktuell fråga
-    user_message = f"""Jag har en fråga om ChargeNode.
-
-Relevant kontext för frågan:
-{context}
-
-Min fråga är: {query}"""
-    
-    # Lägg till det aktuella användarmeddelandet
-    messages.append({"role": "user", "content": user_message})
+    user_message_content = f"Relevant kontext för frågan:\n{context}\n\nMin fråga är: {query}"
+    if not context.strip(): # Om ingen kontext, förenkla prompten
+        user_message_content = f"Min fråga är: {query}"
+        
+    messages.append({"role": "user", "content": user_message_content})
     
     try:
         # Använd Claude Sonnet 4 med RAG-baserad kontext och chatthistorik
         response = anthropic_client.messages.create(
             model=MODEL_NAME,
-            max_tokens=500,
+            max_tokens=1024, # Ökat något för att tillåta längre svar om det behövs
             temperature=0.3,
             system=system_prompt,
             messages=messages
@@ -476,18 +513,18 @@ 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 uppvote, annars False.
+    data.liked är True om upvote, annars False.
     data.value innehåller information om meddelandet.
     """
     feedback_type = "up" if data.liked else "down"
-    global last_log
+    global last_log # Använd den globala variabeln
     log_entry = {
         "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         "feedback": feedback_type,
         "bot_reply": data.value if not isinstance(data.value, dict) else data.value.get("value")
     }
     # Om global logdata finns, lägg till ytterligare metadata.
-    if last_log:
+    if last_log: # Kontrollera att last_log inte är None
         log_entry.update({
             "session_id": last_log.get("session_id"),
             "user_message": last_log.get("user_message"),
@@ -498,7 +535,7 @@ def vote(data: gr.LikeData):
     
     # Skicka feedback till Slack
     try:
-        if feedback_type == "down":  # Skicka bara negativ feedback
+        if feedback_type == "down" and last_log:  # Skicka bara negativ feedback och om last_log finns
             feedback_message = f"""
 *⚠️ Negativ feedback registrerad*
 
@@ -597,8 +634,10 @@ def generate_monthly_stats(days=30):
             except:
                 pass  # Hoppa över poster med ogiltigt datum
     
-    logs = filtered_logs
-    
+    logs = filtered_logs # Använd filtrerade loggar
+    if not logs: # Kontrollera igen efter filtrering
+        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))
@@ -611,7 +650,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]
+    response_times = [log.get('response_time', 0) for log in logs if 'response_time' in log and isinstance(log.get('response_time'), (int, float))]
     avg_response_time = sum(response_times) / len(response_times) if response_times else 0
     
     # Plattformsstatistik
@@ -660,8 +699,8 @@ def simple_status_report():
         stats = generate_monthly_stats(days=7)  # Senaste veckan
         
         # Skapa innehåll för Slack
-        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        subject = f"ChargeNode AI Bot - Status {now}"
+        now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Renamed to avoid conflict
+        subject = f"ChargeNode AI Bot - Status {now_str}"
         
         if 'error' in stats:
             content = f"*Fel vid generering av statistik:* {stats['error']}"
@@ -673,7 +712,7 @@ def simple_status_report():
         perf = stats["performance"]
         
         content = f"""
-*ChargeNode AI Bot - Statusrapport {now}*
+*ChargeNode AI Bot - Statusrapport {now_str}*
 
 *Basstatistik* (senaste 7 dagarna)
 - Totalt antal konversationer: {basic['total_conversations']}
@@ -688,8 +727,8 @@ def simple_status_report():
 """
         
         # Lägg till de senaste konversationerna
-        logs = read_logs()
-        conversations = get_latest_conversations(logs, 3)
+        all_logs = read_logs() # Renamed to avoid conflict with global logs
+        conversations = get_latest_conversations(all_logs, 3)
         
         if conversations:
             content += "\n*Senaste konversationer*\n"
@@ -711,12 +750,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):
+def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history_list): # Renamed to avoid confusion
     """Skickar en supportförfrågan till Slack."""
     try:
         # Formatera chat-historiken
         chat_content = ""
-        for msg in chat_history:
+        for msg in chat_history_list: # Use the renamed parameter
             if msg['role'] == 'user':
                 chat_content += f">*Användare:* {msg['content']}\n\n"
             elif msg['role'] == 'assistant':
@@ -769,6 +808,8 @@ scheduler_thread.start()
 try:
     print("Skickar en inledande statusrapport för att verifiera Slack-integrationen...")
     # Anropa inte direkt här - sker i schemaläggaren
+    # Om du vill testa direkt vid uppstart kan du anropa simple_status_report() här
+    # simple_status_report() 
 except Exception as e:
     print(f"Information: Statusrapport kommer att skickas enligt schema: {e}")
 
@@ -803,7 +844,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
     # Chat interface
     with gr.Group(visible=True) as chat_interface:
         chatbot = gr.Chatbot(value=initial_chat, type="messages", elem_id="chatbot_conversation")
-        chatbot.like(vote, None, None)
+        chatbot.like(vote, None, None) # vote-funktionen anropas med data från chatbot-komponenten
         
         with gr.Row():
             msg = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...")
@@ -835,26 +876,30 @@ 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, request: gr.Request):
+    # KORRIGERAD respond-funktion
+    def respond(message, chat_history_list, request: gr.Request): # Renamed chat_history to chat_history_list for clarity
         global last_log
-        start = time.time()
+        start_time = time.time() # Renamed to avoid conflict
         
-        # Skicka hela chatthistoriken till generate_answer
-        response = generate_answer(message, chat_history)
-        elapsed = round(time.time() - start, 2)
+        # 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)
 
         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:
+        if last_log and 'session_id' in last_log: # Check last_log is not None
             session_id = last_log.get('session_id')
             
         user_id = request.client.host if request else "okänd"
 
         ua_str = request.headers.get("user-agent", "")
         ref = request.headers.get("referer", "")
-        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0]
+        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0].strip() # Added strip()
         ua = parse_ua(ua_str)
         browser = f"{ua.browser.family} {ua.browser.version_string}"
         osys = f"{ua.os.family} {ua.os.version_string}"
@@ -862,9 +907,9 @@ 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:
+        elif "localhost" in ref or "127.0.0.1" in ref : # Added check for 127.0.0.1
             platform = "test"
-        elif "app" in ref:
+        elif "app" in ref: # This might need a more robust check
             platform = "app"
 
         log_data = {
@@ -872,32 +917,29 @@ 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,
+            "bot_reply": response_text,
             "response_time": elapsed,
             "ip": ip,
             "browser": browser,
             "os": osys,
             "platform": platform,
-            "chat_history_length": len(chat_history)  # Lägg till information om chatthistorikens längd
+            "chat_history_length": len(chat_history_list)
         }
 
-        # Använd den förbättrade loggfunktionen
         safe_append_to_log(log_data)
-        last_log = log_data
+        last_log = log_data # Uppdatera last_log med aktuell konversationsdata
 
         # Skicka varje konversation direkt till Slack
         try:
-            # Konversationsinnehåll
             conversation_content = f"""
 *Ny konversation {timestamp}*
 
 *Användare:* {message}
 
-*Bot:* {response[:300]}{'...' if len(response) > 300 else ''}
+*Bot:* {response_text[:300]}{'...' if len(response_text) > 300 else ''}
 
-*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform} | Chat längd: {len(chat_history)} meddelanden
+*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform} | Chat längd: {len(chat_history_list)} meddelanden
 """
-            # Skicka asynkront för att inte blockera svarstiden
             threading.Thread(
                 target=lambda: send_to_slack(f"Ny konversation", conversation_content),
                 daemon=True
@@ -905,26 +947,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}")
 
-        chat_history.append({"role": "user", "content": message})
-        chat_history.append({"role": "assistant", "content": response})
-        return "", chat_history
+        # 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
     
-    def format_chat_preview(chat_history):
-        if not chat_history:
+    def format_chat_preview(chat_history_list): # Renamed
+        if not chat_history_list:
             return "Ingen chatthistorik att visa."
         
         preview = ""
-        for msg in chat_history:
-            sender = "Användare" if msg["role"] == "user" else "Bot"
-            content = msg["content"]
+        for msg_item in chat_history_list: # Renamed msg to msg_item
+            sender = "Användare" if msg_item["role"] == "user" else "Bot"
+            content = msg_item["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):
-        preview = format_chat_preview(chat_history)
+    def show_support_form(chat_history_list): # Renamed
+        preview = format_chat_preview(chat_history_list)
         return {
             chat_interface: gr.Group(visible=False),
             support_interface: gr.Group(visible=True),
@@ -939,84 +981,83 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             success_interface: gr.Group(visible=False)
         }
     
-    def submit_support_form(områdeskod, uttagsnummer, email, chat_history):
+    def submit_support_form(omr_kod, uttags_nr, email_addr, chat_history_list): # Renamed parameters
         """Hanterar formulärinskickningen med bättre felhantering."""
-        print(f"Support-förfrågan: områdeskod={områdeskod}, uttagsnummer={uttagsnummer}, email={email}")
+        print(f"Support-förfrågan: områdeskod={omr_kod}, uttagsnummer={uttags_nr}, email={email_addr}")
         
-        # Validera input med tydligare loggning
         validation_errors = []
         
-        if områdeskod and not områdeskod.isdigit():
-            print(f"Validerar områdeskod: '{områdeskod}' (felaktig)")
+        if omr_kod and not omr_kod.isdigit():
+            print(f"Validerar områdeskod: '{omr_kod}' (felaktig)")
             validation_errors.append("Områdeskod måste vara numerisk.")
         else:
-            print(f"Validerar områdeskod: '{områdeskod}' (ok)")
+            print(f"Validerar områdeskod: '{omr_kod}' (ok)")
         
-        if uttagsnummer and not uttagsnummer.isdigit():
-            print(f"Validerar uttagsnummer: '{uttagsnummer}' (felaktig)")
+        if uttags_nr and not uttags_nr.isdigit():
+            print(f"Validerar uttagsnummer: '{uttags_nr}' (felaktig)")
             validation_errors.append("Uttagsnummer måste vara numerisk.")
         else:
-            print(f"Validerar uttagsnummer: '{uttagsnummer}' (ok)")
+            print(f"Validerar uttagsnummer: '{uttags_nr}' (ok)")
         
-        if not email:
+        if not email_addr:
             print("Validerar email: (saknas)")
             validation_errors.append("En giltig e-postadress krävs.")
-        elif '@' not in email or '.' not in email.split('@')[1]:
-            print(f"Validerar email: '{email}' (felaktigt format)")
+        elif '@' not in email_addr or '.' not in email_addr.split('@')[-1]: # Improved email validation slightly
+            print(f"Validerar email: '{email_addr}' (felaktigt format)")
             validation_errors.append("En giltig e-postadress krävs.")
         else:
-            print(f"Validerar email: '{email}' (ok)")
+            print(f"Validerar email: '{email_addr}' (ok)")
         
-        # Om det finns valideringsfel
         if validation_errors:
             print(f"Valideringsfel: {validation_errors}")
+            # Uppdatera chat_preview med felmeddelanden istället för att returnera en sträng direkt.
+            error_message_md = "**Fel:**\n" + "\n".join(f"- {err}" for err in validation_errors)
             return {
-                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)
+                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) # Uppdatera chat_preview komponenten
             }
         
-        # 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 in chat_history:
-                if 'role' in msg and 'content' in msg:
-                    chat_summary.append(f"{msg['role']}: {msg['content'][:30]}...")
+            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]}...")
             print(f"Chatthistorik att skicka: {chat_summary}")
             
-            # Skicka till Slack
-            success = send_support_to_slack(områdeskod, uttagsnummer, email, chat_history)
+            success = send_support_to_slack(omr_kod, uttags_nr, email_addr, chat_history_list)
             
             if success:
                 print("Support-förfrågan skickad till Slack framgångsrikt")
                 return {
-                    chat_interface: gr.Group(visible=False),
-                    support_interface: gr.Group(visible=False),
-                    success_interface: gr.Group(visible=True)
+                    chat_interface: gr.update(visible=False),
+                    support_interface: gr.update(visible=False),
+                    success_interface: gr.update(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.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.**"
+                    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)
                 }
         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.Group(visible=False),
-                support_interface: gr.Group(visible=True),
-                success_interface: gr.Group(visible=False),
-                chat_preview: f"**Ett fel uppstod: {str(e)}**"
+                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)
             }
     
     msg.submit(respond, [msg, chatbot], [msg, chatbot])
-    clear.click(lambda: initial_chat, None, chatbot, queue=False)
+    clear.click(lambda: initial_chat, None, chatbot, queue=False) # Använd initial_chat för att återställa
     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])
@@ -1028,8 +1069,9 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
 
 # Initialisera embeddings vid uppstart
 print("Förbereder embedding-modell och index...")
-initialize_embeddings()
+initialize_embeddings() # Detta anropas nu för att ladda allt
 print("Embedding-modell och index redo!")
 
 if __name__ == "__main__":
-    app.launch(share=True)
+    app.launch(share=IS_HUGGINGFACE) # share=True om du vill ha en publik länk, False för lokal körning
+                                     # IS_HUGGINGFACE kan användas för att styra detta.