Update app.py

app.py

@@ -74,7 +74,42 @@ embeddings = None
 index = None
 chunks = []
 chunk_sources = []
-faq_dict = {}  # Ny: Dictionary för direktmatchning av vanliga frågor
+chunk_priorities = []  # Ny: Prioritet för varje chunk
+faq_dict = {}  # Dictionary för direktmatchning av vanliga frågor
+
+# Nya globala variabler för källprioriterng
+source_priorities = {
+    "FAQ": 1.0,           # Högsta prioritet
+    "ChargeNode App": 0.8,
+    "ChargeNode Portal": 0.8, 
+    "Företagskonto": 0.8,
+    "local_files": 0.6    # Lägsta prioritet för övriga filer
+}
+
+# Förbättrade nyckelord med organisationskontext
+system_keywords = {
+    "app": ["app", "mobil", "telefon", "ladda bil", "ladda fordon", "qr-kod", "skanna", "kartvy", "favoriter", "laddningar", "nedre meny", "mitt privata"],
+    "portal": [
+        "portal", "dashboard", "medlemmar", "statistik", "priser", "avtal", "felanmälan", "hjälpcenter",
+        "samfällighet", "samfällighetsförening", "bostadsrättsförening", "förening", "organisation", 
+        "vi är", "vi har avtal", "våra uppgifter", "vårt avtal", "vår förening", "adminpanel", 
+        "administrera", "hantera medlemmar", "logga in portal", "portal.chargenode"
+    ],
+    "företagskonto": [
+        "företag", "företagskonto", "administratör", "fakturor", "behörighet", "användare", 
+        "org.nummer", "organisationsnummer", "företagsavtal", "mitt företag", "vårt företag"
+    ],
+    "betalning_privat": [
+        "mitt betalsätt", "min betalmetod", "mitt kort", "min betalning", "privat betalkort",
+        "personlig betalning", "mitt privata kort"
+    ]
+}
+
+# Nya organisationsspecifika regler
+organization_types = [
+    "samfällighet", "samfällighetsförening", "bostadsrättsförening", "förening", 
+    "organisation", "kommun", "kommunal", "offentlig", "vi är", "vi har avtal"
+]
 
 # --- Förbättrad loggfunktion ---
 def safe_append_to_log(log_entry):
@@ -108,50 +143,107 @@ def safe_append_to_log(log_entry):
             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 = ""
+def identify_source_context(query):
+    """Förbättrad identifiering med organisationsmedvetenhet."""
+    query_lower = query.lower()
+    
+    # FÖRST: Kontrollera om det är en organisationsfråga
+    is_organization = any(org_type in query_lower for org_type in organization_types)
+    has_collective_pronouns = any(word in query_lower for word in ["vi", "våra", "vårt", "vår"])
+    mentions_agreement = any(word in query_lower for word in ["avtal", "avtalet", "överenskommelse"])
+    
+    if is_organization or (has_collective_pronouns and mentions_agreement):
+        print(f"🏢 Identifierad som organisationsfråga: {query}")
+        
+        # Om det handlar om fakturor/betalningar för företag -> Företagskonto
+        if any(word in query_lower for word in ["faktura", "betalning", "kostnad", "avgift", "företagskonto"]):
+            return "Företagskonto"
+        else:
+            # Annars Portal för allmän administration
+            return "ChargeNode Portal"
+    
+    # ANDRA: Kontrollera för specifika betalningsfrågor (endast privata)
+    if any(keyword in query_lower for keyword in system_keywords["betalning_privat"]):
+        return "FAQ"
+    
+    # TREDJE: Kontrollera för andra system
+    for system, keywords in system_keywords.items():
+        if system == "betalning_privat":  # Redan hanterat ovan
+            continue
+            
+        if any(keyword in query_lower for keyword in keywords):
+            if system == "app":
+                return "ChargeNode App"
+            elif system == "portal":
+                return "ChargeNode Portal"
+            elif system == "företagskonto":
+                return "Företagskonto"
+    
+    # Standard fallback - men inte FAQ för organisationer
+    if is_organization or has_collective_pronouns:
+        return "ChargeNode Portal"
+    else:
+        return "FAQ"
+
+def load_local_files_with_source_separation():
+    """Laddar filer med tydlig källseparation."""
+    sources_data = {}
     allowed = [".txt", ".docx", ".pdf", ".csv", ".xls", ".xlsx"]
     excluded = ["requirements.txt", "app.py", "conversation_log.txt", "conversation_log_v2.txt", "secrets", "prompt.txt"]
+    
     for file in os.listdir("."):
         if file.lower().endswith(tuple(allowed)) and file not in excluded:
             try:
+                # Bestäm källtyp baserat på filnamn
+                source_key = "local_files"  # Default
+                
+                if "FAQ" in file or "faq" in file.lower():
+                    source_key = "FAQ"
+                elif "App" in file or "app" in file.lower():
+                    source_key = "ChargeNode App"
+                elif "Portal" in file or "portal" in file.lower():
+                    source_key = "ChargeNode Portal"
+                elif "Foretagskonto" in file or "företag" in file.lower():
+                    source_key = "Företagskonto"
+                
+                # Läs filinnehåll
                 if file.endswith(".txt"):
                     with open(file, "r", encoding="utf-8") as f:
                         content = f.read()
                 elif file.endswith(".docx"):
-                    from docx import Document  # Import sker vid behov
+                    from docx import Document
                     content = "\n".join([p.text for p in Document(file).paragraphs])
                 elif file.endswith(".pdf"):
-                    import PyPDF2  # Import sker vid behov
+                    import PyPDF2
                     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 stadat.xlsx":
+                    if "FAQ" in file or "faq" in file.lower():
                         df = pd.read_excel(file)
                         rows = []
                         for index, row in df.iterrows():
-                            # 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:  # Also check for capitalized version
+                            elif 'Kategori' in df.columns:
                                 row_text += f"\nKategori: {row['Kategori']}"
-                                
                             rows.append(row_text)
                         content = "\n\n".join(rows)
                     else:
                         content = pd.read_excel(file).to_string()
-                uploaded_text += f"\n\nFIL: {file}\n{content}"
+                
+                # Lägg till i sources_data med källidentifiering
+                if source_key not in sources_data:
+                    sources_data[source_key] = ""
+                sources_data[source_key] += f"\n\nFIL: {file}\n{content}"
+                
             except Exception as e:
                 print(f"Fel vid läsning av {file}: {str(e)}")
-    return uploaded_text.strip()
+    
+    return sources_data
 
 def load_prompt():
     """Läser in system-prompts från prompt.txt med bättre felhantering."""
@@ -169,184 +261,156 @@ def load_prompt():
         print(f"Fel vid inläsning av prompt.txt: {e}, använder standardprompt")
         return "Du är ChargeNode's AI-assistent. Svara på frågor om ChargeNode's produkter och tjänster baserat på den tillhandahållna informationen."
 
-# --- Förbättrad chunking ---
-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_list, sources_list = [], [] # Renamed to avoid conflict with global 'chunks' and 'sources'
+def enhanced_prepare_chunks(text_data):
+    """Förbättrad chunking med källmedvetenhet och prioritering."""
+    chunks_list = []
+    sources_list = []
+    chunk_priorities_list = []  # Ny: Prioritet för varje chunk
     global faq_dict
     
     for source, text in text_data.items():
-        # Split text into paragraph-sized chunks
+        source_priority = source_priorities.get(source, 0.5)
         paragraphs = [p for p in text.split("\n") if p.strip()]
         
-        # Process FAQ-specific content better
         i = 0
-        current_file_chunks = []
-        current_file_sources = []
         while i < len(paragraphs):
-            # Start a new chunk
             current_chunk = ""
             start_idx = i
             
-            # Check for FAQ format
-            if i < len(paragraphs) and paragraphs[i].startswith("Fråga:"):
-                question = paragraphs[i][7:].strip()  # Extract the question text
+            # Särskild behandling för FAQ
+            if source == "FAQ" and i < len(paragraphs) and paragraphs[i].startswith("Fråga:"):
+                question = paragraphs[i][7:].strip()
                 current_chunk = paragraphs[i]
                 i += 1
                 
-                # Add content until we reach the next question or MAX_CHUNK_SIZE
+                # Lägg till svar och annan info
                 while i < len(paragraphs) and not paragraphs[i].startswith("Fråga:"):
-                    # Add this paragraph if it doesn't exceed chunk size
                     if len(current_chunk) + len(paragraphs[i]) + 1 <= MAX_CHUNK_SIZE:
                         current_chunk += "\n" + paragraphs[i]
                     else:
-                        # If we're already processing a FAQ answer, don't break mid-answer
                         if "Svar:" in current_chunk:
-                            # We prefer to keep whole answers together, so let's break only if answer is too long
-                            if len(current_chunk) > MAX_CHUNK_SIZE * 1.5:  # Allow some overflow
-                                break
-                            else:
-                                current_chunk += "\n" + paragraphs[i]
-                        else:
                             break
+                        else:
+                            current_chunk += "\n" + paragraphs[i]
                     i += 1
                 
-                # Store FAQ pairs in the dictionary for direct lookup
+                # Lagra FAQ i dictionary med förbättrade variationer
                 if "Svar:" in current_chunk:
                     answer_start = current_chunk.find("Svar:")
                     answer_text = current_chunk[answer_start + 5:].strip()
                     
-                    # 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"]):
+                    # Grundläggande FAQ-lagring
+                    faq_dict[question.lower()] = answer_text
+                    
+                    # Skapa variationer för betalningsfrågor
+                    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 byter jag betalsätt", 
                             "hur uppdaterar jag mitt betalkort",
                             "hur ändrar jag betalmetod",
                             "hur byter jag betalningsmetod",
-                            "hur ändrar jag betalkort"
+                            "hur ändrar jag betalkort",
+                            "hur lägger jag till nytt kort",
+                            "hur adderar jag betalkort",
+                            "hur registrerar jag betalkort"
                         ]
                         for variation in payment_variations:
                             faq_dict[variation] = answer_text
-                    
-                    # Add the original question to the dictionary
-                    faq_dict[question.lower()] = answer_text
+                
+                # Ge FAQ chunks högsta prioritet
+                chunk_priorities_list.append(1.0)
+                
             else:
-                # Handle non-FAQ text using sliding window
+                # Hantera icke-FAQ innehåll
                 while i < len(paragraphs) and len(current_chunk) + len(paragraphs[i]) + 1 <= MAX_CHUNK_SIZE:
                     if current_chunk:
                         current_chunk += " " + paragraphs[i]
                     else:
                         current_chunk = paragraphs[i]
                     i += 1
+                
+                chunk_priorities_list.append(source_priority)
             
-            # Save the chunk if it has content
+            # Spara chunk om den har innehåll
             if current_chunk.strip():
-                current_file_chunks.append(current_chunk.strip())
-                current_file_sources.append(source)
+                chunks_list.append(current_chunk.strip())
+                sources_list.append(source)
             
-            # If we've added a chunk but haven't advanced, we need to move forward
+            # Säkerställ framsteg
             if i == start_idx:
                 i += 1
-        
-        # Create overlapping chunks for better context preservation for THIS source
-        overlap_chunks_for_file = []
-        overlap_sources_for_file = []
-        
-        for j in range(len(current_file_chunks)):
-            overlap_chunks_for_file.append(current_file_chunks[j])
-            overlap_sources_for_file.append(current_file_sources[j])
-            
-            if j < len(current_file_chunks) - 1:
-                # Calculate available space in the current chunk
-                space_left = MAX_CHUNK_SIZE - len(current_file_chunks[j])
-                
-                # If there's enough space, add part of the next chunk
-                if space_left >= CHUNK_OVERLAP:
-                    # Ensure we don't duplicate if chunks are already naturally overlapping significantly
-                    # 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)
-        
-    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...")
-        text_data = {"local_files": load_local_files()}
-        print("Förbereder textsegment...")
-        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)
-        
-        # 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(f"Genererade {len(chunks_list)} chunks från {len(text_data)} källor")
+    print(f"FAQ Dictionary innehåller {len(faq_dict)} nycklar")
+    print(f"Källfördelning: {[(source, len([s for s in sources_list if s == source])) for source in set(sources_list)]}")
+    
+    return chunks_list, sources_list, chunk_priorities_list
 
-        # Print FAQ dictionary keys for debugging
-        print(f"FAQ Dictionary innehåller {len(faq_dict)} nycklar")
-        if len(faq_dict) > 0:
-            payment_keys = [k for k in faq_dict.keys() if any(term in k for term in ["betalsätt", "betalmetod", "betalmedel"])]
-            print(f"Betalningsrelaterade FAQ-nycklar: {payment_keys[:5]}")
+def add_organization_faqs():
+    """Lägger till specifika FAQ-svar för organisationer."""
+    global faq_dict
+    
+    # Samfällighets- och föreningsfrågor
+    samfallighet_svar = """För samfällighetsföreningar och andra organisationer med avtal:
+
+1. Gå till portal.chargenode.eu
+2. Logga in med de uppgifter ni fick när avtalet tecknades
+3. I portalen kan ni:
+   - Se Dashboard med översikt
+   - Hantera medlemmar under 'Medlemmar'
+   - Se statistik under 'Statistik'
+   - Ändra priser under 'Priser'
+   - Hantera avtal under 'Avtal'
+   - Se fakturering under 'Fakturering'
+
+Om ni inte har inloggningsuppgifter, kontakta support@chargenode.eu eller 010-2051055."""
+
+    organization_keys = [
+        "samfällighetsförening logga in",
+        "förening logga in portal",
+        "vi har avtal hur loggar vi in",
+        "ändra våra uppgifter",
+        "hantera vår organisation",
+        "organisationsuppgifter",
+        "samfällighet portal",
+        "bostadsrättsförening portal",
+        "vi är en förening"
+    ]
+    
+    for key in organization_keys:
+        faq_dict[key.lower()] = samfallighet_svar
 
-def check_direct_match(query):
-    """Kontrollerar om frågan matchar någon av våra fördefinierade FAQ-svar."""
+def enhanced_check_direct_match(query):
+    """Förbättrad direktmatchning som undviker fel för organisationer."""
     query_lower = query.lower().strip('?').strip()
     
-    # Utökad lista med prefix för betalningsrelaterade frågor
+    # VIKTIG FIX: Kontrollera först om det är organisationsfråga
+    is_organization = any(org_type in query_lower for org_type in organization_types)
+    has_collective_pronouns = any(word in query_lower for word in ["vi", "våra", "vårt", "vår"])
+    
+    if is_organization or has_collective_pronouns:
+        print(f"🏢 Organisationsfråga detekterad - hoppar över FAQ direktmatchning")
+        return None  # Låt RAG hantera detta istället
+    
+    # Endast för PRIVATA betalningsfrågor
     payment_prefixes = [
-        "hur ändrar jag", 
-        "hur byter jag", 
-        "hur uppdaterar jag",
-        "hur lägger jag till",  # NYTT
-        "hur adderar jag",      # NYTT  
-        "hur registrerar jag"   # NYTT
+        "hur ändrar jag", "hur byter jag", "hur uppdaterar jag",
+        "hur lägger jag till", "hur adderar jag", "hur registrerar jag",
+        "hur tar jag bort", "kan jag ändra", "går det att byta"
     ]
     
-    # Explicit check for payment method question
+    # Lägg till extra kontroll för privata termer
+    private_payment_terms = ["mitt betalsätt", "min betalmetod", "mitt betalkort", "mitt kort", "min betalning"]
+    general_payment_terms = ["betalsätt", "betalmetod", "betalmedel", "betalkort", "kort", "betalning", "kortuppgifter"]
+    
+    # Bara matcha om det BÅDE har prefix OCH är tydligt privat ELLER allmän betalning utan organisationskontext
+    is_private_payment = any(term in query_lower for term in private_payment_terms)
+    is_general_payment = any(term in query_lower for term in general_payment_terms)
+    
     if any(query_lower.startswith(prefix) for prefix in payment_prefixes) and \
-       any(term in query_lower for term in ["betalsätt", "betalmetod", "betalmedel", "betalkort", "kort"]):
+       (is_private_payment or (is_general_payment and not has_collective_pronouns)):
+        
         payment_answer = """Så här lägger du till/ändrar betalkort: 
 1. Öppna ChargeNode-appen
 2. Tryck på 'Meny' (hamburgerikon) i nedre menyn
@@ -359,56 +423,146 @@ def check_direct_match(query):
 8. Bekräfta med BankID
 
 OBS! Se till att kortet har pengar och att det är upplåst för internetbetalningar."""
-        return payment_answer  # <-- Detta ska vara INUTI if-blocket!
+        return payment_answer
     
-    # Check if query directly matches a FAQ
+    # Kontrollera exakt matchning i FAQ dictionary (endast för icke-organisationer)
     if query_lower in faq_dict:
         return faq_dict[query_lower]
     
-    # Check for close matches using pattern matching
+    # Förbättrad fuzzy matching (endast för icke-organisationer)
     for key, value in faq_dict.items():
-        # Find questions about changing things with synonyms
-        if ("ändra" in query_lower or "byta" in query_lower or "uppdatera" in query_lower or 
-            "lägger till" in query_lower or "adderar" in query_lower) and \
-           ("ändra" in key or "byta" in key or "uppdatera" in key or "lägger till" in key):
-            # 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
+        query_words = set(re.findall(r'\w+', query_lower))
+        key_words = set(re.findall(r'\w+', key))
+        
+        common_words = query_words.intersection(key_words)
+        required_overlap = 0.6 if len(query_words) <= 4 else 0.4
+        overlap_ratio = len(common_words) / len(query_words) if query_words else 0
+        
+        if overlap_ratio >= required_overlap and len(common_words) >= 2:
+            return value
     
     return None
 
-def retrieve_context(query, k=RETRIEVAL_K):
-    """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()
+def enhanced_retrieve_context(query, k=RETRIEVAL_K):
+    """Förbättrad kontexthämtning med källprioriterng och smart viktning."""
+    initialize_enhanced_embeddings()
     
-    # Först, kolla efter direktmatchningar för vanliga frågor
-    direct_match = check_direct_match(query)
+    # Steg 1: Kontrollera direktmatchning (högsta prioritet)
+    direct_match = enhanced_check_direct_match(query)
     if direct_match:
-        print(f"Direkt matchning hittad för frågan: {query}")
-        return f"Fråga: {query}\nSvar: {direct_match}", ["direct_match"]
+        print(f"✓ Direkt FAQ-matchning hittad för: {query}")
+        return f"Fråga: {query}\nSvar: {direct_match}", ["FAQ_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.")
+    if embedder is None or index is None or index.ntotal == 0:
+        print("Varning: Embedder eller FAISS-index inte tillgängligt")
         return "", []
-
+    
+    # Steg 2: Identifiera förväntad källkontext
+    preferred_source = identify_source_context(query)
+    print(f"📍 Identifierad förväntad källa: {preferred_source}")
+    
+    # Steg 3: Utför embedding-sökning
     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 # Undvik division med noll
+    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() # Renamed to avoid conflict
-    for idx in I[0]:
-        if 0 <= idx < len(chunks): # Ensure index is valid
-            retrieved.append(chunks[idx])
-            sources_set.add(chunk_sources[idx]) # Use chunk_sources which is global
-    return " ".join(retrieved), list(sources_set)
+    # Hämta fler kandidater för bättre filtrering
+    search_k = min(k * 3, len(chunks))  
+    D, I = index.search(query_embedding, search_k)
+    
+    # Steg 4: Viktad ranking baserat på både relevans och källprioritet
+    candidates = []
+    for idx, score in zip(I[0], D[0]):
+        if 0 <= idx < len(chunks):
+            source = chunk_sources[idx]
+            chunk_priority = chunk_priorities[idx] if idx < len(chunk_priorities) else 0.5
+            
+            # Bonuspoäng om det matchar förväntad källa
+            source_bonus = 0.3 if source == preferred_source else 0.0
+            
+            # Kombinera semantic similarity med source priority
+            combined_score = score + chunk_priority + source_bonus
+            
+            candidates.append({
+                'chunk': chunks[idx],
+                'source': source,
+                'score': combined_score,
+                'semantic_score': score,
+                'priority': chunk_priority
+            })
+    
+    # Steg 5: Sortera och välj topp k resultat
+    candidates.sort(key=lambda x: x['score'], reverse=True)
+    top_candidates = candidates[:k]
+    
+    # Steg 6: Logga vad som valdes för debugging
+    print(f"🔍 Valda källor: {[c['source'] for c in top_candidates]}")
+    print(f"📊 Scores: {[(c['source'], round(c['score'], 3)) for c in top_candidates]}")
+    
+    # Steg 7: Bygg kontextsvar
+    retrieved_chunks = [c['chunk'] for c in top_candidates]
+    unique_sources = list(set(c['source'] for c in top_candidates))
+    
+    context = " ".join(retrieved_chunks)
+    return context, unique_sources
 
+def initialize_enhanced_embeddings():
+    """Initierar embeddings med förbättrad källhantering."""
+    global embedder, embeddings, index, chunks, chunk_sources, chunk_priorities, faq_dict
+    
+    if embedder is None:
+        print("🚀 Initierar förbättrad RAG med källprioriterng...")
+        
+        # Ladda data med källseparation
+        print("📁 Laddar källseparerad textdata...")
+        text_data = load_local_files_with_source_separation()
+        print(f"📚 Laddade {len(text_data)} källor: {list(text_data.keys())}")
+        
+        # Förbättrad chunking
+        print("✂️ Skapar chunks med källmedvetenhet...")
+        chunks, chunk_sources, chunk_priorities = enhanced_prepare_chunks(text_data)
+        print(f"📦 {len(chunks)} chunks skapade")
+        
+        # NYTT: Lägg till organisationsspecifika FAQ
+        add_organization_faqs()
+        
+        if not chunks:
+            print("⚠️ Inga chunks genererades")
+            embedder = SentenceTransformer('all-MiniLM-L6-v2')
+            embeddings = np.array([]).reshape(0, embedder.get_sentence_embedding_dimension())
+            index = faiss.IndexFlatIP(embedder.get_sentence_embedding_dimension())
+            chunk_priorities = []
+            return
+        
+        # Skapa embeddings
+        print("🧮 Skapar embeddings...")
+        embedder = SentenceTransformer('all-MiniLM-L6-v2')
+        embeddings = embedder.encode(chunks, convert_to_numpy=True)
+        
+        if embeddings.ndim == 2 and embeddings.shape[0] > 0:
+            embeddings_norm = np.linalg.norm(embeddings, axis=1, keepdims=True)
+            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("⚠️ Tomma embeddings, skapar tomt index")
+            dimension = embedder.get_sentence_embedding_dimension()
+            index = faiss.IndexFlatIP(dimension)
+            chunk_priorities = []
+        
+        # Sammanfattning
+        source_summary = {}
+        for source in chunk_sources:
+            source_summary[source] = source_summary.get(source, 0) + 1
+        
+        print(f"📈 Källsammanfattning: {source_summary}")
+        print(f"❓ FAQ entries: {len(faq_dict)}")
+        print(f"🏢 Organisationsfrågor inkluderade")
 
 # Ladda prompt template
 prompt_template = load_prompt()
@@ -429,34 +583,28 @@ def format_chat_history_for_claude(chat_history):
     
     return messages
 
-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) # 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."
-
+def enhanced_generate_answer(query, chat_history=None):
+    """Genererar svar med förbättrad källprioriterng."""
+    # Använd förbättrad kontexthämtning
+    context, sources = enhanced_retrieve_context(query)
+    
+    if not context.strip():
+        print("ℹ️ Ingen specifik kontext hittad, använder allmän kunskap")
+    
     # System-prompts
     system_prompt = prompt_template
     
     # Förbered meddelanden för Claude API
-    messages = [] # Starta med en tom lista för varje nytt anrop
+    messages = []
     
     # 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.
+    if chat_history and len(chat_history) > 1:
         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_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
+    if not context.strip():
         user_message_content = f"Min fråga är: {query}"
         
     messages.append({"role": "user", "content": user_message_content})
@@ -465,15 +613,21 @@ def generate_answer(query, chat_history=None):
         # Använd Claude Sonnet 4 med RAG-baserad kontext och chatthistorik
         response = anthropic_client.messages.create(
             model=MODEL_NAME,
-            max_tokens=1024, # Ökat något för att tillåta längre svar om det behövs
+            max_tokens=1024,
             temperature=0.3,
             system=system_prompt,
             messages=messages
         )
         answer = response.content[0].text
+        
+        # Lägg till källinformation i svaret för transparens
+        if sources and any(source != "FAQ_direct_match" for source in sources):
+            source_info = f"\n\n📚 Källor: {', '.join(set(sources))}"
+            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)}")
+        print(f"❌ Fel vid API-anrop: {str(e)}")
         return f"Tekniskt fel: {str(e)}\n\nAI-genererat. Kontakta support@chargenode.eu eller 010-2051055"
 
 # --- Slack Integration ---
@@ -529,14 +683,14 @@ def vote(data: gr.LikeData):
     data.value innehåller information om meddelandet.
     """
     feedback_type = "up" if data.liked else "down"
-    global last_log # Använd den globala variabeln
+    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")
     }
     # Om global logdata finns, lägg till ytterligare metadata.
-    if last_log: # Kontrollera att last_log inte är None
+    if last_log:
         log_entry.update({
             "session_id": last_log.get("session_id"),
             "user_message": last_log.get("user_message"),
@@ -547,7 +701,7 @@ def vote(data: gr.LikeData):
     
     # Skicka feedback till Slack
     try:
-        if feedback_type == "down" and last_log:  # Skicka bara negativ feedback och om last_log finns
+        if feedback_type == "down" and last_log:
             feedback_message = f"""
 *⚠️ Negativ feedback registrerad*
 
@@ -644,10 +798,10 @@ def generate_monthly_stats(days=30):
                 if log_date >= cutoff_date:
                     filtered_logs.append(log)
             except:
-                pass  # Hoppa över poster med ogiltigt datum
+                pass
     
-    logs = filtered_logs # Använd filtrerade loggar
-    if not logs: # Kontrollera igen efter filtrering
+    logs = filtered_logs
+    if not logs:
         return {"error": f"Inga loggar hittades för de senaste {days} dagarna"}
 
     # Basstatistik
@@ -708,10 +862,10 @@ def simple_status_report():
     
     try:
         # Generera statistik
-        stats = generate_monthly_stats(days=7)  # Senaste veckan
+        stats = generate_monthly_stats(days=7)
         
         # Skapa innehåll för Slack
-        now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Renamed to avoid conflict
+        now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         subject = f"ChargeNode AI Bot - Status {now_str}"
         
         if 'error' in stats:
@@ -739,7 +893,7 @@ def simple_status_report():
 """
         
         # Lägg till de senaste konversationerna
-        all_logs = read_logs() # Renamed to avoid conflict with global logs
+        all_logs = read_logs()
         conversations = get_latest_conversations(all_logs, 3)
         
         if conversations:
@@ -762,12 +916,12 @@ def simple_status_report():
         error_content = f"*Fel vid generering av statusrapport:* {str(e)}"
         return send_to_slack(error_subject, error_content, "#ff0000")
 
-def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history_list): # Renamed to avoid confusion
+def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history_list):
     """Skickar en supportförfrågan till Slack."""
     try:
         # Formatera chat-historiken
         chat_content = ""
-        for msg in chat_history_list: # Use the renamed parameter
+        for msg in chat_history_list:
             if msg['role'] == 'user':
                 chat_content += f">*Användare:* {msg['content']}\n\n"
             elif msg['role'] == 'assistant':
@@ -810,21 +964,12 @@ def run_scheduler():
     
     while True:
         schedule.run_pending()
-        time.sleep(60)  # Kontrollera varje minut
+        time.sleep(60)
 
 # Starta schemaläggaren i en separat tråd
 scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
 scheduler_thread.start()
 
-# Kör en statusrapport vid uppstart för att verifiera att allt fungerar
-try:
-    print("Skickar en inledande statusrapport för att verifiera Slack-integrationen...")
-    # Anropa inte direkt här - sker i schemaläggaren
-    # 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}")
-
 # --- Gradio UI ---
 initial_chat = [{"role": "assistant", "content": "Detta är ChargeNode's AI bot. Hur kan jag hjälpa dig idag?"}]
 
@@ -856,7 +1001,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) # vote-funktionen anropas med data från chatbot-komponenten
+        chatbot.like(vote, None, None)
         
         with gr.Row():
             msg = gr.Textbox(label="Meddelande", placeholder="Ange din fråga...")
@@ -889,29 +1034,29 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         back_to_chat_btn = gr.Button("Tillbaka till chatten")
     
     # KORRIGERAD respond-funktion
-    def respond(message, chat_history_list, request: gr.Request): # Renamed chat_history to chat_history_list for clarity
+    def respond(message, chat_history_list, request: gr.Request):
         global last_log
-        start_time = time.time() # Renamed to avoid conflict
+        start_time = time.time()
         
         # Lägg till användarens nuvarande meddelande i historiken FÖRE anrop till generate_answer
         chat_history_list.append({"role": "user", "content": message})
 
         # Skicka den uppdaterade chatthistoriken till generate_answer
-        response_text = generate_answer(message, chat_history_list) 
+        response_text = enhanced_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: # Check last_log is not None
+        if last_log and 'session_id' in last_log:
             session_id = last_log.get('session_id')
             
         user_id = request.client.host if request else "okänd"
 
         ua_str = request.headers.get("user-agent", "")
         ref = request.headers.get("referer", "")
-        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0].strip() # Added strip()
+        ip = request.headers.get("x-forwarded-for", user_id).split(",")[0].strip()
         ua = parse_ua(ua_str)
         browser = f"{ua.browser.family} {ua.browser.version_string}"
         osys = f"{ua.os.family} {ua.os.version_string}"
@@ -919,9 +1064,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 or "127.0.0.1" in ref : # Added check for 127.0.0.1
+        elif "localhost" in ref or "127.0.0.1" in ref:
             platform = "test"
-        elif "app" in ref: # This might need a more robust check
+        elif "app" in ref:
             platform = "app"
 
         log_data = {
@@ -939,7 +1084,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         }
 
         safe_append_to_log(log_data)
-        last_log = log_data # Uppdatera last_log med aktuell konversationsdata
+        last_log = log_data
 
         # Skicka varje konversation direkt till Slack
         try:
@@ -963,21 +1108,21 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         chat_history_list.append({"role": "assistant", "content": response_text})
         return "", chat_history_list
     
-    def format_chat_preview(chat_history_list): # Renamed
+    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: # Renamed msg to msg_item
+        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
+            if len(content) > 100:
                 content = content[:100] + "..."
             preview += f"**{sender}:** {content}\n\n"
         
         return preview
     
-    def show_support_form(chat_history_list): # Renamed
+    def show_support_form(chat_history_list):
         preview = format_chat_preview(chat_history_list)
         return {
             chat_interface: gr.Group(visible=False),
@@ -993,7 +1138,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             success_interface: gr.Group(visible=False)
         }
     
-    def submit_support_form(omr_kod, uttags_nr, email_addr, chat_history_list): # Renamed parameters
+    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}")
         
@@ -1014,7 +1159,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         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]: # Improved email validation slightly
+        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:
@@ -1022,13 +1167,12 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
         
         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.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
+                chat_preview: gr.update(value=error_message_md)
             }
         
         try:
@@ -1069,7 +1213,7 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
             }
     
     msg.submit(respond, [msg, chatbot], [msg, chatbot])
-    clear.click(lambda: initial_chat, None, chatbot, queue=False) # Använd initial_chat för att återställa
+    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])
@@ -1081,9 +1225,8 @@ 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() # Detta anropas nu för att ladda allt
+initialize_enhanced_embeddings()
 print("Embedding-modell och index redo!")
 
 if __name__ == "__main__":
-    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.
+    app.launch(share=IS_HUGGINGFACE)