Upload main.py

main.py

@@ -8,9 +8,11 @@ from datetime import datetime
 app = FastAPI()
 
 # --- EINSTELLUNGEN ---
-# Deine korrekten Sammlungs-Namen aus dem Screenshot
 COLLECTION_KNOWLEDGE = "knowledge_base"
-COLLECTION_INBOX = "inbox"  # Kleingeschrieben, wie Standard
+COLLECTION_INBOX = "inbox"
+
+# --- GLOBALE VARIABLE (Der Turbo-Speicher) ---
+KNOWLEDGE_CACHE = []
 
 # --- FIREBASE VERBINDUNG ---
 db = None
@@ -28,94 +30,119 @@ try:
 except Exception as e:
     print(f"❌ FEHLER beim Start: {e}")
 
+# --- HILFSFUNKTION: DATEN IN RAM LADEN ---
+def reload_knowledge():
+    global KNOWLEDGE_CACHE
+    if not db:
+        return 0
+    
+    print("🔄 Lade Wissensdatenbank in den Arbeitsspeicher...")
+    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
+            new_cache.append(d)
+        
+        KNOWLEDGE_CACHE = new_cache
+        print(f"🚀 TURBO-MODE: {len(KNOWLEDGE_CACHE)} Dokumente im RAM bereit!")
+        return len(KNOWLEDGE_CACHE)
+    except Exception as e:
+        print(f"❌ Fehler beim Laden des Caches: {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": "Udo Agent API (Live) ist bereit."}
+    return {
+        "status": "Turbo-Agent ist bereit.", 
+        "cached_docs": len(KNOWLEDGE_CACHE),
+        "info": "Nutze /refresh_knowledge um neue Daten zu laden."
+    }
+
+@app.get("/refresh_knowledge")
+def refresh_endpoint():
+    count = reload_knowledge()
+    return {"status": "Cache aktualisiert", "docs_loaded": count}
 
 @app.post("/search")
 async def search_knowledge(request: Request):
-    # 1. DATEN EMPFANGEN
+    # 1. FRAGE EMPFANGEN
     try:
         data = await request.json()
     except:
         return {"result": "Fehler: Kein JSON."}
 
-    # 2. FRAGE EXTRAHIEREN (Robust für Vapi)
+    # Frage extrahieren (Vapi/Retell kompatibel)
     query_text = ""
-    if "query" in data and isinstance(data["query"], str):
+    if "query" in data:
         query_text = data["query"]
     elif "message" in data and "toolCalls" in data["message"]:
         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
-    elif "toolCall" in data:
-         try:
-            args = data["toolCall"]["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", "")
 
-    print(f"🔎 FRAGE: '{query_text}'")
+    print(f"🔎 TURBO-SEARCH: '{query_text}'")
     
     if not query_text:
         return {"result": "Ich habe die Frage akustisch nicht verstanden."}
-    if not db:
-        return {"result": "Server-Fehler: Datenbank nicht verbunden."}
 
-    # 3. INTELLIGENTE SUCHE (Deine 752 Dokumente)
+    # 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
     
-    try:
-        # Wir laden alle Dokumente (Caching wäre bei >2000 Docs nötig, für 750 geht es noch)
-        docs = db.collection(COLLECTION_KNOWLEDGE).stream()
-        query_lower = query_text.lower()
+    query_lower = query_text.lower()
+    
+    # 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 ""
+
+        if not t_answer:
+            continue
+
+        # A) Keyword-Match
+        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 doc in docs:
-            d = doc.to_dict()
-            
-            # Felder sicher auslesen (auch wenn mal eins fehlt)
-            t_answer = d.get("answer") or d.get("Antwort") or d.get("content")
-            t_keywords = d.get("keywords") or d.get("Keywords") or []
-            t_question = d.get("question") or d.get("Frage") or ""
-
-            if not t_answer:
-                continue
-
-            # A) Keyword-Match (Sehr stark!)
-            if isinstance(t_keywords, list):
-                # Prüft, ob ein Keyword in der Frage vorkommt
-                if any(k.lower() in query_lower for k in t_keywords):
-                    antwort = t_answer
-                    treffer = True
-                    print(f"✅ TREFFER (Keyword) in Doc {doc.id}")
-                    break
-            
-            # B) Frage-Match (Fuzzy)
-            # Prüft, ob die User-Frage in der DB-Frage steckt (oder umgekehrt)
-            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 {doc.id}")
-                 break
-
-        # 4. LERN-LOGIK (INBOX)
-        if not treffer:
-            print(f"⚠️ KEIN TREFFER. Speichere in '{COLLECTION_INBOX}'...")
-            try:
+        # 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:
                 db.collection(COLLECTION_INBOX).add({
                     "question": query_text,
                     "status": "open",
                     "timestamp": firestore.SERVER_TIMESTAMP,
-                    "source": "Vapi Call"
+                    "source": "AI Call"
                 })
-                print("📩 Erfolgreich in Inbox gespeichert.")
-            except Exception as e:
-                print(f"❌ Fehler beim Speichern in Inbox: {e}")
-
-    except Exception as e:
-        print(f"❌ DATABASE ERROR: {e}")
-        return {"result": "Es gab ein technisches Problem beim Zugriff auf das Wissen."}
+        except Exception as e:
+            print(f"❌ Fehler Inbox: {e}")
 
-    # Sauberes Ergebnis für Vapi
     return {"result": antwort}