Update app.py

app.py

@@ -15,11 +15,13 @@ import threading
 from sentence_transformers import SentenceTransformer
 import numpy as np
 import faiss
+import re
 
 # --- Konfiguration ---
 CHARGENODE_URL = "https://www.chargenode.eu"
-MAX_CHUNK_SIZE = 1024  # Storlek på chunker för indexering
-RETRIEVAL_K = 8        # Antal chunker att hämta vid varje sökning
+MAX_CHUNK_SIZE = 2000  # Ökad chunkstorleken för att bättre hantera FAQ-svar
+CHUNK_OVERLAP = 200    # Nytt: Overlapping chunks för att inte tappa kontext
+RETRIEVAL_K = 5        # Antal chunker att hämta vid varje sökning
 
 # Kontrollera om vi kör i Hugging Face-miljön
 IS_HUGGINGFACE = os.environ.get("SPACE_ID") is not None
@@ -69,6 +71,7 @@ embeddings = None
 index = None
 chunks = []
 chunk_sources = []
+faq_dict = {}  # Ny: Dictionary för direktmatchning av vanliga frågor
 
 # --- Förbättrad loggfunktion ---
 def safe_append_to_log(log_entry):
@@ -163,29 +166,117 @@ 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örbered textsegment
+# --- Förbättrad chunking ---
 def prepare_chunks(text_data):
-    """Delar upp texten i mindre segment för embedding och sökning."""
+    """Delar upp texten i mindre segment för embedding och sökning med särskild hänsyn till FAQ-format."""
     chunks, sources = [], []
+    global faq_dict
+    
     for source, text in text_data.items():
+        # Split text into paragraph-sized chunks
         paragraphs = [p for p in text.split("\n") if p.strip()]
-        chunk = ""
-        for para in paragraphs:
-            if len(chunk) + len(para) + 1 <= MAX_CHUNK_SIZE:
-                chunk += " " + para
+        
+        # Process FAQ-specific content better
+        i = 0
+        while i < len(paragraphs):
+            # Start a new chunk
+            current_chunk = ""
+            start_idx = i
+            
+            # Check for FAQ format
+            if i < len(paragraphs) and paragraphs[i].startswith("Fråga:"):
+                question = paragraphs[i][7:].strip()  # Extract the question text
+                current_chunk = paragraphs[i]
+                i += 1
+                
+                # Add content until we reach the next question or MAX_CHUNK_SIZE
+                while i < len(paragraphs) and not paragraphs[i].startswith("Fråga:"):
+                    # Add this paragraph if it doesn't exceed chunk size
+                    if len(current_chunk) + len(paragraphs[i]) + 1 <= MAX_CHUNK_SIZE:
+                        current_chunk += "\n" + paragraphs[i]
+                    else:
+                        # If we're already processing a FAQ answer, don't break mid-answer
+                        if "Svar:" in current_chunk:
+                            # We prefer to keep whole answers together, so let's break only if answer is too long
+                            if len(current_chunk) > MAX_CHUNK_SIZE * 1.5:  # Allow some overflow
+                                break
+                            else:
+                                current_chunk += "\n" + paragraphs[i]
+                        else:
+                            break
+                    i += 1
+                
+                # Store FAQ pairs in the dictionary for direct lookup
+                if "Svar:" in current_chunk:
+                    answer_start = current_chunk.find("Svar:")
+                    answer_text = current_chunk[answer_start + 5:].strip()
+                    
+                    # Add 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"]):
+                        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] = answer_text
+                    
+                    # Add the original question to the dictionary
+                    faq_dict[question.lower()] = answer_text
             else:
-                if chunk.strip():
-                    chunks.append(chunk.strip())
-                    sources.append(source)
-                chunk = para
-        if chunk.strip():
-            chunks.append(chunk.strip())
-            sources.append(source)
+                # Handle non-FAQ text using sliding window
+                while i < len(paragraphs) and len(current_chunk) + len(paragraphs[i]) + 1 <= MAX_CHUNK_SIZE:
+                    if current_chunk:
+                        current_chunk += " " + paragraphs[i]
+                    else:
+                        current_chunk = paragraphs[i]
+                    i += 1
+            
+            # Save the chunk if it has content
+            if current_chunk.strip():
+                chunks.append(current_chunk.strip())
+                sources.append(source)
+            
+            # If we've added a chunk but haven't advanced, we need to move forward
+            if i == start_idx:
+                i += 1
+        
+        # Create overlapping chunks for better context preservation
+        overlap_chunks = []
+        overlap_sources = []
+        
+        for j in range(0, len(chunks)):
+            overlap_chunks.append(chunks[j])
+            overlap_sources.append(sources[j])
+            
+            # Create an overlapping chunk with the next chunk if it exists
+            if j < len(chunks) - 1 and chunks[j].endswith(chunks[j+1][:CHUNK_OVERLAP]):
+                # Skip if there's already significant overlap
+                continue
+                
+            if j < len(chunks) - 1:
+                # Calculate available space in the current chunk
+                space_left = MAX_CHUNK_SIZE - len(chunks[j])
+                
+                # If there's enough space, add part of the next chunk
+                if space_left >= CHUNK_OVERLAP:
+                    overlap_text = chunks[j] + " " + chunks[j+1][:CHUNK_OVERLAP]
+                    overlap_chunks.append(overlap_text)
+                    overlap_sources.append(sources[j])
+        
+        chunks = overlap_chunks
+        sources = overlap_sources
+    
+    print(f"Genererade {len(chunks)} chunks med {len(faq_dict)} FAQ-par")
     return chunks, sources
 
 def initialize_embeddings():
     """Initierar SentenceTransformer och FAISS-index vid första anrop."""
-    global embedder, embeddings, index, chunks, chunk_sources
+    global embedder, embeddings, index, chunks, chunk_sources, faq_dict
     
     if embedder is None:
         print("Initierar SentenceTransformer och FAISS-index...")
@@ -203,12 +294,62 @@ def initialize_embeddings():
         index = faiss.IndexFlatIP(embeddings.shape[1])
         index.add(embeddings)
         print("FAISS-index klart")
+        
+        # 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]}")
+
+# Direkt matchningsfunktion för vanliga frågor
+def check_direct_match(query):
+    """Kontrollerar om frågan matchar någon av våra fördefinierade FAQ-svar."""
+    query_lower = query.lower().strip('?').strip()
+    
+    # Explicit check for payment method question
+    if any(query_lower.startswith(prefix) for prefix in ["hur ändrar jag", "hur byter jag", "hur uppdaterar jag"]) and \
+       any(term in query_lower for term in ["betalsätt", "betalmetod", "betalmedel", "betalkort", "kort"]):
+        payment_answer = """Så här gör du om du vill byta betalkort: 
+1. Gå in i appen. 
+2. Tryck på meny och mina betalsätt 
+3. Tryck på ersätt kort. 
+4. Godkänn våra villkor 
+5. Tryck på kortbetalning under "bekräfta för auktorisering" 
+6. Lägg in dina nya kort uppgifter 
+7. Bekräfta med BankID. 
+
+OBS! Se till att kortet har pengar och att det är upplåst för internetbetalningar."""
+        return payment_answer
+    
+    # Check if query directly matches a FAQ
+    if query_lower in faq_dict:
+        return faq_dict[query_lower]
+    
+    # Check for close matches using pattern matching
+    for key, value in faq_dict.items():
+        # Find questions about changing things with synonyms
+        if ("ändra" in query_lower or "byta" in query_lower or "uppdatera" in query_lower) and \
+           ("ändra" in key or "byta" in key or "uppdatera" in key):
+            # Check if key and query share important terms
+            query_terms = set(query_lower.split())
+            key_terms = set(key.split())
+            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):
-    """Hämtar relevant kontext för frågor."""
+    """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"Direkt matchning hittad för frågan: {query}")
+        return f"Fråga: {query}\nSvar: {direct_match}", ["direct_match"]
+    
+    # Om ingen direktmatchning, använd vanlig embedding-sökning
     query_embedding = embedder.encode([query], convert_to_numpy=True)
     query_embedding /= np.linalg.norm(query_embedding)
     D, I = index.search(query_embedding, k)