Upload main.py

main.py

@@ -7,12 +7,10 @@ from datetime import datetime
 
 app = FastAPI()
 
-# --- EINSTELLUNGEN ---
+# --- KONFIGURATION ---
 COLLECTION_KNOWLEDGE = "knowledge_base"
-COLLECTION_INBOX = "inbox"
 COLLECTION_RULES = "availability_rules"
-
-# --- GLOBALE VARIABLE (RAM) ---
+COLLECTION_INBOX = "inbox"
 KNOWLEDGE_CACHE = []
 
 # --- FIREBASE VERBINDUNG ---
@@ -20,197 +18,176 @@ db = None
 try:
     firebase_key_json = os.environ.get("FIREBASE_KEY")
     if firebase_key_json:
-        cred_dict = json.loads(firebase_key_json)
-        cred = credentials.Certificate(cred_dict)
+        cred = credentials.Certificate(json.loads(firebase_key_json))
         if not firebase_admin._apps:
             firebase_admin.initialize_app(cred)
         db = firestore.client()
-        print(f"✅ SYSTEM: Verbunden mit Projekt '{db.project}'")
+        print(f"✅ DB VERBUNDEN: {db.project}")
     else:
-        print("⚠️ FEHLER: Kein FIREBASE_KEY gefunden.")
+        print("⚠️ KEIN FIREBASE KEY GEFUNDEN!")
 except Exception as e:
-    print(f"❌ FEHLER beim Start: {e}")
+    print(f"❌ DB FEHLER: {str(e)}")
 
-# --- LADEN ---
+# --- CACHE LADEN ---
 def reload_knowledge():
     global KNOWLEDGE_CACHE
-    if not db: return 0
-    print("🔄 Lade Wissensdatenbank...")
+    if not db: return
     try:
         docs = db.collection(COLLECTION_KNOWLEDGE).stream()
-        new_cache = []
-        for doc in docs:
-            d = doc.to_dict()
-            d["id"] = doc.id 
-            new_cache.append(d)
-        KNOWLEDGE_CACHE = new_cache
-        print(f"🚀 TURBO-MODE: {len(KNOWLEDGE_CACHE)} Dokumente im RAM!")
-        return len(KNOWLEDGE_CACHE)
+        KNOWLEDGE_CACHE = [d.to_dict() for d in docs]
+        print(f"📚 {len(KNOWLEDGE_CACHE)} Wissens-Einträge geladen.")
     except Exception as e:
-        print(f"❌ Fehler Cache: {e}")
-        return 0
+        print(f"❌ Cache Fehler: {e}")
 
 @app.on_event("startup")
-async def startup_event():
+async def startup():
     reload_knowledge()
 
-# --- HELPER: DEUTSCHE WORTSTÄMME ---
+# --- HELPER: TEXT NORMALISIEREN (Stemmer) ---
 def get_stem(word):
     w = word.lower().strip()
-    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):
-            return w[:-len(end)]
+    # Schneidet einfache deutsche Endungen ab für bessere Treffer
+    for end in ["ern", "en", "er", "es", "st", "te", "e", "s", "t"]:
+        if w.endswith(end) and len(w) > len(end)+2: return w[:-len(end)]
     return w
 
 # ==========================================
-# 1. NEUER ENDPUNKT: VERFÜGBARKEIT (INJECTION)
+# ENDPUNKT 1: VERFÜGBARKEIT (Server URL)
 # ==========================================
+# Vapi ruft das VOR dem Anruf auf, um Kontext zu laden.
 @app.post("/vapi-incoming")
-async def handle_vapi_incoming(request: Request):
-    """
-    Dieser Endpunkt wird von Vapi aufgerufen, BEVOR der Anruf startet (Server URL).
-    Hier prüfen wir das Datum und injizieren die Regel.
-    """
+async def handle_incoming(request: Request):
     try:
         data = await request.json()
-        message_type = data.get("message", {}).get("type")
+        msg_type = data.get("message", {}).get("type")
+        
+        print(f"📞 INCOMING REQUEST: {msg_type}")
 
-        # Nur reagieren, wenn Vapi nach Konfiguration fragt
-        if message_type == "assistant-request":
-            print("📞 Eingehender Anruf (Setup) - Prüfe Verfügbarkeit...")
-            
-            today_str = datetime.now().strftime("%Y-%m-%d")
-            context_text = ""
+        if msg_type == "assistant-request":
+            today = datetime.now().strftime("%Y-%m-%d")
+            print(f"🗓️ Prüfe Regeln für heute: {today}")
             
+            context = ""
             if db:
-                # Hole alle aktiven Regeln
                 rules = db.collection(COLLECTION_RULES).where("active", "==", True).stream()
                 for r in rules:
                     rd = r.to_dict()
-                    # Prüfen: Ist heute im Zeitraum?
-                    if rd.get('start_date') <= today_str <= rd.get('end_date'):
+                    start = rd.get('start_date', '0000-00-00')
+                    end = rd.get('end_date', '9999-99-99')
+                    
+                    if start <= today <= end:
                         print(f"✅ REGEL AKTIV: {rd.get('name')}")
-                        context_text = f"WICHTIGE VORGABE ZUR ERREICHBARKEIT: {rd.get('instruction_text')}"
-                        break # Erste passende Regel gewinnt
-
-            if not context_text:
-                print("ℹ️ Keine Sonderregel für heute.")
+                        context = f"WICHTIGE VERFÜGBARKEITS-INFO: {rd.get('instruction_text')}"
+                        break # Erste Regel gewinnt
+            
+            if not context:
+                print("ℹ️ Keine Sonderregeln für heute.")
 
-            # Antwort an Vapi: "Fülle die Variable {{seasonal_context}}!"
             return {
                 "assistant": {
                     "variableValues": {
-                        "seasonal_context": context_text
+                        "seasonal_context": context
                     }
                 }
             }
-            
-    except Exception as e:
-        print(f"❌ Fehler im Vapi-Incoming Handler: {e}")
-    
-    # Fallback / OK für andere Nachrichten
-    return {"status": "ok"}
+        
+        # Für alle anderen Events (status-update etc.) einfach OK senden
+        return {"status": "ok"}
 
+    except Exception as e:
+        print(f"❌ ERROR INCOMING: {str(e)}")
+        return {"status": "error"}
 
 # ==========================================
-# 2. OPTIMIERTE SUCHE (JETZT AUCH IM TEXT)
+# ENDPUNKT 2: SUCHE / LOOKUP (Tool URL)
 # ==========================================
 @app.post("/search")
-async def search_knowledge(request: Request):
+async def search(request: Request):
     try:
         data = await request.json()
-    except:
-        return {"result": "Fehler: Kein JSON."}
-
-    # Query holen (egal ob direkt oder via Vapi Tool)
-    query_text = ""
-    if "query" in data: query_text = data["query"]
-    elif "message" in data:
-        try:
-            # Vapi schickt Argumente oft als JSON-String
-            args = data["message"]["toolCalls"][0]["function"]["arguments"]
-            if isinstance(args, str):
-                query_text = json.loads(args).get("search_query", "") 
-            else:
-                query_text = args.get("search_query", "")
-        except: pass
-    
-    # Fallback für dein altes Schema
-    if not query_text and "args" in data: query_text = data["args"].get("query", "")
-
-    print(f"🔎 FRAGE: '{query_text}'")
-    if not query_text: return {"result": "Ich habe die Frage akustisch nicht verstanden."}
-
-    best_doc = None
-    best_score = 0
-    
-    query_words_raw = query_text.lower().replace("?", "").replace(".", "").split()
-    query_stems = [get_stem(w) for w in query_words_raw if len(w) > 2]
-    
-    print(f"   ⚙️ Suchstämme: {query_stems}")
-
-    for entry in KNOWLEDGE_CACHE:
-        score = 0
-        t_answer = entry.get("answer", "")
-        t_question = entry.get("question", "")
-        t_keywords = entry.get("keywords", [])
+        # Debugging: Wir drucken das Paket, falls was schief geht
+        # print(f"📦 RAW TOOL DATA: {json.dumps(data)[:200]}...") 
+
+        query = ""
         
-        if not t_answer: continue
+        # --- ROBUSTE EXTRAKTION ---
+        # 1. Fall: Vapi schickt Argumente direkt (selten)
+        if "search_query" in data: 
+            query = data["search_query"]
+        
+        # 2. Fall: Vapi schickt es im "message" -> "toolCalls" Block (Standard)
+        elif "message" in data and "toolCalls" in data["message"]:
+            try:
+                args = data["message"]["toolCalls"][0]["function"]["arguments"]
+                # Vapi sendet Arguments oft als JSON-String, nicht als Objekt!
+                if isinstance(args, str):
+                    args = json.loads(args)
+                
+                query = args.get("search_query") or args.get("query") or args.get("q")
+            except Exception as parsing_err:
+                print(f"⚠️ Argument Parsing Fehler: {parsing_err}")
+
+        print(f"🔎 GEPARSTE FRAGE: '{query}'")
+
+        if not query:
+            return {"result": "Fehler: Ich habe die Frage technisch nicht verstanden (leeres Argument)."}
+
+        # --- SUCHE STARTEN ---
+        best_doc = None
+        best_score = 0
+        
+        # Suchbegriffe vorbereiten
+        q_clean = query.lower().replace("?", "").replace(".", "")
+        q_stems = [get_stem(w) for w in q_clean.split() if len(w)>2]
+
+        print(f"   ⚙️ Such-Stämme: {q_stems}")
 
-        # A) Keyword Treffer (Höchste Prio: 20 Pkt)
-        if isinstance(t_keywords, list):
-            for k in t_keywords:
-                k_stem = get_stem(k)
-                if k_stem in query_stems:
+        for doc in KNOWLEDGE_CACHE:
+            score = 0
+            # Wir bauen einen großen Text-Blob aus Frage, Antwort und Keywords
+            txt_content = (doc.get("question", "") + " " + doc.get("answer", "")).lower()
+            keywords = [k.lower() for k in doc.get("keywords", [])]
+            
+            # A) Keywords prüfen (Hohe Punkte: 20)
+            for k in keywords:
+                if any(get_stem(k) in s for s in q_stems): 
                     score += 20
-        
-        # B) Frage/Titel Treffer (Mittlere Prio: 15 Pkt)
-        if t_question:
-            q_words = t_question.lower().split()
-            for qw in q_words:
-                if len(qw) < 3: continue
-                if get_stem(qw) in query_stems:
-                     score += 15
-
-        # C) NEU: Antwort-Text Treffer (Niedrige Prio: 5 Pkt pro Wort)
-        # Damit findet er "Preis" auch, wenn es nur im Text steht!
-        a_words = t_answer.lower().split()
-        for aw in a_words:
-            if len(aw) < 3: continue
-            if get_stem(aw) in query_stems:
-                score += 5
-
-        # --- SCORING ENDE ---
-
-        if score > best_score:
-            best_score = score
-            best_doc = entry
-            if score > 15:
-                print(f"   Candidate: {score} Pts -> {t_question}")
-
-    # --- ERGEBNIS ---
-    CONFIDENCE_THRESHOLD = 25 # Etwas gesenkt, damit er toleranter ist
-
-    if best_doc and best_score >= CONFIDENCE_THRESHOLD:
-        print(f"🏆 GEWINNER: {best_score} Pkt | {best_doc.get('question')}")
-        return {"result": best_doc['answer']}
-    
-    # Fallback: Low Confidence Loggen
-    else:
-        print(f"⚠️ LOW CONFIDENCE ({best_score}).")
-        if db and best_doc: # Wenn er zumindest irgendwas gefunden hat (z.B. Score 10)
-             try:
-                db.collection(COLLECTION_INBOX).add({
-                    "question": query_text,
-                    "status": "review_needed",
-                    "found_answer": best_doc['answer'],
-                    "score": best_score,
-                    "timestamp": firestore.SERVER_TIMESTAMP
-                })
-             except: pass
-             
-        return {"result": "Dazu habe ich leider keine genauen Informationen in meiner Datenbank."}
+            
+            # B) Textinhalt prüfen (Mittlere Punkte: 5 pro Treffer)
+            for stem in q_stems:
+                if stem in txt_content: 
+                    score += 5
+            
+            # C) Exakte Phrase im Titel (Bonus: 10)
+            if query.lower() in doc.get("question", "").lower():
+                score += 10
+
+            if score > best_score:
+                best_score = score
+                best_doc = doc
+
+        # --- ERGEBNIS ---
+        if best_doc and best_score >= 10:
+            print(f"🏆 TREFFER ({best_score} Pkt): {best_doc.get('question')}")
+            return {"result": best_doc.get("answer")}
+        else:
+            print(f"⚠️ KEIN TREFFER (Max Score: {best_score})")
+            # In Inbox speichern (optional) zur Verbesserung
+            if db and best_score > 0:
+                 try:
+                    db.collection(COLLECTION_INBOX).add({
+                        "question": query,
+                        "status": "review_needed",
+                        "score": best_score,
+                        "timestamp": firestore.SERVER_TIMESTAMP
+                    })
+                 except: pass
+            
+            return {"result": "Dazu habe ich leider keine Informationen in meiner Datenbank."}
+
+    except Exception as e:
+        print(f"❌ SEARCH ERROR: {str(e)}")
+        return {"result": "Systemfehler bei der Suche."}
 
 @app.get("/")
 def home():