Update app.py

app.py

@@ -1,41 +1,53 @@
 import streamlit as st
-from langchain_community.vectorstores import FAISS  # Updated import
+import os
+from langchain.vectorstores import FAISS
 from langchain.embeddings import OpenAIEmbeddings
 from langchain.document_loaders import PyPDFLoader
-from langchain.llms import HuggingFacePipeline
 from langchain.chains import RetrievalQA
-import groqapi
+from groq import Groq
 
-# Step 1: Initialize Groq API and Llama Model
-def load_llama_model(api_key, model_name):
-    """Load the Llama model using Groq API."""
-    groqapi.set_api_key(api_key)
-    return HuggingFacePipeline.from_pretrained(model_name)
+# Set the API Key directly (Not recommended for production)
+GROQ_API_KEY = "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"
 
-# Step 2: Load and Process PDF
+# Initialize Groq client
+def initialize_groq_client():
+    """Initialize the Groq client with the API key."""
+    os.environ["GROQ_API_KEY"] = GROQ_API_KEY
+    return Groq(api_key=GROQ_API_KEY)
+
+# Generate response using Groq API
+def generate_response(client, query, model_name="llama3-8b-8192"):
+    """Generate a response using Groq's chat completion."""
+    chat_completion = client.chat.completions.create(
+        messages=[
+            {
+                "role": "user",
+                "content": query,
+            }
+        ],
+        model=model_name,
+    )
+    return chat_completion.choices[0].message.content
+
+# Load and process PDF
 def process_pdf(pdf_path):
     """Load and split the PDF into documents."""
     loader = PyPDFLoader(pdf_path)
     documents = loader.load_and_split()
     return documents
 
-# Step 3: Create Vector Database
+# Create FAISS vector database
 def create_vector_db(documents):
     """Create a FAISS vector database from documents."""
     embeddings = OpenAIEmbeddings()  # Use OpenAI embeddings for vectorization
     vector_db = FAISS.from_documents(documents, embeddings)
     return vector_db
 
-# Step 4: Build RAG Pipeline
-def build_rag_pipeline(vector_db, llama_model):
+# Build RAG pipeline
+def build_rag_pipeline(vector_db, groq_client):
     """Build the Retrieval-Augmented Generation (RAG) pipeline."""
     retriever = vector_db.as_retriever(search_type="similarity", search_kwargs={"k": 5})
-    qa_chain = RetrievalQA.from_chain_type(
-        retriever=retriever,
-        llm=llama_model,
-        return_source_documents=True
-    )
-    return qa_chain
+    return retriever, groq_client
 
 # Streamlit App
 def main():
@@ -50,38 +62,25 @@ def main():
         documents = process_pdf("uploaded_act.pdf")
         st.success("PDF Loaded and Processed Successfully!")
 
-        # Step 2: Input Groq API Key
-        api_key = st.text_input("Enter your Groq API Key", type="password")
-        model_name = "llama-3.1-8b-instant"
-
-        if api_key and st.button("Load Llama Model"):
-            try:
-                # Load Llama Model
-                llama_model = load_llama_model(api_key, model_name)
-                st.success("Llama Model Loaded Successfully!")
-
-                # Build Vector DB and QA Chain
-                vector_db = create_vector_db(documents)
-                qa_chain = build_rag_pipeline(vector_db, llama_model)
-
-                # Step 3: Ask Questions
-                query = st.text_input("Ask a question:")
-                if query:
-                    with st.spinner("Fetching Answer..."):
-                        response = qa_chain({"query": query})
-                        answer = response["result"]
-                        source_docs = response["source_documents"]
+        # Initialize Groq Client
+        try:
+            groq_client = initialize_groq_client()
+            st.success("Groq Client Initialized Successfully!")
 
-                        # Display Answer and Sources
-                        st.write("### Answer:")
-                        st.write(answer)
+            # Build Vector DB and QA Chain
+            vector_db = create_vector_db(documents)
+            retriever, client = build_rag_pipeline(vector_db, groq_client)
 
-                        st.write("### Sources:")
-                        for doc in source_docs:
-                            st.write(f"Source: {doc.metadata.get('source', 'Unknown')}")
+            # Step 3: Ask Questions
+            query = st.text_input("Ask a question:")
+            if query:
+                with st.spinner("Fetching Answer..."):
+                    response = generate_response(client, query)
+                    st.write("### Answer:")
+                    st.write(response)
 
-            except Exception as e:
-                st.error(f"Error loading model or processing query: {e}")
+        except Exception as e:
+            st.error(f"Error loading client or processing query: {e}")
 
 if __name__ == "__main__":
     main()