Update app.py

app.py

@@ -1,145 +1,130 @@
 import os
+import time
 import streamlit as st
-import PyPDF2
+from twilio.rest import Client
+from twilio.base.exceptions import TwilioRestException
 from pdfminer.high_level import extract_text
-from transformers import AutoTokenizer
 from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer
 import faiss
 import numpy as np
-from groq import Groq
 import docx
-from fastapi import FastAPI, Request
-import uvicorn
-import threading
-from pydantic import BaseModel
-from twilio.rest import Client
-from fastapi.responses import JSONResponse
-
-# --- Global Config ---
-
-WHATSAPP_FROM = "whatsapp:+14155238886"  # Twilio sandbox number
-WHATSAPP_TO = os.getenv("WHATSAPP_TO") or "whatsapp:+YOUR_NUMBER"
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-TWILIO_SID = os.getenv("TWILIO_SID")
-TWILIO_TOKEN = os.getenv("TWILIO_TOKEN")
-
-# --- Helper Functions ---
+from groq import Groq
+import PyPDF2
 
+# --- Document Loaders ---
 def extract_text_from_pdf(pdf_path):
     try:
         text = ""
         with open(pdf_path, 'rb') as file:
             pdf_reader = PyPDF2.PdfReader(file)
-            for page in pdf_reader.pages:
+            for page_num in range(len(pdf_reader.pages)):
+                page = pdf_reader.pages[page_num]
                 page_text = page.extract_text()
                 if page_text:
                     text += page_text
         return text
-    except Exception as e:
+    except:
         return extract_text(pdf_path)
 
 def extract_text_from_docx(docx_path):
     try:
         doc = docx.Document(docx_path)
         return '\n'.join(para.text for para in doc.paragraphs)
-    except Exception:
+    except:
         return ""
 
-def chunk_text(text, tokenizer, chunk_size=150, overlap=30):
+def chunk_text(text, tokenizer, chunk_size=150, chunk_overlap=30):
     tokens = tokenizer.tokenize(text)
     chunks, start = [], 0
     while start < len(tokens):
         end = min(start + chunk_size, len(tokens))
-        chunk = tokenizer.convert_tokens_to_string(tokens[start:end])
-        chunks.append(chunk)
-        start += chunk_size - overlap
+        chunk_tokens = tokens[start:end]
+        chunks.append(tokenizer.convert_tokens_to_string(chunk_tokens))
+        start += chunk_size - chunk_overlap
     return chunks
 
-def get_embeddings_and_index(chunks, model):
-    embeddings = model.encode(chunks)
-    dim = embeddings[0].shape[0]
-    index = faiss.IndexFlatL2(dim)
-    index.add(np.array(embeddings))
-    return index, embeddings
-
-def get_relevant_chunks(question, index, model, chunks, k=3):
-    query_vector = model.encode([question])[0]
-    _, I = index.search(np.array([query_vector]), k)
-    return [chunks[i] for i in I[0]]
+def retrieve_chunks(question, index, embed_model, text_chunks, k=3):
+    question_embedding = embed_model.encode([question])[0]
+    D, I = index.search(np.array([question_embedding]), k)
+    return [text_chunks[i] for i in I[0]]
 
-def generate_answer(question, context):
+def generate_answer_with_groq(question, context):
     prompt = f"Based on the following context, answer the question: '{question}'\n\nContext:\n{context}"
+    groq_client = Groq(api_key=os.environ["GROQ_API_KEY"])
+    response = groq_client.chat.completions.create(
+        model="llama-3-3b-8192",
+        messages=[
+            {"role": "system", "content": "You are an AI Assistant for Small Businesses."},
+            {"role": "user", "content": prompt},
+        ]
+    )
+    return response.choices[0].message.content
+
+# --- Twilio Chat Handlers ---
+def fetch_latest_incoming_message(account_sid, auth_token, conversation_sid):
+    client = Client(account_sid, auth_token)
+    messages = client.conversations.v1.conversations(conversation_sid).messages.list(limit=10)
+    for msg in reversed(messages):
+        if msg.author.startswith("whatsapp:"):
+            return msg.body, msg.author, msg.index
+    return None, None, None
+
+def send_twilio_message(account_sid, auth_token, conversation_sid, to, body):
     try:
-        client = Groq(api_key=GROQ_API_KEY)
-        response = client.chat.completions.create(
-            model="llama-3.3-70b-versatile",
-            messages=[
-                {"role": "system", "content": "You are an AI assistant for small businesses."},
-                {"role": "user", "content": prompt},
-            ],
-        )
-        return response.choices[0].message.content
+        client = Client(account_sid, auth_token)
+        message = client.conversations.v1.conversations(conversation_sid).messages.create(author=to, body=body)
+        return message.sid
     except Exception as e:
-        return f"Error: {e}"
-
-def send_whatsapp_reply(to, message):
-    client = Client(TWILIO_SID, TWILIO_TOKEN)
-    client.messages.create(body=message, from_=WHATSAPP_FROM, to=to)
-
-# --- Load Documents ---
-
-@st.cache_data
-def load_documents(folder="docs"):
-    all_text = ""
-    for file in os.listdir(folder):
-        path = os.path.join(folder, file)
-        if file.endswith(".pdf"):
-            all_text += extract_text_from_pdf(path) + "\n"
-        elif file.endswith((".docx", ".doc")):
-            all_text += extract_text_from_docx(path) + "\n"
-    return all_text
-
-tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
-embedder = SentenceTransformer("all-mpnet-base-v2")
-docs = load_documents()
-chunks = chunk_text(docs, tokenizer)
-index, embeddings = get_embeddings_and_index(chunks, embedder)
+        return str(e)
 
 # --- Streamlit UI ---
-
-st.set_page_config(page_title="SMEHelpBot 🤖", layout="wide")
-st.title("🤖 SMEHelpBot – Ask your business questions!")
-
-question = st.text_input("💬 Ask something:")
-
-if st.button("Get Answer") and question:
-    with st.spinner("Searching..."):
-        top_chunks = get_relevant_chunks(question, index, embedder, chunks)
-        context = "\n".join(top_chunks)
-        answer = generate_answer(question, context)
-        st.success(answer)
-
-# --- FastAPI WhatsApp Webhook Server ---
-
-app = FastAPI()
-
-class WhatsAppMessage(BaseModel):
-    Body: str
-    From: str
-
-@app.post("/whatsapp-webhook")
-async def whatsapp_webhook(msg: WhatsAppMessage):
-    question = msg.Body.strip()
-    from_number = msg.From
-    relevant_chunks = get_relevant_chunks(question, index, embedder, chunks)
-    context = "\n".join(relevant_chunks)
-    answer = generate_answer(question, context)
-    send_whatsapp_reply(from_number, answer)
-    return JSONResponse(content={"status": "sent"})
-
-# --- Run FastAPI in background ---
-
-def run_fastapi():
-    uvicorn.run(app, host="0.0.0.0", port=7860)
-
-threading.Thread(target=run_fastapi, daemon=True).start()
+st.set_page_config(page_title="SMEHelpBot – WhatsApp Integration", layout="wide")
+st.title("📱 SMEHelpBot + WhatsApp (via Twilio)")
+
+# Secrets and config
+account_sid = st.secrets.get("TWILIO_ACCOUNT_SID") or st.text_input("Twilio Account SID", "")
+auth_token = st.secrets.get("TWILIO_AUTH_TOKEN") or st.text_input("Twilio Auth Token", type="password")
+conversation_sid = st.text_input("Twilio Conversation SID", "")
+GROQ_API_KEY = st.secrets.get("GROQ_API_KEY") or st.text_input("GROQ API Key", type="password")
+
+if all([account_sid, auth_token, conversation_sid, GROQ_API_KEY]):
+    os.environ["GROQ_API_KEY"] = GROQ_API_KEY
+
+    @st.cache_resource
+    def setup_knowledge_base():
+        folder_path = "docs"
+        all_text = ""
+        for file in os.listdir(folder_path):
+            if file.endswith(".pdf"):
+                all_text += extract_text_from_pdf(os.path.join(folder_path, file)) + "\n"
+            elif file.endswith((".docx", ".doc")):
+                all_text += extract_text_from_docx(os.path.join(folder_path, file)) + "\n"
+        tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
+        chunks = chunk_text(all_text, tokenizer)
+        model = SentenceTransformer('all-mpnet-base-v2')
+        embeddings = model.encode(chunks)
+        dim = embeddings[0].shape[0]
+        index = faiss.IndexFlatL2(dim)
+        index.add(np.array(embeddings))
+        return index, model, chunks
+
+    index, embedding_model, text_chunks = setup_knowledge_base()
+
+    st.success("✅ Knowledge base ready. Monitoring WhatsApp...")
+
+    if st.button("🔁 Check for New WhatsApp Query"):
+        with st.spinner("Checking messages..."):
+            question, sender, msg_index = fetch_latest_incoming_message(account_sid, auth_token, conversation_sid)
+            if question:
+                st.info(f"📥 New Question from {sender}:\n\n> {question}")
+                relevant_chunks = retrieve_chunks(question, index, embedding_model, text_chunks)
+                context = "\n\n".join(relevant_chunks)
+                answer = generate_answer_with_groq(question, context)
+                send_twilio_message(account_sid, auth_token, conversation_sid, "system", answer)
+                st.success("📤 Answer sent via WhatsApp!")
+                st.markdown(f"### ✨ Answer:\n\n{answer}")
+            else:
+                st.warning("No new messages from users found.")
+else:
+    st.warning("Please fill all required credentials.")