Upload main.py

main.py

@@ -11,7 +11,7 @@ app = FastAPI()
 COLLECTION_KNOWLEDGE = "knowledge_base"
 COLLECTION_INBOX = "inbox"
 
-# --- GLOBALE VARIABLE (Der Turbo-Speicher) ---
+# --- GLOBALE VARIABLE (RAM) ---
 KNOWLEDGE_CACHE = []
 
 # --- FIREBASE VERBINDUNG ---
@@ -30,119 +30,140 @@ try:
 except Exception as e:
     print(f"❌ FEHLER beim Start: {e}")
 
-# --- HILFSFUNKTION: DATEN IN RAM LADEN ---
+# --- LADEN ---
 def reload_knowledge():
     global KNOWLEDGE_CACHE
-    if not db:
-        return 0
-    
-    print("🔄 Lade Wissensdatenbank in den Arbeitsspeicher...")
+    if not db: return 0
+    print("🔄 Lade Wissensdatenbank...")
     try:
         docs = db.collection(COLLECTION_KNOWLEDGE).stream()
         new_cache = []
         for doc in docs:
             d = doc.to_dict()
-            d["id"] = doc.id # ID speichern für Logs
+            d["id"] = doc.id 
             new_cache.append(d)
-        
         KNOWLEDGE_CACHE = new_cache
-        print(f"🚀 TURBO-MODE: {len(KNOWLEDGE_CACHE)} Dokumente im RAM bereit!")
+        print(f"🚀 TURBO-MODE: {len(KNOWLEDGE_CACHE)} Dokumente im RAM!")
         return len(KNOWLEDGE_CACHE)
     except Exception as e:
-        print(f"❌ Fehler beim Laden des Caches: {e}")
+        print(f"❌ Fehler Cache: {e}")
         return 0
 
-# --- STARTUP EVENT (Lädt Daten sofort beim Start) ---
 @app.on_event("startup")
 async def startup_event():
     reload_knowledge()
 
 # --- ENDPUNKTE ---
-
 @app.get("/")
 def home():
-    return {
-        "status": "Turbo-Agent ist bereit.", 
-        "cached_docs": len(KNOWLEDGE_CACHE),
-        "info": "Nutze /refresh_knowledge um neue Daten zu laden."
-    }
+    return {"status": "Udo Agent API (Stemming Mode) ist bereit.", "docs": len(KNOWLEDGE_CACHE)}
 
 @app.get("/refresh_knowledge")
 def refresh_endpoint():
     count = reload_knowledge()
     return {"status": "Cache aktualisiert", "docs_loaded": count}
 
+# --- 🧠 HELPER: DEUTSCHE WORTSTÄMME ---
+def get_stem(word):
+    """
+    Ein sehr einfacher 'Stemmer' für Deutsch.
+    Schneidet Endungen wie 'en', 'ern', 'te', 's' ab.
+    Macht aus 'Preise' -> 'preis', 'kostet' -> 'kost'.
+    """
+    w = word.lower().strip()
+    # Reihenfolge wichtig! Längere Endungen zuerst.
+    endings = ["ern", "em", "er", "en", "es", "st", "te", "e", "s", "t"]
+    
+    for end in endings:
+        if w.endswith(end) and len(w) > (len(end) + 2): # Nicht zu viel abschneiden
+            return w[:-len(end)]
+    return w
+
+# --- 🧠 DIE NEUE INTELLIGENTE SUCHE ---
 @app.post("/search")
 async def search_knowledge(request: Request):
-    # 1. FRAGE EMPFANGEN
     try:
         data = await request.json()
     except:
         return {"result": "Fehler: Kein JSON."}
 
-    # Frage extrahieren (Vapi/Retell kompatibel)
+    # Frage extrahieren
     query_text = ""
-    if "query" in data:
-        query_text = data["query"]
-    elif "message" in data and "toolCalls" in data["message"]:
+    if "query" in data: query_text = data["query"]
+    elif "message" in data:
         try:
             args = data["message"]["toolCalls"][0]["function"]["arguments"]
             query_text = json.loads(args).get("query", "") if isinstance(args, str) else args.get("query", "")
         except: pass
-    
-    # Retell AI spezifisch (falls Retell die Frage anders schickt)
-    if not query_text and "args" in data:
-         query_text = data["args"].get("query", "")
+    if not query_text and "args" in data: query_text = data["args"].get("query", "")
 
-    print(f"🔎 TURBO-SEARCH: '{query_text}'")
+    print(f"🔎 FRAGE: '{query_text}'")
     
-    if not query_text:
-        return {"result": "Ich habe die Frage akustisch nicht verstanden."}
+    if not query_text: return {"result": "Akustik-Fehler."}
 
-    # 2. SUCHEN IM RAM (Rasend schnell!)
-    antwort = "Dazu habe ich leider keine Informationen in meiner Datenbank. Ich habe die Frage für das Team notiert."
-    treffer = False
+    # --- SCORING ALGORITHMUS V2 (Stemming) ---
+    best_doc = None
+    best_score = 0
     
-    query_lower = query_text.lower()
+    # 1. Query vorbereiten (Wörter zerlegen & stämme bilden)
+    query_words_raw = query_text.lower().replace("?", "").replace(".", "").split()
+    query_stems = [get_stem(w) for w in query_words_raw if len(w) > 2]
     
-    # Wir iterieren durch die Liste im Speicher, nicht durch die Datenbank!
-    for entry in KNOWLEDGE_CACHE:
-        # Felder sicher auslesen
-        t_answer = entry.get("answer") or entry.get("Antwort") or entry.get("content")
-        t_keywords = entry.get("keywords") or entry.get("Keywords") or []
-        t_question = entry.get("question") or entry.get("Frage") or ""
+    print(f"   ⚙️ Suchstämme: {query_stems}")
 
-        if not t_answer:
-            continue
+    # Wir prüfen JEDES Dokument
+    for entry in KNOWLEDGE_CACHE:
+        score = 0
+        doc_id = entry.get('id', 'unknown')
+        
+        # Daten holen
+        t_answer = entry.get("answer", "")
+        t_question = entry.get("question", "")
+        t_keywords = entry.get("keywords", [])
+        
+        if not t_answer or len(t_answer) < 5: continue
 
-        # A) Keyword-Match
+        # A) Keyword Treffer (+10 Punkte)
         if isinstance(t_keywords, list):
-            if any(k.lower() in query_lower for k in t_keywords):
-                antwort = t_answer
-                treffer = True
-                print(f"✅ TREFFER (Keyword) in Doc {entry.get('id')}")
-                break
+            for k in t_keywords:
+                k_stem = get_stem(k)
+                if k_stem in query_stems:
+                    # Spezial-Regel: 'udo' und 'capaneo' sind weniger wert, weil sie überall stehen
+                    if k_stem in ['udo', 'capaneo']:
+                        score += 2 
+                    else:
+                        score += 20 # Harter Keyword Treffer ist viel wert!
         
-        # B) Frage-Match
-        if t_question and (t_question.lower() in query_lower or query_lower in t_question.lower()):
-                antwort = t_answer
-                treffer = True
-                print(f"✅ TREFFER (Frage-Match) in Doc {entry.get('id')}")
-                break
-
-    # 3. LERN-LOGIK (Nur schreiben, wenn nichts gefunden)
-    if not treffer:
-        print(f"⚠️ KEIN TREFFER. Schreibe in '{COLLECTION_INBOX}' (DB Write)...")
-        # Das Schreiben passiert im Hintergrund, bremst die Antwort kaum
-        try:
-            if db:
+        # B) Frage/Titel Treffer (+15 Punkte pro Wort)
+        if t_question:
+            q_words = t_question.lower().replace("?", "").split()
+            for qw in q_words:
+                if len(qw) < 3: continue
+                qw_stem = get_stem(qw)
+                if qw_stem in query_stems:
+                     score += 15
+
+        # Neuer Rekord?
+        if score > best_score:
+            best_score = score
+            best_doc = entry
+            # Debugging: Zeig uns Kandidaten im Log
+            if score > 10:
+                print(f"   Candidate {doc_id}: {score} Pts (Titel: {t_question[:30]}...)")
+
+    # --- ERGEBNIS ---
+    if best_doc and best_score >= 10: # Mindestens 10 Punkte nötig
+        print(f"🏆 GEWINNER: Doc {best_doc['id']} mit {best_score} Punkten.")
+        return {"result": best_doc['answer']}
+    else:
+        print(f"⚠️ KEIN TREFFER (Best Score: {best_score}).")
+        # Inbox Eintrag
+        if db:
+            try:
                 db.collection(COLLECTION_INBOX).add({
                     "question": query_text,
                     "status": "open",
-                    "timestamp": firestore.SERVER_TIMESTAMP,
-                    "source": "AI Call"
+                    "timestamp": firestore.SERVER_TIMESTAMP
                 })
-        except Exception as e:
-            print(f"❌ Fehler Inbox: {e}")
-
-    return {"result": antwort}
+            except: pass
+        return {"result": "Dazu habe ich leider keine Informationen in meiner Datenbank."}