Update app.py

app.py

@@ -1,24 +1,15 @@
 import os
 import logging
-import io
-import pinecone
 from dotenv import load_dotenv
 import streamlit as st
-from PyPDF2 import PdfReader, errors
+from PyPDF2 import PdfReader
 from langchain.text_splitter import CharacterTextSplitter
-from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.embeddings import HuggingFaceEmbeddings
 from langchain.vectorstores import Pinecone
 from langchain.memory import ConversationBufferMemory
 from langchain.chains import ConversationalRetrievalChain
-from langchain_groq import ChatGroq
-
-# Check and import Pinecone
-try:
-    import pinecone
-    print(f"Pinecone version: {pinecone.__version__}")
-except ModuleNotFoundError:
-    st.error("Pinecone module not found. Please install it using 'pip install pinecone-client'.")
-    raise
+from groq import Groq
+import pinecone
 
 # Load environment variables
 load_dotenv()
@@ -30,34 +21,25 @@ logging.basicConfig(
 )
 
 # Initialize Pinecone
-pinecone_api_key = os.getenv("PINECONE_API_KE")
-pinecone_env = os.getenv("PINECONE_API_KE")
-
+pinecone_api_key = os.getenv("PINECONE_API_KEY")
+pinecone_env = os.getenv("PINECONE_ENV")
 if pinecone_api_key and pinecone_env:
     pinecone.init(api_key=pinecone_api_key, environment=pinecone_env)
-    logging.info("Pinecone initialized successfully.")
 else:
-    st.error("Pinecone API key or environment missing.")
-    raise ValueError("Missing Pinecone API key or environment variables.")
+    logging.error("Pinecone API key or environment is missing.")
 
-# Function to extract text from PDFs with error handling
+# Function to extract text from PDF files
 def get_pdf_text(pdf_docs):
     text = ""
     for pdf in pdf_docs:
-        try:
-            pdf_file = io.BytesIO(pdf.read())  # Ensure proper file handling
-            pdf_reader = PdfReader(pdf_file)
-            for page in pdf_reader.pages:
-                extracted_text = page.extract_text()
-                if extracted_text:
-                    text += extracted_text + "\n"
-        except errors.PdfReadError:
-            st.error(f"Error reading {pdf.name}: The file may be corrupted or not a valid PDF.")
-        except Exception as e:
-            st.error(f"Unexpected error processing {pdf.name}: {e}")
+        pdf_reader = PdfReader(pdf)
+        for page in pdf_reader.pages:
+            extracted_text = page.extract_text()
+            if extracted_text:
+                text += extracted_text + "\n"
     return text
 
-# Function to split text into chunks
+# Function to split the extracted text into chunks
 def get_text_chunks(text):
     text_splitter = CharacterTextSplitter(
         separator="\n",
@@ -69,39 +51,34 @@ def get_text_chunks(text):
 
 # Function to create a Pinecone vectorstore
 def get_vectorstore(text_chunks):
-    try:
-        embeddings = OpenAIEmbeddings()
-        index_name = os.getenv("PINECONE_INDEX")
-        if not index_name:
-            st.error("Pinecone index name is missing. Please set PINECONE_INDEX in the environment.")
-            return None
-        # Check if the index exists
-        if index_name not in pinecone.list_indexes():
-            st.error(f"Pinecone index '{index_name}' not found. Please create it first.")
-            return None
-        vectorstore = Pinecone.from_texts(texts=text_chunks, embedding=embeddings, index_name=index_name)
-        return vectorstore
-    except Exception as e:
-        st.error(f"Error creating Pinecone vectorstore: {e}")
-        return None
+    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    index_name = os.getenv("PINECONE_INDEX")
+    if not index_name:
+        raise ValueError("Pinecone index name is not set in environment variables.")
+    vectorstore = Pinecone.from_texts(texts=text_chunks, embedding=embeddings, index_name=index_name)
+    return vectorstore
 
 # Function to set up the conversational retrieval chain
 def get_conversation_chain(vectorstore):
     try:
         groq_api_key = os.getenv("GROQ_API_KEY")
-        if not groq_api_key:
-            st.error("Groq API key is missing. Please set GROQ_API_KEY in the environment.")
-            return None
-
-        llm = ChatGroq(
-            model_name="mixtral-8x7b-32768",
-            temperature=0.7,
-            groq_api_key=groq_api_key
-        )
+        client = Groq(api_key=groq_api_key)
+
+        def groq_llm(messages):
+            completion = client.chat.completions.create(
+                model="llama-3.3-70b-versatile",
+                messages=messages,
+                temperature=0.7,
+                max_completion_tokens=1024,
+                top_p=1,
+                stream=False
+            )
+            return completion.choices[0].message.content
+
         memory = ConversationBufferMemory(memory_key='chat_history', return_messages=True)
         
         conversation_chain = ConversationalRetrievalChain.from_llm(
-            llm=llm,
+            llm=groq_llm,
             retriever=vectorstore.as_retriever(),
             memory=memory
         )
@@ -111,59 +88,47 @@ def get_conversation_chain(vectorstore):
     except Exception as e:
         logging.error(f"Error creating conversation chain: {e}")
         st.error("An error occurred while setting up the conversation chain.")
-        return None
 
 # Handle user input
 def handle_userinput(user_question):
     if st.session_state.conversation is not None:
         response = st.session_state.conversation({'question': user_question})
-        if 'chat_history' in response:
-            st.session_state.chat_history = response['chat_history']
-            for i, message in enumerate(st.session_state.chat_history):
-                if hasattr(message, "content"):
-                    role = "User" if i % 2 == 0 else "Bot"
-                    st.write(f"*{role}:* {message.content}")
-        else:
-            st.error("No valid response received.")
+        st.session_state.chat_history = response['chat_history']
+
+        for i, message in enumerate(st.session_state.chat_history):
+            role = "User" if i % 2 == 0 else "Bot"
+            st.write(f"*{role}:* {message.content}")
     else:
         st.warning("Please process the documents first.")
 
 # Main function to run the Streamlit app
 def main():
     load_dotenv()
-    st.set_page_config(page_title="Chat with multiple PDFs", page_icon="📚")
+    st.set_page_config(page_title="Chat with PDFs", page_icon=":books:")
 
     if "conversation" not in st.session_state:
         st.session_state.conversation = None
     if "chat_history" not in st.session_state:
         st.session_state.chat_history = None
 
-    st.header("Chat with multiple PDFs 📚")
+    st.header("Chat with PDFs :books:")
     user_question = st.text_input("Ask a question about your documents:")
     if user_question:
         handle_userinput(user_question)
 
     with st.sidebar:
         st.subheader("Your documents")
-        pdf_docs = st.file_uploader(
-            "Upload your PDFs here and click on 'Process'", accept_multiple_files=True, type=["pdf"]
-        )
+        pdf_docs = st.file_uploader("Upload PDFs and click 'Process'", accept_multiple_files=True, type=["pdf"])
         if st.button("Process"):
-            if pdf_docs:
-                with st.spinner("Processing..."):
-                    raw_text = get_pdf_text(pdf_docs)
-                    if raw_text.strip():
-                        text_chunks = get_text_chunks(raw_text)
-                        vectorstore = get_vectorstore(text_chunks)
-                        if vectorstore:
-                            st.session_state.conversation = get_conversation_chain(vectorstore)
-                            st.success("Processing complete! You can now ask questions.")
-                        else:
-                            st.error("Vectorstore creation failed.")
-                    else:
-                        st.error("No valid text extracted from the PDFs.")
-            else:
-                st.warning("Please upload at least one PDF.")
+            with st.spinner("Processing..."):
+                raw_text = get_pdf_text(pdf_docs)
+                if raw_text.strip():
+                    text_chunks = get_text_chunks(raw_text)
+                    vectorstore = get_vectorstore(text_chunks)
+                    st.session_state.conversation = get_conversation_chain(vectorstore)
+                    st.success("Processing complete! You can now ask questions.")
+                else:
+                    st.error("No valid text extracted from the PDFs.")
 
 if __name__ == '__main__':
-    main()
+    main()