Upload 5 files

Dockerfile

@@ -0,0 +1,22 @@
+# Use the official Python base image
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Set work directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Expose the port Flask runs on
+EXPOSE 5000
+
+# Run the app
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,102 @@
+from flask import Flask, render_template, request, jsonify
+from googletrans import Translator
+import io
+import asyncio
+from dotenv import load_dotenv
+import os
+import logging
+from chatbot import process_uploaded_file, index_documents, rag_chatbot
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+app = Flask(__name__)
+
+LANGUAGE_MAP = {
+    "English (US)": "en",
+    "Hindi (India)": "hi",
+    "Spanish (Spain)": "es",
+    "French (France)": "fr",
+    "German (Germany)": "de",
+    "Arabic (Saudi Arabia)": "ar"
+}
+
+@app.route('/')
+def index():
+    return render_template("index.html")
+
+@app.route('/api/upload_document', methods=['POST'])
+def upload_document():
+    try:
+        if 'file' not in request.files:
+            return jsonify({"error": "No file uploaded"}), 400
+        
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({"error": "No file selected"}), 400
+        
+        # Process file without saving locally
+        file_stream = io.BytesIO(file.read())
+        documents = process_uploaded_file(file_stream, file.filename)
+        
+        # Index documents in Pinecone
+        vector_store = index_documents(documents)
+        
+        return jsonify({"message": f"Successfully processed and indexed {len(documents)} chunks from {file.filename}"})
+    
+    except Exception as e:
+        logger.error(f"Error in upload_document: {str(e)}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/process_text', methods=['POST'])
+def process_text():
+    # Get JSON payload
+    data = request.get_json()
+    try:
+        original_text = data['text']
+        language_name = data['language']
+    except (KeyError, TypeError):
+        return jsonify({"error": "Missing 'text' or 'language' in JSON payload"}), 400
+
+    # Map language name to language code
+    if language_name not in LANGUAGE_MAP:
+        return jsonify({"error": f"Unsupported language: {language_name}"}), 400
+    original_lang_code = LANGUAGE_MAP[language_name]
+    
+    logger.info(f"Original Text: {original_text}")
+    logger.info(f"Original Language: {language_name} ({original_lang_code})")
+    
+    # Define an async function for translation
+    async def translate_async(text, dest_lang):
+        translator = Translator()
+        translated = translator.translate(text, dest=dest_lang)
+        return translated.text
+    
+    # Translate to English
+    if original_lang_code != "en":
+        translated_text = asyncio.run(translate_async(original_text, dest_lang="en"))
+    else:
+        translated_text = original_text
+    
+    logger.info(f"Translated to English: {translated_text}")
+    
+    # Process with RAG
+    response = rag_chatbot(translated_text)
+    logger.info(f"English Response: {response}")
+    
+    # Translate response back to original language
+    if original_lang_code != "en":
+        final_response = asyncio.run(translate_async(response, dest_lang=original_lang_code))
+    else:
+        final_response = response
+    
+    logger.info(f"Final Response (in original language): {final_response}")
+    
+    # Return the final response
+    return jsonify({"response": final_response, "language": language_name})
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)

chatbot.py

@@ -0,0 +1,195 @@
+import google.generativeai as genai
+from pinecone import Pinecone, ServerlessSpec
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_pinecone import PineconeVectorStore
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from langchain_core.documents import Document
+import io
+import PyPDF2
+import pandas as pd
+import logging
+import asyncio
+from dotenv import load_dotenv
+import os
+import uuid
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Configure Gemini API
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+genai.configure(api_key=GEMINI_API_KEY)
+
+# Initialize Pinecone
+PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
+pc = Pinecone(api_key=PINECONE_API_KEY)
+cloud = os.environ.get('PINECONE_CLOUD', 'aws')
+region = os.environ.get('PINECONE_REGION', 'us-east-1')
+spec = ServerlessSpec(cloud=cloud, region=region)
+
+# Define index name and embedding dimension
+index_name = "rag-donor-index"
+embedding_dimension = 768  # For text-embedding-004
+
+# Check if index exists, create if not
+if index_name not in pc.list_indexes().names():
+    logger.info(f"Creating Pinecone index: {index_name}")
+    pc.create_index(
+        name=index_name,
+        dimension=embedding_dimension,
+        metric="cosine",
+        spec=spec
+    )
+    # Wait for index to be ready
+    while not pc.describe_index(index_name).status['ready']:
+        asyncio.sleep(1)
+
+logger.info(f"Pinecone index {index_name} is ready.")
+
+# Initialize embeddings
+embeddings = GoogleGenerativeAIEmbeddings(model="models/text-embedding-004", google_api_key=GEMINI_API_KEY)
+
+# Function to process uploaded file (PDF, text, CSV, or XLSX) without saving locally
+def process_uploaded_file(file_stream, filename):
+    logger.info(f"Processing uploaded file: {filename}")
+    try:
+        if filename.lower().endswith('.pdf'):
+            logger.info("Processing as PDF file.")
+            pdf_reader = PyPDF2.PdfReader(file_stream)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text() or ""
+            
+            # Split PDF content into chunks
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=500,
+                chunk_overlap=100
+            )
+            chunks = text_splitter.split_text(text)
+            documents = [Document(page_content=chunk, metadata={"source": filename, "chunk_id": str(uuid.uuid4())}) for chunk in chunks]
+            logger.info(f"Extracted {len(documents)} chunks from PDF.")
+            return documents
+        
+        elif filename.lower().endswith(('.txt', '.md')):
+            logger.info("Processing as text file.")
+            content = file_stream.read().decode('utf-8', errors='replace')
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=500,
+                chunk_overlap=100
+            )
+            chunks = text_splitter.split_text(content)
+            documents = [Document(page_content=chunk, metadata={"source": filename, "chunk_id": str(uuid.uuid4())}) for chunk in chunks]
+            logger.info(f"Extracted {len(documents)} chunks from text file.")
+            return documents
+        
+        elif filename.lower().endswith('.csv'):
+            logger.info("Processing as CSV file.")
+            df = pd.read_csv(file_stream)
+            # Convert DataFrame to string representation
+            text = df.to_string()
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=500,
+                chunk_overlap=100
+            )
+            chunks = text_splitter.split_text(text)
+            documents = [Document(page_content=chunk, metadata={"source": filename, "chunk_id": str(uuid.uuid4())}) for chunk in chunks]
+            logger.info(f"Extracted {len(documents)} chunks from CSV.")
+            return documents
+        
+        elif filename.lower().endswith('.xlsx'):
+            logger.info("Processing as XLSX file.")
+            df = pd.read_excel(file_stream, engine='openpyxl')
+            # Convert DataFrame to string representation
+            text = df.to_string()
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=500,
+                chunk_overlap=100
+            )
+            chunks = text_splitter.split_text(text)
+            documents = [Document(page_content=chunk, metadata={"source": filename, "chunk_id": str(uuid.uuid4())}) for chunk in chunks]
+            logger.info(f"Extracted {len(documents)} chunks from XLSX.")
+            return documents
+        
+        else:
+            raise ValueError("Unsupported file type. Only PDF, text, CSV, and XLSX files are supported.")
+    
+    except Exception as e:
+        logger.error(f"Error processing file {filename}: {str(e)}")
+        raise Exception(f"Error processing file: {str(e)}")
+
+# Function to index documents in Pinecone
+def index_documents(documents, namespace="chatbot-knowledge", batch_size=50):
+    logger.info(f"Indexing {len(documents)} documents in Pinecone.")
+    try:
+        vector_store = PineconeVectorStore(
+            index_name=index_name,
+            embedding=embeddings,
+            namespace=namespace
+        )
+        
+        # Batch documents to avoid Pinecone size limits
+        for i in range(0, len(documents), batch_size):
+            batch = documents[i:i + batch_size]
+            batch_size_bytes = sum(len(doc.page_content.encode('utf-8')) for doc in batch)
+            if batch_size_bytes > 4_000_000:
+                logger.warning(f"Batch size {batch_size_bytes} bytes exceeds Pinecone limit. Reducing batch size.")
+                smaller_batch_size = batch_size // 2
+                for j in range(0, len(batch), smaller_batch_size):
+                    smaller_batch = batch[j:j + smaller_batch_size]
+                    vector_store.add_documents(smaller_batch)
+                    logger.info(f"Indexed batch {j // smaller_batch_size + 1} of {len(batch) // smaller_batch_size + 1}")
+            else:
+                vector_store.add_documents(batch)
+                logger.info(f"Indexed batch {i // batch_size + 1} of {len(documents) // batch_size + 1}")
+        
+        logger.info("Document indexing completed.")
+        return vector_store
+    
+    except Exception as e:
+        logger.error(f"Error indexing documents: {e}")
+        raise Exception(f"Error indexing documents: {e}")
+
+# RAG chatbot function
+def rag_chatbot(query, namespace="chatbot-knowledge"):
+    logger.info(f"Processing query: {query}")
+    try:
+        # Initialize vector store
+        vector_store = PineconeVectorStore(
+            index_name=index_name,
+            embedding=embeddings,
+            namespace=namespace
+        )
+        
+        # Retrieve relevant documents
+        relevant_docs_with_scores = vector_store.similarity_search_with_score(query, k=3)
+        for doc, score in relevant_docs_with_scores:
+            logger.info(f"Score: {score:.4f} | Document: {doc.page_content}")
+        
+        # Combine context from retrieved documents
+        context = "\n".join([doc.page_content for doc, score in relevant_docs_with_scores])
+        
+        # Create prompt for Gemini
+        prompt = f"""You are a helpful chatbot that answers questions based on provided context.
+Context:
+{context}
+
+User Query: {query}
+
+Provide a concise and accurate answer based on the context. If the context doesn't contain relevant information, say so and provide a general response if applicable.
+"""
+        
+        # Initialize Gemini model
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        
+        # Generate response
+        response = model.generate_content(prompt)
+        logger.info("Generated response successfully.")
+        return response.text
+    
+    except Exception as e:
+        logger.error(f"Error processing query: {e}")
+        return f"Error processing query: {e}"

requirements.txt

@@ -0,0 +1,18 @@
+flask
+#openai
+python-dotenv
+googletrans
+google-generativeai
+pinecone-client 
+langchain 
+langchain-pinecone 
+langchain-google-genai 
+charset-normalizer
+PyPDF2
+pdfplumber
+langchain-community
+flask-cors
+sentence-transformers
+nltk
+pandas
+openpyxl

templates/index.html

@@ -0,0 +1,252 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>Voice Command</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+    }
+    .chat-container {
+      max-width: 400px;
+      margin: 20px auto;
+      padding: 10px;
+      border: 1px solid #ccc;
+      border-radius: 5px;
+      box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+    }
+    .user-message {
+      background-color: #f0f0f0;
+      border-radius: 5px;
+      padding: 5px 10px;
+      margin: 5px 0;
+      text-align: right;
+    }
+    .bot-message {
+      background-color: #d3e9ff;
+      border-radius: 5px;
+      padding: 5px 10px;
+      margin: 5px 0;
+    }
+    #languageSelector {
+      width: 100%;
+      margin-top: 10px;
+      padding: 5px;
+      border-radius: 5px;
+      border: 1px solid #ccc;
+    }
+    #status {
+      color: grey;
+      font-weight: 600;
+      margin-top: 10px;
+      text-align: center;
+    }
+    #testSpeakerButton {
+      display: block;
+      margin: 10px auto;
+      padding: 10px 20px;
+      border: none;
+      border-radius: 5px;
+      background: #28a745;
+      color: white;
+      cursor: pointer;
+      font-weight: 600;
+    }
+    #uploadButton {
+      display: block;
+      margin: 10px auto;
+      padding: 10px 20px;
+      border: none;
+      border-radius: 5px;
+      background: #2196F3;
+      color: white;
+      cursor: pointer;
+      font-weight: 600;
+    }
+    .speaker {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      width: 100%;
+      margin-top: 10px;
+      padding: 5px;
+      box-shadow: 0 0 13px #0000003d;
+      border-radius: 5px;
+    }
+    #textInput {
+      flex: 1;
+      padding: 8px;
+      border: none;
+      border-radius: 5px;
+      outline: none;
+    }
+    #speech, #sendText {
+      padding: 8px 10px;
+      border: none;
+      border-radius: 5px;
+      margin-left: 5px;
+      cursor: pointer;
+    }
+    #speech {
+      background-color: #007bff;
+      color: white;
+    }
+    #sendText {
+      background-color: #28a745;
+      color: white;
+    }
+  </style>
+</head>
+<body>
+  <button id="testSpeakerButton">Speaker Test</button>
+  <div class="chat-container">
+    <div id="chat-box"></div>
+    <select id="languageSelector">
+      <option value="English (US)">English (US)</option>
+      <option value="Hindi (India)">Hindi (India)</option>
+      <option value="Spanish (Spain)">Spanish (Spain)</option>
+      <option value="French (France)">French (France)</option>
+      <option value="German (Germany)">German (Germany)</option>
+      <option value="Arabic (Saudi Arabia)">Arabic (Saudi Arabia)</option>
+    </select>
+    <input type="file" id="fileUpload" accept=".pdf,.txt,.md,.csv,.xlsx" style="display: none;">
+    <button id="uploadButton" onclick="document.getElementById('fileUpload').click()">Upload Document</button>
+
+    <div class="speaker">
+      <input type="text" id="textInput" placeholder="Type your message...">
+      <button id="speech">Tap to Speak</button>
+      <button id="sendText">Enter</button>
+    </div>
+    <p id="status"></p>
+  </div>
+
+  <script>
+    const statusBar = document.getElementById('status');
+
+    const speechLangMap = {
+      'English (US)': 'en-US',
+      'Hindi (India)': 'hi-IN',
+      'Spanish (Spain)': 'es-ES',
+      'French (France)': 'fr-FR',
+      'German (Germany)': 'de-DE',
+      'Arabic (Saudi Arabia)': 'ar-SA'
+    };
+
+    const synth = window.speechSynthesis;
+    let voices = [];
+
+    function loadVoices() {
+      return new Promise((resolve) => {
+        voices = synth.getVoices();
+        if (voices.length > 0) {
+          resolve(voices);
+        } else {
+          synth.onvoiceschanged = () => {
+            voices = synth.getVoices();
+            resolve(voices);
+          };
+        }
+      });
+    }
+
+    async function speakResponse(text, language) {
+      const langCode = speechLangMap[language] || 'en-US';
+      await loadVoices();
+      const utterance = new SpeechSynthesisUtterance(text);
+      let selectedVoice = voices.find(voice => voice.lang === langCode);
+      if (!selectedVoice) selectedVoice = voices[0];
+      utterance.voice = selectedVoice;
+      synth.speak(utterance);
+    }
+
+    function runSpeechRecog() {
+      const selectedLang = document.getElementById('languageSelector').value;
+      const recognition = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
+      recognition.lang = speechLangMap[selectedLang] || 'en-US';
+      recognition.onstart = () => statusBar.textContent = 'Listening...';
+      recognition.onresult = (event) => {
+        const transcript = event.results[0][0].transcript;
+        sendMessage(transcript, selectedLang);
+      };
+      recognition.onerror = (event) => statusBar.textContent = `Error: ${event.error}`;
+      recognition.onend = () => statusBar.textContent = '';
+      recognition.start();
+    }
+
+    async function sendMessage(message, language) {
+      showUserMessage(message);
+      try {
+        const response = await fetch('/api/process_text', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ text: message, language })
+        });
+        const data = await response.json();
+        showBotMessage(data.response);
+        speakResponse(data.response, language);
+      } catch (error) {
+        console.error('Error:', error);
+        showBotMessage('Error: Unable to process request.');
+      }
+    }
+
+    function showUserMessage(message) {
+      const chatBox = document.getElementById('chat-box');
+      chatBox.innerHTML += `<div class="user-message">${message}</div>`;
+      chatBox.scrollTop = chatBox.scrollHeight;
+    }
+
+    function showBotMessage(message) {
+      const chatBox = document.getElementById('chat-box');
+      chatBox.innerHTML += `<div class="bot-message">${message}</div>`;
+      chatBox.scrollTop = chatBox.scrollHeight;
+    }
+
+    document.getElementById('speech').addEventListener('click', runSpeechRecog);
+
+    document.getElementById('sendText').addEventListener('click', () => {
+      const text = document.getElementById('textInput').value.trim();
+      const language = document.getElementById('languageSelector').value;
+      if (text !== '') {
+        sendMessage(text, language);
+        document.getElementById('textInput').value = '';
+      }
+    });
+
+    document.getElementById('textInput').addEventListener('keydown', (e) => {
+      if (e.key === 'Enter') {
+        e.preventDefault();
+        document.getElementById('sendText').click();
+      }
+    });
+
+    document.getElementById('testSpeakerButton').addEventListener('click', async () => {
+      await loadVoices();
+      speakResponse("Speaker works fine", "English (US)");
+    });
+
+    document.getElementById('fileUpload').addEventListener('change', async (event) => {
+      const file = event.target.files[0];
+      if (!file) return;
+
+      statusBar.textContent = 'Uploading document...';
+      const formData = new FormData();
+      formData.append('file', file);
+
+      try {
+        const response = await fetch('/api/upload_document', {
+          method: 'POST',
+          body: formData
+        });
+        const data = await response.json();
+        statusBar.textContent = data.message || data.error;
+      } catch (err) {
+        statusBar.textContent = 'Error uploading document: ' + err.message;
+        console.error('File upload error:', err);
+      }
+    });
+
+    window.onload = loadVoices;
+  </script>
+</body>
+</html>