Upload main.py

main.py

@@ -10,6 +10,7 @@ app = FastAPI()
 # --- EINSTELLUNGEN ---
 COLLECTION_KNOWLEDGE = "knowledge_base"
 COLLECTION_INBOX = "inbox"
+COLLECTION_RULES = "availability_rules"
 
 # --- GLOBALE VARIABLE (RAM) ---
 KNOWLEDGE_CACHE = []
@@ -53,33 +54,68 @@ def reload_knowledge():
 async def startup_event():
     reload_knowledge()
 
-# --- ENDPUNKTE ---
-@app.get("/")
-def home():
-    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 ---
+# --- 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
+        if w.endswith(end) and len(w) > (len(end) + 2):
             return w[:-len(end)]
     return w
 
-# --- 🧠 DIE NEUE INTELLIGENTE SUCHE ---
+# ==========================================
+# 1. NEUER ENDPUNKT: VERFÜGBARKEIT (INJECTION)
+# ==========================================
+@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.
+    """
+    try:
+        data = await request.json()
+        message_type = data.get("message", {}).get("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 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'):
+                        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.")
+
+            # Antwort an Vapi: "Fülle die Variable {{seasonal_context}}!"
+            return {
+                "assistant": {
+                    "variableValues": {
+                        "seasonal_context": context_text
+                    }
+                }
+            }
+            
+    except Exception as e:
+        print(f"❌ Fehler im Vapi-Incoming Handler: {e}")
+    
+    # Fallback / OK für andere Nachrichten
+    return {"status": "ok"}
+
+
+# ==========================================
+# 2. OPTIMIERTE SUCHE (JETZT AUCH IM TEXT)
+# ==========================================
 @app.post("/search")
 async def search_knowledge(request: Request):
     try:
@@ -87,102 +123,100 @@ async def search_knowledge(request: Request):
     except:
         return {"result": "Fehler: Kein JSON."}
 
-    # Frage extrahieren
+    # 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"]
-            query_text = json.loads(args).get("query", "") if isinstance(args, str) else args.get("query", "")
+            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": "Akustik-Fehler."}
+    if not query_text: return {"result": "Ich habe die Frage akustisch nicht verstanden."}
 
-    # --- SCORING ALGORITHMUS V3 (Mit "Low Confidence" Inbox) ---
     best_doc = None
     best_score = 0
     
-    # 1. Query vorbereiten
     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}")
 
-    # Wir prüfen JEDES Dokument
     for entry in KNOWLEDGE_CACHE:
         score = 0
-        doc_id = entry.get('id', 'unknown')
         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
+        if not t_answer: continue
 
-        # A) Keyword Treffer
+        # 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:
-                    if k_stem in ['udo', 'capaneo']: score += 2 
-                    else: score += 20
+                    score += 20
         
-        # B) Frage/Titel Treffer
+        # B) Frage/Titel Treffer (Mittlere Prio: 15 Pkt)
         if t_question:
-            q_words = t_question.lower().replace("?", "").split()
+            q_words = t_question.lower().split()
             for qw in q_words:
                 if len(qw) < 3: continue
-                qw_stem = get_stem(qw)
-                if qw_stem in query_stems:
+                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
-            # DEBUG: Zeig uns Kandidaten im Log
-            if score > 10:
-                print(f"   Candidate {doc_id}: {score} Pts (Titel: {t_question[:30]}...)")
+            if score > 15:
+                print(f"   Candidate: {score} Pts -> {t_question}")
 
-    # --- ERGEBNIS LOGIK ---
-    
-    # Schwelle für "Ich bin mir sicher"
-    CONFIDENCE_THRESHOLD = 70 
-
-    if best_doc and best_score >= 10:
-        print(f"🏆 GEWINNER: Doc {best_doc['id']} mit {best_score} Punkten.")
-        
-        # DEBUG: Zeig uns die ersten 100 Zeichen der Antwort im Log!
-        preview = best_doc['answer'][:100].replace("\n", " ")
-        print(f"📤 SENDE AN VAPI: '{preview}...'")
-
-        # LOGIK: Wenn der Score "naja" ist (zwischen 10 und 70), ab in die Inbox zur Prüfung!
-        if best_score < CONFIDENCE_THRESHOLD:
-            print(f"⚠️ LOW CONFIDENCE ({best_score}). Schreibe Backup in Inbox...")
-            if db:
-                try:
-                    db.collection(COLLECTION_INBOX).add({
-                        "question": query_text,
-                        "status": "review_needed", # Markierung für dich
-                        "found_answer": best_doc['answer'], # Was hat er gefunden?
-                        "score": best_score,
-                        "timestamp": firestore.SERVER_TIMESTAMP,
-                        "source": "AI Call (Low Confidence)"
-                    })
-                except: pass
+    # --- 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"⚠️ KEIN TREFFER (Best Score: {best_score}).")
-        if db:
-            try:
+        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": "open",
-                    "timestamp": firestore.SERVER_TIMESTAMP,
-                    "source": "AI Call (No Hit)"
+                    "status": "review_needed",
+                    "found_answer": best_doc['answer'],
+                    "score": best_score,
+                    "timestamp": firestore.SERVER_TIMESTAMP
                 })
-            except: pass
-        return {"result": "Dazu habe ich leider keine Informationen in meiner Datenbank."}
+             except: pass
+             
+        return {"result": "Dazu habe ich leider keine genauen Informationen in meiner Datenbank."}
+
+@app.get("/")
+def home():
+    return {"status": "Udo API Online", "docs": len(KNOWLEDGE_CACHE)}
+
+@app.get("/refresh_knowledge")
+def refresh_endpoint():
+    count = reload_knowledge()
+    return {"status": "Cache aktualisiert", "docs_loaded": count}