Upload main.py

main.py

@@ -7,26 +7,25 @@ from datetime import datetime
 
 app = FastAPI()
 
-# --- KONFIGURATION ---
+# --- SETUP ---
 COLLECTION_KNOWLEDGE = "knowledge_base"
 COLLECTION_RULES = "availability_rules"
-COLLECTION_INBOX = "inbox"
 KNOWLEDGE_CACHE = []
 
-# --- FIREBASE VERBINDUNG ---
+# --- DB VERBINDUNG ---
 db = None
 try:
-    firebase_key_json = os.environ.get("FIREBASE_KEY")
-    if firebase_key_json:
-        cred = credentials.Certificate(json.loads(firebase_key_json))
+    key = os.environ.get("FIREBASE_KEY")
+    if key:
+        cred = credentials.Certificate(json.loads(key))
         if not firebase_admin._apps:
             firebase_admin.initialize_app(cred)
         db = firestore.client()
-        print(f"✅ DB VERBUNDEN: {db.project}")
+        print("✅ DB VERBUNDEN")
     else:
-        print("⚠️ KEIN FIREBASE KEY GEFUNDEN!")
+        print("❌ FEHLER: FIREBASE_KEY fehlt!")
 except Exception as e:
-    print(f"❌ DB FEHLER: {str(e)}")
+    print(f"❌ DB CRASH: {e}")
 
 # --- CACHE LADEN ---
 def reload_knowledge():
@@ -35,7 +34,7 @@ def reload_knowledge():
     try:
         docs = db.collection(COLLECTION_KNOWLEDGE).stream()
         KNOWLEDGE_CACHE = [d.to_dict() for d in docs]
-        print(f"📚 {len(KNOWLEDGE_CACHE)} Wissens-Einträge geladen.")
+        print(f"📚 {len(KNOWLEDGE_CACHE)} Einträge geladen.")
     except Exception as e:
         print(f"❌ Cache Fehler: {e}")
 
@@ -43,45 +42,43 @@ def reload_knowledge():
 async def startup():
     reload_knowledge()
 
-# --- HELPER: TEXT NORMALISIEREN (Stemmer) ---
+# --- HELPER ---
 def get_stem(word):
     w = word.lower().strip()
-    # 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
 
 # ==========================================
-# ENDPUNKT 1: VERFÜGBARKEIT (Server URL)
+# 1. START DES ANRUFS (Verfügbarkeit)
 # ==========================================
-# Vapi ruft das VOR dem Anruf auf, um Kontext zu laden.
 @app.post("/vapi-incoming")
-async def handle_incoming(request: Request):
+async def vapi_incoming(request: Request):
     try:
         data = await request.json()
-        msg_type = data.get("message", {}).get("type")
+        msg = data.get("message", {})
+        msg_type = msg.get("type")
         
-        print(f"📞 INCOMING REQUEST: {msg_type}")
+        # LOGGEN WAS PASSIERT
+        print(f"⚡ INCOMING EVENT: {msg_type}")
 
+        # Nur hier reagieren wir mit Regeln!
         if msg_type == "assistant-request":
+            print("📞 ANRUF STARTET - Prüfe Regeln...")
             today = datetime.now().strftime("%Y-%m-%d")
-            print(f"🗓️ Prüfe Regeln für heute: {today}")
-            
             context = ""
+            
             if db:
                 rules = db.collection(COLLECTION_RULES).where("active", "==", True).stream()
                 for r in rules:
                     rd = r.to_dict()
-                    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 = f"WICHTIGE VERFÜGBARKEITS-INFO: {rd.get('instruction_text')}"
-                        break # Erste Regel gewinnt
+                    # Prüfen ob Datum passt
+                    if rd.get('start_date') <= today <= rd.get('end_date'):
+                        print(f"🛑 REGEL AKTIV: {rd.get('name')}")
+                        context = f"ACHTUNG - BESONDERE SITUATION: {rd.get('instruction_text')}"
+                        break
             
-            if not context:
-                print("ℹ️ Keine Sonderregeln für heute.")
+            if not context: print("✅ Keine Regeln für heute.")
 
             return {
                 "assistant": {
@@ -90,110 +87,73 @@ async def handle_incoming(request: Request):
                     }
                 }
             }
-        
-        # 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"}
+        print(f"❌ ERROR START: {e}")
+    
+    return {"status": "ok"}
 
 # ==========================================
-# ENDPUNKT 2: SUCHE / LOOKUP (Tool URL)
+# 2. WÄHREND DES ANRUFS (Suche)
 # ==========================================
 @app.post("/search")
 async def search(request: Request):
     try:
         data = await request.json()
-        # Debugging: Wir drucken das Paket, falls was schief geht
-        # print(f"📦 RAW TOOL DATA: {json.dumps(data)[:200]}...") 
-
         query = ""
         
-        # --- 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)
+        # Parsing
+        if "search_query" in data: query = data["search_query"]
         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
+            args = data["message"]["toolCalls"][0]["function"]["arguments"]
+            if isinstance(args, str): args = json.loads(args)
+            query = args.get("search_query") or args.get("query")
+
+        print(f"🔎 FRAGE: '{query}'")
+        if not query: return {"result": "Akustik-Fehler."}
+
+        # --- INTELLIGENTE FILTERUNG ---
+        # Wörter, die wir IGNORIEREN, damit er nicht bei "Capaneo" jedes Dokument findet
+        STOP_WORDS = ["capaneo", "udo", "schober", "firma", "gmbh", "hallo", "demo"]
+        
+        q_words = [get_stem(w) for w in query.lower().split() if len(w)>2]
+        relevant_words = [w for w in q_words if w not in STOP_WORDS]
+        
+        print(f"   ⚙️ Relevante Suchwörter: {relevant_words}")
         
-        # Suchbegriffe vorbereiten
-        q_clean = query.lower().replace("?", "").replace(".", "")
-        q_stems = [get_stem(w) for w in q_clean.split() if len(w)>2]
+        if not relevant_words:
+            print("⚠️ Keine relevanten Keywords gefunden (nur Stopwörter).")
+            return {"result": "Dazu habe ich keine spezifischen Informationen."}
 
-        print(f"   ⚙️ Such-Stämme: {q_stems}")
+        best_doc = None
+        best_score = 0
 
         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", [])]
+            txt = (doc.get("question", "") + " " + doc.get("answer", "")).lower()
+            kws = [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
+            # A) Keywords (Stark)
+            for k in kws:
+                k_stem = get_stem(k)
+                if k_stem in relevant_words: score += 30
             
-            # 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
+            # B) Text (Mittel)
+            for w in relevant_words:
+                if w in txt: score += 5
 
             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')}")
+        # Schwelle auf 15 setzen
+        if best_doc and best_score >= 15:
+            print(f"🏆 TREFFER ({best_score}): {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."}
+            print(f"⚠️ KEIN GUTER TREFFER (Max: {best_score})")
+            return {"result": "Dazu habe ich leider keine Informationen."}
 
     except Exception as e:
-        print(f"❌ SEARCH ERROR: {str(e)}")
-        return {"result": "Systemfehler bei der Suche."}
-
-@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}
+        print(f"❌ SEARCH ERROR: {e}")
+        return {"result": "Fehler."}