Upload main.py

main.py

@@ -1,162 +1,168 @@
-from fastapi import FastAPI, HTTPException, Request
-from pydantic import BaseModel
-import firebase_admin
-from firebase_admin import credentials, firestore
-import google.generativeai as genai
-import os
-import json
-import datetime
-
-# --- 1. SETUP & AUTHENTIFIZIERUNG ---
-# Wir lesen die Keys aus den Hugging Face Secrets (Environment Variables)
-firebase_key_json = os.getenv("FIREBASE_KEY")
-gemini_key = os.getenv("GEMINI_API_KEY")
-
-if not firebase_key_json or not gemini_key:
-    # Fallback für lokales Testen (falls du es lokal ausführst)
-    # Ersetze das nur lokal, NICHT im Repo hochladen!
-    print("⚠️ Warnung: Keine ENV-Variables gefunden. Prüfe lokale Config.")
-else:
-    # Firebase initialisieren
-    if not firebase_admin._apps:
-        cred = credentials.Certificate(json.loads(firebase_key_json))
-        firebase_admin.initialize_app(cred)
-
-db = firestore.client()
-
-# Gemini initialisieren (nutzt dein funktionierendes Modell)
-genai.configure(api_key=gemini_key)
-model = genai.GenerativeModel('gemini-2.0-flash')
+import uvicorn
+from fastapi import FastAPI, Request
+from sqlalchemy import create_engine, Column, Integer, String, DateTime, Text
+from sqlalchemy.orm import DeclarativeBase, sessionmaker
+from datetime import datetime
 
+# --- 1. DATENBANK SETUP ---
+DATABASE_URL = "sqlite:///./vapi_leads.db"
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+class Base(DeclarativeBase):
+    pass
+
+class CallLog(Base):
+    __tablename__ = "vapi_anrufe"
+    id = Column(Integer, primary_key=True, index=True)
+    call_id = Column(String, unique=True)
+    customer_number = Column(String)
+    status = Column(String)
+    transcript = Column(Text, nullable=True) 
+    timestamp = Column(DateTime, default=datetime.utcnow)
+
+Base.metadata.create_all(bind=engine)
+
+# --- 2. SERVER (Der entscheidende Teil) ---
 app = FastAPI()
 
-# --- DATENMODELLE ---
-class SearchRequest(BaseModel):
-    query: str # Das, was der User gefragt hat
-    
-# ======================================================
-# ENDPOINT 1: Vapi fragt Wissen ab (LIVE im Anruf)
-# ======================================================
-@app.post("/search")
-async def search_knowledge(request: SearchRequest):
-    print(f"🔎 Suche nach: {request.query}")
-    
-    # A. Wissen aus Firebase holen (Nur genehmigtes!)
-    docs = db.collection("knowledge_base").where("status", "==", "approved").stream()
-    
-    # Wir bauen einen Text-Kontext für Gemini
-    knowledge_list = []
-    for doc in docs:
-        d = doc.to_dict()
-        # Wir geben Gemini Frage + Antwort als Kontext
-        knowledge_list.append(f"Frage: {d.get('question')}\nAntwort: {d.get('answer')}")
-    
-    context_text = "\n---\n".join(knowledge_list)
-    
-    if not context_text:
-        return {"result": "Leider habe ich dazu keine Informationen in meiner Datenbank."}
-
-    # B. Gemini entscheidet, welche Antwort passt
-    prompt = f"""
-    Du bist der intelligente Assistent "Alex".
-    Ein User fragt: "{request.query}"
-    
-    Hier ist dein geprüftes Wissen:
-    {context_text}
-    
-    Aufgabe:
-    1. Suche die passendste Antwort im Wissen.
-    2. Formuliere sie freundlich und kurz (gesprochene Sprache).
-    3. Wenn die Antwort NICHT im Wissen steht, antworte exakt: "Dazu habe ich leider keine Informationen vorliegen." (Erfinde nichts!)
-    """
-    
-    try:
-        response = model.generate_content(prompt)
-        answer = response.text.strip()
-        print(f"🤖 Antwort: {answer}")
-        return {"result": answer}
-    except Exception as e:
-        print(f"❌ Fehler: {e}")
-        return {"result": "Es gab einen technischen Fehler bei der Abfrage."}
-
-# ======================================================
-# ENDPOINT 2: Lernen (NACH dem Anruf)
-# ======================================================
-@app.post("/learn")
-async def learn_from_call(request: Request):
-    print("🎓 Analysiere Call für Lerneffekt...")
-    
+# WICHTIG: Hier definieren wir die Tür "/vapi", an die Vapi klopft!
+@app.post("/vapi")
+async def handle_vapi_event(request: Request):
     try:
-        payload = await request.json()
+        data = await request.json()
+        message = data.get("message", {})
+        msg_type = message.get("type")
         
-        # Vapi sendet das Transkript oft tief verschachtelt
-        # Struktur kann variieren, wir suchen das Feld "transcript" oder "messages"
-        # Hier ein generischer Ansatz für Vapi Webhooks:
-        transcript = ""
-        
-        if "message" in payload and "transcript" in payload["message"]:
-             transcript = payload["message"]["transcript"]
-        elif "transcript" in payload:
-             transcript = payload["transcript"]
-        else:
-            # Fallback: Wir nehmen den ganzen Body als Text, falls Vapi anders sendet
-            transcript = str(payload)
-
-        if not transcript or len(transcript) < 50:
-            return {"status": "skipped", "reason": "Transkript zu kurz oder leer"}
-
-        # --- DER GEMINI LERN-CODE ---
-        prompt = f"""
-        Analysiere dieses Telefonat-Transkript.
-        Identifiziere Fragen, die der Bot NICHT oder nur schlecht beantworten konnte.
-        
-        Erstelle für jede Wissenslücke einen neuen Datenbank-Eintrag.
-        
-        Format (JSON Array):
-        [
-          {{
-            "question": "Die Frage des Kunden",
-            "answer": "Die ideale Antwort (formuliere sie professionell)",
-            "keywords": ["keyword1", "keyword2"],
-            "category": "Call-Analyse"
-          }}
-        ]
-        
-        Wenn alles gut lief und keine Lücken da sind, antworte mit einem leeren Array [].
-        
-        Transkript:
-        {transcript[:15000]}
-        """
+        print(f"📩 Event empfangen: {msg_type}")
 
-        response = model.generate_content(prompt)
-        clean_json = response.text.replace("```json", "").replace("```", "").strip()
-        
-        if not clean_json:
-            return {"status": "no_data_generated"}
+        db = SessionLocal()
 
-        new_knowledge = json.loads(clean_json)
-        
-        # Speichern in Firebase (als PENDING zur Prüfung)
-        batch = db.batch()
-        count = 0
-        for entry in new_knowledge:
-            doc_ref = db.collection("knowledge_base").document()
-            doc_data = {
-                "question": entry.get("question"),
-                "answer": entry.get("answer"),
-                "keywords": entry.get("keywords", []),
-                "category": "Auto-Learning",
-                "status": "pending",  # WICHTIG: Muss erst von dir genehmigt werden!
-                "source": "Call Analysis",
-                "created_at": firestore.SERVER_TIMESTAMP
-            }
-            batch.set(doc_ref, doc_data)
-            count += 1
+        # Fall 1: Anruf startet (neuer Name: assistant.started)
+        if msg_type == "assistant.started":
+            call_details = message.get("call", {})
+            customer_number = call_details.get("customer", {}).get("number", "Unbekannt")
+            call_id = call_details.get("id")
+
+            print(f"📞 Neuer Anruf erkannt! ID: {call_id}")
+            
+            # Prüfen ob Anruf schon da ist, sonst anlegen
+            existing = db.query(CallLog).filter(CallLog.call_id == call_id).first()
+            if not existing:
+                new_call = CallLog(call_id=call_id, customer_number=customer_number, status="Live")
+                db.add(new_call)
+                db.commit()
+
+        # Fall 2: Anruf zu Ende (Transkript speichern)
+        elif msg_type == "end-of-call-report":
+            call_id = message.get("call", {}).get("id")
+            transcript = message.get("transcript", "")
+            summary = message.get("summary", "Keine Zusammenfassung")
             
-        batch.commit()
-        print(f"✅ {count} neue Einträge zur Prüfung angelegt.")
-        return {"status": "success", "entries_created": count}
+            print(f"✅ Anruf beendet. Transkript empfangen.")
 
+            existing_call = db.query(CallLog).filter(CallLog.call_id == call_id).first()
+            if existing_call:
+                existing_call.status = "Beendet"
+                existing_call.transcript = transcript
+                db.commit()
+        
+        db.close()
     except Exception as e:
-        print(f"❌ Fehler beim Lernen: {e}")
-        return {"status": "error", "details": str(e)}
+        print(f"⚠️ Fehler beim Verarbeiten: {e}")
+        
+    return {"status": "ok"}
+from fastapi.responses import HTMLResponse
+
+# --- WEBSEITE FÜR TESTER ---
+@app.get("/", response_class=HTMLResponse)
+async def get_web_interface():
+    # HIER DEINE DATEN EINTRAGEN:
+    VAPI_PUBLIC_KEY = "f4f1efff-091c-495f-acab-4669b1cc7cbe" # Beginnt nicht mit 'ey...', ist kürzer
+    ASSISTANT_ID = "4008c58f-556c-44a3-b78d-2b920ea80c66" 
+
+    html_content = f"""
+    <!DOCTYPE html>
+    <html lang="de">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Test: Alex Sales Bot</title>
+        <script src="https://cdn.jsdelivr.net/gh/VapiAI/html-script-tag@latest/dist/assets/index.js"></script>
+        <style>
+            body {{
+                font-family: 'Segoe UI', sans-serif;
+                background-color: #f4f4f9;
+                display: flex;
+                flex-direction: column;
+                align_items: center;
+                justify-content: center;
+                height: 100vh;
+                margin: 0;
+                color: #333;
+            }}
+            h1 {{ margin-bottom: 20px; }}
+            p {{ color: #666; margin-bottom: 40px; }}
+            .info {{ 
+                background: white; padding: 20px; border-radius: 10px; 
+                box-shadow: 0 4px 6px rgba(0,0,0,0.1); 
+                text-align: center;
+            }}
+        </style>
+    </head>
+    <body>
+        <div class="info">
+            <h1>📞 Teste meinen Sales-Bot</h1>
+            <p>Klicke unten rechts auf den Button, um das Gespräch zu starten.</p>
+            <small>⚠️ Mein Laptop muss an sein, damit es funktioniert.</small>
+        </div>
+
+        <script>
+          var vapiInstance = null;
+          const assistant = "{ASSISTANT_ID}"; 
+          const apiKey = "{VAPI_PUBLIC_KEY}"; 
+          
+          // Konfiguration des Buttons
+          const buttonConfig = {{
+              position: "bottom-right",
+              offset: "40px",
+              width: "50px",
+              height: "50px",
+              idle: {{
+                color: "rgb(93, 254, 202)", 
+                type: "pill",
+                title: "Hier klicken zum Sprechen",
+                subtitle: "Kostenloser Testanruf",
+                icon: "https://unpkg.com/lucide-static@0.321.0/icons/phone.svg",
+              }},
+              loading: {{
+                color: "rgb(93, 124, 202)",
+                type: "pill",
+                title: "Verbinde...",
+                subtitle: "Bitte warten",
+                icon: "https://unpkg.com/lucide-static@0.321.0/icons/loader-2.svg",
+              }},
+              active: {{
+                color: "rgb(255, 0, 0)",
+                type: "pill",
+                title: "Anruf läuft...",
+                subtitle: "Klicken zum Auflegen",
+                icon: "https://unpkg.com/lucide-static@0.321.0/icons/phone-off.svg",
+              }}
+          }};
+
+          (function() {{
+            vapiInstance = window.vapiSDK.run({{
+              apiKey: apiKey, 
+              assistant: assistant,
+              config: buttonConfig
+            }});
+          }})();
+        </script>
+    </body>
+    </html>
+    """
+    return html_content
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)