Update app.py

app.py

@@ -3,7 +3,6 @@ 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
@@ -16,24 +15,20 @@ from sentence_transformers import SentenceTransformer
 import numpy as np
 import faiss
 import re
-from docx import Document # NYTT: Flyttad till toppen
-import PyPDF2 # NYTT: Flyttad till toppen
 
 # --- 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"
-FAQ_EXCEL_FILENAME = "FAQ stadat.xlsx" # NYTT: Konfigurerbart filnamn
 
+# Kontrollera om vi kör i Hugging Face-miljön
 IS_HUGGINGFACE = os.environ.get("SPACE_ID") is not None
 
-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:
     raise ValueError("ANTHROPIC_API_KEY saknas")
@@ -43,6 +38,7 @@ 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("")
@@ -52,128 +48,98 @@ hf_token = os.environ.get("HF_TOKEN")
 if not hf_token:
     raise ValueError("HF_TOKEN saknas")
 
+# Minsta möjliga konfiguration som bör fungera
 scheduler = CommitScheduler(
     repo_id="ChargeNodeEurope/logfiles",
     repo_type="dataset",
     folder_path=log_folder,
     path_in_repo="logs_v2",
-    every=300,
+    every=300,  # Vänta 5 minuter
     token=hf_token
 )
 
 # --- Globala variabler ---
-last_log = None
+last_log = None  # Sparar loggdata från senaste svar för feedback
+
+# Globala variabler för embeddings
 embedder = None
 embeddings = None
 index = None
 chunks = []
 chunk_sources = []
-faq_dict = {}
-
-# NYTT: Globala definitioner för nyckelord och typer (VIKTIGT: MÅSTE ANPASSAS EFTER BEHOV)
-# Dessa behövs av check_direct_match och dess hjälpfunktioner.
-# Anpassa listorna med relevanta termer för din applikation.
-system_keywords = {
-    "app": [
-        "app", "appen", "mobilapp", "mobil", "telefon", "ladda bil", "qr-kod", 
-        "betalkort i appen", "laddningar", "mitt kort", "mina sidor app", "kartvy", 
-        "favoriter", "laddhistorik", "starta laddning", "stoppa laddning"
-    ],
-    "portal": [
-        "portal", "portalen", "adminportal", "administrera", "webbportal", "dashboard", 
-        "hantera medlemmar", "organisationskonto", "företagsportal", "användare portal",
-        "statistik portal", "prissättning portal"
-    ],
-    "företagskonto": [ # För mer specifika företagskontofrågor som kanske inte är portaladmin
-        "företagskonto", "företagsavtal", "orgnummer", "organisationsnummer", 
-        "tjänstebil", "firmabil", "fakturor företag"
-    ],
-    "betalning_privat": [ # Används för att identifiera tydligt privata betalningsfrågor
-        "mitt betalsätt", "min betalmetod", "mitt kort", "min betalning", 
-        "privat betalkort", "personlig betalning", "uppdatera mitt kort"
-    ],
-}
-
-organization_types = [
-    "samfällighet", "samfällighetsförening", "bostadsrättsförening", "brf", "förening",
-    "organisation", "kommun", "företag", "fastighetsägare", "arbetsgivare"
-]
-
-# Används för att identifiera om en FAQ-nyckel i faq_dict är organisationsspecifik
-# Detta är en förenkling; idealiskt sett bör FAQ-objekt ha metadata eller separata dictionaries.
-# Dessa termer bör finnas i FRÅGAN (nyckeln) till en FAQ som är avsedd för organisationer.
-organization_faq_keys_substrings = [
-    "samfällighet", "förening", "organisation", "portal", "företag", 
-    "admin", "brf", "styrelse", "medlemmar", "avtal", "fakturering organisation"
-]
-# --- Slut på nya globala definitioner ---
+faq_dict = {}  # Dictionary för direktmatchning av vanliga frågor
 
 # --- 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()
+            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():
+    """Laddar alla lokala filer och returnerar som en sammanhängande text."""
     uploaded_text = ""
-    allowed = [".txt", ".docx", ".pdf", ".csv", ".xls", ".xlsx"]
+    allowed = [".txt", ".csv", ".xls", ".xlsx"]  # Tog bort .docx och .pdf
     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:
             try:
-                content = "" # NYTT: Initiera content
                 if file.endswith(".txt"):
                     with open(file, "r", encoding="utf-8") as f:
                         content = f.read()
-                elif file.endswith(".docx"):
-                    # Document är redan importerad globalt
-                    content = "\n".join([p.text for p in Document(file).paragraphs])
-                elif file.endswith(".pdf"):
-                    # PyPDF2 är redan importerad globalt
-                    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")):
-                    if file == FAQ_EXCEL_FILENAME: # ÄNDRAT: Använder global konstant
+                    if file == "FAQ stadat.xlsx":
                         df = pd.read_excel(file)
                         rows = []
                         for index, row in df.iterrows():
-                            row_text = f"Fråga: {row.get('Fråga', '')}\nSvar: {row.get('Svar', '')}" # ÄNDRAT: Använd .get() för säkerhet
-                            if 'kategori' in df.columns and pd.notna(row.get('kategori')):
+                            # Start with the required fields
+                            row_text = f"Fråga: {row['Fråga']}\nSvar: {row['Svar']}"
+                            
+                            # Add kategori if it exists in the dataframe
+                            if 'kategori' in df.columns:
                                 row_text += f"\nKategori: {row['kategori']}"
-                            elif 'Kategori' in df.columns and pd.notna(row.get('Kategori')):
+                            elif 'Kategori' in df.columns:  # Also check for capitalized version
                                 row_text += f"\nKategori: {row['Kategori']}"
+                                
                             rows.append(row_text)
                         content = "\n\n".join(rows)
                     else:
                         content = pd.read_excel(file).to_string()
-                
-                if content: # NYTT: Lägg bara till om content finns
-                    uploaded_text += f"\n\nFIL: {file}\n{content}"
+                uploaded_text += f"\n\nFIL: {file}\n{content}"
             except Exception as e:
                 print(f"Fel vid läsning av {file}: {str(e)}")
     return uploaded_text.strip()
 
 def load_prompt():
+    """Läser in system-prompts från prompt.txt med bättre felhantering."""
     try:
         with open("prompt.txt", "r", encoding="utf-8") as f:
             prompt_content = f.read().strip()
@@ -190,54 +156,55 @@ def load_prompt():
 
 # --- Förbättrad chunking ---
 def prepare_chunks(text_data):
-    chunks_list, sources_list = [], [] 
+    """Delar upp texten i mindre segment för embedding och sökning."""
+    chunks_list, sources_list = [], []
     global faq_dict
     
-    for source, text in text_data.items(): # source kommer vara "local_files" här
+    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 = [] # Kommer bara innehålla "local_files" upprepat
+        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()
+                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:
-                            if len(current_chunk) > MAX_CHUNK_SIZE * 1.5: 
+                            # 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] # Kan göra chunken för lång
+                                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()
                     
-                    if question and answer_text: # NYTT: Se till att både fråga och svar finns
-                        faq_dict[question.lower()] = answer_text
-                        # Betalningsvariationer (som tidigare)
-                        if any(term in question.lower() for term in ["betalsätt", "betalmetod", "betalmedel", "kort", 
-                                                                    "betalkort", "betalning", "betala"]):
-                            payment_variations = [
-                                "hur ändrar jag betalmedel", "hur byter jag betalsätt",
-                                "hur uppdaterar jag mitt betalkort", "hur ändrar jag betalmetod",
-                                "hur byter jag betalningsmetod", "hur ändrar jag betalkort"
-                            ]
-                            for variation in payment_variations:
-                                faq_dict[variation.lower()] = answer_text # NYTT: .lower() på variationen
+                    # Add the original question to the dictionary
+                    faq_dict[question.lower()] = answer_text
             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]
@@ -245,63 +212,60 @@ def prepare_chunks(text_data):
                         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) # 'source' är "local_files"
+                current_file_sources.append(source)
             
-            if i == start_idx and i < len(paragraphs): # ÄNDRAT: Undvik oändlig loop om en paragraf är för lång
-                print(f"VARNING: Paragrafen som börjar med '{paragraphs[i][:50]}...' är längre än MAX_CHUNK_SIZE och kan inte behandlas som en enskild chunk. Skippar för att undvika oändlig loop.")
-                i += 1 # Hoppa över den problematiska paragrafen
-            elif i == start_idx and i >= len(paragraphs): # Säkerhetskoll
-                 break
-
-
+            # 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]) # Fortfarande "local_files"
+            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:
-                    # Enkel kontroll för att undvika att lägga till exakt samma text igen
-                    # Detta är en mycket grundläggande överlappskontroll
-                    next_chunk_overlap_part = current_file_chunks[j+1][:CHUNK_OVERLAP]
-                    if not current_file_chunks[j].endswith(next_chunk_overlap_part): # Undvik exakt duplikat av slutet
-                        overlap_text = current_file_chunks[j] + " " + next_chunk_overlap_part
-                        if len(overlap_text) <= MAX_CHUNK_SIZE:
+                    # 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
 
 
 def initialize_embeddings():
+    """Initierar SentenceTransformer och FAISS-index vid första anrop."""
     global embedder, embeddings, index, chunks, chunk_sources, faq_dict
     
     if embedder is None:
         print("Initierar SentenceTransformer och FAISS-index...")
+        # Ladda och förbered lokal data
         print("Laddar textdata...")
-        # KOMMENTAR: Med nuvarande load_local_files() och prepare_chunks kommer 
-        # 'chunk_sources' endast att innehålla "local_files". För mer granulär
-        # källspårning (per fil), behöver load_local_files() returnera en dictionary
-        # med källor som nycklar och texter som värden, och prepare_chunks()
-        # anpassas för att hantera detta (liknande de "enhanced"-versionerna
-        # i den ursprungliga, större kodbasen).
-        text_data = {"local_files": load_local_files()} 
+        text_data = {"local_files": load_local_files()}
         print("Förbereder textsegment...")
         chunks, chunk_sources = prepare_chunks(text_data)
-        print(f"{len(chunks)} segment laddade. {len(chunk_sources)} källor (förväntas vara samma antal).")
+        print(f"{len(chunks)} segment laddade")
 
         if not chunks:
             print("Varning: Inga chunks genererades. Kontrollera textkällor och chunking-logik.")
-            embedder = SentenceTransformer('all-MiniLM-L6-v2') 
+            # 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.")
@@ -309,10 +273,12 @@ def initialize_embeddings():
 
         print("Skapar embeddings...")
         embedder = SentenceTransformer('all-MiniLM-L6-v2')
-        embeddings = embedder.encode(chunks, convert_to_numpy=True, show_progress_bar=True) # NYTT: show_progress_bar
+        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
             
@@ -321,249 +287,115 @@ def initialize_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")
-        if len(faq_dict) > 0:
-            payment_keys_example = [k for k in faq_dict.keys() if any(term in k for term in ["betalsätt", "betalmetod", "betalmedel"])]
-            print(f"Exempel på betalningsrelaterade FAQ-nycklar: {payment_keys_example[:5]}")
-
-
-# --- Kontextmedveten direct match ---
-# Hjälpfunktioner (som tidigare föreslagits, behöver finjusteras)
-def _is_app_focused(query_lower):
-    global system_keywords # Använd global
-    # Kollar om frågan innehåller starka app-indikatorer OCH individualitet
-    if any(app_term in query_lower for app_term in system_keywords.get("app", [])):
-        if any(individual_term in query_lower for individual_term in ["jag", "mitt", "min", "mina"]):
-            return True
-        # Om "appen" nämns explicit med en typisk app-åtgärd (även med "vi")
-        if any(app_action in query_lower for app_action in system_keywords.get("betalning_privat", []) + ["laddning", "betalkort"]):
-             return True
-    return False
-
-def _is_org_admin_focused(query_lower):
-    global system_keywords, organization_types # Använd globala
-    is_org_type = any(org_type in query_lower for org_type in organization_types)
-    has_collective_pronoun = any(pronoun in query_lower for pronoun in ["vi", "vår", "våra", "oss", "föreningen", "organisationen"])
-
-    if is_org_type or has_collective_pronoun:
-        if any(portal_term in query_lower for portal_term in system_keywords.get("portal", [])):
-            return True
-        # Termer som starkt pekar på administration av organisationens uppgifter
-        org_admin_terms = ["uppgifter", "avtal", "fakturor", "medlemmar", "styrelse", "ekonomi", "administration"]
-        if any(org_admin_term in query_lower for org_admin_term in org_admin_terms) and \
-           not _is_app_focused(query_lower): # Viktigt: inte om det redan är klassat som app-fokuserat
-            return True
-    return False
 
 def check_direct_match(query):
-    global faq_dict, system_keywords, organization_types, organization_faq_keys_substrings
-
+    """Kontrollerar om frågan matchar någon av våra fördefinierade FAQ-svar."""
     query_lower = query.lower().strip('?').strip()
-
-    is_app_query = _is_app_focused(query_lower)
-    is_org_admin_query = _is_org_admin_focused(query_lower) and not is_app_query # Prioritera app-fokus
-
-    # 1. App-specifika frågor
-    if is_app_query:
-        print(f"INFO: check_direct_match - Query klassad som APP-FOKUSERAD: '{query}'")
-        payment_prefixes = ["hur ändrar jag", "hur byter jag", "hur uppdaterar jag", "hur lägger jag till", "hur adderar jag", "hur registrerar jag"]
-        app_payment_terms_combined = system_keywords.get("betalning_privat", []) + ["betalkort", "kort", "betalmedel", "betalningsmetod"]
-        
-        if any(query_lower.startswith(prefix) for prefix in payment_prefixes) and \
-           any(term in query_lower for term in app_payment_terms_combined):
-            payment_answer = """Så här lägger du till/ändrar betalkort: 
-1. Öppna ChargeNode-appen
-2. Tryck på 'Meny' (hamburgerikon) i nedre menyn
-3. Välj 'Mina betalsätt' eller 'Betalningsmetoder'  
-4. För att lägga till nytt kort: Tryck på 'Lägg till kort' eller '+' knappen
-   För att ersätta befintligt kort: Tryck på 'Ersätt kort'
-5. Godkänn våra villkor 
-6. Tryck på 'Kortbetalning' under "bekräfta för auktorisering" 
-7. Lägg in dina kortuppgifter 
-8. Bekräfta med BankID
-
-OBS! Se till att kortet har pengar och att det är upplåst för internetbetalningar."""
-            print(f"DEBUG: Direkt matchning (hårdkodad app-betalning) för: {query}")
-            return payment_answer
-
-        if query_lower in faq_dict:
-            # För app-frågor, returnera om nyckeln INTE ser ut som en org-admin-specifik nyckel
-            if not any(org_key_sub in query_lower for org_key_sub in organization_faq_keys_substrings):
-                print(f"DEBUG: Direkt matchning (FAQ, app-fokus) för: {query}")
-                return faq_dict[query_lower]
-        
-        # Fuzzy matchning för app-frågor
-        for key, value in faq_dict.items():
-            if any(org_key_sub in key.lower() for org_key_sub in organization_faq_keys_substrings):
-                continue # Hoppa över organisationsspecifika FAQ-nycklar
-            
-            # Enkel fuzzy: minst två gemensamma ord och nyckelord som "ändra"
-            key_lower = key.lower()
-            if ("ändra" in query_lower or "byta" in query_lower or "uppdatera" in query_lower) and \
-               ("ändra" in key_lower or "byta" in key_lower or "uppdatera" in key_lower):
-                query_terms = set(re.findall(r'\b\w+\b', query_lower)) # Hitta hela ord
-                key_terms = set(re.findall(r'\b\w+\b', key_lower))
-                if len(query_terms.intersection(key_terms)) >= 2:
-                    print(f"DEBUG: Fuzzy matchning (FAQ, app-fokus) för: '{query}' med nyckel '{key}'")
-                    return value
-        print(f"INFO: App-fokuserad fråga '{query}' - ingen app-specifik FAQ-matchning, låter RAG hantera.")
-        return None # Faller igenom till RAG för app-frågor utan direktträff
-
-    # 2. Organisations-admin-specifika frågor
-    elif is_org_admin_query:
-        print(f"INFO: check_direct_match - Query klassad som ORG-ADMIN-FOKUSERAD: '{query}'")
-        if query_lower in faq_dict:
-            # För org-admin-frågor, returnera endast om nyckeln (frågan) ser org-specifik ut
-            if any(org_key_sub in query_lower for org_key_sub in organization_faq_keys_substrings):
-                print(f"DEBUG: Direkt matchning (FAQ, org-admin-fokus via query_lower check) för: {query}")
-                return faq_dict[query_lower]
-        
-        # Fuzzy matchning för org-admin-frågor
-        for key, value in faq_dict.items():
-            key_lower = key.lower()
-            # Matcha endast med nycklar som är tydligt organisationsspecifika
-            if not any(org_key_sub in key_lower for org_key_sub in organization_faq_keys_substrings):
-                continue 
-            
-            if ("ändra" in query_lower or "logga in" in query_lower or "hantera" in query_lower) and \
-               ("ändra" in key_lower or "logga in" in key_lower or "hantera" in key_lower or \
-                any(org_key_sub in key_lower for org_key_sub in organization_faq_keys_substrings) ): # Förstärk att nyckeln är org
-                query_terms = set(re.findall(r'\b\w+\b', query_lower))
-                key_terms = set(re.findall(r'\b\w+\b', key_lower))
-                if len(query_terms.intersection(key_terms)) >= 2:
-                    print(f"DEBUG: Fuzzy matchning (FAQ, org-admin-fokus) för: '{query}' med nyckel '{key}'")
-                    return value
-        print(f"INFO: Org-admin fråga '{query}' - ingen specifik org-FAQ-matchning, låter RAG hantera.")
-        return None
-
-    # 3. Fallback till generell FAQ-matchning om kontexten är oklar
-    print(f"INFO: check_direct_match - Query klassad som OKLAR/GENERELL: '{query}'")
+    
+    # Check if query directly matches a FAQ
     if query_lower in faq_dict:
-        # Undvik att returnera en väldigt specifik org-admin FAQ om frågan är generell
-        if not any(org_key_sub in query_lower for org_key_sub in organization_faq_keys_substrings):
-             print(f"DEBUG: Direkt matchning (FAQ, fallback generell) för: {query}")
-             return faq_dict[query_lower]
-
-    # Generell fuzzy matchning
+        return faq_dict[query_lower]
+    
+    # Check for close matches using pattern matching
     for key, value in faq_dict.items():
-        key_lower = key.lower()
-        # Undvik att matcha med väldigt app-specifika eller org-specifika nycklar om frågan är generell
-        # Detta är svårt att göra perfekt utan mer metadata på FAQ:er
-        if any(app_term in key_lower for app_term in system_keywords.get("app",[])) and \
-           not any(app_term in query_lower for app_term in system_keywords.get("app",[])):
-            continue # Hoppa över om nyckeln är app-specifik men frågan inte är det
-        if any(org_key_sub in key_lower for org_key_sub in organization_faq_keys_substrings) and \
-           not any(org_key_sub in query_lower for org_key_sub in organization_faq_keys_substrings):
-            continue # Hoppa över om nyckeln är org-specifik men frågan inte är det
-
-        if ("ändra" in query_lower or "byta" in query_lower or "hur gör jag" in query_lower) and \
-           ("ändra" in key_lower or "byta" in key_lower or "hur" in key_lower ) :
-            query_terms = set(re.findall(r'\b\w+\b', query_lower))
-            key_terms = set(re.findall(r'\b\w+\b', key_lower))
-            if len(query_terms.intersection(key_terms)) >= 1: # Lägre tröskel för generell fallback
-                print(f"DEBUG: Fuzzy matchning (FAQ, fallback generell) för: '{query}' med nyckel '{key}'")
-                return value
-    
-    print(f"INFO: Ingen direkt FAQ-matchning alls för '{query}', låter RAG hantera.")
+        # 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
 
 def retrieve_context(query, k=RETRIEVAL_K):
-    # initialize_embeddings() # ÄNDRAT: Anropas vid uppstart istället
+    """Hämtar relevant kontext för frågor med direkt matchning för vanliga 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"DEBUG: retrieve_context - Direkt matchning hittad för frågan: {query}")
+        print(f"Direkt matchning hittad för frågan: {query}")
         return f"Fråga: {query}\nSvar: {direct_match}", ["direct_match"]
     
-    print(f"DEBUG: retrieve_context - Ingen direkt matchning, fortsätter med RAG för: {query}")
+    # 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.")
+        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
     
     D, I = index.search(query_embedding, k)
     retrieved, sources_set = [], set()
-    
-    # ÄNDRAT: Använd globala 'chunks' och 'chunk_sources' som fylls av initialize_embeddings()
-    # Säkerställ att dessa globala variabler faktiskt innehåller data
-    if not chunks or not chunk_sources:
-        print("VARNING: Globala 'chunks' eller 'chunk_sources' är tomma. RAG kommer inte fungera korrekt.")
-        return "", []
-
     for idx in I[0]:
-        if 0 <= idx < len(chunks): 
+        if 0 <= idx < len(chunks):
             retrieved.append(chunks[idx])
-            # chunk_sources kommer bara innehålla "local_files" med nuvarande setup
-            if idx < len(chunk_sources): # Säkerhetskoll
-                 sources_set.add(chunk_sources[idx])
-            else:
-                 sources_set.add("okänd_källa_pga_index_fel") # Fallback
-    
-    if not retrieved:
-        print(f"DEBUG: retrieve_context - RAG hittade inga chunks för: {query}")
-    else:
-        print(f"DEBUG: retrieve_context - RAG hittade {len(retrieved)} chunks för: {query} från källor: {list(sources_set)}")
+            sources_set.add(chunk_sources[idx])
     return " ".join(retrieved), list(sources_set)
 
-# --- Resten av koden (generate_answer, Slack, Gradio UI, etc.) ---
-# Dessa delar antas vara i stort sett korrekta från tidigare granskning,
-# förutsatt att de globala nyckelordsvariablerna är korrekt definierade.
-# Jag har bytt namn på vissa lokala variabler i Gradio-funktionerna för att undvika skuggning.
-
+# 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_item in recent_history: # ÄNDRAT: msg till msg_item
-        if msg_item["role"] in ["user", "assistant"]:
+    for msg in recent_history:
+        if msg["role"] in ["user", "assistant"]:
             messages.append({
-                "role": msg_item["role"],
-                "content": msg_item["content"]
+                "role": msg["role"],
+                "content": msg["content"]
             })
+    
     return messages
 
 def generate_answer(query, chat_history=None):
-    context, sources = retrieve_context(query) 
+    """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():
-        print(f"INFO: generate_answer - Ingen RAG-kontext hittades för '{query}'. Försöker svara utan.")
-    
+        print("Ingen RAG-kontext hittades. Försöker svara utan.")
+
+    # System-prompts
     system_prompt = prompt_template
-    messages_for_api = [] # ÄNDRAT: Nytt namn för att undvika konflikt
     
-    if chat_history and len(chat_history) > 1: 
+    # Förbered meddelanden för Claude API
+    messages = []
+    
+    # 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_for_api.extend(formatted_history)
+        messages.extend(formatted_history)
     
+    # 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_for_api.append({"role": "user", "content": user_message_content})
+    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=1024,
             temperature=0.3,
             system=system_prompt,
-            messages=messages_for_api # ÄNDRAT
+            messages=messages
         )
         answer = response.content[0].text
-        # NYTT: Lägg till källor om de finns och inte bara är 'direct_match'
-        if sources and sources != ["direct_match"]:
-            source_info = f"\n\n📚 Källor: {', '.join(set(s for s in sources if s))}" # Filtrera bort None/tomma källor
-            answer += source_info
-
         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)}")
@@ -571,18 +403,39 @@ def generate_answer(query, chat_history=None):
 
 # --- 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}}
+                {
+                    "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"})
+        
+        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
@@ -595,36 +448,52 @@ def send_to_slack(subject, content, color="#2a9d8f"):
 
 # --- Feedback & Like-funktion ---
 def vote(data: gr.LikeData):
+    """
+    Hanterar feedback från Gradio's inbyggda like-funktion.
+    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 
-    log_entry_vote = { # ÄNDRAT: Nytt namn
+    global last_log
+    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")
     }
-    if last_log: 
-        log_entry_vote.update({
+    # Om global logdata finns, lägg till ytterligare metadata.
+    if last_log:
+        log_entry.update({
             "session_id": last_log.get("session_id"),
             "user_message": last_log.get("user_message"),
         })
-    safe_append_to_log(log_entry_vote) # ÄNDRAT
+    
+    # Använd den förbättrade loggfunktionen
+    safe_append_to_log(log_entry)
+    
+    # Skicka feedback till Slack
     try:
         if feedback_type == "down" and last_log:
             feedback_message = f"""
 *⚠️ Negativ feedback registrerad*
+
 *Fråga:* {last_log.get('user_message', 'Okänd fråga')}
-*Svar:* {log_entry_vote.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry_vote.get('bot_reply', '')) > 300 else ''}"""
+
+*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: send_to_slack("Negativ feedback", feedback_message, "#ff0000"),
                 daemon=True
             ).start()
     except Exception as e:
         print(f"Kunde inte skicka feedback till Slack: {e}")
+    
     return
 
 # --- Rapportering ---
 def read_logs():
-    logs_list = [] # ÄNDRAT
+    """Läs alla loggposter från loggfilen."""
+    logs = []
     try:
         if os.path.exists(log_file_path):
             with open(log_file_path, "r", encoding="utf-8") as file:
@@ -632,340 +501,501 @@ def read_logs():
                 for line in file:
                     line_count += 1
                     try:
-                        log_entry_read = json.loads(line.strip()) # ÄNDRAT
-                        logs_list.append(log_entry_read)
+                        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_list)} av {line_count} loggposter")
+            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_list
-
-def get_latest_conversations(logs_data, limit=50): # ÄNDRAT
-    conversations_list = [] # ÄNDRAT
-    for log_item in reversed(logs_data): # ÄNDRAT
-        if 'user_message' in log_item and 'bot_reply' in log_item:
-            conversations_list.append({
-                'user_message': log_item['user_message'],
-                'bot_reply': log_item['bot_reply'],
-                'timestamp': log_item.get('timestamp', '')
+    return logs
+
+def get_latest_conversations(logs, limit=50):
+    """Hämta de senaste frågorna och svaren."""
+    conversations = []
+    for log in reversed(logs):
+        if 'user_message' in log and 'bot_reply' in log:
+            conversations.append({
+                'user_message': log['user_message'],
+                'bot_reply': log['bot_reply'],
+                'timestamp': log.get('timestamp', '')
             })
-            if len(conversations_list) >= limit:
+            if len(conversations) >= limit:
                 break
-    return conversations_list
+    return conversations
 
-def get_feedback_stats(logs_data): # ÄNDRAT
+def get_feedback_stats(logs):
+    """Sammanfatta feedback (tumme upp/ned)."""
     feedback_count = {"up": 0, "down": 0}
     negative_feedback_examples = []
-    for log_item in logs_data: # ÄNDRAT
-        if 'feedback' in log_item:
-            feedback = log_item.get('feedback')
+    
+    for log in logs:
+        if 'feedback' in log:
+            feedback = log.get('feedback')
             if feedback in feedback_count:
                 feedback_count[feedback] += 1
-            if feedback == "down" and 'user_message' in log_item and len(negative_feedback_examples) < 10:
+                
+            # Samla exempel på negativ feedback
+            if feedback == "down" and 'user_message' in log and len(negative_feedback_examples) < 10:
                 negative_feedback_examples.append({
-                    'user_message': log_item.get('user_message', 'Okänd fråga'),
-                    'bot_reply': log_item.get('bot_reply', 'Okänt svar')
+                    'user_message': log.get('user_message', 'Okänd fråga'),
+                    'bot_reply': log.get('bot_reply', 'Okänt svar')
                 })
+    
     return feedback_count, negative_feedback_examples
 
 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...")
-    logs_data_monthly = read_logs() # ÄNDRAT
-    if not logs_data_monthly:
+    
+    # Hämta loggar
+    logs = read_logs()
+    
+    if not logs:
         return {"error": "Inga loggar hittades för den angivna perioden"}
     
-    now_time = datetime.now() # ÄNDRAT
-    cutoff_date = now_time - timedelta(days=days)
-    filtered_logs_monthly = [] # ÄNDRAT
+    # Filtrera på datumintervall
+    now = datetime.now()
+    cutoff_date = now - timedelta(days=days)
+    filtered_logs = []
     
-    for log_item_monthly in logs_data_monthly: # ÄNDRAT
-        if 'timestamp' in log_item_monthly:
+    for log in logs:
+        if 'timestamp' in log:
             try:
-                log_date = datetime.strptime(log_item_monthly['timestamp'], "%Y-%m-%d %H:%M:%S")
+                log_date = datetime.strptime(log['timestamp'], "%Y-%m-%d %H:%M:%S")
                 if log_date >= cutoff_date:
-                    filtered_logs_monthly.append(log_item_monthly)
-            except ValueError: # ÄNDRAT: Mer specifik exception
-                pass 
+                    filtered_logs.append(log)
+            except:
+                pass  # Hoppa över poster med ogiltigt datum
     
-    logs_to_process = filtered_logs_monthly # ÄNDRAT
-    if not logs_to_process:
+    logs = filtered_logs
+    if not logs:
         return {"error": f"Inga loggar hittades för de senaste {days} dagarna"}
 
-    total_conversations = sum(1 for log in logs_to_process if 'user_message' in log)
-    # ... (resten av statistiken använder logs_to_process) ...
-    # (antar att resten av logiken i denna funktion är ok)
-    unique_sessions = len(set(log.get('session_id', 'unknown') for log in logs_to_process if 'session_id' in log))
-    unique_users = len(set(log.get('user_id', 'unknown') for log in logs_to_process if 'user_id' in log))
-    feedback_logs = [log for log in logs_to_process if 'feedback' in log]
+    # 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
-    response_times = [log.get('response_time', 0) for log in logs_to_process if 'response_time' in log and isinstance(log.get('response_time'), (int, float))]
+    
+    # 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))]
     avg_response_time = sum(response_times) / len(response_times) if response_times else 0
+    
+    # Plattformsstatistik
     platforms = {}
     browsers = {}
     operating_systems = {}
-    for log in logs_to_process:
-        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
+    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": now_time.strftime("%Y-%m-%d %H:%M:%S"), # ÄNDRAT
-        "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
+        "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():
+    """Skickar en förenklad statusrapport till Slack."""
     print("Genererar statusrapport för Slack...")
+    
     try:
-        stats_report = generate_monthly_stats(days=7) # ÄNDRAT
-        now_str_report = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # ÄNDRAT
-        subject_report = f"ChargeNode AI Bot - Status {now_str_report}" # ÄNDRAT
+        # Generera statistik
+        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}"
         
-        if 'error' in stats_report:
-            content_report = f"*Fel vid generering av statistik:* {stats_report['error']}" # ÄNDRAT
-            return send_to_slack(subject_report, content_report, "#ff0000")
+        if 'error' in stats:
+            content = f"*Fel vid generering av statistik:* {stats['error']}"
+            return send_to_slack(subject, content, "#ff0000")
         
-        basic = stats_report["basic_stats"]
-        feedback_stat = stats_report["feedback"] # ÄNDRAT
-        perf = stats_report["performance"]
+        # Formatera statistik
+        basic = stats["basic_stats"]
+        feedback = stats["feedback"]
+        perf = stats["performance"]
         
-        content_report = f"""*ChargeNode AI Bot - Statusrapport {now_str_report}*
+        content = f"""
+*ChargeNode AI Bot - Statusrapport {now_str}*
+
 *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_stat['positive']}
-- 👎 Tumme ned: {feedback_stat['negative']}
-- Nöjdhet: {feedback_stat['ratio_percent']}%""" # ÄNDRAT
-        
-        all_logs_report = read_logs() # ÄNDRAT
-        conversations_report = get_latest_conversations(all_logs_report, 3) # ÄNDRAT
-        
-        if conversations_report:
-            content_report += "\n*Senaste konversationer*\n"
-            for conv_item in conversations_report: # ÄNDRAT
-                content_report += f"""
-> *Tid:* {conv_item['timestamp']}
-> *Fråga:* {conv_item['user_message'][:100]}{'...' if len(conv_item['user_message']) > 100 else ''}
-> *Svar:* {conv_item['bot_reply'][:100]}{'...' if len(conv_item['bot_reply']) > 100 else ''}"""
-        return send_to_slack(subject_report, content_report, "#2a9d8f")
+- 👍 Tumme upp: {feedback['positive']}
+- 👎 Tumme ned: {feedback['negative']}
+- Nöjdhet: {feedback['ratio_percent']}%
+"""
+        
+        # Lägg till de senaste konversationerna
+        all_logs = read_logs()
+        conversations = get_latest_conversations(all_logs, 3)
+        
+        if conversations:
+            content += "\n*Senaste konversationer*\n"
+            for conv in conversations:
+                content += f"""
+> *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 ''}
+"""
+        
+        # Skicka till Slack
+        return send_to_slack(subject, content, "#2a9d8f")
+        
     except Exception as e:
         print(f"Fel vid generering av statusrapport: {e}")
-        error_subject_report = f"ChargeNode AI Bot - Fel vid statusrapport" # ÄNDRAT
-        error_content_report = f"*Fel vid generering av statusrapport:* {str(e)}" # ÄNDRAT
-        return send_to_slack(error_subject_report, error_content_report, "#ff0000")
+        
+        # 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(form_områdeskod, form_uttagsnummer, form_email, form_chat_history_list): # ÄNDRAT parameternamn
+def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history_list):
+    """Skickar en supportförfrågan till Slack."""
     try:
-        chat_content_support = "" # ÄNDRAT
-        for msg_support in form_chat_history_list: # ÄNDRAT
-            if msg_support['role'] == 'user':
-                chat_content_support += f">*Användare:* {msg_support['content']}\n\n"
-            elif msg_support['role'] == 'assistant':
-                chat_content_support += f">*Bot:* {msg_support['content'][:300]}{'...' if len(msg_support['content']) > 300 else ''}\n\n"
-        
-        subject_support = f"Support förfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}" # ÄNDRAT
-        content_support = f"""*Användarinformation*
-- *Områdeskod:* {form_områdeskod or 'Ej angiven'}
-- *Uttagsnummer:* {form_uttagsnummer or 'Ej angiven'}
-- *Email:* {form_email}
+        # Formatera chat-historiken
+        chat_content = ""
+        for msg in chat_history_list:
+            if msg['role'] == 'user':
+                chat_content += f">*Användare:* {msg['content']}\n\n"
+            elif msg['role'] == 'assistant':
+                chat_content += f">*Bot:* {msg['content'][:300]}{'...' if len(msg['content']) > 300 else ''}\n\n"
+        
+        # Skapa innehåll
+        subject = f"Support förfrågan - {datetime.now().strftime('%Y-%m-%d %H:%M')}"
+        
+        content = f"""
+*Användarinformation*
+- *Områdeskod:* {områdeskod or 'Ej angiven'}
+- *Uttagsnummer:* {uttagsnummer or 'Ej angiven'}
+- *Email:* {email}
 - *Tidpunkt:* {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
 *Chatthistorik:*
-{chat_content_support}""" # ÄNDRAT
-        return send_to_slack(subject_support, content_support, "#e76f51")
+{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 ---
 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
     schedule.every().day.at("08:00").do(simple_status_report)
     schedule.every().day.at("12:00").do(simple_status_report)
     schedule.every().day.at("17:00").do(simple_status_report)
+    
+    # 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)
+        time.sleep(60)  # Kontrollera varje minut
 
+# Starta schemaläggaren i en separat tråd
 scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
 scheduler_thread.start()
 
 # --- Gradio UI ---
 initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
-custom_css = """ ... (CSS som tidigare) ... """ # Behåller din CSS
+
+custom_css = """
+body {background-color: #f7f7f7; font-family: Arial, sans-serif; margin: 0; padding: 0;}
+h1 {font-family: Helvetica, sans-serif; color: #2a9d8f; text-align: center; margin-bottom: 0.5em;}
+.gradio-container {max-width: 400px; margin: 0; padding: 10px; position: fixed; bottom: 20px; right: 20px; box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1); border-radius: 10px; background-color: #fff;}
+#chatbot_conversation { max-height: 300px; overflow-y: auto; }
+.gr-button {background-color: #2a9d8f; color: #fff; border: none; border-radius: 4px; padding: 8px 16px; margin: 5px;}
+.gr-button:hover {background-color: #264653;}
+.support-btn {background-color: #000000; color: #ffffff; margin-top: 5px; margin-bottom: 10px;}
+.support-btn:hover {background-color: #333333;}
+.flex-row {display: flex; flex-direction: row; gap: 5px;}
+.gr-form {padding: 10px; border: 1px solid #eee; border-radius: 4px; margin-bottom: 10px;}
+.chat-preview {max-height: 150px; overflow-y: auto; border: 1px solid #eee; padding: 8px; margin-top: 10px; font-size: 12px; background-color: #f9f9f9;}
+.success-message {font-size: 16px; font-weight: normal; margin-bottom: 15px;}
+/* Dölj Gradio-footer */
+footer {display: none !important;}
+.footer {display: none !important;}
+.gr-footer {display: none !important;}
+.gradio-footer {display: none !important;}
+.gradio-container .footer {display: none !important;}
+.gradio-container .gr-footer {display: none !important;}
+"""
 
 with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
     gr.Markdown("Ställ din fråga om ChargeNodes produkter och tjänster nedan. Om du inte gillar botten, så ring oss gärna på 010 – 205 10 55")
     
+    # Chat interface
     with gr.Group(visible=True) as chat_interface:
-        chatbot_component = gr.Chatbot(value=initial_chat, type="messages", elem_id="chatbot_conversation") # ÄNDRAT namn
-        chatbot_component.like(vote, None, None) 
+        chatbot = gr.Chatbot(value=initial_chat, type="messages", elem_id="chatbot_conversation")
+        chatbot.like(vote, None, None)
         
         with gr.Row():
-            msg_input = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...") # ÄNDRAT namn
+            msg = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...")
         
         with gr.Row():
             with gr.Column(scale=1):
-                clear_btn = gr.Button("Rensa") # ÄNDRAT namn
+                clear = gr.Button("Rensa")
             with gr.Column(scale=1):
-                support_btn_ui = gr.Button("Behöver du mer hjälp?", elem_classes="support-btn") # ÄNDRAT namn
+                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:
         gr.Markdown("### Vänligen fyll i din områdeskod, uttagsnummer och din email adress")
+        
         with gr.Group(elem_classes="gr-form"):
-            ui_områdeskod = gr.Textbox(label="Områdeskod", placeholder="Områdeskod (valfritt)", info="Numeriskt värde") # ÄNDRAT namn
-            ui_uttagsnummer = gr.Textbox(label="Uttagsnummer", placeholder="Uttagsnummer (valfritt)", info="Numeriskt värde") # ÄNDRAT namn
-            ui_email = gr.Textbox(label="Din email adress", placeholder="din@email.se", info="Email adress krävs") # ÄNDRAT namn
+            områdeskod = gr.Textbox(label="Områdeskod", placeholder="Områdeskod (valfritt)", info="Numeriskt värde")
+            uttagsnummer = gr.Textbox(label="Uttagsnummer", placeholder="Uttagsnummer (valfritt)", info="Numeriskt värde")
+            email = gr.Textbox(label="Din email adress", placeholder="din@email.se", info="Email adress krävs")
             
             gr.Markdown("### Chat som skickas till support:")
-            ui_chat_preview = gr.Markdown(elem_classes="chat-preview") # ÄNDRAT namn
+            chat_preview = gr.Markdown(elem_classes="chat-preview")
             
             with gr.Row():
-                back_btn_ui = gr.Button("Tillbaka") # ÄNDRAT namn
-                send_support_btn_ui = gr.Button("Skicka") # ÄNDRAT namn
+                back_btn = gr.Button("Tillbaka")
+                send_support_btn = gr.Button("Skicka")
     
+    # Success message (initially hidden)
     with gr.Group(visible=False) as success_interface:
         gr.Markdown("Tack för att du kontaktar support@chargenode.eu. Vi återkommer inom kort", elem_classes="success-message")
-        back_to_chat_btn_ui = gr.Button("Tillbaka till chatten") # ÄNDRAT namn
+        back_to_chat_btn = gr.Button("Tillbaka till chatten")
     
-    def respond(message_text, current_chat_history, request: gr.Request): # ÄNDRAT parameternamn
+    def respond(message, chat_history_list, request: gr.Request):
         global last_log
-        op_start_time = time.time() # ÄNDRAT namn
+        start_time = time.time()
         
-        current_chat_history.append({"role": "user", "content": message_text})
-        response_text_content = generate_answer(message_text, current_chat_history) # ÄNDRAT namn
-        op_elapsed = round(time.time() - op_start_time, 2) # ÄNDRAT namn
+        # Lägg till användarens nuvarande meddelande i historiken FÖRE anrop till generate_answer
+        chat_history_list.append({"role": "user", "content": message})
 
-        current_timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # ÄNDRAT namn
-        current_session_id = str(uuid.uuid4()) # ÄNDRAT namn
+        # 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())
         
-        if last_log and 'session_id' in last_log: 
-            current_session_id = last_log.get('session_id')
+        # Använd session_id från tidigare logg om det finns
+        if last_log and 'session_id' in last_log:
+            session_id = last_log.get('session_id')
             
-        current_user_id = request.client.host if request else "okänd" # ÄNDRAT namn
+        user_id = request.client.host if request else "okänd"
 
         ua_str = request.headers.get("user-agent", "")
         ref = request.headers.get("referer", "")
-        ip_addr = request.headers.get("x-forwarded-for", current_user_id).split(",")[0].strip() # ÄNDRAT namn
+        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0].strip()
         ua = parse_ua(ua_str)
-        browser_info = f"{ua.browser.family} {ua.browser.version_string}" # ÄNDRAT namn
-        os_info = f"{ua.os.family} {ua.os.version_string}" # ÄNDRAT namn
-
-        platform_info = "webb" # ÄNDRAT namn
-        if "chargenode.eu" in ref: platform_info = "chargenode.eu"
-        elif "localhost" in ref or "127.0.0.1" in ref : platform_info = "test"
-        elif "app" in ref: platform_info = "app"
-
-        log_data_entry = { # ÄNDRAT namn
-            "timestamp": current_timestamp, "user_id": current_user_id, "session_id": current_session_id,
-            "user_message": message_text, "bot_reply": response_text_content, "response_time": op_elapsed,
-            "ip": ip_addr, "browser": browser_info, "os": os_info, "platform": platform_info,
-            "chat_history_length": len(current_chat_history)
+        browser = f"{ua.browser.family} {ua.browser.version_string}"
+        osys = f"{ua.os.family} {ua.os.version_string}"
+
+        platform = "webb"
+        if "chargenode.eu" in ref:
+            platform = "chargenode.eu"
+        elif "localhost" in ref or "127.0.0.1" in ref:
+            platform = "test"
+        elif "app" in ref:
+            platform = "app"
+
+        log_data = {
+            "timestamp": timestamp,
+            "user_id": user_id,
+            "session_id": session_id,
+            "user_message": message,
+            "bot_reply": response_text,
+            "response_time": elapsed,
+            "ip": ip,
+            "browser": browser,
+            "os": osys,
+            "platform": platform,
+            "chat_history_length": len(chat_history_list)
         }
-        safe_append_to_log(log_data_entry)
-        last_log = log_data_entry
 
+        safe_append_to_log(log_data)
+        last_log = log_data
+
+        # Skicka varje konversation direkt till Slack
         try:
-            conversation_content_slack = f"""*Ny konversation {current_timestamp}*
-*Användare:* {message_text}
-*Bot:* {response_text_content[:300]}{'...' if len(response_text_content) > 300 else ''}
-*Sessionsinfo:* {current_session_id[:8]}... | {browser_info} | {platform_info} | Chat längd: {len(current_chat_history)} meddelanden""" # ÄNDRAT
+            conversation_content = f"""
+*Ny konversation {timestamp}*
+
+*Användare:* {message}
+
+*Bot:* {response_text[:300]}{'...' if len(response_text) > 300 else ''}
+
+*Sessionsinfo:* {session_id[:8]}... | {browser} | {platform} | Chat längd: {len(chat_history_list)} meddelanden
+"""
             threading.Thread(
-                target=lambda: send_to_slack(f"Ny konversation", conversation_content_slack), daemon=True
+                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}")
 
-        current_chat_history.append({"role": "assistant", "content": response_text_content})
-        return "", current_chat_history
-    
-    def format_chat_preview(chat_history_data): # ÄNDRAT
-        if not chat_history_data: return "Ingen chatthistorik att visa."
-        preview_text = "" # ÄNDRAT
-        for msg_preview_item in chat_history_data: # ÄNDRAT
-            sender = "Användare" if msg_preview_item["role"] == "user" else "Bot"
-            content_preview = msg_preview_item["content"] # ÄNDRAT
-            if len(content_preview) > 100: content_preview = content_preview[:100] + "..."
-            preview_text += f"**{sender}:** {content_preview}\n\n"
-        return preview_text
-    
-    def show_support_form_action(chat_history_data_support): # ÄNDRAT
-        preview_content_support = format_chat_preview(chat_history_data_support) # ÄNDRAT
+        # 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_list):
+        if not chat_history_list:
+            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"]
+            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)
         return {
-            chat_interface: gr.update(visible=False), support_interface: gr.update(visible=True),
-            success_interface: gr.update(visible=False), ui_chat_preview: gr.update(value=preview_content_support) # ÄNDRAT
+            chat_interface: gr.Group(visible=False),
+            support_interface: gr.Group(visible=True),
+            success_interface: gr.Group(visible=False),
+            chat_preview: preview
         }
     
-    def back_to_chat_action(): # ÄNDRAT
+    def back_to_chat():
         return {
-            chat_interface: gr.update(visible=True), support_interface: gr.update(visible=False),
-            success_interface: gr.update(visible=False)
+            chat_interface: gr.Group(visible=True),
+            support_interface: gr.Group(visible=False),
+            success_interface: gr.Group(visible=False)
         }
     
-    def submit_support_form_action(form_omr_kod, form_uttags_nr, form_email_addr, form_chat_hist_list): # ÄNDRAT
-        print(f"Support-förfrågan: områdeskod={form_omr_kod}, uttagsnummer={form_uttags_nr}, email={form_email_addr}")
+    def submit_support_form(omr_kod, uttags_nr, email_addr, chat_history_list):
+        """Hanterar formulärinskickningen med bättre felhantering."""
+        print(f"Support-förfrågan: områdeskod={omr_kod}, uttagsnummer={uttags_nr}, email={email_addr}")
+        
         validation_errors = []
-        if form_omr_kod and not form_omr_kod.isdigit(): validation_errors.append("Områdeskod måste vara numerisk.")
-        if form_uttags_nr and not form_uttags_nr.isdigit(): validation_errors.append("Uttagsnummer måste vara numerisk.")
-        if not form_email_addr: validation_errors.append("En giltig e-postadress krävs.")
-        elif '@' not in form_email_addr or '.' not in form_email_addr.split('@')[-1]: validation_errors.append("En giltig e-postadress krävs.")
+        
+        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_kod}' (ok)")
+        
+        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: '{uttags_nr}' (ok)")
+        
+        if not email_addr:
+            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)")
+            validation_errors.append("En giltig e-postadress krävs.")
+        else:
+            print(f"Validerar email: '{email_addr}' (ok)")
         
         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), ui_chat_preview: gr.update(value=error_message_md) # ÄNDRAT
+                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)
             }
+        
         try:
-            success_slack = send_support_to_slack(form_omr_kod, form_uttags_nr, form_email_addr, form_chat_hist_list) # ÄNDRAT
-            if success_slack:
+            print("Försöker skicka supportförfrågan till Slack...")
+            
+            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]}...")
+            print(f"Chatthistorik att skicka: {chat_summary}")
+            
+            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.update(visible=False), support_interface: gr.update(visible=False),
+                    chat_interface: gr.update(visible=False),
+                    support_interface: gr.update(visible=False),
                     success_interface: gr.update(visible=True)
                 }
             else:
-                error_message_md_slack = "**Ett fel uppstod när meddelandet skulle skickas. Vänligen försök igen senare.**" # ÄNDRAT
+                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), ui_chat_preview: gr.update(value=error_message_md_slack) # ÄNDRAT
+                    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:
-            error_message_md_exc = f"**Ett oväntat fel uppstod: {str(e)}**" # ÄNDRAT
+            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), ui_chat_preview: gr.update(value=error_message_md_exc) # ÄNDRAT
+                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_input.submit(respond, [msg_input, chatbot_component], [msg_input, chatbot_component])
-    clear_btn.click(lambda: initial_chat, None, chatbot_component, queue=False)
-    support_btn_ui.click(show_support_form_action, chatbot_component, [chat_interface, support_interface, success_interface, ui_chat_preview])
-    back_btn_ui.click(back_to_chat_action, None, [chat_interface, support_interface, success_interface])
-    back_to_chat_btn_ui.click(back_to_chat_action, None, [chat_interface, support_interface, success_interface])
-    send_support_btn_ui.click(
-        submit_support_form_action, 
-        [ui_områdeskod, ui_uttagsnummer, ui_email, chatbot_component], 
-        [chat_interface, support_interface, success_interface, ui_chat_preview]
+    msg.submit(respond, [msg, chatbot], [msg, chatbot])
+    clear.click(lambda: initial_chat, 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])
+    send_support_btn.click(
+        submit_support_form, 
+        [områdeskod, uttagsnummer, email, chatbot], 
+        [chat_interface, support_interface, success_interface, chat_preview]
     )
 
+# Initialisera embeddings vid uppstart
 print("Förbereder embedding-modell och index...")
-initialize_embeddings() 
+initialize_embeddings()
 print("Embedding-modell och index redo!")
 
 if __name__ == "__main__":