Update app.py

app.py

@@ -3,33 +3,12 @@ import os
 import tempfile
 import json
 import requests
-import base64
 from pathlib import Path
 from transformers import pipeline
-from langchain_community.document_loaders import PyPDFLoader, WebBaseLoader
-from langchain_community.vectorstores import FAISS
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain.text_splitter import RecursiveCharacterTextSplitter
 
-# Define paths
+# Create necessary directories
 DOCUMENTS_DIR = Path("documents")
 DOCUMENTS_DIR.mkdir(exist_ok=True)
-VECTOR_DB_PATH = Path("vector_db")
-
-# Initialize models
-model_name = "sentence-transformers/all-MiniLM-L6-v2"
-embeddings = HuggingFaceEmbeddings(model_name=model_name)
-
-# Initialize vector store
-if VECTOR_DB_PATH.exists():
-    try:
-        vector_db = FAISS.load_local(str(VECTOR_DB_PATH), embeddings)
-        print("Loaded existing vector database.")
-    except Exception as e:
-        print(f"Error loading vector database: {e}")
-        vector_db = None
-else:
-    vector_db = None
 
 # Define possible intents
 POSSIBLE_INTENTS = [
@@ -42,7 +21,7 @@ POSSIBLE_INTENTS = [
     "other"
 ]
 
-# Default responses for when RAG fails or no documents are available
+# Default responses
 DEFAULT_RESPONSES = {
     "product_inquiry": "Thank you for your interest in our products. I'll gather the information and have someone contact you with more details.",
     "technical_support": "I understand you're experiencing technical issues. Let me find the right person to help you resolve this.",
@@ -53,6 +32,9 @@ DEFAULT_RESPONSES = {
     "other": "Thank you for your call. I'll make sure your message gets to the right person."
 }
 
+# Simple document storage (in-memory for this example)
+knowledge_base = []
+
 # Create a classifier
 try:
     classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
@@ -81,9 +63,7 @@ def classify_intent(text):
         return "other", 0.0
 
 def load_pdf(file):
-    """Load a PDF document into the vector store"""
-    global vector_db
-    
+    """Load a PDF document into the knowledge base"""
     try:
         # Save the uploaded file temporarily
         temp_dir = tempfile.mkdtemp()
@@ -98,101 +78,40 @@ def load_pdf(file):
             with open(temp_path, "rb") as src:
                 f.write(src.read())
         
-        # Load and process the PDF
-        loader = PyPDFLoader(temp_path)
-        documents = loader.load()
-        
-        # Split the documents
-        text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=1000,
-            chunk_overlap=200
-        )
-        chunks = text_splitter.split_documents(documents)
-        
-        # Update or create vector store
-        if vector_db is None:
-            vector_db = FAISS.from_documents(chunks, embeddings)
-            vector_db.save_local(str(VECTOR_DB_PATH))
-        else:
-            vector_db.add_documents(chunks)
-            vector_db.save_local(str(VECTOR_DB_PATH))
+        # In a real implementation, we would extract text and add to vector store
+        # For this simplified version, we'll just store the file name
+        knowledge_base.append({"type": "pdf", "name": file.name, "path": target_path})
         
-        return f"Successfully added {file.name} to the knowledge base with {len(chunks)} chunks."
+        return f"Successfully added {file.name} to the knowledge base."
     
     except Exception as e:
         return f"Error processing PDF: {str(e)}"
 
 def load_website(url):
-    """Load a website into the vector store"""
-    global vector_db
-    
+    """Load a website into the knowledge base"""
     try:
-        # Load content from website
-        loader = WebBaseLoader(url)
-        documents = loader.load()
+        # In a real implementation, we would fetch and process the website
+        # For this simplified version, we'll just store the URL
+        knowledge_base.append({"type": "website", "url": url})
         
         # Save the URL reference
         with open(os.path.join(DOCUMENTS_DIR, "websites.txt"), "a") as f:
             f.write(f"{url}\n")
         
-        # Split the documents
-        text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=1000,
-            chunk_overlap=200
-        )
-        chunks = text_splitter.split_documents(documents)
-        
-        # Update or create vector store
-        if vector_db is None:
-            vector_db = FAISS.from_documents(chunks, embeddings)
-            vector_db.save_local(str(VECTOR_DB_PATH))
-        else:
-            vector_db.add_documents(chunks)
-            vector_db.save_local(str(VECTOR_DB_PATH))
-        
-        return f"Successfully added {url} to the knowledge base with {len(chunks)} chunks."
+        return f"Successfully added {url} to the knowledge base."
     
     except Exception as e:
         return f"Error processing website: {str(e)}"
 
 def generate_response(query, intent=None):
     """Generate a response based on the query and intent"""
-    global vector_db
-    
     # If no intent provided, use a default
     if not intent or intent not in POSSIBLE_INTENTS:
         intent = "general_information"
     
-    # If no vector database, return default response
-    if vector_db is None:
-        return DEFAULT_RESPONSES.get(intent, DEFAULT_RESPONSES["other"])
-    
-    try:
-        # Query the vector database
-        retrieved_docs = vector_db.similarity_search(query, k=3)
-        
-        if not retrieved_docs:
-            return DEFAULT_RESPONSES.get(intent, DEFAULT_RESPONSES["other"])
-        
-        # Combine retrieved document chunks
-        context = "\n\n".join([doc.page_content for doc in retrieved_docs])
-        
-        # Simple response generation by combining context with templates
-        if len(context) > 10:
-            if intent == "product_inquiry":
-                return f"Based on the information I have: {context[:300]}... Would you like to know more specific details?"
-            elif intent == "technical_support":
-                return f"I found some information that might help with your issue: {context[:300]}... Is there a specific part you'd like me to explain further?"
-            elif intent == "billing_question":
-                return f"Regarding your billing question: {context[:300]}... Would you like me to connect you with our billing department for more details?"
-            else:
-                return f"Here's what I found that might help answer your question: {context[:300]}... Is there anything specific you'd like me to clarify?"
-        else:
-            return DEFAULT_RESPONSES.get(intent, DEFAULT_RESPONSES["other"])
-        
-    except Exception as e:
-        print(f"Error generating response: {e}")
-        return DEFAULT_RESPONSES.get(intent, DEFAULT_RESPONSES["other"])
+    # For this simplified version, we'll just use the default responses
+    # In a real implementation, we would search the knowledge base
+    return DEFAULT_RESPONSES.get(intent, DEFAULT_RESPONSES["other"])
 
 def list_documents():
     """List all documents in the knowledge base"""
@@ -210,77 +129,23 @@ def list_documents():
         "Websites": websites
     }
 
-# Special handler for Twilio
-def handle_twilio_request(data):
-    """Process Twilio request data"""
-    try:
-        # Extract relevant information from Twilio data
-        if "SpeechResult" in data:
-            # This is a speech transcription
-            query = data.get("SpeechResult", "")
-            intent, _ = classify_intent(query)
-            response = generate_response(query, intent)
-            
-            # Create TwiML response
-            twiml = f"""<?xml version="1.0" encoding="UTF-8"?>
-            <Response>
-                <Say>{response}</Say>
-                <Pause length="1"/>
-                <Say>Is there anything else I can help you with today?</Say>
-                <Gather input="speech" action="https://huggingface.co/spaces/iajitpanday/vBot-1.5/api/twilio/followup" method="POST" speechTimeout="auto" speechModel="phone_call"/>
-                <Say>Thank you for calling. Have a great day!</Say>
-            </Response>
-            """
-            return twiml
-            
-        elif "TranscriptionText" in data:
-            # This is a transcription callback
-            query = data.get("TranscriptionText", "")
-            intent, _ = classify_intent(query)
-            response = generate_response(query, intent)
-            
-            # Create SMS response using Twilio API
-            # Note: This requires Twilio credentials which we're avoiding
-            return f"Response would be sent via SMS: {response}"
-            
-        elif "CallStatus" in data and data.get("CallStatus") == "ringing":
-            # Initial call handling
-            twiml = """<?xml version="1.0" encoding="UTF-8"?>
-            <Response>
-                <Say>Hello! Thank you for calling. How can I help you today?</Say>
-                <Gather input="speech" action="https://huggingface.co/spaces/iajitpanday/vBot-1.5/api/twilio/speech" method="POST" speechTimeout="auto" speechModel="phone_call"/>
-                <Say>I didn't hear anything. Please call back when you're ready.</Say>
-            </Response>
-            """
-            return twiml
-            
-        else:
-            # Follow-up or fallback
-            twiml = """<?xml version="1.0" encoding="UTF-8"?>
-            <Response>
-                <Say>Thank you for your call. I've recorded your message and will process it shortly.</Say>
-            </Response>
-            """
-            return twiml
-            
-    except Exception as e:
-        print(f"Error processing Twilio request: {e}")
-        # Return a generic TwiML response
-        twiml = """<?xml version="1.0" encoding="UTF-8"?>
-        <Response>
-            <Say>I'm sorry, I encountered an error processing your request. Please try again later.</Say>
-        </Response>
-        """
-        return twiml
+# Twilio voice handlers
+def twilio_call_handler():
+    """Handle incoming Twilio calls"""
+    twiml = """<?xml version="1.0" encoding="UTF-8"?>
+    <Response>
+        <Say>Hello! Thank you for calling. How can I help you today?</Say>
+        <Gather input="speech" action="https://huggingface.co/spaces/iajitpanday/vBot-1.5/api/twilio/speech" method="POST" speechTimeout="auto" speechModel="phone_call"/>
+        <Say>I didn't hear anything. Please call back when you're ready.</Say>
+    </Response>
+    """
+    return twiml
 
-# API endpoints for Twilio
-def twilio_speech_handler(query):
-    """API endpoint for Twilio speech processing"""
-    # Process the query
-    intent, _ = classify_intent(query)
-    response = generate_response(query, intent)
+def twilio_speech_handler(speech_result=""):
+    """Process speech from Twilio"""
+    intent, _ = classify_intent(speech_result)
+    response = generate_response(speech_result, intent)
     
-    # Create TwiML response
     twiml = f"""<?xml version="1.0" encoding="UTF-8"?>
     <Response>
         <Say>{response}</Say>
@@ -292,9 +157,9 @@ def twilio_speech_handler(query):
     """
     return twiml
 
-def twilio_followup_handler(query):
-    """API endpoint for Twilio follow-up handling"""
-    if any(word in query.lower() for word in ["yes", "yeah", "sure", "please", "correct"]):
+def twilio_followup_handler(speech_result=""):
+    """Handle follow-up responses"""
+    if any(word in speech_result.lower() for word in ["yes", "yeah", "sure", "please", "correct"]):
         twiml = """<?xml version="1.0" encoding="UTF-8"?>
         <Response>
             <Say>Great! How else can I help you today?</Say>
@@ -310,20 +175,9 @@ def twilio_followup_handler(query):
         """
     return twiml
 
-def twilio_call_handler():
-    """API endpoint for initial Twilio call handling"""
-    twiml = """<?xml version="1.0" encoding="UTF-8"?>
-    <Response>
-        <Say>Hello! Thank you for calling. How can I help you today?</Say>
-        <Gather input="speech" action="https://huggingface.co/spaces/iajitpanday/vBot-1.5/api/twilio/speech" method="POST" speechTimeout="auto" speechModel="phone_call"/>
-        <Say>I didn't hear anything. Please call back when you're ready.</Say>
-    </Response>
-    """
-    return twiml
-
 # Create Gradio interface
-with gr.Blocks(title="Call Assistant RAG System") as demo:
-    gr.Markdown("# Call Assistant RAG System")
+with gr.Blocks(title="Call Assistant System") as demo:
+    gr.Markdown("# Call Assistant System")
     gr.Markdown("Add documents and websites to the knowledge base, and test the response generation.")
     
     with gr.Tab("Add Knowledge"):
@@ -382,52 +236,35 @@ with gr.Blocks(title="Call Assistant RAG System") as demo:
         gr.Markdown("""
         ## Twilio Integration Instructions
         
-        This Gradio app provides API endpoints for Twilio integration. Follow these steps to set up:
+        This app provides API endpoints for Twilio voice integration. Follow these steps to set up:
         
         1. Log into your Twilio account
         2. Go to Phone Numbers → Manage → Active numbers
         3. Select your number (+19704064410)
-        4. For "A Call Comes In", select "Webhook" and enter:
+        4. For "A Call Comes In", set "Webhook" to:
            - URL: `https://huggingface.co/spaces/iajitpanday/vBot-1.5/api/twilio/call`
            - Method: HTTP POST
         
-        The system will automatically:
+        The system will:
         - Answer incoming calls
         - Process speech input
         - Generate responses using your knowledge base
         - Handle follow-up questions
         """)
-        
-        gr.Markdown("""
-        ## API Documentation
-        
-        This app exposes several API endpoints for Twilio integration:
-        
-        1. `/api/twilio/call` - Initial call handling
-        2. `/api/twilio/speech` - Processes speech input
-        3. `/api/twilio/followup` - Handles follow-up responses
-        
-        All endpoints return TwiML responses that Twilio can understand.
-        """)
-
-# Define API functions (these are needed for Gradio API endpoints)
-def api_response(query, intent=None):
-    """Standard API function for response generation"""
-    response = generate_response(query, intent)
-    return [response]
 
+# API endpoints for Twilio
 def api_twilio_call():
-    """API function for initial Twilio call handling"""
+    """API endpoint for call handling"""
     return twilio_call_handler()
 
-def api_twilio_speech(speech_result=None):
-    """API function for Twilio speech processing"""
-    return twilio_speech_handler(speech_result)
+def api_twilio_speech(SpeechResult=""):
+    """API endpoint for speech processing"""
+    return twilio_speech_handler(SpeechResult)
 
-def api_twilio_followup(speech_result=None):
-    """API function for Twilio follow-up handling"""
-    return twilio_followup_handler(speech_result)
+def api_twilio_followup(SpeechResult=""):
+    """API endpoint for follow-up handling"""
+    return twilio_followup_handler(SpeechResult)
 
-# Mount these functions as API endpoints
+# Launch the interface
 demo.queue()
 demo.launch()