Update app.py

app.py

@@ -1,113 +1,93 @@
 import os
-import requests
 import streamlit as st
+import PyPDF2
+import requests
 import numpy as np
 import faiss
-from sentence_transformers import SentenceTransformer
 from groq import Groq
 
-# Function to download document from a public Google Drive link
-def download_file_from_public_link(url):
-    file_id = url.split("/d/")[1].split("/")[0]
-    download_url = f"https://drive.google.com/uc?id={file_id}&export=download"
-    response = requests.get(download_url)
-    if response.status_code == 200:
-        return response.text
-    else:
-        raise Exception("Failed to download file from Google Drive.")
+# Initialize Groq client using the secret environment variable
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
 
-# Function to preprocess text
-def preprocess_text(text, chunk_size=512):
-    sentences = text.split(".")
-    chunks = []
-    current_chunk = []
-    current_length = 0
-
-    for sentence in sentences:
-        sentence_length = len(sentence.split())
-        if current_length + sentence_length > chunk_size:
-            chunks.append(" ".join(current_chunk))
-            current_chunk = []
-            current_length = 0
-        current_chunk.append(sentence)
-        current_length += sentence_length
+# Function to download and read PDF content
+def extract_text_from_google_drive():
+    link = "https://drive.google.com/uc?id=1XvqA1OIssRs2gbmOtKFKj-02yQ5X2yg0"
+    response = requests.get(link)
+    with open("document.pdf", "wb") as file:
+        file.write(response.content)
 
-    if current_chunk:
-        chunks.append(" ".join(current_chunk))
+    with open("document.pdf", "rb") as file:
+        reader = PyPDF2.PdfReader(file)
+        text = " ".join([page.extract_text() for page in reader.pages])
+    return text
 
+# Function to chunk text
+def chunk_text(text, max_length=500):
+    sentences = text.split(". ")
+    chunks = []
+    chunk = ""
+    for sentence in sentences:
+        if len(chunk) + len(sentence) <= max_length:
+            chunk += sentence + ". "
+        else:
+            chunks.append(chunk.strip())
+            chunk = sentence + ". "
+    if chunk:
+        chunks.append(chunk.strip())
     return chunks
 
-# Function to create a FAISS index
+# Function to compute embeddings manually (dummy implementation for simplicity)
+def compute_embeddings(chunks):
+    # Create simple embeddings based on the ASCII sum of characters in each chunk
+    embeddings = []
+    for chunk in chunks:
+        vector = np.array([ord(char) for char in chunk[:300]])  # Truncate to 300 characters
+        padded_vector = np.pad(vector, (0, 300 - len(vector)), mode="constant")
+        embeddings.append(padded_vector.astype(np.float32))
+    return np.array(embeddings)
+
+# Function to create FAISS index
 def create_faiss_index(embeddings):
     dimension = embeddings.shape[1]
     index = faiss.IndexFlatL2(dimension)
     index.add(embeddings)
     return index
 
-# Function to query FAISS index
-def query_faiss_index(index, query_embedding, top_k=5):
-    distances, indices = index.search(query_embedding, top_k)
-    return indices[0], distances[0]
+# Function to query Groq API
+def query_groq(question, model_name="llama-3.3-70b-versatile"):
+    chat_completion = client.chat.completions.create(
+        messages=[{"role": "user", "content": question}],
+        model=model_name,
+    )
+    return chat_completion.choices[0].message.content
 
-# Streamlit App
+# Streamlit app
 def main():
-    st.title("RAG-based Application")
-
-    # Load Groq API Key from environment (set in Hugging Face secrets)
-    groq_api_key = os.getenv("GROQ_API_KEY")
-    if not groq_api_key:
-        st.error("Groq API Key is missing. Ensure it is set as a secret in Hugging Face.")
-        return
-
-    # Predefined Google Drive link
-    drive_link = "https://drive.google.com/file/d/1XvqA1OIssRs2gbmOtKFKj-02yQ5X2yg0/view?usp=sharing"
-    
-    if st.button("Load Document"):
-        try:
-            document_text = download_file_from_public_link(drive_link)
-            st.success("Document downloaded successfully!")
-
-            # Process the document
-            chunks = preprocess_text(document_text)
-            st.write(f"Document split into {len(chunks)} chunks.")
-
-            # Embed chunks
-            model = SentenceTransformer("all-MiniLM-L6-v2")
-            embeddings = np.array([model.encode(chunk) for chunk in chunks])
-
-            # Create FAISS index
-            index = create_faiss_index(embeddings)
-            st.success("FAISS index created.")
-
-            # Save index and chunks
-            st.session_state["index"] = index
-            st.session_state["chunks"] = chunks
-
-        except Exception as e:
-            st.error(f"Failed to load document: {str(e)}")
-
-    if "index" in st.session_state and "chunks" in st.session_state:
-        query = st.text_input("Enter your query")
-        if query:
-            model = SentenceTransformer("all-MiniLM-L6-v2")
-            query_embedding = model.encode([query])
-            indices, distances = query_faiss_index(st.session_state["index"], query_embedding)
-
-            # Display results
-            st.write("Relevant Chunks:")
-            for i, idx in enumerate(indices):
-                st.write(f"Chunk {i + 1} (Distance: {distances[i]}):")
-                st.write(st.session_state["chunks"][idx])
-
-            # Query Groq API
-            client = Groq(api_key=groq_api_key)
-            chat_completion = client.chat.completions.create(
-                messages=[{"role": "user", "content": query}],
-                model="llama-3.3-70b-versatile",
-            )
-            st.write("Groq Model Response:")
-            st.write(chat_completion.choices[0].message.content)
-
+    st.title("RAG-based Application with Groq API")
+    st.subheader("Query the document stored on Google Drive")
+
+    st.write("Extracting text from the document...")
+    text = extract_text_from_google_drive()
+    st.write("Document text extracted successfully!")
+
+    st.write("Chunking and embedding text...")
+    chunks = chunk_text(text)
+    embeddings = compute_embeddings(chunks)
+    index = create_faiss_index(embeddings)
+    st.write(f"Created FAISS index with {len(chunks)} chunks.")
+
+    # Query input
+    question = st.text_input("Ask a question based on the document:")
+    if question:
+        st.write("Searching for relevant chunks...")
+        question_embedding = compute_embeddings([question])[0]
+        _, indices = index.search(np.array([question_embedding]), k=1)
+        relevant_chunk = chunks[indices[0][0]]
+
+        st.write("Generating answer using Groq API...")
+        answer = query_groq(relevant_chunk)
+        st.write("### Answer:")
+        st.write(answer)
 
 if __name__ == "__main__":
     main()